gorm中的高级查询

智能选择字段

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`