Dit artikel bevat voorbeelden van het converteren van een tijd waarde naar een datetimeoffset waarde in SQL Server met behulp van Transact-SQL.
Wanneer u een tijd . omrekent waarde naar datetimeoffset , wordt de datum ingesteld op ‘1900-01-01’ en wordt de tijd gekopieerd. Er wordt een tijdzone-offset toegevoegd en ingesteld op +00:00.
Voorbeeld 1 – Expliciete conversie met CAST()
Hier is een voorbeeld van een expliciete conversie. In dit geval gebruik ik de CAST() functie direct binnen de SELECT statement om expliciet te converteren van tijd naar datetimeoffset .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Dus een datumgedeelte wordt toegevoegd en ingesteld op '1900-01-01', de tijd wordt gekopieerd en een tijdzone-offset wordt toegevoegd en ingesteld op +00:00.
Voorbeeld 2 – Precisie
In het vorige voorbeeld gebruiken beide gegevenstypen hun standaardprecisie/schaal (7). Dit komt omdat ik geen schaal tussen haakjes heb toegevoegd (de schaal bepaalt de precisie van de fractionele seconden). Door een schaal van 7 te gebruiken, kunnen we zien dat beide gegevenstypen een tijdwaarde kunnen weergeven die nauwkeurig is tot op 7 decimalen.
Met andere woorden, toen ik in eerste instantie de @thetime . instelde variabele, ik heb 7 decimalen in de waarde opgenomen (met name 1234567 ). Zowel de datatypes ‘time’ als ‘datetimeoffset’ konden deze met succes weergeven omdat ze allebei een schaal van 7 gebruikten. Nogmaals, we weten dat ze 7 gebruikten omdat dat de standaardwaarde is.
Voor alle duidelijkheid:schaal is het aantal cijfers rechts van de komma in een getal. Precisie is het totale aantal cijfers in het getal.
Indien nodig kunnen we de precisie van de fractionele seconden verminderen.
Hier zijn enkele voorbeelden die laten zien wat er gebeurt als de datatypes zijn ingesteld om verschillende fractionele seconden precisie te gebruiken:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
In dit geval stel ik expliciet de @thetime . in variabele om een schaal van 7 te gebruiken. Maar wanneer ik dit cast naar datetimeoffset , heb ik de schaal op 0 gezet. Daarom is het resultaat voor de datetimeoffset waarde is minder fractionele seconden precisie. Op mijn systeem worden nog steeds 7 decimalen weergegeven, maar ze zijn allemaal 0.
Hier is het weer, maar deze keer verhoog ik de precisie van de fractionele seconden naar 3 voor de datetimeoffset waarde:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Het gebruikt dus de eerste 3 fractionele seconden (milliseconden).
Als we de precisie van de fractionele seconden echter verhogen tot 4, kijk dan wat er gebeurt:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
In het volgende voorbeeld verhoog ik de waarde van het fractionele deel zodat het het niet-fractionele deel van de datetimeoffset veroorzaakt waarde naar boven af te ronden:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
In dit geval werden de minuten naar boven afgerond en de seconden op nul gezet.
Laten we het omwisselen zodat de datetimeoffset heeft een hogere precisie dan de tijd waarde:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Ik heb de @thetime . gedeclareerd variabele om een schaal van 4 te gebruiken, maar gebruikte vervolgens een schaal van 7 bij het converteren naar de datetimeoffset data type. Het gebruik van een precisie van 7 is niet nodig, omdat het geen hogere precisie kan gebruiken dan wat al was toegewezen.
Er is ook al een afronding met lagere precisie opgetreden tegen de tijd dat deze is geconverteerd naar de (hogere precisie) datetimeoffset data type. Merk op dat de tijd gegevenstype rond de fractionele seconden af van de beginwaarde die ik eraan heb toegewezen. Dit afrondingseffect vloeide ook door naar de datetimeoffset waarde.
Voorbeeld 3 – Expliciete conversie met CONVERT()
Hier is een voorbeeld met de CONVERT() functie in plaats van CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Voorbeeld 4 – Impliciete conversie
Hier is een voorbeeld van hetzelfde doen, maar met een impliciete typeconversie.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
We krijgen dus hetzelfde resultaat, of het nu een expliciete of impliciete conversie is.
Dit is een impliciete conversie omdat we geen conversiefunctie gebruiken om deze expliciet te converteren. We wijzen eenvoudigweg de waarde van een variabele van het ene gegevenstype toe aan een variabele van een ander gegevenstype. In dit geval voert SQL Server achter de schermen een impliciete conversie uit wanneer we proberen de tijd toe te wijzen waarde naar een datetimeoffset variabel.
Voorbeeld 5 – Wijzig de datum
Als u de datum wilt wijzigen (maar dezelfde tijd aanhoudt), kunt u de DATEADD() gebruiken functie.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SET @thedatetimeoffset = DATEADD(year, 285, @thedatetimeoffset); SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Resultaat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
In dit geval tel ik 285 op bij de jaarwaarde, wat het op 2185 brengt.