Hoe werken databasetransacties in Django?

Question

Accepted Answer

Een **databasetransactie** groepeert meerdere operaties zodat ze **allemaal slagen of allemaal mislukken samen** (atomiciteit) — waardoor gedeeltelijke, inconsistente updates worden voorkomen. Django biedt `transaction.atomic` om operaties in een transactie in te pakken, waardoor gegevensintegriteit voor multi-stap operaties wordt gewaarborgd.

## Het probleem dat transacties oplossen

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

Zonder een transactie, als de tweede operatie mislukt, is de eerste al toegewezen — waardoor de database in een gebroken, inconsistente staat wordt achtergelaten (geld afgeschreven maar niet bijgeschreven).

## transaction.atomic — alles-of-niets

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

Binnen `atomic()`, als een operatie een uitzondering gooit, **rolt** Django elke wijziging in het blok **terug** — dus de database wordt nooit half bijgewerkt. Bij succes worden alle wijzigingen samen toegewezen.

## Geneste atomic blokken (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
```

Geneste `atomic` blokken gebruiken savepoints — het binnenste blok kan onafhankelijk terugdraaien zonder de hele buitentransactie af te breken.

## Belangrijke details

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

## Waarom het belangrijk is

Databasetransacties zijn essentieel voor **gegevensintegriteit** wanneer een operatie meerdere gerelateerde databasewijzigingen omvat die als eenheid moeten slagen of mislukken — en het begrijpen van `transaction.atomic` is belangrijke kennis voor het bouwen van correcte, betrouwbare applicaties.

Het kernprobleem dat transacties oplossen is **gedeeltelijk falen**: zonder atomiciteit, als een multi-stap operatie halfweg mislukt (een crash, een uitzondering, een constraint-schending), wordt de database in een inconsistente staat achtergelaten — het klassieke geldoverdrachtvoorbeeld (afgeschreven van een rekening maar niet bijgeschreven op een ander) illustreert hoe dit gegevens beschadigt en ernstige gevolgen kan hebben. `transaction.atomic` biedt de garantie dat operaties **alles-of-niets** zijn (het hele blok terugdraaien bij falen), wat nodig is voor elke operatie die meerdere schrijfbewerkingen omvat — het maken van een bestelling met regelitems, het overboeken van geldmiddelen, het bijwerken van gerelateerde records — om een consistente database te behouden.

Begrijpen hoe je atomic blokken gebruikt (als context manager of decorator), geneste transacties met savepoints, en de belangrijke details — exceptions **buiten** het blok opvangen, **`select_for_update()`** gebruiken om rijen te vergrendelen en race conditions in gelijktijdige updates te voorkomen, en transacties kort houden om te voorkomen dat locks worden vastgehouden — is praktische kennis voor het bouwen van robuuste applicaties.

Gegevensconsistentie is een fundamentele vereiste van betrouwbare systemen, en transacties zijn het mechanisme dat het voor multi-stap databaseoperaties waarborgt, waardoor dit een belangrijk onderwerp is dat ontwikkelaars onderscheidt die correcte, integriteitsbehoudende code schrijven van degenen wiens applicaties onder faalomstandigheden of gelijktijdige toegang stiekem gegevens kunnen beschadigen — een regelmatig relevant probleem in elke applicatie die belangrijke, gerelateerde gegevenswijzigingen verwerkt.