Django'da veritabanı işlemleri (transactions) nasıl çalışır?

Question

Accepted Answer

Bir **veritabanı işlemi (transaction)**, birden fazla operasyonu gruplandırarak bunların **ya hepsi birden başarılı olmasını ya da hepsi birden başarısız olmasını sağlar** (atomiklik) — kısmi, tutarsız güncellemeleri önler. Django, operasyonları bir işlem içinde sarmalamak için `transaction.atomic` sağlar ve çok adımlı operasyonlar için veri bütünlüğünü garantiler.

## İşlemlerin çözdüğü sorun

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

Bir işlem olmadan, eğer ikinci operasyon başarısız olursa, birinci zaten commit edilmiştir — veritabanını bozuk, tutarsız bir durumda bırakır (para borç alındı ama kredi verilmedi).

## transaction.atomic — ya hep ya hiç

```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()` içinde, herhangi bir operasyon istisna fırlatırsa, Django blok içindeki her değişikliği **geri alır (rollback)** — böylece veritabanı asla yarım güncellenmiş durumda bırakılmaz. Başarı durumunda, tüm değişiklikler birlikte commit edilir.

## İç içe atomic bloklar (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
```

İç içe `atomic` blokları, savepoint'leri kullanır — iç blok bütün dış işlemi iptal etmeden bağımsız olarak geri alınabilir.

## Önemli detaylar

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

## Neden önemli

Veritabanı işlemleri, bir operasyon birden fazla ilişkili veritabanı değişikliği içerdiğinde **veri bütünlüğü** için gereklidir ve bunların bir birim olarak başarılı olması veya başarısız olması gerektiğinde — ve `transaction.atomic` anlamak, doğru ve güvenilir uygulamalar geliştirmek için önemli bir bilgidir.

İşlemlerin çözdüğü temel sorun **kısmi başarısızlıktır**: atomiklik olmadan, eğer çok adımlı bir operasyon ortasında başarısız olursa (bir çökme, bir istisna, bir kısıtlama ihlali), veritabanı tutarsız bir durumda kalır — klasik para transferi örneği (bir hesaptan borç alındı ama diğerine kredi verilmedi) bunun veriyi nasıl bozduğunu ve ciddi sonuçlara yol açabileceğini gösterir. `transaction.atomic` operasyonların **ya hep ya hiç** olacağının garantisini sağlar (herhangi bir başarısızlık durumunda tüm bloku geri alarak), bu da birden fazla yazma işlemi içeren herhangi bir operasyon — bir sipariş öğeleriyle oluşturma, fonları transfer etme, ilişkili kayıtları güncelleme — için veritabanı tutarlılığını korumak için gereklidir. Atomic blokları nasıl kullanacağını (bağlam yöneticisi veya dekoratör olarak), nested işlemleri savepoint'lerle nasıl yapacağını, ve önemli detayları — istisnaları bloğun *dışında* yakalaması, eşzamanlı güncellemelerde ırk koşullarını önlemek için **`select_for_update()`** kullanması, ve işlemleri kısa tutarak kilitleri tutmaktan kaçınması — anlamak, güçlü uygulamalar geliştirmek için pratik bir bilgidir.

Veri tutarlılığı, güvenilir sistemlerin temel bir gereksinimidir ve işlemler, çok adımlı veritabanı operasyonları için bunu sağlayan mekanizmadır; bu, doğru, bütünlüğü koruyan kod yazan geliştiricileri, başarısızlık koşulları veya eşzamanlı erişim altında veri sessizce bozabilen uygulamalar yazan geliştiricilerden ayıran önemli bir konudur — önemli, ilişkili veri değişiklikleri işleyen herhangi bir uygulamada sık görülen bir endişedir.