Go连接Mysql

GO操作Mysql

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

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

下载依赖：go get -u github.com/go-sql-driver/mysql

导入包问题解析

// _ : 匿名 导入，  import 的时候会自动的执行   驱动的Init()方法
	_ "github.com/go-sql-driver/mysql"

数据库连接 基本 案例

func main() {
	// DSN:Data Source Name
	dsn := "user:pass@tcp(127.0.0.1:3306)/db"
	//Open  函数只是校验   dsn  的查数是否正确，  并不会连接数据库
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}
	//如果  出错了， 就没有 db 会造成 空指针异常
	defer db.Close() // 注意这行代码要写在上面err判断的下面
	fmt.Println("连接成功？？？")

	//尝试与数据库进行连接
	err = db.Ping()
	if err != nil {
		fmt.Println("数据库连接失败", err)
		return
	}
	fmt.Println("数据库连接成功.....")
}

进行 初始化封装

var db *sql.DB

func initMysql() (err error) {

	// DSN:Data Source Name
	dsn := "user:pass@tcp(127.0.0.1:3306)/db"
	//Open  函数只是校验   dsn  的查数是否正确，  并不会连接数据库
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}

	fmt.Println("连接成功？？？")

	//尝试与数据库进行连接
	err = db.Ping()
	if err != nil {
		fmt.Println("数据库连接失败", err)
		return
	}
	return
}

func main() {
	if err := initMysql(); err != nil {
		fmt.Println("数据库连接失败", err)
	}
	
	// 注意这个  defer 关闭的  需要  拿出来
	defer db.Close()
	fmt.Println("数据库连接成功....")
}

最大连接数和空闲连接设置

func (db *DB) SetMaxOpenConns(n int)

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

SetMaxIdleConns

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

go 代码

var db *sql.DB

func initMysql() (err error) {
	db.SetConnMaxLifetime(time.Second * 10) 
	db.SetMaxOpenConns(200) //  最大连接数
	db.SetConnMaxIdleTime(10) //   最大空闲连接数
	return
}

增删改查

单行查询

数据库 文件

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;



insert into  user  (name, age)  values("salary", 24)

go 代码

注意：
//执行查询语句, QueryRow执行完之后一定要调用 Scan 方法（会自动关闭 连接）
row := db.QueryRow(sqlStr, 1)
//将数据取出赋值到 user 结构体中的变量中
err := row.Scan(&u.id, &u.age, &u.name)

type User struct {
	id   int
	age  int
	name string
}

// 单行查询
func queryRowDemo() {
	sqlStr := "select  id,  age, name  from user  where id = ?"
	var u User

	//执行查询语句, QueryRow执行完之后一定要调用  Scan 方法（会自动关闭  连接）
	row := db.QueryRow(sqlStr, 1)
	//将数据取出赋值到  user  结构体中的变量中
	err := row.Scan(&u.id, &u.age, &u.name)
	if err != nil {
		fmt.Println("scan  filed  fail", err)
		return
	}
	fmt.Printf("id: %d,   age: %d ,  name:%s", u.id, u.age, u.name)
}

func main() {
	if err := initMysql(); err != nil {
		fmt.Println("数据库连接失败", err)
	}

	defer db.Close()
	fmt.Println("数据库连接成功....")
	queryRowDemo()
}

多行查询

多行查询 db.Query()

注意： // 非常重要：关闭rows释放持有的数据库链接
defer rows.Close()

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)
	}
}

插入数据

go代码

// 插入数据
func insertRowDemo() {
	sqlStr := "insert into user(name, age) values (?,?)"
	ret, err := db.Exec(sqlStr, "王五", 38)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	//  最后一个插入的id
	var  theID  int64
	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)
}

更新数据

go代码

// 更新数据
func updateRowDemo() {
	sqlStr := "update user set age=? where id = ?"
	ret, err := db.Exec(sqlStr, 39, 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)
}

删除数据

go代码

// 删除数据
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)

MySql 预处理

什么是预处理？
普通SQL语句执行过程：

• 客户端对SQL语句进行占位符替换得到完整的SQL语句。
• 客户端发送完整SQL语句到MySQL服务端
• MySQL服务端执行完整的SQL语句并将结果返回给客户端。

预处理执行过程：

1. 把SQL语句分成两部分，命令部分与数据部分。
2. 先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。
3. 然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。
4. MySQL服务端执行完整的SQL语句并将结果返回给客户端。

为什么要预处理？
1.优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。
2.避免SQL注入问题。

查询预处理

// 预处理查询示例
func prepareQueryDemo() {
	sqlStr := "select id, name, age from user where id > ?"
	stmt, err := db.Prepare(sqlStr)
	if err != nil {
		fmt.Printf("prepare failed, err:%v\n", err)
		return
	}
	defer stmt.Close()
	rows, err := stmt.Query(0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	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 prepareInsertDemo() {
	sqlStr := "insert into user(name, age) values (?,?)"
	stmt, err := db.Prepare(sqlStr)
	if err != nil {
		fmt.Printf("prepare failed, err:%v\n", err)
		return
	}
	defer stmt.Close()
	_, err = stmt.Exec("小王子", 18)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	_, err = stmt.Exec("沙河娜扎", 18)
	if err != nil {
		fmt.Printf("insert failed, err:%v\n", err)
		return
	}
	fmt.Println("insert success.")
}

Go 实现MySql事务

Go语言中使用以下三个方法实现MySQL中的事务操作。

开始事务

func (db *DB) Begin() (*Tx, error)

提交事务

func (tx *Tx) Commit() error

回滚事务

func (tx *Tx) Rollback() error

事务案例

// 事务操作示例
func transactionDemo() {
	tx, err := db.Begin() // 开启事务
	if err != nil {
		if tx != nil {
			tx.Rollback() // 回滚
		}
		fmt.Printf("begin trans failed, err:%v\n", err)
		return
	}
	sqlStr1 := "Update user set age=30 where id=?"
	ret1, err := tx.Exec(sqlStr1, 2)
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec sql1 failed, err:%v\n", err)
		return
	}
	affRow1, err := ret1.RowsAffected()
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
		return
	}

	sqlStr2 := "Update user set age=40 where id=?"
	ret2, err := tx.Exec(sqlStr2, 3)
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec sql2 failed, err:%v\n", err)
		return
	}
	affRow2, err := ret2.RowsAffected()
	if err != nil {
		tx.Rollback() // 回滚
		fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
		return
	}

	fmt.Println(affRow1, affRow2)
	if affRow1 == 1 && affRow2 == 1 {
		fmt.Println("事务提交啦...")
		tx.Commit() // 提交事务
	} else {
		tx.Rollback()
		fmt.Println("事务回滚啦...")
	}

	fmt.Println("exec trans success!")
}

参考链接