Suche…


Syntax

  • EOMONTH ( start_date [, month_to_add])

Bemerkungen

Wie in https://msdn.microsoft.com/en-us/library/ms187819.aspx angegeben , sind DateTime s nur auf 3 DateTime genau.

Rundung von datetime Bruchzeit Sekunden Die Präzisions-datetime-Werte werden auf Inkremente von 0,000, 0,003 oder 0,007 Sekunden gerundet, wie in der folgenden Tabelle gezeigt.

Vom Benutzer angegebener Wert Vom System gespeicherter Wert
01/01/98 23: 59: 59,999 1998-01-02 00: 00: 00.000
------ ------
01/01/98 23: 59: 59,995 1998-01-01 23: 59: 59.997
01/01/98 23: 59: 59,996
01/01/98 23: 59: 59,997
01/01/98 23: 59: 59,998
------ ------
01/01/98 23: 59: 59,992 1998-01-01 23: 59: 59,993
01/01/98 23: 59: 59,993
01/01/98 23: 59: 59,994
------ ------
01/01/98 23: 59: 59,990 1998-01-01 23: 59: 59,990
01.01.98 23: 59: 59.991
------ ------

Wenn mehr Genauigkeit erforderlich ist, sollten time , datetime2 oder datetimeoffset verwendet werden.

Datums- und Uhrzeitformatierung mit CONVERT

Sie können die CONVERT-Funktion verwenden, um einen Datetime-Datentyp in eine formatierte Zeichenfolge umzuwandeln.

SELECT GETDATE() AS [Result] -- 2016-07-21 07:56:10.927

Sie können auch einige integrierte Codes verwenden, um in ein bestimmtes Format zu konvertieren. Hier sind die in SQL Server integrierten Optionen:

DECLARE @convert_code INT = 100 -- See Table Below
SELECT CONVERT(VARCHAR(30), GETDATE(), @convert_code) AS [Result]
@convert_code Ergebnis
100 "21. Juli 2016 07:56"
101 "21.07.2016"
102 2016.07.21
103 "21/07/2016"
104 "21.07.2016"
105 21-07-2016
106 "21. Juli 2016"
107 "21. Juli 2016"
108 "07:57:05"
109 "21. Juli 2016 7: 57: 45: 707 Uhr"
110 21.07.2016
111 "2016/07/21"
112 "20160721"
113 "21. Juli 2016 07: 57: 59: 553"
114 07: 57: 59: 553
120 "2016-07-21 07:57:59"
121 2016-07-21 07: 57: 59.553
126 2016-07-21T07: 58: 34.340
127 2016-07-21T07: 58: 34.340
130 16 ???? 1437 7: 58: 34: 340 Uhr
131 16/10/1437 7: 58: 34: 340 Uhr
SELECT GETDATE() AS [Result]                                -- 2016-07-21 07:56:10.927
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),100) AS [Result] -- Jul 21 2016  7:56AM
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),101) AS [Result] -- 07/21/2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),102) AS [Result] -- 2016.07.21
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),103) AS [Result] -- 21/07/2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),104) AS [Result] -- 21.07.2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),105) AS [Result] -- 21-07-2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),106) AS [Result] -- 21 Jul 2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),107) AS [Result] -- Jul 21, 2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),108) AS [Result] -- 07:57:05
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),109) AS [Result] -- Jul 21 2016  7:57:45:707AM
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),110) AS [Result] -- 07-21-2016
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),111) AS [Result] -- 2016/07/21
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),112) AS [Result] -- 20160721
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),113) AS [Result] -- 21 Jul 2016 07:57:59:553
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),114) AS [Result] -- 07:57:59:553
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),120) AS [Result] -- 2016-07-21 07:57:59
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),121) AS [Result] -- 2016-07-21 07:57:59.553
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),126) AS [Result] -- 2016-07-21T07:58:34.340
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),127) AS [Result] -- 2016-07-21T07:58:34.340
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),130) AS [Result] -- 16 ???? 1437  7:58:34:340AM
UNION SELECT CONVERT(VARCHAR(30),GETDATE(),131) AS [Result] -- 16/10/1437  7:58:34:340AM

Datums- und Zeitformatierung mit FORMAT

SQL Server 2012

Sie können die neue Funktion nutzen: FORMAT() .

