Mi az MVCC a PostgreSQL-ben?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) az a módszer, ahogyan a PostgreSQL az egyidejű hozzáférést kezeli — ahelyett, hogy az olvasásra sorokat zárolna, **több verzióját** tartja meg a soroknak, így minden tranzakció az adatok konzisztens **pillanatképét** látja. A fő előny: **az olvasók nem blokkolják az írokat, az írók nem blokkolják az olvasókat**, magas párhuzamosságot engedélyez.

## Az alapgondolat: több sor verzió

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

## A nagy előny: nincsenek olvasási zárolások

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

## Hogyan működik (egyszerűsített)

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

A Postgres nyomon követi a tranzakció azonosítóit és a sorok láthatóságát, így minden tranzakció a helyes verziót látja. Ez **izolációt** biztosít olvasási zárolások nélkül.

## A költség: halott tuple-ek és 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.
```

## Miért fontos

Az MVCC alapvető a PostgreSQL párhuzamossági viselkedésének és teljesítményének megértéséhez, ezért értékes tudás a Postgres hatékony használatához.

Az MVCC által nyújtott alapvető érték a **magas párhuzamosság**: a sorok több verziójának megtartásával és minden tranzakciónak konzisztens pillanatképet adva, **az olvasók nem blokkolják az írokat és az írók nem blokkolják az olvasókat** — ami nagy előny a valós alkalmazások számára (egy hosszú ideig futó jelentés nem blokkolja a frissítéseket, az írások nem blokkolják az olvasásokat), sokkal jobb párhuzamosságot engedélyez az olvasásra hajlamos és vegyes terhelésekhez, mint a zárolás alapú megközelítések.

Ezért kezeli a PostgreSQL olyan jól az egyidejű hozzáférést, és az MVCC megértése magyarázza az adatbázis párhuzamossági jellemzőit (konzisztens pillanatképek, izoláció olvasási zárolások nélkül, nincs piszkos olvasás).

Meghatározóan az MVCC megértése azt is magyarázza, **miért fontos a `VACUUM` a Postgresben**: az MVCC elavult sor verziókat ("halott tuple-eket") hoz létre, ahogy a sorokat frissítik és törölik, amelyek felhalmozódnak szennyezésként, és a `VACUUM`/`AUTOVACUUM` az a tisztítási mechanizmus, amely visszaigényli ezt a helyet és az adatbázist egészségesnek tartja — így az MVCC és VACUUM szorosan kapcsolódnak, és ennek a kapcsolatnak az ismerete fontos az adatbázis karbantartásához és teljesítményéhez (a VACUUM elhanyagolása szennyezéshez és teljesítmény-romláshoz vezet, valós működési probléma).

Mivel a párhuzamossági viselkedés alapvetően befolyásolja az adatbázis terhelés alatti teljesítményét, és mivel az MVCC (a Postgres párhuzamossági modellje) mind a kiváló olvasás/írás párhuzamosságot, mind a VACUUM karbantartás szükségességét magyarázza, az MVCC megértése értékes tudás a PostgreSQL-lel való munkához — tisztázza az adatbázis párhuzamossági előnyeit és a szükséges karbantartást, fontos a teljesítmény meggondolásához és a Postgres helyes üzemeltetéséhez, valamint egy közös témakör, amely azt mutatja, hogy értelmezzük, hogyan kezeli a Postgres az egyidejű hozzáférést.