使用go-mssqldb的事务

事务将多个操作组合成一个原子单元。 要么所有操作成功(提交),要么全部操作都不生效(回滚)。 本文将介绍如何使用驱动程序 go-mssqldb 事务,包括隔离级别、错误处理以及生产应用中的模式。

本文中的示例与 AdventureWorks2025 样本数据库比较。 写入导向的示例以 HumanResources.Department、Production.ProductCategory、Production.ProductSubcategory 和 Production.ProductInventory 为目标。

发起交易

使用 db.BeginTx 来启动事务。 返回的 *sql.Tx 会在整个事务生命周期内固定池中的单个连接:

tx, err := db.BeginTx(ctx, nil) // nil uses the default isolation level
if err != nil {
    return err
}
defer tx.Rollback() // No-op if tx.Commit() succeeds first.

_, err = tx.ExecContext(ctx, "INSERT INTO HumanResources.Department (Name, GroupName) VALUES (@p1, @p2)",
    sql.Named("p1", name),
    sql.Named("p2", groupName))
if err != nil {
    return err
}

return tx.Commit()

Important

务必在defer tx.Rollback()后立即调用BeginTx。 如果 Commit() 成功,被延迟的 Rollback() 就是一个空操作。 如果在 Commit() 之前发生任何错误,延后的 Rollback() 可确保事务不会继续保持打开状态,也不会将连接以未提交状态泄漏回连接池。

隔离级别

SQL Server 支持多个隔离级别,用于控制并发事务的交互方式。 将隔离水平设为:sql.TxOptions

tx, err := db.BeginTx(ctx, &sql.TxOptions{
    Isolation: sql.LevelReadCommitted,
})

隔离级别比较

隔离级别 脏读取 不可重复读取 虚拟读取 性能影响 何时使用
sql.LevelReadUncommitted 是的 是的 是的 最低开销 近似计数,监控仪表板。 数据准确性并非关键。
sql.LevelReadCommitted 否 是的 是的 违约。 适用于大多数工作负载。 一般的OLTP工作量。 默认且推荐的起点。
sql.LevelRepeatableRead 否 否 是的 适中。 持有锁的时间更长。 必须看到事务内相同行具有一致值的读取操作。
sql.LevelSerializable 否 否 否 最高。 范围锁会阻止并发插入。 金融交易、库存管理,以及任何不允许出现幻读的场景。
sql.LevelSnapshot 否 否 否 在 tempdb 中使用行版本控制。 没有挡板。 需要时间点一致性且不阻塞写入操作的读密集型工作负荷。

注释

sql.LevelSnapshot 需要在数据库上启用快照隔离: ALTER DATABASE AdventureWorks2025 SET ALLOW_SNAPSHOT_ISOLATION ON。

示例:读取已提交与可序列化

在 sql.TxOptions 中指定隔离级别:

// Read Committed (default) - suitable for most operations.
tx1, err := db.BeginTx(ctx, &sql.TxOptions{
    Isolation: sql.LevelReadCommitted,
})

// Serializable - prevents phantom reads in financial calculations.
tx2, err := db.BeginTx(ctx, &sql.TxOptions{
    Isolation: sql.LevelSerializable,
})

只读路由

驱动不支持 sql.TxOptions.ReadOnly。 如果传入 ReadOnly: true,BeginTx 会返回错误。

对于AlwaysOn只读路由,打开连接时在连接字符串中设置applicationintent=ReadOnly:

sqlserver://listener.example.com?database=AdventureWorks2025&applicationintent=ReadOnly

这是连接级别的设置。 它可以将符合条件的会话路由到可读辅助副本,但不会将现有事务变为只读。 对于不能写入数据的工作负载,使用专用的只读连接或最小权限凭据。

交易中的错误处理

谨慎处理交易中的错误。 当任何语句失败时,事务必须完全回滚。 发生错误后,不要尝试继续执行其他语句:

