Wie man mit Datum und Zeit in SQL arbeitet

Einführung

Bei der Arbeit mit relationalen Datenbanken und Structured Query Language (SQL) kann es Zeiten geben, in denen Sie mit Werten arbeiten müssen, die bestimmte Daten oder Zeiten darstellen. Möglicherweise müssen Sie beispielsweise die insgesamt verbrachten Stunden für eine bestimmte Aktivität berechnen, oder Sie müssen Datum- oder Zeitwerte mithilfe mathematischer Operatoren und Aggregatfunktionen manipulieren, um ihre Summe oder ihren Durchschnitt zu berechnen.

In diesem Tutorial erfahren Sie, wie Sie Datum und Uhrzeit in SQL verwenden. Sie beginnen damit, Arithmetik durchzuführen und verschiedene Funktionen mit Daten und Zeiten nur mithilfe des SELECT-Statements zu verwenden. Anschließend üben Sie, indem Sie Abfragen auf Beispieldaten ausführen, und Sie lernen, wie Sie die Funktion CAST implementieren, um die Ausgabe besser lesbar zu machen.

Voraussetzungen

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

• A server running Ubuntu 20.04, with a non-root user with sudo administrative privileges and firewall enabled. Follow our Initial Server Setup with Ubuntu 20.04 to get started.
• MySQL installiert und auf dem Server gesichert. Befolgen Sie unsere Anleitung So installieren Sie MySQL auf Ubuntu 20.04, um dies einzurichten. Diese Anleitung setzt voraus, dass Sie auch einen nicht-root MySQL-Benutzer eingerichtet haben, wie in Schritt 3 dieser Anleitung beschrieben.

Um das Arbeiten mit Datum und Uhrzeit in diesem Tutorial zu üben, benötigen Sie eine Datenbank und eine Tabelle, die mit Beispieldaten geladen ist. Wenn Sie keine bereit haben, können Sie den folgenden Verbindung zu MySQL und Einrichten einer Beispieldatenbank Abschnitt lesen, um zu erfahren, wie Sie eine Datenbank und Tabelle erstellen. In diesem Tutorial wird auf diese Beispieldatenbank und -tabelle verwiesen.

Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten

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

ssh sammy@your_server_ip

Öffnen Sie dann die MySQL-Eingabeaufforderung und ersetzen Sie sammy durch Ihre MySQL-Benutzerkontoinformationen:

mysql -u sammy -p

Erstellen Sie eine Datenbank mit dem Namen datetimeDB:

CREATE DATABASE datetimeDB;

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

Output
Query OK, 1 row affected (0.01 sec)

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

USE datetimeDB;

Output
Database changed

Nach Auswahl der Datenbank erstellen Sie darin eine Tabelle. Für das Beispiel dieses Tutorials erstellen wir eine Tabelle, die die Ergebnisse zweier Läufer für verschiedene Rennen im Verlauf eines Jahres enthält. Diese Tabelle wird die folgenden sieben Spalten enthalten:

• race_id: zeigt Werte vom Datentyp int an 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 Rennarten mit dem Datentyp varchar mit maximal 20 Zeichen.
• start_day: verwendet den Datentyp DATE, um das Datum eines bestimmten Rennens nach Jahr, Monat und Tag zu verfolgen. Dieser Datentyp entspricht den folgenden Parametern: vier Ziffern für das Jahr und maximal zwei Ziffern für den Monat und den Tag (YYYY-MM-DD).
• start_time: stellt die Startzeit des Rennens mit dem Datentyp TIME nach Stunden, Minuten und Sekunden dar (HH:MM:SS). Dieser Datentyp folgt einem 24-Stunden-Format, wie zum Beispiel 15:00 für die Äquivalenz von 15:00 Uhr.
• Gesamtkilometer: zeigt die Gesamtkilometerleistung für jedes Rennen unter Verwendung des Datentyps DECIMAL an, da viele der Gesamtkilometer pro Rennen keine ganzen Zahlen sind. In diesem Fall gibt DECIMAL eine Genauigkeit von drei mit einer Skalierung von eins an, was bedeutet, dass Werte in dieser Spalte drei Stellen haben können, wobei eine dieser Stellen rechts vom Dezimalpunkt liegt.
• Endzeit: verwendet den Datentyp ZEITSTEMPEL, um die Laufzeiten der Läufer am Ende des Rennens zu verfolgen. Dieser Datentyp kombiniert sowohl Datum als auch Uhrzeit in einem String, und sein Format ist eine Kombination aus denen von DATUM und ZEIT: (JJJJ-MM-TT SS:MM:SS).

