PostgreSQL இல் MVCC என்றால் என்ன?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) என்பது PostgreSQL வில் concurrent access களை கையாளும் விதம் — rows களுக்கு reads க்கு locks போடுவதற்கு பதிலாக, rows களின் **multiple versions** களை வைத்திருக்கிறது, ஆகையால் ஒவ்வொரு transaction ம் data வின் consistent **snapshot** ஐ பார்க்கிறது. முக்கிய benefit: **readers writers களை block செய்யாது, writers readers களை block செய்யாது**, high concurrency ஐ enable செய்கிறது.

## மையமான concept: 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.
```

## பெரிய benefit: 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.
```

## இது எப்படி வேலை செய்கிறது (simplified)

```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 ஐ பார்க்கிறது. இது **isolation** ஐ read locks இல்லாமல் provide செய்கிறது.

## செலவு: 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 இன் concurrency behavior மற்றும் performance ஐ புரிந்துகொள்ள fundamental ஆக இருக்கிறது, ஆகையால் Postgres உடன் effective ஆக வேலை செய்வதற்கு valuable knowledge ஆக இருக்கிறது.

MVCC provide செய்யும் core value என்பது **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 களுக்கு much better concurrency ஐ enable செய்கிறது.

இதுவே PostgreSQL concurrent access ஐ நன்றாக handle செய்கிற காரணம், மற்றும் MVCC ஐ புரிந்துகொள்வது database இன் concurrency characteristics களை (consistent snapshots, read locks இல்லாமல் isolation, dirty reads இல்லை) விளக்குகிறது.

အရေးအပါ, MVCC ஐ புரிந்துகொள்வது **Postgres இல் `VACUUM` ஏன் முக்கியமாக இருக்கிறது** என்பதையும் விளக்குகிறது: MVCC obsolete row versions களை ("dead tuples") create செய்கிறது rows update மற்றும் delete ஆகும்போது, இவை bloat ஆக accumulate ஆகிறது, மற்றும் `VACUUM`/`AUTOVACUUM` என்பது cleanup mechanism ஆக இருக்கிறது இந்த space ஐ reclaim செய்து database ஐ healthy வாக வைத்திருக்கிறது — ஆகையால் MVCC மற்றும் VACUUM intimately connected ஆக இருக்கிறது, மற்றும் இந்த connection ஐ knowing வது database maintenance மற்றும் performance க்கு important ஆக இருக்கிறது (vacuum ஐ neglect செய்வது bloat மற்றும் degraded performance க்கு leads செய்கிறது, real operational concern ஆக இருக்கிறது).

Concurrency behavior fundamentally database performance ஐ load க்கு affect செய்கிறது, மற்றும் MVCC (Postgres இன் concurrency model) excellent read/write concurrency மற்றும் VACUUM maintenance இன் need இரண்டையும் விளக்குகிறது, MVCC ஐ புரிந்துகொள்வது PostgreSQL க்கு valuable knowledge ஆக இருக்கிறது — இது database இன் concurrency advantages மற்றும் அது require செய்யும் maintenance ஐ clarify செய்கிறது, performance பற்றி reasoning க்கு மற்றும் Postgres ஐ correctly operate செய்வதற்கு important ஆக இருக்கிறது, மற்றும் Postgres concurrent access ஐ எப்படி handle செய்கிறது என்பதைப் புரிந்துகொள்ளல் demonstrate செய்யும் common topic ஆக இருக்கிறது.