Damit können Sie Ihre DATETIME Felder in Ihr eigenes VARCHAR Format umwandeln.

Beispiel

DECLARE @Date DATETIME = '2016-09-05 00:01:02.333'

SELECT FORMAT(@Date, N'dddd, MMMM dd, yyyy hh:mm:ss tt')

Montag, 05. September 2016 00:01:02 Uhr

Argumente

Da das DATETIME Format 2016-09-05 00:01:02.333 formatiert ist, zeigt das folgende Diagramm, welche Ausgabe es für das angegebene Argument geben würde.

Streit Ausgabe
yyyy 2016
yy 16
MMMM September
MM 09
M 9
dddd Montag
ddd Mo
dd 05
d 5
HH 00
H 0
hh 12
h 12
mm 01
m 1
ss 02
s 2
tt AM
t EIN
F f f 333
ff 33
f 3

Sie können der Funktion FORMAT() auch ein einzelnes Argument FORMAT() , um eine FORMAT() Ausgabe zu generieren:

DECLARE @Date DATETIME = '2016-09-05 00:01:02.333'

SELECT FORMAT(@Date, N'U')

Montag, 05. September 2016 04:01:02 Uhr

Einzelargument Ausgabe
D Montag, 05. September 2016
d 9/5/2016
F Montag, 05. September 2016 00:01:02 Uhr
f Montag, 05. September 2016, 12:01 Uhr
G 05.09.2016 12:01:02 Uhr
G 05.09.2016 12:01 Uhr
M September 05
O 2016-09-05T00: 01: 02.3330000
R Mo, 05 Sep 2016 00:01:02 GMT
s 2016-09-05T00: 01: 02
T 12:01:02 Uhr
t 12:01 Uhr
U Montag, 05. September 2016 04:01:02 Uhr
u 2016-09-05 00: 01: 02Z
Y September 2016

Hinweis: Die obige Liste verwendet die en-US Kultur. Über den dritten Parameter kann eine andere Kultur für FORMAT() angegeben werden:

DECLARE @Date DATETIME = '2016-09-05 00:01:02.333'

SELECT FORMAT(@Date, N'U', 'zh-cn')

2016 年 9 月 5 日 4:01:02

Holen Sie sich die aktuelle DateTime

Die eingebauten Funktionen GETDATE und GETUTCDATE jeweils das aktuelle Datum und die aktuelle Uhrzeit ohne Zeitzonenversatz zurück.

Der Rückgabewert beider Funktionen basiert auf dem Betriebssystem des Computers, auf dem die Instanz von SQL Server ausgeführt wird.

Der Rückgabewert von GETDATE repräsentiert die aktuelle Uhrzeit in derselben Zeitzone wie das Betriebssystem. Der Rückgabewert von GETUTCDATE repräsentiert die aktuelle UTC-Zeit.

Jede Funktion kann in der SELECT Klausel einer Abfrage oder als Teil eines booleschen Ausdrucks in der WHERE Klausel enthalten sein.

Beispiele:

-- example query that selects the current time in both the server time zone and UTC
SELECT GETDATE() as SystemDateTime, GETUTCDATE() as UTCDateTime

-- example query records with EventDate in the past.
SELECT * FROM MyEvents WHERE EventDate < GETDATE() 

Es gibt ein paar andere integrierte Funktionen, die verschiedene Variationen des aktuellen Datums und der Uhrzeit anzeigen:

SELECT 
    GETDATE(),          --2016-07-21 14:27:37.447
    GETUTCDATE(),       --2016-07-21 18:27:37.447
    CURRENT_TIMESTAMP,  --2016-07-21 14:27:37.447
    SYSDATETIME(),      --2016-07-21 14:27:37.4485768
    SYSDATETIMEOFFSET(),--2016-07-21 14:27:37.4485768 -04:00
    SYSUTCDATETIME()    --2016-07-21 18:27:37.4485768

DATEADD zum Hinzufügen und Entfernen von Zeiträumen

Allgemeine Syntax:

DATEADD (datepart , number , datetime_expr)  

Um ein Zeitmaß hinzuzufügen, muss die number positiv sein. Um ein Zeitmaß abzuziehen, muss die number negativ sein.

Beispiele

