Ten artykuł zawiera przykłady konwersji czasu wartość na przesunięcie daty i godziny wartość w SQL Server przy użyciu języka Transact-SQL.
Po przekonwertowaniu czasu wartość przesunięcie daty i godziny , data jest ustawiona na „1900-01-01”, a godzina jest kopiowana. Przesunięcie strefy czasowej jest dodawane i ustawiane na +00:00.
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 na przesunięcie daty i godziny .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Tak więc dodawana jest część daty i ustawiana na „1900-01-01”, czas jest kopiowany, a przesunięcie strefy czasowej jest dodawane i ustawiane na +00:00.
Przykład 2 – Precyzja
W poprzednim przykładzie oba typy danych używają domyślnej precyzji/skali (7). Dzieje się tak dlatego, że nie dodałem skali w nawiasach (skala określa dokładność ułamków sekund). Używając skali 7, możemy zobaczyć, że oba typy danych są w stanie reprezentować wartość czasu z dokładnością do 7 miejsc po przecinku.
Innymi słowy, kiedy początkowo ustawiłem @thetime zmienna, umieściłem w wartości 7 miejsc po przecinku (dokładnie 1234567 ). Zarówno typy danych „czas”, jak i „datetimeoffset” z powodzeniem reprezentowały je, ponieważ oba używały skali 7. Ponownie, wiemy, że użyli 7, ponieważ jest to wartość domyślna.
Ż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 razie potrzeby możemy zmniejszyć dokładność ułamków sekund.
Oto kilka przykładów, które pokazują, co się dzieje, gdy typy danych są ustawione na różne dokładności ułamków sekund:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
W tym przypadku jawnie ustawiłem @thetime zmienna, aby użyć skali 7. Ale kiedy rzucę to na przesunięcie daty i godziny , ustawiłem skalę na 0. Dlatego wynik dla przesunięcie daty i godziny wartość jest mniejsza precyzja ułamków sekund. W moim systemie nadal wyświetlanych jest 7 miejsc po przecinku, ale wszystkie są równe 0.
Znowu, ale tym razem zwiększam precyzję ułamków sekund do 3 dla przesunięcie daty i godziny wartość:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Wykorzystuje więc pierwsze 3 sekundy ułamkowe (milisekundy).
Jeśli jednak zwiększymy dokładność ułamków sekund do 4, zobacz, co się stanie:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
W następnym przykładzie zwiększam wartość części ułamkowej, aby powodowała nieułamkowa część przesunięcie daty i godziny wartość do zaokrąglenia w górę:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
W tym przypadku minuty zostały zaokrąglone w górę, a sekundy ustawione na zero.
Zamieńmy to tak, aby przesunięcie daty i godziny ma wyższą precyzję niż czas wartość:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Zadeklarowałem @thetime zmienna, aby użyć skali 4, ale następnie użyła skali 7 podczas konwertowania jej na przesunięcie daty i godziny typ danych. Użycie precyzji 7 jest niepotrzebne, ponieważ nie można użyć wyższej precyzji niż ta, która została już przypisana.
Ponadto każde zaokrąglanie o niższej precyzji miało już miejsce przed przekonwertowaniem na (o wyższej precyzji) przesunięcie daty i godziny typ danych. Zauważ, że czas typ danych zaokrąglił ułamki sekund w górę od wartości początkowej, którą mu przypisałem. Ten efekt zaokrąglenia przeniósł się również na przesunięcie daty i godziny wartość.
Przykład 3 – Jawna konwersja przy użyciu funkcji CONVERT()
Oto przykład użycia CONVERT() funkcja zamiast CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Przykład 4 – Konwersja niejawna
Oto przykład zrobienia tego samego, ale przy użyciu niejawnej konwersji typu.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
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ść na przesunięcie daty i godziny 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, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SET @thedatetimeoffset = DATEADD(year, 285, @thedatetimeoffset); SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Wynik:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
W tym przypadku dodaję 285 do wartości roku, co daje 2185.
