Dit artikel bevat voorbeelden van het converteren van een tijd waarde toe aan een datetime2 waarde in SQL Server.
Wanneer u een tijd . omrekent waarde tot datetime2 , wordt er extra informatie aan de waarde toegevoegd. Dit komt omdat de datetime2 gegevenstype bevat zowel datum- als tijdinformatie. De tijd gegevenstype daarentegen bevat alleen tijdinformatie.
Meer specifiek, de datum is ingesteld op '1900-01-01' (tenzij het toevallig wordt afgerond op '1900-01-02'), de tijdcomponent wordt gekopieerd en volgens de Microsoft-documentatie wordt de tijdzone-offset is ingesteld op 00:00 (ook al is de datetime2 gegevenstype is niet op de hoogte van de tijdzone en behoudt geen tijdzoneverschuiving).
Wanneer de fractionele seconden precisie van de datetime2(n) waarde is groter dan de time(n) waarde, wordt de waarde naar boven afgerond.
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 datetime2 .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Resultaat:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Wanneer u converteert vanaf tijd naar datetime2 , wordt een datumcomponent toegevoegd en ingesteld op 1900-01-01 .
Er zijn echter scenario's waarin de datum naar boven kan worden afgerond op 1900-01-02 . Dit hangt af van de fractionele seconden en de precisie die u gebruikt. Zie hieronder voor een voorbeeld hiervan.
Voorbeeld 2 – Precisie in fracties van seconden
U kunt verschillende resultaten krijgen, afhankelijk van de fractionele secondennauwkeurigheid die aan elk gegevenstype is toegewezen. Dit hangt af van de werkelijke waarde van het fractionele deel.
In het vorige voorbeeld gebruikten beide gegevenstypen dezelfde precisie in breuken in seconden. Dit komt omdat ik geen schaal heb gespecificeerd (om hun precisie te definiëren) en daarom gebruikten ze allebei hun standaard schaalwaarden (beide zijn toevallig 7).
Voor alle duidelijkheid:schaal is het aantal cijfers rechts van de komma in een getal. Precisie is het totale aantal cijfers in het getal.
Hoe dan ook, in dat voorbeeld heb ik slechts 6 decimalen toegewezen aan de beginwaarde, daarom wordt er een nul aan het einde toegevoegd.
Dit gebeurt er als ik een hogere precisie opgeef voor de tijd waarde vergeleken met de datetime2 waarde:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(4)) AS 'datetime2(4)';
Resultaat:
+------------------+--------------------------+ | time | datetime2(4) | |------------------+--------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235 | +------------------+--------------------------+
Door een schaal van 4 op te geven voor de datetime2 waarde, wordt het resultaat teruggebracht tot 4 cijfers achter de komma en in dit geval naar boven afgerond.
Zoals je zou verwachten, is het niet alleen het fractionele deel dat naar boven kan worden afgerond. Hier is een voorbeeld van waar het fractionele deel ervoor zorgt dat de minuten en seconden naar boven worden afgerond:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Resultaat:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00 | +------------------+---------------------+
U kunt echter verschillende resultaten krijgen voor dezelfde gegevens door de precisie te wijzigen. Als we de precisie verhogen, zelfs met slechts één decimaal, krijgen we dit:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(1)) AS 'datetime2(1)';
Resultaat:
+------------------+-----------------------+ | time | datetime2(1) | |------------------+-----------------------| | 23:15:59.7654321 | 1900-01-01 23:15:59.8 | +------------------+-----------------------+
Dus in dit geval waren de minuten en seconden niet naar boven afgerond (maar milliseconden waren ).
Dit gebeurt er als ik de tijd instel waarde om een lagere precisieschaal te gebruiken dan de datetime2 waarde.
DECLARE @thetime time(0); SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Resultaat:
+----------+-----------------------------+ | time | datetime2 | |----------+-----------------------------| | 23:15:59 | 1900-01-01 23:15:59.0000000 | +----------+-----------------------------+
En nu we toch bezig zijn, hier is een voorbeeld van waar onze precisieschaal kan resulteren in de fractionele seconden waardoor de datum naar de volgende dag wordt afgerond:
DECLARE @thetime time(7); SET @thetime = '23:59:59.9999999'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Resultaat:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:59:59.9999999 | 1900-01-02 00:00:00 | +------------------+---------------------+
Voorbeeld 3 – Expliciete conversie met CONVERT()
Dit is hetzelfde als het eerste voorbeeld, behalve dat ik deze keer de CONVERT() . gebruik functie in plaats van CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CONVERT(datetime2, @thetime) AS 'datetime2';
Resultaat:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Voorbeeld 4 – Impliciete conversie
Hier is een voorbeeld van hetzelfde doen, maar met een impliciete typeconversie.
DECLARE @thetime time, @thedatetime2 datetime2; SET @thetime = '23:15:59.004007'; SET @thedatetime2 = @thetime; SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
Resultaat:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
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 toe aan een datetime2 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, @thedatetime2 datetime2; SET @thetime = '23:15:59.004007'; SET @thedatetime2 = @thetime; SET @thedatetime2 = DATEADD(year, 120, @thedatetime2); SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
Resultaat:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 2020-01-01 23:15:59.0040070 | +------------------+-----------------------------+
In dit geval tel ik 120 op bij de jaarwaarde, wat het op 2020 brengt.