Zoeken…


Syntaxis

  • EOMONTH ( startdatum [, month_to_add])

Opmerkingen

volgens https://msdn.microsoft.com/en-us/library/ms187819.aspx zijn DateTime s slechts nauwkeurig tot 3ms.

Afronding van datetime Fractionele seconde Precisie datetime-waarden worden afgerond op stappen van .000, .003 of .007 seconden, zoals weergegeven in de volgende tabel.

Door de gebruiker opgegeven waarde Systeem opgeslagen waarde
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
------ ------

Als meer precisie vereist is, moet time , datetime2 of datetimeoffset worden gebruikt.

Datum- en tijdnotatie met CONVERT

U kunt de CONVERT-functie gebruiken om een datetime-gegevenstype naar een opgemaakte tekenreeks te casten.

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

U kunt ook enkele ingebouwde codes gebruiken om te converteren naar een specifiek formaat. Hier zijn de opties ingebouwd in SQL Server:

DECLARE @convert_code INT = 100 -- See Table Below
SELECT CONVERT(VARCHAR(30), GETDATE(), @convert_code) AS [Result]
@convert_code Resultaat
100 "21 jul. 2016 07:56 uur"
101 "2016/07/21"
102 "2016/07/21"
103 "21/07/2016"
104 "2016/07/21"
105 "21-07-2016"
106 "21 jul. 2016"
107 "21 jul. 2016"
108 "07:57:05"
109 "21 jul 2016 7: 57: 45: 707AM"
110 "2016/07/21"
111 "2016/07/21"
112 "20160721"
113 "21 jul 2016 07: 57: 59: 553"
114 "07: 57: 59: 553"
120 "21-07-2016 07:57:59"
121 "21-07-2016 07: 57: 59.553"
126 "2016-07-21T07: 58: 34,340"
127 "2016-07-21T07: 58: 34,340"
130 "16 ???? 1437 7: 58: 34: 340AM"
131 "16/10/1437 7: 58: 34: 340AM"
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

Datum- en tijdnotatie met FORMAT

SQL Server 2012

U kunt de nieuwe functie gebruiken: FORMAT() .

Hiermee kunt u uw DATETIME velden transformeren naar uw eigen aangepaste VARCHAR indeling.

Voorbeeld

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

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

Maandag 5 september 2016 12:01:02 AM

argumenten

Gezien de DATETIME wordt opgemaakt is 2016-09-05 00:01:02.333 , de volgende grafiek laat zien wat hun output zou zijn voor het gegeven argument.

Argument uitgang
yyyy 2016
yy 16
MMMM september
MM 09
M 9
dddd maandag
ddd ma
dd 05
d 5
HH 00
H 0
hh 12
h 12
mm 01
m 1
ss 02
s 2
tt AM
t EEN
fff 333
ff 33
f 3

U kunt ook een enkel argument opgeven voor de functie FORMAT() om een vooraf opgemaakte uitvoer te genereren:

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

SELECT FORMAT(@Date, N'U')

Maandag 5 september 2016 4:01:02 AM

Eén argument uitgang
D Maandag 5 september 2016
d 2016/09/05
F Maandag 5 september 2016 12:01:02 AM
f Maandag 5 september 2016 12:01 AM
G 9/5/2016 12:01:02 AM
g 9/5/2016 12:01 AM
M 5 september
O 2016-09-05T00: 01: 02,3330000
R Maa, 05 Sep 2016 00:01:02 GMT
s 2016-09-05T00: 01: 02
T 12:01:02 uur
t 12:01 uur
U Maandag 5 september 2016 4:01:02 AM
u 2016-09-05 00: 01: 02Z
Y September 2016

Opmerking: de bovenstaande lijst gebruikt de en-US cultuur. Een andere cultuur kan worden opgegeven voor FORMAT() via de derde parameter:

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

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

2016 年 9 月 5 日 4:01:02

Download de huidige DateTime

