Bagaimana cara kerja transaksi database di Django?

Question

Accepted Answer

Sebuah **transaksi database** mengelompokkan beberapa operasi sehingga semuanya **berhasil atau semuanya gagal bersama-sama** (atomicity) — mencegah pembaruan parsial dan tidak konsisten. Django menyediakan `transaction.atomic` untuk membungkus operasi dalam sebuah transaksi, memastikan integritas data untuk operasi multi-langkah.

## Masalah yang transaksi selesaikan

```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 commit — meninggalkan database dalam keadaan rusak dan tidak konsisten (uang sudah didebit tetapi belum dikreditkan).

## transaction.atomic — semua-atau-tidak-sama-sekali

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

Dalam `atomic()`, jika ada operasi yang memicu exception, Django **melakukan rollback** setiap perubahan dalam blok tersebut — sehingga database tidak pernah tertinggal setengah-diperbarui. Saat berhasil, semua perubahan commit bersama-sama.

## Blok atomic bertingkat (savepoints)

```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` bertingkat menggunakan savepoints — blok dalam dapat melakukan rollback secara independen tanpa membatalkan seluruh transaksi luar.

## Detail 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 ini penting

Transaksi database sangat penting untuk **integritas data** kapan pun operasi melibatkan beberapa perubahan database terkait yang harus berhasil atau gagal sebagai satu unit — dan memahami `transaction.atomic` adalah pengetahuan penting untuk membangun aplikasi yang benar dan dapat diandalkan.

Masalah inti yang transaksi selesaikan adalah **kegagalan parsial**: tanpa atomicity, jika operasi multi-langkah gagal di tengah jalan (crash, exception, pelanggaran constraint), database tertinggal dalam keadaan tidak konsisten — contoh klasik transfer uang (didebit dari satu rekening tetapi tidak dikreditkan ke rekening lain) mengilustrasikan bagaimana hal ini merusak data dan dapat memiliki konsekuensi serius. `transaction.atomic` memberikan jaminan bahwa operasi adalah **semua-atau-tidak-sama-sekali** (melakukan rollback seluruh blok pada kegagalan apa pun), yang diperlukan untuk operasi apa pun yang mencakup beberapa write — membuat order dengan line item-nya, mentransfer dana, memperbarui record terkait — untuk mempertahankan database yang konsisten.

Memahami cara menggunakan atomic block (sebagai context manager atau decorator), transaksi bertingkat dengan savepoints, dan detail penting — menangkap exception *di luar* blok, menggunakan **`select_for_update()`** untuk mengunci row dan mencegah race condition dalam pembaruan concurrent, dan menjaga transaksi tetap singkat untuk menghindari pemegangan lock — adalah pengetahuan praktis untuk membangun aplikasi yang robust.

Konsistensi data adalah persyaratan fundamental dari sistem yang dapat diandalkan, dan transaksi adalah mekanisme yang memastikannya untuk operasi database multi-langkah, menjadikan ini topik penting yang membedakan developer yang menulis kode yang benar dan menjaga integritas dari mereka yang aplikasinya dapat mengacaukan data secara diam-diam dalam kondisi kegagalan atau akses concurrent — kekhawatiran yang sering relevan di aplikasi apa pun yang menangani perubahan data penting dan terkait.