gorm中的高階查詢
阿新 • • 發佈：2021-11-19
智慧選擇欄位
GORM 允許通過Select方法選擇特定的欄位，如果您在應用程式中經常使用此功能，你也可以定義一個較小的結構體，以實現呼叫 API 時自動選擇特定的欄位，例如：
type User struct {
ID int `gorm:"primaryKey;autoIncrement"`
Name sql.NullString `gorm:"default:'隔壁老王'"`
Age uint8 `gorm:"default:55"`
UUID uuid.UUID
CreatedAt time.Time `gorm:"autoCreateTime"`
}
type APIUser struct {
ID int
Name string
}// 查詢時會自動選擇ID、Name欄位
db.Debug().Model(new(User)).Find(&apiUsers) // SELECT `users`.`id`,`users`.`name` FROM `users`
注意QueryFields模式會根據當前 model 的所有欄位名稱進行 select。
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
QueryFields: true,
})
db.Debug().Find(&users)
// SELECT `users`.`id`,`users`.`name`,`users`.`age`,`users`.`uuid`,`users`.`created_at` FROM `users`
// Session Mode
db.Debug().Session(&gorm.Session{QueryFields: true}).Find(&users)
// SELECT `users`.`id`,`users`.`name`,`users`.`age`,`users`.`uuid`,`users`.`created_at` FROM `users`
Locking (FOR UPDATE)
GORM 支援多種型別的鎖，例如：
// 獨佔鎖
db.Debug().Clauses(clause.Locking{Strength: "UPDATE"}).Find(&users)
// SELECT * FROM `users` FOR UPDATE
// 共享鎖
db.Debug().Clauses(clause.Locking{
Strength: "SHARE",
Table: clause.Table{Name: clause.CurrentTable},
}).Find(&users)
// SELECT * FROM `users` FOR SHARE OF `users`
子查詢
子查詢可以巢狀在查詢中，GORM 允許在使用*gorm.DB物件作為引數時生成子查詢
db.Debug().Where("age > (?)", db.Table("users").Select("avg(age)")).Find(&users)
// SELECT * FROM `users` WHERE age > (SELECT avg(age) FROM `users`)
// 智慧選擇欄位
type APIUser struct {
Name string
Age uint8
}
// 子查詢
var users []APIUser
subQuery := db.Debug().Table("users").Select("avg(age) as age").Where("name IN (?)", []string{"李四", "趙六"})
db.Debug().Model(&User{}).Where("age > (?)", subQuery).Scan(&users)
// SELECT * FROM `users` WHERE age > (SELECT avg(age) as age FROM `users` WHERE name IN ('李四','趙六'))
From 子查詢
GORM 允許您在Table方法中通過 FROM 子句使用子查詢，例如：
db.Debug().Table("(?) as u", db.Model(new(User)).Select("name, age")).Where("age > ?", 18).Scan(&users)
// SELECT * FROM (SELECT name, age FROM `users`) as u WHERE age > 18
subQuery1 := db.Model(new(User)).Select("name")
subQuery2 := db.Model(&Email{}).Select("email")
db.Debug().Table("(?) as a, (?) as b", subQuery1, subQuery2).Scan(&users)
// SELECT * FROM (SELECT `name` FROM `users`) as a, (SELECT `email` FROM `emails`) as b // 生成笛卡爾積表
Group 條件
使用 Group 條件可以更輕鬆的編寫複雜 SQL
db.Debug().Model(new(User)).Where(
db.Where("name <> ?", "老王").Where(db.Where("age = ?", 10).Or("age = ?", 11)),
).Or(
db.Where("name <> ?", "李四").Where("age = ?", 55),
).Scan(&users)
// SELECT * FROM `users` WHERE (name <> '老王' AND (age = 10 OR age = 11)) OR (name <> '李四' AND age = 55)
命名引數
GORM 支援 sql.Named和map[string]interface{}{}形式的命名引數，例如：
db.Debug().Model(&User{}).Where(
"name = @name OR age = @age", sql.Named("name", "李四"), sql.Named("age", 11),
).Scan(&apiUsers)
// SELECT * FROM `users` WHERE name = '李四' OR age = 11
db.Debug().Model(new(User)).Where(
"name=@n", map[string]interface{}{"n": "老王"},
).Find(&apiUsers)
// SELECT `users`.`name`,`users`.`age` FROM `users` WHERE name='老王'
Find 至 map
GORM 允許掃描結果至map[string]interface{}或[]map[string]interface{}，此時別忘了指定Model或Table，例如：
var m1 map[string]interface{}
db.Debug().Model(new(User)).First(&m1, "id = ?", 5)
// SELECT * FROM `users` WHERE id = 5 ORDER BY `users`.`id` LIMIT 1
var m1 []map[string]interface{}
db.Debug().Model(new(User)).Find(&m1)
// SELECT * FROM `users`
FirstOrInit
獲取第一條匹配的記錄，或者根據給定的條件初始化一個例項（僅支援 sturct 和 map 條件）
// 未找到user,根據給定的條件初始化 struct
db.Debug().FirstOrInit(&user, &User{Name: sql.NullString{"老王2", true}})
// SELECT * FROM `users` WHERE `users`.`name` = '老王2' ORDER BY `users`.`id` LIMIT 1
// 找到了user
db.Debug().Where(&User{Age: 10}).FirstOrInit(&user)
// SELECT * FROM `users` WHERE `users`.`age` = 10 ORDER BY `users`.`id` LIMIT 1
// 使用map
db.Debug().FirstOrInit(&user, map[string]interface{}{"name": "李四"})
// SELECT * FROM `users` WHERE `name` = '李四2' ORDER BY `users`.`id` LIMIT 1
如果沒有找到記錄，可以使用包含更多的屬性的結構體初始化 user，Attrs不會被用於生成查詢 SQL
// 未找到user,則根據給定的條件和Attrs初始化user
db.Debug().Where(&User{Name: sql.NullString{"趙武", true}}).Attrs(&User{Age: 99}).FirstOrInit(&user)
// SELECT * FROM `users` WHERE `users`.`name` = '趙武' ORDER BY `users`.`id` LIMIT 1
// 找到了name=李四的user,則忽略：Attrs
db.Debug().Where("name = ?", "李四").Attrs(User{Age: 88}).FirstOrInit(&user)
// SELECT * FROM `users` WHERE name = '李四' ORDER BY `users`.`id` LIMIT 1
不管是否找到記錄，Assign都會將屬性賦值給 struct，但這些屬性不會被用於生成查詢 SQL，也不會被儲存到資料庫
// 未找到user,根據條件和Assign初始化struct
db.Debug().Where(User{Name: sql.NullString{"NonUser", true}}).Assign(User{Age: 5}).FirstOrInit(&user)
// SELECT * FROM `users` WHERE `users`.`name` = 'NonUser' ORDER BY `users`.`id` LIMIT 1
// 找到name=李四的user, 依然會更新Assign屬性
db.Debug().Where(User{Name: sql.NullString{"老王", true}}).Assign(User{Age: 5}).FirstOrInit(&user)
// SELECT * FROM `users` WHERE `users`.`name` = '老王' ORDER BY `users`.`id` LIMIT 1
FirstOrCreate
獲取第一條匹配的記錄，或者根據給定的條件建立一條新紀錄（僅支援 sturct 和 map 條件）
// 未找到user，則根據給定的條件建立一條新紀錄
db.Debug().Attrs(User{Name: sql.NullString{"馬豔娜", true}}).FirstOrCreate(&user, User{Age: 12})
// SELECT * FROM `users` WHERE `users`.`age` = 12 ORDER BY `users`.`id` LIMIT 1
// INSERT INTO `users` (`name`,`age`,`uuid`,`created_at`) VALUES ('馬豔娜',12,'00000000-0000-0000-0000-000000000000','2021-11-19 10:04:54.991')
// 找到了Age = 12的user,同時也把Assign屬性賦值給age,更新資料庫的Assign屬性
db.Debug().Where(User{Age: 12}).Assign(map[string]interface{}{
"name": "馬亞南",
}).FirstOrCreate(&user)
// SELECT * FROM `users` WHERE `users`.`age` = 12 ORDER BY `users`.`id` LIMIT 1
// UPDATE `users` SET `name`='馬亞南' WHERE `users`.`age` = 12 AND `id` = 6 ORDER BY `users`.`id` LIMIT 1
如果沒有找到記錄，可以使用包含更多的屬性的結構體建立記錄，Attrs不會被用於生成查詢 SQL 。
不管是否找到記錄，Assign都會將屬性賦值給 struct，並將結果寫回資料庫
未找到 user，根據條件和 Attrs 屬性建立記錄,找到了 `name` = `jinzhu` 的 user，則忽略 Attrs
未找到 user，根據條件和 Assign 屬性建立記錄,找到了 `name` = `jinzhu` 的 user，依然會根據 Assign 更新記錄
迭代
GORM 支援通過行進行迭代
// ScanRows方法用於將一行Rows掃描至結構體
rows, _ := db.Model(&User{}).Rows()
for rows.Next() {
var user User
db.ScanRows(rows, &user)
myPrint(user)
}
FindInBatches
用於批量查詢並處理記錄
var users []User
db.Debug().FindInBatches(&users, 3, func(tx *gorm.DB, batch int) error {
for _, result := range users {
spew.Println(result)
}
spew.Println(tx.RowsAffected) // 本次批量操作影響的記錄數
return nil
})
/*
SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 3
5是根據上次查詢的最後一個ID確定的
SELECT * FROM `users` WHERE `users`.`id` > 5 ORDER BY `users`.`id` LIMIT 3
*/
查詢鉤子
對於查詢操作，GORM 支援AfterFind鉤子，查詢記錄後會呼叫它
func (u *User) AfterFind(tx *gorm.DB) (err error) {
// 查詢之後會呼叫的鉤子
if u.Age > 20 {
spew.Println("您的歲數是%d,超過20歲了", u.Age)
}
return
}
Pluck
Pluck 用於從資料庫查詢單個列，並將結果掃描到切片。如果您想要查詢多列，您應該使用Select和Scan
var ages []int
db.Debug().Table("users").Pluck("age", &ages)
// SELECT `age` FROM `users`
var names []string
db.Debug().Model(&User{}).Distinct().Pluck("name", &names)
// SELECT DISTINCT `name` FROM `users`
// Distinct Select
var users []APIUser
db.Debug().Model(&User{}).Distinct().Select("name, age").Scan(&users)
// SELECT distinct name, age FROM `users`
// 超過一列的查詢，應該使用 `Scan` 或者 `Find`，例如：
db.Select("name", "age").Scan(&users)
db.Select("name", "age").Find(&users)
Scopes
Scopes允許你指定常用的查詢，可以在呼叫方法時引用這些查詢
func LaoWang(db *gorm.DB) *gorm.DB {
return db.Where("name = ?", "老王")
}
func Age10(db *gorm.DB) *gorm.DB {
return db.Where(map[string]interface{}{"age": 10})
}
// Scopes允許你指定常用的查詢，可以在呼叫方法時引用這些查詢
var users []User
db.Debug().Scopes(LaoWang, Age10).Find(&users) // 查詢name=老王而且age=10的users
// SELECT * FROM `users` WHERE name = '老王' AND `age` = 10
func Age10Or11(age []int) func(db *gorm.DB) *gorm.DB {
return func(db *gorm.DB) *gorm.DB {
return db.Where("age IN (?)", age)
}
}
db.Debug().Scopes(Age10Or11([]int{10, 11})).Find(&users) // 查詢age = 10或age=11的users
// SELECT * FROM `users` WHERE age IN (10,11)
Count
Count 用於獲取匹配的記錄數
var count int64
db.Debug().Model(new(User)).Count(&count)
// SELECT count(*) FROM `users`
var count int64
db.Debug().Table("users").Distinct("name").Count(&count)
// SELECT COUNT(DISTINCT(`name`)) FROM `users`
var count int64
db.Debug().Model(&User{}).Select("count(distinct(name))").Count(&count)
// SELECT count(distinct(name)) FROM `users`