sqlx庫使用指南

sqlx介紹

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

安裝sqlx

go get github.com/jmoiron/sqlx

基本使用

連接數據庫

var db *sqlx.DB

func initDB() (err error) {
	dsn := "user:password@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
	// 也可以使用MustConnect連接不成功就panic
	db, err = sqlx.Connect("mysql", dsn)
	if err != nil {
		fmt.Printf("connect DB failed, err:%v\n", err)
		return
	}
	db.SetMaxOpenConns(20)
	db.SetMaxIdleConns(10)
	return
}

查詢

查詢單行數據示例代碼如下：

// 查詢單條數據示例
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)
}

查詢多行數據示例代碼如下：

// 查詢多條數據示例
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使用基本一致：

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

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

NamedExec

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

func insertUserDemo()(err error){
	sqlStr := "INSERT INTO user (name,age) VALUES (:name,:age)"
	_, err = db.NamedExec(sqlStr,
		map[string]interface{}{
			"name": "七米",
			"age": 28,
		})
	return
}

NamedQuery

與DB.NamedExec同理，這里是支持查詢。

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

	u := user{
		Name: "七米",
	}
	// 使用結構體命名查詢，根據結構體字段的 db tag進行映射
	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)
	}
}

事務操作

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

func transactionDemo2()(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) // re-throw panic after Rollback
		} else if err != nil {
			fmt.Println("rollback")
			tx.Rollback() // err is non-nil; don't change it
		} else {
			err = tx.Commit() // err is nil; if Commit returns error update err
			fmt.Println("commit")
		}
	}()

	sqlStr1 := "Update user set age=20 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=50 where i=?"
	rs, err = tx.Exec(sqlStr2, 5)
	if err!=nil{
		return err
	}
	n, err = rs.RowsAffected()
	if err != nil {
		return err
	}
	if n != 1 {
		return errors.New("exec sqlStr1 failed")
	}
	return err
}

sqlx.In

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

sqlx.In的批量插入示例

表結構

為了方便演示插入數據操作，這里創建一個user表，表結構如下：

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結構體，字段通過tag與數據庫中user表的列一致。

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

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

自己拼接語句實現批量插入

比較笨，但是很好理解。就是有多少個User就拼接多少個(?, ?)。

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

使用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
	fmt.Println(args)  // 查看生成的args
	_, err := DB.Exec(query, args...)
	return err
}

使用NamedExec實現批量插入

注意：該功能目前有人已經推了#285 PR，但是作者還沒有發release，所以想要使用下面的方法實現批量插入需要暫時使用master分支的代碼：

在項目目錄下執行以下命令下載並使用master分支代碼：

go get github.com/jmoiron/sqlx@master

使用NamedExec實現批量插入的代碼如下：

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

把上面三種方法綜合起來試一下：

func main() {
	err := initDB()
	if err != nil {
		panic(err)
	}
	defer DB.Close()
	u1 := User{Name: "七米", Age: 18}
	u2 := User{Name: "q1mi", Age: 28}
	u3 := User{Name: "小王子", Age: 38}

	// 方法1
	users := []*User{&u1, &u2, &u3}
	err = BatchInsertUsers(users)
	if err != nil {
		fmt.Printf("BatchInsertUsers failed, err:%v\n", err)
	}

	// 方法2
	users2 := []interface{}{u1, u2, u3}
	err = BatchInsertUsers2(users2)
	if err != nil {
		fmt.Printf("BatchInsertUsers2 failed, err:%v\n", err)
	}

	// 方法3
	users3 := []*User{&u1, &u2, &u3}
	err = BatchInsertUsers3(users3)
	if err != nil {
		fmt.Printf("BatchInsertUsers3 failed, err:%v\n", err)
	}
}

sqlx.In的查詢示例

關於sqlx.In這里再補充一個用法，在sqlx查詢語句中實現In查詢和FIND_IN_SET函數。即實現SELECT * 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查詢

查詢id在給定id集合中的數據。

