Kif jaħdmu l-transaksjonijiet tad-database f'Django?

Question

Accepted Answer

A **transaksjoni tad-database** tiġbor operazzjonijiet multipli sabiex huma kollha jirnexxu jew jiffallew flimkien **(atomicity)** — u tippreveni aġġornamenti parzjali u inkonsistenti. Django tipprovdi `transaction.atomic` biex issaħħaħ operazzjonijiet f'transaksjoni, u tgħarантизz l-integrità tad-data għal operazzjonijiet multi-pass.

## Il-problema li t-transaksjonijiet isolvu

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

Bedda l-transaksjoni, jekk it-tieni operazzjoni tiffail, l-ewwel waħda diġà ikkummittiet — u ħalli d-database f'stat miksur u inkonsistenti (flus mitbugħa iżda mhux kreditati).

## transaction.atomic — kullu jew xejn

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

Gewwa `atomic()`, jekk kwalunkwe operazzjoni terfa' eċċezzjoni, Django **irrotlabba** kull bidla fil-blokk — u d-database qatt ma titħalla nofs aġġornata. Dwar is-suċċess, il-bidlat kollha jikkommittaw flimkien.

## Blokks atomic nested (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
```

Blokks `atomic` nested jużaw savepoints — il-blokk ta' ġewwa jista' jirrotlabba indipendentement bla ma jaħrab it-transaksjoni ta' barra kollha.

## Dettalji importanti

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

## Għaliex importa

It-transaksjonijiet tad-database huma essenzjali għall-**integrità tad-data** kull meta operazzjoni tinvolvi bidlat multipli ta' database relatati li għandhom jirnexxu jew jiffallew bħala unità — u l-għarfien ta' `transaction.atomic` hu għarfien importanti għal bini ta' applikazzjonijiet korretti u affidabbli.

Il-problema ewlenija li t-transaksjonijiet isolvu hu **falliment parzjali**: bla atomicity, jekk operazzjoni multi-pass tiffail mezzana (crash, eċċezzjoni, ksura ta' constraint), id-database titħalla f'stat inkonsistenti — l-eżempju klassiku ta' trasferiment ta' flus (mitbugħa minn kont iżda mhux kreditati għal ieħor) juri kif dan jikkorrupizza d-data u jista' jkollha konsegwenzi serjużi. `transaction.atomic` tipprovdi l-garantija li l-operazzjonijiet huma **kullu jew xejn** (u jirrotlabbaw il-blokk kollu dwar kwalunkwe falliment), li hu neċessarju għal kwalunkwe operazzjoni li temm writes multipli — binkrea ta' ordni mal-items tagħha, trasferiment ta' flus, aġġornament ta' rekords relatati — biex tintuża d-database konsistenti.

L-għarfien ta' kif tuża atomic blocks (bħala context manager jew decorator), transaksjonijiet nested bi savepoints, u d-dettalji importanti — laqgħa eccezioni *barra* il-blokk, użu ta' **`select_for_update()`** biex tuqfal rigs u tippreveni race conditions f'aġġornamenti konkorrenti, u żomm transaksjonijiet qosra biex tevita tħabbita ta' locks — hu għarfien pratiku għal bini ta' applikazzjonijiet robusti.

L-konsistenza tad-data hu rekwiżitu fundamentali ta' sistemi affidabbli, u t-transaksjonijiet huma l-mekkaniżmu li jiggarantixxi dan għal operazzjonijiet database multi-pass, u jagħmlu dan suġġett importanti li jiddistingwi l-iżviluppaturi li jiktbu kod korrett u li jippreservaw l-integrità minn dawk l-applikazzjonijiet tagħhom jistgħu faċilment jikkorruppiżżaw d-data taħt kundizzjonijiet ta' falliment jew aċċess konkorrenti — konsiderazzjoni frekwentement relevanti f'kwalunkwe applikazzjoni li timmaniġġja bidlat ta' data importanti u relatati.