Direct naar de inhoud
test-nummers.nl

ID-systemen · 11 min lezen

UUID v4 versus v7 — waarom databasesorteerbare UUIDs de standaard worden

Door Alex · Gepubliceerd 17 april 2026

Deel:

Sinds mei 2024 is RFC 9562 de actuele specificatie voor UUID-formaten. De belangrijkste nieuwe versie in die RFC is v7: een tijdstempel-gebaseerde UUID die wél willekeurig genoeg is om botsingen te vermijden, maar zodanig geordend is dat een database-index hem sequentieel kan verwerken. Dit artikel legt uit waar dat verschil vandaan komt, wat het betekent voor btree-inserts in PostgreSQL, en geeft werkende TypeScript-implementaties voor beide versies.

1. Wat is een UUID?

Een UUID (Universally Unique Identifier) is een 128-bit identifier, meestal weergegeven als 32 hexadecimale tekens in het formaat xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx. De positie M geeft de versie aan (1–8), de positie N codeert de variant. De oorspronkelijke versies zijn vastgelegd in RFC 4122 (2005) en omvatten v1 (tijd + MAC-adres), v2 (DCE security), v3 (MD5-hash), v4 (random) en v5 (SHA-1-hash).

In mei 2024 is RFC 9562 uitgebracht als vervanger van 4122. Die introduceert drie nieuwe versies: v6 (v1 met herordende bits voor sorteerbaarheid), v7 (Unix-timestamp in milliseconden + random) en v8 (custom formaat voor specifieke behoeften). RFC 9562 raadt v7 aan boven v1 en v6; als databasesleutel is v7 bovendien een alternatief voor v4.

2. Hoe werkt UUID v4?

v4 is het eenvoudigst: van de 128 bits worden 6 bits vastgelegd voor versie (4 bits = 0100) en variant (2 bits = 10), de overige 122 bits zijn cryptografisch willekeurig. Dat geeft 2¹²² ≈ 5,3 × 10³⁶ unieke waarden. De kans op een botsing is verwaarloosbaar: pas na ongeveer 86 jaar lang een miljard UUIDs per seconde is de kans op minstens één botsing 50 %.

f47ac10b-58cc-4372-a567-0e02b2c3d479
              ^    ^
              │    variant: 8, 9, a of b (bits 10)
              versie=4

v4 is populair geworden vanwege simpliciteit: één aanroep van een cryptografisch-veilige RNG is voldoende. In Node.js zit crypto.randomUUID() sinds versie 14.17 in de crypto-module; in moderne browsers (alleen via HTTPS) en vanaf Node 19 is het ook globaal beschikbaar. De UUID generator op deze site gebruikt dezelfde functie.

3. Hoe werkt UUID v7?

v7 splitst de 128 bits in vijf velden:

 48 bits         4 bits    12 bits       2 bits     62 bits
────────────── ──────── ────────── ────────── ──────────────────────
unix_ts_ms      versie=7  rand_a     variant    rand_b
│                        │                      │
tijdstempel in          extra random          rest random
milliseconden

De eerste 48 bits bevatten het Unix-tijdstempel in milliseconden — genoeg tot het jaar 10889. Daarna volgen 4 bits versienummer, 12 bits random, 2 bits variant en 62 bits random. In totaal blijft 74 bits entropy over, nog steeds meer dan voldoende voor praktisch elke schaal.

Visueel gepresenteerd:

0190d8a8-fe34-7123-a5bc-8a5e4b22e3f1
───────────── ^
48 bits       versie=7
tijdstempel

Omdat de eerste bits monotoon stijgend zijn, zijn v7-UUIDs chronologisch sorteerbaar — twee UUIDs van dezelfde milliseconde staan in willekeurige volgorde (door de random tail), maar twee UUIDs van verschillende milliseconden staan in tijdvolgorde, zolang de klok van de generator niet terugspringt. RFC 9562 beschrijft ook varianten met een teller, voor oplopende waarden binnen dezelfde milliseconde.

4. Het btree-probleem met v4

Een btree-index gaat uit van sorteerbare sleutels. Inserts worden op de juiste positie in de boom ingevoegd, wat efficiënt gebeurt als nieuwe sleutels clusteren aan één kant (bv. altijd groter dan de vorige). Bij volledig random sleutels zoals v4 valt elke insert op een willekeurige plek, wat twee problemen veroorzaakt: page splits (pagina's die vol zitten moeten gesplitst worden bij inserts) en write amplification(meer pagina's worden gewijzigd dan strikt nodig, wat I/O en WAL-verkeer verhoogt).

Wat dat in PostgreSQL betekent, kwalitatief samengevat:

ScenarioWaar landt een insert?IndexWAL
bigserial (sequential)Altijd rechts in de indexCompact (sleutel 8 bytes)Laag
uuid v7Vrijwel altijd rechts (oplopend per ms)Compact (sleutel 16 bytes)Laag
uuid v4Op een willekeurige plekGroter: meer splits, pagina's minder volHoger: meer full-page writes

