Hogyan működnek az adatbázis-tranzakciók a Django-ban?

Question

Accepted Answer

Az **adatbázis-tranzakció** több műveletet csoportosít úgy, hogy azok vagy **mind sikeresek, vagy mind sikertelennek tekintendők egyszerre** (atomicitás) — megelőzve a részleges, inkonzisztens frissítéseket. A Django a `transaction.atomic` függvényt biztosítja a műveletek tranzakcióba csomagolásához, biztosítva az adatok integritását többlépéses műveleteknél.

## A probléma, amit a tranzakciók megoldanak

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

Tranzakció nélkül, ha a második művelet meghiúsul, az első már lezárult — az adatbázist egy sérült, inkonzisztens állapotban hagyva (pénz terhelve, de nem jóváírva).

## transaction.atomic — „vagy minden vagy semmi"

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

Az `atomic()` belsejében, ha bármilyen művelet kivételt vét fel, a Django **visszavon** minden változtatást a blokkban — így az adatbázis soha nem marad félig frissítve. Sikeres futáson az összes módosítás egyszerre lezárul.

## Beágyazott atomic blokkok (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
```

A beágyazott `atomic` blokkok savepoint-okat használnak — a belső blokk egymástól függetlenül visszaállítható anélkül, hogy az egész külső tranzakciót megszakítaná.

## Fontos részletek

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

## Miért számít

Az adatbázis-tranzakciók elengedhetetlenek az **adatok integritásához**, amikor egy művelet több kapcsolódó adatbázis-módosítást foglal magában, amelyek egy egységként kell, hogy sikereseiek vagy sikertelenek legyenek — és a `transaction.atomic` megértése fontos tudás az olyan helyes, megbízható alkalmazások építéséhez.

A probléma, amit a tranzakciók megoldanak, a **részleges meghibásodás**: atomicitás nélkül, ha egy többlépéses művelet félúton meghiúsul (összeomlás, kivétel, korlátozás megsértése), az adatbázis egy inkonzisztens állapotban marad — a klasszikus pénzátutalás-példa (az egyik számláról terhelve, de a másikra nem jóváírva) szemlélteti, hogyan sérülnek meg az adatok és milyen komoly következményei lehetnek. A `transaction.atomic` azt garantálja, hogy a műveletek **vagy mind vagy semmi** alapon működnek (a teljes blokk visszavonása bármilyen meghibásodás esetén), ami szükséges bármilyen több írást felölelő műveletnél — rendelés létrehozása a sorelemeivel, pénzátirányítás, kapcsolódó rekordok frissítése — az adatbázis konzisztenciájának megőrzéséhez.

A megértése, hogyan kell atomi blokkokat használni (kontextuskezelőként vagy dekorátorként), a beágyazott tranzakciók savepoint-okkal történő kezelése, és a fontos részletek — a kivételek *a blokkon kívül* történő megfogása, a **`select_for_update()`** használata sorok zárolásához és a versengő frissítésekben a feltételek megelőzéséhez, valamint a tranzakciók rövid megőrzése a zárolások tartásának elkerüléséhez — gyakorlati tudás a robusztus alkalmazások építéséhez.

Az adatok konzisztenciája a megbízható rendszerek alapvető követelménye, és a tranzakciók azok a mechanizmusok, amelyek ezt biztosítják a többlépéses adatbázis-műveletek számára, ami ezt egy fontos témává teszi, amely megkülönbözteti azokat a fejlesztőket, akik helyes, integritást megőrző kódot írnak, azoktól, akik alkalmazásai csendesen sérülhetnek meg meghibásodás vagy versengő hozzáférés körülményei között — egy gyakran releváns probléma bármely alkalmazásban, amely fontos, kapcsolódó adatváltoztatásokat kezel.