Bagaimanakah transaksi pangkalan data berfungsi dalam Django?

Question

Accepted Answer

**Transaksi pangkalan data** mengumpulkan berbilang operasi supaya ia **semua berjaya atau semua gagal bersama** (atomicity) — mencegah kemas kini separa yang tidak konsisten. Django menyediakan `transaction.atomic` untuk membungkus operasi dalam transaksi, memastikan integriti data untuk operasi berbilang langkah.

## Masalah yang diselesaikan oleh transaksi

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

Tanpa transaksi, jika operasi kedua gagal, yang pertama sudah pun di-commit — meninggalkan pangkalan data dalam keadaan yang rosak dan tidak konsisten (wang didebit tetapi tidak dikreditkan).

## transaction.atomic — semua atau tiada langsung

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

Di dalam `atomic()`, jika mana-mana operasi membangkitkan exception, Django **me-rollback** setiap perubahan dalam blok — jadi pangkalan data tidak pernah dibiarkan separa dikemas kini. Apabila berjaya, semua perubahan di-commit bersama.

## Blok atomic bersarang (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
```

Blok `atomic` bersarang menggunakan savepoint — blok dalaman boleh me-rollback secara bebas tanpa membatalkan keseluruhan transaksi luar.

## Butiran penting

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

## Mengapa ia penting

Transaksi pangkalan data adalah penting untuk **integriti data** apabila operasi melibatkan berbilang perubahan pangkalan data yang berkaitan yang mesti berjaya atau gagal sebagai satu unit — dan memahami `transaction.atomic` ialah pengetahuan penting untuk membina aplikasi yang betul dan boleh dipercayai.

Masalah teras yang diselesaikan oleh transaksi ialah **kegagalan separa**: tanpa atomicity, jika operasi berbilang langkah gagal di pertengahan (kerosakan, exception, pelanggaran kekangan), pangkalan data dibiarkan dalam keadaan tidak konsisten — contoh pemindahan wang yang klasik (didebit daripada satu akaun tetapi tidak dikreditkan ke akaun lain) menggambarkan bagaimana ini merosakkan data dan boleh membawa akibat yang serius. `transaction.atomic` menyediakan jaminan bahawa operasi adalah **semua-atau-tiada** (me-rollback keseluruhan blok pada sebarang kegagalan), yang perlu untuk mana-mana operasi yang merangkumi berbilang penulisan — mencipta pesanan dengan item barisnya, memindahkan dana, mengemas kini rekod berkaitan — untuk mengekalkan pangkalan data yang konsisten.

Memahami cara menggunakan blok atomic (sebagai context manager atau decorator), transaksi bersarang dengan savepoint, dan butiran penting — menangkap exception *di luar* blok, menggunakan **`select_for_update()`** untuk mengunci baris dan mencegah race condition dalam kemas kini serentak, dan memastikan transaksi pendek untuk mengelakkan memegang kunci — ialah pengetahuan praktikal untuk membina aplikasi yang teguh.

Ketekalan data ialah keperluan asas sistem yang boleh dipercayai, dan transaksi ialah mekanisme yang memastikannya untuk operasi pangkalan data berbilang langkah, menjadikan ini topik penting yang membezakan pembangun yang menulis kod yang betul dan mengekalkan integriti daripada mereka yang aplikasinya boleh merosakkan data secara senyap di bawah keadaan kegagalan atau akses serentak — kebimbangan yang kerap relevan dalam mana-mana aplikasi yang mengendalikan perubahan data yang penting dan berkaitan.