DECLARE @now DATETIME2 = GETDATE();
SELECT @now;                        --2016-07-21 14:39:46.4170000
SELECT DATEADD(YEAR, 1, @now)       --2017-07-21 14:39:46.4170000
SELECT DATEADD(QUARTER, 1, @now)    --2016-10-21 14:39:46.4170000
SELECT DATEADD(WEEK, 1, @now)       --2016-07-28 14:39:46.4170000
SELECT DATEADD(DAY, 1, @now)        --2016-07-22 14:39:46.4170000
SELECT DATEADD(HOUR, 1, @now)       --2016-07-21 15:39:46.4170000
SELECT DATEADD(MINUTE, 1, @now)     --2016-07-21 14:40:46.4170000
SELECT DATEADD(SECOND, 1, @now)     --2016-07-21 14:39:47.4170000
SELECT DATEADD(MILLISECOND, 1, @now)--2016-07-21 14:39:46.4180000

DATEADD : DATEADD akzeptiert auch Abkürzungen im Parameter datepart . Die Verwendung dieser Abkürzungen wird im Allgemeinen nicht empfohlen, da sie verwirrend sein können ( m vs mi , ww vs w usw.).

Datum Teile Referenz

Dies sind die datepart , die für Datums- und datepart verfügbar sind:

Datumsteil Abkürzungen
Jahr yy, yyyy
Quartal qq, q
Monat mm, m
Tag des Jahres dy, y
Tag dd, d
Woche wk, ww
Wochentag dw, w
Stunde hh
Minute Mindest
zweite ss, s
Millisekunde Frau
Mikrosekunde mcs
Nanosekunde ns

HINWEIS : Die Verwendung von Abkürzungen wird im Allgemeinen nicht empfohlen, da sie verwirrend sein können ( m vs mi , ww vs w usw.). Die Langversion der datepart Darstellung datepart für Klarheit und Lesbarkeit und sollte nach Möglichkeit verwendet werden ( month , minute , week , weekday usw.).

DATEDIFF zur Berechnung von Zeitdifferenzen

Allgemeine Syntax:

DATEDIFF (datepart, datetime_expr1, datetime_expr2)

Es wird eine positive Zahl zurückgegeben, wenn datetime_expr relativ zu datetime_expr2 in der Vergangenheit datetime_expr2 , ansonsten eine negative Zahl.

Beispiele

DECLARE @now DATETIME2 = GETDATE();
DECLARE @oneYearAgo DATETIME2 = DATEADD(YEAR, -1, @now);
SELECT @now                                    --2016-07-21 14:49:50.9800000
SELECT @oneYearAgo                             --2015-07-21 14:49:50.9800000
SELECT DATEDIFF(YEAR, @oneYearAgo, @now)       --1
SELECT DATEDIFF(QUARTER, @oneYearAgo, @now)    --4
SELECT DATEDIFF(WEEK, @oneYearAgo, @now)       --52
SELECT DATEDIFF(DAY, @oneYearAgo, @now)        --366
SELECT DATEDIFF(HOUR, @oneYearAgo, @now)       --8784
SELECT DATEDIFF(MINUTE, @oneYearAgo, @now)     --527040
SELECT DATEDIFF(SECOND, @oneYearAgo, @now)     --31622400

DATEDIFF : DATEDIFF akzeptiert auch Abkürzungen im Parameter datepart . Die Verwendung dieser Abkürzungen wird im Allgemeinen nicht empfohlen, da sie verwirrend sein können ( m vs mi , ww vs w usw.).

DATEDIFF kann auch verwendet werden, um den Versatz zwischen UTC und der lokalen Zeit des SQL-Servers zu bestimmen. Mit der folgenden Anweisung kann der Versatz zwischen UTC und lokaler Zeit (einschließlich Zeitzone) berechnet werden.

select  DATEDIFF(hh, getutcdate(), getdate()) as 'CentralTimeOffset'

DATEPART & DATENAME

DATEPART gibt den angegebenen datepart des angegebenen Datetime-Ausdrucks als numerischen Wert zurück.

DATENAME gibt eine Zeichenfolge zurück, die den angegebenen datepart des angegebenen Datums darstellt. In der Praxis ist DATENAME meistens nützlich, um den Namen des Monats oder des Wochentags DATENAME .

