I SQL Server kan du använda T-SQL DATEDIFF() funktion för att returnera skillnaden mellan två datum/tider. Det fungerar på alla uttryck som kan lösas till en tid , datum , smalldatetime , datumtid , datetime2 , eller datetime offset värde.
Den här artikeln ger exempel på DATEDIFF() funktion i SQL Server.
Syntax
Först, här är syntaxen:
DATEDIFF ( datepart , startdate , enddate )
Där datepart är den del av datumet som du vill jämföra. startdatum är det första datumet och slutdatum är slutdatumet.
Sättet det fungerar är att det returnerar antalet (som ett signerat heltalsvärde) för den angivna datepart gränser korsade mellan det angivna startdatumet och slutdatum .
Exempel 1
Här är ett grundläggande exempel där vi tar reda på antalet dagar mellan två datum:
SELECT DATEDIFF(day, '2001-01-01', '2002-01-01') AS Result;
Resultat:
+----------+ | Result | |----------| | 365 | +----------+
Exempel 2
Här är ett annat exempel där jag deklarerar två variabler och tilldelar två olika datum till dem (jag använder DATEADD() för att lägga till 1 år till det första datumet). Jag använder sedan DATEDIFF() för att returnera olika datumdelar för det datumet:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 1, @date1);
SELECT
DATEDIFF( year, @date1, @date2 ) AS Years,
DATEDIFF( quarter, @date1, @date2 ) AS Quarters,
DATEDIFF( month, @date1, @date2 ) AS Months,
DATEDIFF( week, @date1, @date2 ) AS Weeks,
DATEDIFF( dayofyear, @date1, @date2 ) AS DayOfYear,
DATEDIFF( day, @date1, @date2 ) AS Days; Resultat:
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1 | 4 | 12 | 53 | 366 | 366 | +---------+------------+----------+---------+-------------+--------+
Exempel 3
Som nämnts kan du även returnera tidsdelarna mellan datumen. Här är ett exempel på hur man returnerar antalet timmar, minuter och sekunder mellan datum-/tidsvärdena:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(hour, 1, @date1);
SELECT
DATEDIFF( hour, @date1, @date2 ) AS Hours,
DATEDIFF( minute, @date1, @date2 ) AS Minutes,
DATEDIFF( second, @date1, @date2 ) AS Seconds; Resultat:
+---------+-----------+-----------+ | Hours | Minutes | Seconds | |---------+-----------+-----------| | 1 | 60 | 3600 | +---------+-----------+-----------+
Exempel 4
Och här är ett exempel på hur man får antalet millisekunder, mikrosekunder och nanosekunder mellan två datum-/tidsvärden:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(millisecond, 1, @date1);
SELECT
DATEDIFF( millisecond, @date1, @date2 ) AS Milliseconds,
DATEDIFF( microsecond, @date1, @date2 ) AS Microseconds,
DATEDIFF( nanosecond, @date1, @date2 ) AS Nanoseconds; Resultat:
+----------------+----------------+---------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+----------------+---------------| | 1 | 1000 | 1000000 | +----------------+----------------+---------------+
Exempel 5 – Fel!
Om du försöker göra något extremt, som att returnera antalet nanosekunder på 100 år, får du ett felmeddelande. Detta beror på att DATEDIFF() returnerar en int värde, och det finns fler nanosekunder på 100 år än int datatyp kan hantera.
Så här är vad som händer om du försöker göra det:
DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 100, @date1);
SELECT
DATEDIFF( millisecond, @date1, @date2 ) AS Milliseconds,
DATEDIFF( microsecond, @date1, @date2 ) AS Microseconds,
DATEDIFF( nanosecond, @date1, @date2 ) AS Nanoseconds; Resultat:
The datediff function resulted in an overflow. The number of dateparts separating two date/time instances is too large. Try to use datediff with a less precise datepart.
Lyckligtvis, om du verkligen måste ta reda på hur många nanosekunder det är på 100 år, kan du använda DATEDIFF_BIG() funktion istället. Denna funktion returnerar en signerad bigint datatyp, som låter dig returnera mycket större värden än DATEDIFF() kan.
Exempel 6 – Få konstiga resultat?
Resultaten du får från DATEDIFF() kan ibland se helt fel ut om du inte vet hur funktionen faktiskt fungerar.
Till exempel:
DECLARE @startdate datetime2 = '2016-01-01 00:00:00.0000000', @enddate datetime2 = '2016-12-31 23:59:59.9999999'; SELECT DATEDIFF(day, @startdate, @enddate) Days, DATEDIFF(year, @startdate, @enddate) Years;
Resultat:
+--------+---------+ | Days | Years | |--------+---------| | 365 | 0 | +--------+---------+
Om du inte vet hur DATEDIFF() faktiskt fungerar, det här resultatet kan se så fel ut att du skulle bli förlåten för att anta att det är en bugg. Men det är inget fel.
Kolla in DATEDIFF() Returnerar fel resultat i SQL Server? Läs detta. för att se det här exemplet och andra fall där resultaten kan se helt fel ut, men vara helt korrekta (och för en förklaring till varför de ser ut som de gör).
Ett av exemplen på den sidan är nog värt att nämna igen här. DATEDIFF() ignorerar faktiskt din SET DATEFIRST värde. Detta kan resultera i oväntade resultat, särskilt om du befinner dig i en kultur som inte använder söndagen som den första dagen i veckan. Kolla in den här lösningen för DATEDIFF() som ignorerar SET DATEFIRST i SQL Server om du tror att detta kan påverka dig.