Verwenden von Datums- und Zeitdaten

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

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.

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

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 [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.

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

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. Verwenden Sie vierstellige Jahreszahlen, um Mehrdeutigkeit zu vermeiden.

• 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]

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 wird durch die bei der Anmeldung angegebene Standardsprache oder mithilfe der Anweisungen SET LANGUAGE oder SET DATEFORMAT gesetzt. Wird bei der Anmeldung oder mithilfe der Anweisung SET LANGUAGE die Sprache us_english gewählt, gilt als Standarddatumsformat mdy.

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.

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.

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.

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.

Konvertierungshinweise

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

DECLARE @date date
DECLARE @datetime datetime
SELECT @date = '12-10-25'
SELECT @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)

DECLARE @date date
DECLARE @smalldatetime smalldatetime
SELECT @date = '1912-10-25'
SELECT @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)

DECLARE @date date
DECLARE @datetimeoffset datetimeoffset(3)
SELECT @date = '1912-10-25'
SELECT @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)

DECLARE @date date
DECLARE @datetime2 datetime2(3)
SELECT @date = '1912-10-25'
SELECT @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

DECLARE @timeTo time(3)
DECLARE @timeFrom time(4)
SELECT @timeFrom = '12:34:54.1234'
SELECT @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)

DECLARE @time time(4)
DECLARE @datetime datetime
SELECT @time = '12:15:04.1234'
SELECT @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)

DECLARE @time time(4)
DECLARE @smalldatetime smalldatetime
SELECT @time = '12:15:04.1234'
SELECT @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)

DECLARE @time time(4)
DECLARE @datetimeoffset datetimeoffset(3)
SELECT @time = '12:15:04.1234'
SELECT @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)

DECLARE @time time(4)
DECLARE @datetime2 datetime2(3)
SELECT @time = '12:15:04.1234'
SELECT @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

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

DECLARE @time time(4)
DECLARE @datetime datetime
SELECT @time = '12:10:05.1234'
SELECT @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)

DECLARE @smalldatetime smalldatetime
DECLARE @datetime datetime
SELECT @smalldatetime = '12-01-01 12:32'
SELECT @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)

DECLARE @datetimeoffset datetimeoffset(4)
DECLARE @datetime datetime
SELECT @datetimeoffset = '1968-10-23 12:45:37.1234 +10:0'
SELECT @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)

DECLARE @datetime2 datetime2(4)
DECLARE @datetime datetime
SELECT @datetime2 = '1968-10-23 12:45:37.1237'
SELECT @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

DECLARE @smalldatetime smalldatetime
DECLARE @date date
SELECT @smalldatetime = '1955-12-13 12:43:10'
SELECT @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)

DECLARE @smalldatetime smalldatetime
DECLARE @time time(4)
SELECT @smalldatetime = '1955-12-13 12:43:10'
SELECT @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)

DECLARE @smalldatetime smalldatetime
DECLARE @datetime datetime
SELECT @smalldatetime = '1955-12-13 12:43:10'
SELECT @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)

DECLARE @smalldatetime smalldatetime
DECLARE @datetimeoffset datetimeoffset(4)
SELECT @smalldatetime = '1955-12-13 12:43:10'
SELECT @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)

DECLARE @smalldatetime smalldatetime
DECLARE @datetime2 datetime2(4)
SELECT @smalldatetime = '1955-12-13 12:43:10'
SELECT @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

DECLARE @datetimeoffset datetimeoffset(4)
DECLARE @date date
SELECT @datetimeoffset = '12-10-25 12:32:10 +01:0'
SELECT @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)

DECLARE @datetimeoffset datetimeoffset(4)
DECLARE @time time(3)
SELECT @datetimeoffset = '12-10-25 12:32:10.1234 +01:0'
SELECT @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)

DECLARE @datetimeoffset datetimeoffset(4)
DECLARE @datetime datetime
SELECT @datetimeoffset = '12-10-25 12:32:10.1234 +01:0'
SELECT @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)

DECLARE @datetimeoffset datetimeoffset(3)
DECLARE @smalldatetime smalldatetime
SELECT @datetimeoffset = '1912-10-25 12:24:32 +10:0'
SELECT @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)

DECLARE @datetimeoffset datetimeoffset(4)
DECLARE @datetime2 datetime2(3)
SELECT @datetimeoffset = '1912-10-25 12:24:32.1234 +10:0'
SELECT @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

DECLARE @datetime2 datetime2(4)
DECLARE @date date
SELECT @datetime2 = '12-10-25 12:32:10.1234'
SELECT @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)

DECLARE @datetime2 datetime2(4)
DECLARE @time time(3)
SELECT @datetime2 = '12-10-25 12:32:10.1234'
SELECT @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)

DECLARE @datetime2 datetime2
DECLARE @datetime datetime
SELECT @datetime2 = '12-10-25 12:32:10.1234567'
SELECT @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)

DECLARE @datetime2 datetime2
DECLARE @smalldatetime smalldatetime
SELECT @datetime2 = '12-10-25 12:32:10.1234567'
SELECT @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)

DECLARE @datetime2 datetime2(3)
DECLARE @datetimeoffset datetimeoffset(2)
SELECT @datetime2 = '12-10-25 12:32:10.1234567'
SELECT @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)

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

Konvertierung in 'datetimeoffset'

Konvertierung von 'datetimeoffset'

Informationen, die bei der Konvertierung verloren gehen

Datenkürzung in Konvertierungen

Konvertierung von Sekundenbruchteilen

Stilargumente für die CONVERT-Funktion

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';

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)

• 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

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

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);

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