PostgreSQL માં MVCC શું છે?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) એ PostgreSQL કીસંશોધન એક્સેસ સંભાળવાનો માર્ગ છે — વાંચનો માટે પંક્તિઓને લોક કરવાને બદલે, તે પંક્તિઓના **બહુવિધ સંસ્કરણો** રાખે છે, તેથી દરેક લેનદેન ડેટાના સુસંગત **સ્નેપશોટ** જુએ છે. મુખ્ય લાભ: **વાચકો લેખકોને અવરોધિત કરતા નથી, અને લેખકો વાચકોને અવરોધિત કરતા નથી**, ઉચ્ચ સમવર્તીતા સક્ષમ કરે છે.

## મુખ્ય વિચાર: બહુવિધ પંક્તિ સંસ્કરણો

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

## મોટો લાભ: કોઈ વાંચન તાળાઓ નથી

```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 લેનદેન IDઓ અને પંક્તિ દૃશ્યમાનતાને ટ્રૅક કરે છે જેથી દરેક લેનદેન સાચું સંસ્કરણ જુએ છે. આ વાંચન તાળાઓ વિના **અલગતા** પૂરી પાડે છે.

## ખર્ચ: મૃત tuple અને 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 ની સમવર્તીતા વર્તન અને કામગીરીને સમજવા માટે મૌળિક છે, તેથી Postgres સાથે અસરકારક રીતે કામ કરવા માટે તે મૂલ્યવાન જ્ઞાન છે.

MVCC જે મૂલ્ય પૂરું પાડે છે તે છે **ઉચ્ચ સમવર્તીતા**: પંક્તિઓના બહુવિધ સંસ્કરણો રાખીને અને દરેક લેનદેનને સુસંગત સ્નેપશોટ આપીને, **વાચકો લેખકોને અવરોધિત કરતા નથી અને લેખકો વાચકોને અવરોધિત કરતા નથી** — જે વાસ્તવિક એપ્લિકેશન્સ માટે મોટો લાભ છે (લાંબા સમયનો અહેવાલ અપડેટ્સને અવરોધિત કરતો નથી, અને લખાણ વાંચન અવરોધિત કરતું નથી), લોક-આધારિત પદ્ધતિઓ કરતાં વાંચન-ભારે અને મિશ્ર કાર્યભાર માટે ખૂબ જ સારી સમવર્તીતા સક્ષમ કરે છે.

જે કારણે PostgreSQL સમવર્તીતા એક્સેસ ખૂબ જ સારી રીતે સંભાળે છે, અને MVCC ને સમજવું ડેટાબેસ ની સમવર્તીતા લક્ષણોને સમજાવે છે (સુસંગત સ્નેપશોટ્સ, વાંચન તાળાઓ વિના અલગતા, કોઈ ગંદા વાંચન નથી).

Crucially, understanding MVCC also explains **why `VACUUM` is important in Postgres**: MVCC creates obsolete row versions ("dead tuples") as rows are updated and deleted, which accumulate as bloat, and `VACUUM`/`AUTOVACUUM` is the cleanup mechanism that reclaims this space and keeps the database healthy — so MVCC and VACUUM are intimately connected, and knowing this connection is important for database maintenance and performance (neglecting vacuum leads to bloat and degraded performance, a real operational concern).

Since concurrency behavior fundamentally affects how a database performs under load, and since MVCC (Postgres's concurrency model) explains both the excellent read/write concurrency and the need for VACUUM maintenance, understanding MVCC is valuable knowledge for working with PostgreSQL — it clarifies the database's concurrency advantages and the maintenance it requires, important for both reasoning about performance and operating Postgres correctly, and a common topic that demonstrates understanding of how Postgres handles concurrent access.