Hvad er MVCC i PostgreSQL?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) er hvordan PostgreSQL håndterer samtidig adgang — i stedet for at låse rækker under læsninger, beholder det **flere versioner** af rækker, så hver transaktion ser et konsistent **snapshot** af dataene. Hovedfordelen: **læsere blokerer ikke skrivere, og skrivere blokerer ikke læsere**, hvilket muliggør høj concurrency.

## Kerneidéen: flere rækkeversioner

```text
When a row is UPDATED, Postgres doesn't overwrite it — it creates a NEW version and
marks the old one obsolete. Different transactions can see different versions.
→ Each transaction sees a consistent SNAPSHOT of the database as of its start
  (depending on isolation level), unaffected by others' uncommitted changes.
```

## Den store fordel: ingen læselåse

```text
Without MVCC (lock-based): readers and writers BLOCK each other
  → a long-running report could block writes; a write could block reads.
With MVCC:
  ✓ READERS DON'T BLOCK WRITERS — a SELECT sees an old version while an UPDATE proceeds
  ✓ WRITERS DON'T BLOCK READERS
  ✓ Each transaction sees a stable, consistent view (no dirty reads)
→ Much higher concurrency for read-heavy and mixed workloads.
```

## Sådan fungerer det (forenklet)

```sql
-- Transaction A starts a long SELECT (sees a snapshot)
BEGIN; SELECT count(*) FROM orders;   -- sees data as of its snapshot

-- meanwhile Transaction B updates rows — creates new versions, doesn't block A
-- A still sees its consistent snapshot; B's changes are a new version
```

Postgres sporer transaktions-ID'er og rækkesynlighed, så hver transaktion ser den korrekte version. Dette giver **isolation** uden læselåse.

## Omkostningen: døde tupler og VACUUM

```text
MVCC creates obsolete row versions ("dead tuples") that accumulate → bloat.
VACUUM (and AUTOVACUUM) reclaims this dead space and keeps the database healthy.
→ This is why VACUUM is important in Postgres — it's the cleanup for MVCC's versions.
```

## Hvorfor det betyder noget

MVCC er fundamental for at forstå PostgreSQL's concurrency-adfærd og ydeevne, så det er værdifuldt viden for at arbejde effektivt med Postgres.

Den kerneverdi, som MVCC giver, er **høj concurrency**: ved at beholde flere versioner af rækker og give hver transaktion et konsistent snapshot, **blokerer læsere ikke skrivere og skrivere blokerer ikke læsere** — hvilket er en stor fordel for rigtige applikationer (en langkørende rapport blokerer ikke opdateringer, og skrivninger blokerer ikke læsninger), hvilket muliggør meget bedre concurrency for læseheavy og blandede workloads sammenlignet med låsbaserede tilgange.

Dette er grunden til, at PostgreSQL håndterer samtidig adgang så godt, og forståelse af MVCC forklarer databasens concurrency-karakteristika (konsistente snapshots, isolation uden læselåse, ingen dirty reads).

Vigtigt er det også, at forståelse af MVCC forklarer **hvorfor `VACUUM` er vigtig i Postgres**: MVCC skaber forældede rækkeversioner ("døde tupler") når rækker opdateres og slettes, som akkumuleres som bloat, og `VACUUM`/`AUTOVACUUM` er oprydningsmekanismen, der frigør denne plads og holder databasen sund — så MVCC og VACUUM er intimt forbundet, og kendskab til denne forbindelse er vigtig for databasevedligeholdelse og ydeevne (forsømmelse af vacuum fører til bloat og forringet ydeevne, en reel operationel concern).

Da concurrency-adfærd fundamentalt påvirker, hvordan en database fungerer under belastning, og da MVCC (Postgres's concurrency-model) forklarer både den udmærkede read/write-concurrency og behovet for VACUUM-vedligeholdelse, er forståelse af MVCC værdifuld viden for at arbejde med PostgreSQL — det præciserer databasens concurrency-fordele og den vedligeholdelse, den kræver, vigtig både for at ræsonnere om ydeevne og for at drive Postgres korrekt, og et almindeligt emne, der demonstrerer forståelse af, hvordan Postgres håndterer samtidig adgang.