Тази статия съдържа примери за преобразуване на време стойност към datetimeoffset стойност в SQL Server с помощта на Transact-SQL.
Когато преобразувате време стойност на datetimeoffset , датата е зададена на „1900-01-01“ и часът се копира. Добавя се отместване на часовата зона и се задава на +00:00.
Пример 1 – Изрично преобразуване с помощта на CAST()
Ето пример за изрично преобразуване. В този случай използвам CAST() функция директно в SELECT изявление за изрично преобразуване от време до datetimeoffset .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Така част от датата се добавя и се задава на „1900-01-01“, часът се копира и се добавя изместване на часовата зона и се задава на +00:00.
Пример 2 – Прецизност
В предишния пример и двата типа данни използват своята точност/мащаб по подразбиране (7). Това е така, защото не добавих скала в скоби (скалата определя точността на дробни секунди). Използвайки скала от 7, можем да видим, че и двата типа данни са в състояние да представят времева стойност, която е точна до 7 знака след десетичната запетая.
С други думи, когато първоначално зададох @thetime променлива, включих 7 знака след десетичната запетая в стойността (по-конкретно, 1234567 ). И двата типа данни „time“ и „datetimeoffset“ успяха да ги представят успешно, защото и двата използваха скала от 7. Отново знаем, че са използвали 7, защото това е стойността по подразбиране.
Само за да е ясно, мащаб е броят на цифрите вдясно от десетичната запетая в число. Прецизност е общият брой цифри в числото.
Можем да намалим точността на частични секунди, ако е необходимо.
Ето няколко примера, които демонстрират какво се случва, когато типовете данни са настроени да използват различна прецизност в частни секунди:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
В този случай изрично задавам @thetime променлива, за да използвам мащаб от 7. Но когато прехвърля това към datetimeoffset , зададох мащаба на 0. Следователно, резултатът за datetimeoffset стойността е с по-малка точност до части от секунди. В моята система все още се показват 7 знака след десетичната запетая, но всички са 0.
Ето го отново, но този път увеличавам точността на частични секунди до 3 за datetimeoffset стойност:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Така че използва първите 3 части от секунди (милисекунди).
Ако обаче увеличим точността на частични секунди до 4, вижте какво се случва:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
В следващия пример увеличавам стойността на дробната част, така че да предизвика недробната част на datetimeoffset стойност, която да бъде закръглена:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
В този случай минутите бяха закръглени нагоре, а секундите бяха зададени на нула.
Нека го разменим, така че datetimeoffset има по-висока прецизност отвремета стойност:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Декларирах @thetime променлива, за да се използва мащаб от 4, но след това се използва мащаб от 7, когато се преобразува в datetimeoffset тип данни. Използването на точност от 7 не е необходимо, тъй като не може да използва по-висока точност от вече зададената.
Освен това всяко закръгляване с по-ниска прецизност вече е настъпило до момента, в който е преобразуван в (по-висока прецизност) datetimeoffset тип данни. Забележете, че евремета типът данни закръгли дробните секунди нагоре спрямо първоначалната стойност, която му присвоих. Този ефект на закръгляване също премина през отместването на датата и времето стойност.
Пример 3 – Изрично преобразуване с помощта на CONVERT()
Ето пример за използване на CONVERT() функция вместо CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Пример 4 – Неявно преобразуване
Ето пример за правене на същото нещо, но с помощта на имплицитно преобразуване на тип.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Така че получаваме един и същ резултат, независимо дали е изрично или неявно преобразуване.
Това е имплицитно преобразуване, защото не използваме функция за преобразуване, за да я преобразуваме изрично. Ние просто присвояваме стойността от променлива от един тип данни на променлива от друг тип данни. В този случай SQL Server изпълнява имплицитно преобразуване зад кулисите, когато се опитваме да зададем време стойност към datetimeoffset променлива.
Пример 5 – Промяна на датата
Ако трябва да промените датата (но запазите същото време), можете да използвате DATEADD() функция.
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';
Резултат:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
В този случай добавям 285 към стойността на годината, което я довежда до 2185.
