Freigeben über


Verwenden von Datums- und Zeitdaten

Die folgenden Abschnitte in diesem Thema enthalten eine Übersicht über alle Datums- und Zeitdatentypen sowie die zugehörigen Funktionen zusammen mit Beispielen. Eine Übersicht über alle Datums- und Zeitdatentypen und die zugehörigen Funktionen von Transact-SQL finden Sie unter Datums- und Uhrzeitfunktionen (Transact-SQL).

  • Verwenden von Operatoren mit Datums- und Zeitdatentypen

  • Verwenden von Datums- und Zeitformaten

  • Zeichenfolgenliterale für Datums- und Zeitformate

  • Unstrukturierte Zeichenfolgen

  • ISO 8601-Format

  • Alphabetische Datumsformate

  • Numerische Datumsformate

  • Zeitformate

  • ODBC-Datums-/Zeitformat

  • Konvertieren von "date", "time", "datetime2" und "datetimeoffset"

  • Konvertierung zwischen Zeichenfolgenliteralen und "time(n)", "date", "datetime2(n)" und "datetimeoffset(n)"

  • Konvertierung zwischen Datums- und Uhrzeit-Datentypen

  • Verwenden von CAST und CONVERT mit "time", "date", "datetime2" und "datetimeoffset"

  • Stilargumente für die CONVERT-Funktion

  • SQL Server-Datums-/Zeit-Einschränkungen

  • Abwärtskompatibilität für Downlevelclients

  • Beispiele

Verwenden von Operatoren mit Datums- und Zeitdatentypen

Die relationalen Operatoren (<, <=, >, >=, <>), die Vergleichsoperatoren (=, <, <=, >, >=, <>, !<, !>) und die logischen Operatoren sowie die booleschen Prädikate (IS NULL, IS NOT NULL, IN, BETWEEN, EXISTS, NOT EXISTS und LIKE) werden für alle Datums- und Zeitdatentypen unterstützt.

Arithmetische Operatoren für Datums- und Zeitdatentypen

MitDATEADD und DATEDIFF können Sie mit allen Datums- und Zeitdatentypen addieren und subtrahieren.

Verwenden von Datums- und Zeitformaten

Formate für Zeichenfolgenliterale legen fest, wie Datumswerte für die Benutzer einer Anwendung dargestellt werden, bestimmen in SQL Server jedoch nicht das zugrunde liegende ganzzahlige Speicherformat. Jedoch könnte SQL Server einen Datumswert, der von einem Benutzer oder einer anderen Anwendung als Zeichenfolgenliteral zur Speicherung eingegeben oder einer Datumsfunktion übergeben wurde, als einen anderen Datumswert interpretieren. Die Interpretation hängt von der Kombination aus Zeichenfolgenliteralformat, Datumstyp und Laufzeiteinstellungen für SET DATEFORMAT, SET LANGUAGE und der Option default language ab.

Einige Zeichenfolgenliteralformate werden nicht von diesen Einstellungen beeinflusst. Erwägen Sie, ein Format zu verwenden, das nicht von diesen Einstellungen abhängt, es sei denn, Sie wissen, dass die Einstellungen für das Format korrekt funktionieren. Das ISO 8601-Format hängt nicht von diesen Einstellungen ab und ist ein internationaler Standard. Von Transact-SQL verwendete Zeichenfolgenliteralformate, die von Systemeinstellungen abhängen, sind nur eingeschränkt portierbar.

Das für Downlevelclients verwendete standardmäßige Format der Zeichenfolgenliterale ist in den Themen der Datums- und Zeitdatentypen beschrieben. Eine Übersicht über alle Datums- und Zeitdatentypen und die zugehörigen Funktionen von Transact-SQL finden Sie unter Datums- und Uhrzeitfunktionen (Transact-SQL).

Das ydm-Datumsformat wird für die Datentypen date, datetime2 und datetimeoffset nicht unterstützt. Ein Laufzeitfehler wird ausgelöst.

Zeichenfolgenliterale für Datums- und Zeitformate

In der folgenden Tabelle werden verschiedene Zeichenfolgenformate für Datums- und Zeitwerte aufgelistet. Wir empfehlen, Datums- und Zeitformate zu verwenden, die nicht von DATEFORMAT abhängen und mehrere Sprachen unterstützen. Die ISO 8601-Formate "1998-02-23T14: 23:05" und "1998-02-23T14: 23:05 -08: 00" sind die einzigen Formate, die als internationaler Standard gelten. Sie sind nicht von DATEFORMAT oder der bei der Anmeldung angegebenen Standardsprache abhängig und unterstützen mehrere Sprachen.

Datums-Zeitteil

Formattyp

Formatbeispiel

Kann mit anderen Formaten kombiniert werden

DATEFORMAT-abhängig

Unterstützt mehrere Sprachen

Datum

Unstrukturiert

ISO 8601

'19980223'

Ja

Nein

Ja

Datum

Numerisch

'02/23/1998'

Ja

Ja

Nein

(DATEFORMAT)

Datum

ISO 8601-Numerisch

'1998-02-23'

Ja

Nein

Nein

Datum

Alphabetisch

'23. Februar 1998'

Ja

Nein

Nein

(Monat oder Monatskurzname)

Datum

ODBC-Datum

{d '1998-02-23'}

Nein

Nein

Ja

Uhrzeit

ISO 8601-Uhrzeit

'14:23:05'

'10:00:00.123456'

Ja

Nein

Ja

Uhrzeit

ODBC-Uhrzeit

{t '14:23:05'}

Nein

Nein

Ja

Datum/Uhrzeit

ODBC-Datum/Uhrzeit

{ts '1998-02-23 14:23:05'}

Nein

Nein

Ja

Datum/Uhrzeit

ISO 8601

'1998-02-23T14:23:05'

'1998-02-23T14:23:05 -08:00'

Nein

Nein

Ja date, datetime2, datetimeoffset.

Datum/Uhrzeit

ANSI SQL-Standard

'1998-02-23 14:23:05'

'1998-02-23 14:23:05 -08:00'

Nein

Nein (datetime2, datetimeoffset)

Ja (datetime)

Ja date, datetime2, datetimeoffset.

Datum/Uhrzeit

Kombination von Datum und Zeit

'19980223 14:23:05'

'02/23/1998 2:23:05 PM'

'1998-02-23 10:00:00.123'

'23 Feb 1998 14:23:05'

Nein

Ja

(Datumsteil)

Nein

TimeZone

TimeZone-Format

'+12:00'

'01:00'

'-08:00'

'Z'

Ja

Nein

Ja

Die folgenden Anweisungen zeigen die Auswirkungen der Einstellungen von SET LANGUAGE und SET DATEFORMAT.

DECLARE @Today date = '12/1/2003';
DECLARE @MyTime time = '12:30:22';
DECLARE @MyDatetimeoffset datetimeoffset = '12/1/2003 12:30:22 -5:00';
SET LANGUAGE Italian
    -- Returns: Changed language setting to Italiano.
SELECT DATENAME(month, @Today) AS 'Month Name';
    -- Returns: dicembre
SELECT CONVERT(VARCHAR(30), @MyDatetimeoffset) AS 'DATETIMEOFFSET';
    -- Returns: dic  1 2003 12:30PM -05:00
SELECT DATENAME(hour, @MyTime) As 'Hour Name';
    -- Returns: 12

SET LANGUAGE us_english;
    -- Returns: Changed language setting to us_english.
SELECT DATENAME(month, @Today) AS 'Month Name';
    -- Returns: December
SELECT CONVERT(VARCHAR(30), @MyDatetimeoffset) AS 'DATETIMEOFFSET';
    -- Returns: Dec  1 2003 12:30PM -05:00
SELECT DATENAME(hour, @MyTime) As 'Hour Name';
    -- Returns: 12
GO
-- Set date format to month, day, year.
SET DATEFORMAT mdy;
GO
DECLARE @datevar date = '12/31/1998';
SELECT @datevar AS DateVar;
    -- Returns: 1998-12-31
GO
-- Set date format to year, day, month. 
SET DATEFORMAT ydm;
GO
DECLARE @datevar datetimeoffset = '1998/31/12 12:30:22 -05:00';
SELECT @datevar AS DateVar;
    -- Returns: Msg 241, Conversion failed when converting 
    -- date and/or time from character string.
GO
-- Set date format to year, month, day.
SET DATEFORMAT ymd;
GO
DECLARE @datevar date = '12/31/1998';
SELECT @datevar AS DateVar;
    -- Returns: 1998-12-31
GO

Unstrukturierte Zeichenfolgen

Sie können Datumsdaten als unstrukturierte Zeichenfolgen angeben. Die Datumsdaten können mit vier, sechs oder acht Ziffern, einer leeren Zeichenfolge oder einer Zeitangabe ohne Datumsangabe angegeben werden.

Die SET DATEFORMAT-Sitzungseinstellung ist nicht auf rein numerische Datumsangaben (z. B. numerische Angaben ohne Trennzeichen) anwendbar. Die aus sechs oder acht Ziffern bestehenden Zeichenfolgen werden immer als ymd interpretiert. Monat und Tag müssen immer zweistellig sein.

