SQLite Datum & Zeit: strftime, date(), datetime() & Modifier

SQLite hat eigentlich keinen echten Datentyp für Datum

Das bringt jeden ins Straucheln, der von Postgres oder MySQL kommt. SQLite kennt nur fünf Storage Classes — NULL, INTEGER, REAL, TEXT, BLOB — und damit hat sich's. Es gibt kein DATE, kein DATETIME, keinen TIMESTAMP. Du kannst zwar created_at DATETIME in dein CREATE TABLE schreiben, und SQLite schluckt das auch klaglos, aber intern landet der Wert schlicht als Text oder Zahl.

Was SQLite dir stattdessen mitgibt, ist eine Reihe von Funktionen, die drei gängige Formate verstehen:

• ISO-8601-Text — '2026-04-23', '2026-04-23 10:15:00', '2026-04-23T10:15:00.123Z'.
• Unix-Timestamp — Sekunden seit dem 1.1.1970 UTC, gespeichert als Integer.
• Julianisches Datum — Bruchteil von Tagen seit 4714 v. Chr., gespeichert als Real.

Entscheide dich für eines und bleib konsequent dabei. ISO-8601-Text ist am besten lesbar und sortiert als String korrekt — deshalb ist es auch die übliche Wahl.

SELECT date('now'),
       datetime('now'),
       strftime('%s', 'now'),
       julianday('now');

Vier Wege, die aktuelle Zeit abzufragen – als Text-Datum, Text-Zeitstempel, Unix-Sekunden oder Julianisches Datum. Alle vier beschreiben denselben Moment.

Die fünf Datumsfunktionen in SQLite

SQLite bringt fünf eingebaute Funktionen mit, die so gut wie alles abdecken, was du mit Datum und Uhrzeit machen willst:

• date(time, ...) – liefert YYYY-MM-DD.
• time(time, ...) – liefert HH:MM:SS.
• datetime(time, ...) – liefert YYYY-MM-DD HH:MM:SS.
• julianday(time, ...) – liefert einen Fließkommawert (ideal, um Datumsdifferenzen zu berechnen).
• strftime(format, time, ...) – liefert einen frei formatierten String.

Jede dieser Funktionen erwartet als erstes Argument einen Zeitwert, gefolgt von beliebig vielen Modifier-Strings.

SELECT date('2026-04-23 10:15:00')          AS just_date,
       time('2026-04-23 10:15:00')          AS just_time,
       datetime(1745402100, 'unixepoch')    AS from_unix,
       julianday('2026-04-23')              AS julian;

Beachte den Modifier 'unixepoch' — damit signalisierst du den Datumsfunktionen, dass die Eingabe ein Unix-Timestamp ist und kein julianisches Datum. Lässt du ihn weg, geht SQLite automatisch von einem Julian Day aus.

strftime: eigenes SQLite Date Format definieren

strftime ist das Schweizer Taschenmesser unter den Datumsfunktionen in SQLite. Die %-Platzhalter kennst du wahrscheinlich schon aus C oder Python:

SELECT strftime('%Y-%m-%d',           'now') AS iso_date,
       strftime('%d/%m/%Y',           'now') AS european,
       strftime('%H:%M',              'now') AS hours_minutes,
       strftime('%Y-%m-%dT%H:%M:%fZ', 'now') AS iso_with_ms,
       strftime('%w',                 'now') AS day_of_week,
       strftime('%j',                 'now') AS day_of_year;

Die Format-Codes, die du am häufigsten brauchst:

• %Y — vierstelliges Jahr.
• %m — Monat (01-12).
• %d — Tag im Monat (01-31).
• %H, %M, %S — Stunden, Minuten, Sekunden.
• %w — Wochentag (0=Sonntag).
• %j — Tag im Jahr (001-366).
• %s — Unix-Timestamp.
• %f — Sekundenbruchteile (SS.SSS).