Es gibt auch einige Abkürzungsfunktionen, um das Jahr, den Monat oder den Tag eines datetime-Ausdrucks abzurufen, die sich wie DATEPART mit ihren jeweiligen datepart Einheiten verhalten.

Syntax:

DATEPART ( datepart , datetime_expr )
DATENAME ( datepart , datetime_expr )
DAY ( datetime_expr )
MONTH ( datetime_expr )
YEAR ( datetime_expr )

Beispiele:

DECLARE @now DATETIME2 = GETDATE();
SELECT @now                       --2016-07-21 15:05:33.8370000
SELECT DATEPART(YEAR, @now)       --2016
SELECT DATEPART(QUARTER, @now)    --3
SELECT DATEPART(WEEK, @now)       --30
SELECT DATEPART(HOUR, @now)       --15
SELECT DATEPART(MINUTE, @now)     --5
SELECT DATEPART(SECOND, @now)     --33
-- Differences between DATEPART and DATENAME:
SELECT DATEPART(MONTH, @now)      --7
SELECT DATENAME(MONTH, @now)      --July
SELECT DATEPART(WEEKDAY, @now)    --5
SELECT DATENAME(WEEKDAY, @now)    --Thursday
--shorthand functions
SELECT DAY(@now)    --21
SELECT MONTH(@now)  --7
SELECT YEAR(@now)   --2016

DATEPART : DATEPART und DATENAME akzeptieren auch Abkürzungen im Parameter datepart . Die Verwendung dieser Abkürzungen wird im Allgemeinen nicht empfohlen, da sie verwirrend sein können ( m vs mi , ww vs w usw.).

Den letzten Tag eines Monats bekommen

Mit den Funktionen DATEADD und DATEDIFF kann das letzte Datum eines Monats zurückgegeben werden.

SELECT DATEADD(d, -1, DATEADD(m, DATEDIFF(m, 0, '2016-09-23') + 1, 0))
-- 2016-09-30 00:00:00.000
SQL Server 2012

Die EOMONTH Funktion bietet eine EOMONTH Möglichkeit, das letzte Datum eines Monats zurückzugeben, und verfügt über einen optionalen Parameter zum Versetzen des Monats.

SELECT EOMONTH('2016-07-21')        --2016-07-31
SELECT EOMONTH('2016-07-21', 4)     --2016-11-30
SELECT EOMONTH('2016-07-21', -5)    --2016-02-29

Nur Datum aus einer DateTime zurückgeben

Es gibt viele Möglichkeiten, ein Date aus einem DateTime-Objekt zurückzugeben

  1. SELECT CONVERT(Date, GETDATE())
  2. SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE())) gibt 2016-07-21 00: 00: 00.000 zurück
  3. SELECT CAST(GETDATE() AS DATE)
  4. SELECT CONVERT(CHAR(10),GETDATE(),111)
  5. SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')

Beachten Sie, dass die Optionen 4 und 5 eine Zeichenfolge und kein Datum zurückgeben.

Funktion erstellen, um das Alter einer Person an einem bestimmten Datum zu berechnen

Diese Funktion benötigt zwei datetime-Parameter, das DOB und ein Datum, um das Alter bei zu überprüfen

  CREATE FUNCTION [dbo].[Calc_Age]
    (
    @DOB datetime , @calcDate datetime 
    )
    RETURNS int
    AS
   BEGIN
declare @age int

IF (@calcDate < @DOB  )
RETURN -1

-- If a DOB is supplied after the comparison date, then return -1
SELECT @age = YEAR(@calcDate) - YEAR(@DOB) +
  CASE WHEN DATEADD(year,YEAR(@calcDate) - YEAR(@DOB)
  ,@DOB) > @calcDate THEN -1 ELSE 0 END
    

RETURN @age
    

END

B. um das Alter einer am 01.01.2000 geborenen Person zu überprüfen

SELECT  dbo.Calc_Age('2000-01-01',Getdate())

CROSS PLATFORM DATE OBJECT

SQL Server 2012

In Transact SQL können Sie ein Objekt als Date (oder DateTime ) definieren, indem Sie die Funktion [DATEFROMPARTS][1] (oder [DATETIMEFROMPARTS][1] ) wie folgt verwenden:

 DECLARE @myDate DATE=DATEFROMPARTS(1988,11,28) 
 DECLARE @someMoment DATETIME=DATEFROMPARTS(1988,11,28,10,30,50,123)

