DATEDIFF_BIG() Eksempler i SQL Server

I SQL Server kan du bruge DATEDIFF_BIG() funktion i stedet for DATEDIFF() funktion, hvis du forventer, at den returnerede værdi er rigtig stor. For eksempel, hvis du prøver at finde ud af, hvor mange millisekunder der er om 1000 år, får du en fejl.

Det er fordi DATEDIFF() returnerer en int datatype, og resultatet er for stort til, at den datatype kan håndtere. På den anden side er DATEDIFF_BIG() funktion returnerer en bigint med fortegn datatype, hvilket betyder, at du kan bruge den til at returnere meget større værdier. Med andre ord kan du bruge med et meget større udvalg af datoer.

Bortset fra det er der ikke rigtig nogen forskel mellem de to funktioner.

Artiklen giver eksempler på brug af DATEDIFF_BIG() funktion i SQL Server.

Syntaks

Først her er syntaksen:

DATEDIFF_BIG ( datepart , startdate , enddate )

Hvor datepart er den del af datoen, du vil sammenligne. startdato er den første dato og slutdato er slutdatoen.

Funktionen trækker startdato fra fra slutdato .

Måden det fungerer på er, at det returnerer antallet (som en signeret stort heltalsværdi) af den angivne datepart grænser krydset mellem den angivne startdato og slutdato .

Dette er nøjagtig den samme syntaks, som bruges med DATEDIFF() funktion.

Eksempel 1

Dette er et grundlæggende eksempel for at demonstrere, hvordan det virker.

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

Resultat:

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

Bemærk, at i dette tilfælde kunne vi have brugt DATEDIFF() , da resultatet ikke er for stort til et heltal.

Eksempel 2

Her er et eksempel, hvor vi returnerer forskellen mellem forskellige datodele fra to datoer. I dette tilfælde erklærer jeg to variable og tildeler to forskellige datoer til dem (jeg bruger DATEADD() funktion for at tilføje 1000 år til den første dato):

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 |
+---------+------------+----------+---------+-------------+--------+

Igen kunne vi have brugt DATEDIFF() , fordi ingen af ​​resultaterne er for store til et heltal.

Eksempel 3

I dette eksempel returnerer vi timer, minutter og sekunder mellem to datoer:

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 er vi på det punkt, hvor DATEDIFF() ville have returneret en fejl. Antallet af sekunder er for stort til en int (men ikke for en bigt ).

Eksempel 4

Og endelig, her er et eksempel med millisekunder, mikrosekunder og 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 dette tilfælde kan vi tydeligt se fordelen ved DATEDIFF_BIG() har over DATEDIFF() . DATEDIFF() ville være faldet om på alle tre.