Wie man in SQL mit Datums- und Zeitangaben arbeitet

Einführung

Bei der Arbeit mit relationalen Datenbanken und der strukturierten Abfragesprache (SQL) kann es vorkommen, dass Sie mit Werten arbeiten müssen, die bestimmte Datums- oder Zeitangaben repräsentieren. Beispielsweise müssen Sie möglicherweise die Gesamtstundenzahl einer bestimmten Aktivität berechnen oder Datums- oder Zeitwerte mithilfe mathematischer Operatoren und Funktionen aggregieren, um deren Summe oder Durchschnitt zu ermitteln.

In diesem Tutorial lernen Sie, wie Sie Datum und Uhrzeit in SQL verwenden. Zunächst führen Sie Berechnungen durch und nutzen verschiedene Funktionen mit Datum und Uhrzeit mithilfe der SELECT-Anweisung. Anschließend üben Sie anhand von Beispieldaten und lernen, wie Sie die CAST-Funktion einsetzen, um die Ausgabe lesbarer zu gestalten.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie Folgendes:

• Ein Server mit Ubuntu 20.04, auf dem ein Benutzer ohne Root-Rechte, aber mit sudo-Administratorrechten und aktivierter Firewall läuft.
• MySQL ist auf dem Server installiert und gesichert.

Hinweis: Bitte beachten Sie, dass viele relationale Datenbankmanagementsysteme (RDBMS) ihre eigenen SQL-Implementierungen verwenden. Obwohl die in diesem Tutorial genannten Befehle auf den meisten RDBMS funktionieren, können Syntax und Ausgabe auf anderen Systemen als MySQL abweichen.

Um in diesem Tutorial die Verwendung von Datum und Uhrzeit zu üben, benötigen Sie eine Datenbank und eine Tabelle mit Beispieldaten. Falls Sie noch keine Datenbank oder Tabelle zum Einfügen haben, lesen Sie bitte den Abschnitt „Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten“, um zu erfahren, wie Sie eine Datenbank und eine Tabelle erstellen. In diesem Tutorial wird im Folgenden auf diese Beispieldatenbank und -tabelle Bezug genommen.

Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten

Wenn Ihre SQL-Datenbank auf einem Remote-Server läuft, stellen Sie eine SSH-Verbindung von Ihrem lokalen Rechner zu Ihrem Server her:

ssh sammy@your_server_ip

Öffnen Sie anschließend die MySQL-Eingabeaufforderung und ersetzen Sie „Sami“ durch Ihre MySQL-Kontoinformationen:

mysql -u sammy -p

Erstellen Sie eine Datenbank namens datetimeDB:

CREATE DATABASE datetimeDB;

Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie folgende Ausgabe:

Output
Query OK, 1 row affected (0.01 sec)

Um die datetimeDB-Datenbank auszuwählen, führen Sie die folgende USE-Anweisung aus:

USE datetimeDB;

Output
Database changed

Nachdem Sie die Datenbank ausgewählt haben, erstellen Sie darin eine Tabelle. In diesem Tutorial erstellen wir eine Tabelle, die die Ergebnisse zweier Läufer für verschiedene Rennen speichert, an denen sie im Laufe eines Jahres teilgenommen haben. Diese Tabelle hat die folgenden sieben Spalten:

• race_id: Stellt Werte vom Datentyp int dar und fungiert als Primärschlüssel der Tabelle, was bedeutet, dass jeder Wert in dieser Spalte als eindeutiger Bezeichner für die entsprechende Zeile dient.
• runner_name: Verwendet den Datentyp varchar mit maximal 30 Zeichen für die Namen der beiden Läufer Bolt und Felix.
• race_name: Enthält Renntypen mit varchar-Datentyp und bis zu 20 Zeichen.
• start_day: Verwendet den Datentyp DATE, um das Datum eines bestimmten Spiels anhand von Jahr, Monat und Tag zu erfassen. Dieser Datentyp hat folgende Parameter: vier Ziffern für das Jahr und maximal zwei Ziffern für Monat und Tag (JJJJ-MM-TT).
• start_time: Gibt die Startzeit des Spiels im 24-Stunden-Format (Stunden, Minuten, Sekunden, HH:MM:SS) an.
• total_miles: Zeigt die Gesamtkilometerzahl für jedes Rennen im Dezimalformat an, da viele der angegebenen Kilometer pro Rennen keine ganzen Zahlen sind. In diesem Fall gibt das Dezimalformat eine Genauigkeit von drei Stellen und eine Skalierung von eins an. Das bedeutet, dass jeder Wert in dieser Spalte drei Stellen haben kann, wobei eine dieser Stellen rechts vom Dezimaltrennzeichen steht.
• end_time: Verwendet den Datentyp TIMESTAMP, um die Zeit der Läufer am Ende des Rennens zu erfassen. Dieser Datentyp kombiniert Datum und Uhrzeit zu einer Zeichenkette, und sein Format ist eine Kombination aus DATE und TIME: (YYYY-MM-DD HH:MM:SS).