Dies ist ein gültiges Format für unstrukturierte Zeichenfolgen: [19]960415

Eine Zeichenfolge aus nur vier Ziffern wird als Jahr interpretiert. Monat und Tag werden dabei auf den 1. Januar festgelegt. Wenn Sie nur vier Ziffern angeben, müssen Sie das Jahrhundert einschließen.

ISO 8601-Format

Das ISO 8601-Format für Datum mit Uhrzeit hat folgende Form:

  • YYYY-MM-DDThh:mm:ss[.nnnnnnn][{+|-}hh:mm]

  • YYYY-MM-DDThh:mm:ss[.nnnnnnn]Z (UTC, koordinierte Weltzeit)

Der Buchstabe T zeigt den Beginn des Uhrzeitabschnitts des Datum-Zeit-Werts an.

Wenn Sie das ISO 8601-Format verwenden, müssen Sie jedes Element in diesem Format angeben. Dies schließt den Buchstaben T, die Doppelpunkte (:), das + oder - und die Punkte (.) ein. Die Klammern zeigen an, dass der Teil, der die Sekunden angibt, oder die Zeitzonenoffsetkomponenten optional sind.

Die Uhrzeit wird im 24-Stunden-Format angegeben.

Der Vorteil des ISO 8601-Formats liegt darin, dass es sich dabei um einen internationalen Standard handelt. In diesem Format angegebene Datums- und Zeitwerte sind eindeutig. Dieses Format wird nicht von den Einstellungen für SET LANGUAGE, SET DATEFORMAT und der bei der Anmeldung angegebenen Standardsprache beeinflusst.

Zwei Beispiele für im ISO 8601-Format angegebene Datums-/Zeitwerte:

  • 2004-05-23T14:25:10

  • 2004-05-23T14:25:10.1234567+07:00

Alphabetische Datumsformate

Sie können einen Monat als Name angeben, beispielsweise April oder die Abkürzung Apr auf Englisch. Dies sollte in der LANGUAGE-Einstellung der Sitzung angegeben werden, zum Beispiel avril oder avr auf Französisch. Kommas sind optional, und die Großschreibung wird ignoriert.

