# UUID v4, v7 oder ULID als Primärschlüssel?

Wann sich UUIDs als Primärschlüssel lohnen, warum v7 und ULID für Datenbanken besser sind als v4 und wie Sie sie speichern.

Website: https://skriptbox.com/de/anleitungen/uuid-als-primaerschluessel

Fortlaufende Zahlen als Primärschlüssel sind einfach und schnell. Sobald Daten aber an mehreren Stellen entstehen, IDs in URLs auftauchen oder Datenbestände zusammengeführt werden, stoßen sie an Grenzen. Dann liegt eine UUID nahe – doch die falsche Variante kann eine große Tabelle spürbar ausbremsen.

Diese Anleitung vergleicht Auto-Increment, UUID v4, UUID v7 und ULID, erklärt, was im Index passiert, und zeigt, wie Sie die IDs in PostgreSQL, MySQL und MariaDB platzsparend speichern.

## Auto-Increment oder UUID?

Ein `BIGINT` mit Auto-Increment belegt 8 Byte, ist gut lesbar und wird von der Datenbank in aufsteigender Reihenfolge vergeben – ideal für den Index. Die Nachteile:

- Nur die Datenbank kann IDs vergeben. Die Anwendung kennt die ID eines neuen Datensatzes erst nach dem Speichern.
- Beim Zusammenführen mehrerer Datenbanken, etwa von Mandanten oder Standorten, kollidieren die Nummern.
- IDs in URLs sind erratbar (`/rechnung/1042`, `/rechnung/1043`) und verraten, wie viele Datensätze es ungefähr gibt.

Eine UUID (Universally Unique Identifier) ist 128 Bit lang und kann überall erzeugt werden – im Browser, in einem Microservice, offline in einer App – ohne Abstimmung mit einer zentralen Stelle. Kollisionen sind bei korrekter Erzeugung praktisch ausgeschlossen. Dafür ist sie doppelt so groß wie ein `BIGINT`, schlechter lesbar und belastet den Index, wenn sie zufällig verteilt ist.

## So ist eine UUID aufgebaut

Die übliche Schreibweise besteht aus 32 Hexadezimalziffern in fünf Gruppen. Zwei Stellen haben eine feste Bedeutung:

```
fbd0a224-e753-47f1-8ab9-f8f688240eb6
              ^    ^
              |    Variante (8, 9, a oder b)
              Version (hier 4)
```

