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 **ਬਲਾਕ ਵਿੱਚ ਹਰ ਬਦਲਾਵ ਵਾਪਸ ਲੈ ਲੈਂਦਾ ਹੈ** — ਇਸ ਲਈ ਡੇਟਾਬੇਸ ਕਦੇ ਅੱਧਾ-ਅਪਡੇਟ ਨਹੀਂ ਛੁੱਟਦਾ। ਸਫਲਤਾ ਤੇ, ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਇਕਠੇ ਕਮਿਟ ਹੁੰਦੀਆਂ ਹਨ।

## ਨੇਸਟਡ ਐਟੋਮਿਕ ਬਲਾਕਸ (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 ਵਰਤਦੇ ਹਨ — ਅੰਦਰਲਾ ਬਲਾਕ ਪੂਰੀ ਬਾਹਰੀ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾਏ ਬਗੈਰ ਆਜ਼ਾਦੀ ਨਾਲ ਵਾਪਸ ਲੈ ਸਕਦਾ ਹੈ।

## ਮਹੱਤਵਪੂਰਨ ਵਿਵਰਣ

```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` ਇਸ ਗ੍ਰੇਜ਼ਾਂਟੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਕਿ ਓਪਰੇਸ਼ਨ **ਸਭ-ਜਾਂ-ਨਿੱਕ** ਹਨ (ਕਿਸੇ ਵੀ ਫੇਲ ਤੇ ਪੂਰੀ ਬਲਾਕ ਨੂੰ ਵਾਪਸ ਲੈਂਦਾ ਹੈ), ਜੋ ਬਹੁ-ਲਿਖਤ ਤੇ ਫੈਲਿਆ ਕੋਈ ਓਪਰੇਸ਼ਨ — ਆਰਡਰ ਅਤੇ ਇਸਦੀਆਂ ਲਾਇਨ ਆਈਟਮਾਂ ਬਣਾਉਣਾ, ਫੰਡ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ, ਸੰਬੰਧਤ ਰਿਕਾਰਡ ਅਪਡੇਟ ਕਰਨਾ — ਇੱਕ ਅਸਥਿਰ ਡੇਟਾਬੇਸ ਨੂੰ ਮੇਨਟੇਇਨ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਅਟੋਮਿਕ ਬਲਾਕਸ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ (ਕਨਟੈਕਸਟ ਮੈਨੇਜਰ ਜਾਂ ਡੈਕੋਰੇਟਰ ਦੇ ਤੌਰ ਤੇ), ਨੇਸਟਡ ਟ੍ਰਾਂਜੈਕਸ਼ਨਸ savepoints ਦੇ ਨਾਲ, ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਵਿਵਰਣ — ਐਕਸੈਪਸ਼ਨਸ ਨੂੰ ਬਲਾਕ ਦੇ *ਬਾਹਰ* ਫੜਨਾ, **`select_for_update()`** ਨੂੰ ਸਮਵਰਤੀ ਅਪਡੇਟਸ ਵਿੱਚ ਰੇਸ ਕੰਡੀਸ਼ਨਸ ਨੂੰ ਰੋਕਣ ਲਈ ਸਤਰਾਂ ਨੂੰ ਲਾਕ ਕਰਨ ਲਈ ਵਰਤਣਾ, ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨਸ ਨੂੰ ਛੋਟਾ ਰੱਖਣਾ ਤਾਲਾ ਰੱਖਣ ਤੋਂ ਬਚਣ ਲਈ — ਮਜ਼ਬੂਤ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਪ੍ਰੈਕਟੀਕਲ ਜ਼ਾਨਕਾਰੀ ਹੈ।

ਡੇਟਾ ਸਥਿਰਤਾ ਲੇਵਾਯੰਗ ਸਿਸਟਮਾਂ ਦੀ ਇੱਕ ਬੁਨਿਆਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਮਲਟੀ-ਸਟੈਪ ਡੇਟਾਬੇਸ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਇਸ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਵਾਲੀ ਯੰਤਰ ਹਨ, ਇਸ ਨੂੰ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਸਹੀ, ਇੰਟੀਗ੍ਰਿਟੀ-ਪ੍ਰਿਜ਼ਰਵਿੰਗ ਕੋਡ ਲਿਖਦੇ ਹਨ ਉਨ੍ਹਾਂ ਤੋਂ ਜਿਨ੍ਹਾਂ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਫੇਲ ਕੰਡੀਸ਼ਨਸ ਜਾਂ ਸਮਵਰਤੀ ਪਹੁੰਚ ਦੇ ਅਧੀਨ ਚੁੱਪ-ਨਾਲ ਡੇਟਾ ਨੂੰ ਖਰਾਬ ਕਰ ਸਕਦੀਆਂ ਹਨ — ਕਿਸੇ ਵੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ, ਸੰਬੰਧਤ ਡੇਟਾ ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਬੇਸਵਰਨ ਮੁਨਾਸਬਤ ਹੈ।