Die von Ihnen angegebenen Parameter sind Jahr, Monat, Tag für die Funktion DATEFROMPARTS und für die Funktion DATETIMEFROMPARTS müssen Sie Jahr, Monat, Tag, Stunde, Minuten, Sekunden und Millisekunden DATETIMEFROMPARTS .

Diese Methoden sind nützlich und sollten verwendet werden, da die Verwendung der einfachen Zeichenfolge zum Erstellen eines Datums (oder einer Datumszeit) je nach Region, Speicherort oder Datumsformat des Host-Computers fehlschlagen kann.

Datumsformat erweitert

Datumsformat SQL-Anweisung Beispielausgabe
JJ-MM-TT WÄHLEN SIE RECHTS (CONVERT (VARCHAR (10), SYSDATETIME (), 20), 8) AS [JJ-MM-TT]
SELECT REPLACE (KONVERTIEREN (VARCHAR (8), SYSDATETIME (), 11), '/', '-') AS [JJ-MM-TT]
11-06-08
JJJJ-MM-TT SELECT CONVERT (VARCHAR (10), SYSDATETIME (), 120) ALS [JJJJ-MM-TT]
SELECT REPLACE (KONVERTIEREN (VARCHAR (10), SYSDATETIME (), 111), '/', '-') AS [JJJJ-MM-TT]
2011-06-08
JJJJ-MD WÄHLEN SIE CAST (JAHR (SYSDATETIME ()) AS VARCHAR (4)) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (TAG (SYSDATETIME ()) AS VARCHAR ( 2)) AS [JJJJ-MD] 2011-6-8
YY-MD WÄHLEN SIE RECHT (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (TAG (SYSDATETIME ( )) AS VARCHAR (2)) AS [YY-MD] 11-6-8
MD-JJJJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (JAHR (SYSDATETIME ()) AS VARCHAR ( 4)) AS [MD-JJJJ] 6-8-2011
MD-YY WÄHLEN SIE CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '-' + RECHTS (CAST (YEAR (SYSDATETIME () AS) VARCHAR (4)), 2) AS [MD-YY] 6-8-11
DM-JJJJ SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (JAHR (SYSDATETIME ()) AS VARCHAR ( 4)) AS [DM-JJJJ] 8-6-2011
DM-JJ WÄHLEN SIE CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + RECHTS (CAST (YEAR (SYSDATETIME () AS)) VARCHAR (4)), 2) AS [DM-YY] 8-6-11
JJ-MM WÄHLEN SIE RECHTS (CONVERT (VARCHAR (7), SYSDATETIME (), 20), 5) AS [JJ-MM]
SUBSTRING WÄHLEN (CONVERT (VARCHAR (10), SYSDATETIME (), 120), 3, 5) AS [JJ-MM]
11-06
JJJJ-MM SELECT CONVERT (VARCHAR (7), SYSDATETIME (), 120) ALS [JJJJ-MM] 2011-06
YY-M WÄHLEN SIE RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '-' + CAST (MONAT (SYSDATETIME ()) ALS VARCHAR (2)) AS [YY-M] 11-6
JJJJ-M SELECT CAST (JAHR (SYSDATETIME ()) AS VARCHAR (4)) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) ALS [JJJJ-M] 2011-6
MM-JJ WÄHLEN SIE RECHTS (CONVERT (VARCHAR (8), SYSDATETIME (), 5), 5) AS [MM-JJ]
SELECT SUBSTRING (CONVERT (VARCHAR (8), SYSDATETIME (), 5), 4, 5) AS [MM-YY]
06-11
MM-JJJJ WÄHLEN SIE RECHTS (CONVERT (VARCHAR (10), SYSDATETIME (), 105), 7) ALS [MM-JJJJ] 06-2011
M-JJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + RECHTS (CAST (JAHR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [M-YY] 6-11
M-JJJJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) ALS [M-JJJJ] 6-2011
MM-DD SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 10) AS [MM-DD] 06-08
DD-MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 5) AS [DD-MM] 08-06
MD SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) AS [MD] 6-8
DM SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) AS [DM] 8-6
M / T / JJJJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (JAHR (SYSDATETIME ()) AS VARCHAR ( 4)) AS [M / T / JJJJ] 08.06.2011
M / T / JJ WÄHLEN SIE CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + RECHTS (CAST (YEAR (SYSDATETIME () AS) VARCHAR (4)), 2) AS [M / T / JJ] 6/8/11
D / M / JJJJ SELECT CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (JAHR (SYSDATETIME ()) AS VARCHAR ( 4)) AS [D / M / JJJJ] 8/6/2011
D / M / YY WÄHLEN SIE CAST (TAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + RECHTS (CAST (YEAR (SYSDATETIME () AS)) VARCHAR (4)), 2) AS [D / M / YY] 8/6/11
JJJJ / M / D SELECT CAST (JAHR (SYSDATETIME ()) AS VARCHAR (4)) + '/' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (TAG (SYSDATETIME ()) AS VARCHAR ( 2)) AS [JJJJ / M / D] 2011/6/8
JJ / M / T WÄHLEN SIE RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '/' + CAST (MONAT (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (TAG (SYSDATETIME ( )) AS VARCHAR (2)) AS [JJ / M / T] 11/6/8
MM / JJ WÄHLEN SIE RECHTS (CONVERT (VARCHAR (8), SYSDATETIME (), 3), 5) AS [MM / YY] 06/11
MM / JJJJ WÄHLEN SIE RECHTS (CONVERT (VARCHAR (10), SYSDATETIME (), 103), 7) AS [MM / JJJJ] 06/2011
M / JJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + RECHTS (CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [M / YY] 6/11
M / JJJJ SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) ALS [M / JJJJ] 6/2011
JJ / MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 11) ALS [JJ / MM] 11/06
JJJJ / MM SELECT CONVERT (VARCHAR (7), SYSDATETIME (), 111) ALS [JJJJ / MM] 2011/06
JJ / M WÄHLEN SIE RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '/' + CAST (MONAT (SYSDATETIME ()) ALS VARCHAR (2)) AS [JJ / M] 11/6
JJJJ / M SELECT CAST (JAHR (SYSDATETIME ()) AS VARCHAR (4)) + '/' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) ALS [JJJJ / M] 2011/6
MM / DD SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 1) AS [MM / DD] 06/08
DD / MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 3) AS [DD / MM] 08/06
M / D SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) AS [M / D] 6/8
DM SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) AS [D / M] 8/6
MM.DD.YYYY SELECT REPLACE (KONVERTIEREN (VARCHAR (10), SYSDATETIME (), 101), '/', '.') AS [MM.DD.YYYY] 06.08.2011
MM.DD.YY SELECT REPLACE (CONVERT (VARCHAR (8), SYSDATETIME (), 1), '/', '.') AS [MM.DD.YY] 06.08.11
MDYYYY SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) ALS [MDYYYY] 6.8.2011
MDYY SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '.' + RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) ALS [MDYY] 6.8.11
DD / MM / JJJJ SELECT CONVERT (VARCHAR (10), SYSDATETIME (), 104) AS [DD.MM.YYYY] 08.06.2011
TT.MM.JJ SELECT CONVERT (VARCHAR (10), SYSDATETIME (), 4) AS [DD.MM.YY] 08.06.11
DMYYYY SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) ALS [DMYYYY] 8.6.2011
DMYY SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) ALS [DMYY] 8.6.11
JJJJ.MD SELECT CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) + '.' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) ALS [JJJJ.MD] 2011.6.8
YY.MD WÄHLEN SIE RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '.' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) AS [YY.MD] 11.6.8
MM.JJJJ WÄHLEN SIE RECHTS (CONVERT (VARCHAR (10), SYSDATETIME (), 104), 7) AS [MM.YYYY] 06.2011
MM.YY WÄHLEN SIE RECHTS (CONVERT (VARCHAR (8), SYSDATETIME (), 4), 5) AS [MM.YY] 06.11
M.YYYY SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)) ALS [M.YYYY] 6.2011
M.YY SELECT CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) + '.' + RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) ALS [M.YY] 6.11
JJJJ.MM SELECT CONVERT (VARCHAR (7), SYSDATETIME (), 102) ALS [JJJJ.MM] 2011.06
YY.MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 2) AS [YY.MM] 11.06
JJJJ.M SELECT CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)) + '.' + CAST (MONAT (SYSDATETIME ()) ALS VARCHAR (2)) ALS [JJJJ.M] 2011.6
YY.M WÄHLEN SIE RECHTS (CAST (JAHR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '.' + CAST (MONAT (SYSDATETIME ()) AS VARCHAR (2)) AS [JJ.M] 11.6
MM.DD SELECT RIGHT (CONVERT (VARCHAR (8), SYSDATETIME (), 2), 5) AS [MM.DD] 06.08
DD.MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 4) AS [DD.MM] 08.06
MMDDYYYY SELECT REPLACE (KONVERTIEREN (VARCHAR (10), SYSDATETIME (), 101), '/', '') AS [MMDDYYYY] 06082011
MMDDYY SELECT REPLACE (CONVERT (VARCHAR (8), SYSDATETIME (), 1), '/', '') AS [MMDDYY] 060811
DD / MM / JJJJ SELECT REPLACE (CONVERT (VARCHAR (10), SYSDATETIME (), 103), '/', '') AS [DDMMYYYY] 08062011
DDMMYY SELECT REPLACE (CONVERT (VARCHAR (8), SYSDATETIME (), 3), '/', '') AS [DDMMYY] 080611
MMYYYY WÄHLEN SIE RECHTS (REPLACE (CONVERT (VARCHAR (10), SYSDATETIME (), 103), '/', ''), 6) AS [MMYYYY] 062011
MMYY WÄHLEN SIE RECHTS (REPLACE (CONVERT (VARCHAR (8), SYSDATETIME (), 3), '/', ''), 4) AS [MMYY] 0611
JJJJMM SELECT CONVERT (VARCHAR (6), SYSDATETIME (), 112) ALS [JJJJMM] 201106
YYMM SELECT CONVERT (VARCHAR (4), SYSDATETIME (), 12) ALS [JJMM] 1106
Monat TT, JJJJ SELECT DATENAME (MONAT, SYSDATETIME ()) + '' + RIGHT ('0' + DATENAME (DAY, SYSDATETIME ()), 2) + ',' + DATENAME (YEAR, SYSDATETIME ()) AS [Monat DD, YYYY] 8. Juni 2011
Mo JJJJ SELECT LINKS (DATENAME (MONAT, SYSDATETIME ()), 3) + '' + DATENAME (YEAR, SYSDATETIME ()) AS [Mon YYYY] Juni 2011
Monat JJJJ SELECT DATENAME (MONAT, SYSDATETIME ()) + '' + DATENAME (YEAR, SYSDATETIME ()) AS [Monat JJJJ] Juni 2011
DD Monat SELECT RIGHT ('0' + DATENAME (DAY, SYSDATETIME ()), 2) + '' + DATENAME (MONTH, SYSDATETIME ()) AS [DD Month] 08. Juni
Monat DD SELECT DATENAME (MONAT, SYSDATETIME ()) + '' + RIGHT ('0' + DATENAME (DAY, SYSDATETIME ()), 2) AS [Month DD] 08. Juni
TT Monat JJ SELECT CAST (DAY (SYSDATETIME ()) AS VARCHAR (2)) + '' + DATENAME (MM, SYSDATETIME ()) + '' + RECHTS (CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [TT Monat JJ] 08. Juni
TT Monat JJJJ WÄHLEN SIE RECHTS ('0' + DATENAME (DAY, SYSDATETIME ()), 2) + '' + DATENAME (MONAT, SYSDATETIME ()) + '' + DATENAME (YEAR, SYSDATETIME ()) AS [DD Monat JJJJ] 08. Juni 2011
Mo-JJ SELECT ERSETZEN (RECHTS (CONVERT (VARCHAR (9), SYSDATETIME (), 6), 6), '', '-') AS [Mon-YY] 08-Jun
Mo-JJJJ SELECT ERSETZEN (RECHTS (CONVERT (VARCHAR (11), SYSDATETIME (), 106), 8), '', '-') AS [Mon-YYYY] Jun-2011
DD-Mo-JJ SELECT REPLACE (KONVERTIEREN (VARCHAR (9), SYSDATETIME (), 6), '', '-') AS [DD-Mo-YY] 08-Jun-11
TT-Mo-JJJJ SELECT REPLACE (KONVERTIEREN (VARCHAR (11), SYSDATETIME (), 106), '', '-') AS [DD-Mo-JJJJ] 08-Jun-2011


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow