Kaip duomenų bazės transakcijos veikia Django?

Question

Accepted Answer

**Duomenų bazės transakcija** grupuoja kelis veiksmus taip, kad jie arba **visi sėkmingai įvykdomi, arba visi nepavyksta kartu** (atomarumas) — tai užkerta kelią daliniam, nesuderintiems duomenų atnaujinimams. Django suteikia `transaction.atomic` operacijoms apvynioti transakcijoje, užtikrinant duomenų integrumą daugiažingsniams veiksmams.

## Problema, kurią sprendžia transakcijos

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

Be transakcijos, jei antrasis veiksmas nepavyksta, pirmasis jau yra įdiegtas — duomenų bazę paliekant sugadintoje, nesuderintoje būsenoje (pinigai nusiųsti iš vienos sąskaitos, bet nepriimti kitoje).

## transaction.atomic — viskas arba nieko

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

Šaltinyje `atomic()`, jei bet kuris veiksmas iškelia išimtį, Django **anuliuoja** visus bloko pakeitimus — taigi duomenų bazė niekada nėra paliekama pusiau atnaujinta. Sėkmės atveju visi pakeitimai įdiegiami kartu.

## Įdėti atomic blokai (išsaugojimo taškai)

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

Įdėti `atomic` blokai naudoja išsaugojimo taškus — vidinis blokas gali nepriklausomai anuliuoti be visos išorinės transakcijos nutraukimo.

## Svarbūs detalės

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

## Kodėl tai svarbu

Duomenų bazės transakcijos yra būtinos **duomenų integralumui** kai operacija apima kelis susijusius duomenų bazės pakeitimus, kurie turi sėkmingai įvykti arba nepavykti kaip vienetas — ir `transaction.atomic` supratimas yra svarbi žinojimo sritis kuriant teisingas, patikimas aplikacijas.

Pagrindinis šią problemą sprendžiantis faktorius — **dalinis gedimas**: be atomarumo, jei daugiažingsnė operacija nepavyksta viduryje (katastrofa, išimtis, apribojimo pažeidimas), duomenų bazė paliekama nesuderintoje būsenoje — klasikinis pinigų perlaidumo pavyzdys (nubraižyta iš vienos sąskaitos, bet nepersiųsta į kitą) parodo, kaip tai iškraipo duomenis ir gali turėti rimtų padarinių. `transaction.atomic` suteikia garantiją, kad operacijos yra **viskas arba nieko** (anuliuojant visą bloką bet kurio gedimo atveju), kuris yra būtinas bet kuriai operacijai apimančiai kelis įrašus — užsakymo su jo eilutėmis kūrimas, lėšų perlaidimas, susijusių įrašų atnaujinimas — duomenų bazės nuoseklumui išlaikyti.

Supratimas, kaip naudoti atomic blokus (kaip konteksto vadybininką ar dekoratorių), įdėtas transakcijas su išsaugojimo taškais ir svarbius detalius — išimčių pagavimą *už* bloko, **`select_for_update()`** naudojimą eilutėms užrakinti ir lenktynių sąlygų išvengimą lygiagrečiuose atnaujinimuose, ir trumpų transakcijų palaikymą, kad būtų išvengta spynų laikymo — yra praktiškas žinojimas tvirtiems veiksmams kurti.

Duomenų nuoseklumas yra pagrindinė patikimų sistemų svarba, ir transakcijos yra mechanizmas, kuris to gali užtikrinti daugiažingsnėms duomenų bazės operacijoms, todėl tai yra svarbi tema, išskirtas kūrėjams, kurie rašo teisingą, integralumą išsaugojantį kodą iš tų, kurių aplikacijos gali tyliai iškraipyti duomenis gedimo sąlygomis arba lygiagrečios prieigos metu — dažnai aktuali problema bet kurioje aplikacijoje, atliekančioje svarbius, susijusius duomenų pakeitimus.