Date- und Zeitfunktionen in SQL: leicht erklärt

Wie oft hast du schon das Alter eines Users berechnet, Bestellungen der letzten 30 Tage abgefragt oder Öffnungszeiten für einen bestimmten Wochentag formatiert? Auf den ersten Blick sind das alltägliche Aufgaben, doch wenn du genauer hinschaust, steckt dahinter eine gemeinsame Herausforderung: das Arbeiten mit Datum und Zeit.

Ohne die passenden Funktionen wird jede Abfrage mühsam, fehleranfällig und kann zu ungenauen Ergebnissen führen. Unterschiedliche Formate, Zeitzonen und datenbankspezifische Eigenheiten machen das Handling von Datumswerten schnell kompliziert.

In diesem Artikel lernst du die wichtigsten SQL-Date- und Zeitfunktionen von Grund auf kennen. Du wirst Schritt für Schritt verstehen, wie du:

  • Das aktuelle Datum und die aktuelle Uhrzeit abfragst
  • Einzelne Bestandteile eines Datums zerlegst, z. B. Tag, Monat oder Jahr
  • Timestamps lesbar formatierst
  • Mit Zeitintervallen rechnest und die Differenz zwischen Daten berechnest

Alle Beispiele sind leicht nachvollziehbar und direkt einsatzbereit – so dass du nach dem Lesen sicherer und schneller mit Datums- und Zeitwerten in SQL arbeiten kannst.

Date- und Zeitfunktionen

Warum sind Datum und Zeit so tricky?

Arbeiten mit Datum und Zeit klingt einfach – aber in der Praxis lauern viele Fallstricke. Selbst kleine Fehler können zu falschen Ergebnissen führen. Die wichtigsten Herausforderungen sind:

  • Unterschiedliche Datumsformate: ISO 8601 (YYYY-MM-DD), europäisches Format (DD.MM.YYYY) oder US-Format (MM/DD/YYYY) – je nach Datenquelle kann es schnell zu Verwirrung kommen.
  • Zeitzonen: UTC vs. lokale Zeit, Sommer- und Winterzeit – ohne Berücksichtigung können Zeitangaben falsch interpretiert werden.
  • Datentypen: Datenbanken erkennen nicht automatisch, ob ein Wert ein Datum oder nur ein String ist. Falsche Typen führen zu Fehlern bei Berechnungen und Vergleichen.

Das Bewusstsein für diese Probleme ist der erste Schritt, um Datums- und Zeitwerte korrekt zu handhaben. In den folgenden Abschnitten zeigen wir dir, wie du diese Herausforderungen elegant mit SQL-Funktionen meisterst.

Die Grundbausteine: Aktuelles Datum und Zeit holen

Bevor du komplexere Datumsberechnungen machst, musst du erstmal wissen, wie du das aktuelle Datum und die aktuelle Uhrzeit abfragst. Fast jeder SQL-Dialekt bietet dafür grundlegende Funktionen:

  • CURRENT_DATE: Liefert das heutige Datum.
  • CURRENT_TIME: Liefert die aktuelle Uhrzeit.
  • CURRENT_TIMESTAMP (oder NOW()): Liefert beides – Datum und Uhrzeit – bis auf die Sekunde (oder sogar Mikrosekunde) genau.

Ein einfaches Beispiel für eine Abfrage:

SELECT CURRENT_DATE AS Heute, 
       CURRENT_TIME AS Jetzt, 
       CURRENT_TIMESTAMP AS Genau;

Mit diesen Funktionen hast du die absolute Basis, um alle weiteren Berechnungen und Analysen rund um Datum und Zeit aufzubauen.

Datumswerte zerlegen und analysieren

Oft willst du nicht das ganze Datum, sondern nur bestimmte Teile wie Tag, Monat oder Jahr verwenden. Dafür gibt es in SQL praktische Funktionen.

EXTRACT(): Der universelle Schlüssel zum Zerlegen

Die EXTRACT()-Funktion erlaubt es dir, einzelne Bestandteile eines Datums zu extrahieren:

  • EXTRACT(YEAR FROM birthdate) AS Geburtsjahr
  • EXTRACT(MONTH FROM order_date) AS Bestellmonat
  • EXTRACT(DAY FROM created_at) AS Tag_im_Monat
  • EXTRACT(DOW FROM created_at) AS Tag_der_Woche (0=Sonntag, 6=Samstag oder 1=Montag, 7=Sonntag – je nach Datenbank)

Spezifische Funktionen in manchen Dialekten

Einige SQL-Dialekte bieten eigene Funktionen, die das Extrahieren vereinfachen:

  • YEAR(birthdate), MONTH(birthdate), DAYOFWEEK(birthdate) in MySQL

Mit diesen Werkzeugen kannst du Datumswerte gezielt analysieren und Abfragen deutlich flexibler gestalten.

Datumswerte formatieren und lesbar machen

Rohdaten wie 2024-10-24 14:35:00 sind für Menschen oft schwer lesbar. Mit SQL kannst du sie in verständliche Formate bringen.

TO_CHAR() und DATE_FORMAT(): Die mächtigsten Formatierer

Je nach Datenbank gibt es unterschiedliche Funktionen:

  • PostgreSQL / Oracle: TO_CHAR()
  • MySQL: DATE_FORMAT()

Beispiele

PostgreSQL:

TO_CHAR(CURRENT_TIMESTAMP, 'DD.MM.YYYY HH24:MI') 
-- Ausgabe: 24.10.2024 14:35

