როგორ მუშაობს მონაცემთა ბაზის ტრანზაქციები 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 **უბრუნდება** ყველა ცვლილებას ბლოკში — ამიტომ მონაცემთა ბაზა არასოდეს რჩება ნახევრადი განახლებული. წარმატებার შემთხვევაში, ყველა ცვლილება ერთად დადახმება.

## ჩასმული 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` ბლოკები იყენებენ savepoint-ებს — შიგნითა ბლოკი შეუძლია დამოუკიდებლად უბრუნდეს მთელი გარე ტრანზაქციის გაწყვეტის გარეშე.

## მნიშვნელოვანი დეტალები

```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` უზღვდება გარანტიას, რომ ოპერაციები არიან **ყველა-ან-არა** (მთელი ბლოკის უკან დაბრუნება ნებისმიერი უკმარის შემთხვევაში), რაც აუცილებელია ნებისმიერი ოპერაციისთვის მრავალი ჩანაწერის გაწერაზე — ორდერის შექმნა მის ხაზების ჩანაწერებით, თანხის გადატანა, დაკავშირებული ჩანაწერების განახლება — რათა შენარჩუნდეს თანმიმდევრი მონაცემთა ბაზა.

atomic ბლოკების გამოყენების გაგება (context manager-ად ან decorator-ად), ჩასმული ტრანზაქციები savepoint-ებით, და მნიშვნელოვანი დეტალები — შეცდომის ჩაჭერა *ბლოკის გარეთ*, **`select_for_update()`**-ის გამოყენება რიგების დასაკეტად და race conditions-ის თავიდან აცილება კონკურენტულ განახლებებში, და ტრანზაქციების მოკლე დროის დაკავება დამჭერის ასაკეტად — ეს პრაქტიკული ცოდნაა მყარი აპლიკაციების აგებისთვის.

მონაცემთა თანმიმდევრობა საიმედო სისტემების ფუნდამენტური მოთხოვნილებაა, და ტრანზაქციები არის მექანიზმი, რომელიც უზრუნველყოფს მას მრავალ ეტაპის მონაცემთა ბაზის ოპერაციებისთვის, რაც ამ თემას მნიშვნელოვან შენაფერს ხდის, რომელიც განასხვავებს დეველოპერებს, რომლებიც წერენ სწორ, სისწორის შესანარჩუნებელ კოდს, იმ დეველოპერებისგან, რომელთა აპლიკაციებმა შეუძლია ჩალიანად დააზიანოს მონაცემები უკმარის პირობებში ან კონკურენტული წვდომის ქვეშ — ეს არის ხშირად აქტუალური ზუსტ მონაცემებზე დაკავშირებული რომელიმე ოპერაციის აპლიკაციაში.