Go 语言之 sqlx 库使用

一、sqlx 库安装与连接

sqlx 介绍

sqlx is a library which provides a set of extensions on go's standard database/sql library. The sqlx versions of sql.DB, sql.TX, sql.Stmt, et al. all leave the underlying interfaces untouched, so that their interfaces are a superset on the standard ones. This makes it relatively painless to integrate existing codebases using database/sql with sqlx.

Sqlx 是一个库，它在 go 的标准数据库/sql 库上提供了一组扩展。

sqlx库：github.com/jmoiron/sql…

Illustrated guide to SQLX：jmoiron.github.io/sqlx/

sqlx：pkg.go.dev/github.com/…

安装

go get github.com/jmoiron/sqlx

创建 sqlx_demo 项目

创建 main.go 文件

使用 go mod tidy 添加丢失的模块和删除未使用的模块

go mod tidy add missing and remove unused modules

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go mod tidy   
go: finding module for package github.com/jmoiron/sqlx
go: finding module for package github.com/go-sql-driver/mysql
go: downloading github.com/jmoiron/sqlx v1.3.5
go: found github.com/go-sql-driver/mysql in github.com/go-sql-driver/mysql v1.7.1
go: found github.com/jmoiron/sqlx in github.com/jmoiron/sqlx v1.3.5
go: downloading github.com/lib/pq v1.2.0
go: downloading github.com/mattn/go-sqlite3 v1.14.6

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

连接 MySQL 数据库

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base took 2.0s 
➜

二、sqlx 的 CRUD （查询、插入、更新、修改）

查询单条数据

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝

// 查询单条数据
func queryRowDemo(id int) (u user, err error) {
  sqlStr := "SELECT id, name, age FROM user WHERE id=?"
  // 使用这个数据库。任何占位符参数都将被提供的参数替换。如果结果集为空，则返回错误。
  // 在 Get 中要修改传入的变量，需要传指针，即 &u
  err = db.Get(&u, sqlStr, id)
  if err != nil {
    fmt.Printf("get failed, err:%v\n", err)
    return u, err
  }
  return u, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
  // 查询
  u, err := queryRowDemo(1)
  if err != nil {
    fmt.Printf("query row demo failed, err %v\n", err)
  }
  fmt.Printf("id: %d name: %s age: %d\n", u.ID, u.Name, u.Age)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
id: 1 name: 小乔 age: 16

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base took 3.1s 
➜

查询多条数据

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝

// 查询多条数据
func queryMultiRowDemo(id int) (users []user, err error) {
  sqlStr := "SELECT id, name, age FROM user WHERE id > ?"
  err = db.Select(&users, sqlStr, id)
  if err != nil {
    fmt.Printf("query failed, err: %v\n", err)
    return users, err
  }
  return users, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")

  // 查询多条
  users, err := queryMultiRowDemo(0)
  if err != nil {
    fmt.Printf("query many rows failed %v\n", err)
  }
  fmt.Printf("users: %#v\n", users)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base took 3.1s 
➜ go run main.go
init DB succeeded
users: []main.user{main.user{ID:1, Age:16, Name:"小乔"}, main.user{ID:2, Age:22, Name:"小乔"}, main.user{ID:5, Age:100, Name:"昭君"}, main.user{ID:6, Age:16, Name:"黛玉"}}

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

~ via 🅒 base
➜ mysql -uroot -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 476
Server version: 8.0.32 Homebrew

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> use sql_test;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |  100 |
|  6 | 黛玉   |   16 |
+----+--------+------+
4 rows in set (0.00 sec)

mysql>

插入

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝

// 插入数据
func insertRowDemo(name string, age int) (int64, error) {
  sqlStr := "INSERT INTO user(name, age) VALUES (?,?)"
  // 执行查询而不返回任何行。
  // 参数用于查询中的任何占位符参数
  ret, err := db.Exec(sqlStr, name, age)
  if err != nil {
    fmt.Printf("insert failed, err: %v\n", err)
    return 0, err
  }
  // 返回数据库响应命令生成的整数。
  // 通常，当插入新行时，这将来自“自动增量”列。
  // 并非所有数据库都支持此特性，并且此类语句的语法各不相同。
  var LastInsertId int64
  LastInsertId, err = ret.LastInsertId() // 新插入数据的id
  if err != nil {
    fmt.Printf("get lastinsert ID failed, err: %v\n", err)
    return 0, err
  }
  return LastInsertId, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")

  // 插入数据
  LastInsertId, err := insertRowDemo("宝玉", 17)
  if err != nil {
    fmt.Printf("insert row demo failed %v\n", err)
  }
  fmt.Printf("insert success, the id is %d.\n", LastInsertId)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
insert success, the id is 7.

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |  100 |
|  6 | 黛玉   |   16 |
|  7 | 宝玉   |   17 |
+----+--------+------+
5 rows in set (0.01 sec)

mysql>

更新

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝


// 更新数据
func updateRowDemo(age, id int) (int64, error) {
  sqlStr := "UPDATE user SET age=? WHERE id = ?"
  ret, err := db.Exec(sqlStr, age, id)
  if err != nil {
    fmt.Printf("update failed, err:%v\n", err)
    return 0, err
  }
  // 返回受更新、插入或删除影响的行数。并非每个数据库或数据库驱动程序都支持此功能。
  var n int64
  n, err = ret.RowsAffected() // 操作影响的行数
  if err != nil {
    fmt.Printf("get RowsAffected failed, err:%v\n", err)
    return 0, err
  }
  return n, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")

  // 更新数据
  n, err := updateRowDemo(18, 5)
  if err != nil {
    fmt.Printf("update row demo failed %v\n", err)
  }
  fmt.Printf("update success, affected rows: %d\n", n)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
update success, affected rows: 1

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  7 | 宝玉   |   17 |
+----+--------+------+
5 rows in set (0.00 sec)

mysql>

删除

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝

// 删除数据
func deleteRowDemo(id int) (int64, error) {
  sqlStr := "DELETE FROM user WHERE id = ?"
  ret, err := db.Exec(sqlStr, id)
  if err != nil {
    fmt.Printf("delete failed, err:%v\n", err)
    return 0, err
  }
  // 返回受更新、插入或删除影响的行数。并非每个数据库或数据库驱动程序都支持此功能。
  var n int64
  n, err = ret.RowsAffected() // 操作影响的行数
  if err != nil {
    fmt.Printf("get RowsAffected failed, err:%v\n", err)
    return 0, err
  }
  return n, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
  
  // 删除数据
  n, err := deleteRowDemo(7)
  if err != nil {
    fmt.Printf("delete row demo failed %v\n", err)
  }
  fmt.Printf("delete success, affected rows:%d\n", n)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
delete success, affected rows:1

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  7 | 宝玉   |   17 |
+----+--------+------+
5 rows in set (0.00 sec)

mysql>

NamedExec 的使用

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

// 1. 想要让别的包能够访问到结构体中的字段，那这个结构体中的字段需要首字母大写
// 2. Go 语言中参数的传递是值拷贝


func insertUserDemo(arg interface{}) (int64, error) {
  sqlStr := "INSERT INTO user (name,age) VALUES (:name,:age)"
  // 使用这个数据库。任何命名的占位符参数都将被arg中的字段替换。
  Result, err := db.NamedExec(sqlStr, arg)
  if err != nil {
    return 0, err
  }
  // 返回数据库响应命令生成的整数。
  // 通常，当插入新行时，这将来自“自动增量”列。
  // 并非所有数据库都支持此特性，并且此类语句的语法各不相同。
  var new_id int64
  new_id, err = Result.LastInsertId() // 新插入数据的id
  if err != nil {
    fmt.Printf("get lastinsert ID failed, err: %v\n", err)
    return 0, err
  }
  return new_id, nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
  
  // NamedExec
  arg := map[string]interface{}{"name": "李煜", "age": 26}
  new_id, err := insertUserDemo(arg)
  if err != nil {
    fmt.Printf("insert user demo failed %v\n", err)
  }
  fmt.Printf("insert user success, the new id is %d\n", new_id)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
insert user success, the new id is 8

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  8 | 李煜   |   26 |
+----+--------+------+
5 rows in set (0.01 sec)

mysql>

NamedQuery 的使用

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

func namedQueryMap(arg interface{}) {
  sqlStr := "SELECT * FROM user WHERE name=:name"
  // 任何命名的占位符参数都将被arg中的字段替换。
  rows, err := db.NamedQuery(sqlStr, arg)
  if err != nil {
    fmt.Printf("db.NamedQuery failed, err:%v\n", err)
    return
  }
  defer rows.Close()
  for rows.Next() {
    results := make(map[string]interface{})
    // 使用 map 做命名查询
    err := rows.MapScan(results)
    //dest, err := rows.SliceScan()
    if err != nil {
      fmt.Printf("scan failed, err:%v\n", err)
      continue
    }
    // 将 "name" 字段的值转换为字符串类型
    if nameBytes, ok := results["name"].([]uint8); ok {
      results["name"] = string(nameBytes)
    }
    fmt.Printf("NamedQuery Map user: %#v\n", results)
  }
}

func namedQuerySlice(arg interface{}) {
  sqlStr := "SELECT * FROM user WHERE name=:name"
  // 任何命名的占位符参数都将被arg中的字段替换。
  rows, err := db.NamedQuery(sqlStr, arg)
  if err != nil {
    fmt.Printf("db.NamedQuery failed, err:%v\n", err)
    return
  }
  defer rows.Close()
  for rows.Next() {
    results, err := rows.SliceScan()
    if err != nil {
      fmt.Printf("scan failed, err:%v\n", err)
      continue
    }
    if len(results) >= 3 {
      id, _ := results[0].(int64)
      name, _ := results[1].([]uint8)
      age, _ := results[2].(int64)

      fmt.Printf("NamedQuery Slice user: id=%d, name=%s, age=%d\n", id, string(name), age)
    }
  }
}

func namedQueryStruct(arg interface{}) {
  sqlStr := "SELECT * FROM user WHERE name=:name"
  // 任何命名的占位符参数都将被arg中的字段替换。
  rows, err := db.NamedQuery(sqlStr, arg)
  if err != nil {
    fmt.Printf("db.NamedQuery failed, err:%v\n", err)
    return
  }
  defer rows.Close()
  for rows.Next() {
    var results user
    err := rows.StructScan(&results)
    if err != nil {
      fmt.Printf("scan failed, err:%v\n", err)
      continue
    }
    fmt.Printf("NamedQuery struct user: %#v\n", results)
  }
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
  
  // NamedQuery
  // 使用 map 做命名查询
  arg := map[string]interface{}{"name": "黛玉"}
  namedQueryMap(arg)
  // 使用结构体命名查询，根据结构体字段的 db tag进行映射
  arg1 := user{Name: "黛玉"}
  namedQueryStruct(arg1)
  // 使用 Slice 做命名查询
  arg2 := []user{arg1}
  namedQuerySlice(arg2)
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
NamedQuery Map user: map[string]interface {}{"age":16, "id":6, "name":"黛玉"}
NamedQuery struct user: main.user{ID:6, Age:16, Name:"黛玉"}
NamedQuery Slice user: id=6, name=黛玉, age=16

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   16 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  8 | 李煜   |   26 |
+----+--------+------+
5 rows in set (0.00 sec)

mysql>

sqlx 事务

package main

import (
  "fmt"

  _ "github.com/go-sql-driver/mysql"
  "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func initDB() (err error) {
  dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
  // 连接到数据库并使用ping进行验证。
  // 也可以使用 MustConnect MustConnect连接到数据库，并在出现错误时恐慌 panic。
  db, err = sqlx.Connect("mysql", dsn)
  if err != nil {
    fmt.Printf("connect DB failed, err:%v\n", err)
    return
  }
  db.SetMaxOpenConns(20) // 设置数据库的最大打开连接数。
  db.SetMaxIdleConns(10) // 设置空闲连接池中的最大连接数。
  return
}

type user struct {
  ID   int    `db:"id"`
  Age  int    `db:"age"`
  Name string `db:"name"`
}

func executeQuery(tx *sqlx.Tx, sqlStr string, args ...interface{}) error {
  rs, err := tx.Exec(sqlStr, args...)
  if err != nil {
    return err
  }

  // 返回受更新、插入或删除影响的行数。并非每个数据库或数据库驱动程序都支持此功能。
  var n int64
  n, err = rs.RowsAffected()
  if err != nil {
    return err
  }

  if n != 1 { // 如果受影响的行数不是 1 ，说明更新出了问题，return 错误
    return fmt.Errorf("exec failed for id: %d", args[1])
  }

  return nil
}

func transactionDemo() error {
  // 开始事务并返回sqlx.Tx而不是sql.Tx。
  tx, err := db.Beginx() // 开启事务
  if err != nil {
    return fmt.Errorf("begin trans failed, err: %v", err)
  }

  defer func() {
    // recover 恢复内置功能允许程序管理一个恐慌的程序的行为。
    // recover的返回值报告了例程是否处于恐慌状态。
    // recover 捕获当前函数可能会出现的 panic，执行恢复操作，即先回滚然后 panic
    if p := recover(); p != nil {
      _ = tx.Rollback() // 中止回滚事务。
      panic(p)
    } else if err != nil { // 判断 err 是否为空，如果当前函数有错误，则回滚
      fmt.Printf("begin trans failed, Rollback err: %v\n", err)
      _ = tx.Rollback()
    } else { // 如果没有错误也没有 panic 则提交
      err = tx.Commit()
      fmt.Printf("error committing transaction: %v\n", err)
    }
  }()

  sqlStr := "UPDATE user SET age=? WHERE id=?"

  queries := []struct {
    id  int
    age int
  }{
    {1, 88},
    {3, 16},
  }
  
  // 更新用户表 user 中两个用户的年龄，只有当这两个用户的年龄都更新成功的情况下才会去提交
  for _, query := range queries {
    if err = executeQuery(tx, sqlStr, query.age, query.id); err != nil {
      return err
    }
  }

  return nil
}

func main() {
  if err := initDB(); err != nil {
    fmt.Printf("init DB failed, err:%v\n", err)
    return
  }
  fmt.Println("init DB succeeded")
  
  // 事务
  _ = transactionDemo()
}

运行

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
init DB succeeded
begin trans failed, Rollback err: exec failed for id: 3

Code/go/sqlx_demo via 🐹 v1.20.3 via 🅒 base 
➜

SQL 查询结果

mysql> select * from user;  # 事务执行前
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   12 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  8 | 李煜   |   26 |
+----+--------+------+
5 rows in set (0.00 sec)

mysql> select * from user;  # 事务执行后
+----+--------+------+
| id | name   | age  |
+----+--------+------+
|  1 | 小乔   |   12 |
|  2 | 小乔   |   22 |
|  5 | 昭君   |   18 |
|  6 | 黛玉   |   16 |
|  8 | 李煜   |   26 |
+----+--------+------+
5 rows in set (0.01 sec)

mysql>

使用 defer 来做事务最终是回滚还是提交的判断。
执行之后，事务回滚了，查询数据库未发生改变，是因为 ID 为 3 的那条记录不存在。