Mit strftime extrahierst du gleichzeitig auch einzelne Bestandteile eines Datums — eine separate EXTRACT- oder YEAR()-Funktion gibt es in SQLite nicht. Du formatierst das Datum einfach so weit herunter, bis nur noch der gewünschte Teil übrig bleibt, und castest ihn bei Bedarf in eine Zahl:

SELECT strftime('%Y', '2026-04-23') AS year_text,
       CAST(strftime('%Y', '2026-04-23') AS INTEGER) AS year_num,
       CAST(strftime('%m', '2026-04-23') AS INTEGER) AS month_num;

strftime liefert immer Text zurück. Wenn du also rechnen oder numerisch vergleichen willst, packst du das Ergebnis in CAST(... AS INTEGER).

Modifier: Datumsarithmetik ohne Rechenzeichen

Genau dieses Feature macht den Umgang mit Datumsangaben in SQLite so angenehm. Nach dem Zeitargument kannst du beliebig viele Modifier-Strings übergeben, die dann der Reihe nach abgearbeitet werden:

SELECT date('2026-04-23', '+7 days')              AS week_later,
       date('2026-04-23', '-1 month')             AS month_earlier,
       datetime('now', '+2 hours', '+30 minutes') AS in_two_thirty,
       date('now', 'start of month')              AS first_of_month,
       date('now', 'start of month', '+1 month', '-1 day') AS last_of_month,
       date('now', 'weekday 0')                   AS next_sunday;

Modifier, die du ständig brauchst:

• '+N days', '-N days' und das Gleiche für hours, minutes, seconds, months, years.
• 'start of day', 'start of month', 'start of year' — schneidet auf die jeweilige Grenze ab.
• 'weekday N' — springt zum nächsten angegebenen Wochentag (0 = Sonntag).
• 'localtime' und 'utc' — wechselt zwischen den Zeitzonen.

Den Trick mit dem „letzten Tag des Monats" solltest du dir merken: start of month, dann einen Monat dazu und einen Tag wieder abziehen. SQLite hat zwar keine LAST_DAY-Funktion, aber durch das Verketten von Modifiern kommst du aufs gleiche Ergebnis.

UTC vs. lokale Zeit

'now' liefert immer UTC zurück. Wenn du die lokale Zeit willst, musst du explizit danach fragen:

SELECT datetime('now')              AS utc_now,
       datetime('now', 'localtime') AS local_now,
       datetime('2026-04-23 10:00:00', 'utc') AS treated_as_local_then_utc;

Der Modifier 'localtime' rechnet einen UTC-Wert in die lokale Systemzeitzone um. 'utc' macht das Gegenteil – er interpretiert den Eingabewert als Lokalzeit und wandelt ihn in UTC um.

Eine bewährte Regel: Speichere alles in UTC und konvertiere nur bei der Anzeige in die Lokalzeit. Wer in der Datenbank verschiedene Zeitzonen vermischt, handelt sich Bugs ein, die zuverlässig zweimal im Jahr auftauchen – nämlich bei der Sommerzeitumstellung.

Datumsvergleiche und Bereichsfilter mit BETWEEN

Wenn du Datumswerte als ISO-8601-Text ablegst, funktionieren Vergleiche und BETWEEN ohne weiteres Zutun – ISO 8601 sortiert lexikografisch nämlich exakt so wie chronologisch. Genau deshalb ist dieses Format auch der Standard.

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL  -- ISO 8601
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00');

SELECT customer, placed_at
FROM orders
WHERE placed_at >= '2026-04-01'
  AND placed_at <  '2026-05-01'
ORDER BY placed_at;

Das halboffene Intervall (>= start, < end) ist eine gute Angewohnheit – damit umgeht man die typische Frage „Zählt Mitternacht am 30. jetzt mit oder nicht?" komplett.

Für „die letzten 7 Tage" lässt du SQLite die Grenze selbst ausrechnen:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer, placed_at
FROM orders
WHERE placed_at >= datetime('now', '-7 days')
ORDER BY placed_at DESC;