Es folgen einige Richtlinien für die Verwendung von alphabetischen Datumsformaten:

  • Schließen Sie die Datums- und Zeitdaten in einfache Anführungszeichen ein (').

  • Wenn Sie nur die letzten zwei Ziffern des Jahres angeben, liegen Werte, die niedriger als die letzten zwei Ziffern des Werts der Konfigurationsoption two digit year cutoff sind, im selben Jahrhundert wie das Umstellungsjahr. Werte, die größer als oder gleich dem Wert dieser Option sind, liegen in dem Jahrhundert, das dem Umstellungsjahr vorangeht. Wenn z. B. two digit year cutoff den Wert 2050 hat (Standardeinstellung), wird das zweistellige Jahr 25 als 2025 und das zweistellige Jahr 50 als 1950 interpretiert. Um Mehrdeutigkeit zu vermeiden, sollten Sie vierstellige Jahreszahlen verwenden.

  • Wenn der Tag fehlt, wird der erste Tag des Monats angegeben.

  • Die SET DATEFORMAT-Sitzungseinstellung wird nicht angewendet, wenn Sie den Monat in alphabetischer Form (als Wort) angeben.

  • Die folgenden Formate sind gültige Formate für SQL Server-Datumsdaten. In eckige Klammern eingeschlossene Zeichen sind optional. 

  • Apr[il] [15][,] 1996

  • Apr[il] 15[,] [19]96

  • Apr[il] 1996 [15]

  • [15] Apr[il][,] 1996

  • 15 Apr[il][,][19]96

  • 15 [19]96 apr[il]

  • [15] 1996 apr[il]

  • 1996 APR[IL] [15]

  • 1996 [15] APR[IL]

Numerische Datumsformate

Sie können bei Datumsdaten einen Monat in numerischer Form angeben. So stellt z. B. das Datum 5/20/97 das Jahr 1997 und den zwanzigsten Tag des Monats Mai dar. Wenn Sie ein numerisches Datumsformat verwenden, müssen Sie den Monat, den Tag und das Jahr in einer Zeichenfolge mit Schrägstrichen (/), Bindestrichen (-) oder Punkten (.) als Trennzeichen angeben. Diese Zeichenfolge muss eines der folgenden Formate haben:

Zahl Trennzeichen Zahl Trennzeichen Zahl [Zeit] [Zeit]

Gültige numerische Formate sind:

  • [0]4/15/[19]96 -- (mdy)

  • [0]4-15-[19]96 -- (mdy)

  • [0]4.15.[19]96 -- (mdy)

  • [0]4/[19]96/15 -- (myd)

  • 15/[0]4/[19]96 -- (dmy)

  • 15/[19]96/[0]4 -- (dym)

  • [19]96/15/[0]4 -- (ydm)

  • [19]96/[0]4/15 -- (ymd)

Die DATEFORMAT-Standardsprache für eine Sitzung wird durch die bei der Anmeldung angegebene Standardsprache oder mithilfe der Anweisungen SET LANGUAGE oder SET DATEFORMAT festgelegt. Wird bei der standardmäßigen Anmeldung oder mithilfe der Anweisung SET LANGUAGE die Sprache us_english festgelegt, gilt mdy als Standarddatumsformat.

Sie können das Datumsformat mithilfe der SET DATEFORMAT-Anweisung ändern. Die SET DATEFORMAT-Einstellung bestimmt, wie Datumsangaben interpretiert werden. Wenn die Reihenfolge nicht mit der Einstellung übereinstimmt, werden die Werte nicht als Datumsangabe interpretiert, da sie außerhalb des Bereichs liegen, oder die Werte werden falsch interpretiert. Beispielsweise gibt es für 12/10/08 je nach der DATEFORMAT-Einstellung sechs verschiedene Interpretationen. Eine vierstellige Jahresangabe wird als Jahr interpretiert.

Zeitformate

SQL Server erkennt die folgenden Formate für Zeitangaben. Schließen Sie jedes Format in einfache Anführungszeichen (') ein.

  • 14:30

  • 14:30[:20:999]

  • 14:30[:20.9]

  • 4am

  • 4 PM

  • [0]4[:30:20:500]AM

Die folgenden Anweisungen zeigen, welche Rückgabewerte die CAST-Funktion für andere Eingaben liefert.

SELECT CAST('01/01/2000 14:30' AS datetime2)
    --Returns: 2000-01-01 14:30:00.0000000
SELECT CAST('01/01/2000 14:30:20:999' AS datetime2)
    -- Returns: 2000-01-01 14:30:20.9990000
SELECT CAST('01/01/2000 14:30:20.9' AS datetime2)
    -- Returns: 2000-01-01 14:30:20.9000000
SELECT CAST('01/01/2000 4am' AS datetime2)
    -- Returns: 2000-01-01 04:00:00.0000000
SELECT CAST('01/01/2000 4 PM' AS datetime2)
    -- Returns: 2000-01-01 16:00:00.0000000
SELECT CAST('01/01/2000 04:30:20:500AM' AS datetime2)
    -- Returns: 2000-01-01 04:30:20.5000000
SELECT CAST('01/01/2000 04:30:20:500 AM' AS datetime2)
    -- Returns: 2000-01-01 04:30:20.5000000
GO

Sie können AM oder PM als Suffix angeben, um anzugeben, dass der Zeitwert vor oder nach 12 Uhr mittags liegt. Die Groß-/Kleinschreibung von AM oder PM wird ignoriert.

Stunden können entweder im 12-Stunden- oder im 24-Stunden-Format angegeben werden. Die Stundenangaben werden folgendermaßen interpretiert:

  • Der Stundenwert von 00 stellt die Stunde nach Mitternacht (AM) dar, unabhängig davon, ob AM angegeben ist. Wenn die Stundenangabe dem Wert 00 entspricht, kann PM nicht angegeben werden.

  • Stundenwerte von 01 bis 11 stellen die Stunden vor 12 Uhr mittags dar, wenn weder AM noch PM angegeben wurde. Sie bezeichnen darüber hinaus die Stunden vor 12 Uhr mittags, wenn AM angegeben wurde. Sie kennzeichnen die Stunden nach 12 Uhr mittags, wenn PM angegeben wurde.

  • Der Stundenwert 12 stellt die Stunde, beginnend mit 12 Uhr mittags, dar, wenn weder AM noch PM angegeben wurde. Wurde AM angegeben, bezeichnet der Wert die Stunde, die um Mitternacht beginnt. Wurde PM angegeben, bezeichnet der Wert die Stunde, die um 12 Uhr mittags beginnt. Beispiel: 12:01 ist 1 Minute nach 12 Uhr mittags, genauso wie 12:01 PM, während 12:01 AM 1 Minute nach Mitternacht ist. Die Angabe 12:01 AM ist identisch mit der Angabe 00:01 oder 00:01 AM.

  • Stundenwerte von 13 bis 23 stehen für die Stunden nach 12 Uhr mittags, unabhängig davon, ob AM oder PM angegeben wurde. Sie bezeichnen darüber hinaus die Stunden nach 12 Uhr mittags, wenn PM angegeben wurde. Sie können nicht AM angeben, wenn der Stundenwert zwischen 13 und 23 liegt.

  • Ein Stundenwert von 24 ist ungültig; verwenden Sie vielmehr 12:00 AM oder 00:00 für die Darstellung von Mitternacht.

Vor Millisekundenangaben kann entweder ein Doppelpunkt (:) oder ein Punkt (.) stehen. Der Doppelpunkt bedeutet, dass die folgende Zahl Tausendstelsekunden darstellt. Ein Punkt bedeutet, dass eine einzelne folgende Ziffer Zehntelsekunden, zwei Folgeziffern Hundertstelsekunden und drei Folgeziffern Tausendstelsekunden darstellen. Beispielsweise zeigt "12:30:20:1" zwanzig Sekunden und eine Tausendstelsekunde nach 12:30 an, während "12:30:20.1" zwanzig Sekunden und eine Zehntelsekunde nach 12:30 anzeigt.

ODBC-Datums-/Zeitformat

Die ODBC-API definiert Escapesequenzen zur Darstellung von Datums- und Zeitwerten, die in der ODBC-Terminologie als Timestamp-Daten bezeichnet werden. Dieses ODBC-Timestamp-Format wird auch von der OLE DB-Sprachendefinition (DBGUID-SQL) und vom Microsoft OLE DB-Anbieter für SQL Server unterstützt. Anwendungen, die die ADO-, OLE DB- und ODBC-basierten APIs verwenden, können dieses ODBC-Timestamp-Format zur Darstellung von Datums- und Zeitangaben verwenden.

SQL Server behandelt ODBC-Daten immer als Daten des Typs datetime.

Escapesequenzen für ODBC-Timestamp-Daten haben das folgende Format:

{ literal_type 'constant_value' }

  • literal_type
    Gibt die Art der Escapesequenz an. Folgende Argumente sind für literal_type gültig.

    d = nur Datum

    t = nur Uhrzeit

    ts = timestamp (Uhrzeit + Datum)

  • 'constant_value'
    Dies ist der Wert der Escapesequenz. constant_value muss einem der folgenden Formate für jeden literal_type entsprechen.

    literal_type

    Format für constant_value

    d

    YYYY-MM-DD

    t

    hh:mm:ss[.fff]

    ts

    YYYY-MM-DDhh:mm:ss[.fff]

Nachfolgend werden Beispiele für ODBC-Zeit- und -Datumskonstanten aufgeführt:

  • { ts '1998-05-02 01:23:56.123' }

  • { d '1990-10-02' }

  • { t '13:33:41' }

Sie sollten den ODBC- und OLE DB-Datentypnamen Timestamp nicht mit dem Transact-SQL-Datentypnamen timestamp verwechseln. Der ODBC- und OLE DB-Timestamp-Datentyp zeichnet Daten und Zeiten auf. Der Transact-SQL-Datentyp timestamp ist ein Binärdatentyp ohne zeitbezogene Werte.

Konvertieren von 'date', 'time', 'datetime2' und 'datetimeoffset'

Es gibt zwei Arten der Konvertierung zwischen unterschiedlichen Datumstypen: explizite und implizite Konvertierung. Implizite Konvertierungen treten auf, ohne dass die CAST- oder die CONVERT-Funktionen verwendet werden. Explizite Konvertierungen verwenden die Funktionen CAST oder CONVERT.

Konvertierung zwischen Zeichenfolgenliteralen und 'time(n)', 'date', 'datetime2(n)' und 'datetimeoffset(n)'

Konvertierungen von Zeichenfolgenliteralen in Datums- und Zeitwerte sind erlaubt, wenn alle Teile der Zeichenfolge in gültigen Formaten vorliegen. Andernfalls wird ein Laufzeitfehler ausgelöst.

Wird bei impliziten oder expliziten Konvertierungen von Datums- und Zeitwerten in Zeichenfolgenliterale kein Stil angegeben, wird das Standardformat der aktuellen Sitzung verwendet.

Bei impliziten Konvertierungen von Werten des Typs date, time, datetime2 und datetimeoffset in Zeichenfolgenliterale wird das SQL-Standardformat YYY-MM-DD hh:mi:ss.[nnnnnnn], CONVERT-Stil 121 verwendet. Das CONVERT-Format Stil 0, mon dd yyyy hh:miAM (oder PM), wird für die Datentypen datetime und smalldatetime verwendet.

In der folgenden Tabelle werden die Regeln für die Konvertierung zwischen den Datentypen date, time, datetime2 oder datetimeoffset und Zeichenfolgenliteralen aufgeführt.

Eingabezeichenfolgenliteral

date

time(n)

datetime2(n)

datetimeoffset(n)

ODBC DATE

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

ODBC TIME

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

ODBC DATETIME

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

(siehe Hinweis 1).

Nur DATE

Trivial

Standardwerte werden festgelegt

Der TIME-Teil wird standardmäßig auf 00:00:00 festgelegt.

Der TIME-Teil wird standardmäßig auf 00:00:00 festgelegt. TIMEZONE wird standardmäßig auf +00:00 festgelegt.

Nur TIME

Standardwerte werden festgelegt

Trivial

Der DATE-Teil wird standardmäßig auf 1900-1-1 festgelegt.

Der DATE-Teil wird standardmäßig auf 1900-1-1 festgelegt. TIMEZONE wird standardmäßig auf +00:00 festgelegt.

Nur TIMEZONE

Standardwerte werden festgelegt

Standardwerte werden festgelegt

Standardwerte werden festgelegt

Standardwerte werden festgelegt

DATE + TIME

Der DATE-Teil der Eingabezeichenfolge wird verwendet.

Der TIME-Teil der Eingabezeichenfolge wird verwendet.

Trivial

TIMEZONE wird standardmäßig auf +00:00 festgelegt.

DATUM + TIMEZONE

Nicht zulässig

Nicht zulässig

Nicht zulässig

Nicht zulässig

TIME + TIMEZONE

Standardwerte werden festgelegt

Der TIME-Teil der Eingabezeichenfolge wird verwendet.

Der DATE-Teil wird standardmäßig auf 1900-1-1 festgelegt. TIMEZONE-Eingabe wird ignoriert.

Der DATE-Teil wird standardmäßig auf 1900-1-1 festgelegt.

DATE + TIME + TIMEZONE

Der DATE-Teil von lokalem DATETIME wird verwendet.

Der TIME-Teil von lokalem DATETIME wird verwendet.

Die lokale DATETIME wird verwendet.

Trivial

Konvertierungshinweise

  1. Dem datetime-Datentyp werden ODBC-Zeichenfolgenliterale zugeordnet. Jede Zuweisungsoperation von ODBC DATETIME-Literalen zu date-, time-, datetime2- oder datetimeoffset-Typen bewirkt, wie in den Konvertierungsregeln definiert, eine implizite Konvertierung zwischen datetime und diesen Typen.

  2. Die Genauigkeit in Bruchteilen von Sekunden beträgt bei datetime ein Dreihundertstel einer Sekunde (entspricht 3,33 Millisekunden oder 0,00333 Sekunden). Werte werden in Inkrementen von 0,000, 0,003 oder 0,007 Sekunden gerundet. '08/22/1995 10:15:19:999' wird gerundet, da '.999' die Genauigkeit übersteigt.

  3. Die Genauigkeit in Bruchteilen von Sekunden beträgt bei time(3), datetime2(3) oder datetimeoffset(3) eine Millisekunde. Deshalb wird '1995-8-22 10:15:19:999' nicht gerundet.

  4. Der Offsetteil von TIMEZONE sollte sowohl für hh als auch für mm mit zwei Ziffern angegeben werden. Das Vorzeichen, entweder + oder –, ist obligatorisch.

Konvertierung zwischen Datums- und Uhrzeit-Datentypen

Die Tabellen in diesem Abschnitt zeigen, wie die einzelnen Datums- und Zeit-Datentypen in die jeweils anderen Datums- und Zeit-Datentypen konvertiert werden:

  • date

  • time(n)

  • datetime

  • smalldatetime

  • datetimeoffset(n)

  • datetime2

date-Datumstyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des date-Datentyps in andere Datums- und Zeit-Datentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

time(n)

Die Konvertierung schlägt fehl, und die Fehlermeldung 206 "Operandentypkollision: date ist inkompatibel mit time" wird ausgegeben.

datetime

Das Datum wird kopiert. Der folgende Code zeigt die Ergebnisse der Konvertierung eines date-Werts in einen datetime-Wert.

DECLARE @date date;
DECLARE @datetime datetime;
SET @date = '12-10-25';
SET @datetime = @date;
SELECT @date AS '@date', @datetime AS '@datetime';
--Result
--@date      @datetime
------------ -----------------------
--2025-12-10 2025-12-10 00:00:00.000
--
--(1 row(s) affected)

smalldatetime

Wenn der date-Wert im Bereich von smalldatetime liegt, wird die Datumskomponente kopiert, und die Zeitkomponente wird auf 00:00:00.000 gesetzt. Wenn der date-Wert nicht im Bereich von smalldatetime liegt, wird die Fehlermeldung 242 "Bei der Konvertierung eines date-Datentyps in einen smalldatetime-Datentyp liegt der Wert außerhalb des gültigen Bereichs" ausgegeben, und der smalldatetime-Wert wird auf NULL gesetzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines date-Werts in einen smalldatetime-Wert.

DECLARE @date date;
DECLARE @smalldatetime smalldatetime;
SET @date = '1912-10-25';
SET @smalldatetime = @date;
SELECT @date AS '@date', @smalldatetime AS '@smalldatetime';
--Result
--@date      @smalldatetime
------------ -----------------------
--1912-10-25 1912-10-25 00:00:00
--
--(1 row(s) affected)

datetimeoffset(n)

Das Datum wird kopiert, und die Zeit wird auf 00:00.0000000 +00:00 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines date-Werts in einen datetimeoffset(3)-Wert.

DECLARE @date date;
DECLARE @datetimeoffset datetimeoffset(3);
SET @date = '1912-10-25';
SET @datetimeoffset = @date;
SELECT @date AS '@date', @datetimeoffset AS '@datetimeoffset';
--Result
--@date      @datetimeoffset
------------ ------------------------------
--1912-10-25 1912-10-25 00:00:00.000 +00:00
--
--(1 row(s) affected)

datetime2(n)

Die Datumskomponente wird kopiert, und die Zeitkomponente wird auf 00:00.000000 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines date-Werts in einen datetime2(3)-Wert.

DECLARE @date dat;e
DECLARE @datetime2 datetime2(3);
SET @date = '1912-10-25';
SET @datetime2 = @date;
SELECT @date AS '@date', @datetime2 AS '@datetime2(3)';
--Result
--@date      @datetime2(3)
------------ -----------------------
--1912-10-25 1912-10-25 00:00:00.000
--
--(1 row(s) affected)

time(n)-Datentyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des time-Datentyps in andere Datums- und Zeitdatentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

time(n)

Stunden, Minuten und Sekunden werden kopiert. Wenn die Genauigkeit des Quellwerts die Genauigkeit des Zielwerts übersteigt, werden die Sekundenbruchteile entsprechend gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen time(3)-Wert.

DECLARE @timeTo time(3);
DECLARE @timeFrom time(4);
SET @timeFrom = '12:34:54.1234';
SET @timeTo = @timeFrom;
SELECT @timeTo AS 'time(3)', @timeFrom AS 'time(4)';
--Results
--time(3)      time(4)
-------------- -------------
--12:34:54.123 12:34:54.1234
--
--(1 row(s) affected)

date

Die Konvertierung schlägt fehl, und die Fehlermeldung 206 "Operandentypkollision: date ist inkompatibel mit time" wird ausgegeben.

datetime

Die Werte für Stunden, Minuten und Sekunden werden kopiert, und die Datumskomponente wird auf 1900-01-01 festgelegt. Wenn die Genauigkeit des time(n)-Werts größer ist als drei Sekundenbruchteile, wird das datetime-Ergebnis gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen datetime-Wert.

DECLARE @time time(4);
DECLARE @datetime datetime;
SET @time = '12:15:04.1234';
SET @datetime = @time;
SELECT @time AS '@time', @datetime AS '@datetime';
--Result
--@time         @datetime
--------------- -----------------------
--12:15:04.1234 1900-01-01 12:15:04.123
--
--(1 row(s) affected)

smalldatetime

Das Datum wird auf 1900-01-01 festgelegt, und die Werte für Stunden und Minuten werden kopiert. Die Sekunden und die Sekundenbruchteile werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen smalldatetime-Wert.

DECLARE @time time(4);
DECLARE @smalldatetime smalldatetime;
SET @time = '12:15:04.1234';
SET @smalldatetime = @time;
SELECT @time AS '@time', @smalldatetime AS '@smalldatetime';
--Result
--@time         @smalldatetime
--------------- -----------------------
--12:15:04.1234 1900-01-01 12:15:00
--
--(1 row(s) affected)

datetimeoffset(n)

Das Datum wird auf 1900-01-01 festgelegt, und die Zeit wird kopiert. Der Zeitzonenoffset wird auf +00:00 festgelegt. Wenn die Genauigkeit in Sekundenbruchteilen des time(n)-Werts größer ist als die Genauigkeit des datetimeoffset(n)-Werts, wird der Wert gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen datetimeoffset(3)-Wert.

DECLARE @time time(4);
DECLARE @datetimeoffset datetimeoffset(3);
SET @time = '12:15:04.1234';
SET @datetimeoffset = @time;
SELECT @time AS '@time', @datetimeoffset AS '@datetimeoffset';
--Result
--@time         @datetimeoffset
--------------- ------------------------------
--12:15:04.1234 1900-01-01 12:15:04.123 +00:00
--
--(1 row(s) affected)

datetime2(n)

Das Datum wird auf 1900-01-01 festgelegt, die Zeitkomponente wird kopiert, und der Zeitzonenoffset wird auf 00:00 festgelegt. Wenn die Genauigkeit in Sekundenbruchteilen des datetime2(n)-Werts größer ist als die Genauigkeit des time(n)-Werts, wird der Wert gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen datetime2(2)-Wert.

DECLARE @time time(4);
DECLARE @datetime2 datetime2(3);
SET @time = '12:15:04.1234';
SET @datetime2 = @time;
SELECT @datetime2 AS '@datetime2', @time AS '@time';
--Result
--@datetime2              @time
------------------------- -------------
--1900-01-01 12:15:04.123 12:15:04.1234
--
--(1 row(s) affected)

datetime-Datentyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des datetime-Datentyps in andere Datums- und Zeitdatentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

date

Jahr, Monat und Tag werden kopiert. Die Zeitkomponente wird auf 00:00:00.000 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines date-Werts in einen datetime-Wert.

DECLARE @date date;
DECLARE @datetime datetime;
SET @date = '12-21-05';
SET @datetime = @date;
SELECT @datetime AS '@datetime', @date AS '@date';
--Result
--@datetime               @date
------------------------- ----------
--2005-12-21 00:00:00.000 2005-12-21

time(n)

Die Zeitkomponente wird kopiert, und die Datumskomponente wird auf 1900-01-01 festgelegt. Wenn die Genauigkeit des time(n)-Werts um mehr als drei Sekundenbruchteile abweicht, wird der Wert gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines time(4)-Werts in einen datetime-Wert.

DECLARE @time time(4);
DECLARE @datetime datetime;
SET @time = '12:10:05.1234';
SET @datetime = @time;
SELECT @datetime AS '@datetime', @time AS '@time';
--Result
--@datetime               @time
------------------------- -------------
--1900-01-01 12:10:05.123 12:10:05.1234
--
--(1 row(s) affected)

smalldatetime

Stunden und Minuten werden kopiert. Die Sekunden und die Sekundenbruchteile werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen datetime-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @datetime datetime;
SET @smalldatetime = '12-01-01 12:32';
SET @datetime = @smalldatetime;
SELECT @datetime AS '@datetime', @smalldatetime AS '@smalldatetime';
--Result
--@datetime               @smalldatetime
------------------------- -----------------------
--2001-12-01 12:32:00.000 2001-12-01 12:32:00
--
--(1 row(s) affected)

datetimeoffset(n)

Datums- und Zeitkomponenten werden kopiert. Die Zeitzone wird abgeschnitten. Wenn die Genauigkeit des datetimeoffset(n)-Werts um mehr als drei Sekundenbruchteile abweicht, wird der Wert gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines datetimeoffset(4)-Werts in einen datetime-Wert.

DECLARE @datetimeoffset datetimeoffset(4);
DECLARE @datetime datetime;
SET @datetimeoffset = '1968-10-23 12:45:37.1234 +10:0';
SET @datetime = @datetimeoffset;
SELECT @datetime AS '@datetime', @datetimeoffset AS '@datetimeoffset';
--Result
--@datetime               @datetimeoffset
------------------------- ------------------------------
--1968-10-23 12:45:37.123 1968-10-23 12:45:37.1234 +01:0
--
--(1 row(s) affected)

datetime2(n)

Datum und Uhrzeit werden kopiert. Wenn die Genauigkeit des datetime2(n)-Werts um mehr als drei Sekundenbruchteile abweicht, wird der Wert gekürzt.

Das folgende Beispiel zeigt die Ergebnisse der Konvertierung eines datetime2(4)-Werts in einen datetime-Wert.

DECLARE @datetime2 datetime2(4);
DECLARE @datetime datetime;
SET @datetime2 = '1968-10-23 12:45:37.1237';
SET @datetime = @datetime2;
SELECT @datetime AS '@datetime', @datetime2 AS '@datetime2';
--Result
--@datetime               @datetime2
------------------------- ------------------------
--1968-10-23 12:45:37.123 1968-10-23 12:45:37.1237
--
--(1 row(s) affected)

smalldatetime-Datentyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des smalldatetime-Datentyps in andere Datums- und Zeitdatentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

date

Jahr, Monat und Tag werden kopiert.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen date-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @date dat;e
SET @smalldatetime = '1955-12-13 12:43:10';
SET @date = @smalldatetime;
SELECT @smalldatetime AS '@smalldatetime', @date AS 'date';
--Result
--@smalldatetime          date
------------------------- ----------
--1955-12-13 12:43:00     1955-12-13
--
--(1 row(s) affected)

time(n)

Stunden, Minuten und Sekunden werden kopiert. Die Sekundenbruchteile werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen time(4)-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @time time(4);
SET @smalldatetime = '1955-12-13 12:43:10';
SET @time = @smalldatetime;
SELECT @smalldatetime AS '@smalldatetime', @time AS 'time';
--Result
--@smalldatetime          time
------------------------- -------------
--1955-12-13 12:43:00     12:43:00.0000
--
--(1 row(s) affected)

datetime

Der smalldatetime-Wert wird in den datetime-Wert kopiert. Die Sekundenbruchteile werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen datetime-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @datetime datetime;
SET @smalldatetime = '1955-12-13 12:43:10';
SET @datetime = @smalldatetime;
SELECT @smalldatetime AS '@smalldatetime', @datetime AS 'datetime';
--Result
--@smalldatetime          datetime
------------------------- -----------------------
--1955-12-13 12:43:00     1955-12-13 12:43:00.000
--
--(1 row(s) affected)

datetimeoffset(n)

Der smalldatetime-Wert wird in den datetimeoffset(n)-Wert kopiert. Die Sekundenbruchteile werden auf 0 und der Zeitzonenoffset auf +00:0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen datetimeoffset(4)-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @datetimeoffset datetimeoffset(4);
SET @smalldatetime = '1955-12-13 12:43:10';
SET @datetimeoffset = @smalldatetime;
SELECT @smalldatetime AS '@smalldatetime', @datetimeoffset AS 'datetimeoffset(4)';
--Result
--@smalldatetime          datetimeoffset(4)
------------------------- ------------------------------
--1955-12-13 12:43:00     1955-12-13 12:43:00.0000 +00:0
--
--(1 row(s) affected)

datetime2(n)

Der smalldatetime-Wert wird in den datetime2(n)-Wert kopiert. Die Sekundenbruchteile werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines smalldatetime-Werts in einen datetime2(4)-Wert.

DECLARE @smalldatetime smalldatetime;
DECLARE @datetime2 datetime2(4);
SET @smalldatetime = '1955-12-13 12:43:10';
SET @datetime2 = @smalldatetime;
SELECT @smalldatetime AS '@smalldatetime', @datetime2 AS ' datetime2(4)';
--Result
--@smalldatetime           datetime2(4)
------------------------- ------------------------
--1955-12-13 12:43:00     1955-12-13 12:43:00.0000
--
--(1 row(s) affected)

datetimeoffset(n)-Datentyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des datetimeoffset(n)-Datentyps in andere Datums- und Zeitdatentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

date

Jahr, Monat und Tag werden kopiert.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetimeoffset(4)-Werts in einen date-Wert.

DECLARE @datetimeoffset datetimeoffset(4);
DECLARE @date date;
SET @datetimeoffset = '12-10-25 12:32:10 +01:0;
SET @date = @datetimeoffset;
SELECT @datetimeoffset AS '@datetimeoffset ', @date AS 'date';
--Result
--@datetimeoffset                date
-------------------------------- ----------
--2025-12-10 12:32:10.0000 +01:0 2025-12-10
--
--(1 row(s) affected)

time(n)

Stunden, Minuten, Sekunden und Sekundenbruchteile werden kopiert. Der Zeitzonenwert wird abgeschnitten. Wenn die Genauigkeit des datetimeoffset(n)-Werts größer ist als die Genauigkeit des time(n)-Werts, wird der Wert gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetimeoffset(4)-Werts in einen time(3)-Wert.

DECLARE @datetimeoffset datetimeoffset(4);
DECLARE @time time(3);
SET @datetimeoffset = '12-10-25 12:32:10.1234 +01:0';
SET @time = @datetimeoffset;
SELECT @datetimeoffset AS '@datetimeoffset ', @time AS 'time';
--Result
--@datetimeoffset                time
-------------------------------- ------------
--2025-12-10 12:32:10.1234 +01:0 12:32:10.123
--
--(1 row(s) affected)

datetime

Datums- und Zeitwerte werden kopiert, die Zeitzone wird abgeschnitten. Wenn die Genauigkeit des datetimeoffset(n)-Werts um mehr als drei Sekundenbruchteile abweicht, wird der Wert gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetimeoffset(4)-Werts in einen datetime-Wert.

DECLARE @datetimeoffset datetimeoffset(4);
DECLARE @datetime datetime;
SET @datetimeoffset = '12-10-25 12:32:10.1234 +01:0';
SET @datetime = @datetimeoffset;
SELECT @datetimeoffset AS '@datetimeoffset ', @datetime AS 'datetime';
--Result
--@datetimeoffset                datetime
-------------------------------- -----------------------
--2025-12-10 12:32:10.1234 +01:0 2025-12-10 12:32:10.123
--
--(1 row(s) affected)

smalldatetime

Datum, Stunden und Minuten werden kopiert. Die Sekunden werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetimeoffset(3)-Werts in einen smalldatetime-Wert.

DECLARE @datetimeoffset datetimeoffset(3);
DECLARE @smalldatetime smalldatetime;
SET @datetimeoffset = '1912-10-25 12:24:32 +10:0';
SET @smalldatetime = @datetimeoffset;
SELECT @datetimeoffset AS '@datetimeoffset', @smalldatetime AS '@smalldatetime';
--Result
--@datetimeoffset                @smalldatetime
-------------------------------- -----------------------
--1912-10-25 12:24:32.000 +10:00 1912-10-25 12:25:00
--
--(1 row(s) affected)

datetime2(n)

Datum und Zeit werden in den datetime2-Wert kopiert, die Zeitzone wird abgeschnitten. Wenn die Genauigkeit in Sekundenbruchteilen des datetime2(n)-Werts größer ist als die Genauigkeit des datetimeoffset(n)-Werts, wird der Wert gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetimeoffset(4)-Werts in einen datetime2(3)-Wert.

DECLARE @datetimeoffset datetimeoffset(4);
DECLARE @datetime2 datetime2(3);
SET @datetimeoffset = '1912-10-25 12:24:32.1234 +10:0';
SET @datetime2 = @datetimeoffset;
SELECT @datetimeoffset AS '@datetimeoffset', @datetime2 AS '@datetime2';
--Result
--@datetimeoffset                @datetime2
-------------------------------- -----------------------
--1912-10-25 12:24:32.1234 +10:0 1912-10-25 12:24:32.123
--
--(1 row(s) affected)

datetime2-Datentyp

Die folgende Tabelle veranschaulicht die Abläufe bei der Konvertierung des datetime2-Datentyps in andere Datums- und Zeitdatentypen.

Zieldatentyp der Konvertierung

Konvertierungsinformationen

date

Jahr, Monat und Tag werden kopiert.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetime2(4)-Werts in einen date-Wert.

DECLARE @datetime2 datetime2(4;
DECLARE @date date;
SET @datetime2 = '12-10-25 12:32:10.1234';
SET @date = @datetime2;
SELECT @datetime2 AS '@datetime2', @date AS 'date';
--Result
--@datetime2               date
-------------------------- ----------
--2025-12-10 12:32:10.1234 2025-12-10
--
--(1 row(s) affected)

time(n)

Stunden, Minuten, Sekunden und Sekundenbruchteile werden kopiert.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetime2(4)-Werts in einen time(3)-Wert.

DECLARE @datetime2 datetime2(4);
DECLARE @time time(3);
SET @datetime2 = '12-10-25 12:32:10.1234';
SET @time = @datetime2;
SELECT @datetime2 AS '@datetime2', @time AS 'time(3)';
--Result
--@datetime2                time(3) 
-------------------------- ------------
--2025-12-10 12:32:10.1234 12:32:10.123
--
--(1 row(s) affected)

datetime

Datums- und Zeitwerte werden kopiert. Wenn die Genauigkeit des datetimeoffset(n)-Werts um mehr als drei Sekundenbruchteile abweicht, wird der Wert gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetime2-Werts in einen datetime-Wert.

DECLARE @datetime2 datetime;2
DECLARE @datetime datetime;
SET @datetime2 = '12-10-25 12:32:10.1234567;'
SET @datetime = @datetime2;
SELECT @datetime2 AS '@datetime2', @datetime AS '@datetime';
--Result
--@datetime2                  @datetime
----------------------------- -----------------------
--2025-12-10 12:32:10.1234567 2025-12-10 12:32:10.123
--
--(1 row(s) affected)

smalldatetime

Datum, Stunden und Minuten werden kopiert. Die Sekunden werden auf 0 festgelegt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetime2-Werts in einen smalldatetime-Wert.

DECLARE @datetime2 datetime2;
DECLARE @smalldatetime smalldatetime;
SET @datetime2 = '12-10-25 12:32:10.1234567';
SET @smalldatetime = @datetime2;
SELECT @datetime2 AS '@datetime2', @smalldatetime AS '@smalldatetime';
--Result
--@datetime2                  @datetime
----------------------------- -----------------------
--2025-12-10 12:32:10.1234567 2025-12-10 12:32:10.123
--
--(1 row(s) affected)

datetimeoffset(n)

Der datetime2(n)-Wert wird auf den datetimeoffset(n)-Wert kopiert. Der Zeitzonenoffset wird auf +00:0 festgelegt. Wenn die Genauigkeit des datetime2(n)-Werts größer ist als die Genauigkeit des datetimeoffset(n)-Werts, wird der Wert gekürzt.

Der folgende Code zeigt die Ergebnisse der Konvertierung eines datetime2(5)-Werts in einen datetimeoffset(3)-Wert.

DECLARE @datetime2 datetime2(3);
DECLARE @datetimeoffset datetimeoffset(2);
SET @datetime2 = '12-10-25 12:32:10.1234567';
SET @datetimeoffset = @datetime2;
SELECT @datetime2 AS '@datetime2', @datetimeoffset AS '@datetimeoffset(2)';
--Result
--@datetime2              @datetimeoffset(2)
------------------------- -----------------------------
--2025-12-10 12:32:10.123 2025-12-10 12:32:10.12 +00:00
--
--(1 row(s) affected)

Verwenden von CAST und CONVERT mit 'time', 'date', 'datetime2' und 'datetimeoffset'

Der folgende Abschnitt bietet Informationen zur Konvertierung zwischen Datums- und Zeitdatentypen.

Konvertierung in 'datetimeoffset'

  • Wann immer ein datetimeoffset-Wert mit Zeitzone implizit von einem Wert ohne Zeitzone abgeleitet werden muss (beispielsweise in einer einfachen Zuweisungsoperation), wird der Wert ohne Zeitzone als lokaler Wert behandelt, und zur UTC-Ermittlung wird der aktuelle Zeitzonenversatz (00:00) von diesem Wert subtrahiert.
  1. Bei den folgenden Konvertierungen wird die UTC-Zeitzone (00:00) immer angehängt, wenn Sie einen Datentyp ohne Zeitzone in datetimeoffset konvertieren:
  • date in datetimeoffset

  • time in datetimeoffset

  • datetime2 in datetimeoffset

  • datetime oder smalldatetime in datetimeoffset

  • Zeichenfolgenliterale in gültigem date-, time- oder datetime-Format ohne Zeitzone in datetimeoffset

Konvertierung von "datetimeoffset"

Wenn Sie von datetimeoffset in folgende Typen ohne Zeitzone konvertieren, dann gibt Stil 0 (Standard) immer an, dass der zurückgegebene date-, time-, datetime2-, datetime oder smalltime-Wert im lokalen Format des beibehaltenen Zeitzonenoffsets vorliegt; Stil 1 gibt dagegen immer das UTC-Format an.

Wann immer ein Datums- oder Zeitwert ohne Zeitzone in einer der folgenden Konvertierungen implizit abgeleitet wird, wird der datetimeoffset-Wert als UTC behandelt. Der beibehaltene Zeitzonenversatz wird zu dem Wert addiert, um die lokale Zeit zu erhalten. Das Ergebnis, ohne jeden Zeitzonenoffset, liegt in lokaler Zeit vor.

  • datetimeoffset in date

  • datetimeoffset in time

  • datetimeoffset in datetime2

  • datetimeoffset oder datetime in smalldatetime

  • Die Stile 0 und 1 können nicht für die Konvertierung von datetimeoffset in Zeichenfolgen verwendet werden. Konvertieren Sie stattdessen datetimeoffset in datetime2 oder datetime und dannin varchar oder char.

Umfasst ein vorhandener CONVERT-Stil den Uhrzeitteil, und Sie konvertieren datetimeoffset in eine Zeichenfolge, wird der Zeitzonenoffset (außer bei Stil 127) eingeschlossen. Wenn Sie den Zeitzonenoffset nicht wünschen, können Sie den Wert zuerst mit CAST in datetime2 umwandeln und ihn dann in eine Zeichenfolge konvertieren.

Alle vorhandenen Datums- und Zeitstile gelten für jede Konvertierung von datetimeoffset in Zeichenfolgen, und der Zeitzonenoffset bleibt erhalten.

Der Teil der Eingabezeichenfolge für die Zeitzone sollte sowohl für hh als auch für mm mit zwei Ziffern eingegeben werden. Das Vorzeichen, entweder + oder –, ist obligatorisch.

Informationen, die bei der Konvertierung verloren gehen

  • Wenn Sie datetime2 oder datetimeoffset in date konvertieren, findet keine Rundung statt, und der Datumsteil wird explizit extrahiert. Für datetimeoffset wird die Extrahierung für das lokale Datum und die lokale Zeit, aber nicht für den UTC-Wert ausgeführt.

  • Bei jeder impliziten Konvertierung von datetimeoffset in date, time, datetime2, datetime oder smalldatetime basiert die Konvertierung auf dem lokalen Datums- und Zeitwert (für den permanenten Zeitzonenoffset). Wenn beispielsweise der datetimeoffset(3)-Wert , 2006-10-21 12:20:20.999 -8:00, in time(3) konvertiert wird, ist das Ergebnis 12:20:20.999 und nicht 20:20:20.999(UTC).

Datenkürzung in Konvertierungen

  • Konvertierungen von Zeitwerten höherer Genauigkeit in Werte mit geringerer Genauigkeit sind erlaubt. Die Werte mit höherer Genauigkeit werden entsprechend abgeschnitten, um sie an den Datentyp mit der geringeren Genauigkeit anzupassen.

Konvertierung von Sekundenbruchteilen

Wenn ein Stil das Uhrzeitformat hh:mm:ss.mmm einschließt, wird für time(n), datetime2(n) und datetimeoffset(n) das Format hh:mm:ss.[nnnnnnn] verwendet. Die Anzahl der Ziffern hängt von der Typspezifikation ab. Wenn Sie nur eine Millisekundengenauigkeit möchten, konvertieren Sie zuerst in datetime2(3) und dann in eine Zeichenfolge.

Bei den Stilen 9, 109, 13, 113, 21, 121, 130 und 131 wird das dem Doppelpunkt (:) vorangehende Trennzeichen für die Konvertierung von time, datetime2 und datetimeoffset in Zeichenfolgen nicht unterstützt. Das Ausgabezeichenfolgenformat mit irgendeinem dieser Stile wird zu einem Punkt (.) transformiert.

Stilargumente für die CONVERT-Funktion

Die folgende Tabelle zeigt Beispiele von date, time-, datetime2- und datetimeoffset-Werten für Stilargumente der CONVERT-Funktion. Weitere Informationen zu Stilen finden Sie im Abschnitt "Argumente" unter CAST und CONVERT (Transact-SQL).

Stil

Associated standard

Input/Output (3)

format

date

time(n)

datetime2(n)

datetimeoffset(n)

0 oder 100 (1,2)

Standard

mon dd yyyy hh:miAM (oder PM)

Jan 1 2001

12:20PM

Jan 1 2001 12:20PM

Jan 1 2001 12:20PM -08:00

101

USA

mm/dd/yyyy

01/01/2001

-

01/01/2001

01/01/2001

102

ANSI

yy.mm.dd

2001.01.01

-

2001.01.01

2001.01.01

103

Britisch/Französisch

dd/mm/yy

01/01/2001

-

01/01/2001

01/01/2001

104

Deutsch

dd.mm.yy

01.01.2001

-

01.01.2001

01.01.2001

105

Italienisch

dd-mm-yy

01-01-2001

-

01-01-2001

01-01-2001

106(1)

-

dd mon yy

01 Jan 2001

-

01 Jan 2001

01 Jan 2001

107(1)

-

Mon dd, yy

Jan 01, 2001

-

Jan 01, 2001

Jan 01, 2001

108

-

hh:mi:ss

-

12:20:20

12:20:20

12:20:20

9 oder 109 (1,2)

Standardwert + Millisekunden

mon dd yyyy hh:mi:ss:mmmAM (oder PM)

Jan 1 2001

12:20:20.1234567AM

Jan 1 2001 12:20:20.1234567PM

Jan 1 2001 12:20:20:1230000PM -08:00

110

USA

mm-dd-yy

01-01-2001

-

01-01-2001

01-01-2001

111

JAPAN

yy/mm/dd

2001/01/01

-

2001/01/01

2001/01/01

112

ISO

yymmdd

20010101

-

20010101

20010101

13 oder 113 (1,2)

Europ. Standard + Millisekunden

dd mon yyyy hh:mi:ss:mmm(24h)

01 Jan 2001

12:20:20.1234567

01 Jan 2001 12:20:20.1234567

01 Jan 2001 12:20:20:1230000 -08:00

114

-

hh:mi:ss:mmm(24h)

-

12:20:20.1234567

12:20:20.1234567

12:20:20:1230000 -08:00

20 oder 120 (2)

ODBC kanonisch

yyyy-mm-dd hh:mi:ss(24h)

2001-01-01

12:20:20

2001-01-01 12:20:20

2001-01-01 12:20:20 -08:00

21 oder 121 (2)

ODBC kanonisch (mit Millisekunden)

yyyy-mm-dd hh:mi:ss.mmm(24h)

2001-01-01

12:20:20.1234567

2001-01-01 12:20:20.1234567

2001-01-01 12:20:20.1230000 -08:00

126 (4)

ISO8601

yyyy-mm-ddThh:mi:ss.mmm (keine Leerzeichen)

2001-01-01

12:20:20.1234567

2001-01-01T 12:20:20.1234567

2001-01-01T 12:20:20.1234567

127(6, 7)

ISO8601 mit Zeitzone Z.

yyyy-mm-ddThh:mi:ss.mmmZ

(keine Leerzeichen)

2001-01-01

12:20:20.1234567Z

2001-01-01T 12:20:20.1234567Z

2001-01-01T20:20:20.1230000Z

130 (1,2)

Hijri (5)

dd mon yyyy hh:mi:ss:mmmAM

01 Jan 2001

12:20:20.1230000PM

01 Jan 2001 12:20:20.1230000PM

1 Jan 2001 12:20:20:1230000PM -08:00

131 (2)

Hijri (5)

dd/mm/yy hh:mi:ss:mmmAM

01/01/2001

12:20:20.1230000PM

01/01/2001 12:20:20.1230000PM

01/01/2001 12:20:20.1230000PM -08:00

1 Diese Formatwerte geben nicht deterministische Ergebnisse zurück. Dazu gehören alle (yy)-Formate (ohne Jahrhundert) und eine Teilmenge der (yyyy)-Formate (mit Jahrhundert).

2 Die Standardwerte (style0 oder 100, 9 oder 109, 13 oder 113, 20 oder 120 und 21 oder 121) geben immer das Jahrhundert zurück (yyyy).

3 Eingabe, wenn in datetime konvertiert wird; Ausgabe, wenn in Zeichendaten konvertiert wird.

4 Vorgesehen für XML-Verwendung. Für eine Konvertierung aus datetime- oder smalldatetime-Daten in Zeichendaten ist das Ausgabeformat so wie in der Tabelle beschrieben.

5 Hijri ist ein Kalendersystem mit verschiedenen Varianten. In SQL Server wird der kuwaitische Algorithmus verwendet.

6 Wird nur bei der Umwandlung mit CAST von Zeichendaten in datetime- oder smalldatetime-Werte unterstützt. Wenn Zeichendaten, die nur Zeit- oder nur Datumskomponenten darstellen, in die Datentypen datetime oder smalldatetime umgewandelt werden, wird die nicht angegebene Zeitkomponente auf 00:00:00.000 festgelegt und die nicht angegebene Datumskomponente auf 1900-01-01.

7 Der optionale Zeitzonenindikator Z vereinfacht die Zuordnung von XML-datetime-Werten mit Zeitzoneninformationen zu SQL Server-datetime-Werten ohne Zeitzone. Z ist der Indikator für Zeitzonen-UTC-0.

SQL Server-Datums-/Zeit-Einschränkungen

In der folgenden Liste beziehen sich Datum und Zeit auf jeden Datums-/Zeittyp, der einen Datums- oder einen Zeitteil umfasst.

  • Keine serverseitige Sommerzeitunterstützung (DST) für datetimeoffset.

  • Keine Unterstützung des Julianischen Kalenders für Datum.

  • Keine Unterstützung der '24'-Stunden-Darstellung für Mitternacht.

  • Keine Unterstützung von 'Schaltsekunden' über '59'.

  • Keine Unterstützung von 'einer Nanosekunde' oder größer für die Genauigkeit von Sekundenbruchteilen.

  • Keine Zeitzonenunterstützung für Zeit.

  • Keine Unterstützung der SQL-Standard-INTERVAL-Operation.

Abwärtskompatibilität für Downlevelclients

Einige Clients früherer Versionen unterstützendie Datentypen time, date, datetime2 und datetimeoffset nicht, die in SQL Server 2008 hinzugefügt wurden. In der folgenden Tabelle wird die Typzuordnung zwischen einer Instanz höherer Ebene in SQL Server 2008 zu Clients früherer Versionen gezeigt.

SQL Server 2008-Datentyp

Standardmäßige Formate der an Downlevelclients übergebene Zeichenfolgenliterale

ODBC früherer Versionen

OLEDB früherer Versionen

JDBC früherer Versionen

SQLCLIENT früherer Versionen

time

hh:mm:ss[.nnnnnnn]

SQL_WVARCHAR oder SQL_VARCHAR

DBTYPE_WSTR oder DBTYPE_STR

Java.sql.String

Zeichenfolge oder SqlString

date

YYYY-MM-DD

SQL_WVARCHAR oder SQL_VARCHAR

DBTYPE_WSTR oder DBTYPE_STR

Java.sql.String

Zeichenfolge oder SqlString

datetime2

YYYY-MM-DD hh:mm:ss[.nnnnnnn]

SQL_WVARCHAR oder SQL_VARCHAR

DBTYPE_WSTR oder DBTYPE_STR

Java.sql.String

Zeichenfolge oder SqlString

datetimeoffset

YYYY-MM-DD hh:mm:ss[.nnnnnnn] [+|-]hh:mm

SQL_WVARCHAR oder SQL_VARCHAR

DBTYPE_WSTR oder DBTYPE_STR

Java.sql.String

Zeichenfolge oder SqlString

Beispiele

A. Vergleich von Datums- und Zeitdatentypen

Im folgenden Beispiel werden die Ergebnisse der Umwandlung von einer Zeichenfolge in alle Datums- und Zeitdatentypen verglichen. Der Versuch, mit CAST ein Zeichenfolgenliteral mit einer Genauigkeit der Sekundenbruchteile, die für smalldatetime oder datetime größer als erlaubt ist, umzuwandeln, löst einen Fehler aus.

SELECT 
     CAST('2007-05-08 12:35:29. 1234567 +12:15' AS time(7)) AS 'time' 
    ,CAST('2007-05-08 12:35:29. 1234567 +12:15' AS date) AS 'date' 
    ,CAST('2007-05-08 12:35:29.123' AS smalldatetime) AS 
        'smalldatetime' 
    ,CAST('2007-05-08 12:35:29.123' AS datetime) AS 'datetime' 
    ,CAST('2007-05-08 12:35:29. 1234567 +12:15' AS datetime2(7)) AS 
        'datetime2'
    ,CAST('2007-05-08 12:35:29.1234567 +12:15' AS datetimeoffset(7)) AS 
        'datetimeoffset';

Datentyp

Ausgabe

time

12:35:29.1234567

date

2007-05-08

smalldatetime

2007-05-08 12:35:00

datetime

2007-05-08 12:35:29.123

datetime2(7)

2007-05-08 12:35:29.1234567

datetimeoffset(7)

2007-05-08 12:35:29.1234567 +12:15

B. Abrufen des aktuellen Systemdatums und der aktuellen Systemzeit

Das folgende Beispiel veranschaulicht die Verwendung von SQL Server-Systemfunktionen, die das aktuelle Systemdatum und die aktuelle Systemzeit zurückgeben. 

SELECT SYSDATETIME() AS 'SYSDATETIME'

--Results
--SYSDATETIME
--2007-10-22 14:10:41.7984554
--(1 row(s) affected)

SELECT SYSDATETIMEOFFSET() AS 'SYSDATETIMEOFFSET'

--Results
--SYSDATETIMEOFFSET
--2007-10-22 14:11:34.2607172 -0
--(1 row(s) affected)

SELECT SYSUTCDATETIME() AS 'SYSUTCDATETIME'

--Results
--SYSUTCDATETIME
--2007-10-22 21:12:11.7069470
--(1 row(s) affected)

SELECT CURRENT_TIMESTAMP AS 'CURRENT_TIMESTAMP'

--Results
--CURRENT_TIMESTAMP
-------------------------
--2007-10-22 14:12:33.320
--(1 row(s) affected)

SELECT GETDATE() AS 'GETDATE'

--Results
--GETDATE
--2007-10-22 14:13:57.943
--(1 row(s) affected)

SELECT GETUTCDATE() AS 'GETUTCDATE'

--Results
--GETUTCDATE
--2007-10-22 21:14:35.657
--(1 row(s) affected)

C. Suchen nach allen datetime2-Werten eines Tags

  • Das folgende Beispiel zeigt, wie Sie alle Datums- und Zeitwerte für einen Tag suchen.
-- Create a table that contains with the following dates:
--     The last date-time in 2005-04-06, '2005-04-06 23:59:59.9999999'
--     The first date-time in 2005-04-07, '2005-04-07 00:00:00.0000000'
--     The last date-time in 2005-04-07, '2005-04-07 23:59:59.9999999'
--     The first date-time in 2005-04-08, '2005-04-08 00:00:00.0000000'
CREATE TABLE #Search
    (
    MyDate datetime2
    );
INSERT INTO #Search(MyDate)VALUES('2005-04-06 23:59:59.9999999');
INSERT INTO #Search(MyDate)VALUES('2005-04-07 00:00:00.0000000');
INSERT INTO #Search(MyDate)VALUES('2005-04-07 23:59:59.9999999');
INSERT INTO #Search(MyDate)VALUES('2005-04-08 00:00:00.0000000');

-- The following four SELECT statements show different ways to find
-- only the two rows that contain 2005-04-07 dates.
--Use CONVERT.
SELECT MyDate 
FROM #Search 
WHERE CONVERT(date,MyDate) = '2005-04-07';

--Use >= and <=.
SELECT MyDate 
FROM #Search 
WHERE MyDate >= '2005-04-07 00:00:00.0000000' 
    AND MyDate <= '2005-04-07 23:59:59.9999999';

--Use > and <.
SELECT MyDate
FROM #Search
WHERE MyDate > '2005-04-06 23:59:59.9999999'
    AND MyDate < '2005-04-08 00:00:00.0000000';

--Use BETWEEN AND.
SELECT MyDate
FROM #Search
WHERE MyDate BETWEEN '2005-04-07 00:00:00.0000000'
    AND '2005-04-07 23:59:59.9999999';
DROP TABLE #Search
GO

D. Suchen nach einem Zeitraum innerhalb eines Tags

Die folgenden Beispiele zeigen, wie Sie nach Datumsdaten mit Zeitwerten suchen, um einen Zeitraum zu ermitteln.

-- Create a table called Search and insert
-- five different time values for the same
-- date.

CREATE TABLE #Search
    (
    MyDate datetime2
    );

INSERT INTO #Search(MyDate)VALUES('2005-04-06 08:59:59.9999999');
INSERT INTO #Search(MyDate)VALUES('2005-04-06 09:00:00.0000000');
INSERT INTO #Search(MyDate)VALUES('2005-04-06 09:00:00.9999999');
INSERT INTO #Search(MyDate)VALUES('2005-04-06 16:59:59.9999999');
INSERT INTO #Search(MyDate)VALUES('2005-04-06 17:00:00.0000000');

-- The following SELECT statements show different ways
-- to search for dates that have time values to find a
-- time range.

--Using CONVERT with time (0) to ignore fractional seconds
SELECT MyDate 
FROM #Search 
WHERE CONVERT(time(0),MyDate) = '09:00:00';

--Returns two rows (ignores fractional seconds):
--2005-04-06 08:59:59.9999999
--2005-04-06 09:00:00.0000000

--Using CONVERT with time (7) to include fractional seconds
SELECT MyDate 
FROM #Search 
WHERE CONVERT(time(7),MyDate) = '09:00:00';

--Returns one row (matches fractional seconds):
--2005-04-06 09:00:00.0000000


--Each of the SELECT statements below use CONVERT
--to find all times in an eight-hour period.

--Use CONVERT with >= and <=.
SELECT MyDate 
FROM #Search 
WHERE CONVERT(time(7),MyDate) >=  '09:00:00.0000000'
    AND CONVERT(time(7),MyDate) <= '16:59:59.9999999'

--Use CONVERT with > and <.
SELECT MyDate
FROM #Search
WHERE CONVERT(time(7),MyDate) > '08:59:59.9999999'
    AND CONVERT(time(7),MyDate) < '17:00:00.0000000';

--Use CONVERT with BETWEEN AND
SELECT MyDate
FROM #Search
WHERE CONVERT(time(7),MyDate) BETWEEN '09:00:00.0000000'
    AND '16:59:59.9999999';
DROP TABLE #Search
GO

E. Verwenden von DATEPART und DATEADD, um den ersten und den letzten Tag eines datepart-Werts zu ermitteln

Das folgende Beispiel zeigt, wie Sie den ersten bzw. letzten Tag eines datepart-Werts ermitteln.

-- When several months, quarters, or years are added to the base
-- year,1900-01-01, the returned day is the first day of a month.
-- To calculate the last day of the current month, you need to
--
-- 1. Find the difference in months between today and the base
--    year (0 ='1900-01-01'). This is accomplished by
--
-- DATEDIFF(month, 0, SYSDATETIME())
-- 2. Add that number of months plus 1 to the base year (0)
--    to obtain the first day of the next month.
--    DATEADD(month, DATEDIFF(month, 0, SYSDATETIME()) + 1, 0)
-- 3. Subtract 1 day.
--
--Find the first day of the current month.
SELECT DATEADD(month, DATEDIFF(month, 0, SYSDATETIME()), 0);

--Find the last day of the current month.
SELECT DATEADD(month, DATEDIFF(month, 0, SYSDATETIME()) + 1, 0) - 1;

-- Find the first day of the current quarter.
SELECT DATEADD(quarter, DATEDIFF(quarter, 0, SYSDATETIME()), 0);

-- Find the last day of the current quarter.
SELECT DATEADD(quarter, DATEDIFF(quarter, -1, SYSDATETIME()), -1);

-- Find the first day of the current year.
SELECT DATEADD(year, DATEDIFF(year, 0, SYSDATETIME()), 0);

-- Find the last day of the current year.
SELECT DATEADD(year, DATEDIFF(year, -1, SYSDATETIME()), -1);

F. Verwenden von benutzerdefiniertem datepart-Argumenten für DATEADD, DATEDIFF, DATENAME und DATEPART

Im folgenden Beispiel wird eine benutzerdefinierte Skalarfunktion erstellt, die einem beliebigen Teil eines datetime2-Werts eine Konstante hinzufügt.

USE tempdb
GO
CREATE FUNCTION UserDateadd
    (
    @datepart nvarchar(11)
    ,@number int 
    ,@date datetime2
    )
RETURNS datetime2
AS
BEGIN
    DECLARE @Return datetime2

    SELECT @Return = CASE @datepart
        WHEN 'year' THEN DATEADD(year,@number,@date) 
        WHEN 'yy' THEN DATEADD(year,@number,@date) 
        WHEN 'yyyy' THEN DATEADD(year,@number,@date) 
        WHEN 'quarter' THEN DATEADD(quarter,@number,@date) 
        WHEN 'qq' THEN DATEADD(quarter,@number,@date) 
        WHEN 'month' THEN DATEADD(month,@number,@date) 
        WHEN 'mm' THEN DATEADD(month,@number,@date) 
        WHEN 'm' THEN DATEADD(month,@number,@date) 
        WHEN 'dayofyear' THEN DATEADD(dayofyear,@number,@date) 
        WHEN 'dy' THEN DATEADD(dayofyear,@number,@date) 
        WHEN 'y' THEN DATEADD(dayofyear,@number,@date) 
        WHEN 'day' THEN DATEADD(day,@number,@date) 
        WHEN 'dd' THEN DATEADD(day,@number,@date) 
        WHEN 'd' THEN DATEADD(day,@number,@date) 
        WHEN 'week' THEN DATEADD(week,@number,@date) 
        WHEN 'wk' THEN DATEADD(week,@number,@date) 
        WHEN 'ww' THEN DATEADD(week,@number,@date) 
        WHEN 'weekday' THEN DATEADD(weekday,@number,@date) 
        WHEN 'wk' THEN DATEADD(weekday,@number,@date) 
        WHEN 'w' THEN DATEADD(weekday,@number,@date) 
        WHEN 'hour' THEN DATEADD(hour,@number,@date) 
        WHEN 'hh' THEN DATEADD(hour,@number,@date) 
        WHEN 'minute' THEN DATEADD(minute,@number,@date)
        WHEN 'mi' THEN DATEADD(minute,@number,@date) 
        WHEN 'n' THEN DATEADD(minute,@number,@date)  
        WHEN 'second' THEN DATEADD(second,@number,@date) 
        WHEN 'ss' THEN DATEADD(second,@number,@date)
        WHEN 's' THEN DATEADD(second,@number,@date)
        WHEN 'millisecond' THEN DATEADD(millisecond,@number,@date) 
        WHEN 'ms' THEN DATEADD(millisecond,@number,@date) 
        WHEN 'microsecond' THEN DATEADD(microsecond,@number,@date)
        WHEN 'mcs' THEN DATEADD(microsecond,@number,@date)
        WHEN 'nanosecond' THEN DATEADD(nanosecond,@number,@date)
        WHEN 'ns' THEN DATEADD(nanosecond,@number,@date)
    END
    return @Return
END
GO

SELECT GetDate()
SELECT dbo.UserDateadd('year', 1, GetDate())
GO

G. Verwenden von DATEPART zur Gruppierung nach Datumsteilen

Im folgenden Beispiel wird die Beispieldatenbank AdventureWorks2008R2 verwendet. DATEPART wird verwendet, um Gesamtumsätze nach Wochentag, Monat, Jahr und nach Jahr/Monat/Wochentag zu gruppieren.

USE AdventureWorks2008R2;
GO
SELECT SUM(TotalDue) AS 'Total Sales'
    ,DATEPART(year,OrderDate)AS 'By Year'
    ,DATEPART(month,OrderDate) AS 'By Month'
    ,DATEPART(weekday,OrderDate) AS 'By Weekday'
FROM Sales.SalesOrderHeader
WHERE YEAR(OrderDate) IN('2007','2008')
GROUP BY GROUPING SETS 
    (
     (DATEPART(year,OrderDate))
    ,(DATEPART(month,OrderDate))
    ,(DATEPART(weekday,OrderDate))
    ,(
        DATEPART(year,OrderDate)
        ,DATEPART(month,OrderDate)
        ,DATEPART(weekday,OrderDate))
    )
ORDER BY DATEPART(year,OrderDate)
    ,DATEPART(month,OrderDate)
    ,DATEPART(weekday,OrderDate);