yyz notes
YiZhang-You
2023-05-24
目录

mysql基础使用

# 1. mysql基础使用

# 连接mysql

Go语言中的database/sql包提供了保证SQL或类SQL数据库的泛用接口，并不提供具体的数据库驱动。使用database/sql包时必须注入（至少）一个数据库驱动。

我们常用的数据库基本上都有完整的第三方实现。例如：MySQL驱动 (opens new window)

# 下载依赖

go get -u github.com/go-sql-driver/mysql
1

# 使用MySQL驱动

func Open(driverName, dataSourceName string) (*DB, error)
1

Open打开一个dirverName指定的数据库，dataSourceName指定数据源，一般至少包括数据库文件名和其它连接必要的信息。

import (
	"database/sql"

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

func main() {
   // DSN:Data Source Name
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
	db, err := sql.Open("mysql", dsn)
	// defer db.Close()  不要写在这里
	if err != nil {
		panic(err)
	}
	defer db.Close()  // 注意这行代码要写在上面err判断的下面
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

思考题： 为什么上面代码中的defer db.Close()语句不应该写在if err != nil的前面呢？

因为有的第三方不怎么完善,当校验格式出错的时候db会返回空这个时候执行defer db.Close()就会直接报错，不会走到判断哪里。

# 初始化连接

Open函数只是验证其参数格式是否正确，实际上并不创建与数据库的连接。如果要检查数据源的名称是否真实有效，应该调用Ping方法。

返回的DB对象可以安全地被多个goroutine并发使用，并且维护其自己的空闲连接池。因此，Open函数应该仅被调用一次，很少需要关闭这个DB对象。

接下来，我们定义一个全局变量db，用来保存数据库连接对象。将上面的示例代码拆分出一个独立的initDB函数，只需要在程序启动时调用一次该函数完成全局变量db的初始化，其他函数中就可以直接使用全局变量db了。（注意下方的注意）

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql" // 为使用可以用匿名变量
	"time"
)

// 定义一个全局对象db 全局使用首字母大写
var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	// DSN:Data Source Name
	//dsn := "用户名:密码@tcp(地址:端口)/数据库名称?编码以及其他配置"
	dsn := "root:mysql@tcp(127.0.0.1:3306)/meiduo?charset=utf8mb4&parseTime=True"
	// 不会校验账号密码是否正确
	// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}

	// ！ 数值更具业务实际来确定
	db.SetConnMaxLifetime(time.Second * 10) // 单个连接的存活时间 秒
	db.SetMaxOpenConns(200)                 // 最大连接数
	db.SetMaxIdleConns(5)                   // 最大空闲连接数

	return nil
}

func main() {

	if err := initDB(); err != nil { // 调用输出化数据库的函数
		fmt.Printf("init db failed,err:%v\n", err)
		return
	}
	defer db.Close()
	fmt.Println("连接成功")
}

/*
连接成功

报错: init db failed,err:sql: unknown driver "mysql" (forgotten import?) 为安装mysql
*/
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

其中sql.DB是表示连接的数据库对象（结构体实例），它保存了连接数据库相关的所有信息。它内部维护着一个具有零到多个底层连接的连接池，它可以安全地被多个goroutine同时使用。

# SetMaxOpenConns（最大连接数）

SetMaxOpenConns设置与数据库建立连接的最大数目。 如果n大于0且小于最大闲置连接数，会将最大闲置连接数减小到匹配最大开启连接数的限制。 如果n<=0，不会限制最大开启连接数，默认为0（无限制）

func (db *DB) SetMaxOpenConns(n int)
1

# SetMaxIdleConns（限制最大连接数）

SetMaxIdleConns设置连接池中的最大闲置连接数。 如果n大于最大开启连接数，则新的最大闲置连接数会减小到匹配最大开启连接数的限制。 如果n<=0，不会保留闲置连接。

func (db *DB) SetMaxIdleConns(n int)
1

# SetConnMaxLifetime（单个连接的存活时间）

func (db *DB) SetConnMaxLifetime(d time.Duration)
1

单个连接的存活时间

# 增删改查

我们先在MySQL中创建一个名为sql_test的数据库

CREATE DATABASE sql_test;
1

进入该数据库:

use sql_test;
1

执行以下命令创建一张用于测试的数据表：