func createCategory(ctx context.Context, db *sql.DB, category Category) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return fmt.Errorf("begin transaction: %w", err)
    }
    defer tx.Rollback()

    var categoryId int64
    err = tx.QueryRowContext(ctx, `
        INSERT INTO Production.ProductCategory (Name)
        OUTPUT INSERTED.ProductCategoryID
        VALUES (@name)`,
        sql.Named("name", category.Name)).Scan(&categoryId)
    if err != nil {
        return fmt.Errorf("insert category: %w", err)
    }

    // Insert subcategories under the new category.
    for _, sub := range category.Subcategories {
        _, err = tx.ExecContext(ctx, `
            INSERT INTO Production.ProductSubcategory (ProductCategoryID, Name)
            VALUES (@catId, @name)`,
            sql.Named("catId", categoryId),
            sql.Named("name", sub.Name))
        if err != nil {
            return fmt.Errorf("insert subcategory %s: %w", sub.Name, err)
        }
    }

    if err = tx.Commit(); err != nil {
        return fmt.Errorf("commit category: %w", err)
    }
    return nil
}

如果批处理或存储过程在 SET XACT_ABORT ON 设置下运行,则将所有语句错误视为事务的终止性错误。 立即回滚,不要再执行更多语句或 Commit()。 当前驱动程序版本可检测到服务器中止的事务并返回错误,而不会允许静默的部分提交。

保存点

保存点在事务内创建中间回滚点。 SQL Server 原生支持保存点。 由于 Go 的 database/sql 包不直接提供对保存点的支持,因此需要通过事务以原始 SQL 执行它们:

func createCategoryWithOptionalSubcategory(ctx context.Context, db *sql.DB, category Category) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()

    err = tx.QueryRowContext(ctx,
        "INSERT INTO Production.ProductCategory (Name) OUTPUT INSERTED.ProductCategoryID VALUES (@p1)",
        sql.Named("p1", category.Name)).Scan(&category.Id)
    if err != nil {
        return err
    }

    // Try to add a subcategory. If it fails, roll back only the subcategory part.
    _, err = tx.ExecContext(ctx, "SAVE TRANSACTION AddSubcategory")
    if err != nil {
        return err
    }

    _, err = tx.ExecContext(ctx,
        "INSERT INTO Production.ProductSubcategory (ProductCategoryID, Name) VALUES (@p1, @p2)",
        sql.Named("p1", category.Id),
        sql.Named("p2", category.DefaultSubcategory))
    if err != nil {
        // Roll back only the subcategory; the category insert is preserved.
        _, rbErr := tx.ExecContext(ctx, "ROLLBACK TRANSACTION AddSubcategory")
        if rbErr != nil {
            return fmt.Errorf("rollback savepoint: %w (original: %w)", rbErr, err)
        }
        log.Printf("Subcategory %q failed, proceeding without it: %v",
            category.DefaultSubcategory, err)
    }

    return tx.Commit()
}

注释

SAVE TRANSACTION <name> 创建保存点。 ROLLBACK TRANSACTION <name> 在不结束外部事务的情况下回滚到该保存点。 不带名称的 ROLLBACK 会回滚整个事务。

死锁处理

SQL Server 通过终止其中一个竞争事务(死锁牺牲品)并返回错误 1205 来解决死锁。 终止的交易会被服务器自动回滚。

检测到死锁后重试

检查错误 1205,并在短暂延迟后重试整个事务:

import (
    "errors"
    "fmt"
    "time"

    "github.com/microsoft/go-mssqldb"
)

func isDeadlock(err error) bool {
    var mssqlErr mssql.Error
    return errors.As(err, &mssqlErr) && mssqlErr.Number == 1205
}

func withDeadlockRetry(ctx context.Context, db *sql.DB, maxRetries int,
    fn func(ctx context.Context, tx *sql.Tx) error) error {

    for attempt := 0; attempt < maxRetries; attempt++ {
        tx, err := db.BeginTx(ctx, nil)
        if err != nil {
            return err
        }

        err = fn(ctx, tx)
        if err != nil {
            tx.Rollback()
            if isDeadlock(err) && attempt < maxRetries-1 {
                // Wait briefly before retrying.
                delay := time.Duration(attempt+1) * 50 * time.Millisecond
                select {
                case <-ctx.Done():
                    return ctx.Err()
                case <-time.After(delay):
                }
                continue
            }
            return err
        }

        if err = tx.Commit(); err != nil {
            if isDeadlock(err) && attempt < maxRetries-1 {
                delay := time.Duration(attempt+1) * 50 * time.Millisecond
                select {
                case <-ctx.Done():
                    return ctx.Err()
                case <-time.After(delay):
                }
                continue
            }
            return err
        }
        return nil
    }
    return fmt.Errorf("transaction failed after %d deadlock retries", maxRetries)
}