Erstellen Sie die Tabelle mit dem Befehl CREATE TABLE:

CREATE TABLE race_results (
race_id int, 
runner_name varchar(30),
race_name varchar(20), 
start_day DATE,
start_time TIME, 
total_miles decimal(3, 1),
end_time TIMESTAMP,
PRIMARY KEY (race_id)
); 

Geben Sie anschließend einige Beispieldaten in die leere Tabelle ein:

INSERT INTO race_results
(race_id, runner_name, race_name, start_day, start_time, total_miles, end_time)
VALUES
(1, 'bolt', '1600_meters', '2022-09-18', '7:00:00', 1.0, '2022-09-18 7:06:30'),
(2, 'bolt', '5K', '2022-10-19', '11:00:00', 3.1, '2022-10-19 11:22:31'),
(3, 'bolt', '10K', '2022-11-20', '10:00:00', 6.2, '2022-11-20 10:38:05'),
(4, 'bolt', 'half_marathon', '2022-12-21', '6:00:00', 13.1, '2022-12-21 07:39:04'),
(5, 'bolt', 'full_marathon', '2023-01-22', '8:00:00', 26.2, '2023-01-22 11:23:10'),
(6, 'felix', '1600_meters', '2022-09-18', '7:00:00', 1.0, '2022-09-18 7:07:15'),
(7, 'felix', '5K', '2022-10-19', '11:00:00', 3.1, '2022-10-19 11:30:50'),
(8, 'felix', '10K', '2022-11-20', '10:00:00', 6.2, '2022-11-20 11:10:17'),
(9, 'felix', 'half_marathon', '2022-12-21', '6:00:00', 13.1, '2022-12-21 08:11:57'),
(10, 'felix', 'full_marathon', '2023-01-22', '8:00:00', 26.2, '2023-01-22 12:02:10');

Output
Query OK, 10 rows affected (0.00 sec)
Records: 10 Duplicates: 0 Warnings: 0

Sobald Sie die Daten eingegeben haben, können Sie mit dem Üben von Arithmetik und Funktionen mit Datums- und Zeitangaben in SQL beginnen.

Verwendung des Kontos mit Datum und Uhrzeit

In SQL können Sie Datums- und Zeitwerte mithilfe mathematischer Ausdrücke bearbeiten. Sie benötigen lediglich einen mathematischen Operator und die zu berechnenden Werte.

Angenommen, Sie möchten ein Datum finden, das eine bestimmte Anzahl von Tagen nach einem anderen liegt. Die folgende Abfrage nimmt einen Datumswert (2022-10-05) und addiert 17 dazu, um einen Datumswert zurückzugeben, der siebzehn Tage nach dem in der Abfrage angegebenen Datum liegt. Beachten Sie, dass in diesem Beispiel 2022-10-05 als DATE-Wert angegeben wird, um sicherzustellen, dass das DBMS ihn nicht als Zeichenkette oder einen anderen Datentyp interpretiert:

SELECT DATE '2022-10-05' + 17 AS new_date;

Output
+----------+
| new_date |
+----------+
| 20221022 |
+----------+
1 row in set (0.01 sec)

Wie diese Ausgabe zeigt, sind 17 Tage nach dem 5. Oktober 2022 der 22. Oktober 2022.

