Go database/sql 事务与连接管理深度解析

tx, err := db.Begin()
if err != nil {
    return err
}
// 关键：在任何可能出错的地方前，先设置延迟回滚
defer func() {
    if r := recover(); r != nil {
        tx.Rollback() // 捕获panic时回滚
        panic(r)
    } else if err != nil { // 如果存在其他错误，也进行回滚
        tx.Rollback()
    }
}()

// 执行一系列数据库操作
_, err = tx.Exec("INSERT INTO users (name) VALUES (?)", "Alice")
if err != nil {
    return err // defer 会捕获 err 并回滚
}

_, err = tx.Exec("UPDATE products SET stock = stock - 1 WHERE id = ?", 1)
if err != nil {
    return err // defer 会捕获 err 并回滚
}

// 所有操作成功，提交事务
err = tx.Commit()
if err != nil {
    return err // 提交失败也需要处理
}
return nil // 事务成功

package main

import (
    "bufio"
    "database/sql"
    "fmt"
    "os"
    "strconv"
    "time"

    _ "github.com/lib/pq" // PostgreSQL 驱动
    // _ "github.com/go-sql-driver/mysql" // MySQL 驱动
)

const C_CONN_RDBMS = "postgres"
const C_CONN_STR = "user=admin dbname=testdb password=admin sslmode=disable"
// const C_CONN_RDBMS = "mysql"
// const C_CONN_STR = "test:test@tcp(127.0.0.1:3306)/testdb?charset=utf8&parseTime=True" // MySQL连接字符串示例

var db *sql.DB // 全局数据库连接池对象

func main() {
    fmt.Println("\ntestdb1 - small test on " + C_CONN_RDBMS + " driver")

    // 1. 在程序启动时初始化一次数据库连接池
    var err error
    db, err = sql.Open(C_CONN_RDBMS, C_CONN_STR)
    if err != nil {
        fmt.Printf("Failed to open Db Connection. Error = %s\n", err)
        os.Exit(1)
    }
    defer db.Close() // 确保程序退出时关闭连接池

    // 可选：配置连接池参数
    db.SetMaxOpenConns(20)                 // 最大打开连接数
    db.SetMaxIdleConns(10)                 // 最大空闲连接数
    db.SetConnMaxLifetime(5 * time.Minute) // 连接最大生命周期

    err = db.Ping() // 验证数据库连接是否有效
    if err != nil {
        fmt.Printf("Failed to connect to database. Error = %s\n", err)
        os.Exit(1)
    }
    fmt.Println("Database connection pool initialized successfully.")

    println()
    iIters := fGetIterations()

    tmeStart := time.Now()

    fDbTestInserts(db, iIters) // 运行插入测试，传入db连接池

    fmt.Printf("Elapsed Time to process = %s\n", time.Since(tmeStart))
}

func fDbTestInserts(db *sql.DB, iIters int) {
    var iCommitted int = 0
    println("Running test inserts .........")

    for iPos := 1; iPos <= iIters; iPos += 1 {
        // 2. 每次操作从连接池获取一个连接，开始一个事务
        tx, err := db.Begin()
        if err != nil {
            fmt.Printf("Begin Transaction failed. Error = %s\n", err)
            return
        }

        // 3. 立即设置延迟回滚，确保事务在任何错误路径下都能被回滚
        defer func(tx *sql.Tx) {
            if r := recover(); r != nil {
                tx.Rollback() // 捕获panic时回滚
                panic(r)
            } else if err != nil { // 如果事务过程中出现错误，回滚
                tx.Rollback()
            }
        }(tx) // 确保defer函数捕获的是当前循环的tx

        var sSql string = "INSERT INTO test01 " +
            "(sName, dBalance)" +
            " VALUES ('Bart Simpson', 999.99)"

        _, err = tx.Exec(sSql)
        if err != nil {
            fmt.Printf("INSERT for Table failed. Error = %s\n", err)
            return // defer 会处理回滚
        }

        // 4. 使用 tx.Commit() 提交事务
        err = tx.Commit()
        if err != nil {
            fmt.Printf("COMMIT for Insert failed. Error = %s\n", err)
            return // defer 会处理回滚（如果Commit失败，事务可能处于未定义状态，通常驱动会尝试回滚）
        }

        // 确保在Commit成功后，将err置为nil，避免defer误回滚已提交的事务
        err = nil 
        iCommitted += 1

        if iPos%100 == 0 {
            fmt.Printf("Iteration = %d, Inserted = %d   \n", iPos, iCommitted)
        }
    }

    fmt.Printf("Inserts completed - committed = %d\n", iCommitted)
}

// 辅助函数保持不变
func fGetIterations() int {
    oBufReader := bufio.NewReader(os.Stdin)
    for {
        print("Number of Inserts to process : (1 to 10,000) or 'end' : ")
        vLine, _, _ := oBufReader.ReadLine()
        var sInput string = string(vLine)
        if sInput == "end" || sInput == "END" {
            os.Exit(1)
        }
        iTot, oError := strconv.Atoi(sInput)
        if oError != nil {
            println("Invalid number")
        } else if iTot < 1 || iTot > 10000 {
            println("Number must be from 1 to 10,000")
        } else {
            return iTot
        }
    }
}