Beim Formatieren wird ein Datum zu Text im Layout deiner Wahl, etwa 03/15/2026 oder Thursday, January 15. Jede Datenbank hat dafür ihre eigene Funktion, und die Beispiele decken PostgreSQL, MySQL, SQLite und SQL Server ab.
So formatierst du Datumswerte in SQL
Übergib der Funktion ein Datum und einen Formatstring. Codes im Formatstring stehen für Teile des Datums, alles andere wird unverändert übernommen. In SQLite heißt die Funktion strftime(), und ihre Codes beginnen mit %:
strftime(format, date)
SELECT strftime('%m/%d/%Y', '2026-03-15');
-- Output: 03/15/2026
SELECT strftime('%I:%M %p', '2026-03-15 14:30:00');
-- Output: 02:30 PM
Auf eine Spalte angewendet, kann dasselbe Datum in beliebig vielen Layouts ausgegeben werden:
-- Input: orders
-- order_id | order_date
-- ---------+--------------------
-- 1 | 2026-01-15 09:42:00
-- 2 | 2026-03-02 16:05:00
SELECT
order_date,
strftime('%Y-%m-%d', order_date) AS iso_date,
strftime('%m/%d/%Y', order_date) AS us_date,
strftime('%d/%m/%Y', order_date) AS european_date
FROM orders;
-- Output:
-- order_date | iso_date | us_date | european_date
-- --------------------+------------+------------+--------------
-- 2026-01-15 09:42:00 | 2026-01-15 | 01/15/2026 | 15/01/2026
-- 2026-03-02 16:05:00 | 2026-03-02 | 03/02/2026 | 02/03/2026
Das sind die Codes, die du am häufigsten brauchst, jeweils mit dem Ergebnis für 2026-03-15 14:30:45:
| Code | Bedeutung | Beispiel |
|---|---|---|
%Y |
Jahr, 4-stellig | 2026 |
%m |
Monat (01-12) | 03 |
%d |
Tag des Monats (01-31) | 15 |
%H |
Stunde, 24-Stunden-Format (00-23) | 14 |
%I |
Stunde, 12-Stunden-Format (01-12) | 02 |
%p |
AM oder PM | PM |
%M |
Minute (00-59) | 30 |
%S |
Sekunde (00-59) | 45 |
%w |
Wochentag (0-6, Sonntag ist 0) | 0 |
Wichtige Regeln
-
SQLite hat keine Codes für Tages- oder Monatsnamen. Codes wie
%aund%Bsorgen dafür, dassstrftime()NULL zurückgibt. Ordne stattdessen%woder%mmitCASEeinem Namen zu (siehe den Abschnitt zum Wochentag weiter unten). -
Das Ergebnis ist Text. Beim Vergleichen oder Sortieren formatierter Datumswerte werden Strings verglichen, und das entspricht nur dann der zeitlichen Reihenfolge, wenn das Jahr vorne steht:
-- Input: sales
-- id | sale_date | amount
-- ---+------------+-------
-- 1 | 2025-11-20 | 89.0
-- 2 | 2026-01-08 | 120.0
-- 3 | 2026-03-04 | 64.5
-- Wrong: '11/2025' > '02/2026' is true, because '1' > '0'
SELECT * FROM sales
WHERE strftime('%m/%Y', sale_date) > '02/2026';
-- Output:
-- id | sale_date | amount
-- ---+------------+-------
-- 1 | 2025-11-20 | 89.0
-- 3 | 2026-03-04 | 64.5
-- Right: put the year first
SELECT * FROM sales
WHERE strftime('%Y-%m', sale_date) > '2026-02';
-- Output:
-- id | sale_date | amount
-- ---+------------+-------
-- 3 | 2026-03-04 | 64.5
-
NULL rein, NULL raus.
strftime('%Y-%m-%d', NULL)gibt NULL zurück. Pack es inCOALESCE(), um stattdessen etwas anderes anzuzeigen, etwa'No date'. -
Nach dem Datum filtern, für die Anzeige formatieren.
WHERE order_date >= '2026-01-01' AND order_date < '2027-01-01'liefert dieselben Zeilen wieWHERE strftime('%Y', order_date) = '2026', aber nur die erste Variante kann einen Index auforder_datenutzen.
Alternative Syntax
PostgreSQL, MySQL und SQL Server haben jeweils eigene Funktionen und Codes:
-- PostgreSQL: TO_CHAR(value, pattern)
-- (FM stops it padding the day name to 9 characters)
SELECT TO_CHAR(TIMESTAMP '2026-01-15 09:42:00', 'FMDay, MM/DD/YYYY HH24:MI');
-- Output: Thursday, 01/15/2026 09:42
-- MySQL: DATE_FORMAT(value, pattern)
-- (%i is the minute; %M would be the month name)
SELECT DATE_FORMAT('2026-01-15 09:42:00', '%W, %m/%d/%Y %H:%i');
-- Output: Thursday, 01/15/2026 09:42
-- SQL Server: FORMAT(value, pattern)
-- (MM is the month, mm the minute)
SELECT FORMAT(CAST('2026-01-15 09:42:00' AS datetime2), 'dddd, MM/dd/yyyy HH:mm');
-- Output: Thursday, 01/15/2026 09:42
-- Older SQL Server code uses CONVERT with a style number (101 is mm/dd/yyyy)
SELECT CONVERT(VARCHAR(10), CAST('2026-01-15' AS date), 101);
-- Output: 01/15/2026
Wann solltest du Datumswerte formatieren?
Formatiere ein Datum, wenn es als Text angezeigt oder gruppiert werden soll. Die meisten Anwendungsfälle fallen in eine dieser vier Kategorien.
Datumswerte in einem Standardlayout anzeigen
Nutze ISO 8601 (YYYY-MM-DD) für Dateien und APIs, MM/DD/YYYY für US-Leser und DD/MM/YYYY für den Großteil Europas. Durch das Formatieren fällt außerdem die Uhrzeit weg, wenn du nur das Datum brauchst.
Zeilen nach Monat oder Jahr gruppieren
Zieh nur den Teil des Datums heraus, den du brauchst, etwa %Y für das Jahr oder %Y-%m für den Monat, und gruppiere nach dem Ergebnis, um Jahres- oder Monatssummen zu erhalten.
Lesbare Datumsangaben schreiben
Kombiniere Codes mit Wörtern für Labels, Erinnerungen und E-Mails. „03/16 at 02:30 PM“ liest sich besser als „2026-03-16 14:30:00“.
Mit dem Wochentag arbeiten
%w liefert den Wochentag als Zahl von 0 (Sonntag) bis 6 (Samstag). Filtere danach, um Werktage oder Wochenenden zu finden, oder ordne ihm mit CASE einen Namen zu.
Praxisbeispiele zur Datumsformatierung
Einen Export mit ISO-8601-Zeitstempeln versehen
Eine API erwartet Zeitstempel wie 2026-03-15T08:05:12Z. Die Zeiten in audit_log sind in UTC gespeichert, also setzt du T und Z um die Codes herum (SQLite):
-- Input: audit_log
-- id | action | logged_at
-- ---+--------+--------------------
-- 1 | login | 2026-03-15 08:05:12
-- 2 | export | 2026-03-15 14:30:45
-- 3 | logout | 2026-03-15 17:58:03
SELECT
id,
action,
strftime('%Y-%m-%dT%H:%M:%SZ', logged_at) AS logged_at_iso
FROM audit_log;
-- Output:
-- id | action | logged_at_iso
-- ---+--------+---------------------
-- 1 | login | 2026-03-15T08:05:12Z
-- 2 | export | 2026-03-15T14:30:45Z
-- 3 | logout | 2026-03-15T17:58:03Z
Registrierungen pro Monat zählen
Gruppiere Nutzer nach dem Monat ihrer Registrierung (PostgreSQL). YYYY-MM hält die Monate in zeitlicher Reihenfolge:
-- Input: users
-- id | name | signup_date
-- ---+------------+------------
-- 1 | Ana Lima | 2026-01-08
-- 2 | Ben Okafor | 2026-01-27
-- 3 | Chloe Park | 2026-02-14
-- 4 | Dev Mehta | 2026-03-03
-- 5 | Elle Novak | 2026-03-30
SELECT
TO_CHAR(signup_date, 'YYYY-MM') AS month,
COUNT(*) AS signups
FROM users
GROUP BY TO_CHAR(signup_date, 'YYYY-MM')
ORDER BY month;
-- Output:
-- month | signups
-- --------+--------
-- 2026-01 | 2
-- 2026-02 | 1
-- 2026-03 | 2
Eine Buchungsbestätigung schreiben
Schreib Tag und Monat in einer Bestätigungsnachricht aus (SQL Server):
-- Input: bookings
-- guest_name | booking_time
-- ------------+--------------------
-- Priya Patel | 2026-03-16 14:30:00
-- Liam Murphy | 2026-03-18 09:15:00
SELECT
guest_name,
FORMAT(booking_time, 'dddd, MMMM d') + ' at ' + FORMAT(booking_time, 'h:mm tt') AS confirmation
FROM bookings;
-- Output:
-- guest_name | confirmation
-- ------------+-------------------------------
-- Priya Patel | Monday, March 16 at 2:30 PM
-- Liam Murphy | Wednesday, March 18 at 9:15 AM
Den geschäftigsten Wochentag finden
Zähle Bestellungen nach dem Namen des Tages, an dem sie aufgegeben wurden (MySQL):
-- Input: orders
-- order_id | order_date
-- ---------+--------------------
-- 1 | 2026-03-07 10:12:00
-- 2 | 2026-03-09 16:40:00
-- 3 | 2026-03-14 11:05:00
-- 4 | 2026-03-16 09:20:00
-- 5 | 2026-03-21 13:45:00
SELECT
DATE_FORMAT(order_date, '%W') AS weekday,
COUNT(*) AS order_count
FROM orders
GROUP BY weekday
ORDER BY order_count DESC;
-- Output:
-- weekday | order_count
-- ---------+------------
-- Saturday | 3
-- Monday | 2
Weiterführendes zur Datumsformatierung
In diesem Blog:
-
Leitfaden zum Formatieren von Datumswerten in PostgreSQL: weitere
TO_CHAR-Muster - SQL-DATEDIFF-Leitfaden: die Zeit zwischen zwei Datumswerten
-
Leitfaden zum Einfügen von Datumswerten in SQL: die umgekehrte Richtung, von Text zu Datum mit
STR_TO_DATE()und Co. - PostgreSQL: Nur Werktage auswählen: nach Wochentag filtern
- SQL-GROUP-BY-Leitfaden: Zeilen zu Monats- oder Jahressummen gruppieren
- Leitfaden zur SQL-CASE-Anweisung: Tagesnummern Namen zuordnen
Offizielle Dokumentation:
- PostgreSQL: Data Type Formatting Functions
- MySQL: DATE_FORMAT()
- SQLite: Date and Time Functions
- SQL Server: FORMAT und CAST and CONVERT
Beekeeper Studio ist eine kostenlose & quelloffene Datenbank-GUI
Das beste SQL-Abfrage- & Editor-Tool, das ich je benutzt habe. Es bietet alles, was ich zum Verwalten meiner Datenbank brauche. - ⭐⭐⭐⭐⭐ Mit
Beekeeper Studio ist schnell, intuitiv und einfach zu bedienen. Beekeeper unterstützt jede Menge Datenbanken und läuft hervorragend auf Windows, Mac und Linux.
Was Nutzer über Beekeeper Studio sagen
„Beekeeper Studio hat meinen alten SQL-Workflow komplett ersetzt. Es ist schnell, intuitiv und macht die Arbeit mit Datenbanken wieder zum Vergnügen.“
„Ich habe viele Datenbank-GUIs ausprobiert, aber Beekeeper findet die perfekte Balance zwischen Funktionsumfang und Einfachheit. Es funktioniert einfach.“