Go 操作 Mysql（三）

什么是事务？

事务是数据库非常重要的部分，它具有四大特性（原子性、一致性、隔离性、持久性）

以下内容出自《高性能MySQL》第三版，了解事务的ACID及四种隔离级有助于我们更好的理解事务运作。

下面举一个银行应用是解释事务必要性的一个经典例子。假如一个银行的数据库有两张表：支票表（checking）和储蓄表（savings）。现在要从用户Jane的支票账户转移200美元到她的储蓄账户，那么至少需要三个步骤：

1. 检查支票账户的余额高于或者等于200美元。
2. 从支票账户余额中减去200美元。
3. 在储蓄帐户余额中增加200美元。

上述三个步骤的操作必须打包在一个事务中，任何一个步骤失败，则必须回滚所有的步骤。

一个很好的事务处理系统，必须具备这些标准特性：

• 原子性（atomicity）

一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作，这就是事务的原子性

• 一致性（consistency）

数据库总是从一个一致性的状态转换到另一个一致性的状态。（在前面的例子中，一致性确保了，即使在执行第三、四条语句之间时系统崩溃，支票账户中也不会损失200美元，因为事务最终没有提交，所以事务中所做的修改也不会保存到数据库中。）

• 隔离性（isolation）

通常来说，一个事务所做的修改在最终提交以前，对其他事务是不可见的。（在前面的例子中，当执行完第三条语句、第四条语句还未开始时，此时有另外的一个账户汇总程序开始运行，则其看到支票帐户的余额并没有被减去200美元。）

• 持久性（durability）

一旦事务提交，则其所做的修改会永久保存到数据库。（此时即使系统崩溃，修改的数据也不会丢失。）

Tx 对象

database/sql 提供了事务处理的功能，通过 Tx 类型实现

之前在增删改查操作中使用的都是 sqlx.DB 类型对象，而事务则使用的是 Tx 类型对象，使用 DB.Begin() 方法可以创建 Tx 类型对象，Tx 类型对象也可以调用 Exec() 和 Query() 等方法执行数据库操作，用法和之前操作一样，但是需要在操作完毕后执行 Tx 的 Commit() 或 Rollback() 方法完成数据库事务的提交或回滚，同时释放连接

一旦调用 Begin() 方法，Tx 类型对象就会从连接池中获取一个空闲的连接，接下来的 sql 执行都基于这个连接，直到 commit 或 rollback 后才释放到连接池

Tx 类型对象拥有的方法如下：

在事务处理的时候，不能使用 DB 类型对象的方法去执行 sql 语句，当然如果使用也能执行成功，但是这和你在事务里执行的操作不属于一个事务（隔离性），将不会接受 commit 或 rollback 的改变，如下面的操作时：

demo：下面这个伪代码中，调用Db.Exec() 方法的时候，和 Tx 执行 Exec() 方法是不同的，只有 Tx 的操作会绑定到事务中，Db 则是额外的一个连接，两者不属于同一个事务

Tx,err := Db.Begin()
Db.Exec()
Tx.Exec()
Tx.Commit()

　　

事务并发

对于 sqlx.DB 类型对象，调用了 Query() 方法之后，在 Next() 方法中获取结果的时候，rows 是维护了一个连接，再次调用 QueryRow() 方法的时候，DB 类型对象会再从连接池取出一个新的连接给到查询结果 row，row 和 rows 的连接，两者可以共存，并且互相不影响

for rows.Next() {
	//定义变量接收查询数据
	var uid int
	var create_time, username, password, department, email string

	err := rows.Scan(&uid, &create_time, &username, &password, &department, &email)
	if err != nil {
		fmt.Println("get data failed, error:[%v]", err.Error())
	}
	fmt.Println(uid, create_time, username, password, department, email)

	row := Db.QueryRow("select * from userinfo where uid = 1")
	err = row.Scan(&uid, &create_time, &username, &password, &department, &email)
	if err != nil {
		fmt.Printf("scan failed, error:[%v]", err.Error())
		return
	}
	fmt.Println(uid, create_time, username, password, department, email)
}

//关闭结果集（释放连接）
rows.Close()

运行结果：
1 2019-07-06 11:45:20 anson 123456 技术部 123456@163.com
1 2019-07-06 11:45:20 anson 123456 技术部 123456@163.com
3 2019-07-06 11:45:20 johny 123456 技术部 123456@163.com
1 2019-07-06 11:45:20 anson 123456 技术部 123456@163.com
4 2019-07-06 11:45:20 johny 123456 技术部 123456@163.com
1 2019-07-06 11:45:20 anson 123456 技术部 123456@163.com