Nehmen wir als weiteres Beispiel an, Sie möchten die Gesamtstundenzahl zwischen zwei verschiedenen Zeitpunkten berechnen. Dies erreichen Sie, indem Sie die beiden Zeitpunkte voneinander subtrahieren. In der folgenden Abfrage ist 11:00 der erste Zeitpunkt und 3:00 der zweite. Hier müssen Sie angeben, dass beide Werte vom Typ TIME sind, um die Differenz in Stunden zu erhalten:

SELECT TIME '11:00' - TIME '3:00' AS time_diff;

Output
+-----------+
| time_diff |
+-----------+
| 80000 |
+-----------+
1 row in set (0.00 sec)

Diese Ausgabe zeigt Ihnen, dass die Differenz zwischen 11:00 und 3:00 80.000 oder 8 Stunden beträgt.

Üben Sie nun die Berechnungen mit Datums- und Zeitangaben anhand der Beispieldaten. Berechnen Sie für die erste Abfrage die Gesamtzeit, die die Läufer für jedes Rennen benötigten, indem Sie die Endzeit von der Startzeit subtrahieren:

SELECT runner_name, race_name, end_time - start_time 
AS total_time 
FROM race_results;

Output
+-------------+---------------+----------------+
| runner_name | race_name | total_time |
+-------------+---------------+----------------+
| bolt | 1600_meters | 20220918000630 |
| bolt | 5K | 20221019002231 |
| bolt | 10K | 20221120003805 |
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | 1600_meters | 20220918000715 |
| felix | 5K | 20221019003050 |
| felix | 10K | 20221120011017 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+----------------+
10 rows in set (0.00 sec)

Sie werden feststellen, dass die Ausgabe in der Spalte „total_time“ recht lang und schwer lesbar ist. Im Folgenden zeigen wir Ihnen, wie Sie die CAST-Funktion verwenden, um diese Datenwerte so umzuwandeln, dass sie besser lesbar sind.

Wenn Sie sich nur für die Leistung jedes Läufers bei längeren Läufen wie Halb- und Marathonläufen interessieren, können Sie Ihre Daten abfragen, um diese Informationen zu erhalten. Subtrahieren Sie dazu die Endzeit von der Startzeit und beschränken Sie die Ergebnisse mithilfe einer WHERE-Klausel auf Daten, bei denen die Gesamtkilometerzahl größer als 12 ist.

SELECT runner_name, race_name, end_time - start_time AS half_full_results
FROM race_results 
WHERE total_miles > 12;

Output
+-------------+---------------+-------------------+
| runner_name | race_name | half_full_results |
+-------------+---------------+-------------------+
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+-------------------+
4 rows in set (0.00 sec)

In diesem Abschnitt haben Sie einige Datums- und Zeitberechnungen mit der SELECT-Anweisung und anhand von Beispieldaten durchgeführt. Im nächsten Abschnitt üben Sie Abfragen mit verschiedenen Datums- und Zeitfunktionen.

Verwendung von Datums- und Zeitfunktionen und Bereichsausdrücken

Es gibt verschiedene Funktionen in SQL, mit denen sich Datums- und Zeitwerte ermitteln und bearbeiten lassen. SQL-Funktionen dienen typischerweise der Datenverarbeitung und -manipulation, wobei die verfügbaren Funktionen von der jeweiligen SQL-Implementierung abhängen. Die meisten SQL-Implementierungen ermöglichen es jedoch, das aktuelle Datum und die aktuelle Uhrzeit durch Abfragen der Werte `current_date` und `current_time` zu ermitteln.

Um beispielsweise das heutige Datum zu ermitteln, ist die Syntax kurz und besteht lediglich aus der SELECT-Anweisung und der Funktion current_date, etwa so:

SELECT current_date;

Output
+--------------+
| current_date |
+--------------+
| 2022-02-15 |
+--------------+
1 row in set (0.00 sec)

Mit der gleichen Syntax können Sie die aktuelle Zeit mit der Funktion current_time ermitteln:

SELECT current_time;

Output
+--------------+
| current_time |
+--------------+
| 17:10:20 |
+--------------+
1 row in set (0.00 sec)

Wenn Sie Datum und Uhrzeit in der Ausgabe abfragen möchten, verwenden Sie die Funktion current_timestamp:

SELECT current_timestamp;

Output
+---------------------+
| current_timestamp |
+---------------------+
| 2022-02-15 19:09:58 |
+---------------------+
1 row in set (0.00 sec)

