DATEDIFF_BIG() Exempel i SQL Server

I SQL Server kan du använda DATEDIFF_BIG() funktion istället för DATEDIFF() funktion om du förväntar dig att det returnerade värdet ska vara riktigt stort. Om du till exempel försöker ta reda på hur många millisekunder det är på 1000 år får du ett felmeddelande.

Det beror på att DATEDIFF() returnerar en int datatyp och resultatet är för stort för att datatypen ska kunna hanteras. Å andra sidan, DATEDIFF_BIG() funktion returnerar en signerad bigint datatyp, vilket innebär att du kan använda den för att returnera mycket större värden. Med andra ord kan du använda med ett mycket större datumintervall.

Utöver det är det egentligen ingen skillnad mellan de två funktionerna.

Artikeln ger exempel på hur du använder DATEDIFF_BIG() funktion i SQL Server.

Syntax

Först, här är syntaxen:

DATEDIFF_BIG ( 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.

Funktionen subtraherar startdatum från slutdatum .

Sättet det fungerar är att det returnerar antalet (som ett signerat stort heltalsvärde) för den angivna datepart gränser korsade mellan det angivna startdatumet och slutdatum .

Detta är exakt samma syntax som används med DATEDIFF() funktion.

Exempel 1

Detta är ett grundläggande exempel för att visa hur det fungerar.

SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 3287547  |
+----------+

Observera att i det här fallet kunde vi ha använt DATEDIFF() , eftersom resultatet inte är för stort för ett heltal.

Exempel 2

Här är ett exempel där vi returnerar skillnaden mellan olika datumdelar från två datum. I det här fallet deklarerar jag två variabler och tilldelar två olika datum till dem (jag använder DATEADD() funktion för att lägga till 1000 år till det första datumet):

DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 1000, @date1);
SELECT 
    DATEDIFF_BIG( year, @date1, @date2 ) AS Years,
    DATEDIFF_BIG( quarter, @date1, @date2 ) AS Quarters,
    DATEDIFF_BIG( month, @date1, @date2 ) AS Months,
    DATEDIFF_BIG( week, @date1, @date2 ) AS Weeks,
    DATEDIFF_BIG( dayofyear, @date1, @date2 ) AS DayOfYear,
    DATEDIFF_BIG( day, @date1, @date2 ) AS Days;

Resultat:

+---------+------------+----------+---------+-------------+--------+
| Years   | Quarters   | Months   | Weeks   | DayOfYear   | Days   |
|---------+------------+----------+---------+-------------+--------|
| 1000    | 4000       | 12000    | 52178   | 365243      | 365243 |
+---------+------------+----------+---------+-------------+--------+

Återigen, vi kunde ha använt DATEDIFF() , eftersom inget av resultaten är för stort för ett heltal.

Exempel 3

I det här exemplet returnerar vi timmar, minuter och sekunder mellan två datum:

DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 1000, @date1);
SELECT 
    DATEDIFF_BIG( hour, @date1, @date2 ) AS Hours,
    DATEDIFF_BIG( minute, @date1, @date2 ) AS Minutes,
    DATEDIFF_BIG( second, @date1, @date2 ) AS Seconds;

Resultat:

+---------+-----------+-------------+
| Hours   | Minutes   | Seconds     |
|---------+-----------+-------------|
| 8765832 | 525949920 | 31556995200 |
+---------+-----------+-------------+

Nu är vi vid den punkt där DATEDIFF() skulle ha returnerat ett fel. Antalet sekunder är för stort för en int (men inte för en stor ).

Exempel 4

Och slutligen, här är ett exempel med millisekunder, mikrosekunder och nanosekunder:

DECLARE @date1 datetime2 = '2000-01-01 00:00:00.0000000';
DECLARE @date2 datetime2 = DATEADD(year, 100, @date1);
SELECT    
    DATEDIFF_BIG( millisecond, @date1, @date2 ) AS Milliseconds,
    DATEDIFF_BIG( microsecond, @date1, @date2 ) AS Microseconds,
    DATEDIFF_BIG( nanosecond, @date1, @date2 ) AS Nanoseconds;

Resultat:

+----------------+------------------+---------------------+
| Milliseconds   | Microseconds     | Nanoseconds         |
|----------------+------------------+---------------------|
| 3155760000000  | 3155760000000000 | 3155760000000000000 |
+----------------+------------------+---------------------+

I det här fallet kan vi tydligt se fördelen med DATEDIFF_BIG() har över DATEDIFF() . DATEDIFF() skulle ha ramlat omkull på alla tre.