使用死锁重试包装器

将事务函数传递给重试包装器:

err := withDeadlockRetry(ctx, db, 3, func(ctx context.Context, tx *sql.Tx) error {
    _, err := tx.ExecContext(ctx,
        "UPDATE Production.ProductInventory SET Quantity = Quantity - @qty WHERE ProductID = @pid AND LocationID = @lid",
        sql.Named("qty", orderQty),
        sql.Named("pid", productId),
        sql.Named("lid", locationId))
    return err
})

减少死锁

Strategy 它如何提供帮助
按一致的顺序访问表 当所有事务都先锁定表A,再锁定表B时,就不会出现循环等待。
保持交易简短 较短的事务持有锁的时间更短,从而缩小了冲突的时间窗口。
使用最低的足够隔离水平 ReadCommitted 持有的锁数比 Serializable少。
添加合适的索引 基于索引定位的更新比表扫描锁定的行数更少。
避免交易过程中的用户互动 切勿在 BeginTx 和 Commit 之间等待用户输入。

在应用代码中,重试是正确的响应,但同一查询上出现反复死锁则说明存在设计问题。 使用SQL Server死锁图(通过扩展事件或系统健康会话捕获)来识别竞争的语句和锁类型,然后应用前表中的策略。 关于死锁分析和预防的完整攻略,请参见 死锁指南。

事务与连接固定

事务会固定使用池中的单个连接,直到 Commit() 或 Rollback() 被调用。 在此期间,其他 goroutine 无法使用该连接。

影响:

  • 长时间运行的事务会降低连接池的有效大小。 如果你有 MaxOpenConns=25,并且有 20 个未结事务,则只有 5 个连接可用于其他工作。
  • 忘记的 Rollback() 会导致连接永久泄漏。
  • 对事务上下文进行取消操作会回滚事务并将连接返回连接池。
// Set a deadline to prevent transactions from running indefinitely.
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

tx, err := db.BeginTx(ctx, nil)
if err != nil {
    return err
}
defer tx.Rollback()

并发事务

每个 goroutine 都应该创建自己的事务。 切勿在多个 goroutine 之间共享 *sql.Tx,因为 *sql.Tx 不适合并发使用:

// CORRECT: Each goroutine gets its own transaction.
var g errgroup.Group
for _, item := range items {
    item := item
    g.Go(func() error {
        tx, err := db.BeginTx(ctx, nil)
        if err != nil {
            return err
        }
        defer tx.Rollback()

        _, err = tx.ExecContext(ctx,
            "UPDATE Production.ProductInventory SET Quantity = Quantity - 1 WHERE ProductID = @p1 AND LocationID = @p2",
            sql.Named("p1", item.ProductId),
            sql.Named("p2", item.LocationId))
        if err != nil {
            return err
        }
        return tx.Commit()
    })
}
return g.Wait()

分布式事务

该 go-mssqldb 驱动不支持分布式事务(XA事务或 System.Transactions 等效事务)。 如果你需要协调多个数据库的工作:

  • 使用带有补偿操作的 Saga 模式。
  • 尽可能将运营整合到单一数据库中。
  • 如果两个数据库都是 SQL Server,请使用来自 Transact-SQL (T-SQL) 的 BEGIN DISTRIBUTED TRANSACTION 链接服务器。

交易清单

Area Recommendation
回滚安全性 在调用 BeginTx 之后立即 defer tx.Rollback()。
隔离级别 从 ReadCommitted(默认值)开始。 只有在需要时才升级。
死锁 将事务代码置于重试循环中。 按一致的顺序访问表。
持续时间 保持交易时间尽可能简短。 设定上下文截止日期。
Concurrency 绝不要在多个 goroutine 之间共享 *sql.Tx。
保存点 使用 SAVE TRANSACTION 和 ROLLBACK TRANSACTION <name> 进行部分回滚。
泳池影响 监控 db.Stats().InUse 以检测未提交交易中的连接泄漏。