GO通過sqlx庫操作MySQL

sqlx介紹

sqlx可以認為是Go語言內置database/sql的超集，它在優秀的內置database/sql基礎上提供了擴展功能。這些擴展中除了大家常用來查詢的Get(dest interface{}, ...) error和Select(dest interface{}, ...) error外還有很多其他強大的功能。

sqlx庫地址

github.com/jmoiron/sqlx

連接數據庫示例

package main

import (
	"fmt"

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

var db *sqlx.DB

func initDB() (err error) {
	dsn := "ruan:password@tcp(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True"
	// Connect包含了open和ping方法，也可以使用MustConnect連接不成功就panic
	db, err = sqlx.Connect("mysql", dsn)
	if err != nil {
		fmt.Printf("connect DB failed, err:%v\n", err)
		return
	}

	db.SetMaxOpenConns(200)
	db.SetMaxIdleConns(10)
	return
}

func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init DB failed, err:%v\n", err)
		return
	}
	fmt.Println("init DB success...")
}

基本使用

查

type user struct {	// 結構體打tag，數據庫對應字段
	ID   int    `db:"id"` // 同類型放一起對內存地址更有順序
	Age  int    `db:"age"` 
	Name string `db:"name"`
}

// 查詢單條數據示例 結構體，Get
func queryRowDemo() {
	sqlStr := "select id, name, age from user where id=?"
	var u user
	err := db.Get(&u, sqlStr, 1) // 結構體接受指針， 查詢語句， 占位符值
	if err != nil {
		fmt.Printf("get failed err:%v\n", err)
		return
	}
	fmt.Printf("id:%d name:%s age:%d\n", u.ID, u.Name, u.Age)

}

// 查詢多條數據示例 切片，Select
func queryMultiRowDemo() {
	sqlStr := "select id, name, age from user where id > ?"
	var users []user
	err := db.Select(&users, sqlStr, 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	fmt.Printf("users:%#v\n", users)
}

增

sqlx中的exec方法與原生sql中的exec使用基本一致

// 插入數據 Exec
func insertRowDemo() {
	sqlStr := "insert into user(name, age) values (?,?)"
	ret, err := db.Exec(sqlStr, "朝陽", 18)
	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)
}

改

sqlx中的exec方法與原生sql中的exec使用基本一致

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

刪

sqlx中的exec方法與原生sql中的exec使用基本一致

// 刪除數據 Exec
func deleteRowDemo() {
	sqlStr := "delete from user where id = ?"
	ret, err := db.Exec(sqlStr, 2)
	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)
}

NamedQuery

NamedQuery方法用來綁定SQL語句與結構體或map中的同名字段, 查詢。

// NamedQuery :name
func namedQuery() {
	sqlStr := "SELECT * FROM user WHERE name=:name"
	// 使用map做命名查詢
	rows, err := db.NamedQuery(sqlStr, map[string]interface{}{"name": "西瓜"})
	if err != nil {
		fmt.Printf("db.NamedQuery failed, err:%v\n", err)
		return
	}
	defer rows.Close()
	for rows.Next() {
		var u user
		err := rows.StructScan(&u)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			continue
		}
		fmt.Printf("user:%#v\n", u)
	}

	// 使用結構體命名查詢，根據結構體字段的 db tag進行映射
	u := user{
		Name: "西瓜",
	}
	rows, err = db.NamedQuery(sqlStr, u)
	if err != nil {
		fmt.Printf("db.NamedQuery failed, err:%v\n", err)
		return
	}
	defer rows.Close()
	for rows.Next() {
		var u user
		err := rows.StructScan(&u)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			continue
		}
		fmt.Printf("user:%#v\n", u)
	}
}

NamedExec

NamedExec方法用來綁定SQL語句與結構體或map中的同名字段。

// NamedExec :name :age
func insertUserDemo() (err error) {
	sqlStr := "INSERT INTO user (name,age) VALUES (:name,:age)"

	// 使用map做命名插入
	_, err = db.NamedExec(sqlStr,
		map[string]interface{}{
			"name": "西瓜",
			"age":  23,
		})
	if err != nil {
		fmt.Printf("db.NamedExec failed, err:%v\n", err)
		return
	}

	// 使用結構體命名插入，根據結構體字段的 db tag進行映射
	u := user{
		Name: "西瓜",
		Age:  18,
	}
	_, err = db.NamedExec(sqlStr, u)
	if err != nil {
		fmt.Printf("db.NamedExec failed, err:%v\n", err)
		return
	}
	return 
}

事務操作

對於事務操作，我們可以使用sqlx中提供的db.Beginx()和tx.Exec()方法。

// 事務操作
func transactionDemo() (err error) {
	tx, err := db.Beginx() // 開啟事務
	if err != nil {
		fmt.Printf("begin trans failed, err:%v\n", err)
		return err
	}
	defer func() {
		if p := recover(); p != nil {
			tx.Rollback()
			panic(p) // 回滾后，panic
		} else if err != nil {
			fmt.Println("rollback")
			tx.Rollback() // err為非零，不要改變它
		} else {
			err = tx.Commit() // err is nil，如果Commit返回錯誤更新錯誤
			fmt.Println("commit")
		}
	}()

	sqlStr1 := "Update user set age=23 where id=?"

	rs, err := tx.Exec(sqlStr1, 1)
	if err != nil {
		return err
	}
	n, err := rs.RowsAffected()
	if err != nil {
		return err
	}
	if n != 1 {
		return errors.New("exec sqlStr1 failed")
	}
	sqlStr2 := "Update user set age=18 where id=?"
	rs, err = tx.Exec(sqlStr2, 3)
	if err != nil {
		return err
	}
	n, err = rs.RowsAffected()
	if err != nil {
		return err
	}
	if n != 1 {
		return errors.New("exec sqlStr2 failed")
	}
	return err
}

sqlx.In

sqlx.In是sqlx提供的一個非常方便的函數。

sqlx.In的批量插入

bindvars（綁定變量）

查詢占位符?在內部稱為bindvars（查詢占位符）,它非常重要。你應該始終使用它們向數據庫發送值，因為它們可以防止SQL注入攻擊。database/sql不嘗試對查詢文本進行任何驗證；它與編碼的參數一起按原樣發送到服務器。除非驅動程序實現一個特殊的接口，否則在執行之前，查詢是在服務器上准備的。因此bindvars是特定於數據庫的:

• MySQL中使用?
• PostgreSQL使用枚舉的$1、$2等bindvar語法
• SQLite中?和$1的語法都支持
• Oracle中使用:name的語法

bindvars的一個常見誤解是，它們用來在sql語句中插入值。它們其實僅用於參數化，不允許更改SQL語句的結構。例如，使用bindvars嘗試參數化列或表名將不起作用：

// ？不能用來插入表名（做SQL語句中表名的占位符）
db.Query("SELECT * FROM ?", "mytable")
 
// ？也不能用來插入列名（做SQL語句中列名的占位符）
db.Query("SELECT ?, ? FROM people", "name", "location")

拼接語句實現批量插入

type user struct {
	ID   int    `db:"id"` // 同類型放一起對內存地址更有順序
	Age  int    `db:"age"`
	Name string `db:"name"`
}

// BatchInsertUsers 自行構造批量插入的語句
func BatchInsertUsers(users []*user) error {
   // 存放 (?, ?) 的slice
   valueStrings := make([]string, 0, len(users))
   // 存放values的slice
   valueArgs := make([]interface{}, 0, len(users)*2)
   // 遍歷users准備相關數據
   for _, u := range users {
      // 此處占位符要與插入值的個數對應
      valueStrings = append(valueStrings, "(?, ?)")
      valueArgs = append(valueArgs, u.Name)
      valueArgs = append(valueArgs, u.Age)
   }
   // 自行拼接要執行的具體語句
   stmt := fmt.Sprintf("INSERT INTO user (name, age) VALUES %s",
      strings.Join(valueStrings, ","))
   _, err := db.Exec(stmt, valueArgs...)
   return err
}
func main() {
	if err := initDB(); err != nil {
		fmt.Printf("init DB failed, err:%v\n", err)
		return
	}
	u1 := user{Name: "西瓜", Age: 18}
	u2 := user{Name: "yy", Age: 23}
	u3 := user{Name: "kk", Age: 24}
	users := []*user{&u1, &u2, &u3}
    err = BatchInsertUsers(users)
    if err != nil {
    	fmt.Printf("BatchInsertUsers failed, err:%v\n", err)
	}
}

sqlx.In實現批量插入

前提是需要我們的結構體實現driver.Valuer接口：

func (u user) Value() (driver.Value, error) {
	return []interface{}{u.Name, u.Age}, nil
}

