Was ist MVCC in PostgreSQL?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) ist die Methode, wie PostgreSQL gleichzeitigen Zugriff handhabt — statt Zeilen für Lesezugriffe zu sperren, behält es **mehrere Versionen** von Zeilen, so dass jede Transaktion einen konsistenten **Snapshot** der Daten sieht. Der Hauptvorteil: **Leser blockieren Schreiber nicht, und Schreiber blockieren Leser nicht**, was hohe Parallelität ermöglicht.

## Die Kernidee: mehrere Zeilenversionen

```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.
```

## Der große Vorteil: keine Lesesperren

```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.
```

## Wie es funktioniert (vereinfacht)

```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 verfolgt Transaktions-IDs und Zeilensichtbarkeit, so dass jede Transaktion die richtige Version sieht. Dies bietet **Isolation** ohne Lesesperren.

## Die Kosten: tote Tupel und 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.
```

## Warum es wichtig ist

MVCC ist grundlegend für das Verständnis des Parallelitätsverhaltens und der Leistung von PostgreSQL, daher ist es wertvolles Wissen für die effektive Arbeit mit Postgres.

Der Kernwert, den MVCC bietet, ist **hohe Parallelität**: Durch das Verwalten mehrerer Zeilenversionen und die Bereitstellung eines konsistenten Snapshots für jede Transaktion **blockieren Leser Schreiber nicht und Schreiber blockieren Leser nicht** — ein großer Vorteil für echte Anwendungen (ein lang laufender Bericht blockiert keine Updates, und Schreibvorgänge blockieren keine Lesevorgänge), was deutlich bessere Parallelität für lese-intensive und gemischte Workloads ermöglicht als auf Sperren basierende Ansätze.

Darum handhabt PostgreSQL gleichzeitigen Zugriff so gut, und das Verständnis von MVCC erklärt die Parallelitätscharakteristiken der Datenbank (konsistente Snapshots, Isolation ohne Lesesperren, keine Dirty Reads).

Entscheidend ist auch, dass das Verständnis von MVCC erklärt, **warum `VACUUM` in Postgres wichtig ist**: MVCC erzeugt obsolete Zeilenversionen („tote Tupel"), wenn Zeilen aktualisiert und gelöscht werden, die sich als Bloat ansammeln, und `VACUUM`/`AUTOVACUUM` ist der Cleanup-Mechanismus, der diesen Speicherplatz freimacht und die Datenbank gesund hält — MVCC und VACUUM sind daher eng miteinander verbunden, und diese Verbindung zu kennen ist wichtig für Datenbankwartung und Leistung (Vernachlässigung von Vacuum führt zu Bloat und verschlechterter Leistung, ein echtes operatives Problem).

Da das Parallelitätsverhalten grundlegend beeinflusst, wie eine Datenbank unter Last läuft, und da MVCC (das Parallelitätsmodell von Postgres) sowohl die hervorragende Lese-/Schreib-Parallelität als auch die Notwendigkeit der VACUUM-Wartung erklärt, ist das Verständnis von MVCC wertvolles Wissen für die Arbeit mit PostgreSQL — es verdeutlicht die Parallelitätsvorteile der Datenbank und die erforderliche Wartung, wichtig sowohl zum Nachdenken über Leistung als auch zum korrekten Betreiben von Postgres, und ein häufiges Thema, das Verständnis dafür zeigt, wie Postgres gleichzeitigen Zugriff handhabt.