Transacciones, Sentencias Preparadas y sql.Tx

Las transacciones agrupan múltiples sentencias en una única unidad atómica.

Las sentencias preparadas reutilizan SQL analizado para parámetros repetidos.

sql.Tx une ambos: comienza con contexto, ejecuta dentro del límite, luego confirma o revierte.

Resumen

BeginTx(ctx, opts) inicia una transacción con nivel de aislamiento opcional.

Commit persiste los cambios; Rollback los descarta - llama a una ruta después de errores.

PrepareContext crea un Stmt; Tx.Stmt lo reutiliza dentro de una transacción.

Delega Rollback después de BeginTx para que las rutas de error no filtren transacciones abiertas.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

func Transfer(ctx context.Context, db *sql.DB, from, to int64, amount int) error {
    tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
    if err != nil {
        return err
    }
    defer tx.Rollback()
 
    if _, err := tx.ExecContext(ctx,
        `UPDATE accounts SET balance = balance - $1 WHERE id = $2`, amount, from,
    ); err != nil {
        return err
    }
    if _, err := tx.ExecContext(ctx,
        `UPDATE accounts SET balance = balance + $1 WHERE id = $2`, amount, to,
    ); err != nil {
        return err
    }
    return tx.Commit()
}

Cuándo usar esto:

• Escrituras de múltiples pasos que deben tener éxito o fallar juntas.
• Inserciones o búsquedas repetidas con la misma forma de SQL en una ruta crítica.
• Aislamiento serializable cuando las condiciones de carrera no se pueden resolver solo en la lógica de la aplicación.

Ejemplo de Trabajo

package main
 
import (
    "context"
    "database/sql"
    "fmt"
 
    _ "github.com/mattn/go-sqlite3"
)
 
func main() {
    db, _ := sql.Open("sqlite3", ":memory:")
    defer db.Close()
    ctx := context.Background()
 
    _, _ = db.ExecContext(ctx, `CREATE TABLE ledger (
        id INTEGER PRIMARY KEY,
        balance INTEGER NOT NULL
    )`)
    _, _ = db.ExecContext(ctx, `INSERT INTO ledger (id, balance) VALUES (1, 100), (2, 0)`)
 
    stmt, err := db.PrepareContext(ctx, `UPDATE ledger SET balance = balance + ? WHERE id = ?`)
    if err != nil {
        panic(err)
    }
    defer stmt.Close()
 
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        panic(err)
    }
    defer tx.Rollback()
 
    txStmt := tx.Stmt(stmt)
    if _, err := txStmt.ExecContext(ctx, -25, 1); err != nil {
        panic(err)
    }
    if _, err := txStmt.ExecContext(ctx, 25, 2); err != nil {
        panic(err)
    }
    fmt.Println(tx.Commit())
}

Lo que esto demuestra:

• PrepareContext una vez, Tx.Stmt para vincular la sentencia a la transacción activa.
• defer tx.Rollback() cubre las salidas por pánico y error; Commit tiene éxito después de que el trabajo se completa.
• El mismo ctx fluye a través de begin, exec y commit para la cancelación.
• SQLite ilustra el patrón; Postgres y MySQL usan la misma API database/sql.

Análisis Profundo

Cómo Funciona

• BeginTx extrae una conexión dedicada hasta que se confirma o se revierte.
• Las sentencias en tx se ejecutan en esa misma conexión, preservando las garantías de aislamiento.
• Los objetos Stmt pueden almacenar en caché planes preparados del lado del servidor dependiendo de la configuración del driver.
• Después de Commit, el objeto de transacción queda inválido; inicia un nuevo BeginTx para más trabajo.

Niveles de Aislamiento

Disciplina de Rollback

tx, err := db.BeginTx(ctx, nil)
if err != nil {
    return err
}
defer func() {
    _ = tx.Rollback() // no-op después de un Commit exitoso
}()

• Rollback después de Commit devuelve sql.ErrTxDone - seguro de ignorar en defer.
• Devuelve errores de dominio antes de confirmar; mapea sql.ErrTxDone solo si confirmas dos veces por error.
• Las transacciones largas retienen bloqueos de filas - mantén la lógica de negocio fuera de la tx cuando sea posible.

Puntos de Guardado (específico del driver)

Algunos equipos usan SQL SAVEPOINT crudo dentro de una tx para reversiones parciales.

Prefiere menos transacciones, más cortas, sobre anidamiento profundo de puntos de guardado a menos que el equipo de la base de datos documente patrones.

Trampas Comunes

• Olvidó Rollback en la ruta de error - La conexión permanece en estado abortado y se filtra del pool. Solución: defer tx.Rollback() inmediatamente después de BeginTx.
• Usar db.Exec dentro de una tx abierta para escrituras relacionadas - Las sentencias se ejecutan en conexiones diferentes y rompen la atomicidad. Solución: solo tx.ExecContext para trabajo transaccional.
• Sentencia preparada de la tx incorrecta - Ejecutar stmt.Exec mientras una tx está abierta omite la conexión de la transacción. Solución: tx.Stmt(stmt) o preparar directamente en tx.
• Grandes trabajos por lotes en transacciones - Una tx bloquea tablas durante minutos. Solución: confirma lotes con desplazamientos idempotentes o tablas de staging.
• Serializable sin reintento - Los conflictos aparecen como errores bajo carga. Solución: reintenta ante fallos de serialización con retroceso (backoff).
• Cerrar Stmt mientras la tx aún se está ejecutando - Comportamiento indefinido en algunos drivers. Solución: cierra las sentencias después de que la tx se complete o usa preparaciones de corta duración por solicitud.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de Bases de Datos - Ejemplo de inicio de BeginTx
• Pool de Conexiones y Tiempos de Espera de database/sql - las tx retienen conexiones
• Migraciones con golang-migrate & goose - transacciones de cambio de esquema
• GORM vs sqlx vs Raw database/sql - ayudantes de transacción ORM
• Mejores Prácticas de Bases de Datos y Acceso a Datos - reglas de duración y reversión de tx

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC de Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica los objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).