Sie können Datums- und Zeitfunktionen wie diese in arithmetischen Funktionen ähnlich dem vorherigen Abschnitt verwenden. Angenommen, Sie möchten wissen, welches Datum vor elf Tagen war. In diesem Fall können Sie dieselbe Syntax wie für die Abfrage der Funktion `current_date` verwenden und anschließend 11 davon subtrahieren, um das Datum vor elf Tagen zu ermitteln.

SELECT current_date - 11;

Output
+-------------------+
| current_date - 11 |
+-------------------+
| 20220206 |
+-------------------+
1 row in set (0.01 sec)

Wie diese Ausgabe zeigt, war 11 Tage vor dem aktuellen Datum (zum Zeitpunkt des Verfassens dieses Artikels) der 6. Februar 2022. Versuchen Sie nun dieselbe Operation, ersetzen Sie aber das aktuelle Datum durch die Funktion aktuelle Zeit:

SELECT current_time - 11;

Output
+-------------------+
| current_time - 11 |
+-------------------+
| 233639 |
+-------------------+
1 row in set (0.00 sec)

Diese Ausgabe zeigt, dass beim Subtrahieren von 11 vom Wert von current_time 11 Sekunden abgezogen werden. Die zuvor mit der Funktion current_date durchgeführte Operation interpretierte 11 als Tage, nicht als Sekunden. Diese Inkonsistenz in der Zahleninterpretation kann bei der Arbeit mit Datums- und Zeitfunktionen zu Verwirrung führen. Anstatt Datums- und Zeitwerte durch Berechnungen wie diese zu manipulieren, ermöglichen viele Datenbankmanagementsysteme eine präzisere Angabe mithilfe von INTERVAL-Anweisungen.

INTERVAL-Ausdrücke ermöglichen es Ihnen, ein Datum oder eine Uhrzeit vor oder nach einem bestimmten Zeitintervall ab einem Datums- oder Zeitausdruck anzugeben. Sie müssen die folgende Form haben:

INTERVAL value unit

Um beispielsweise das Datum in fünf Tagen zu ermitteln, können Sie die folgende Abfrage ausführen:

SELECT current_date + INTERVAL '5' DAY AS "5_days_from_today";

Dieses Beispiel ermittelt den Wert von current_date und addiert anschließend den Intervallausdruck INTERVAL '5' DAY dazu. Dadurch wird das Datum in 5 Tagen zurückgegeben:

Output
+-------------------+
| 5_days_from_today |
+-------------------+
| 2022-03-06 |
+-------------------+
1 row in set (0.00 sec)

Dies ist wesentlich weniger mehrdeutig als die folgende Abfrage, die ein ähnliches, wenn auch nicht identisches Ergebnis liefert:

SELECT current_date + 5 AS "5_days_from_today";

Output
+-------------------+
| 5_days_from_today |
+-------------------+
| 20220306 |
+-------------------+
1 row in set (0.00 sec)

Beachten Sie, dass Sie Zeitintervalle von Datums- oder Zeitangaben subtrahieren können, um Werte vor einem bestimmten Datumswert zu ermitteln:

SELECT current_date - INTERVAL '7' MONTH AS "7_months_ago";

Output
+--------------+
| 7_months_ago |
+--------------+
| 2021-08-01 |
+--------------+
1 row in set (0.00 sec)

Welche Einheiten in INTERVAL-Anweisungen verwendet werden können, hängt von der Wahl des DBMS ab, wobei die meisten Optionen wie STUNDE, MINUTE und SEKUNDE bieten:

SELECT current_time + INTERVAL '6' HOUR AS "6_hours_from_now",
current_time - INTERVAL '5' MINUTE AS "5_minutes_ago",
current_time + INTERVAL '20' SECOND AS "20_seconds_from_now";

Output
+------------------+---------------+---------------------+
| 6_hours_from_now | 5_minutes_ago | 20_seconds_from_now |
+------------------+---------------+---------------------+
| 07:51:43 | 01:46:43 | 01:52:03.000000 |
+------------------+---------------+---------------------+
1 row in set (0.00 sec)

