• 周日. 6 月 16th, 2024

    Go语言操作MySQL

    root

    8 月 15, 2021

    一、连接

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

    我们常用的数据库基本上都有完整的第三方实现。如:https://github.com/go-sql-driver/mysql

    下载依赖, 打开命令行,定位到项目根目录。

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

    使用MySQL驱动

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

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

    package main
    import (
    package main
    
    import (
    	"database/sql"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    func main() {
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/studygo"
    	//Open函数可能只是验证其参数格式是否正确,实际上并不创建与数据库的连接。如果要检查数据源的名称是否真实有效,应该调用Ping方法
    	db, err := sql.Open("mysql", dsn)
    	if err != nil {
    		panic(err)
    	}
    	defer db.Close()  //注意这行代码要写在上面err判断的下面
    }

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

    如果连接出现错误,db是没有值的,这个时候再调用db.Close()会报错的。

    二、初始化连接

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

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

    package main
    
    import (
    	"database/sql"
    	"fmt"
    )
    
    //定义一个全局对象db
    var db *sql.DB
    
    //定义一个初始化数据库的函数
    func initDB() (err error) {
    	//DSN:Data Source Name
    	dsn := "user:password@tcp(127.0.0.1:3306)/studygo?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
    	}
    	return nil
    }
    
    func main() {
    	err := initDB()
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n", err)
    		return
    	}
    }
    

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

    SetMaxOpenConns

    func (db *DB) SetMaxOpenConns(n int)

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

    SetMaxIdleConns

    func (db *DB) SetMaxIdleConns(n int)

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

    三、 CRUD

    建库建表

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

    CREATE DATABASE sql_test;
    use sql_test;
    //新建一张表
    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;

    查询

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

    type user struct {
       id int
       age int
       name string
    }

    单行查询

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

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

    具体示例代码:

    package main
    //单行查询QueryRow
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    type user struct {
    	id int
    	name string
    	age int
    }
    
    func initDB() (err error) {
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	db, err = sql.Open("mysql", dsn)
    	if err != nil {
    		return err
    	}
    	err = db.Ping()
    	if err != nil {
    		return err
    	}
    	return nil
    }
    
    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 main() {
    	err := initDB()
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n", err)
    		return
    	}
    	queryRowDemo()
    }

    多行查询

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

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

    示例代码:

    package main
    
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    type User struct {
    	Id int `db:"id"`
    	Name string `db:"name"`
    	Age int `db:"age"`
    }
    
    func initDB() (err error) {
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	db, err = sql.Open("mysql", dsn)
    	if err != nil {
    		return err
    	}
    	err = db.Ping()
    	if err != nil {
    		return err
    	}
    	return nil
    }
    
    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 main() {
    	err := initDB()
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n",err)
    	}
    	queryMultiRowDemo()
    }
    

    插入数据

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

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

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

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

    package main
    
    import (
       "database/sql"
       "fmt"
       _ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    type User struct {
       Id int `db:"id"`
       Name string `db:"name"`
       Age int `db:"age"`
    }
    
    func initDB() (err error) {
       dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
       db, err = sql.Open("mysql", dsn)
       if err != nil {
          return err
       }
       err = db.Ping()
       if err != nil {
          return err
       }
       return nil
    }
    
    func main() {
       err := initDB()
       if err != nil {
          fmt.Printf("init db failed, err:%v\n", err)
          return
       }
       insertRowDemo()
       queryMultiRowDemo()  //调用以边查询的示例方法
    }
    
    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
       }
       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)
    }

    更新数据

    //更新数据
    package main
    
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    type User struct {
    	Id int `db:"id"`
    	Name string `db:"name"`
    	Age int `db:"age"`
    }
    
    func main() {
    	err := initDB()
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n", err)
    		return
    	}
    	updateRowDemo()
    }
    
    func updateRowDemo() {
    	sql := "update user set age=? where id=?"
    	ret, err := db.Exec(sql, 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)
    }
    
    
    func initDB() (err error){
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	db, err = sql.Open("mysql", dsn)
    	if err != nil{
    		return err
    	}
    	err = db.Ping()
    	if err != nil {
    		return err
    	}
    	return nil
    }
    
    

    删除数据

    package main
    
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    func main() {
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	var err error
    	db, err = sql.Open("mysql", dsn)
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n",err)
    		return
    	}
    	err = db.Ping()
    	if err != nil {
    		fmt.Printf("ping err:%v\n",err)
    		return
    	}
    	deleteRowDemo()
    }
    
    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 RowsAffect failed, err:%v\n", err)
    		return
    	}
    	fmt.Printf("delete success, affected rows:%d\n",n)
    }
    

    四、MySQL预处理

    什么是预处理?

    普通SQL语句执行过程:
    1. 客户端对SQL语句进行占位符替换得到完整的SQL语句。
    2. 客户端发送完整SQL语句到MySQL服务器
    3. MySQL服务端执行完整的SQL语句并将结果返回给客户端

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

    为什么要预处理?

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

    Go实现MySQL预处理

    database/sql 中使用下面的Prepare方法来实现预处理操作

    func (db *DB) Prepare(query string) (*Stmt, error)

    Prepare方法会先将sql语句发送给MySQL服务端,返回一个准备好的状态用于之后的查询和命令。返回值可以同时执行多个查询和命令。

    查询操作的预处理示例代码如下:

    package main

    import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    )

    var db *sql.DB

    type User struct {
    Id int `db:"id"`
    Name string `db:"name"`
    Age int `db:"id"`
    }

    func main() {
    dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    var err error
    db, err = sql.Open("mysql", dsn)
    if err != nil {
    fmt.Printf("init db failed, err:%v\n", err)
    return
    }
    err = db.Ping()
    if err != nil {
    fmt.Printf("ping err:%v\n",err)
    return
    }
    prepareQueryDemo()
    }

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

    插入、更新和删除操作的预处理十分类似,这里以插入操作的预处理为例:

    package main
    
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    func main() {
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	var err error
    	db, err = sql.Open("mysql", dsn)
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n",err)
    		return
    	}
    	prepareInsertDemo()
    }
    
    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")
    }
    
    
    不同数据库中,SQL语句使用的占位符不相同

    五、Go实现MySQL事务

    什么是事务

    事务:一个最小的不可再分的工作单元;通常一个事务对应一个完整的业务(例如银行账户转账业务,该业务就是一个最小的工作单元),同时这个完整的业务需要执行多次的DML(insert, update, delete)语句共同联合完成。A转账给B,这里面就需要执行两次update操作。

    在MySQL中只用使用了InnoDB数据库引擎的数据库或表才支持事务。事务处理可以用来维护数据库的完整性, 保证成批SQL语句要么全部执行,要么全部不执行。

    事务的ACID

    通常事务必须满足4个条件(ACID): 原子性(Atomicity,或称不可分割性)、一致性(Consistency)、隔离性(Isolation,又称独立性)、持久性(Durability)。

    事务相关方法

    func (db *DB) Begin() (*Tx, error)
    func (tx *Tx) Commit() error  
    func (tx *Tx) Rollback() error    //回滚事务

    事务示例:

    package main
    
    import (
    	"database/sql"
    	"fmt"
    	_ "github.com/go-sql-driver/mysql"
    )
    
    var db *sql.DB
    
    func main() {
    	var err error
    	dsn := "root:lpfukia@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
    	db, err = sql.Open("mysql", dsn)
    	if err != nil {
    		fmt.Printf("init db failed, err:%v\n", err)
    		return
    	}
    	transactionDemo()
    }
    
    func transactionDemo() {
    	tx, err := db.Begin() //开启事务
    	if err != nil {
    		if tx != nil {
    			tx.Rollback() //回滚
    		}
    		fmt.Printf("begin trans failed, err:%v\n",err)
    		return
    	}
    	sqlStr := "update user set age=300 where id=?"
    	ret, err := tx.Exec(sqlStr, 2)
    	if err != nil {
    		tx.Rollback()
    		fmt.Printf("exec sql failed, err:%v\n", err)
    		return
    	}
    	affRow, err := ret.RowsAffected()
    	if err != nil {
    		tx.Rollback()
    		fmt.Printf("exec ret.RowsAffected() failed, err:%v\n", err)
    		return
    	}
    	sqlStr2 := "update user set age=400 where id=?"
    	ret2, err := tx.Exec(sqlStr2, 5)
    	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 ret2.RowsAffected() failed, err:%v\n", err)
    		return
    	}
    	fmt.Println(affRow, affRow2)
    	if affRow == 1 && affRow2 == 1 {
    		fmt.Println("事务提交啦...")
    		tx.Commit()
    	} else {
    		tx.Rollback()
    		fmt.Println("事务回滚了")
    	}
    	fmt.Println("exec trans success!")
    }
    

    root