Datums- und Zeitwerte in SQL effektiv nutzen: Ein umfassender Leitfaden
Einführung
Beim Arbeiten mit relationalen Datenbanken und Structured Query Language (SQL) kann es Situationen geben, in denen Sie mit Werten arbeiten müssen, die bestimmte Daten oder Zeiten repräsentieren. Zum Beispiel müssen Sie möglicherweise die insgesamt aufgewendeten Stunden für eine bestimmte Aktivität berechnen oder Datums- oder Zeitwerte mithilfe mathematischer Operatoren und Aggregatfunktionen manipulieren, um deren Summe oder Durchschnitt zu berechnen.
In diesem Tutorial lernen Sie, wie man mit Datums- und Zeitwerten in SQL arbeitet. Sie beginnen damit, Arithmetik durchzuführen und verschiedene Funktionen mit Datums- und Zeitwerten nur mit der SELECT-Anweisung zu verwenden. Anschließend üben Sie, indem Sie Abfragen auf Beispieldaten ausführen und lernen, wie man die CAST-Funktion anwendet, um die Ausgabe besser lesbar zu machen.
Voraussetzungen ür Datums- und Zeitwerte in SQL
Um dieses Tutorial abzuschließen, benötigen Sie:
- Ein Server, der Ubuntu 20.04 ausführt, mit einem Nicht-Root-Benutzer mit sudo-Administrationsrechten und aktiviertem Firewall. Folgen Sie unserem Initial Server Setup mit Ubuntu 20.04, um loszulegen.
- MySQL installiert und auf dem Server gesichert. Folgen Sie unserem How To Install MySQL on Ubuntu 20.04 Guide, um dies einzurichten. Dieser Leitfaden geht davon aus, dass Sie auch einen Nicht-Root-Mysql-Benutzer eingerichtet haben, wie in Schritt 3 dieses Leitfadens beschrieben.
Hinweis: Bitte beachten Sie, dass viele relationale Datenbankmanagementsysteme ihre eigenen spezifischen Implementierungen von SQL verwenden. Obwohl die in diesem Tutorial beschriebenen Befehle auf den meisten RDBMSs funktionieren, kann die genaue Syntax oder Ausgabe abweichen, wenn Sie sie auf einem System testen, das nicht MySQL ist.
Um mit Datums- und Zeitwerten in diesem Tutorial zu üben, benötigen Sie eine Datenbank und eine Tabelle, die mit Beispieldaten gefüllt ist. Wenn Sie noch keine haben, können Sie den Abschnitt „Mit MySQL verbinden und eine Beispieldatenbank einrichten“ lesen, um zu erfahren, wie Sie eine Datenbank und eine Tabelle erstellen. Dieses Tutorial wird sich throughout auf diese Beispieldatenbank und Tabelle beziehen.
Mit MySQL verbinden und eine Beispieldatenbank einrichten
Wenn Ihre SQL-Datenbank auf einem Remote-Server läuft, stellen Sie eine SSH-Verbindung von Ihrem lokalen Computer aus her:
ssh sammy@your_server_ip
Öffnen Sie dann die MySQL-Eingabeaufforderung und ersetzen Sie „sammy“ mit Ihren MySQL-Benutzerdaten:
mysql -u sammy -p
Erstellen Sie eine Datenbank namens datetimeDB:
CREATE DATABASE datetimeDB;
Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie die folgende Ausgabe:
Query OK, 1 row affected (0.01 sec)
Um die datetimeDB-Datenbank auszuwählen, führen Sie den folgenden USE-Befehl aus:
USE datetimeDB;
Ausgabe:
Database changed
Nach der Auswahl der Datenbank erstellen Sie eine Tabelle darin. Für dieses Tutorial erstellen wir eine Tabelle, die die Ergebnisse von zwei Läufern für verschiedene Rennen enthält, die sie im Laufe eines Jahres absolviert haben. Diese Tabelle enthält die folgenden sieben Spalten:
- race_id: zeigt Werte des Datentyps int und dient als Primärschlüssel der Tabelle, was bedeutet, dass jeder Wert in dieser Spalte als eindeutiger Bezeichner für die jeweilige Zeile fungiert.
- 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 die Namen der Rennen mit dem varchar-Datentyp, maximal 20 Zeichen.
- start_day: verwendet den DATE-Datentyp, um das Datum eines bestimmten Rennens nach Jahr, Monat und Tag zu verfolgen. Dieser Datentyp folgt den folgenden Parametern: vier Ziffern für das Jahr und maximal zwei Ziffern für den Monat und Tag (YYYY-MM-DD).
- start_time: stellt die Startzeit des Rennens mit dem TIME-Datentyp in Stunden, Minuten und Sekunden (HH:MM:SS) dar. Dieser Datentyp folgt dem 24-Stunden-Format, z.B. 15:00 für 3:00 pm.
- total_miles: zeigt die Gesamtstrecke für jedes Rennen mit dem Dezimal-Datentyp, da viele der Gesamtstrecken pro Rennen keine ganzen Zahlen sind. In diesem Fall gibt decimal eine Genauigkeit von drei und eine Skala von eins an, was bedeutet, dass Werte in dieser Spalte drei Ziffern haben können, von denen eine Ziffer nach dem Dezimalpunkt steht.
- end_time: verwendet den TIMESTAMP-Datentyp, um die Zeiten der Läufer am Ende des Rennens zu verfolgen. Dieser Datentyp kombiniert sowohl Datum als auch Zeit in einem String, wobei das Format eine Kombination von DATE und TIME ist: (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)
);
Fügen Sie dann 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');
Ausgabe:
Query OK, 10 rows affected (0.00 sec)
Nachdem Sie die Daten eingefügt haben, können Sie mit der Übung von Arithmetik und Funktionen mit Datums- und Zeitwerten in SQL beginnen.
Arithmetik mit Datums- und Zeitwerten in SQL verwenden
In SQL können Sie Datums- und Zeitwerte mithilfe mathematischer Ausdrücke manipulieren. Alles, was erforderlich ist, ist der mathematische Operator und die Werte, die Sie berechnen möchten.
Ein Beispiel: 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 fügt 17 hinzu, um das Datum 17 Tage nach dem angegebenen Datum zu erhalten. Beachten Sie, dass dieses Beispiel 2022-10-05 als DATE-Wert angibt, um sicherzustellen, dass das DBMS den Wert nicht als String oder einen anderen Datentyp interpretiert:
SELECT DATE '2022-10-05' + 17 AS new_date;
Ausgabe:
+----------+
| new_date |
+----------+
| 20221022 |
+----------+
1 row in set (0.01 sec)
Wie diese Ausgabe zeigt, ist 17 Tage nach dem 2022-10-05 das Datum 2022-10-22, also der 22. Oktober 2022.
Ein weiteres Beispiel: Angenommen, Sie möchten die gesamten Stunden zwischen zwei verschiedenen Zeiten berechnen. Dies können Sie tun, indem Sie die beiden Zeiten voneinander abziehen. Die folgende Abfrage nimmt 11:00 als erste Zeit und 3:00 als zweite Zeit. Hier müssen Sie beide als TIME-Werte angeben, um die Differenz in Stunden zu erhalten:
SELECT TIME '11:00' - TIME '3:00' AS time_diff;
Ausgabe:
+-----------+
| time_diff |
+-----------+
| 80000 |
+-----------+
1 row in set (0.00 sec)
Diese Ausgabe zeigt, dass die Differenz zwischen 11:00 und 3:00 80000 beträgt, also 8 Stunden.
Nun üben Sie mit der Arithmetik auf den Datums- und Zeitwerten aus den Beispieldaten. Für die erste Abfrage berechnen Sie die gesamte Zeit, die die Läufer für jedes Rennen benötigt haben, indem Sie end_time von start_time abziehen:
SELECT runner_name, race_name, end_time - start_time
AS total_time
FROM race_results;
Ausgabe:
+-------------+---------------+----------------+
| 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 ziemlich lang und schwer zu lesen ist. Später zeigen wir Ihnen, wie Sie die CAST-Funktion verwenden können, um diese Werte klarer darzustellen.
Jetzt, wenn Sie nur an der Leistung jedes Läufers für längere Rennen interessiert sind, wie zum Beispiel bei Halbmarathons und Marathons, können Sie Ihre Daten abfragen, um diese Informationen zu erhalten. Führen Sie dazu die Abfrage aus, indem Sie end_time von start_time abziehen und Ihre Ergebnisse mit der WHERE-Klausel auf Daten mit einer total_miles größer als 12 eingrenzen:
SELECT runner_name, race_name, end_time - start_time AS half_full_results
FROM race_results
WHERE total_miles > 12;
Ausgabe:
+-------------+---------------+-------------------+
| 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)
Verwendung von Datums- und Zeitfunktionen und INTERVAL-Ausdrücken
Es gibt mehrere Funktionen, die verwendet werden können, um Datums- und Zeitwerte in SQL zu finden und zu manipulieren. SQL-Funktionen werden typischerweise verwendet, um Daten zu verarbeiten oder zu manipulieren, und die verfügbaren Funktionen hängen von der SQL-Implementierung ab. Die meisten SQL-Implementierungen erlauben es jedoch, das aktuelle Datum und die aktuelle Uhrzeit abzufragen, indem man die Funktionen current_date und current_time verwendet.
Um das heutige Datum zu finden, verwenden Sie die kurze Syntax mit der SELECT-Anweisung und der current_date-Funktion wie folgt:
SELECT current_date;
Ausgabe:
+--------------+
| current_date |
+--------------+
| 2022-02-15 |
+--------------+
1 row in set (0.00 sec)
Mit der gleichen Syntax können Sie die aktuelle Zeit mit der current_time-Funktion finden:
SELECT current_time;
Ausgabe:
+--------------+
| current_time |
+--------------+
| 17:10:20 |
+--------------+
1 row in set (0.00 sec)
Wenn Sie lieber sowohl das Datum als auch die Uhrzeit in der Ausgabe abfragen möchten, verwenden Sie die current_timestamp-Funktion:
SELECT current_timestamp;
Ausgabe:
+---------------------+
| current_timestamp |
+---------------------+
| 2022-02-15 19:09:58 |
+---------------------+
1 row in set (0.00 sec)
Sie können solche Datums- und Zeitfunktionen auch innerhalb von Arithmetikfunktionen wie im vorherigen Abschnitt verwenden. Wenn Sie beispielsweise wissen möchten, welches Datum vor 11 Tagen von heute war, können Sie die gleiche Syntax verwenden, um die current_date-Funktion abzufragen und dann 11 davon zu subtrahieren, um das Datum von vor elf Tagen zu finden:
SELECT current_date - 11;
Ausgabe:
+-------------------+
| current_date - 11 |
+-------------------+
| 20220206 |
+-------------------+
1 row in set (0.01 sec)
Wie diese Ausgabe zeigt, war der 6. Februar 2022, also 11 Tage vor dem aktuellen Datum (zum Zeitpunkt des Schreibens). Versuchen Sie nun, den gleichen Vorgang auszuführen, aber ersetzen Sie current_date durch die current_time-Funktion:
SELECT current_time - 11;
Ausgabe:
+-------------------+
| current_time - 11 |
+-------------------+
| 233639 |
+-------------------+
1 row in set (0.00 sec)
Diese Ausgabe zeigt, dass, wenn Sie 11 von current_time subtrahieren, 11 Sekunden abgezogen werden. Die Operation, die Sie vorher mit der current_date-Funktion durchgeführt haben, interpretierte die Zahl 11 als Tage und nicht als Sekunden. Diese Inkonsistenz, wie Zahlen bei der Arbeit mit Datums- und Zeitfunktionen interpretiert werden, kann verwirrend sein. Anstatt Datums- und Zeitwerte auf diese Weise mit Arithmetik zu manipulieren, lassen viele Datenbankmanagementsysteme eine explizitere Verwendung von INTERVAL-Ausdrücken zu.
INTERVAL-Ausdrücke ermöglichen es Ihnen zu berechnen, welches Datum oder welche Uhrzeit vor oder nach einem festgelegten Intervall von einem angegebenen Datum oder einer angegebenen Uhrzeit liegen würde. Sie müssen folgendermaßen aussehen:
Beispiel für einen Intervallexpression:
INTERVAL Wert Einheit
Um zum Beispiel das Datum fünf Tage in der Zukunft zu finden, könnten Sie die folgende Abfrage ausführen:
SELECT current_date + INTERVAL '5' DAY AS "5_days_from_today";
Dieses Beispiel findet den current_date-Wert und fügt dann die Intervallexpression INTERVAL ‚5‘ DAY hinzu, um das Datum in fünf Tagen zurückzugeben:
+-------------------+
| 5_days_from_today |
+-------------------+
| 2022-03-06 |
+-------------------+
1 row in set (0.00 sec)
Dies ist viel weniger mehrdeutig als die folgende Abfrage, die ähnliche, aber nicht identische Ausgaben produziert:
SELECT current_date + 5 AS "5_days_from_today";
Ausgabe:
+-------------------+
| 5_days_from_today |
+-------------------+
| 20220306 |
+-------------------+
1 row in set (0.00 sec)
Beachten Sie, dass Sie auch Intervalle von Daten oder Zeiten subtrahieren können, um Werte vor dem angegebenen Datum zu finden:
SELECT current_date - INTERVAL '7' MONTH AS "7_months_ago";
Ausgabe:
+--------------+
| 7_months_ago |
+--------------+
| 2021-08-01 |
+--------------+
1 row in set (0.00 sec)
Welche Einheiten Sie in INTERVAL-Ausdrücken verwenden können, hängt von Ihrer Wahl des DBMS ab. Die meisten bieten jedoch Optionen wie STUNDE, MINUTE und SEKUNDE:
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";
Ausgabe:
+------------------+---------------+---------------------+
| 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)
Verwendung von CAST und Aggregatfunktionen mit Datums- und Zeitwerten in SQL
Erinnern Sie sich an das dritte Beispiel im Abschnitt „Arithmetik mit Datums- und Zeitwerten“, als Sie die folgende Abfrage ausführten, um end_time von start_time zu subtrahieren und die Gesamtstunden zu berechnen, die jeder Läufer in jedem Rennen verbracht hat. Das Ergebnis war jedoch eine sehr lange Ausgabe, die dem TIMESTAMP-Datentyp entspricht, der in der Tabelle festgelegt wurde:
SELECT runner_name, race_name, end_time - start_time
AS total_time
FROM race_results;
Ausgabe:
+-------------+---------------+----------------+
| 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 mit zwei Spalten unterschiedlicher Datentypen durchführen (end_time enthält TIMESTAMP-Werte und start_time enthält TIME-Werte), weiß die Datenbank nicht, welchen Datentyp sie verwenden soll, wenn sie das Ergebnis der Operation ausgibt. Stattdessen werden beide Werte in Ganzzahlen konvertiert, damit die Operation durchgeführt werden kann, was zu den langen Zahlen in der Spalte total_time führt.
Um diese Daten lesbarer zu machen, können Sie die CAST-Funktion verwenden, um diese langen Ganzzahlenwerte in den TIME-Datentyp zu konvertieren. Dafür beginnen Sie mit CAST und fügen dann sofort eine öffnende Klammer, die zu konvertierenden Werte und das AS-Schlüsselwort mit dem gewünschten Datentyp hinzu.
Die folgende Abfrage ist identisch mit dem vorherigen Beispiel, verwendet jedoch die CAST-Funktion, um die Spalte total_time in den TIME-Datentyp zu konvertieren:
SELECT runner_name, race_name, CAST(end_time - start_time AS time)
AS total_time
FROM race_results;
Ausgabe:
+-------------+---------------+------------+
| 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 hat die Datenwerte in dieser Ausgabe in TIME konvertiert, wodurch die Werte deutlich lesbarer und verständlicher wurden.
Nun verwenden wir einige Aggregatfunktionen in Kombination mit der CAST-Funktion, um die kürzeste, längste und gesamte Zeit jedes Läufers zu finden. Zuerst fragen wir die minimale (oder kürzeste) Zeit mit der MIN-Aggregatfunktion ab. Denken Sie daran, CAST zu verwenden, um die TIMESTAMP-Datenwerte in TIME-Werte zu konvertieren, damit die Ausgabe klarer wird. Beachten Sie bitte, dass bei der Verwendung von zwei Funktionen wie in diesem Beispiel zwei Klammerpaare erforderlich sind und die Berechnung der Gesamtstunden (end_time – start_time) in einem der Paare verschachtelt sein sollte. Fügen Sie zuletzt eine GROUP BY-Klausel hinzu, um diese Werte anhand der Spalte runner_name zu organisieren, damit die Ausgabe die Renn-Ergebnisse der beiden Läufer zeigt:
SELECT runner_name, MIN(CAST(end_time - start_time AS time)) AS min_time
FROM race_results GROUP BY runner_name;
Ausgabe:
+-------------+----------+
| 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 Laufzeit jedes Läufers, in diesem Fall 6 Minuten 30 Sekunden für Bolt und 7 Minuten 15 Sekunden für Felix.
Nun finden wir die längste Laufzeit jedes Läufers. Sie können die gleiche Syntax wie bei der vorherigen Abfrage verwenden, ersetzen aber MIN durch MAX:
SELECT runner_name, MAX(CAST(end_time - start_time AS time)) AS max_time
FROM race_results GROUP BY runner_name;
Ausgabe:
+-------------+----------+
| 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 3 Stunden, 23 Minuten und 10 Sekunden betrug, während Felix 4 Stunden, 2 Minuten und 10 Sekunden benötigte.
Nun fragen wir einige allgemeine Informationen über die Gesamtzeit ab, die jeder Läufer beim Rennen verbracht hat. Für diese Abfrage kombinieren wir die SUM-Aggregatfunktion, um die gesamte Zeit basierend auf end_time – start_time zu berechnen, und verwenden CAST, um diese Datenwerte in TIME zu konvertieren. Vergessen Sie nicht, GROUP BY hinzuzufügen, um die Werte für beide Läufer zu organisieren:
SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;
Ausgabe:
+-------------+-------------+
| runner_name | total_hours |
+-------------+-------------+
| bolt | 52880 |
| felix | 76149 |
+-------------+-------------+
2 rows in set (0.00 sec)
Interessanterweise zeigt diese Ausgabe die Interpretation für MySQL, das die Gesamtzeit tatsächlich als Ganzzahlen berechnet. Wenn wir diese Ergebnisse als Zeit lesen, wird Bolts Gesamtzeit als 5 Stunden, 28 Minuten und 80 Sekunden dargestellt und Felix’ Zeit als 7 Stunden, 61 Minuten und 49 Sekunden. Diese Zeitaufteilung macht keinen Sinn, was darauf hinweist, dass sie als Ganzzahl und nicht als Zeit berechnet wird. Wenn Sie dies in einem anderen DBMS wie PostgreSQL versuchen, würde dieselbe Abfrage leicht anders aussehen:
SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;
Ausgabe:
runner_name | total_hours
-------------+-------------
felix | 10:01:44
bolt | 06:09:20
(2 rows)
In diesem Fall interpretiert die Abfrage in PostgreSQL die Werte als Zeit und berechnet sie als solche. Somit laufen Felix‘ Ergebnisse auf insgesamt 10 Stunden, 1 Minute und 44 Sekunden und Bolts auf 6 Stunden, 9 Minuten und 20 Sekunden hinaus. Dieses Beispiel zeigt, wie verschiedene DBMS-Datenwerte unterschiedlich interpretieren können, selbst bei gleicher Abfrage und Datenset.
Fazit
Das Arbeiten mit Datums- und Zeitwerten in SQL hilft, spezifische Ergebnisse wie Minuten, Stunden, Tage oder Jahre zu finden. Viele Funktionen für Datums- und Zeitwerte erleichtern das Finden des aktuellen Datums oder der Uhrzeit. In diesem Tutorial haben wir Arithmetik verwendet, aber Sie können Datums- und Zeitwerte mit beliebigen mathematischen Ausdrücken nutzen. Erfahren Sie mehr in unserem Leitfaden zu mathematischen Ausdrücken und Aggregatfunktionen und wenden Sie sie auf Ihre Abfragen an.
