In SQL Server kunt u de DATEDIFF_BIG() . gebruiken functie in plaats van de DATEDIFF() functie als u verwacht dat de geretourneerde waarde erg groot is. Als u bijvoorbeeld probeert te achterhalen hoeveel milliseconden er in 1000 jaar zijn, krijgt u een foutmelding.
Dat komt omdat DATEDIFF() retourneert een int gegevenstype, en het resultaat is te groot voor dat gegevenstype om te verwerken. Aan de andere kant, de DATEDIFF_BIG() functie retourneert een ondertekende bigin gegevenstype, wat betekent dat u het kunt gebruiken om veel grotere waarden te retourneren. Met andere woorden, u kunt het met een veel grotere reeks datums gebruiken.
Verder is er niet echt een verschil tussen de twee functies.
Het artikel geeft voorbeelden van het gebruik van de DATEDIFF_BIG() functie in SQL Server.
Syntaxis
Ten eerste, hier is de syntaxis:
DATEDIFF_BIG ( datepart , startdate , enddate )
Waar datepart is het deel van de datum dat u wilt vergelijken. startdatum is de eerste datum en einddatum is de einddatum.
De functie trekt startdatum af vanaf einddatum .
De manier waarop het werkt, is dat het de telling retourneert (als een ondertekend groot geheel getal) van het opgegeven datepart grenzen overschreden tussen de opgegeven startdatum en einddatum .
Dit is precies dezelfde syntaxis die wordt gebruikt met de DATEDIFF() functie.
Voorbeeld 1
Dit is een eenvoudig voorbeeld om te laten zien hoe het werkt.
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
Resultaat:
+----------+ | Result | |----------| | 3287547 | +----------+
Merk op dat we in dit geval DATEDIFF() . hadden kunnen gebruiken , omdat het resultaat niet te groot is voor een geheel getal.
Voorbeeld 2
Hier is een voorbeeld waarbij we het verschil van verschillende datumdelen van twee datums retourneren. In dit geval declareer ik twee variabelen en wijs ik er twee verschillende datums aan toe (ik gebruik de DATEADD() functie om 1000 jaar toe te voegen aan de eerste datum):
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; Resultaat:
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1000 | 4000 | 12000 | 52178 | 365243 | 365243 | +---------+------------+----------+---------+-------------+--------+
Nogmaals, we hadden DATEDIFF() . kunnen gebruiken , omdat geen van de resultaten te groot is voor een geheel getal.
Voorbeeld 3
In dit voorbeeld retourneren we de uren, minuten en seconden tussen twee datums:
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; Resultaat:
+---------+-----------+-------------+ | Hours | Minutes | Seconds | |---------+-----------+-------------| | 8765832 | 525949920 | 31556995200 | +---------+-----------+-------------+
Nu zijn we op het punt waar DATEDIFF() zou een fout hebben geretourneerd. Het aantal seconden is te groot voor een int (maar niet voor een grote ).
Voorbeeld 4
En tot slot, hier is een voorbeeld met milliseconden, microseconden en nanoseconden:
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; Resultaat:
+----------------+------------------+---------------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+------------------+---------------------| | 3155760000000 | 3155760000000000 | 3155760000000000000 | +----------------+------------------+---------------------+
In dit geval zien we duidelijk het voordeel dat DATEDIFF_BIG() heeft meer dan DATEDIFF() . DATEDIFF() zou bij alle drie zijn omgevallen.