Nachdem Sie nun etwas über Intervallausdrücke und einige Datums- und Zeitfunktionen gelernt haben, üben Sie weiter mit den Beispieldaten, die Sie im ersten Schritt eingegeben haben.

Verwendung von CAST- und Aggregatfunktionen mit Datums- und Zeitangaben

Erinnern Sie sich an das dritte Beispiel im Abschnitt „Arithmetische Operationen mit Datum und Uhrzeit“, als Sie die folgende Abfrage ausgeführt haben, um die Endzeit von der Startzeit zu subtrahieren und so die Gesamtlaufzeit jedes Läufers in jedem Rennen zu berechnen. Die Ausgabe führte jedoch zu einer Spalte mit einer sehr langen Ausgabe, die dem in der Tabelle festgelegten Datentyp TIMESTAMP folgte:

SELECT runner_name, race_name, end_time - start_time 
AS total_time 
FROM race_results;

Output
+-------------+---------------+----------------+
| runner_name | race_name | total_time |
+-------------+---------------+----------------+
| bolt | 1600_meters | 20220918000630 |
| bolt | 5K | 20221019002231 |
| bolt | 10K | 20221120003805 |
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | 1600_meters | 20220918000715 |
| felix | 5K | 20221019003050 |
| felix | 10K | 20221120011017 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+----------------+
10 rows in set (0.00 sec)

Da Sie eine Operation auf zwei Spalten mit unterschiedlichen Datentypen durchführen (end_time enthält TIMESTAMP-Werte und start_time enthält TIME-Werte), weiß die Datenbank nicht, welchen Datentyp sie beim Ausgeben des Ergebnisses verwenden soll. Daher konvertiert sie beide Werte in Ganzzahlen, um die Operation durchzuführen, was zu langen Zahlen in der Spalte total_time führt.

Um die Daten lesbarer und verständlicher zu machen, können Sie die Funktion CAST verwenden, um diese langen Ganzzahlwerte in den Datentyp TIME umzuwandeln. Beginnen Sie dazu mit CAST, gefolgt von einer öffnenden Klammer, den zu konvertierenden Werten und anschließend dem Schlüsselwort AS sowie dem Zieldatentyp.

Die folgende Abfrage ist identisch mit dem vorherigen Beispiel, verwendet jedoch eine CAST-Funktion, um die Spalte total_time in den Datentyp Zeit zu konvertieren:

SELECT runner_name, race_name, CAST(end_time - start_time AS time)
AS total_time 
FROM race_results;

Output
+-------------+---------------+------------+
| runner_name | race_name | total_time |
+-------------+---------------+------------+
| bolt | 1600_meters | 00:06:30 |
| bolt | 5K | 00:22:31 |
| bolt | 10K | 00:38:05 |
| bolt | half_marathon | 01:39:04 |
| bolt | full_marathon | 03:23:10 |
| felix | 1600_meters | 00:07:15 |
| felix | 5K | 00:30:50 |
| felix | 10K | 01:10:17 |
| felix | half_marathon | 02:11:57 |
| felix | full_marathon | 04:02:10 |
+-------------+---------------+------------+
10 rows in set (0.00 sec)

CAST wandelte die Datenwerte in dieser Ausgabe in TIME um, wodurch sie sehr gut lesbar und verständlich wurden.

Nun verwenden wir einige Aggregatfunktionen in Kombination mit der CAST-Funktion, um die kürzeste, längste und Gesamtzeit jedes Läufers zu ermitteln. Zuerst suchen wir mit der MIN-Funktion nach der minimalen (oder kürzesten) Zeit. Auch hier verwenden wir CAST, um die TIMESTAMP-Datenwerte zur besseren Übersicht in TIME-Datenwerte umzuwandeln. Beachten Sie, dass bei der Verwendung zweier Funktionen wie in diesem Beispiel zwei Klammerpaare erforderlich sind und die Berechnung der Gesamtzeit (Endzeit - Startzeit) in einer davon erfolgen muss. Fügen Sie abschließend eine GROUP BY-Klausel hinzu, um diese Werte nach der Spalte „Läufername“ zu sortieren und die Rennergebnisse anzuzeigen.

SELECT runner_name, MIN(CAST(end_time - start_time AS time)) AS min_time
FROM race_results GROUP BY runner_name;

