Si funksionojnë transaksionet e bazës de të dhënave në Django?

Question

Accepted Answer

Një **transaksion i bazës de të dhënave** grupon operacione të shumta në mënyrë që të **gjitha të kenë sukses ose të dështojnë së bashku** (atomiciteti) — duke parandaluar përditësimet e pjesshme dhe të paqëndrueshme. Django ofron `transaction.atomic` për të mbështjellë operacione në një transaksion, duke siguruar integritetin e të dhënave për operacione me shumë hapa.

## Problemi që e zgjidhin transaksionet

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

Pa transaksion, nëse operacioni i dytë dështon, i pari është tashmë dërguar — duke lënë bazën e të dhënave në një gjendje të thyer dhe të paqëndrueshme (paratë u debituan por nuk u kredituaan).

## transaction.atomic — të gjitha ose asgjë

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

Brenda `atomic()`, nëse ndonjë operacion ngre një përjashtim, Django **shfuqizon** çdo ndryshim në bllok — kështu që baza e të dhënave nuk është kurrë e lënë gjysmë-përditësuar. Në sukses, të gjitha ndryshimet zotohen së bashku.

## Blloqet atomic të mbivendosur (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
```

Blloqet e mbivendosur `atomic` përdorin savepoints — bloku i brendshëm mund të shfuqizet në mënyrë të pavarur pa e prishur të gjithë transaksionin e jashtëm.

## Detaje të rëndësishme

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

## Përse kjo ka rëndësi

Transaksionet e bazës de të dhënave janë thelbësor për **integritetin e të dhënave** sa herë që një operacion përfshin ndryshime të shumta dhe të lidhura të bazës de të dhënash që duhet të kenë sukses ose të dështojnë si një njësi — dhe të kuptosh `transaction.atomic` është njohuri e rëndësishme për ndërtimin e aplikacioneve të sakta dhe të besueshme.

Problemi themelor që e zgjidhin transaksionet është **dështimi i pjesshëm**: pa atomiciteti, nëse një operacion me shumë hapa dështon në mes (një rrëzim, një përjashtim, një shkelje e kufizimit), baza e të dhënave lihet në një gjendje të paqëndrueshme — shembulli klasik i transferimit të parave (i debituar nga një llogari por nuk u kredituua në tjetrën) ilustron se si kjo korruptojnë të dhënat dhe mund të ketë pasoja serioze. `transaction.atomic` ofron garantinë se operacione janë **të gjitha ose asgjë** (duke shfuqizuar të gjithë bllokun në çdo dështim), e cila është e nevojshme për ndonjë operacion që shtrihet në shkrime të shumta — krijimi i një porosie me artikujt e saj linjare, transferimi i fondeve, përditësimi i regjistrimeve të lidhura — për të ruajtur një bazë të dhënash të qëndrueshme.

Të kuptosh se si të përdorësh blloqet atomic (si një menaxher konteksti ose dekorator), transaksionet e mbivendosur me savepoints, dhe detajet e rëndësishme — kapja i përjashtimet *jashtë* bllokut, përdorimi i **`select_for_update()`** për të bllokuar rreshtat dhe për të parandaluar kushtet e garës në përditësimet e njëkohshme, dhe mbajtja e transaksioneve të shkurtra për të evituar mbajtjen e blloqeve — është njohuri praktike për ndërtimin e aplikacioneve të forta.

Konsistenca e të dhënave është një kërkesë themelore e sistemeve të besueshme, dhe transaksionet janë mekanizmi që e siguron atë për operacione të bazës de të dhënash me shumë hapa, duke e bërë këtë një temë të rëndësishme që dalloi zhvilluesit të cilët shkruajnë kod të saktë dhe me ruajtje të integritetit nga ata aplikacionet të cilëve mund t'u korruptojnë të dhënat në heshtje nën kushte dështimi ose qasje të njëkohshme — një shqetësim shpesh i lidhur në ndonjë aplikacion që merret me ndryshime të rëndësishme dhe të lidhura të të dhënave.