Tento článek obsahuje příklady převodu času hodnotu na datetimeoffset hodnotu v SQL Server pomocí Transact-SQL.
Když převedete čas hodnotu na datetimeoffset , datum se nastaví na ‚1900-01-01‘ a čas se zkopíruje. Je přidán posun časového pásma a nastaven na +00:00.
Příklad 1 – Explicitní konverze pomocí CAST()
Zde je příklad explicitní konverze. V tomto případě používám CAST() funkce přímo v SELECT příkaz explicitně převést z času na datetimeoffset .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Přidá se tedy část data a nastaví se na ‚1900-01-01‘, zkopíruje se čas a přidá se posun časového pásma a nastaví se na +00:00.
Příklad 2 – Přesnost
V předchozím příkladu oba datové typy používají svou výchozí přesnost/měřítko (7). Je to proto, že jsem v závorkách nepřidal měřítko (měřítko určuje přesnost ve zlomcích sekund). Při použití škály 7 vidíme, že oba datové typy jsou schopny reprezentovat časovou hodnotu s přesností na 7 desetinných míst.
Jinými slovy, když jsem původně nastavil @thetime proměnné, zahrnul jsem do hodnoty 7 desetinných míst (konkrétně 1234567 ). Datové typy „time“ a „datetimeoffset“ je úspěšně reprezentovaly, protože oba používaly stupnici 7. Opět víme, že použili 7, protože to je výchozí hodnota.
Aby bylo jasno, škálování je počet číslic napravo od desetinné čárky v čísle. Přesnost je celkový počet číslic v čísle.
V případě potřeby můžeme snížit přesnost na zlomky sekund.
Zde je několik příkladů, které demonstrují, co se stane, když jsou datové typy nastaveny na použití různé přesnosti ve zlomcích sekund:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 | +------------------+------------------------------------+
V tomto případě jsem explicitně nastavil @thetime proměnnou pro použití stupnice 7. Ale když to přetypuji na datetimeoffset , nastavil jsem měřítko na 0. Proto výsledek pro datetimeoffset hodnota je menší s přesností na zlomky sekund. V mém systému se stále zobrazuje 7 desetinných míst, ale všechna jsou 0.
Tady je to znovu, ale tentokrát zvyšuji přesnost ve zlomcích sekund na 3 pro datetimeoffset hodnota:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 | +------------------+------------------------------------+
Takže používá první 3 zlomkové sekundy (milisekundy).
Pokud však zvýšíme přesnost ve zlomcích sekund na 4, podívejte se, co se stane:
DECLARE @thetime time(7); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
V dalším příkladu zvýším hodnotu zlomkové části tak, aby způsobila nezlomkovou část datetimeoffset hodnota, která se má zaokrouhlit nahoru:
DECLARE @thetime time(7); SET @thetime = '23:15:59.7654321'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 | +------------------+------------------------------------+
V tomto případě byly minuty zaokrouhleny nahoru a sekundy nastaveny na nulu.
Prohoďme to tak, že datetimeoffset má vyšší přesnost než čas hodnota:
DECLARE @thetime time(4); SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 | +------------------+------------------------------------+
Deklaroval jsem @thetime proměnnou pro použití měřítka 4, ale poté při převodu na datetimeoffset použil měřítko 7 datový typ. Použití přesnosti 7 je zbytečné, protože nelze použít vyšší přesnost, než jaká již byla přiřazena.
Také jakékoli zaokrouhlení s nižší přesností již nastalo v době, kdy bylo převedeno na (s vyšší přesností) datetimeoffset datový typ. Všimněte si, že čas datový typ zaokrouhlil zlomky sekund nahoru od počáteční hodnoty, kterou jsem mu přiřadil. Tento efekt zaokrouhlení se projevil také v datetimeoffset hodnotu.
Příklad 3 – Explicitní převod pomocí CONVERT()
Zde je příklad použití CONVERT() funkce namísto CAST() .
DECLARE @thetime time; SET @thetime = '23:15:59.1234567'; SELECT @thetime AS 'time', CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Příklad 4 – Implicitní konverze
Zde je příklad provedení stejné věci, ale s použitím implicitní konverze typu.
DECLARE @thetime time, @thedatetimeoffset datetimeoffset; SET @thetime = '23:15:59.1234567'; SET @thedatetimeoffset = @thetime; SELECT @thetime AS 'time', @thedatetimeoffset AS 'datetimeoffset';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
Dostaneme tedy stejný výsledek, bez ohledu na to, zda se jedná o explicitní nebo implicitní konverzi.
Toto je implicitní převod, protože k jeho explicitnímu převodu nepoužíváme konverzní funkci. Jednoduše přiřadíme hodnotu z proměnné jednoho datového typu k proměnné jiného datového typu. V tomto případě SQL Server provede implicitní převod za scénou, když se pokusíme přiřadit čas hodnotu na datetimeoffset proměnná.
Příklad 5 – Změna data
Pokud potřebujete změnit datum (ale zachovat stejný čas), můžete použít DATEADD() funkce.
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';
Výsledek:
+------------------+------------------------------------+ | time | datetimeoffset | |------------------+------------------------------------| | 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 | +------------------+------------------------------------+
V tomto případě přidám 285 k hodnotě roku, čímž se dostane na 2185.