Ten artykuł zawiera przykłady konwersji czasu wartość do datetime2 wartość w SQL Server.
Po przekonwertowaniu czasu wartość datetime2 , dodatkowe informacje są dodawane do wartości. Dzieje się tak, ponieważ datetime2 typ danych zawiera zarówno informacje o dacie, jak i godzinie. Czas z drugiej strony typ danych zawiera tylko informacje o czasie.
Mówiąc dokładniej, data jest ustawiona na „1900-01-01” (chyba że zostanie zaokrąglona w górę do „1900-01-02”), składnik czasu jest kopiowany i zgodnie z dokumentacją Microsoft przesunięcie strefy czasowej jest ustawiony na 00:00 (mimo że datetime2 typ danych nie uwzględnia strefy czasowej i nie zachowuje żadnego przesunięcia strefy czasowej).
Kiedy precyzja ułamka sekundy datetime2(n) wartość jest większa niż czas(n) wartość, wartość jest zaokrąglana w górę.
Przykład 1 – Jawna konwersja za pomocą CAST()
Oto przykład jawnej konwersji. W tym przypadku używam CAST() działać bezpośrednio w SELECT oświadczenie o jawnej konwersji z czasu do datetime2 .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Wynik:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Gdy konwertujesz od czasu do datetime2 , zostanie dodany składnik daty i ustawiony na 1900-01-01 .
Istnieją jednak scenariusze, w których datę można zaokrąglić w górę do 1900-01-02 . Będzie to zależeć od ułamków sekund i użytej precyzji. Zobacz poniższy przykład.
Przykład 2 – Dokładność ułamków sekund
Możesz uzyskać różne wyniki w zależności od dokładności ułamków sekund przypisanej do każdego typu danych. Będzie to zależeć od rzeczywistej wartości części ułamkowej.
W poprzednim przykładzie oba typy danych używały tej samej dokładności ułamków sekund. Dzieje się tak dlatego, że nie określiłem skali (aby zdefiniować ich precyzję) i dlatego obaj używali swoich domyślnych wartości skali (obie zdarzają się 7).
Żeby było jasne, skaluj to liczba cyfr po prawej stronie przecinka dziesiętnego w liczbie. Precyzja to całkowita liczba cyfr w liczbie.
W każdym razie w tym przykładzie przypisałem tylko 6 miejsc po przecinku do wartości początkowej, dlatego na końcu dodawane jest zero.
Oto, co się stanie, jeśli określę wyższą precyzję dla czasu wartość w porównaniu z datetime2 wartość:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(4)) AS 'datetime2(4)';
Wynik:
+------------------+--------------------------+ | time | datetime2(4) | |------------------+--------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235 | +------------------+--------------------------+
Określając skalę od 4 do datetime2 wartość, wynik jest redukowany do 4 miejsc po przecinku, aw tym przypadku jest zaokrąglany w górę.
Jak można się spodziewać, nie tylko część ułamkowa może zostać zaokrąglona. Oto przykład, w którym część ułamkowa powoduje zaokrąglenie minut i sekund w górę:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Wynik:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00 | +------------------+---------------------+
Możesz jednak uzyskać różne wyniki dla tych samych danych, zmieniając precyzję. Jeśli zwiększymy precyzję, nawet tylko o jedno miejsce po przecinku, otrzymamy to:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(1)) AS 'datetime2(1)';
Wynik:
+------------------+-----------------------+ | time | datetime2(1) | |------------------+-----------------------| | 23:15:59.7654321 | 1900-01-01 23:15:59.8 | +------------------+-----------------------+
Zatem w tym przypadku minuty i sekundy nie zaokrąglone w górę (ale milisekundy były ).
Oto, co się stanie, jeśli ustawię czas wartość, aby użyć niższej skali dokładności niż datetime2 wartość.
DECLARE @thetime time(0); SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
Wynik:
+----------+-----------------------------+ | time | datetime2 | |----------+-----------------------------| | 23:15:59 | 1900-01-01 23:15:59.0000000 | +----------+-----------------------------+
A skoro już przy tym jesteśmy, oto przykład, w którym nasza precyzyjna skala może skutkować ułamkami sekund powodującymi zaokrąglenie daty do następnego dnia:
DECLARE @thetime time(7); SET @thetime = '23:59:59.9999999'; SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)';
Wynik:
+------------------+---------------------+ | time | datetime2(0) | |------------------+---------------------| | 23:59:59.9999999 | 1900-01-02 00:00:00 | +------------------+---------------------+
Przykład 3 – Jawna konwersja przy użyciu funkcji CONVERT()
To jest to samo, co w pierwszym przykładzie, z tą różnicą, że tym razem używam metody CONVERT() funkcja zamiast CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.004007'; SELECT @thetime AS 'time', CONVERT(datetime2, @thetime) AS 'datetime2';
Wynik:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Przykład 4 – Konwersja niejawna
Oto przykład zrobienia tego samego, ale przy użyciu niejawnej konwersji typu.
DECLARE @thetime time, @thedatetime2 datetime2; SET @thetime = '23:15:59.004007'; SET @thedatetime2 = @thetime; SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
Wynik:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 | +------------------+-----------------------------+
Dzięki temu otrzymujemy ten sam wynik, niezależnie od tego, czy jest to konwersja jawna czy niejawna.
Jest to niejawna konwersja, ponieważ nie używamy funkcji konwersji do jawnej konwersji. Po prostu przypisujemy wartość ze zmiennej jednego typu danych do zmiennej o innym typie danych. W tym przypadku SQL Server wykonuje niejawną konwersję za kulisami, gdy próbujemy przypisać czas wartość do datetime2 zmienna.
Przykład 5 – Zmień datę
Jeśli chcesz zmienić datę (ale zachować tę samą godzinę), możesz użyć DATEADD() funkcjonować.
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';
Wynik:
+------------------+-----------------------------+ | time | datetime2 | |------------------+-----------------------------| | 23:15:59.0040070 | 2020-01-01 23:15:59.0040070 | +------------------+-----------------------------+
W tym przypadku dodaję 120 do wartości roku, co daje rok 2020.
