In SQL Server puoi utilizzare DATEDIFF_BIG() funzione invece di DATEDIFF() funzione se si prevede che il valore restituito sia davvero grande. Ad esempio, se stai cercando di scoprire quanti millisecondi sono in 1000 anni, riceverai un errore.
Questo perché DATEDIFF() restituisce un int tipo di dati e il risultato è troppo grande per essere gestito da quel tipo di dati. D'altra parte, il DATEDIFF_BIG() la funzione restituisce un bigint con segno tipo di dati, il che significa che puoi usarlo per restituire valori molto più grandi. In altre parole, puoi utilizzare con un intervallo di date molto più ampio.
A parte questo, non c'è davvero alcuna differenza tra le due funzioni.
L'articolo fornisce esempi di utilizzo di DATEDIFF_BIG() funzione in SQL Server.
Sintassi
Innanzitutto, ecco la sintassi:
DATEDIFF_BIG ( datepart , startdate , enddate )
Dove datapart è la parte della data che vuoi confrontare. data di inizio è la prima data e la data finale è la data di fine.
La funzione sottrae data di inizio da data finale .
Il modo in cui funziona è che restituisce il conteggio (come valore intero grande con segno) del datepart specificato limiti attraversati tra la data di inizio specificata e data di fine .
Questa è esattamente la stessa sintassi utilizzata con DATEDIFF() funzione.
Esempio 1
Questo è un esempio di base per dimostrare come funziona.
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
Risultato:
+----------+ | Result | |----------| | 3287547 | +----------+
Nota che in questo caso avremmo potuto usare DATEDIFF() , poiché il risultato non è troppo grande per un numero intero.
Esempio 2
Ecco un esempio in cui restituiamo la differenza di varie parti di date da due date. In questo caso dichiaro due variabili e le assegno due date diverse (uso il DATEADD() funzione per aggiungere 1000 anni alla prima data):
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; Risultato:
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1000 | 4000 | 12000 | 52178 | 365243 | 365243 | +---------+------------+----------+---------+-------------+--------+
Ancora una volta, avremmo potuto usare DATEDIFF() , perché nessuno dei risultati è troppo grande per un numero intero.
Esempio 3
In questo esempio restituiamo ore, minuti e secondi tra due date:
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; Risultato:
+---------+-----------+-------------+ | Hours | Minutes | Seconds | |---------+-----------+-------------| | 8765832 | 525949920 | 31556995200 | +---------+-----------+-------------+
Ora siamo al punto in cui DATEDIFF() avrebbe restituito un errore. Il numero di secondi è troppo grande per un int (ma non per un bigint ).
Esempio 4
E infine, ecco un esempio con millisecondi, microsecondi e nanosecondi:
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; Risultato:
+----------------+------------------+---------------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+------------------+---------------------| | 3155760000000 | 3155760000000000 | 3155760000000000000 | +----------------+------------------+---------------------+
In questo caso, possiamo vedere chiaramente il vantaggio che DATEDIFF_BIG() ha più di DATEDIFF() . DATEDIFF() sarebbe caduto tutti e tre.