Die erste Ziffer der dritten Gruppe gibt die **Version** an, die erste Ziffer der vierten Gruppe die **Variante**. Die aktuelle Spezifikation ist [RFC 9562](https://www.rfc-editor.org/rfc/rfc9562.html) vom Mai 2024; sie ersetzt RFC 4122 und führt unter anderem die Versionen 6, 7 und 8 ein. Mit dem [UUID- & ULID-Generator](https://skriptbox.com/de/tools/uuid-generator) können Sie eine vorhandene UUID zerlegen und sehen Version, Variante und – bei zeitbasierten Varianten – den enthaltenen Zeitpunkt.

## UUID v4 und das Problem mit dem Index

Version 4 besteht bis auf Version und Variante aus 122 Zufallsbits. Für die Eindeutigkeit ist das ideal, für einen B-Baum-Index – den Standardindex in PostgreSQL, MySQL und MariaDB – nicht:

- Jede neue ID landet an einer zufälligen Stelle im Index. Volle Indexseiten müssen geteilt werden (**Page Splits**), die Seiten sind danach nur teilweise gefüllt.
- Der Index wird dadurch größer und **fragmentiert**.
- Beim Einfügen wird ständig auf andere Seiten zugegriffen. Solange der Index in den Arbeitsspeicher passt, fällt das kaum auf; wird er größer als der **Cache**, muss die Datenbank häufig von der Festplatte lesen, und Schreibvorgänge werden deutlich langsamer.

Besonders betroffen ist MySQL mit InnoDB: Dort ist der Primärschlüssel ein gruppierter Index, die Tabellenzeilen selbst werden also nach der ID sortiert gespeichert. Zudem enthält jeder Sekundärindex den Primärschlüssel – eine große ID vergrößert alle Indizes der Tabelle.

Fortlaufende IDs werden dagegen immer am rechten Rand des Index angehängt. Genau diese Eigenschaft bringen UUID v7 und ULID zurück.

## UUID v7 und ULID: zeitlich sortierbar

**UUID v7** beginnt mit einem 48-Bit-Zeitstempel in Millisekunden seit 1970 (Unix-Zeit), gefolgt von Version, Variante und 74 Bit, die zufällig sind oder teilweise als Zähler dienen. Drei UUIDs v7, im Abstand von je einer Millisekunde erzeugt:

```
01a1f873-c8a0-75c3-9f44-cdacf58c2bf3
01a1f873-c8a1-7074-8292-f8d38b0b8d9c
01a1f873-c8a2-7c30-8879-e52c96bfbcc4
```

Die ersten zwölf Hexadezimalziffern (`01a1f873c8a0`) sind der Zeitstempel: dezimal 1795169700000 Millisekunden, also der 20. November 2026, 10:15:00 Uhr UTC. Solche Werte rechnen Sie mit dem [Timestamp-Umrechner](https://skriptbox.com/de/tools/unix-timestamp-umrechner) in ein lesbares Datum um. Neue IDs sind damit größer als ältere und werden – wie bei Auto-Increment – am Ende des Index eingefügt.

Die **ULID** (Universally Unique Lexicographically Sortable Identifier) verfolgt dasselbe Prinzip: 48 Bit Zeitstempel in Millisekunden und 80 Bit Zufall. Sie wird aber nicht hexadezimal, sondern in **Crockford-Base32** geschrieben – 26 Zeichen, nur Großbuchstaben und Ziffern, ohne die leicht verwechselbaren Buchstaben I, L, O und U:

```
01M7W77J50RS5VA0XF7WT5AGYY
```

Die ersten zehn Zeichen enthalten den Zeitstempel. ULIDs sind kürzer als UUIDs in Textform und lassen sich als Zeichenkette sortieren. Sie sind allerdings kein IETF-Standard, sondern eine [offene Spezifikation](https://github.com/ulid/spec). In der Datenbank speichern Sie sie wie eine UUID als 16 Byte.

### Alle Varianten im Vergleich

|  | BIGINT Auto-Increment | UUID v4 | UUID v7 | ULID |
| --- | --- | --- | --- | --- |
| Größe (binär) | 8 Byte | 16 Byte | 16 Byte | 16 Byte |
| Textform | bis 19 Ziffern | 36 Zeichen | 36 Zeichen | 26 Zeichen |
| Erzeugung ohne Datenbank | nein | ja | ja | ja |
| Zeitlich sortiert | ja | nein | ja | ja |
| Verhalten im B-Baum-Index | sehr gut | schlecht bei großen Tabellen | gut | gut |
| Verrät Informationen | Anzahl und Reihenfolge | nichts | Erstellungszeitpunkt | Erstellungszeitpunkt |
| Standard | – | RFC 9562 | RFC 9562 | eigene Spezifikation |

Der [UUID- & ULID-Generator](https://skriptbox.com/de/tools/uuid-generator) erzeugt alle drei Varianten sowie namensbasierte UUIDs v5 – auf Wunsch bis zu 1000 Stück auf einmal als Liste, JSON oder SQL.

## UUIDs richtig speichern

### PostgreSQL

PostgreSQL hat einen eigenen Datentyp `uuid`, der intern 16 Byte belegt. `gen_random_uuid()` erzeugt UUIDs v4, seit PostgreSQL 18 gibt es zusätzlich `uuidv7()` (siehe [Dokumentation](https://www.postgresql.org/docs/current/functions-uuid.html)):

```
CREATE TABLE orders (
    id uuid PRIMARY KEY DEFAULT uuidv7(),
    created_at timestamptz NOT NULL DEFAULT now()
);
```

### MySQL

MySQL hat keinen UUID-Datentyp. Speichern Sie die ID als `BINARY(16)`, nicht als `CHAR(36)` – das spart mehr als die Hälfte des Platzes in jedem Index. Zum Umwandeln gibt es `UUID_TO_BIN()` und `BIN_TO_UUID()`:

```
CREATE TABLE orders (
    id BINARY(16) PRIMARY KEY
);

INSERT INTO orders (id) VALUES (UUID_TO_BIN('01a1f873-c8a0-75c3-9f44-cdacf58c2bf3'));
SELECT BIN_TO_UUID(id) FROM orders;
```

Die MySQL-Funktion `UUID()` erzeugt Version 1, bei der die Zeitanteile ungünstig angeordnet sind. Mit `UUID_TO_BIN(UUID(), 1)` werden sie umsortiert, sodass die Werte aufsteigend gespeichert werden. Diesen zweiten Parameter verwenden Sie **nur bei v1**; eine UUID v7 ist bereits richtig sortiert und wird ohne ihn gespeichert. UUIDs v7 erzeugen Sie in MySQL am besten in der Anwendung.

### MariaDB

MariaDB bringt seit Version 10.7 einen eigenen Datentyp `UUID` mit, der 16 Byte belegt und die übliche Textform ein- und ausgibt. Eine Umwandlung mit Funktionen ist dann nicht nötig.

### In der Anwendung

In Symfony erzeugt die Uid-Komponente UUIDs v7 (`Uuid::v7()`) und ULIDs (`new Ulid()`); für Doctrine stehen passende Spaltentypen bereit. In Laravel vergibt der Trait `HasUuids` seit Version 12 standardmäßig UUIDs v7, `HasUlids` erzeugt ULIDs.

## Vorsicht: Was eine ID verrät

Eine UUID v7 oder ULID enthält den Erstellungszeitpunkt auf die Millisekunde genau – jeder, der die ID sieht, kann ihn auslesen. Bei einer Bestellnummer ist das meist unkritisch, bei der ID eines Nutzerkontos kann es mehr verraten als gewollt, etwa wann sich jemand registriert hat. Wenn das stört, verwenden Sie nach außen eine UUID v4 oder eine separate öffentliche Kennung.

Verwenden Sie IDs außerdem nie als Geheimnis. Auch wenn eine UUID schwer zu erraten ist: Wer den Link zu `/rechnung/01a1f873-…` kennt, darf die Rechnung nur sehen, wenn Ihre Anwendung die Berechtigung prüft. Für Passwort-Links oder API-Schlüssel gehören eigene, ausreichend lange Zufallswerte ohne Zeitanteil.

## Empfehlung

- **Kleine Anwendung mit einer Datenbank, IDs nicht öffentlich:** `BIGINT` mit Auto-Increment ist weiterhin eine gute Wahl.
- **IDs werden verteilt erzeugt, Daten zusammengeführt oder IDs stehen in URLs:** UUID v7 als Primärschlüssel. Sie ist standardisiert, wird von PostgreSQL nativ erzeugt und von gängigen Bibliotheken unterstützt.
- **Kurze, gut lesbare IDs gewünscht:** ULID – vor allem, wenn die ID oft in Textform auftaucht.
- **Der Erstellungszeitpunkt darf nicht erkennbar sein:** UUID v4, bei großen Tabellen am besten nur als zusätzliche öffentliche Kennung neben einem sortierbaren Primärschlüssel.

Speichern Sie UUIDs immer binär (`uuid`, `BINARY(16)` oder MariaDB-`UUID`) und nicht als Text. Und wählen Sie eine Variante pro Tabelle – ein Mix aus v4 und v7 in derselben Spalte verliert den Vorteil der Sortierung.


## Tools zum Thema

- [UUID- & ULID-Generator](https://skriptbox.com/de/tools/uuid-generator.md) – UUIDs (v4, v7, v5) und ULIDs kostenlos erzeugen – bis zu 1.000 auf einmal als Liste, JSON oder SQL – und vorhandene IDs prüfen. Ohne Übertragung.
- [Unix-Timestamp-Umrechner](https://skriptbox.com/de/tools/unix-timestamp-umrechner.md) – Unix-Timestamps in Datum und Uhrzeit umrechnen und zurück – Sekunden bis Nanosekunden, jede Zeitzone, mit Code für PHP, JavaScript, Python, SQL und Bash.