CREATE TABLE `user` (
    `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(20) DEFAULT '',
    `age` INT(11) DEFAULT '0',
    PRIMARY KEY(`id`)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;
1
2
3
4
5
6

# 查询

为了方便查询，我们事先定义好一个结构体来存储user表的数据。

type user struct {
	id   int
	age  int
	name string
}
1
2
3
4
5

# 单行查询

单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。（如：未找到结果）

func (db *DB) QueryRow(query string, args ...interface{}) *Row
1

具体示例代码：

// 查询单条数据示例
func queryRowDemo() {
	sqlStr := "select id, name, age from user where id=?"
	var u user
	// 非常重要：! 确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
	err := Db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
	if err != nil {
		fmt.Printf("scan failed, err:%v\n", err)
		return
	}
	fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
1
2
3
4
5
6
7
8
9
10
11
12

# 多行查询

多行查询db.Query()执行一次查询，返回多行结果（即Rows），一般用于执行select命令。参数args表示query中的占位参数。

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)
1

具体示例代码：

// 查询多条数据示例
func queryMultiRowDemo() {
	sqlStr := "select id, name, age from user where id > ?"
	rows, err := Db.Query(sqlStr, 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	// 非常重要：关闭rows释放持有的数据库链接
	defer rows.Close()

	// 循环读取结果集中的数据
	for rows.Next() {
		var u user
		err := rows.Scan(&u.id, &u.name, &u.age)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 插入数据

插入、更新和删除操作都使用Exec方法。

func (db *DB) Exec(query string, args ...interface{}) (Result, error)
1

Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数。

具体插入数据示例代码如下：

// 插入数据
func insertRowDemo() {
	sqlStr := "insert into user(name, age) values (?,?)"
	ret, err := Db.Exec(sqlStr, "王五", 39)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	theID, err := ret.LastInsertId() // 新插入数据的id
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert success, the id is %d.\n", theID)  // 总数
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 更新数据

插入、更新和删除操作都使用Exec方法。

func (db *DB) Exec(query string, args ...interface{}) (Result, error)
1

Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数。

具体更新数据示例代码如下：

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

# 删除数据

具体删除数据的示例代码如下：

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

# 示例

# main.go

package main

import (
	"fmt"
)

// 定义用户结构体
type user struct {
	id   int
	name string
	age  int
}

// 查询单条数据示例
func queryRowDemo() {
	sqlStr := "select id, name, age from user where id=?"
	var u user
	// 非常重要：! 确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
	err := Db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
	if err != nil {
		fmt.Printf("scan failed, err:%v\n", err)
		return
	}
	fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}

// 查询多条数据示例
func queryMultiRowDemo() {
	sqlStr := "select id, name, age from user where id > ?"
	rows, err := Db.Query(sqlStr, 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	// 非常重要：关闭rows释放持有的数据库链接
	defer rows.Close()

	// 循环读取结果集中的数据
	for rows.Next() {
		var u user
		err := rows.Scan(&u.id, &u.name, &u.age)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
	}
}

// 插入数据
func insertRowDemo() {
	sqlStr := "insert into user(name, age) values (?,?)"
	ret, err := Db.Exec(sqlStr, "王五", 39)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	theID, err := ret.LastInsertId() // 新插入数据的id
	if err != nil {
		fmt.Printf("get lastinsert ID failed, err:%v\n", err)
		return
	}
	fmt.Printf("insert success, the id is %d.\n", theID) // 总数
}

// 更新数据
func updateRowDemo() {
	sqlStr := "update user set age=? where id = ?"
	ret, err := Db.Exec(sqlStr, 99, 3)
	if err != nil {
		fmt.Printf("update failed, err:%v\n", err)
		return
	}
	n, err := ret.RowsAffected() // 操作影响的行数
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v\n", err)
		return
	}
	fmt.Printf("update success, affected rows:%d\n", n)
}

// 删除数据
func deleteRowDemo() {
	sqlStr := "delete from user where id = ?"
	ret, err := Db.Exec(sqlStr, 3)
	if err != nil {
		fmt.Printf("delete failed, err:%v\n", err)
		return
	}
	n, err := ret.RowsAffected() // 操作影响的行数
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v\n", err)
		return
	}
	fmt.Printf("delete success, affected rows:%d\n", n)
}

func main() {

	// 1. 连接mysql
	if err := InitDB(); err != nil { // 调用输出化数据库的函数
		fmt.Printf("init db failed,err:%v\n", err)
		return
	}
	defer Db.Close()
	fmt.Println("连接成功")
	// 查询单条语句
	queryRowDemo()
	// 查询多态语句
	queryMultiRowDemo()
	// 插入数据
	insertRowDemo()
	// 更新数据
	updateRowDemo()
	// 删除数据
	deleteRowDemo()
}

/*
连接成功

报错: init db failed,err:sql: unknown driver "mysql" (forgotten import?) 为安装mysql
*/
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

# utils_mysql.go

package main

import (
	"database/sql"
	_ "github.com/go-sql-driver/mysql" // 为使用可以用匿名变量，其实就是执行了Init()
	"time"
)

// Db 定义一个全局对象db 全局使用首字母大写
var Db *sql.DB

// InitDB 定义一个初始化数据库的函数
func InitDB() (err error) {
	// DSN:Data Source Name
	//dsn := "用户名:密码@tcp(地址:端口)/数据库名称?编码以及其他配置"
	dsn := "root:mysql@tcp(127.0.0.1:3306)/meiduo?charset=utf8mb4&parseTime=True"
	// 不会校验账号密码是否正确
	// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
	Db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = Db.Ping()
	if err != nil {
		return err
	}

	// ！ 数值更具业务实际来确定
	Db.SetConnMaxLifetime(time.Second * 10) // 单个连接的存活时间 秒
	Db.SetMaxOpenConns(200)                 // 最大连接数
	Db.SetMaxIdleConns(5)                   // 最大空闲连接数

	return nil
}
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
编辑 (opens new window)
通过反射修改结构体的变量
mysql预处理

← mysql预处理→

最近更新
01
配置yun源
05-24
02
linux-配置python虚拟环境
05-24
03
linux文件目录管理
05-24
更多文章>
Theme by Vdoing | Copyright © 2023-2023 yizhang | MIT License