Konvertieren Sie „time“ in „datetimeoffset“ in SQL Server (T-SQL-Beispiele)

Dieser Artikel enthält Beispiele für die Konvertierung einer Zeit Wert zu einem datetimeoffset -Wert in SQL Server mithilfe von Transact-SQL.

Wenn Sie eine Zeit konvertieren Wert auf datetimeoffset , wird das Datum auf „1900-01-01“ gesetzt und die Uhrzeit kopiert. Ein Zeitzonen-Offset wird hinzugefügt und auf +00:00 gesetzt.

Beispiel 1 – Explizite Konvertierung mit CAST()

Hier ist ein Beispiel für eine explizite Konvertierung. In diesem Fall verwende ich den CAST() Funktion direkt innerhalb des SELECT Anweisung zum expliziten Konvertieren von time zu datetimeoffset .

DECLARE @thetime time;
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Also wird ein Datumsteil hinzugefügt und auf „1900-01-01“ gesetzt, die Zeit wird kopiert und ein Zeitzonenoffset wird hinzugefügt und auf +00:00 gesetzt.

Beispiel 2 – Präzision

Im vorherigen Beispiel verwenden beide Datentypen ihre Standardgenauigkeit/-skalierung (7). Dies liegt daran, dass ich keine Skala in Klammern hinzugefügt habe (die Skala bestimmt die Genauigkeit in Sekundenbruchteilen). Durch die Verwendung einer Skala von 7 können wir sehen, dass beide Datentypen in der Lage sind, einen Zeitwert darzustellen, der auf 7 Dezimalstellen genau ist.

Mit anderen Worten, wenn ich zum ersten Mal @thetime setze Variable habe ich 7 Dezimalstellen in den Wert eingefügt (insbesondere 1234567 ). Sowohl die Datentypen „time“ als auch „datetimeoffset“ konnten diese erfolgreich darstellen, da sie beide eine Skala von 7 verwendeten. Auch hier wissen wir, dass sie 7 verwendeten, da dies der Standardwert ist.

Nur um es klar zu sagen, skaliert ist die Anzahl der Stellen rechts vom Dezimalkomma einer Zahl. Präzision ist die Gesamtzahl der Stellen in der Nummer.

Bei Bedarf können wir die Sekundenbruchteilgenauigkeit reduzieren.

Hier sind einige Beispiele, die zeigen, was passiert, wenn die Datentypen so eingestellt sind, dass sie unterschiedliche Sekundenbruchteile verwenden:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 |
+------------------+------------------------------------+

In diesem Fall setze ich explizit den @thetime Variable, um eine Skala von 7 zu verwenden. Aber wenn ich dies in datetimeoffset umwandle habe ich die Skalierung auf 0 gesetzt. Daher das Ergebnis für den datetimeoffset Wert ist weniger Sekundenbruchteile Genauigkeit. Auf meinem System werden noch 7 Nachkommastellen angezeigt, die aber alle 0 sind.

Hier ist es wieder, aber dieses Mal erhöhe ich die Sekundenbruchteilgenauigkeit für datetimeoffset auf 3 Wert:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 |
+------------------+------------------------------------+

Es verwendet also die ersten 3 Bruchteile von Sekunden (Millisekunden).

Wenn wir jedoch die Sekundenbruchteilgenauigkeit auf 4 erhöhen, sehen Sie, was passiert:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 |
+------------------+------------------------------------+

Im nächsten Beispiel erhöhe ich den Wert des Bruchteils so, dass er den nicht gebrochenen Teil des datetimeoffset verursacht aufzurundender Wert:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.7654321';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 |
+------------------+------------------------------------+

In diesem Fall wurden die Minuten aufgerundet und die Sekunden auf Null gesetzt.

Vertauschen wir es so, dass datetimeoffset hat eine höhere Genauigkeit als die Zeit Wert:

DECLARE @thetime time(4);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 |
+------------------+------------------------------------+

Ich habe den @thetime deklariert -Variable, um eine Skala von 4 zu verwenden, aber dann eine Skala von 7 verwendet, als sie in den datetimeoffset konvertiert wurde Datentyp. Die Verwendung einer Genauigkeit von 7 ist unnötig, da keine höhere Genauigkeit als die bereits zugewiesene verwendet werden kann.

Außerdem ist jede Rundung mit geringerer Genauigkeit bereits zu dem Zeitpunkt erfolgt, zu dem sie in den datetimeoffset (mit höherer Genauigkeit) konvertiert wird Datentyp. Beachten Sie, dass die Zeit data type hat die Sekundenbruchteile vom Anfangswert, den ich ihm zugewiesen habe, aufgerundet. Dieser Rundungseffekt floss auch auf den datetimeoffset durch Wert.

Beispiel 3 – Explizite Konvertierung mit CONVERT()

Hier ist ein Beispiel mit CONVERT() Funktion anstelle von CAST() .

DECLARE @thetime time;
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Beispiel 4 – Implizite Konvertierung

Hier ist ein Beispiel dafür, wie Sie dasselbe tun, aber eine implizite Typkonvertierung verwenden.

DECLARE @thetime time, @thedatetimeoffset datetimeoffset;
SET @thetime = '23:15:59.1234567';
SET @thedatetimeoffset = @thetime;
SELECT 
  @thetime AS 'time',
  @thedatetimeoffset AS 'datetimeoffset';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Wir erhalten also dasselbe Ergebnis, unabhängig davon, ob es sich um eine explizite oder implizite Konvertierung handelt.

Dies ist eine implizite Konvertierung, da wir keine Konvertierungsfunktion verwenden, um sie explizit zu konvertieren. Wir weisen einfach den Wert einer Variablen eines Datentyps einer Variablen eines anderen Datentyps zu. In diesem Fall führt SQL Server im Hintergrund eine implizite Konvertierung durch, wenn wir versuchen, die Zeit zuzuweisen Wert zu einem datetimeoffset Variable.

Beispiel 5 – Datum ändern

Wenn Sie das Datum ändern müssen (aber die gleiche Zeit beibehalten), können Sie DATEADD() verwenden Funktion.

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';

Ergebnis:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

In diesem Fall füge ich 285 zum Jahreswert hinzu, was 2185 ergibt.