sqlx.In實現批量插入代碼

// BatchInsertUsers2 使用sqlx.In幫我們拼接語句和參數, 注意傳入的參數是[]interface{}
func BatchInsertUsers2(users []interface{}) error {
	query, args, _ := sqlx.In(
		"INSERT INTO user (name, age) VALUES (?), (?), (?)",
		users..., // 如果arg實現了 driver.Valuer, sqlx.In 會通過調用 Value()來展開它
	)
	fmt.Println(query) // 查看生成的querystring  // INSERT INTO user (name, age) VALUES (?, ?), (?, ?), (?, ?)
	fmt.Println(args)  // 查看生成的args // [西瓜 18 yy 23 kk 24]
	_, err := db.Exec(query, args...)
	return err
}


func main() {
	u1 := user{Name: "西瓜", Age: 18}
	u2 := user{Name: "yy", Age: 23}
	u3 := user{Name: "kk", Age: 24}
	users := []interface{}{u1, u2, u3}
	err = BatchInsertUsers2(users)
    if err != nil {
    	fmt.Printf("BatchInsertUsers2 failed, err:%v\n", err)
	}
}

NamedExec實現批量插入

注意 ：該功能需github.com/jmoiron/sqlx1.3.1版本以上，sql語句最后不能空格和;

// BatchInsertUsers3 使用NamedExec實現批量插入
func BatchInsertUsers3(users []*user) error {
	_, err := db.NamedExec("INSERT INTO user (name, age) VALUES (:name, :age)", users)
	return err
}



u1 := user{Name: "西瓜", Age: 18}
u2 := user{Name: "yy", Age: 23}
u3 := user{Name: "kk", Age: 24}
users := []*user{&u1, &u2, &u3}
err = BatchInsertUsers3(users)
if err != nil {
    fmt.Printf("BatchInsertUsers3 failed, err:%v\n", err)
}

sqlx.In的查詢

sqlx查詢語句中實現In查詢和FIND_IN_SET函數。即實現SELEC * FROM user WHERE id in (3, 2, 1);和SELECT * FROM user WHERE id in (3, 2, 1) ORDER BY FIND_IN_SET(id, '3,2,1');。

in查詢

// QueryByIDs 根據給定ID查詢
func QueryByIDs(ids []int) (users []user, err error) {
	// 動態填充id
	query, args, err := sqlx.In("SELECT id, name, age FROM user WHERE id IN (?)", ids)
	if err != nil {
		return
	}
	// sqlx.In 返回帶 `?` bindvar的查詢語句, 我們使用Rebind()重新綁定它
	query = db.Rebind(query)

	err = db.Select(&users, query, args...)
	return
}

func main() {
	users, err := QueryByIDs([]int{1, 6, 3, 4}) // 無法自定義順序，默認id從小到大順序
	if err != nil {
		fmt.Printf("QueryByIDs failed, err:%v\n", err)
		return
	}
	for _, user := range users {
		fmt.Printf("user:%#v\n", user)
	}
}

in查詢和FIND_IN_SET函數(給定順序)

查詢id在給定id集合的數據並維持給定id集合的順序。

// QueryAndOrderByIDs 按照指定id查詢並維護順序
func QueryAndOrderByIDs(ids []int) (users []user, err error) {
	// 動態填充id
	strIDs := make([]string, 0, len(ids))
	for _, id := range ids {
		strIDs = append(strIDs, fmt.Sprintf("%d", id))
	}
    // FIND_IN_SET維護順序
	query, args, err := sqlx.In("SELECT id, name, age FROM user WHERE id IN (?) ORDER BY FIND_IN_SET(id, ?)", ids, strings.Join(strIDs, ","))
	if err != nil {
		return
	}

	// sqlx.In 返回帶 `?` bindvar的查詢語句, 我們使用Rebind()重新綁定它
	query = db.Rebind(query)

	err = db.Select(&users, query, args...)
	return
}


func main() {
	// 1. 用代碼去做排序
	// 2. 讓MySQL排序
	fmt.Println("----")
	users, err = QueryAndOrderByIDs([]int{1, 6, 3, 4}) // 維護id查詢順序
	if err != nil {
		fmt.Printf("QueryAndOrderByIDs failed, err:%v\n", err)
		return
	}
	for _, user := range users {
		fmt.Printf("user:%#v\n", user)
	}
}