ODBC-Skalarfunktionen für Datum und Uhrzeit in SQL Server (T-SQL-Beispiele)

Sie können ODBC-Skalarfunktionen verwenden, wenn Sie T-SQL-Anweisungen in SQL Server ausführen. Es gibt verschiedene Arten von ODBC-Skalarfunktionen, darunter Zeichenfolgenfunktionen, numerische Funktionen, Systemfunktionen und natürlich Datums-/Zeitfunktionen (auch als Datums-, Zeit- und Intervallfunktionen bezeichnet).

Nachfolgend finden Sie Beispiele für Datums-, Uhrzeit- und Intervallfunktionen, die Sie in SQL Server verwenden können.

Syntax

Hier ist zunächst die Syntax, die Sie verwenden müssen, wenn Sie eine ODBC-Skalarfunktion aufrufen:

SELECT {fn  [ (,....n) ] }

Wobei <function_name> ist der Name der Funktion und (<argument>,....n) ist eine beliebige Anzahl optionaler Argumente.

Denken Sie also vor allem daran, dass Sie beim Aufrufen einer ODBC-Skalarfunktion den Funktionsaufruf in geschweifte Klammern einschließen müssen ({} ) und stellen Sie dem Namen fn voran .

Beispiel 1 – JETZT()

Diese Funktion gibt das aktuelle Datum und die Uhrzeit als Zeitstempelwert zurück.

SELECT {fn NOW()} AS Result;

Ergebnis:

+-------------------------+| Ergebnis ||-------------------------|| 2018-06-13 21:52:25.667 |+--------------------+

Beispiel 2 – Zeitstempel, Datum und Uhrzeit

Der CURRENT_TIMESTAMP() -Funktion gibt das aktuelle lokale Datum und die lokale Zeit als Zeitstempelwert zurück. Sie können auch das CURRENT_DATE() verwenden um nur den Datumsteil zurückzugeben, und/oder CURRENT_TIME() um nur den Zeitanteil zurückzugeben.

SELECT {fn CURRENT_TIMESTAMP()} AS 'Datum &Zeit', {fn CURRENT_DATE()} AS 'Datum', {fn CURRENT_TIME()} AS 'Zeit';

Ergebnis:

+--------------------+------------+------- -------+| Datum &Uhrzeit | Datum | Zeit ||--------------------+------------+-------- ------|| 2018-06-13 21:57:29.197 | 2018-06-13 | 21:57:29.197 |+--------------------+------------+---- ----------+

Außerdem CURRENT_TIMESTAMP() und CURRENT_TIME() beide akzeptieren ein optionales Argument, um die Sekundengenauigkeit des zurückgegebenen Werts zu bestimmen.

Beispiele:

SELECT {fn CURRENT_TIMESTAMP(3)} AS 'Date &Time', {fn CURRENT_TIME(6)} AS 'Time';

Ergebnis:

+-------------------------+----------------+| Datum &Uhrzeit | Zeit ||-------------------------+----------------|| 2018-06-13 22:00:59.263 | 22:00:59.263000 |+-------------------------+---------------- +

In diesem Beispiel CURRENT_TIMESTAMP() gibt eine Sekundengenauigkeit von 3 zurück, während CURRENT_TIME() gibt eine Sekundengenauigkeit von 6 zurück.

Beispiel 3 – CURDATE() und CURTIME()

Sie können CURDATE() verwenden und/oder CURTIME() als Alternative zu den obigen Datums- und Zeitfunktionen:

SELECT {fn CURDATE()} AS 'Datum', {fn CURTIME()} AS 'Time';

Ergebnis:

+------------+-------------+| Datum | Zeit ||------------+--------------|| 2018-06-13 | 22:05:20.013 |+-----------+---------------------+

Beachten Sie, dass diese Argumente keine Argumente akzeptieren. Wenn Sie also die Sekundengenauigkeit angeben müssen, verwenden Sie CURRENT_DATE() und/oder CURRENT_TIME() stattdessen.

Beispiel 4 – Tage und Wochen

Es gibt eine Reihe von ODBC-Skalarfunktionen zum Zurückgeben bestimmter Teile eines Datumswerts. Diese Funktionen akzeptieren ein Argument, das der Datumsausdruck ist, aus dem der gewünschte Datumsteil extrahiert werden soll.

