1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 声明全局变量db
var db *sqlx.DB
// 结构体存储user表内输出
type User struct {
ID
int
Age
int `db:"age"`
Name string `db:"name"`
}
// 连接数据库
func initDB() (err error) {
dsn := "root:wangjian@tcp(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True"
// 连接数据库 open + ping
// db = sqlx.MustConnect("mysql", dsn) // 连接不成功直接panic
db, err = sqlx.Connect("mysql", dsn)
if err != nil {
fmt.Printf("connect DB failed, err:%vn", err)
return
}
// 最大连接数
db.SetMaxOpenConns(20)
// 空闲链接数
db.SetMaxIdleConns(10)
return
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
// 1. 查询单条数据 / db.Get() / 相当于 query + scan
func queryRowDemo() {
// sql语句 ——> 字符串
sqlStr := "select id, name, age from user where id=?"
var u User
// 指定id为1 / 将数据存入结构体实例中 
err := db.Get(&u, sqlStr, 1)
if err != nil {
fmt.Printf("get failed, err:%vn", err)
return
}
fmt.Printf("id:%d name:%s age:%dn", u.ID, u.Name, u.Age)
}
// 2. 查询多条数据 / db.Select()
func queryMultiRowDemo() {
// sql语句 ——> 字符串
sqlStr := "select id, name, age from user where id > ?"
var users []User
// 指定id>1 / 将数据存入结构体实例中
err := db.Select(&users, sqlStr, 1)
if err != nil {
fmt.Printf("query failed, err:%vn", err)
return
}
fmt.Printf("users:%#vn", users)
}
// 3. 绑定SQL语句与结构体或map中的同名字段，进行查询操作 / db.NamedQuery() + rows.Next()
func namedQuery(){
sqlStr := "SELECT * FROM user WHERE name=:name"
// 1. 使用map做命名查询
rows, err := db.NamedQuery(sqlStr,
map[string]interface{}{"name": "Tom"},
)
if err != nil {
fmt.Printf("db.NamedQuery failed, err:%vn", err)
return
}
defer rows.Close() // 延时关闭
// 循环存入user结构体实例，并输出
for rows.Next(){
var u User
err := rows.StructScan(&u)
if err != nil {
fmt.Printf("scan failed, err:%vn", err)
continue
}
fmt.Printf("user:%#vn", u)
}
// 4. 批量查询 根据批量ID查询数据 / sqlx.In() + db.Rebind() + db.Select()
/*
users,_ := QueryByIDs([]int{4,5,6})
for _, user := range users {
fmt.Printf("user:%#vn", user)
}
*/
func QueryByIDs(ids []int)(users []User, err error){
// 动态填充id
query, args, err := sqlx.In("SELECT name, age FROM user WHERE id IN (?)", ids)
if err != nil {
return
}
// sqlx.In 返回带 `?` bindvar的查询语句, Rebind()可以重新绑定它
query = db.Rebind(query)
err = db.Select(&users, query, args...)
return
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// 1. 插入单条数据 / db.Exec()
func insertRowDemo() {
sqlStr := "insert into user(name, age) values (?,?)"
ret, err := db.Exec(sqlStr, "侠奢", 18)
if err != nil {
fmt.Printf("insert failed, err:%vn", err)
return
}
// 获取新插入数据的id / 验证是否插入成功
theID, err := ret.LastInsertId()
if err != nil {
fmt.Printf("get lastinsert ID failed, err:%vn", err)
return
}
fmt.Printf("insert success, the id is %d.n", theID)
}
// 2. 绑定SQL语句与结构体或map中的同名字段，进行插入操作 / db.NamedExec()
func insertUserDemo()(err error){
sqlStr := "INSERT INTO user (name,age) VALUES (:name,:age)"
_, err = db.NamedExec(sqlStr,
map[string]interface{}{
"name": "Tom",
"age": 13,
})
return
}
// 3. 批量插入数据
sqlx.In / 注意传入的参数是[]interface{}
// 3.1 结构体实现driver.Valuer接口
func (u User) Value() (driver.Value, error) {
return []interface{}{u.Name, u.Age}, nil
}
// 3.2 sqlx.In拼接 SQL 语句和 插入参数 , 注意传入的参数是[]interface{}
/*
u1 := User{Age:
1, Name: "Daming"}
u2 := User{Age:
2, Name: "Xiaoming"}
u3 := User{Age:
3, Name: "Zhongming"}
users := []interface{}{u1, u2, u3}
BatchInsertUsers2(users)
*/
func BatchInsertUsers2(users []interface{}) error {
query, args, _ := sqlx.In(
"INSERT INTO user (name, age) VALUES (?), (?), (?)",
users..., // 如果arg实现了 driver.Valuer, sqlx.In 会通过调用 Value()来展开它
)
fmt.Println(query) // 查看生成的querystring
fmt.Println(args)
// 查看生成的args
_, err := db.Exec(query, args...)
return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 更新数据 / db.Exec()
func updateRowDemo() {
sqlStr := "update user set age=? where id = ?"
ret, err := db.Exec(sqlStr, 39, 6)
if err != nil {
fmt.Printf("update failed, err:%vn", err)
return
}
// 操作影响的行数
n, err := ret.RowsAffected()
if err != nil {
fmt.Printf("get RowsAffected failed, err:%vn", err)
return
}
fmt.Printf("update success, affected rows:%dn", n)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 删除数据 / db.Exec()
func deleteRowDemo() {
sqlStr := "delete from user where id = ?"
ret, err := db.Exec(sqlStr, 6)
if err != nil {
fmt.Printf("delete failed, err:%vn", err)
return
}
// 操作影响的行数
n, err := ret.RowsAffected()
if err != nil {
fmt.Printf("get RowsAffected failed, err:%vn", err)
return
}
fmt.Printf("delete success, affected rows:%dn", n)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// 事务操作 / db.Beginx()
func transactionDemo2()(err error) {
// 开启事务
tx, err := db.Beginx()
if err != nil {
fmt.Printf("begin trans failed, err:%vn", err)
return err
}
defer func() {
// 捕获panic
if p := recover(); p != nil {
// 回滚
tx.Rollback()
panic(p) // re-throw panic after Rollback
} else if err != nil {
fmt.Println("rollback")
tx.Rollback() // err is non-nil; don't change it
} else {
err = tx.Commit() // err is nil; if Commit returns error update err
fmt.Println("commit")
}
}()
// 更新语句1
sqlStr1 := "Update user set age=18 where id=?"
rs, err := tx.Exec(sqlStr1, 1)
if err!= nil{
return err
}
n, err := rs.RowsAffected() // 影响行数
if err != nil {
return err
}
if n != 1 {
return errors.New("exec sqlStr1 failed")
}
// 更新语句2
sqlStr2 := "Update user set age=99 where i=?"
rs, err = tx.Exec(sqlStr2, 5)
if err!=nil{
return err
}
n, err = rs.RowsAffected() // 影响行数
if err != nil {
return err
}
if n != 1 {
return errors.New("exec sqlStr1 failed")
}
return err
}