Piyé carane database transactions bisa ngana ing Django?

Question

Accepted Answer

A **database transaction** nglumpukake operasi akèh supaya padha **kabèh sukses utawa kabèh gagal babarengan** (atomicity) — nyegah update sing parsial lan ora konsisten. Django nyadiyakake `transaction.atomic` kanggo nutup operasi ing sawijining transaction, ngurangi integritas data kanggo operasi sing ana pirang-pirang tahap.

## Masalah sing bisa dirampungi 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!
```

Tanpa transaction, yen operasi kapindho gagal, operasi pisanan wis committed — ninggalake database ing keadaan sing rusak lan ora konsisten (dhuwit wis diambil nanging durung dikreditake).

## transaction.atomic — kabèh-utawa-ngisor

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

Ning jero `atomic()`, yen ana operasi sing ndadekake exception, Django **roll back** saben perubahan ing blok kasebut — dadi database ora bakal ditinggalake setengah-update. Yen sukses, kabèh owah-owahan commit babarengan.

## Nested atomic blocks (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` sing nested nganggo savepoints — blok jero bisa roll back kanthi mandiri tanpa mbatalake transaksi jaba sakabèhé.

## Rincian sing 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
```

## Apa sebabe penting

Database transactions kuwi penting banget kanggo **integritas data** kapan operasi ana hubungane karo akèh owah-owahan database sing kudu sukses utawa gagal minangka sawijining unit — lan ngerti babagan `transaction.atomic` iku ilmu penting kanggo nggawa aplikasi sing bener lan dipercaya.

Masalah inti sing bisa dirampungi transactions iku **partial failure**: tanpa atomicity, yen operasi sing ana pirang-pirang tahap gagal ing tengah-tengah (crash, exception, pelanggaran constraint), database ditinggalake ing keadaan ora konsisten — conto klasik transfer dhuwit (ambil saka siji rekening nanging ora dikredit menyang liyane) nunju carane iki merusak data lan bisa ana akibat serius. `transaction.atomic` menehi jaminan yen operasi iku **kabèh-utawa-ngisor** (roll back blok lengkap yen ana gagal), iki perlu kanggo operasi sing ngliwati akèh tulis — nggawa order karo item-iteme, transfer dana, nganyari record sing ana hubungane — kanggo jupuk database sing konsisten.

Ngerti carane nganggo atomic blocks (minangka context manager utawa decorator), nested transactions karo savepoints, lan rincian penting — nangkep exceptions *metu* saka blok, nganggo **`select_for_update()`** kanggo lock row lan nyegah race conditions ing update concurrent, lan mumutuha transactions ceneng supaya ora terus-terusan nahanani lock — iku ilmu praktis kanggo nggawa aplikasi sing kuat.

Konsistensi data iku syarat fundamental saka sistem sing dipercaya, lan transactions iku mekanisme sing ngurangi iku kanggo operasi database sing ana pirang-pirang tahap, nggawa iki topik penting sing mbedakake developer sing nulis kode bener, sing njaga integritas, saka sing aplikasine bisa diam-diam merusak data ing kahanane failur utawa akses concurrent — kepedulian sing asring ana ing aplikasi apa wae sing nangani owah-owahan data penting lan ana hubungane.