// QueryByIDs 根據給定ID查詢
func QueryByIDs(ids []int)(users []User, err error){
	// 動態填充id
	query, args, err := sqlx.In("SELECT 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
}

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))
	}
	query, args, err := sqlx.In("SELECT 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
}

當然，在這個例子里面你也可以先使用IN查詢，然后通過代碼按給定的ids對查詢結果進行排序。

預處理

stmt, err := db.Prepare(`SELECT * FROM place WHERE telcode=?`)
row = stmt.QueryRow(65)
 
tx, err := db.Begin()
txStmt, err := tx.Prepare(`SELECT * FROM place WHERE telcode=?`)
row = txStmt.QueryRow(852)

准備實際上是在數據庫上運行准備，因此它需要一個連接及其連接狀態。 
database / sql從您那里抽象了這一點，從而允許您通過自動在新連接上創建語句，從而在多個連接上同時從單個Stmt對象執行。 
Preparex（），它返回一個sqlx.Stmt，它具有sqlx.DB和sqlx.Tx所做的所有句柄擴展：

stmt, err := db.Preparex(`SELECT * FROM place WHERE telcode=?`)
var p Place
err = stmt.Get(&p, 852)

標准的sql.Tx對象還具有Stmt（）方法，該方法從預先存在的語句中返回特定於事務的語句。 
sqlx.Tx具有Stmtx版本，它將從現有sql.Stmt或sqlx.Stmt創建一個特定於事務的新sqlx.Stmt。

高級掃描　　

StructScan具有看似復雜的功能。
它支持嵌入式結構，並使用Go用於嵌入式屬性和方法訪問的相同優先級規則分配給字段。
它的普遍用法是在許多表之間共享表模型的公共部分，例如：

type AutoIncr struct {
    ID       uint64
    Created  time.Time
}
 
type Place struct {
    Address string
    AutoIncr
}
 
type Person struct {
    Name string
    AutoIncr
}

使用上面的結構，Person和Place都將能夠從StructScan接收id和創建的列，因為它們嵌入了定義它們的AutoIncr結構。
此功能使您可以快速創建用於聯接的臨時表。
它也可以遞歸工作。
通過Go點運算符和StructScan，以下內容將具有“人員名稱”及其AutoIncr ID和“創建”字段：

type Employee struct {
    BossID uint64
    EmployeeID uint64
    Person
}

請注意，sqlx過去一直為非嵌入式結構支持此功能，由於用戶使用此功能來定義關系並將相同的結構兩次嵌入，這最終造成了混亂。

type Child struct {
    Father Person
    Mother Person
}

這會引起一些問題。
在Go中，陰影后代字段是合法的；
如果嵌入式示例中的Employee定義了Name，則它將優先於Person的Name。
但是模糊的選擇器是非法的，並且會導致運行時錯誤。
如果我們想為Person and Place創建一個快速的JOIN類型，我們將id列放在哪里，這是通過它們的嵌入式AutoIncr定義的？
會有錯誤嗎？

由於sqlx構建字段名稱到字段地址的映射的方式，因此當您掃描到結構時，它不再知道在遍歷結構樹期間是否兩次遇到過名稱。
因此，與Go不同，StructScan將選擇遇到的具有該名稱的“第一個”字段。
由於Go struct字段是從上到下排序的，並且sqlx進行廣度優先遍歷以維護優先級規則，因此它將在最淺，最頂層的定義中發生。
例如，在類型中：

type PersonPlace struct {
    Person
    Place
}

StructScan將在Person.AutoIncr.ID中設置一個id列結果，也可以作為Person.ID訪問。
為避免混淆，建議您改用AS在SQL中創建列別名。

掃描目的地安全

