In SQL Server können Sie DATEDIFF_BIG() verwenden anstelle von DATEDIFF() Funktion, wenn Sie erwarten, dass der zurückgegebene Wert sehr groß ist. Wenn Sie beispielsweise versuchen, herauszufinden, wie viele Millisekunden in 1000 Jahren sind, erhalten Sie eine Fehlermeldung.
Das liegt daran, dass DATEDIFF() gibt ein int zurück Datentyp, und das Ergebnis ist zu groß für diesen Datentyp. Andererseits das DATEDIFF_BIG() Funktion gibt ein signiertes bigint zurück Datentyp, was bedeutet, dass Sie damit viel größere Werte zurückgeben können. Mit anderen Worten, Sie können einen viel größeren Datenbereich verwenden.
Ansonsten gibt es keinen wirklichen Unterschied zwischen den beiden Funktionen.
Der Artikel enthält Beispiele für die Verwendung von DATEDIFF_BIG() Funktion in SQL Server.
Syntax
Hier ist zunächst die Syntax:
DATEDIFF_BIG ( datepart , startdate , enddate )
Wo datepart ist der Teil des Datums, den Sie vergleichen möchten. Startdatum ist das erste Datum und Enddatum ist das Enddatum.
Die Funktion subtrahiert startdate ab Enddatum .
Es funktioniert so, dass es die Anzahl (als vorzeichenbehafteten Big-Integer-Wert) des angegebenen datepart zurückgibt Grenzen, die zwischen dem angegebenen Startdatum überschritten wurden und Enddatum .
Dies ist genau die gleiche Syntax, die mit DATEDIFF() verwendet wird Funktion.
Beispiel 1
Dies ist ein einfaches Beispiel, um zu demonstrieren, wie es funktioniert.
SELECT DATEDIFF_BIG(day, '0001-01-01', '9002-01-01') AS Result;
Ergebnis:
+----------+ | Result | |----------| | 3287547 | +----------+
Beachten Sie, dass wir in diesem Fall DATEDIFF() hätten verwenden können , da das Ergebnis nicht zu groß für eine Ganzzahl ist.
Beispiel 2
Hier ist ein Beispiel, in dem wir die Differenz verschiedener Datumsteile von zwei Daten zurückgeben. In diesem Fall deklariere ich zwei Variablen und weise ihnen zwei unterschiedliche Daten zu (ich verwende die DATEADD() Funktion zum Addieren von 1000 Jahren zum ersten 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; Ergebnis:
+---------+------------+----------+---------+-------------+--------+ | Years | Quarters | Months | Weeks | DayOfYear | Days | |---------+------------+----------+---------+-------------+--------| | 1000 | 4000 | 12000 | 52178 | 365243 | 365243 | +---------+------------+----------+---------+-------------+--------+
Auch hier hätten wir DATEDIFF() verwenden können , da keines der Ergebnisse zu groß für eine Ganzzahl ist.
Beispiel 3
In diesem Beispiel geben wir die Stunden, Minuten und Sekunden zwischen zwei Daten zurück:
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; Ergebnis:
+---------+-----------+-------------+ | Hours | Minutes | Seconds | |---------+-----------+-------------| | 8765832 | 525949920 | 31556995200 | +---------+-----------+-------------+
Jetzt sind wir an dem Punkt angelangt, an dem DATEDIFF() hätte einen Fehler zurückgegeben. Die Anzahl der Sekunden ist zu groß für ein int (aber nicht für einen bigint ).
Beispiel 4
Und zum Schluss noch ein Beispiel mit Millisekunden, Mikrosekunden und Nanosekunden:
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; Ergebnis:
+----------------+------------------+---------------------+ | Milliseconds | Microseconds | Nanoseconds | |----------------+------------------+---------------------| | 3155760000000 | 3155760000000000 | 3155760000000000000 | +----------------+------------------+---------------------+
In diesem Fall sehen wir deutlich den Vorteil von DATEDIFF_BIG() hat über DATEDIFF() . DATEDIFF() wäre bei allen dreien umgefallen.
