Django मा database transactions कसरी काम गर्छन्?

Question

Accepted Answer

एक **database transaction** ले गरी बहु-चलनहरू समूहबद्ध गर्छ ताकि तिनीहरू सबै सफल हुन् वा सबै एकसाथ असफल हुन् (atomicity) — आंशिक, असंगत अद्यावधिकहरू रोक्ने। Django ले `transaction.atomic` प्रदान गर्छ अपरेशनहरूलाई transaction मा बेर्न, बहु-चरण अपरेशनहरूको लागि डेटा integrity सुनिश्चित गर्दै।

## समस्या जुन transactions समाधान गर्छ

```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 बिना, यदि दोस्रो अपरेशन असफल हुन्छ भने, पहिलेको पहिले नै commit भएको छ — डेटाबेसलाई टुट्टा, असंगत अवस्थामा छोडिरहेको छ (पैसा debit भएको तर क्रेडिट गरिएको छैन)।

## 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()` अन्दर, यदि कुनै पनि अपरेशन exception उठाउँछ भने, Django ब्लक मा प्रत्येक परिवर्तन **rollback** गर्छ — त्यसैले डेटाबेस कहिले आधा-अद्यावधिक छोडिएको छैन। सफलतामा, सबै परिवर्तनहरू एकसाथ commit हुन्छन्।

## नेस्ट गरिएको atomic ब्लकहरू (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
```

नेस्ट गरिएको `atomic` ब्लकहरू savepoints प्रयोग गर्छन् — भित्री ब्लक स्वतन्त्र रूपमा rollback गर्न सक्छ बिना पूरै बाहिरी transaction रद्द गरी।

## महत्त्वपूर्ण विवरणहरू

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

## किन यो महत्त्वपूर्ण छ

डेटाबेस transactions **डेटा integrity** को लागि आवश्यक छन् जब कुनै अपरेशन बहु-सम्बन्धित डेटाबेस परिवर्तनहरू समावेश गर्छ जो एकाई रूपमा सफल वा असफल हुनुपर्छ — र `transaction.atomic` बुझ्नु सही, विश्वसनीय अनुप्रयोगहरू निर्माण गर्नको लागि महत्त्वपूर्ण ज्ञान हो।

Transactions समाधान गर्ने मूल समस्या **आंशिक असफलता** हो: atomicity बिना, यदि बहु-चरण अपरेशन बीचमा असफल हुन्छ (क्रास, exception, constraint उल्लङ्घन), डेटाबेस असंगत अवस्थामा छोडिएको छ — उदाहरणको पैसा-हस्तान्तरण (एक खातामा debit भएको तर अर्कोमा क्रेडिट गरिएको छैन) ले दिखाउँछ कि यसले कसरी डेटा दूषित गर्छ र गम्भीर परिणाम हुन सक्छ। `transaction.atomic` ले गरान्टी प्रदान गर्छ कि अपरेशनहरू **सब-वा-केही-पनि-होइन** छन् (कुनै असफलतामा पूरै ब्लक rollback गरी), जो कुनै पनि अपरेशन बहु-लेखन जोडिएकोको लागि आवश्यक छ — अर्डर यसको लाइन आइटमहरू, फन्ड हस्तान्तरण, सम्बन्धित रेकर्ड अद्यावधिक गर्दै — असंगत डेटाबेस कायम गर्न।

Atomic ब्लकहरू कसरी प्रयोग गर्ने (context manager वा decorator को रूपमा), savepoints सँग नेस्ट गरिएको transaction, र महत्त्वपूर्ण विवरणहरू — ब्लक *बाहिर* exceptions क्याच गर्दै, **`select_for_update()`** प्रयोग गरी पङ्क्तिहरू लक गर्दै र concurrent अद्यावधिकहरुमा race conditions रोक्दै, र transaction छोटो राख्दै ताकि लक होल्ड गर्न नदिइ — robust अनुप्रयोगहरू निर्माण गर्नको लागि व्यावहारिक ज्ञान हो।

डेटा असंगतता विश्वसनीय प्रणालीहरूको मौलिक आवश्यकता हो, र transactions ले बहु-चरण डेटाबेस अपरेशनहरूको लागि यसले गरान्टी दिने यन्त्र हो, यसलाई महत्त्वपूर्ण विषय बनाइरहेको छ जो विकाससर्लीहरूलाई अलग गर्छ जो सही, integrity-सञ्चय कोड लेख्छन् तिनीहरूबाट जसको अनुप्रयोगहरू असफलता शर्तहरु वा concurrent पहुँच अन्तर्गत चुपचाप डेटा दूषित गर्न सक्छन् — कुनै पनि अनुप्रयोगमा बारम्बार-सम्बन्धित चिन्ता जो महत्त्वपूर्ण, सम्बन्धित डेटा परिवर्तनहरू ह्यान्डल गर्दछ।