Hier sind die verschiedenen Funktionen zum Zurückgeben der Tage und Wochen als Teil des Datums:

DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn DAYNAME(@date)} AS 'DAYNAME', {fn DAYOFYEAR(@date)} AS 'DAYOFYEAR', {fn DAYOFMONTH(@date)} AS 'DAYOFMONTH', {fn DAYOFWEEK(@date)} AS 'DAYOFWEEK', {fn WEEK(@date)} AS 'WEEK';

Ergebnis:

+-----------+------------+-------------+----- --------+--------+| TAGESNAME | TAG DES JAHRES | TAG DES MONATS | WOCHENTAG | WOCHE ||-----------+------------+-------------+------ -------+--------|| Montag | 45 | 14 | 2 | 8 |+---+-----+------+------ -------+--------+

In diesem Fall haben wir einer Variablen ein Datum zugewiesen und diese Variable dann an jede Funktion übergeben. Die Funktion gab dann den zutreffenden Datumsteil zurück.

Beispiel 5 – Monate, Quartale und Jahre

Hier sind die verschiedenen Funktionen zum Zurückgeben der Monate, Quartale und Jahre aus dem Datums-/Uhrzeitwert:

DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn YEAR(@date)} AS 'YEAR', {fn MONTH(@date)} AS 'MONTH', {fn MONATSNAME(@date)} AS 'MONATSNAME', {fn QUARTER(@date)} AS 'QUARTER';

Ergebnis:

