Questo articolo contiene esempi di conversione di un tempo valore a un datetimeoffset valore in SQL Server utilizzando Transact-SQL.
Quando converti un tempo valore a datetimeoffset , la data viene impostata su "1900-01-01" e l'ora viene copiata. Viene aggiunto un fuso orario che viene impostato su +00:00.
Esempio 1 – Conversione esplicita mediante CAST()
Ecco un esempio di conversione esplicita. In questo caso, utilizzo il CAST() funzione direttamente all'interno di SELECT dichiarazione da convertire esplicitamente da tempo a datetimeoffset .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Quindi una parte della data viene aggiunta e impostata su "1900-01-01", l'ora viene copiata e viene aggiunto un offset di fuso orario e impostato su +00:00.
Esempio 2 – Precisione
Nell'esempio precedente, entrambi i tipi di dati utilizzano la loro precisione/scala predefinita (7). Questo perché non ho aggiunto una scala tra parentesi (la scala determina la precisione dei secondi frazionari). Utilizzando una scala di 7, possiamo vedere che entrambi i tipi di dati sono in grado di rappresentare un valore temporale preciso a 7 cifre decimali.
In altre parole, quando inizialmente ho impostato il @thetime variabile, ho incluso 7 cifre decimali nel valore (in particolare, 1234567 ). Entrambi i tipi di dati "time" e "datetimeoffset" sono stati in grado di rappresentarli con successo perché entrambi utilizzavano una scala di 7. Anche in questo caso, sappiamo che hanno utilizzato 7 perché questo è il valore predefinito.
Giusto per essere chiari, scala è il numero di cifre a destra della virgola decimale in un numero. Precisione è il numero totale di cifre nel numero.
Possiamo ridurre la precisione frazionaria dei secondi, se necessario.
Di seguito sono riportati alcuni esempi che dimostrano cosa accade quando i tipi di dati sono impostati per utilizzare una diversa precisione frazionaria di secondi:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
In questo caso ho impostato esplicitamente il @thetime variabile per utilizzare una scala di 7. Ma quando eseguo il cast su datetimeoffset , ho impostato la scala su 0. Pertanto, il risultato per datetimeoffset il valore è una precisione di secondi frazionari inferiore. Sul mio sistema sono ancora visualizzate 7 cifre decimali, ma sono tutte 0.
Eccolo di nuovo, ma questa volta aumento la precisione dei secondi frazionari a 3 per il datetimeoffset valore:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Quindi utilizza i primi 3 secondi frazionari (millisecondi).
Tuttavia, se aumentiamo la precisione dei secondi frazionari a 4, guarda cosa succede:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Nell'esempio successivo aumento il valore della parte frazionaria in modo che provochi la parte non frazionaria del datetimeoffset valore da arrotondare per eccesso:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
In questo caso, i minuti sono stati arrotondati per eccesso ei secondi a zero.
Scambialo in modo che il datetimeoffset ha una precisione superiore al tempo valore:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Ho dichiarato il @thetime variabile per utilizzare una scala di 4, ma poi ha utilizzato una scala di 7 durante la conversione in datetimeoffset tipo di dati. L'utilizzo di una precisione di 7 non è necessario, in quanto non è possibile utilizzare una precisione superiore a quella già assegnata.
Inoltre, qualsiasi arrotondamento di precisione inferiore si è già verificato nel momento in cui è stato convertito in datetimeoffset (precisione superiore) tipo di dati. Nota che il tempo tipo di dati arrotondato i secondi frazionari per eccesso dal valore iniziale che gli ho assegnato. Questo effetto di arrotondamento è passato anche al datetimeoffset valore.
Esempio 3 – Conversione esplicita mediante CONVERT()
Ecco un esempio usando CONVERT() funzione invece di CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Esempio 4 – Conversione implicita
Ecco un esempio di come fare la stessa cosa, ma usando una conversione di tipo implicita.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Quindi otteniamo lo stesso risultato, indipendentemente dal fatto che si tratti di una conversione esplicita o implicita.
Questa è una conversione implicita perché non stiamo usando una funzione di conversione per convertirla in modo esplicito. Stiamo semplicemente assegnando il valore da una variabile di un tipo di dati a una variabile di un altro tipo di dati. In questo caso, SQL Server esegue una conversione implicita dietro le quinte quando proviamo ad assegnare il tempo valore a un datetimeoffset variabile.
Esempio 5:modifica della data
Se devi cambiare la data (ma mantenere la stessa ora), puoi usare il DATEADD() funzione.
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';
Risultato:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
In questo caso aggiungo 285 al valore dell'anno, che lo porta a 2185.
