Django இல் database transactions எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

ஒரு **database transaction** பல செயல்பாடுகளை ஒன்றாக சேர்ப்பதால் அவை அனைத்தும் **வெற்றிபெறுகின்றன அல்லது அனைத்தும் ஒன்றாக தோல்வியடைகின்றன** (atomicity) — பகுதியான, முரண்பட்ட updates தடுக்கின்றன. Django பல-படி செயல்பாடுகளுக்கான data integrity உறுதிசெய்ய, ஒரு transaction இல் செயல்பாடுகளை மடிக்க `transaction.atomic` வழங்குகிறது.

## 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 இல்லாமல், இரண்டாவது செயல்பாடு தோல்வியடைந்தால், முதல் ஏற்கனவே committed - database ஐ உடைந்த, முரண்பட்ட நிலையில் விட்டுச் செல்லும் (பணம் debit செய்யப்பட்டிருக்கும் ஆனால் credit செய்யப்படவில்லை).

## transaction.atomic — all-or-nothing

```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 ஐ raise செய்தால், Django **rollback** செய்கிறது블கு block இல் உள்ள ஒவ்வொரு மாற்றமும் — database ஐ பாதி-update செய்யப்பட்ட நிலையில் விட்டுச் செல்லாதிருக்கிறது. வெற்றியில், அனைத்து மாற்றமும் ஒன்றாக commit செய்யப்படுகிறது.

## Nested atomic blocks (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
```

Nested `atomic` blocks savepoints ஐ பயன்படுத்துகின்றன — உள் block சுயாதீனமாக 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
```

## அது ஏன் முக்கியமாக உள்ளது

Database transactions **data integrity** க்கு அவசியமாக உள்ளன எப்போதும் ஒரு செயல்பாடு பல தொடர்புடைய database மாற்றங்கள் உள்ளடக்கிய போது அவை வெற்றிபெற வேண்டும் அல்லது ஒரு unit ஆக தோல்வியடைய வேண்டும் — மற்றும் `transaction.atomic` ஐ புரிந்துகொள்வது சரியான, நம்பகமான applications கட்டுவதற்கான முக்கியமான அறிவாக உள்ளது.

Transactions தீர்க்கும் முக்கிய சிக்கல் **partial failure** ஆக உள்ளது: atomicity இல்லாமல், ஒரு பல-படி செயல்பாடு மধ்যில் தோல்வியடைந்தால் (ஒரு crash, ஒரு exception, ஒரு constraint violation), database முரண்பட்ட நிலையில் விட்டுவிடப்படுகிறது — பாரம்பரிய பணம்-transfer உதாரணம் (ஒரு கணக்கிலிருந்து debit செய்யப்பட்டிருக்கும் ஆனால் மற்றொன்றுக்கு credit செய்யப்படவில்லை) இது எவ்வாறு data ஐ corrupt செய்கிறது மற்றும் serious விளைவுகளை ஏற்படுத்த முடியும் என்பதை விளக்குகிறது. `transaction.atomic` operations **all-or-nothing** செய்ய உத்தரவாதம் வழங்குகிறது (எந்த தோல்வியிலும் முழு block ஐ rollback செய்து), இது பல writes கொண்ட எந்த செயல்பாடுக்கும் அவசியமாக உள்ளது — ஒரு order அதன் line items உடன் உருவாக்குவது, நிதி பரிமாற்றம் செய்வது, தொடர்புடைய records ஐ update செய்வது — ஒரு சீரான database ஐ பராமரிக்க.

Atomic blocks (ஒரு context manager அல்லது decorator ஆக) பயன்படுத்துவது எவ்வாறு உள்ளது, nested transactions with savepoints, மற்றும் முக்கியமான விவரங்கள் — **block வெளியே exceptions ஐ catch செய்யுங்கள**, race conditions ஐ தடுக்க rows ஐ lock செய்ய **`select_for_update()`** ஐ பயன்படுத்தவும் concurrent updates இல், மற்றும் locks ஐ பிடிக்க transactions ஐ சிறியதாக வைத்திருக்கவும் — robust applications கட்டுவதற்கான நடைமுறை அறிவாக உள்ளது.

Data consistency நம்பகமான systems இன் ஒரு அடிப்படை தேவையாக உள்ளது, மற்றும் transactions பல-படி database செயல்பாடுகளுக்கு அதை உறுதிசெய்ய பயன்படுத்தும் வழிமுறையாக உள்ளது, இது சரியான, integrity-preserving code எழுதும் developers ஐ அவர்களின் applications விலிருந்து வேறுபடுத்துகிறது அவை failure conditions அல்லது concurrent access இல் silently data ஐ corrupt செய்ய முடியும் — எந்த application முக்கியமான, தொடர்புடைய data மாற்றங்கள் கையாளும் தொடர்புடைய கவலையாக உள்ளது.