Cum funcționează tranzacțiile de baze de date în Django?

Question

Accepted Answer

O **tranzacție de bază de date** grupează mai multe operații astfel încât să **reușească toate sau să eșueze toate împreună** (atomicitate) — prevenind actualizările parțiale și inconsistente. Django oferă `transaction.atomic` pentru a încadra operațiile într-o tranzacție, asigurând integritatea datelor pentru operații cu mai mulți pași.

## Problema pe care o rezolvă tranzacțiile

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

Fără o tranzacție, dacă a doua operație eșuează, prima s-a comis deja — lăsând baza de date într-o stare ruptă, inconsistentă (bani debitați dar nu creditați).

## transaction.atomic — totul sau nimic

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

În interiorul `atomic()`, dacă orice operație ridică o excepție, Django **revine** la fiecare modificare din bloc — deci baza de date nu este niciodată lăsată pe jumătate actualizată. La succes, toate modificările se comit împreună.

## Blocuri atomic imbricate (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
```

Bloacurile `atomic` imbricate utilizează savepoints — blocul interior se poate reveni independent fără a abandona întreaga tranzacție exterioară.

## Detalii importante

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

## De ce contează

Tranzacțiile de baze de date sunt esențiale pentru **integritatea datelor** ori de câte ori o operație implică mai multe modificări corelate ale bazei de date care trebuie să reușească sau să eșueze ca unitate — și înțelegerea `transaction.atomic` este cunoștință importantă pentru construirea aplicațiilor corecte și fiabile.

Problema de bază pe care o rezolvă tranzacțiile este **eșecul parțial**: fără atomicitate, dacă o operație cu mai mulți pași eșuează la jumătate (o blocare, o excepție, o încălcare a constrângerii), baza de date este lăsată într-o stare inconsistentă — exemplul clasic de transfer de bani (debitat dintr-un cont dar nu creditat pe altul) ilustrează cum aceasta coruptează datele și poate avea consecințe grave. `transaction.atomic` oferă garanția că operațiile sunt **totul sau nimic** (revenind la întregul bloc la orice eșec), ceea ce este necesar pentru orice operație care se întinde pe mai multe scrieri — crearea unei comenzi cu articolele sale, transferul de fonduri, actualizarea înregistrărilor corelate — pentru a menține o bază de date consistentă.

Înțelegerea cum se folosesc blocurile atomice (ca context manager sau decorator), tranzacțiile imbricate cu savepoints, și detaliile importante — capturarea excepțiilor *în afara* blocului, folosirea **`select_for_update()`** pentru a bloca rândurile și a preveni condiții de cursă în actualizările concurente, și păstrarea tranzacțiilor scurte pentru a evita reținerea blocajelor — este cunoștință practică pentru construirea aplicațiilor robuste.

Consistența datelor este o cerință fundamentală a sistemelor fiabile, și tranzacțiile sunt mecanismul care o asigură pentru operații de baze de date cu mai mulți pași, făcând aceasta un subiect important care distinge dezvoltatorii care scriu cod corect, care preservează integritatea, de cei ale căror aplicații pot corupta în tăcere datele în condiții de eșec sau acces concurent — o preocupare frecvent relevantă în orice aplicație care gestionează modificări de date importante și corelate.