¿Cómo funcionan las transacciones de base de datos en Django?

Question

Accepted Answer

Una **transacción de base de datos** agrupa múltiples operaciones para que **todas tengan éxito o todas fallen juntas** (atomicidad) — previniendo actualizaciones parciales e inconsistentes. Django proporciona `transaction.atomic` para envolver operaciones en una transacción, asegurando la integridad de datos para operaciones de múltiples pasos.

## Por qué es importante

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

Sin una transacción, si la segunda operación falla, la primera ya ha sido confirmada — dejando la base de datos en un estado roto e inconsistente (dinero debitado pero no acreditado).

## transaction.atomic — todo o 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()`, si cualquier operación lanza una excepción, Django **revierte** cada cambio en el bloque — por lo que la base de datos nunca queda medio actualizada. Al tener éxito, todos los cambios se confirman juntos.

## Bloques atomic anidados (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
```

Los bloques `atomic` anidados usan savepoints — el bloque interno puede revertirse independientemente sin abortar toda la transacción externa.

## Detalles 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 qué es importante

Las transacciones de base de datos son esenciales para la **integridad de datos** siempre que una operación implique múltiples cambios relacionados en la base de datos que deben tener éxito o fallar como una unidad — y entender `transaction.atomic` es un conocimiento importante para construir aplicaciones correctas y confiables.

El problema central que resuelven las transacciones es el **fallo parcial**: sin atomicidad, si una operación de múltiples pasos falla a mitad de camino (un bloqueo, una excepción, una violación de restricción), la base de datos queda en un estado inconsistente — el ejemplo clásico de transferencia de dinero (debitado de una cuenta pero no acreditado en otra) ilustra cómo esto corrompe datos y puede tener consecuencias graves. `transaction.atomic` proporciona la garantía de que las operaciones son **todo o nada** (revirtiendo todo el bloque ante cualquier fallo), lo cual es necesario para cualquier operación que abarque múltiples escrituras — crear un pedido con sus artículos, transferir fondos, actualizar registros relacionados — para mantener una base de datos consistente.

Entender cómo usar bloques atomic (como gestor de contexto o decorador), transacciones anidadas con savepoints, y los detalles importantes — capturar excepciones *fuera* del bloque, usar **`select_for_update()`** para bloquear filas y prevenir condiciones de carrera en actualizaciones concurrentes, y mantener transacciones cortas para evitar mantener bloqueos — es conocimiento práctico para construir aplicaciones robustas.

La consistencia de datos es un requisito fundamental de sistemas confiables, y las transacciones son el mecanismo que lo asegura para operaciones de base de datos de múltiples pasos, haciendo este un tema importante que distingue a los desarrolladores que escriben código correcto que preserva la integridad, de aquellos cuyas aplicaciones pueden corromper silenciosamente datos bajo condiciones de fallo o acceso concurrente — una preocupación frecuentemente relevante en cualquier aplicación que maneje cambios de datos importantes y relacionados.