De ingebouwde functies GETDATE en GETUTCDATE elk de huidige datum en tijd zonder tijdzone-offset.

De retourwaarde van beide functies is gebaseerd op het besturingssysteem van de computer waarop het exemplaar van SQL Server wordt uitgevoerd.

De retourwaarde van GETDATE vertegenwoordigt de huidige tijd in dezelfde tijdzone als het besturingssysteem. De retourwaarde van GETUTCDATE vertegenwoordigt de huidige UTC-tijd.

Beide functies kunnen worden opgenomen in de SELECT component van een query of als onderdeel van de Booleaanse expressie in de WHERE component.

Voorbeelden:

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

Er zijn een paar andere ingebouwde functies die verschillende variaties van de huidige datum-tijd teruggeven:

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 voor het optellen en aftrekken van tijdsperioden

Algemene syntaxis:

DATEADD (datepart , number , datetime_expr)  

Om een tijdmaat toe te voegen, moet het number positief zijn. Om een tijdmaat af te trekken, moet het number negatief zijn.

Voorbeelden

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

OPMERKING: DATEADD accepteert ook afkortingen in de parameter datepart . Het gebruik van deze afkortingen wordt over het algemeen afgeraden omdat ze verwarrend kunnen zijn ( m vs mi , ww vs w , etc.).

Datum onderdelen referentie

Dit zijn de waarden van het datepart die beschikbaar zijn voor datum- en tijdfuncties:

datepart afkortingen
jaar jjjjjjjjjjjjjj
kwartaal qq, q
maand mm, m
DAYOFYEAR dy, y
dag dd, d
week wk, ww
weekdag dw, w
uur hh
minuut mi, n
tweede ss, s
milliseconde Mevrouw
microseconde mcs
nanoseconde NS

OPMERKING : het gebruik van afkortingen wordt over het algemeen afgeraden omdat ze verwarrend kunnen zijn ( m vs mi , ww vs w , etc.). De lange versie van de weergave van datepart bevordert de duidelijkheid en leesbaarheid en moet waar mogelijk worden gebruikt ( month , minute , week , weekday , enz.).

DATEDIFF voor het berekenen van verschillen in tijdsperiode

Algemene syntaxis:

DATEDIFF (datepart, datetime_expr1, datetime_expr2)

Het retourneert een positief getal als datetime_expr in het verleden is ten opzichte van datetime_expr2 , en anders een negatief getal.

Voorbeelden

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

OPMERKING: DATEDIFF accepteert ook afkortingen in de parameter datepart . Het gebruik van deze afkortingen wordt over het algemeen afgeraden omdat ze verwarrend kunnen zijn ( m vs mi , ww vs w , etc.).

DATEDIFF kan ook worden gebruikt om de offset tussen UTC en de lokale tijd van de SQL Server te bepalen. De volgende instructie kan worden gebruikt om de offset tussen UTC en lokale tijd (inclusief tijdzone) te berekenen.

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

DATEPART & DATENAME

DATEPART retourneert het opgegeven datepart van de opgegeven datetime-expressie als een numerieke waarde.

DATENAME retourneert een tekenreeks die het opgegeven datepart van de opgegeven datum vertegenwoordigt. In de praktijk is DATENAME vooral handig om de naam van de maand of de dag van de week te DATENAME .

Er zijn ook enkele steno-functies om het jaar, de maand of de dag van een datetime-expressie te krijgen, die zich gedragen als DATEPART met hun respectieve datepart eenheden.

Syntaxis:

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

Voorbeelden:

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

OPMERKING: DATEPART en DATENAME accepteren ook afkortingen in de parameter datepart . Het gebruik van deze afkortingen wordt over het algemeen afgeraden omdat ze verwarrend kunnen zijn ( m vs mi , ww vs w , etc.).

De laatste dag van een maand krijgen

Met de functies DATEADD en DATEDIFF is het mogelijk om de laatste datum van een maand te retourneren.

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