对于 sql.Tx 类型对象，因为事务过程只有一个连接，事务内的操作都是顺序执行的，在开始下一个数据库交互之前，必须先完成上一个数据库交互

demo：Tx 执行了 Query() 方法后，rows 维护了数据库连接，然后 Tx 尝试调用 QueryRow 将尝试获取该连接进行数据库操作，因为还没有调用 rows.Close() 方法（事务还没有结束），因此连接属于 busy 状态，Tx 类型对象是无法再从连接池获取连接的

rows, err := Tx.Query("select * from userinfo")
if err != nil {
	fmt.Printf("query faied, error:[%v]", err.Error())
	return
}
for rows.Next() {
	//定义变量接收查询数据
	var uid int
	var create_time, username, password, department, email string

	err := rows.Scan(&uid, &create_time, &username, &password, &department, &email)
	if err != nil {
		fmt.Println("get data failed, error:[%v]", err.Error())
	}
	fmt.Println(uid, create_time, username, password, department, email)

	row := Tx.QueryRow("select * from userinfo where uid = 1")
        //在这里获取数据库连接报错
	err = row.Scan(&uid, &create_time, &username, &password, &department, &email)
	if err != nil {
		fmt.Printf("scan failed, error:[%v]", err.Error())
		return
	}
	fmt.Println(uid, create_time, username, password, department, email)
}

//关闭结果集（释放连接）
rows.Close()

运行结果：
1 2019-07-06 11:45:20 anson 123456 技术部 123456@163.com
scan failed, error:[driver: bad connection][mysql] 2019/07/09 22:52:07 packets.go:446: busy buffer

　　

实例（加强理解）

通过下面完整的例子能够更好的理解

demo：

1. 定义了一个 clearTransaction(Tx) 函数，该函数会执行 rollback 操作，因为在事物处理的过程中，任何一个错误都会导致 main 函数退出，因此在 main 函数退出时执行 defer 的 rollback 操作，回滚事务和释放连接
2. 如果不添加 defer 来回滚事务和释放连接，只在最后 commit 或 rollback，那么当 doSomething 发生异常的时候，函数就退出了，此时还没有执行到 commit 操作，这样就导致该事务的连接没有关闭，事务也没有回滚
3. Tx 事务环境中，只有一个数据库连接，事务内的 Exec() 方法都是依次执行的，事务中也可以使用 DB 进行查询，但是 DB 查询的过程会新建连接，不属于 Tx 这个事务

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

var (
	userName  string = "chenkai"
	password  string = "chenkai"
	ipAddrees string = "192.168.0.115"
	port      int    = 3306
	dbName    string = "test"
	charset   string = "utf8"
)

func connectMysql() (*sqlx.DB) {
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s", userName, password, ipAddrees, port, dbName, charset)
	Db, err := sqlx.Open("mysql", dsn)
	if err != nil {
		fmt.Printf("mysql connect failed, detail is [%v]", err.Error())
	}
	return Db
}

func updateData(Db *sqlx.DB) {
	Tx, err := Db.Begin()
	if err != nil {
		fmt.Printf("open the transaction failed, error:[%v]", err.Error())
		return
	}
	//回滚处理
	defer clearTransaction(Tx)

	result, err := Tx.Exec("update userinfo set username = 'honey' where uid = 1")
	if err != nil {
		fmt.Printf("update failed, error:[%v]", err.Error())
		return
	}
	rowAffected, _ := result.RowsAffected()
	fmt.Printf("affected rows:[%v]\n", rowAffected)

	result, err = Tx.Exec("update userinfo set username = 'honey' where uid = 3")
	if err != nil {
		fmt.Printf("update failed, error:[%v]", err.Error())
		return
	}
	rowAffected, _ = result.RowsAffected()
	fmt.Printf("affected rows:[%v]\n", rowAffected)

	//主动 panic
	doSomething()

	//提交事务
	err = Tx.Commit()
	if err != nil {
		// tx.Rollback() 此时处理错误，会忽略 doSomthing 的异常
		fmt.Printf("commit failed, error:[%v]", err.Error())
	}
}

func clearTransaction(Tx *sql.Tx) {
	//尝试进行 rollback，若 Tx 已经关闭，则不作处理
	err := Tx.Rollback()
	if err != sql.ErrTxDone && err != nil {
		fmt.Printf("tx rollback failed, error:[%v]", err.Error())
	}
}

func doSomething(){
	panic("a panic running error")
}

func main() {
	var Db *sqlx.DB = connectMysql()
	defer Db.Close()

	updateData(Db)
}

运行结果：
affected rows:[1]
affected rows:[1]
panic: a panic running error

ending ~