Hur fungerar databastransaktioner i Django?

Question

Accepted Answer

En **databastransaktion** grupperar flera operationer så att de antingen **lyckas eller misslyckas tillsammans** (atomicitet) — vilket förhindrar partiella, inkonsistenta uppdateringar. Django tillhandahåller `transaction.atomic` för att omsluta operationer i en transaktion och säkerställa dataintegritet för operationer med flera steg.

## Problemet som transaktioner löser

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

Utan en transaktion, om den andra operationen misslyckas, har den första redan genomförts — vilket lämnar databasen i ett bruten, inkonsistent tillstånd (pengar debiterade men inte krediterade).

## transaction.atomic — allt-eller-ingenting

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

Innanför `atomic()`, om någon operation slänger ett undantag, **återställer** Django alla ändringar i blocket — så databasen blir aldrig half-uppdaterad. Vid framgång genomförs alla ändringar tillsammans.

## Kapslade atomic-block (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
```

Kapslade `atomic`-block använder savepoints — det inre blocket kan återställas oberoende utan att avbryta hela den yttre transaktionen.

## Viktiga detaljer

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

## Varför det är viktigt

Databastransaktioner är väsentliga för **dataintegritet** när en operation involverar flera relaterade databasändringar som måste lyckas eller misslyckas som en enhet — och att förstå `transaction.atomic` är viktig kunskap för att bygga korrekta, tillförlitliga applikationer.

Kärnproblemet som transaktioner löser är **partiell misslyckande**: utan atomicitet, om en operation med flera steg misslyckas på mitten (en krasch, ett undantag, en begränsningsöverträdelse), lämnas databasen i ett inkonsistent tillstånd — det klassiska pengaröverföringsexemplet (debiterade från ett konto men inte krediterade till ett annat) illustrerar hur detta korrupterar data och kan få allvarliga konsekvenser. `transaction.atomic` ger garantin att operationer är **allt-eller-ingenting** (återställer hela blocket vid något misslyckande), vilket är nödvändigt för alla operationer som spänner flera skrivningar — skapa en order med dess radartiklar, överför pengar, uppdatera relaterade poster — för att upprätthålla en konsistent databas.

Att förstå hur man använder atomic-block (som en context manager eller dekoratör), kapslade transaktioner med savepoints, och viktiga detaljer — fånga undantag *utanför* blocket, använd **`select_for_update()`** för att låsa rader och förhindra race conditions i samtidiga uppdateringar, och håll transaktioner korta för att undvika att hålla lås — är praktisk kunskap för att bygga robusta applikationer.

Datakonsistens är ett grundläggande krav för tillförlitliga system, och transaktioner är mekanismen som säkerställer det för databaskoperationer med flera steg, vilket gör detta till ett viktigt ämne som skiljer utvecklare som skriver korrekt, integritetsbevarande kod från de vars applikationer kan tyst korruptera data under felvillkor eller samtidig åtkomst — en ofta relevant fråga i alla applikationer som hanterar viktiga, relaterade dataändringar.