Arbeiten mit Unix-Zeit: EPOCH

Unix-Zeit ist einfach eine Möglichkeit, Zeit als die Anzahl der Sekunden (manchmal auch Millisekunden) zu speichern, die seit Mitternacht am 1. Januar 1970 (UTC) vergangen sind. Dieses Format ist in der Entwicklung mega beliebt: Es ist super einfach zu speichern, zu übertragen und zu vergleichen, weil es einfach nur eine Zahl ist.

Vereinfacht gesagt: Unix-Zeit ist wie ein Timer, der 1970 angefangen hat zu ticken und nie aufhört. Siehst du eine komische Zahl wie 1697222400? Keine Panik – das ist einfach nur die Anzahl der Sekunden seit dem Startpunkt. Willst du wissen, welches Datum das ist? Das lernst du gleich!

Dieses Format wird oft genutzt, wenn Daten zwischen Systemen synchronisiert werden, um Zeitstempel zu speichern oder wenn man schnell vergleichen will, was früher oder später passiert ist.

Umwandlung in Unix-Zeit

In PostgreSQL gibt es die spezielle Funktion EXTRACT(EPOCH FROM ...), mit der du ein Datum oder einen Zeitstempel in Unix-Zeit umwandeln kannst.

Lass uns das aktuelle Datum in dieses Format umwandeln:

SELECT EXTRACT(EPOCH FROM NOW());

Das Ergebnis sieht dann ungefähr so aus:

1697222400

Dieses Ergebnis ist einfach das aktuelle Datum und die aktuelle Uhrzeit in Sekunden seit 1970.

So wandelst du ein festes Datum um:

SELECT EXTRACT(EPOCH FROM TIMESTAMP '2023-10-01 12:00:00');

Ergebnis:

1696152000

Jetzt wissen wir, dass der 1. Oktober 2023 um 12:00 Uhr UTC diesem Wert entspricht.

Umwandlung aus Unix-Zeit

Klar gibt’s auch die Umwandlung zurück. Wenn du eine Unix-Zeit hast und sie in ein für Menschen lesbares Format umwandeln willst, hilft dir die Funktion TO_TIMESTAMP().

Lass uns eine Unix-Zeit in Datum und Uhrzeit umwandeln

SELECT TO_TIMESTAMP(1697222400);

Ergebnis:

2023-10-13 00:00:00+00

Jetzt sehen wir, dass das der 13. Oktober 2023 um 00:00 Uhr UTC ist.

Praktische Anwendung von Unix-Zeit

Angenommen, wir haben eine Tabelle events, in der wir Infos zu Events speichern, inklusive ihrer Zeitstempel im Unix-Zeit-Format.

CREATE TABLE events (
    id SERIAL PRIMARY KEY,
    event_name TEXT,
    event_time BIGINT -- zum Speichern von Unix-Zeit
);

Wir können Daten in diese Tabelle einfügen und die Zeitstempel im Unix-Zeit-Format angeben:

INSERT INTO events (event_name, event_time)
VALUES
('Serverstart', 1697222400),
('Datenbank-Update', 1697308800);

Um diese Infos lesbar zu machen, reicht ein TO_TIMESTAMP:

SELECT event_name, TO_TIMESTAMP(event_time) AS readable_time
FROM events;

Ergebnis:

Tipps und typische Fehler

1. Falsche Genauigkeit gewählt

Wenn dein Unix-Zeit-Format Millisekunden hat (zum Beispiel 1697222400000), kannst du das nicht einfach direkt an TO_TIMESTAMP oder EXTRACT übergeben. In solchen Fällen musst du den Wert durch 1000 teilen:

SELECT TO_TIMESTAMP(1697222400000 / 1000);

Ergebnis:

2023-10-13 00:00:00+00

2. Zeitzonen ignoriert

Unix-Zeit ist immer in UTC, also bekommst du die Ergebnisse immer ohne Zeitzonenanpassung, außer du wandelst die Zeit explizit um. Zum Beispiel:

SELECT TO_TIMESTAMP(1697222400) AT TIME ZONE 'Europe/Moscow';

Ergebnis:

2023-10-13 03:00:00

3. Probleme mit zu großen Zahlen

Manchmal geben Entwickler aus Versehen einen zu großen Unix-Zeit-Wert an (zum Beispiel Millisekunden statt Sekunden). Das führt zu falschen Ergebnissen:

SELECT TO_TIMESTAMP(1697222400000); -- Gibt einen Fehler!

Um das zu fixen, musst du die Zahl korrekt durch 1000 teilen.

Beispiel: Berechnung der Laufzeit einer Aufgabe

Nehmen wir ein Beispiel aus dem echten Leben: Wir haben eine Tabelle tasks und wollen berechnen, wie viel Zeit seit der Erstellung jeder Aufgabe vergangen ist.

Tabelle anlegen:

CREATE TABLE tasks (
    id SERIAL PRIMARY KEY,
    task_name TEXT,
    created_at TIMESTAMP DEFAULT NOW()
);

Ein paar Aufgaben einfügen:

INSERT INTO tasks (task_name)
VALUES
('Aufgabe 1'),
('Aufgabe 2'),
('Aufgabe 3');

Jetzt können wir eine Spalte mit der Unix-Zeit hinzufügen:

SELECT id, task_name, EXTRACT(EPOCH FROM created_at) AS created_epoch
FROM tasks;

Ergebnis:

Und wir berechnen, wie viel Zeit seit der Erstellung vergangen ist (in Sekunden):

SELECT id, task_name, EXTRACT(EPOCH FROM NOW()) - EXTRACT(EPOCH FROM created_at) AS elapsed_seconds
FROM tasks;

Ergebnis:

Wann und warum sollte man Unix-Zeit verwenden?

Unix-Zeit ist perfekt, um Zeitdaten zu speichern, wenn Werte zwischen Systemen übertragen werden, Zeitstempel verglichen werden oder überall dort, wo möglichst wenig Rechenaufwand nötig ist. Sie wird oft in APIs, Webentwicklung, Analytics und zur Synchronisation von Server- und Client-Anwendungen genutzt. Aber du solltest immer ihre Besonderheiten beachten: UTC-Orientierung, verschiedene Einheiten (Sekunden oder Millisekunden) und das Speicherformat.

Wenn du mal mit externen Systemen zu tun hast, die „in Unix-Zeit sprechen“, weißt du jetzt, wie du damit in PostgreSQL umgehst. Nutze einfach TO_TIMESTAMP und EXTRACT(EPOCH) für die Umwandlung in beide Richtungen – und deine Zeitprobleme sind gelöst!