Denne artikel indeholder eksempler på konvertering af en tid værdi til en datotidsforskydning værdi i SQL Server ved hjælp af Transact-SQL.
Når du konverterer en tid værdi til datetimeoffset , datoen er sat til '1900-01-01' og klokkeslættet kopieres. En tidszoneforskydning tilføjes og indstilles til +00:00.
Eksempel 1 – Eksplicit konvertering ved hjælp af CAST()
Her er et eksempel på en eksplicit konvertering. I dette tilfælde bruger jeg CAST() funktion direkte i SELECT sætning for eksplicit at konvertere fra tid til datotidsforskydning .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Så en datodel tilføjes og indstilles til '1900-01-01', klokkeslættet kopieres, og en tidszoneforskydning tilføjes og indstilles til +00:00.
Eksempel 2 – Præcision
I det foregående eksempel bruger begge datatyper deres standardpræcision/skala (7). Dette skyldes, at jeg ikke tilføjede en skala i parentes (skalaen bestemmer brøksekunders præcision). Ved at bruge en skala fra 7 kan vi se, at begge datatyper er i stand til at repræsentere en tidsværdi, der er præcis med 7 decimaler.
Med andre ord, da jeg oprindeligt indstillede @thetime variabel, inkluderede jeg 7 decimaler i værdien (specifikt 1234567 ). Både datatyperne "tid" og "datotidsforskydning" var med succes i stand til at repræsentere disse, fordi de begge brugte en skala på 7. Igen ved vi, at de brugte 7, fordi det er standardværdien.
Bare for at være klar, skaler er antallet af cifre til højre for decimaltegnet i et tal. Nøjagtighed er det samlede antal cifre i tallet.
Vi kan reducere brøksekunders præcision, hvis det kræves.
Her er nogle eksempler, der viser, hvad der sker, når datatyperne er indstillet til at bruge forskellige brøksekunders præcision:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
I dette tilfælde har jeg udtrykkeligt indstillet @thetime variabel for at bruge en skala fra 7. Men når jeg caster dette til datetimeoffset , sætter jeg skalaen til 0. Derfor er resultatet for datetime offset værdien er mindre brøksekunders præcision. På mit system vises der stadig 7 decimaler, men de er alle 0.
Her er det igen, men denne gang øger jeg brøksekunders præcision til 3 for datetime offset værdi:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Så den bruger de første 3 brøksekunder (millisekunder).
Men hvis vi øger brøksekunders præcision til 4, så se hvad der sker:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
I det næste eksempel øger jeg brøkdelens værdi, så den forårsager den ikke-brøkdel af datotidsforskydningen værdi, der skal rundes op:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
I dette tilfælde blev minutterne rundet op og sekunderne sat til nul.
Lad os bytte det rundt, så datotidsforskydningen har en højere præcision end tiden værdi:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Jeg erklærede @thetime variabel for at bruge en skala på 4, men brugte derefter en skala på 7, når den konverteredes til datetime offset datatype. Det er unødvendigt at bruge en præcision på 7, da det ikke kan bruge en højere præcision end det, der allerede var tildelt.
Desuden er enhver afrunding med lavere præcision allerede fundet sted på det tidspunkt, hvor den er konverteret til (højere præcision) dato-tidsforskydning datatype. Bemærk, at tiden datatypen rundede brøksekunderne op fra den oprindelige værdi, som jeg tildelte den. Denne afrundingseffekt strømmede også igennem til datetime offset værdi.
Eksempel 3 – Eksplicit konvertering ved hjælp af CONVERT()
Her er et eksempel, der bruger CONVERT() funktion i stedet for CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Eksempel 4 – Implicit konvertering
Her er et eksempel på at gøre det samme, men ved at bruge en implicit typekonvertering.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Så vi får det samme resultat, uanset om det er en eksplicit eller implicit konvertering.
Dette er en implicit konvertering, fordi vi ikke bruger en konverteringsfunktion til eksplicit at konvertere den. Vi tildeler simpelthen værdien fra en variabel af én datatype til en variabel af en anden datatype. I dette tilfælde udfører SQL Server en implicit konvertering bag kulisserne, når vi forsøger at tildele tidspunktet værdi til en datotidsforskydning variabel.
Eksempel 5 – Skift datoen
Hvis du har brug for at ændre datoen (men beholde den samme tid), kan du bruge DATEADD() fungere.
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';
Resultat:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
I dette tilfælde tilføjer jeg 285 til årsværdien, hvilket bringer den til 2185.