Erstellen Sie die Tabelle, indem Sie den CREATE TABLE-Befehl ausführen:

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 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

Nachdem Sie die Daten eingefügt haben, können Sie mit der Praxis einiger arithmetischer Operationen und Funktionen mit Datum und Uhrzeit in SQL beginnen.

Verwendung von Arithmetik mit Datum und Uhrzeit

In SQL können Sie Datum- und Uhrzeitwerte mithilfe von mathematischen Ausdrücken manipulieren. Alles, was benötigt wird, ist der mathematische Operator und die Werte, die Sie berechnen möchten.

Als Beispiel, sagen wir, 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 den Wert für das Datum siebzehn Tage nach dem in der Abfrage angegebenen zurückzugeben. Beachten Sie, dass dieses Beispiel 2022-10-05 als einen DATE-Wert spezifiziert, um sicherzustellen, dass das DBMS es nicht als Zeichenfolge 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 anzeigt, ist 17 Tage nach 2022-10-05 der 2022-10-22, oder 22. Oktober 2022.

Als weiteres Beispiel, sagen wir, Sie möchten die Gesamtstunden zwischen zwei verschiedenen Zeiten berechnen. Dies können Sie tun, indem Sie die eine Zeit von der anderen subtrahieren. Für die folgende Abfrage ist 11:00 der erste Zeitwert und 3:00 der zweite Zeitwert. Hier müssen Sie angeben, dass beide TIME-Werte sind, um die Differenz in Stunden zurückzugeben:

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 der Unterschied zwischen 11:00 und 3:00 80000 beträgt, oder 8 Stunden.

Üben Sie nun, arithmetische Operationen mit den Datums- und Zeitinformationen aus den Beispieldaten durchzuführen. Für die erste Abfrage berechnen Sie die Gesamtzeit, die die Läufer benötigt haben, um jedes Rennen zu beenden, indem Sie end_time von der start_time 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 diese Ausgabe in der total_time-Spalte ziemlich lang und schwer zu lesen ist. Später werden wir zeigen, wie Sie die CAST-Funktion verwenden, um diese Datenwerte so zu konvertieren, dass sie klarer lesbar sind.

Nun, wenn Sie nur an der Leistung jedes Läufers bei längeren Rennen interessiert waren, wie zum Beispiel Halb- und Vollmarathons, können Sie Ihre Daten abfragen, um diese Informationen abzurufen. Für diese Abfrage subtrahieren Sie end_time von start_time und begrenzen Ihre Ergebnisse, indem Sie die WHERE-Klausel verwenden, um Daten abzurufen, bei denen total_miles größer als 12 waren:

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 arithmetische Operationen mit Datum und Uhrzeit mit dem SELECT-Statement durchgeführt und zu praktischen Zwecken auf den Beispieldaten. Als nächstes werden Sie Abfragen mit verschiedenen Datum- und Uhrzeitfunktionen üben.

Verwendung von Datum- und Uhrzeitfunktionen und Intervallausdrücken

Es gibt mehrere Funktionen, die verwendet werden können, um Datum- und Uhrzeitwerte in SQL zu finden und zu manipulieren. SQL-Funktionen werden in der Regel 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 zu finden, indem man nach den Werten current_date und current_time abfragt.

Um zum Beispiel das heutige Datum zu finden, ist die Syntax kurz und besteht nur aus dem SELECT-Statement und der current_date-Funktion wie folgt:

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 Uhrzeit mit der Funktion current_time finden:

SELECT current_time;

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

