Como funcionam as transações de banco de dados no Django?

Question

Accepted Answer

Uma **transação de banco de dados** agrupa múltiplas operações para que **todas sejam bem-sucedidas ou todas falhem juntas** (atomicidade) — prevenindo atualizações parciais e inconsistentes. Django fornece `transaction.atomic` para envolver operações em uma transação, garantindo integridade de dados para operações em múltiplas etapas.

## O problema que as transações resolvem

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

Sem uma transação, se a segunda operação falhar, a primeira já foi confirmada — deixando o banco de dados em um estado quebrado e inconsistente (dinheiro debitado mas não creditado).

## transaction.atomic — tudo ou nada

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

Dentro de `atomic()`, se qualquer operação lançar uma exceção, Django **desfaz** todas as mudanças no bloco — garantindo que o banco de dados nunca seja deixado pela metade. Ao suceder, todas as mudanças são confirmadas juntas.

## Blocos atomic aninhados (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
```

Blocos `atomic` aninhados usam savepoints — o bloco interno pode desfazer independentemente sem abortar toda a transação externa.

## Detalhes importantes

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

## Por que isso importa

Transações de banco de dados são essenciais para **integridade de dados** sempre que uma operação envolve múltiplas mudanças de banco de dados relacionadas que devem suceder ou falhar como uma unidade — e compreender `transaction.atomic` é conhecimento importante para construir aplicações corretas e confiáveis.

O problema central que as transações resolvem é **falha parcial**: sem atomicidade, se uma operação em múltiplas etapas falhar no meio (um crash, uma exceção, uma violação de restrição), o banco de dados fica em um estado inconsistente — o exemplo clássico de transferência de dinheiro (debitado de uma conta mas não creditado em outra) ilustra como isso corrompe dados e pode ter consequências sérias. `transaction.atomic` fornece a garantia de que operações são **tudo ou nada** (desfazendo todo o bloco em qualquer falha), o que é necessário para qualquer operação que abrange múltiplas escritas — criando um pedido com seus itens, transferindo fundos, atualizando registros relacionados — para manter um banco de dados consistente.

Compreender como usar blocos atomic (como um gerenciador de contexto ou decorador), transações aninhadas com savepoints, e os detalhes importantes — capturar exceções *fora* do bloco, usar **`select_for_update()`** para bloquear linhas e prevenir condições de corrida em atualizações concorrentes, e manter transações curtas para evitar segurar locks — é conhecimento prático para construir aplicações robustas.

Consistência de dados é um requisito fundamental de sistemas confiáveis, e transações são o mecanismo que garante isso para operações de banco de dados em múltiplas etapas, tornando este um tópico importante que distingue desenvolvedores que escrevem código correto que preserva integridade daqueles cujas aplicações podem silenciosamente corromper dados em condições de falha ou acesso concorrente — uma preocupação frequentemente relevante em qualquer aplicação que lida com mudanças de dados importantes e relacionadas.