Django లో డేటాబేస్ ట్రాన్‍జ్యాక్షన్‍లు ఎలా పని చేస్తాయి?

Question

Accepted Answer

ఒక **డేటాబేస్ ట్రాన్‍జ్యాక్షన్** బహుళ ఆపరేషన్‍లను సమూహీకరిస్తుంది తద్వారా అవన్నీ **కలిసి విజయవంతమవుతాయి లేదా కలిసి విఫలమవుతాయి** (అటామిసిటీ) — పాక్షిక, అసంగত అప్‍డేట్‍లను నిరోధిస్తుంది. Django `transaction.atomic` ను అందించి ఆపరేషన్‍లను ట్రాన్‍జ్యాక్షన్‌లో చుట్టడానికి, మల్టీ-స్టెప్ ఆపరేషన్‍ల కోసం డేటా సమగ్రతను నిర్ధారిస్తుంది.

## ట్రాన్‍జ్యాక్షన్‍లు సమాధానం ఇచ్చే సమస్య

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

ట్రాన్‍జ్యాక్షన్ లేకుండా, రెండవ ఆపరేషన్ విఫలమైతే, మొదటిది ఇప్పటికే కమిట్ చేయబడింది — డేటాబేస్‌ను విచ్ఛిన్న, అసంగత స్థితిలో వదిలివేస్తుంది (డబ్బు డెబిట్ చేయబడింది కానీ క్రెడిట్ చేయబడలేదు).

## transaction.atomic — ఆల్-ఆర్-నదింగ్

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

`atomic()` లోపల, ఏదైనా ఆపరేషన్ అనుమతి విసిరితే, Django బ్లాక్‌లోని ప్రతిটి మార్పును **రోల్‌బ్యాక్** చేస్తుంది — కాబట్టి డేటాబేస్ ఎప్పుడూ సగం-అప్‍డేట్ చేయబడదు. విజయంపై, సమస్త మార్పులు కలిసి కమిట్ చేయబడతాయి.

## నెస్టెడ్ అటామిక్ బ్లాక్‍లు (సేవ్‌పాయింట్‍లు)

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

నెస్టెడ్ `atomic` బ్లాక్‍లు సేవ్‌పాయింట్‍లను ఉపయోగిస్తాయి — అంతర్గత బ్లాక్ పూర్తి బాహ్య ట్రాన్‍జ్యాక్షన్‌ను విస్మరించకుండా స్వతంత్రంగా రోల్‌బ్యాక్ చేయవచ్చు.

## ముఖ్యమైన వివరాలు

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

## ఇది ఎందుకు ముఖ్యమైనది

డేటాబేస్ ట్రాన్‍జ్యాక్షన్‍లు **డేటా సమగ్రత** కోసం అవసరమైనవి ఎప్పుడైనా ఒక ఆపరేషన్ బహుళ సంబంధిత డేటాబేస్ మార్పులను కలిగి ఉండటానికి ఎక్కువ లేదా యూనిట్‌గా విఫలమవుతాయి — మరియు `transaction.atomic` ను అర్థం చేసుకోవడం సరైన, నమ్మదగిన అనువర్తనాలను నిర్మించడానికి ముఖ్య జ్ఞానం.

ట్రాన్‍జ్యాక్షన్‍లు సమాధానం ఇచ్చే ప్రధాన సమస్య **పాక్షిక విఫలత**: అటామిసిటీ లేకుండా, ఒక మల్టీ-స్టెప్ ఆపరేషన్ మధ్యలో విఫలమైతే (క్రాష్, అనుమతి, నిషేధం ఉల్లంఘన), డేటాబేస్ అసంగత స్థితిలో ఉంటుంది — క్లాసిక్ డబ్బు-బదిలీ ఉదాహరణ (ఒక ఖాతా నుండి డెబిట్ చేయబడినది కానీ మరొకటికి క్రెడిట్ చేయబడలేనిది) ఇది డేటాను ఎలా దెబ్బతీస్తుందో మరియు సీరియస్ పరిణామాలను కలిగి ఉండటం గురించి తెలుపుతుంది. `transaction.atomic` ఆపరేషన్‍లు **ఆల్-ఆర్-నదింగ్** (ఏదైనా విఫలతపై సంపూర్ణ బ్లాక్‌ను రోల్‌బ్యాక్ చేస్తుంది) గ్యారెంటీ ఇస్తుంది, ఇది ఎక్కువ రేటింగ్‍ల కోసం అవసరమైనది — ఆర్డర్ దాని లైన్ వస్తువులతో సృష్టించడం, నిధులను బదిలీ చేయడం, సంబంధిత రిటర్న్‍లను అప్‍డేట్ చేయడం — సంగత డేటాబేస్‌ను నిర్వహించడానికి.

అటామిక్ బ్లాక్‍లను ఎలా ఉపయోగించాలో (సందర్భ నిర్వాహకుడిగా లేదా డెకోరేటర్‌గా), నెస్టెడ్ ట్రాన్‍జ్యాక్షన్‍లు సేవ్‌పాయింట్‍లతో, మరియు ముఖ్యమైన వివరాలు — బ్లాక్ *బయట* అనుమతిని క్యాచ్ చేయడం, **`select_for_update()`** ని ఉపయోగించి అర్హతలను లాక్ చేయడం మరియు సమకాల అప్‍డేట్‍లలో రేస్ పరిస్థితులను నిరోధించడం, మరియు లాక్‍లను నిరోధించడానికి ట్రాన్‍జ్యాక్షన్‍లను స짦కుండా ఉంచడం — దృఢ అనువర్తనాలను నిర్మించడానికి ప్రాక్టికల్ జ్ఞానం.

డేటా సమరూపత నమ్మదగిన సిస్టమ్‍ల యొక్క ఆధారమైన అవసరం, మరియు ట్రాన్‍జ్యాక్షన్‍లు మల్టీ-స్టెప్ డేటాబేస్ ఆపరేషన్‍ల కోసం సమరూపతను నిర్ధారించే యంత్రం, ఇది సరైన, సమగ్రతను సంరక్షించే కోడ్‌ను వ్రాసే డెవలపర్‍లను వారి అనువర్తనాలు విఫలమయ్యే పరిస్థితుల లేదా సమకాల ప్రవేశం — ఎటువంటి ముఖ్యమైన సంబంధిత డేటా మార్పులను నిర్వహించే అనువర్తనంలో తరచుగా-సంబంధిత ఆందోళన — నిశ్శబ్దంగా డేటాను నష్టపరిచే వారి నుండి వేరు చేసే ముఖ్య విషయం.