DATEDIFF_BIG() Exemplos no SQL Server

No SQL Server, você pode usar o DATEDIFF_BIG() função em vez de DATEDIFF() função se você espera que o valor retornado seja muito grande. Por exemplo, se você está tentando descobrir quantos milissegundos existem em 1000 anos, você receberá um erro.

Isso porque DATEDIFF() retorna um int tipo de dados e o resultado é muito grande para esse tipo de dados manipular. Por outro lado, o DATEDIFF_BIG() função retorna um bigint assinado tipo de dados, o que significa que você pode usá-lo para retornar valores muito maiores. Em outras palavras, você pode usar com um intervalo muito maior de datas.

Fora isso, não há realmente nenhuma diferença entre as duas funções.

O artigo fornece exemplos de uso do DATEDIFF_BIG() função no SQL Server.

Sintaxe

Primeiro, aqui está a sintaxe:

DATEDIFF_BIG ( datepart , startdate , enddate )

Onde datepart é a parte da data que você deseja comparar. data de início é a primeira data e data final é a data final.

A função subtrai data de início a partir de data final .

A maneira como funciona é que ele retorna a contagem (como um valor inteiro grande com sinal) da datepart especificada limites cruzados entre a data de início especificada e data de término .

Essa é exatamente a mesma sintaxe usada com o DATEDIFF() função.

Exemplo 1

Este é um exemplo básico para demonstrar como funciona.

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

Resultado:

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

Observe que, neste caso, poderíamos ter usado DATEDIFF() , pois o resultado não é muito grande para um inteiro.

Exemplo 2

Aqui está um exemplo em que retornamos a diferença de várias partes de data de duas datas. Neste caso eu declaro duas variáveis e atribuo duas datas diferentes a elas (eu uso o DATEADD() função para adicionar 1000 anos à primeira 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;

Resultado:

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

Novamente, poderíamos ter usado DATEDIFF() , porque nenhum dos resultados é muito grande para um número inteiro.

Exemplo 3

Neste exemplo, retornamos as horas, minutos e segundos entre duas datas:

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;

Resultado:

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

Agora estamos no ponto em que DATEDIFF() teria retornado um erro. O número de segundos é muito grande para um int (mas não para um grande ).

Exemplo 4

E, finalmente, aqui está um exemplo com milissegundos, microssegundos e nanossegundos:

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;

Resultado:

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

Nesse caso, podemos ver claramente o benefício que DATEDIFF_BIG() tem mais de DATEDIFF() . DATEDIFF() teria caído em todos os três.