+--------+---------+------------+-----------+| JAHR | MONAT | MONATSNAME | VIERTEL ||--------+---------+-------------+-----------|| 2000 | 2 | Februar | 1 |+--------+---------+------------+-----------+ Beispiel 6 – Stunden, Minuten und Sekunden
 
 Hier sind die verschiedenen Funktionen zum Zurückgeben des Stunden-, Minuten- und Sekundenteils aus dem Datums-/Uhrzeitwert:
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn HOUR(@date)} AS 'HOUR', {fn MINUTE(@date)} AS 'MINUTE', {fn SECOND(@date)} AS 'SECOND';
 
 Ergebnis:
 +--------+----------+----------+| STUNDE | MINUTE | ZWEITE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
 Beispiel 7 – Die Funktion EXTRACT()
 
 Es gibt auch eine ODBC-Skalarfunktion namens EXTRACT() , mit dem Sie die verschiedenen Datumsteile aus dem Datums-/Uhrzeitwert extrahieren können. Beispiele unten.
 Jahr, Monat und Tag
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(YEAR FROM @date)} AS 'YEAR', {fn EXTRACT(MONTH FROM @date)} AS 'MONTH ', {fn EXTRACT(DAY FROM @date)} AS 'DAY';
 
 Ergebnis:
 +--------+---------+-------+| JAHR | MONAT | TAG ||--------+---------+-------|| 2000 | 2 | 14 |+--------+---------+-------+
 Stunden, Minuten und Sekunden
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(HOUR FROM @date)} AS 'HOUR', {fn EXTRACT(MINUTE FROM @date)} AS 'MINUTE ', {fn EXTRACT(SECOND FROM @date)} AS 'SECOND';
 
 Ergebnis:
 +--------+----------+----------+| STUNDE | MINUTE | ZWEITE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
 Beispiel 8 – Die TIMESTAMPADD()-Funktion
 
 Das TIMESTAMPADD() ermöglicht es Ihnen, eine bestimmte Zahl des angegebenen Intervalls (Datums-/Uhrzeitteil) zum Datums-/Uhrzeitwert hinzuzufügen. Diese Funktion akzeptiert drei Argumente; das hinzuzufügende Intervall (Datums-/Uhrzeitteil) (z. B. Monat), die Nummer dieses hinzuzufügenden Teils und der Datumswert. Beispiele unten.
 Jahr, Quartal, Monat und Tag
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_YEAR, 21, @date)} AS 'SQL_TSI_YEAR', {fn TIMESTAMPADD(SQL_TSI_QUARTER, 21, @date) } AS 'SQL_TSI_QUARTER', {fn TIMESTAMPADD(SQL_TSI_MONTH, 21, @date)} AS 'SQL_TSI_MONTH', {fn TIMESTAMPADD(SQL_TSI_DAY, 21, @date)} AS 'SQL_TSI_DAY';
 
 Ergebnis:
 SQL_TSI_YEAR | 2021-02-14 07:31:58.1234567SQL_TSI_QUARTER | 2005-05-14 07:31:58.1234567SQL_TSI_MONAT | 14.11.2001 07:31:58.1234567SQL_TSI_DAY | 06.03.2000 07:31:58.1234567
 Stunden, Minuten und Sekunden
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_HOUR, 5, @date)} AS 'SQL_TSI_HOUR', {fn TIMESTAMPADD(SQL_TSI_MINUTE, 5, @date) } AS 'SQL_TSI_MINUTE', {fn TIMESTAMPADD(SQL_TSI_SECOND, 5, @date)} AS 'SQL_TSI_SECOND', {fn TIMESTAMPADD(SQL_TSI_FRAC_SECOND, 5, @date)} AS 'SQL_TSI_FRAC_SECOND';
 
 Ergebnis:
 SQL_TSI_HOUR | 2000-02-14 12:31:58.1234567SQL_TSI_MINUTE | 2000-02-14 07:36:58.1234567SQL_TSI_SECOND | 2000-02-14 07:32:03.1234567SQL_TSI_FRAC_SECOND | 2000-02-14 07:31:58.1284567
 Beispiel 9 – Die TIMESTAMPDIFF()-Funktion
 
 Der TIMESTAMPDIFF() Die Funktion gibt die Differenz zwischen zwei Datums-/Uhrzeitwerten zurück. Diese Funktion akzeptiert drei Argumente; das Intervall (Datums-/Uhrzeitteil), für das die Differenz berechnet werden soll (z. B. Monat), das erste Datum und das zweite Datum. Die Funktion gibt die Anzahl der Intervalle zurück, in denen das erste Datum größer als das zweite Datum ist. Beispiele unten.
 Jahr, Quartal, Monat, Woche und Tag
 DECLARE @date1 datetime2 ='2000-02-14 07:31:58.1234567'; DECLARE @date2 datetime2 =DATEADD(year, 1, @date1);SELECT {fn TIMESTAMPDIFF(SQL_TSI_YEAR, @date1, @date2)} AS 'SQL_TSI_YEAR', {fn TIMESTAMPDIFF(SQL_TSI_QUARTER, @date1, @date2)} AS 'SQL_TSI_QUARTER ', {fn TIMESTAMPDIFF(SQL_TSI_MONTH, @date1, @date2)} AS 'SQL_TSI_MONTH', {fn TIMESTAMPDIFF(SQL_TSI_WEEK, @date1, @date2)} AS 'SQL_TSI_WEEK', {fn TIMESTAMPDIFF(SQL_TSI_DAY, @date1, @date2) } AS 'SQL_TSI_DAY';
 
 Ergebnis:
 +----------------+-------------------+--------- --------+----------------+---------------+| SQL_TSI_JAHR | SQL_TSI_QUARTER | SQL_TSI_MONAT | SQL_TSI_WEEK | SQL_TSI_DAY ||----------------+-------------------+---------- -------+----------------+---------------|| 1 | 4 | 12 | 52 | 366 |+-----------+-------------------+---------- -------+----------------+---------------+
 Stunden, Minuten und Sekunden
 DECLARE @date1 datetime2 ='2000-02-14 07:31:58.1234567'; DECLARE @date2 datetime2 =DATEADD(day, 1, @date1);SELECT {fn TIMESTAMPDIFF(SQL_TSI_HOUR, @date1, @date2)} AS 'SQL_TSI_HOUR', {fn TIMESTAMPDIFF(SQL_TSI_MINUTE, @date1, @date2)} AS 'SQL_TSI_MINUTE ', {fn TIMESTAMPDIFF(SQL_TSI_SECOND, @date1, @date2)} AS 'SQL_TSI_SECOND', {fn TIMESTAMPDIFF(SQL_TSI_FRAC_SECOND, @date1, @date2)} AS 'SQL_TSI_FRAC_SECOND';
 
 Ergebnis:
 +----------------+------+---------- --------+-----------------------+| SQL_TSI_HOUR | SQL_TSI_MINUTE | SQL_TSI_SECOND | SQL_TSI_FRAC_SECOND ||----------------+------------------+----------- -------+-----------------------|| 24 | 1440 | 86400 | 86400000 |+-----------+------------------+----------- -------+-----------------------+