MVCC ใน PostgreSQL คืออะไร?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) คือวิธีที่ PostgreSQL จัดการการเข้าถึงแบบพร้อมกัน แทนที่จะ lock แถวสำหรับการอ่าน มันเก็บ **หลายเวอร์ชัน** ของแถว ดังนั้นแต่ละ transaction จึงเห็น **snapshot** ของข้อมูลที่สอดคล้องกัน ประโยชน์หลัก: **ผู้อ่านไม่บล็อกผู้เขียน และผู้เขียนไม่บล็อกผู้อ่าน** ทำให้มี concurrency สูง

## แนวคิดหลัก: หลายเวอร์ชันของแถว

```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 และการมองเห็นของแถวเพื่อให้แต่ละ transaction เห็นเวอร์ชันที่ถูกต้อง สิ่งนี้ให้ **isolation** โดยไม่ต้องมี read locks

## ต้นทุน: 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 เป็นพื้นฐานต่อการเข้าใจพฤติกรรม concurrency และ performance ของ PostgreSQL ดังนั้นมันจึงเป็นความรู้ที่มีคุณค่าต่อการทำงานกับ Postgres อย่างมีประสิทธิภาพ

คุณค่าหลักที่ MVCC ให้คือ **concurrency สูง**: ด้วยการเก็บหลายเวอร์ชันของแถวและให้แต่ละ transaction มี snapshot ที่สอดคล้องกัน **ผู้อ่านไม่บล็อกผู้เขียนและผู้เขียนไม่บล็อกผู้อ่าน** ซึ่งเป็นข้อได้เปรียบสำคัญสำหรับแอปพลิเคชันจริง (รายงานที่รันนานไม่บล็อกการอัปเดต และการเขียนไม่บล็อกการอ่าน) ช่วยให้มี concurrency ที่ดีกว่ามากสำหรับ workload ที่เน้นการอ่านและแบบผสมเมื่อเทียบกับแนวทางแบบ lock

นี่คือเหตุผลที่ PostgreSQL จัดการการเข้าถึงแบบพร้อมกันได้ดีมาก และการเข้าใจ MVCC อธิบายลักษณะ concurrency ของฐานข้อมูล (snapshot ที่สอดคล้อง, isolation โดยไม่มี read locks, ไม่มี dirty reads)

ที่สำคัญ การเข้าใจ MVCC ยังอธิบาย **ว่าทำไม `VACUUM` ถึงสำคัญใน Postgres**: MVCC สร้างเวอร์ชันแถวที่ล้าสมัย ("dead tuples") เมื่อแถวถูก update และ delete ซึ่งสะสมเป็น bloat และ `VACUUM`/`AUTOVACUUM` เป็นกลไกการ cleanup ที่เรียกคืนพื้นที่นี้และรักษาฐานข้อมูลให้แข็งแรง ดังนั้น MVCC และ VACUUM จึงเชื่อมโยงกันอย่างใกล้ชิด และการรู้ความเชื่อมโยงนี้สำคัญต่อการบำรุงรักษาและ performance ของฐานข้อมูล (การละเลย vacuum นำไปสู่ bloat และ performance ที่เสื่อมลง ซึ่งเป็นข้อกังวลเชิงปฏิบัติการจริง)

เนื่องจากพฤติกรรม concurrency ส่งผลพื้นฐานต่อวิธีที่ฐานข้อมูลทำงานภายใต้ภาระงาน และเนื่องจาก MVCC (โมเดล concurrency ของ Postgres) อธิบายทั้ง concurrency การอ่าน/เขียนที่ยอดเยี่ยมและความจำเป็นในการบำรุงรักษาด้วย VACUUM การเข้าใจ MVCC จึงเป็นความรู้ที่มีคุณค่าต่อการทำงานกับ PostgreSQL มันชี้แจงข้อได้เปรียบด้าน concurrency ของฐานข้อมูลและการบำรุงรักษาที่มันต้องการ สำคัญต่อทั้งการให้เหตุผลเกี่ยวกับ performance และการดำเนินงาน Postgres อย่างถูกต้อง และเป็นหัวข้อที่พบบ่อยซึ่งแสดงถึงความเข้าใจว่า Postgres จัดการการเข้าถึงแบบพร้อมกันอย่างไร