Datumsdifferenz berechnen

In SQLite gibt es kein DATEDIFF – aber keine Sorge: Mit zwei Mustern deckst du eigentlich alle Fälle ab:

SELECT julianday('2026-04-23') - julianday('2026-04-01')           AS days_between,
       (julianday('2026-04-23 18:00') - julianday('2026-04-23 09:00')) * 24 AS hours_between,
       strftime('%s', '2026-04-23 18:00') - strftime('%s', '2026-04-23 09:00') AS seconds_between;

Differenzen über julianday() werden in Tagen ausgedrückt (inklusive Nachkommastellen). Multiplizierst du das Ergebnis mit 24, bekommst du Stunden, mit 1440 entsprechend Minuten. Differenzen mit strftime('%s', ...) liefern dagegen Sekunden – praktisch, wenn du direkt einen ganzzahligen Wert brauchst.

Mit CAST(... AS INTEGER) schneidest du die Nachkommastellen ab, falls du ganze Tage zählen willst:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer,
       CAST(julianday('now') - julianday(placed_at) AS INTEGER) AS days_ago
FROM orders
ORDER BY days_ago;

Datum in SQLite speichern: ein Format wählen und dabei bleiben

Drei vernünftige Optionen, sortiert nach der Häufigkeit, mit der du sie nehmen solltest:

1. ISO-8601-Text (TEXT). Lesbar in Dumps, sortiert korrekt und harmoniert mit allen Datumsfunktionen. Die Standardwahl.
2. Unix-Sekunden (INTEGER). Kompakt, schnelle Vergleiche, keine Zeitzonen-Stolperfallen. Sinnvoll bei Millionen von Zeilen. Zum Auslesen brauchst du dann datetime(col, 'unixepoch').
3. Julianischer Tag (REAL). Lohnt sich selten – höchstens, wenn du intensiv mit Datumsarithmetik arbeitest und in einer einzigen Spalte Genauigkeit unterhalb der Sekunde brauchst.

Was du auf gar keinen Fall machen solltest: verschiedene Formate in derselben Spalte mischen. Die Datumsfunktionen schlucken zwar beides klaglos, aber Indizes, Sortierungen und Vergleiche liefern dann puren Unsinn.

-- Standardwerte, die beim Einfügen automatisch gesetzt werden:
CREATE TABLE events (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,
    happened_at TEXT NOT NULL DEFAULT (datetime('now'))
);

INSERT INTO events (name) VALUES ('Anmeldung'), ('Login');

SELECT name, happened_at FROM events;

DEFAULT (datetime('now')) ist das SQLite-Pendant zu DEFAULT CURRENT_TIMESTAMP – jeder neue Datensatz bekommt damit automatisch die aktuelle UTC-Zeit verpasst, ganz ohne Zutun aus dem Anwendungscode.

Nach Zeitraum gruppieren

strftime spielt seine Stärken aus, wenn du Datensätze nach Monat, Woche oder Stunde bündeln willst:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00'),
    ('Ezra',  '2026-05-20 17:00:00');

SELECT strftime('%Y-%m', placed_at) AS month,
       COUNT(*)                     AS order_count
FROM orders
GROUP BY month
ORDER BY month;

Dasselbe Prinzip funktioniert auch für „Bestellungen pro Tagesstunde", „Anmeldungen pro Wochentag" oder „Events pro Minute" – du wählst einfach einen Format-String, der genau die gewünschte Granularität abbildet, gruppierst danach und aggregierst.

Als Nächstes: Aggregatfunktionen

Apropos Gruppieren – COUNT(*) ist die simpelste der Aggregatfunktionen in SQLite. Im nächsten Abschnitt schauen wir uns das ganze Arsenal an: SUM, AVG, MIN, MAX und wie sie viele Zeilen zu einem einzigen Ergebniswert zusammenfassen.