Output
+-------------+----------+
| runner_name | min_time |
+-------------+----------+
| bolt | 00:06:30 |
| felix | 00:07:15 |
+-------------+----------+
2 rows in set (0.00 sec)

Diese Ausgabe zeigt die kürzeste Zeit des Läufers an, in diesem Fall mindestens sechs Minuten und 30 Sekunden für Bolt und sieben Minuten und 15 Sekunden für Felix.

Ermitteln Sie als Nächstes die längste Ausführungszeit für jeden Runner. Sie können dieselbe Syntax wie in der vorherigen Anweisung verwenden, ersetzen Sie diesmal jedoch MIN durch MAX:

SELECT runner_name, MAX(CAST(end_time - start_time AS time)) AS max_time
FROM race_results GROUP BY runner_name;

Output
+-------------+----------+
| runner_name | max_time |
+-------------+----------+
| bolt | 03:23:10 |
| felix | 04:02:10 |
+-------------+----------+
2 rows in set (0.00 sec)

Diese Ausgabe zeigt, dass Bolts längste Laufzeit insgesamt drei Stunden, 23 Minuten und 10 Sekunden betrug. Und Felix' Laufzeit betrug insgesamt vier Stunden, zwei Minuten und 10 Sekunden.

Nun fragen wir die Gesamtstunden jedes Läufers ab. Verwenden Sie dazu die SUMME-Funktion, um die Gesamtstunden anhand von end_time - start_time zu berechnen, und wandeln Sie diese Datenwerte mit CAST in das Zeitformat TIME um. Vergessen Sie nicht, GROUP BY hinzuzufügen, um die Ergebnisse für jeden Läufer zu sortieren.

SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;

Output
+-------------+-------------+
| runner_name | total_hours |
+-------------+-------------+
| bolt | 52880 |
| felix | 76149 |
+-------------+-------------+
2 rows in set (0.00 sec)

Interessanterweise zeigt diese Ausgabe, dass MySQL die Gesamtzeit als Ganzzahl interpretiert. Würde man diese Ergebnisse als Zeiten lesen, würde Bolts Gesamtzeit in fünf Stunden, 28 Minuten und 80 Sekunden unterteilt. Felix' Zeit würde in sieben Stunden, 61 Minuten und 49 Sekunden unterteilt. Wie man sieht, ist dies keine logische Zeitaufteilung, was darauf hindeutet, dass die Zeit als Ganzzahl und nicht als Zeit berechnet wird. Wenn man dies beispielsweise in einem anderen DBMS wie PostgreSQL versucht, sähe dieselbe Abfrage etwas anders aus:

SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;

Output
runner_name | total_hours
-------------+-------------
felix | 10:01:44
bolt | 06:09:20
(2 rows)

In diesem Fall interpretiert die PostgreSQL-Abfrage die Werte als Zeitangaben und berechnet sie entsprechend. Felix' Ergebnis ergibt sich daher zu insgesamt 10 Stunden, einer Minute und 44 Sekunden, während Bolts Ergebnis sechs Stunden, neun Minuten und 20 Sekunden beträgt. Dies ist ein Beispiel dafür, wie unterschiedliche DBMS-Implementierungen Datenwerte unterschiedlich interpretieren können, selbst wenn sie dieselbe Abfrage und denselben Datensatz verwenden.

Ergebnis

Das Verständnis der Verwendung von Datum und Uhrzeit in SQL ist hilfreich, wenn Sie nach bestimmten Ergebnissen wie Minuten, Sekunden, Stunden, Tagen, Monaten, Jahren oder einer Kombination davon suchen. Darüber hinaus gibt es zahlreiche Funktionen für Datum und Uhrzeit, die das Auffinden bestimmter Werte wie des aktuellen Datums oder der aktuellen Uhrzeit vereinfachen. Dieses Tutorial behandelt zwar nur Additions- und Subtraktionsberechnungen mit Datum und Uhrzeit in SQL, Sie können Datums- und Uhrzeitwerte jedoch mit beliebigen mathematischen Ausdrücken verwenden. Weitere Informationen finden Sie in unserem Leitfaden zu mathematischen Ausdrücken und Additionsfunktionen. Probieren Sie diese gerne bei Ihren Datums- und Uhrzeitabfragen aus.