Dieser Artikel enthält Beispiele für die Konvertierung einer Zeit Wert zu einem datetime2 Wert in SQL Server.
Wenn Sie eine Zeit konvertieren Wert auf datetime2 , werden dem Wert zusätzliche Informationen hinzugefügt. Das liegt daran, dass datetime2 Datentyp enthält sowohl Datums- als auch Zeitinformationen. Die Zeit Datentyp hingegen enthält nur Zeitinformationen.
Genauer gesagt wird das Datum auf '1900-01-01' gesetzt (es sei denn, es wird zufällig auf '1900-01-02' aufgerundet), die Zeitkomponente wird kopiert und gemäß der Microsoft-Dokumentation der Zeitzonenoffset auf 00:00 eingestellt ist (obwohl die datetime2 Datentyp erkennt keine Zeitzone und behält keinen Zeitzonen-Offset bei).
Wenn die Sekundenbruchteilgenauigkeit von datetime2(n) Wert ist größer als die Zeit(n) Wert, der Wert wird aufgerundet.
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 bis datetime2 .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Ergebnis:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Wenn Sie von Zeit konvertieren bis datetime2 , wird eine Datumskomponente hinzugefügt und auf 1900-01-01 gesetzt .
Es gibt jedoch Szenarien, in denen das Datum auf 1900-01-02 aufgerundet werden könnte . Dies hängt von den Sekundenbruchteilen und der verwendeten Genauigkeit ab. Unten finden Sie ein Beispiel dafür.
Beispiel 2 – Sekundenbruchteilgenauigkeit
Abhängig von der Sekundenbruchteilgenauigkeit, die jedem Datentyp zugewiesen ist, können Sie unterschiedliche Ergebnisse erhalten. Dies hängt vom tatsächlichen Wert des Bruchteils ab.
Im vorherigen Beispiel haben beide Datentypen die gleiche Sekundenbruchteilgenauigkeit verwendet. Dies liegt daran, dass ich keine Skala angegeben habe (um ihre Genauigkeit zu definieren) und daher beide ihre Standard-Skalenwerte verwendet haben (beide sind zufällig 7).
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.
Wie auch immer, in diesem Beispiel habe ich dem Anfangswert nur 6 Dezimalstellen zugewiesen, daher wird am Ende eine Null hinzugefügt.
Folgendes passiert, wenn ich eine höhere Genauigkeit für die Zeit festlege -Wert im Vergleich zu datetime2 Wert:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(4)) AS 'datetime2(4)';
Ergebnis:
+------------------+--------------------------+ | time | datetime2(4) | |------------------+--------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235 | +------------------+--------------------------+
Durch Angabe einer Skala von 4 für datetime2 Wert wird das Ergebnis auf 4 Nachkommastellen gekürzt und in diesem Fall aufgerundet.
Wie zu erwarten ist, kann nicht nur der Bruchteil aufgerundet werden. Hier ist ein Beispiel dafür, wo der Bruchteil dazu führt, dass die Minuten und Sekunden aufgerundet werden:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Ergebnis:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00 | +------------------+---------------------+
Sie können jedoch unterschiedliche Ergebnisse für dieselben Daten erhalten, indem Sie die Genauigkeit ändern. Wenn wir die Genauigkeit erhöhen, auch nur um eine Dezimalstelle, erhalten wir Folgendes:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(1)) AS 'datetime2(1)';
Ergebnis:
+------------------+-----------------------+ | time | datetime2(1) | |------------------+-----------------------| | 23:15:59.7654321 | 1900-01-01 23:15:59.8 | +------------------+-----------------------+
In diesem Fall waren die Minuten und Sekunden also nicht aufgerundet (aber Millisekunden waren ).
Folgendes passiert, wenn ich die Uhrzeit einstelle -Wert, um eine niedrigere Genauigkeitsskala als datetime2 zu verwenden Wert.
DECLARE @thetime time(0); SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Ergebnis:
+----------+-----------------------------+ | time | datetime2 | |----------+-----------------------------| | 23:15:59 | 1900-01-01 23:15:59.0000000 | +----------+-----------------------------+
Und wo wir gerade dabei sind, hier ist ein Beispiel dafür, wo unsere Präzisionsskala dazu führen kann, dass die Sekundenbruchteile dazu führen, dass das Datum auf den nächsten Tag gerundet wird:
DECLARE @thetime time(7); SET @thetime = '23:59:59.9999999'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Ergebnis:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:59:59.9999999 | 1900-01-02 00:00:00 | +------------------+---------------------+
Beispiel 3 – Explizite Konvertierung mit CONVERT()
Dies ist dasselbe wie im ersten Beispiel, außer dass ich diesmal CONVERT() verwende Funktion anstelle von CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CONVERT(datetime2, @thetime) AS 'datetime2';
Ergebnis:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Beispiel 4 – Implizite Konvertierung
Hier ist ein Beispiel dafür, wie Sie dasselbe tun, aber eine implizite Typkonvertierung verwenden.
DECLARE @thetime time, @thedatetime2 datetime2; SET @thetime = '23:15:59.004007'; SET @thedatetime2 = @thetime; SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
Ergebnis:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
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 datetime2 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, @thedatetime2 datetime2; SET @thetime = '23:15:59.004007'; SET @thedatetime2 = @thetime; SET @thedatetime2 = DATEADD(year, 120, @thedatetime2); SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
Ergebnis:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 2020-01-01 23:15:59.0040070 | +------------------+-----------------------------+
In diesem Fall füge ich 120 zum Jahreswert hinzu, was 2020 ergibt.