Wenn Sie sowohl Datum als auch Uhrzeit im Ausgabewert 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 Datum- und Zeitfunktionen wie diese innerhalb von arithmetischen Funktionen ähnlich wie im vorherigen Abschnitt verwenden. Zum Beispiel, wenn Sie wissen möchten, welches Datum vor 11 Tagen vom heutigen Datum war, könnten Sie dieselbe Syntaxstruktur wie zuvor verwenden, um die Funktion current_date abzufragen und dann 11 davon abzuziehen, um das Datum von vor elf Tagen zu finden:

SELECT current_date - 11;

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

Wie diese Ausgabe zeigt, war vor 11 Tagen vom current_date (zum Zeitpunkt dieser Abfassung) der 2022-02-06 oder der 6. Februar 2022. Versuchen Sie nun, dieselbe Operation auszuführen, aber ersetzen Sie current_date durch die Funktion current_time:

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 ausgeführte Operation mit der Funktion current_date hat 11 als Tage und nicht als Sekunden interpretiert. Diese Inkonsistenz bei der Interpretation von Zahlen bei der Arbeit mit Datum- und Zeitfunktionen kann verwirrend sein. Anstatt Sie zu zwingen, Datum- und Zeitwerte auf diese Weise durch Arithmetik zu manipulieren, ermöglichen es Ihnen viele Datenbankverwaltungssysteme, expliziter zu sein, indem sie INTERVAL-Ausdrücke verwenden:

INTERVAL-Ausdrücke ermöglichen es Ihnen, das Datum oder die Zeit vor oder nach einem festgelegten Intervall von einem gegebenen Datum oder Zeitausdruck zu finden. Sie müssen die folgende Form haben:

INTERVAL value unit

Zum Beispiel, um das Datum von fünf Tagen ab heute zu finden, könnten 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 fügt dann den Intervallausdruck INTERVAL '5' DAY hinzu. Dies gibt das Datum von 5 Tagen ab jetzt zurück:

Output
+-------------------+
| 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 erzeugt:

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 auch Intervalle von Daten oder Zeiten subtrahieren können, um Werte von vor dem angegebenen Datumswert zu finden:

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 Sie in INTERVAL-Ausdrücken verwenden können, hängt von Ihrer Wahl des DBMS ab, obwohl die meisten Optionen wie HOUR, MINUTE und SECOND haben werden:

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)

Jetzt, da Sie etwas über Intervallausdrücke und einige Datum- und Uhrzeitfunktionen gelernt haben, fahren Sie fort und üben Sie mit den Beispieldaten, die Sie im ersten Schritt eingefügt haben.

Verwendung von CAST und Aggregatfunktionen mit Datum und Uhrzeit

Erinnern Sie sich an das dritte Beispiel im Abschnitt Verwendung von Arithmetik mit Datum und Uhrzeit, als Sie die folgende Abfrage ausgeführt haben, um end_time von start_time abzuziehen, um die Gesamtstunden zu berechnen, die jeder Läufer pro Rennen absolviert hat. Die Ausgabe resultierte jedoch in einer Spalte mit einer sehr langen Ausgabe, die dem TIMESTAMP-Datentyp folgte, der in der Tabelle festgelegt wurde:

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 mit zwei Spalten durchführen, die unterschiedliche Datentypen haben (end_time hält TIMESTAMP-Werte und start_time hält TIME-Werte), weiß die Datenbank nicht, welchen Datentyp sie verwenden soll, wenn sie das Ergebnis der Operation ausgibt. Stattdessen wandelt sie beide Werte in Ganzzahlen um, um die Operation durchzuführen, was zu den langen Zahlen in der total_time-Spalte führt.

Um diese Daten klarer zu lesen und zu interpretieren, können Sie die CAST-Funktion verwenden, um diese langen Ganzzahlwerte in den Datentyp TIME umzuwandeln. Dazu verwenden Sie CAST und dann unmittelbar danach eine öffnende Klammer, die zu konvertierenden Werte und dann das AS-Schlüsselwort und den Datentyp, in den Sie sie konvertieren möchten.

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

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 hat die Datenwerte in TIME in dieser Ausgabe umgewandelt, was sie viel leichter lesbar und verständlich macht.

