En SQL Server, puede usar DATEDIFF_BIG() función en lugar de DATEDIFF() función si espera que el valor devuelto sea realmente grande. Por ejemplo, si está tratando de averiguar cuántos milisegundos hay en 1000 años, obtendrá un error.
Eso es porque DATEDIFF() devuelve un int tipo de datos y el resultado es demasiado grande para que lo maneje ese tipo de datos. Por otro lado, el DATEDIFF_BIG() la función devuelve un bigint firmado tipo de datos, lo que significa que puede usarlo para devolver valores mucho más grandes. En otras palabras, puede usar con un rango de fechas mucho más amplio.
Aparte de eso, no hay realmente ninguna diferencia entre las dos funciones.
El artículo proporciona ejemplos del uso de DATEDIFF_BIG() función en SQL Server.
Sintaxis
Primero, aquí está la sintaxis:
DATEDIFF_BIG ( datepart , startdate , enddate )
Donde datepart es la parte de la fecha que desea comparar. fecha de inicio es la primera fecha y enddate es la fecha de finalización.
La función resta startdate desde fecha de finalización .
La forma en que funciona es que devuelve el recuento (como un valor entero grande con signo) del datepart especificado. límites cruzados entre la startdate especificada y fecha de finalización .
Esta es exactamente la misma sintaxis que se usa con DATEDIFF() función.
Ejemplo 1
Este es un ejemplo básico para demostrar cómo funciona.
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
Resultado:
+----------+ | Result | |----------| | 3287547 | +----------+
Tenga en cuenta que en este caso, podríamos haber usado DATEDIFF() , ya que el resultado no es demasiado grande para un número entero.
Ejemplo 2
Aquí hay un ejemplo en el que devolvemos la diferencia de varias partes de fechas de dos fechas. En este caso declaro dos variables y les asigno dos fechas diferentes (uso el DATEADD() función para sumar 1000 años a la primera fecha):
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 | +---------+------------+----------+---------+-------------+--------+
Nuevamente, podríamos haber usado DATEDIFF() , porque ninguno de los resultados es demasiado grande para un número entero.
Ejemplo 3
En este ejemplo devolvemos las horas, minutos y segundos entre dos fechas:
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 | +---------+-----------+-------------+
Ahora estamos en el punto donde DATEDIFF() habría devuelto un error. El número de segundos es demasiado grande para un int (pero no para un bigint ).
Ejemplo 4
Y finalmente, aquí hay un ejemplo con milisegundos, microsegundos y nanosegundos:
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 | +----------------+------------------+---------------------+
En este caso, podemos ver claramente el beneficio que DATEDIFF_BIG() tiene más de DATEDIFF() . DATEDIFF() me hubiera caído en los tres.