Hoe groot het verschil is, hangt vooral af van de verhouding tussen indexgrootte en geheugen. Zolang de hele index in het geheugen past, merk je weinig. Groeit de index daarboven uit, dan moet PostgreSQL bij v4-inserts steeds andere pagina's van schijf lezen en wegschrijven, terwijl v7-inserts steeds dezelfde paar pagina's aan de rechterkant raken.

Meet het daarom zelf, op je eigen hardware en data: fillfactor, WAL-instellingen, autovacuum-gedrag en schijflatency bepalen de absolute cijfers.

5. TypeScript implementaties

v4 is een one-liner dankzij de standaard Web Crypto API:

// Globaal in Node 19+, Deno, Bun en moderne browsers (HTTPS).
// Oudere Node: import { randomUUID } from 'node:crypto'
export function uuidV4(): string {
  return crypto.randomUUID();
}

Browsers en Node.js hebben bij het schrijven van dit artikel nog geen ingebouwde functie voor v7 (PostgreSQL 18 wel: uuidv7()). Een compacte pure-TS-implementatie die RFC 9562 volgt:

export function uuidV7(): string {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);

  // 48-bit Unix-timestamp in ms → eerste 6 bytes
  const ms = BigInt(Date.now());
  bytes[0] = Number((ms >> 40n) & 0xffn);
  bytes[1] = Number((ms >> 32n) & 0xffn);
  bytes[2] = Number((ms >> 24n) & 0xffn);
  bytes[3] = Number((ms >> 16n) & 0xffn);
  bytes[4] = Number((ms >> 8n) & 0xffn);
  bytes[5] = Number(ms & 0xffn);

  // Versie 7: bovenste 4 bits van byte 6
  bytes[6] = (bytes[6] & 0x0f) | 0x70;
  // Variant RFC 9562: bovenste 2 bits van byte 8 = 10
  bytes[8] = (bytes[8] & 0x3f) | 0x80;

  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
  return [
    hex.slice(0, 8),
    hex.slice(8, 12),
    hex.slice(12, 16),
    hex.slice(16, 20),
    hex.slice(20, 32),
  ].join('-');
}

Twee subtiele punten: de bit-manipulaties voor versie en variant gebeuren na het vullen met random bytes, zodat het random-veld niet per ongeluk de vaste bits overschrijft. En de timestamp wordt als BigInt behandeld om de 48-bit-range goed te hanteren — een gewone number is in JavaScript max 2⁵³ en dus voldoende, maar bitshifts boven 32 bits werken dan niet betrouwbaar.

6. Wanneer kies je wat?

Criteriumv4v7
Privacy (geen tijdstip-leak)Wint — geen metadataVerliest — tijdstip in ID
Database-insert-performanceDuurder zodra de index niet in het geheugen pastGoed (vrijwel oplopend)
SorteerbaarheidNiet chronologischChronologisch per ms
CompatibilityUniverseelPast in elke uuid-kolom; gestandaardiseerd in RFC 9562 (2024)
Multi-node generatieGeen coördinatie nodigGeen coördinatie nodig
Enumeratie-risicoGeenGeen (timestamp-deel is bekend, random-deel beschermt)

Vuistregel: voor database primary keys is v7 meestal de betere keuze (behalve in SQL Server, zie hieronder). Voor publieke URL-identifiers waar het tijdstip van aanmaak gevoelig is (bv. healthcare-cases, onderzoeks-dossiers, documentverwijzingen in gerechtelijke context) blijft v4 verstandig — of gebruik v4 voor de publieke ID en v7 voor de interne database-key.

7. Migratie-strategie

Je hoeft bestaande v4-IDs niet te rewriten. Beide versies delen hetzelfde kolomtype — uuid in PostgreSQL, BINARY(16) of CHAR(36) in MySQL, uniqueidentifier in SQL Server (MariaDB heeft sinds 10.7 een eigen UUID-type). Het versieveld (het 13e hexteken) onderscheidt de twee; je kunt ze zonder schema-wijziging door elkaar gebruiken. Let op: SQL Server sorteert uniqueidentifier op de laatste bytes eerst, waardoor v7 daar geen oplopende index oplevert.

De pragmatische stap: nieuwe records krijgen v7, bestaande records behouden hun v4. Nieuwe inserts landen dan aan de rechterkant van de index, zonder downtime of backfill. De btree blijft intern gesorteerd; een mix van v4 en v7 is geen probleem voor correctheid.

Als je wél wilt backfillen (bv. voor archief-tabellen waar index-grootte echt knelt): genereer nieuwe v7-UUIDs met een tijdstempel die overeenkomt met created_at van het record, en werk alle verwijzende foreign keys mee bij. De ordering van historische data blijft dan consistent.

8. Bronnen

  • RFC 9562 — Universally Unique IDentifiers (UUIDs), mei 2024. IETF. Vervangt RFC 4122 en voegt v6, v7 en v8 toe.
  • RFC 4122 — A Universally Unique IDentifier (UUID) URN Namespace, juli 2005. Oorspronkelijke specificatie voor v1–v5.
  • PostgreSQL documentation — UUID Type, de UUID-functies (uuidv7() sinds versie 18) en de uuid-ossp-module.
  • The Open Group — DCE 1.1: Remote Procedure Call (1997), bijlage A: de UUID-specificatie waarop RFC 4122 voortbouwt.

Gerelateerde tools