Nun verwenden wir ein paar Aggregatfunktionen in Kombination mit der CAST-Funktion, um die kürzeste, längste und Gesamtzeit der Läufer zu finden. Zuerst fragen Sie nach der minimalen (oder kürzesten) verstrichenen Zeit mit der MIN-Aggregatfunktion ab. Erneut möchten Sie die CAST-Funktion verwenden, um die TIMESTAMP-Datenwerte in TIME-Datenwerte umzuwandeln, um die Klarheit zu verbessern. Bitte beachten Sie, dass bei der Verwendung von zwei Funktionen wie in diesem Beispiel zwei Paar Klammern erforderlich sind und die Berechnung der Gesamtstunden (end_time - start_time) innerhalb einer von ihnen verschachtelt sein sollte. Fügen Sie schließlich eine GROUP BY-Klausel hinzu, um diese Werte basierend auf der runner_name-Spalte zu organisieren, damit die Ausgabe die Rennergebnisse der beiden Läufer präsentiert:

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 Laufzeit jedes Läufers, in diesem Fall ein Minimum von sechs Minuten und 30 Sekunden für Bolt und sieben Minuten und 15 Sekunden für Felix.

Als nächstes finden Sie die längste Laufzeit jedes Läufers. Sie können die gleiche Syntax wie bei der vorherigen Abfrage verwenden, ersetzen Sie jedoch dieses Mal 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 uns, dass Bolts längste Laufzeit insgesamt drei Stunden, 23 Minuten und 10 Sekunden betrug; und Felix war insgesamt vier Stunden, zwei Minuten und 10 Sekunden.

Jetzt fragen wir nach einigen hochrangigen Informationen über die Gesamtstunden, die jeder Läufer mit Laufen verbracht hat. Für diese Abfrage kombinieren Sie die SUM-Aggregatfunktion, um die Gesamtsumme der Stunden basierend auf end_time - start_time zu finden, und verwenden Sie CAST, um diese Datenwerte in TIME zu konvertieren. Vergessen Sie nicht, GROUP BY einzuschließen, um die Werte für die Ergebnisse beider 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;

Output
+-------------+-------------+
| 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 tatsächlich die Gesamtzeit als Ganzzahlen berechnet. Wenn wir diese Ergebnisse als Zeit lesen, ergibt sich für Bolt eine Gesamtzeit von fünf Stunden, 28 Minuten und 80 Sekunden; und die Zeit von Felix zerfällt in sieben Stunden, 61 Minuten und 49 Sekunden. Wie Sie sehen können, ergibt diese Zeitzerlegung 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ürden, sähe die gleiche Abfrage zum Beispiel 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 Abfrage in PostgreSQL die Werte als Zeit und berechnet sie entsprechend, sodass die Ergebnisse von Felix auf insgesamt 10 Stunden, eine Minute und 44 Sekunden und die von Bolt auf sechs Stunden, neun Minuten und 20 Sekunden kommen. Dies ist ein Beispiel dafür, wie verschiedene Implementierungen von DBMS Datenwerte möglicherweise unterschiedlich interpretieren, auch wenn sie die gleiche Abfrage und den gleichen Datensatz verwenden.

Schlussfolgerung

Das Verständnis dafür, wie man Datum und Uhrzeit in SQL verwendet, ist nützlich, wenn man nach spezifischen Ergebnissen wie Minuten, Sekunden, Stunden, Tagen, Monaten, Jahren oder einer Kombination davon sucht. Darüber hinaus stehen viele Funktionen für Datum und Uhrzeit zur Verfügung, die es erleichtern, bestimmte Werte zu finden, wie das aktuelle Datum oder die aktuelle Uhrzeit. Während dieses Tutorial nur Addition und Subtraktion von Datum und Uhrzeit in SQL verwendet hat, können Sie Datum und Uhrzeit mit jedem mathematischen Ausdruck verwenden. Erfahren Sie mehr in unserem Leitfaden zu mathematischen Ausdrücken und Aggregatfunktionen und probieren Sie sie mit Ihren Datum- und Uhrzeitabfragen aus.