transaction ฐานข้อมูลใน Django ทำงานอย่างไร?

Question

Accepted Answer

**transaction ฐานข้อมูล** จัดกลุ่มการทำงานหลายอย่างเข้าด้วยกันเพื่อให้มัน**สำเร็จทั้งหมดหรือล้มเหลวทั้งหมดพร้อมกัน** (atomicity) — ป้องกันการอัปเดตบางส่วนที่ไม่สอดคล้องกัน Django มี `transaction.atomic` เพื่อห่อหุ้มการทำงานไว้ใน transaction รับประกันความถูกต้องของข้อมูลสำหรับการทำงานหลายขั้นตอน

## ปัญหาที่ transaction แก้

```python
# ❌ WITHOUT a transaction — partial failure leaves inconsistent data
def transfer_money(from_account, to_account, amount):
    from_account.balance -= amount
    from_account.save()                  # ✓ succeeds
    # ...if the server crashes HERE, money vanished from one account...
    to_account.balance += amount
    to_account.save()                    # ✗ never runs → money LOST!
```

หากไม่มี transaction หากการทำงานที่สองล้มเหลว การทำงานแรกได้ commit ไปแล้ว — ทำให้ฐานข้อมูลอยู่ในสถานะที่เสียหายและไม่สอดคล้องกัน (หักเงินแต่ไม่ได้เพิ่มเข้า)

## transaction.atomic — ทั้งหมดหรือไม่เลย

```python
from django.db import transaction

# as a context manager
def transfer_money(from_account, to_account, amount):
    with transaction.atomic():           # everything inside is ONE transaction
        from_account.balance -= amount
        from_account.save()
        to_account.balance += amount
        to_account.save()
    # if ANY operation raises an exception, the WHOLE block is ROLLED BACK
    # → either both saves happen, or neither does (atomicity)
```

```python
# or as a decorator on a whole function/view
@transaction.atomic
def create_order(request):
    order = Order.objects.create(...)
    for item in items:
        OrderItem.objects.create(order=order, ...)
    # all-or-nothing: a failure anywhere rolls back the entire order creation
```

ภายใน `atomic()` หากการทำงานใด raise exception Django จะ **roll back** ทุกการเปลี่ยนแปลงใน block — ดังนั้นฐานข้อมูลจึงไม่เคยถูกทิ้งไว้แบบอัปเดตครึ่ง ๆ กลาง ๆ เมื่อสำเร็จ การเปลี่ยนแปลงทั้งหมดจะ commit พร้อมกัน

## atomic block แบบซ้อน (savepoint)

```python
with transaction.atomic():               # outer transaction
    do_something()
    try:
        with transaction.atomic():       # inner = a SAVEPOINT
            risky_operation()
    except Exception:
        pass                              # inner rolls back to the savepoint; outer continues
```

`atomic` block แบบซ้อนใช้ savepoint — block ภายในสามารถ roll back ได้อย่างอิสระโดยไม่ยกเลิก transaction ภายนอกทั้งหมด

## รายละเอียดสำคัญ

```text
✓ Catch exceptions OUTSIDE the atomic block (catching inside can break rollback handling)
✓ select_for_update() locks rows within a transaction (prevent race conditions on updates)
    with transaction.atomic():
        account = Account.objects.select_for_update().get(pk=id)  # row locked until commit
✓ ATOMIC_REQUESTS setting wraps EVERY request in a transaction (per-database)
✓ Keep transactions SHORT — long transactions hold locks, hurting concurrency
```

## ทำไมจึงสำคัญ

transaction ฐานข้อมูลจำเป็นต่อ **ความถูกต้องของข้อมูล** เมื่อใดก็ตามที่การทำงานเกี่ยวข้องกับการเปลี่ยนแปลงฐานข้อมูลที่สัมพันธ์กันหลายอย่างซึ่งต้องสำเร็จหรือล้มเหลวเป็นหน่วยเดียว — และการเข้าใจ `transaction.atomic` เป็นความรู้สำคัญสำหรับการสร้างแอปพลิเคชันที่ถูกต้องและเชื่อถือได้

ปัญหาหลักที่ transaction แก้คือ **ความล้มเหลวบางส่วน**: หากไม่มี atomicity หากการทำงานหลายขั้นตอนล้มเหลวกลางคัน (การ crash, exception, การละเมิด constraint) ฐานข้อมูลจะถูกทิ้งไว้ในสถานะที่ไม่สอดคล้องกัน — ตัวอย่างการโอนเงินคลาสสิก (หักจากบัญชีหนึ่งแต่ไม่ได้เพิ่มเข้าอีกบัญชี) แสดงให้เห็นว่าสิ่งนี้ทำให้ข้อมูลเสียหายและอาจมีผลร้ายแรง `transaction.atomic` ให้การรับประกันว่าการทำงานเป็นแบบ **ทั้งหมดหรือไม่เลย** (roll back ทั้ง block เมื่อล้มเหลว) ซึ่งจำเป็นสำหรับการทำงานใด ๆ ที่ครอบคลุมการ write หลายครั้ง — การสร้าง order พร้อม line item, การโอนเงิน, การอัปเดตระเบียนที่สัมพันธ์กัน — เพื่อรักษาฐานข้อมูลให้สอดคล้อง

การเข้าใจวิธีใช้ atomic block (เป็น context manager หรือ decorator), transaction แบบซ้อนด้วย savepoint และรายละเอียดสำคัญ — การ catch exception *ภายนอก* block, การใช้ **`select_for_update()`** เพื่อ lock แถวและป้องกัน race condition ในการอัปเดตพร้อมกัน และการรักษา transaction ให้สั้นเพื่อหลีกเลี่ยงการถือ lock — เป็นความรู้เชิงปฏิบัติสำหรับการสร้างแอปพลิเคชันที่ทนทาน

ความสอดคล้องของข้อมูลเป็นข้อกำหนดพื้นฐานของระบบที่เชื่อถือได้ และ transaction คือกลไกที่รับประกันมันสำหรับการทำงานฐานข้อมูลหลายขั้นตอน ทำให้มันเป็นหัวข้อสำคัญที่แยกแยะนักพัฒนาที่เขียนโค้ดที่ถูกต้องและรักษาความถูกต้อง ออกจากผู้ที่แอปพลิเคชันสามารถทำให้ข้อมูลเสียหายอย่างเงียบ ๆ ภายใต้สภาวะล้มเหลวหรือการเข้าถึงพร้อมกัน — เป็นข้อกังวลที่เกี่ยวข้องบ่อยในแอปพลิเคชันใด ๆ ที่จัดการการเปลี่ยนแปลงข้อมูลที่สำคัญและสัมพันธ์กัน