MySQL:

DATE_FORMAT(NOW(), '%W, %d. %M %Y') 
-- Ausgabe: Thursday, 24. October 2024

Hinweis: Achte auf die Formatierungscodes wie %Y (Jahr), %d (Tag), %W (Wochentag) – die vollständige Liste findest du in der offiziellen Dokumentation deiner Datenbank.

Die Magie der Intervalle: Mit Datum und Zeit rechnen

Mit Intervallen kannst du Tage, Monate, Stunden oder Minuten zu einem Datum addieren oder davon subtrahieren. Das ist essenziell für Aufgaben wie Lieferzeiten, Garantien oder Altersberechnungen.

INTERVAL: Zeitspannen definieren

Die allgemeine Syntax:

CURRENT_DATE + INTERVAL '7 days'      -- Datum in einer Woche
CURRENT_TIMESTAMP - INTERVAL '2 hours'  -- Timestamp vor zwei Stunden
order_date + INTERVAL '30 days' AS Warranty_Ends  -- Garantieende 30 Tage nach Bestellung

AGE() in PostgreSQL

Mit AGE() kannst du die Differenz zwischen zwei Datumswerten berechnen. Das Ergebnis wird als Jahre, Monate und Tage zurückgegeben:

AGE('2000-01-01') 
-- Gibt z.B. das Alter einer Person zurück, die am 01.01.2000 geboren wurde

Mit Intervallen und Funktionen wie AGE() lassen sich fast alle zeitbezogenen Berechnungen direkt in SQL erledigen.

Unterschiede berechnen: Wie viel Zeit ist vergangen?

Oft willst du wissen, wie viele Tage, Wochen oder Monate zwischen zwei Datumsangaben liegen. SQL bietet dafür mehrere Möglichkeiten.

Einfache Subtraktion

In einigen Datenbanken, wie PostgreSQL, kannst du Datumswerte direkt subtrahieren:

DATE '2024-12-24' - DATE '2024-10-24' 
-- Ergebnis: 61 (Tage)

DATEDIFF()

In MySQL oder SQL Server gibt es die Funktion DATEDIFF():

DATEDIFF(day, start_date, end_date)

Alternative: EXTRACT und AGE

Wenn du detailliertere Informationen willst, wie Jahre, Monate und Tage, kannst du EXTRACT() oder AGE() nutzen:

EXTRACT(YEAR FROM AGE(birthdate)) AS age_in_years

So findest du zuverlässig heraus, wie viel Zeit zwischen zwei Ereignissen vergangen ist.

Praxis-Beispiele: So setzt du alles zusammen

Jetzt kombinieren wir die bisher gelernten Funktionen in praxisnahen Szenarien.

Alter berechnen

SELECT name, birthdate,
       EXTRACT(YEAR FROM AGE(birthdate)) AS age_in_years
FROM users;

Bestellungen der letzten 30 Tage finden

SELECT * FROM orders
WHERE order_date >= CURRENT_DATE - INTERVAL '30 days';

Umsatz nach Kalenderwoche ausgeben

SELECT
    TO_CHAR(order_date, 'IYYY-"KW"IW') AS calendar_week, -- ISO-Woche
    SUM(amount) AS total_amount
FROM orders
GROUP BY calendar_week
ORDER BY calendar_week;

Mit diesen Beispielen siehst du, wie mächtig SQL-Date- und Zeitfunktionen sein können, wenn man sie gezielt einsetzt.

Kurzer Hinweis: Wichtige Unterschiede zwischen Datenbanken

SQL ist nicht gleich SQL – je nach Datenbank unterscheiden sich Funktionsnamen und Syntax leicht. Deshalb ist es wichtig, die Dokumentation deiner Datenbank zu kennen.

Wichtige Unterschiede

  • PostgreSQL: CURRENT_DATE, EXTRACT(), TO_CHAR(), AGE()
  • MySQL: CURDATE(), YEAR()/MONTH()/DAYOFWEEK(), DATE_FORMAT(), DATEDIFF()
  • SQL Server: GETDATE(), DATEPART(), FORMAT(), DATEDIFF()

Essenziell: Prüfe immer, welche Funktionen und Formate deine Datenbank unterstützt, um Fehler zu vermeiden.

Kurze Vergleichstabelle

Funktion PostgreSQL MySQL SQL Server
Aktuelles Datum CURRENT_DATE CURDATE() GETDATE()
Jahr extrahieren EXTRACT(YEAR FROM date) YEAR(date) DATEPART(YEAR, date)
Datum formatieren TO_CHAR(date, format) DATE_FORMAT(date, format) FORMAT(date, format)

Fazit: Robustes Werkzeugkit

Mit den hier vorgestellten SQL Date- und Zeitfunktionen hast du nun ein robustes Werkzeugkit an der Hand, um die häufigsten Aufgaben zu lösen:

  • Abfragen des aktuellen Datums und der Uhrzeit
  • Zerlegen von Datumswerten in Jahr, Monat, Tag oder Wochentag
  • Formatieren von Timestamps in lesbare Darstellungen
  • Rechnen mit Zeitintervallen und Berechnen von Differenzen

Ein letzter Tipp: Übe mit den Beispielen und wirf regelmäßig einen Blick in die Dokumentation deiner Datenbank. Zeitzonen, unterschiedliche Funktionsnamen und kleine Syntaxunterschiede können sonst leicht zu Fehlern führen.