Dans SQL Server, vous pouvez utiliser le DATEDIFF_BIG() fonction au lieu de DATEDIFF() fonction si vous vous attendez à ce que la valeur renvoyée soit vraiment grande. Par exemple, si vous essayez de savoir combien de millisecondes il y a dans 1000 ans, vous obtiendrez une erreur.
C'est parce que DATEDIFF() renvoie un int type de données et le résultat est trop volumineux pour être géré par ce type de données. D'autre part, le DATEDIFF_BIG() la fonction renvoie un bigint signé type de données, ce qui signifie que vous pouvez l'utiliser pour renvoyer des valeurs beaucoup plus grandes. En d'autres termes, vous pouvez utiliser avec une plage de dates beaucoup plus large.
En dehors de cela, il n'y a pas vraiment de différence entre les deux fonctions.
L'article fournit des exemples d'utilisation de DATEDIFF_BIG() fonction dans SQL Server.
Syntaxe
Tout d'abord, voici la syntaxe :
DATEDIFF_BIG ( datepart , startdate , enddate )
Où datepart est la partie de la date que vous voulez comparer. date de début est la première date et la date de fin est la date de fin.
La fonction soustrait startdate à partir de date de fin .
La façon dont cela fonctionne est qu'il renvoie le nombre (sous la forme d'une grande valeur entière signée) de la partie de date spécifiée frontières franchies entre la date de début spécifiée et date de fin .
Il s'agit exactement de la même syntaxe que celle utilisée avec DATEDIFF() fonction.
Exemple 1
Ceci est un exemple de base pour montrer comment cela fonctionne.
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
Résultat :
+----------+ | Result | |----------| | 3287547 | +----------+
Notez que dans ce cas, nous aurions pu utiliser DATEDIFF() , car le résultat n'est pas trop grand pour un entier.
Exemple 2
Voici un exemple où nous renvoyons la différence de différentes parties de date à partir de deux dates. Dans ce cas, je déclare deux variables et leur attribue deux dates différentes (j'utilise le DATEADD() fonction pour ajouter 1000 ans à la première date):
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; Résultat :
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1000 | 4000 | 12000 | 52178 | 365243 | 365243 | +---------+------------+----------+---------+-------------+--------+
Encore une fois, nous aurions pu utiliser DATEDIFF() , car aucun des résultats n'est trop grand pour un entier.
Exemple 3
Dans cet exemple, nous renvoyons les heures, les minutes et les secondes entre deux dates :
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; Résultat :
+---------+-----------+-------------+ | Hours | Minutes | Seconds | |---------+-----------+-------------| | 8765832 | 525949920 | 31556995200 | +---------+-----------+-------------+
Nous sommes maintenant au point où DATEDIFF() aurait retourné une erreur. Le nombre de secondes est trop grand pour un int (mais pas pour un bigint ).
Exemple 4
Et enfin, voici un exemple avec des millisecondes, des microsecondes et des nanosecondes :
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; Résultat :
+----------------+------------------+---------------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+------------------+---------------------| | 3155760000000 | 3155760000000000 | 3155760000000000000 | +----------------+------------------+---------------------+
Dans ce cas, nous pouvons clairement voir l'avantage que DATEDIFF_BIG() a plus de DATEDIFF() . DATEDIFF() serait tombé à tous les trois.
