Apa itu MVCC di PostgreSQL?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) adalah cara PostgreSQL menangani akses bersamaan — alih-alih mengunci baris untuk pembacaan, itu menyimpan **multiple versions** dari baris, sehingga setiap transaksi melihat **snapshot** data yang konsisten. Manfaat utama: **pembaca tidak memblokir penulis, dan penulis tidak memblokir pembaca**, memungkinkan concurrency tinggi.

## Ide inti: multiple row versions

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

## Manfaat besar: tidak ada read locks

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

## Cara kerjanya (disederhanakan)

```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 melacak transaction IDs dan row visibility sehingga setiap transaksi melihat versi yang benar. Ini memberikan **isolation** tanpa read locks.

## Biayanya: dead tuples dan 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.
```

## Mengapa ini penting

MVCC adalah fundamental untuk memahami perilaku concurrency dan performa PostgreSQL, jadi ini adalah pengetahuan berharga untuk bekerja dengan Postgres secara efektif.

Nilai inti yang diberikan MVCC adalah **high concurrency**: dengan menyimpan multiple versions dari baris dan memberikan setiap transaksi snapshot yang konsisten, **pembaca tidak memblokir penulis dan penulis tidak memblokir pembaca** — yang adalah keuntungan besar untuk aplikasi nyata (laporan yang berjalan lama tidak memblokir updates, dan writes tidak memblokir reads), memungkinkan concurrency jauh lebih baik untuk workloads yang heavy-read dan mixed dibandingkan pendekatan berbasis lock.

Inilah mengapa PostgreSQL menangani akses bersamaan dengan sangat baik, dan memahami MVCC menjelaskan karakteristik concurrency database (consistent snapshots, isolation tanpa read locks, tidak ada dirty reads).

Secara kritis, memahami MVCC juga menjelaskan **mengapa `VACUUM` penting di Postgres**: MVCC menciptakan obsolete row versions ("dead tuples") saat baris diupdate dan dihapus, yang terakumulasi sebagai bloat, dan `VACUUM`/`AUTOVACUUM` adalah mekanisme cleanup yang merebut kembali space ini dan menjaga database tetap sehat — jadi MVCC dan VACUUM sangat terkait erat, dan mengetahui koneksi ini penting untuk database maintenance dan performa (mengabaikan vacuum menyebabkan bloat dan degraded performance, sebuah operational concern yang nyata).

Karena concurrency behavior secara fundamental mempengaruhi bagaimana database berkinerja di bawah beban, dan karena MVCC (concurrency model Postgres) menjelaskan both excellent read/write concurrency dan kebutuhan untuk VACUUM maintenance, memahami MVCC adalah pengetahuan berharga untuk bekerja dengan PostgreSQL — ini mengklarifikasi keuntungan concurrency database dan maintenance yang diperlukan, penting untuk kedua reasoning tentang performa dan operating Postgres dengan benar, dan topik umum yang menunjukkan pemahaman tentang bagaimana Postgres menangani akses bersamaan.