De EOMONTH functie biedt een meer beknopte manier om de laatste datum van een maand te retourneren en heeft een optionele parameter om de maand te compenseren.

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

Retourneer alleen Datum van een datum / tijd

Er zijn veel manieren om een datum uit een DateTime-object te retourneren

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

Merk op dat opties 4 en 5 een tekenreeks retourneren, geen datum.

Maak een functie om de leeftijd van een persoon op een specifieke datum te berekenen

Voor deze functie zijn 2 datetime-parameters, de DOB en een datum nodig om de leeftijd te controleren

  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

bijv. om vandaag de leeftijd te controleren van iemand geboren op 1/1/2000

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

DATUMOVERZICHT VAN CROSS-PLATFORM

SQL Server 2012

In Transact SQL kunt u een object als Date (of DateTime ) definiëren met behulp van de functie [DATEFROMPARTS][1] (of [DATETIMEFROMPARTS][1] ) als volgt:

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

De parameters die u opgeeft zijn Jaar, Maand, Dag voor de functie DATEFROMPARTS en voor de functie DATETIMEFROMPARTS moet u jaar, maand, dag, uur, minuten, seconden en milliseconden opgeven.

Deze methoden zijn nuttig en de moeite waard om te worden gebruikt, omdat het gebruik van de gewone tekenreeks om een datum (of datetime) op te bouwen mogelijk mislukt, afhankelijk van de regio van de hostmachine, de locatie of de datumnotatie.

Datumnotatie verlengd

