PostgreSQL में MVCC क्या है?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) PostgreSQL में concurrent access को संभालने का तरीका है — पढ़ने के लिए rows को lock करने के बजाय, यह rows के **multiple versions** को रखता है, इसलिए प्रत्येक transaction डेटा का एक consistent **snapshot** देखता है। मुख्य लाभ: **readers writers को block नहीं करते, और writers readers को block नहीं करते**, high concurrency को सक्षम करते हैं।

## मूल विचार: 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.
```

## बड़ा लाभ: कोई 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.
```

## यह कैसे काम करता है (सरलीकृत)

```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 transaction IDs और row visibility को track करता है ताकि प्रत्येक transaction सही version देखे। यह read locks के बिना **isolation** प्रदान करता है।

## लागत: dead tuples और 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.
```

## इसका क्यों महत्व है

MVCC PostgreSQL के concurrent behavior और performance को समझने के लिए मौलिक है, इसलिए Postgres के साथ प्रभावी रूप से काम करने के लिए यह मूल्यवान knowledge है।

MVCC का मुख्य मूल्य **high concurrency** है: rows के multiple versions रखकर और प्रत्येक transaction को एक consistent snapshot देकर, **readers writers को block नहीं करते और writers readers को block नहीं करते** — जो real applications के लिए एक major advantage है (एक long-running report updates को block नहीं करता, और writes reads को block नहीं करते), जो lock-based approaches की तुलना में read-heavy और mixed workloads के लिए बहुत better concurrency सक्षम करता है।

यह है कि PostgreSQL concurrent access को कितनी अच्छी तरह से संभालता है, और MVCC को समझना database के concurrent characteristics को समझाता है (consistent snapshots, read locks के बिना isolation, कोई dirty reads नहीं)।

महत्वपूर्ण रूप से, MVCC को समझना यह भी समझाता है **कि Postgres में `VACUUM` क्यों महत्वपूर्ण है**: MVCC obsolete row versions ("dead tuples") बनाता है जब rows को update और delete किया जाता है, जो bloat के रूप में accumulate होता है, और `VACUUM`/`AUTOVACUUM` एक cleanup mechanism है जो इस space को reclaim करता है और database को healthy रखता है — इसलिए MVCC और VACUUM closely connected हैं, और यह connection जानना database maintenance और performance के लिए महत्वपूर्ण है (VACUUM की उपेक्षा bloat और degraded performance की ओर ले जाती है, एक real operational concern)।

चूंकि concurrent behavior fundamentally प्रभावित करता है कि database load के तहत कैसे perform करता है, और चूंकि MVCC (Postgres की concurrency model) excellent read/write concurrency और VACUUM maintenance की जरूरत दोनों को समझाता है, MVCC को समझना PostgreSQL के साथ काम करने के लिए मूल्यवान knowledge है — यह database के concurrency advantages और required maintenance को clarify करता है, performance के बारे में reasoning और Postgres को सही तरीके से operate करने दोनों के लिए महत्वपूर्ण है, और एक common topic है जो यह demonstrate करता है कि कोई Postgres के concurrent access को कैसे संभालता है।