默認情況下，如果列未映射到目標中的字段，則StructScan將返回錯誤。
這模仿了Go中未使用的變量之類的處理方式，但與標准庫編組器（例如encoding / json）的行為方式不匹配。
由於通常以比解析JSON更受控制的方式執行SQL，並且這些錯誤通常是編碼錯誤，因此決定默認返回錯誤。
與未使用的變量一樣，被忽略的列會浪費網絡和數據庫資源，並且如果不通過映射器讓您知道未發現某些內容，那么就很難在結構標記中及早發現不兼容的映射或錯字。
盡管如此，在某些情況下可能還是希望忽略沒有目的地的列。
為此，每種句柄類型都有一個Unsafe方法，該方法會在安全性關閉的情況下返回該句柄的新副本：

var p Person
// err here is not nil because there are no field destinations for columns in `place`
err = db.Get(&p, "SELECT * FROM person, place LIMIT 1;")
 
// this will NOT return an error, even though place columns have no destination
udb := db.Unsafe()
err = udb.Get(&p, "SELECT * FROM person, place LIMIT 1;")

控制名稱映射

必須將用作StructScans目標的Struct字段大寫，以便sqlx可以訪問。
因此，sqlx使用NameMapper來應用字符串.ToLower到字段名稱以將它們映射到行結果中的列。
根據您的模式，這並不總是可取的，因此sqlx允許通過多種方式自定義映射。
這些方法中最簡單的方法是使用sqlx.DB.MapperFunc將其設置為db句柄，該函數會接收到func（string）字符串類型的參數。
如果您的庫需要特定的映射器，並且您不想毒害收到的sqlx.DB，則可以創建一個副本以在庫中使用，以確保特定的默認映射：

// if our db schema uses ALLCAPS columns, we can use normal fields
db.MapperFunc(strings.ToUpper)
 
// suppose a library uses lowercase columns, we can create a copy
copy := sqlx.NewDb(db.DB, db.DriverName())
copy.MapperFunc(strings.ToLower)

每個sqlx.DB都使用sqlx / reflectx包的Mapper在下面實現此映射，並將活動映射器公開為sqlx.DB.Mapper。
您可以通過直接設置它來進一步自定義數據庫上的映射：

import "github.com/jmoiron/sqlx/reflectx"
 
// Create a new mapper which will use the struct field tag "json" instead of "db"
db.Mapper = reflectx.NewMapperFunc("json", strings.ToLower)

替代掃描類型

除了使用Scan和StructScan外，還可以使用sqlx Row或Rows自動返回切片或結果圖：

rows, err := db.Queryx("SELECT * FROM place")
for rows.Next() {
    // cols is an []interface{} of all of the column results
    cols, err := rows.SliceScan()
}
 
rows, err := db.Queryx("SELECT * FROM place")
for rows.Next() {
    results := make(map[string]interface{})
    err = rows.MapScan(results)
}

SliceScan返回所有列的[] interface {}接口，在您代表第三方執行查詢而無法知道可能返回哪些列的情況下，這很有用。
MapScan的行為相同，但是將列名映射到interface {}值。
這里的一個重要警告是，rows.Columns（）返回的結果不包含完全限定的名稱，因此從NATURAL JOIN b進行的SELECT a.id，b.id將導致[] string {“ id
“，” id“}，破壞地圖中的結果之一。

參考鏈接：

Illustrated guide to SQLX

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 sqlx使用指南 golang 數據庫開發神器 sqlx使用指南 Libghttp庫使用指南 DXF庫(dxflib)使用指南 Scintilla開源庫使用指南 WindPy使用指南 JSDoc使用指南 Sphinx使用指南 Wox使用指南 pktgen使用指南

轉自

sqlx介紹

安裝sqlx

基本使用

連接數據庫

查詢

插入、更新和刪除

NamedExec

NamedQuery

事務操作

sqlx.In

sqlx.In的批量插入示例

表結構

結構體

bindvars（綁定變量）

自己拼接語句實現批量插入

使用sqlx.In實現批量插入

使用NamedExec實現批量插入

sqlx.In的查詢示例

in查詢

in查詢和FIND_IN_SET函數

預處理

高級掃描

掃描目的地安全

控制名稱映射

替代掃描類型

免責聲明！

高級掃描　　