Datumnotatie SQL-verklaring Voorbeelduitvoer
YY-MM-DD SELECTEER RECHTS (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 20), 8) AS [YY-MM-DD]
SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 11), '/', '-') AS [YY-MM-DD]
11-06-08
YYYY-MM-DD SELECTEER CONVERTEREN (VARCHAR (10), SYSDATETIME (), 120) ALS [JJJJ-MM-DD]
SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 111), '/', '-') ALS [JJJJ-MM-DD]
2011-06-08
YYYY-MD SELECTEER CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '-' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (DAG (SYSDATETIME ()) AS VARCHAR ( 2)) ALS [JJJJ-MD] 2011/06/08
YY-MD SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '-' + CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (DAG (SYSDATETIME ( )) AS VARCHAR (2)) AS [YY-MD] 11-6-8
MD-YYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR ( 4)) ALS [MD-JJJJ] 2011/06/08
MD-YY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) + '-' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [MD-YY] 6-8-11
DM-YYYY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '-' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR ( 4)) ALS [DM-JJJJ] 8-6-2011
DM-YY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '-' + RECHTS (CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [DM-YY] 8-6-11
YY-MM SELECTEER RECHTS (CONVERTEREN (VARCHAR (7), SYSDATETIME (), 20), 5) ALS [JJ-MM]
SELECTEER SUBSTRING (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 120), 3, 5) ALS [JJ-MM]
11-06
YYYY-MM SELECTEER CONVERTEREN (VARCHAR (7), SYSDATETIME (), 120) ALS [JJJJ-MM] 2011-06
YY-M SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '-' + CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) AS [YY-M] 11-6
YYYY-M SELECTEER CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '-' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [YYYY-M] 2011-6
MM-JJ SELECTEER RECHTS (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 5), 5) AS [MM-JJ]
SELECTEER SUBSTRING (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 5), 4, 5) AS [MM-JJ]
06-11
MM-YYYY SELECTEER RECHTS (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 105), 7) ALS [MM-JJJJ] 06-2011
M-JJ SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) AS [M-JJ] 6-11
M-YYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)) ALS [M-JJJJ] 6-2011
MM-DD SELECTEER CONVERTEREN (VARCHAR (5), SYSDATETIME (), 10) AS [MM-DD] 06-08
DD-MM SELECTEER CONVERTEREN (VARCHAR (5), SYSDATETIME (), 5) AS [DD-MM] 08-06
MD SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) AS [MD] 6-8
DM SELECT CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '-' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [DM] 8-6
M / D / YYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR ( 4)) ALS [M / D / JJJJ] 6/8/2011
M / D / YY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) + '/' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [M / D / JJ] 6/8/11
D / M / YYYY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR ( 4)) ALS [D / M / JJJJ] 8/6/2011
D / M / YY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '/' + RECHTS (CAST (YEAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [D / M / JJ] 8/6/11
YYYY / M / D KIES CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '/' + CAST (DAG (SYSDATETIME ()) AS VARCHAR ( 2)) ALS [JJJJ / M / D] 2011/06/08
YY / M / D SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '/' + CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (DAG (SYSDATETIME ( )) AS VARCHAR (2)) AS [JJ / M / D] 11/6/8
MM / JJ SELECTEER RECHTS (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 3), 5) AS [MM / JJ] 06/11
MM / YYYY SELECTEER RECHTS (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 103), 7) AS [MM / JJJJ] 06/2011
M / YY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) AS [M / JJ] 6/11
M / YYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)) AS [M / JJJJ] 6/2011
JJ / MM SELECTEER CONVERTEREN (VARCHAR (5), SYSDATETIME (), 11) ALS [JJ / MM] 11/06
YYYY / MM SELECTEER CONVERTEREN (VARCHAR (7), SYSDATETIME (), 111) ALS [JJJJ / MM] 2011/06
YY / M SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [YY / M] 11/6
YYYY / M SELECTEER CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [YYYY / M] 2011/6
MM / DD SELECTEER CONVERTEREN (VARCHAR (5), SYSDATETIME (), 1) AS [MM / DD] 06/08
DD / MM SELECTEER CONVERTEREN (VARCHAR (5), SYSDATETIME (), 3) AS [DD / MM] 08/06
M / D SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) AS [M / D] 6/8
D / M SELECT CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '/' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [D / M] 8/6
MM.DD.YYYY SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 101), '/', '.') ALS [MM.DD.YYYY] 06.08.2011
MM.DD.JJ SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 1), '/', '.') ALS [MM.DD.YY] 06.08.11
MDYYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)) AS [MDYYYY] 6.8.2011
MDYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [MDYY] 6.8.11
DD.MM.JJJJ SELECTEER CONVERT (VARCHAR (10), SYSDATETIME (), 104) ALS [DD.MM.YYYY] 08.06.2011
DD.MM.YY SELECTEER CONVERT (VARCHAR (10), SYSDATETIME (), 4) AS [DD.MM.YY] 08.06.11
DMYYYY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)) AS [DMYYYY] 8.6.2011
DMYY SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '.' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [DMYY] 8.6.11
YYYY.MD SELECTEER CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) AS [YYYY.MD] 2011/06/08
YY.MD SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) + '.' + CAST (DAG (SYSDATETIME ()) AS VARCHAR (2)) AS [YY.MD] 11.6.8
MM.YYYY SELECTEER RECHTS (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 104), 7) ALS [MM.YYYY] 06.2011
MM.YY SELECTEER RECHTS (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 4), 5) ALS [MM.YY] 06.11
M.YYYY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)) AS [M.YYYY] 6.2011
M.YY SELECTEER CAST (MAAND (SYSDATETIME ()) ALS VARCHAR (2)) + '.' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4)), 2) AS [M.YY] 6.11
YYYY.MM SELECTEER CONVERT (VARCHAR (7), SYSDATETIME (), 102) AS [YYYY.MM] 2011.06
YY.MM SELECTEER CONVERT (VARCHAR (5), SYSDATETIME (), 2) AS [YY.MM] 11.06
YYYY.M SELECTEER CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [YYYY.M] 2011,6
YY.M SELECTEER RECHTS (CAST (JAAR (SYSDATETIME ()) ALS VARCHAR (4)), 2) + '.' + CAST (MAAND (SYSDATETIME ()) AS VARCHAR (2)) AS [JJ.M] 11.6
MM.DD SELECTEER RECHTS (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 2), 5) ALS [MM.DD] 06.08
DD.MM SELECT CONVERT (VARCHAR (5), SYSDATETIME (), 4) AS [DD.MM] 08.06
MMDDJJJJ SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 101), '/', '') ALS [MMDDYYYY] 06082011
MMDDYY SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 1), '/', '') ALS [MMDDYY] 060.811
DDMMJJJJ SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (10), SYSDATETIME (), 103), '/', '') ALS [DDMMYYYY] 08062011
DDMMJJ SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 3), '/', '') ALS [DDMMYY] 080.611
MMYYYY SELECTEER RECHTS (VERVANG (CONVERT (VARCHAR (10), SYSDATETIME (), 103), '/', ''), 6) AS [MMYYYY] 062.011
MMYY SELECTEER RECHTS (VERVANG (CONVERTEREN (VARCHAR (8), SYSDATETIME (), 3), '/', ''), 4) ALS [MMYY] 0611
YYYYMM SELECTEER CONVERT (VARCHAR (6), SYSDATETIME (), 112) ALS [JJJJM] 201106
JJMM SELECTEER CONVERTEREN (VARCHAR (4), SYSDATETIME (), 12) ALS [JJMM] 1106
Maand DD, JJJJ SELECTEER DATENAME (MAAND, SYSDATETIME ()) + '' + RIGHT ('0' + DATENAME (DAY, SYSDATETIME ()), 2) + ',' + DATENAME (JAAR, SYSDATETIME ()) AS [maand DD, JJJJ] 8 juni 2011
Mon JJJJ SELECTEER LINKS (DATENAME (MONTH, SYSDATETIME ()), 3) + '' + DATENAME (YEAR, SYSDATETIME ()) AS [Mon YYYY] Juni 2011
Maand JJJJ SELECTEER DATENAME (MONTH, SYSDATETIME ()) + '' + DATENAME (YEAR, SYSDATETIME ()) AS [Maand JJJJ] Juni 2011
DD maand SELECTEER RECHTS ('0' + DATENAME (DAY, SYSDATETIME ()), 2) + '' + DATENAME (MONTH, SYSDATETIME ()) AS [DD maand] 08 juni
Maand DD SELECTEER DATENAME (MONTH, SYSDATETIME ()) + '' + RIGHT ('0' + DATENAME (DAY, SYSDATETIME ()), 2) AS [Maand DD] 08 juni
DD maand JJ SELECTEER CAST (DAG (SYSDATETIME ()) ALS VARCHAR (2)) + '' + DATENAME (MM, SYSDATETIME ()) + '' + RECHTS (CAST (JAAR (SYSDATETIME ()) AS VARCHAR (4), 2) AS [DD maand YY] 08 11 juni
DD maand JJJJ SELECTEER RECHTS ('0' + DATENAME (DAG, SYSDATETIME ()), 2) + '' + DATENAME (MAAND, SYSDATETIME ()) + '' + DATENAME (JAAR, SYSDATETIME ()) AS [DD maand JJJJ] 08 juni 2011
Ma-YY SELECTEER VERVANGEN (RECHTS (CONVERTEREN (VARCHAR (9), SYSDATETIME (), 6), 6), '', '-') AS [ma-jj] Jun-08
Ma-YYYY SELECTEER VERVANGEN (RECHTS (CONVERTEREN (VARCHAR (11), SYSDATETIME (), 106), 8), '', '-') ALS [ma-jjjj] Jun-2011
DD-Ma-YY SELECTEER VERVANGEN (CONVERTEREN (VARCHAR (9), SYSDATETIME (), 6), '', '-') AS [DD-Mon-YY] 08-Jun-11
DD-Ma-YYYY SELECTEER VERVANGEN (CONVERT (VARCHAR (11), SYSDATETIME (), 106), '', '-') AS [DD-Mon-YYYY] 08-Jun-2011


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow