Как работают транзакции базы данных в 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` используют 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()`** для блокировки строк и предотвращения race conditions в одновременных обновлениях, и сохранение транзакций короткими во избежание удержания блокировок — это практическое знание для создания надёжных приложений.

Согласованность данных — это фундаментальное требование надёжных систем, а транзакции — это механизм, который обеспечивает её для многошаговых операций базы данных, делая эту тему важной, которая отличает разработчиков, пишущих корректный, сохраняющий целостность код, от тех, чьи приложения могут молча повреждать данные при условиях отказа или одновременного доступа — часто возникающая проблема в любом приложении, обрабатывающем важные, связанные изменения данных.