Kako delujejo podatkovne transakcije v Djangu?

Question

Accepted Answer

A **database transaction** groups multiple operations so they either **all succeed or all fail together** (atomicity) — preventing partial, inconsistent updates. Django provides `transaction.atomic` to wrap operations in a transaction, ensuring data integrity for multi-step operations.

## Težava, ki jo rešujejo transakcije

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

Brez transakcije, če druga operacija ne uspe, je prva že potrjena — podatkovni sistem ostane v razbitem, nedoslednem stanju (denar je odbit, vendar ni dobrobit).

## transaction.atomic — vse ali nič

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

Znotraj `atomic()`, če katera koli operacija sprosi izjemo, Django **vrne nazaj** vsako spremembo v bloku — tako da podatkovni sistem nikoli ni pola posodobljen. V primeru uspeha se vse spremembe skupaj potrdijo.

## Vgnezdeni atomic bloki (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
```

Vgnezdeni `atomic` bloki uporabljajo savepoints — notranji blok se lahko vrne nazaj neodvisno brez prekida celotne zunanje transakcije.

## Pomembne podrobnosti

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

## Zakaj je to pomembno

Podatkovne transakcije so bistvene za **integralno podatkov** kadar koli operacija vključuje več povezanih sprememb podatkovnega sistema, ki morajo uspeti ali propasti kot celota — in razumevanje `transaction.atomic` je pomembno znanje za gradnjo pravilnih in zanesljivih aplikacij.

Težava, ki jo rešujejo transakcije, je **nepopolna napaka**: brez atomičnosti, če večstopenjska operacija ne uspe na polovici (sesutje, izjema, kršitev omejitve), je podatkovni sistem v nedoslednem stanju — klasičen primer prenosa denarja (debit z enega računa, vendar ne kredita na drugega) ponazarja, kako to pokvari podatke in ima lahko resne posledice. `transaction.atomic` zagotavlja, da so operacije **vse ali nič** (vrnitev celotnega bloka ob katerikoli napaki), kar je potrebno za vsako operacijo, ki se razprostira na več zapisov — ustvarjanje naročila s svojimi postavkami, prenos sredstev, posodabljanje povezanih zapisov — za ohranitev doslednega podatkovnega sistema.

Razumevanje uporabe atomic blokov (kot kontekstni manager ali dekorator), vgnezdenih transakcij s savepoints in pomembnih podrobnosti — lovljenje izjem *zunaj* bloka, uporaba **`select_for_update()`** za zaklepanje vrstic in preprečevanje race conditions v sočasnih posodobitvah ter kratko držanje transakcij za izogibanje držanju zaključkov — je praktično znanje za gradnjo robustnih aplikacij.

Doslednost podatkov je temeljni zahtevek zanesljivih sistemov, transakcije pa so mehanizem, ki ga zagotavlja za večstopenjske operacije podatkovnega sistema, kar to temo naredi pomembno in razlikuje razvojnike, ki pišejo pravilno, integralno-ohranjajočo kodo, od tistih, katerih aplikacije lahko nemo pokvarijo podatke v pogojih napake ali sočasnega dostopa — pogosto relevantna skrb v kateri koli aplikaciji, ki obdeluje pomembne, povezane spremembe podatkov.