go的mysql預處理和mysql事物

what is mysql預處理？

普通SQL語句執行過程：
    1.客戶端對SQL語句進行占位符替換得到完整的SQL語句。
    2.客戶端發送完整SQL語句到MySQL服務端
    3.MySQL服務端執行完整的SQL語句並將結果返回給客戶端。
	
預處理執行過程：
    1.把SQL語句分成兩部分，命令部分與數據部分。
    2.先把命令部分發送給MySQL服務端，MySQL服務端進行SQL預處理。
    3.然后把數據部分發送給MySQL服務端，MySQL服務端對SQL語句進行占位符替換。
    4.MySQL服務端執行完整的SQL語句並將結果返回給客戶端
	批量的插入、批量的查詢，sql語句的變化不大，僅僅是占位符的變化，這時候適合使用預處理
	
好處：
    1.提高性能，一次編譯，多次使用
	2.避免sql注入

go的mysql預處理

func (db *DB) Prepare(query string) (*Stmt, error)
Prepare方法會先將sql語句發送給MySQL服務端，返回一個准備好的狀態用於之后的查詢和命令。返回值可以同時執行多個查詢和命令
// 預處理查詢示例
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.")
}

sql注入

請記住：永遠不要相信用戶的輸入

// sql注入示例
func sqlInjectDemo(name string) {
	sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name)
	fmt.Printf("SQL:%s\n", sqlStr)
	var u user
	err := db.QueryRow(sqlStr).Scan(&u.id, &u.name, &u.age)
	if err != nil {
		fmt.Printf("exec failed, err:%v\n", err)
		return
	}
	fmt.Printf("user:%#v\n", u)
}

sqlInjectDemo("xxx' or 1=1#")  // or 1=1為真，#表示注釋后面的內容
sqlInjectDemo("xxx' union select * from user #")  // union 連表查詢所有用戶數據，#表示注釋后面的內容
sqlInjectDemo("xxx' and (select count(*) from user) <10 #")

sql語句占位符

MySQL             ?
PostgreSQL        $1, $2等
SQLite            ? 和$1
Oracle            :name

go語言的mysql的事物

事務：一個最小的不可再分的工作單元；通常一個事務對應一個完整的業務(例如銀行賬戶轉賬業務，該業務就是一個最小的工作單元)
MySQL中只有使用了Innodb數據庫引擎的數據庫或表才支持事務
通常事務必須滿足4個條件（ACID）：原子性（Atomicity，或稱不可分割性）、一致性（Consistency）、隔離性（Isolation，又稱獨立性）、持久性（Durability）

原子性：一個事務（transaction）中的所有操作，要么全部完成，要么全部不完成，不會結束在中間某個環節。事務在執行過程中發生錯誤，會被回滾（Rollback）到事務開始前的狀態，就像這個事務從來沒有執行過一樣  
一致性：在事務開始之前和事務結束以后，數據庫的完整性沒有被破壞。這表示寫入的資料必須完全符合所有的預設規則，這包含資料的精確度、串聯性以及后續數據庫可以自發性地完成預定的工作。   
隔離性：數據庫允許多個並發事務同時對其數據進行讀寫和修改的能力，隔離性可以防止多個事務並發執行時由於交叉執行而導致數據的不一致。事務隔離分為不同級別，包括讀未提交（Read uncommitted）、讀提交（read committed）、可重復讀（repeatable read）和串行化（Serializable）。   
持久性：事務處理結束后，對數據的修改就是永久的，即便系統故障也不會丟失。  

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