MVCC ni nini katika PostgreSQL?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) ni jinsi PostgreSQL inavyoshughulikia ufikiaji unaoendana — badala ya kufunga safu kwa usomaji, inaweka **matoleo mengi** ya safu, hivyo kila transaction inaona **snapshot** thabiti ya data. Faida kuu: **wasomaji hawazuii waandishi, na waandishi hawazuii wasomaji**, ikiwezesha concurrency ya juu.

## Wazo la msingi: matoleo mengi ya safu

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

## Faida kubwa: hakuna 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.
```

## Jinsi inavyofanya kazi (kwa urahisi)

```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 inafuatilia transaction IDs na mwonekano wa safu ili kila transaction ione toleo sahihi. Hii inatoa **isolation** bila read locks.

## Gharama: dead tuples na 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.
```

## Kwa nini ni muhimu

MVCC ni ya msingi kwa kuelewa tabia ya concurrency na utendaji wa PostgreSQL, hivyo ni maarifa yenye thamani kwa kufanya kazi na Postgres kwa ufanisi.

Thamani ya msingi ambayo MVCC inatoa ni **concurrency ya juu**: kwa kuweka matoleo mengi ya safu na kuipa kila transaction snapshot thabiti, **wasomaji hawazuii waandishi na waandishi hawazuii wasomaji** — ambayo ni faida kubwa kwa programu halisi (ripoti inayoendelea kwa muda mrefu haizuii sasisho, na uandishi hauzuii usomaji), ikiwezesha concurrency bora zaidi kwa mizigo-kazi inayotegemea usomaji na mchanganyiko kuliko mbinu zinazotegemea locks.

Ndiyo maana PostgreSQL inashughulikia ufikiaji unaoendana vizuri sana, na kuelewa MVCC kunaeleza tabia za concurrency za hifadhidata (snapshots thabiti, isolation bila read locks, hakuna dirty reads).

Muhimu, kuelewa MVCC pia kunaeleza **kwa nini `VACUUM` ni muhimu katika Postgres**: MVCC inaunda matoleo ya zamani ya safu ("dead tuples") kadiri safu zinavyosasishwa na kufutwa, ambazo zinajilimbikiza kama bloat, na `VACUUM`/`AUTOVACUUM` ni mfumo wa usafishaji unaopata nafasi hii tena na kuweka hifadhidata kuwa na afya — hivyo MVCC na VACUUM zimeunganishwa kwa karibu, na kujua uhusiano huu ni muhimu kwa udumishaji na utendaji wa hifadhidata (kupuuza vacuum kunasababisha bloat na utendaji uliodhoofika, wasiwasi halisi wa uendeshaji).

Kwa kuwa tabia ya concurrency inaathiri kimsingi jinsi hifadhidata inavyofanya kazi chini ya mzigo, na kwa kuwa MVCC (modeli ya concurrency ya Postgres) inaeleza concurrency bora ya usomaji/uandishi na haja ya udumishaji wa VACUUM, kuelewa MVCC ni maarifa yenye thamani kwa kufanya kazi na PostgreSQL — kunafafanua faida za concurrency za hifadhidata na udumishaji unaohitaji, muhimu kwa kufikiri kuhusu utendaji na kuendesha Postgres kwa usahihi, na mada ya kawaida inayoonyesha uelewa wa jinsi Postgres inavyoshughulikia ufikiaji unaoendana.