GORM---高级查询

构建Demo数据

模型定义

type Users struct {
	Id      uint64 `gorm:"primary_key;NOT NULL"`
	EmailId uint64 `gorm:"foreignKey:email_id;references:Email;"`
	Email   Email  `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL"`
	Age     uint64
	Name    string
}

type Email struct {
	EmailId uint64 `gorm:"column:email_id;primary_key;NOT NULL"`
	Addr    string
}

数据表

Users表：

Email表：

高级查询

子查询

子查询是指一个查询语句嵌套在另一个查询语句内部的查询，内部的查询是外部查询的条件。

//查询大于平均年龄的所有记录
var u1 []*connect.Users
connect.DB.Where("age > (?)", connect.DB.Table("users").Select("AVG(age)")).Find(&u1)
//SELECT * FROM `users` WHERE age > (SELECT AVG(age) FROM `users`)
for _, v := range u1 {
    fmt.Printf("%+v\n", v)
}

运行结果如下：

由于平均年龄需要计算，所以内层的SELECT语句的作用是为了得到平均年龄（connect.DB.Table(“users”).Select(“AVG(age)”)），外层的SELECT语句的作用就是条件判断。

var u2 []*connect.Users
subQuery := connect.DB.Select("AVG(age)").Where("name LIKE ?", "%y%").Table("users")
connect.DB.Select("name,AVG(age) as avgAge").Group("name").Having("AVG(age) > (?)", subQuery).Find(&u2)
//SELECT name,AVG(age) as avgAge FROM `users` GROUP BY `name` HAVING AVG(age) > (SELECT AVG(age) FROM `users` WHERE name LIKE '%y%')
for _, v := range u2 {
    fmt.Printf("%+v\n", v.Name)
}

运行结果如下：

虽然这个子查询的例子的实际意义不大，但实在是想不出什么好的例子了。首先subQuery变量存储的是内层SELECT语句的查询结果，就是查询在users表中查找name字段类似于%y%的（中间有y的name字段）的记录，并计算这些记录的平均年龄(24+23+25+25+23)/5=24。接下来就外层SELECT语句的作用就是：根据name指定分组（共四组：abc、xyz、dyg、xyg），找出这四组中的年龄大于24的记录。不熟悉group having的详见：mysql必知必会——GROUP BY和HAVING

选择字段

Select方法能指定你想从数据库中检索出的字段，默认会选择全部字段。

var u1, u2 []*connect.Users
connect.DB.Select("name, age").Find(&u1) //写法一 
//SELECT `name`,`age` FROM `users`
connect.DB.Select([]string{"name", "age"}).Find(&u2) //写法二
//SELECT `name`,`age` FROM `users`

//例二
var age int
rows, err := connect.DB.Table("users").Select("COALESCE(age,?)", 0).Rows()
	//SELECT COALESCE(age,23) FROM `users`
	if err != nil {
		fmt.Println(err.Error())
	}
	defer rows.Close()

	for rows.Next() {
		if err = rows.Scan(&age); err != nil {
            fmt.Println(err.Error())
		}
		fmt.Println(age)
	}

例二的代码分析如下：

1. 使用 Table() 方法指定要查询的数据表为 users。
2. 使用 Select() 方法指定查询的字段为 COALESCE(age,?)，其中 COALESCE() 函数是一个条件判断函数，如果 age 不为 NULL，则返回 age 的值，否则返回指定的值，这里指定的值是 ?，这代表一个占位符，会在执行查询语句时被具体的值替换，这里占位符的值为 0。
3. 使用 Rows() 方法执行查询并返回结果集，该方法会返回一个 *sql.Rows 对象，表示整个结果集。
4. 使用 rows 变量可以遍历结果集，处理每一行数据。

排序

Order，指定从数据库中检索出记录的顺序。

var u1, u2 []*connect.Users
connect.DB.Order("age desc, name").Find(&u1)
// SELECT * FROM users ORDER BY age desc, name;
for _, v := range u1 {
    fmt.Printf("%+v\n", v)
}

// 多字段排序
connect.DB.Order("age desc").Order("name").Find(&u2)
// SELECT * FROM users ORDER BY age desc, name;
for _, v := range u2 {
    fmt.Printf("%+v\n", v)
}

数量

Limit，指定从数据库检索出的最大记录数。

var u1, u2, u3 []*connect.Users
connect.DB.Limit(3).Find(&u1)
//SELECT * FROM `users` LIMIT 3 (u1)

// -1 取消 Limit 条件
connect.DB.Limit(5).Find(&u2).Limit(-1).Find(&u3)
//SELECT * FROM `users` LIMIT 5 (u2)
//SELECT * FROM `users` (u3)

偏移

Offset，指定开始返回记录前要跳过的记录数。需要注意的是，在mysql中OFFSET关键字必须要与LIMIT关键字搭配使用。

var u1, u2, u3 []connect.Users
connect.DB.Limit(3).Offset(3).Find(&u1)
//SELECT * FROM `users` LIMIT 5 OFFSET 3
for _, v := range u1 {
    fmt.Printf("%+v\n", v)
}

connect.DB.Limit(3).Offset(2).Find(&u2).Offset(-1).Find(&u3)
//SELECT * FROM `users` LIMIT 2 OFFSET 2 (u2)
//SELECT * FROM `users` LIMIT 2 (u3)
for _, v := range u2 {
    fmt.Printf("%+v\n", v)
}
fmt.Println()
for _, v := range u3 {
    fmt.Printf("%+v\n", v)
}

运行结果如下：

总数

Count，该 model 能获取的记录总数。

var u []connect.Users
var count1, count2, count3 int64
connect.DB.Where("name = ?", "xyg").Or("name = ?", "dyg").Find(&u).Count(&count1)
//SELECT * FROM `users` WHERE name = 'xyg' OR name = 'dyg'
//SELECT count(*) FROM `users` WHERE name = 'xyg' OR name = 'dyg'

connect.DB.Model(&connect.Users{}).Where("name = ?", "abc").Count(&count2)
//SELECT count(*) FROM `users` WHERE name = 'abc'

connect.DB.Table("email").Select("count(distinct(addr))").Count(&count3)
//SELECT count(distinct(addr)) FROM `email`

注意 Count 必须是链式查询的最后一个操作 ，因为它会覆盖前面的 SELECT，但如果里面使用了 count 时不会覆盖。

Group & Having

详见子查询。

连接

Joins，指定连接条件。

//SELECT users.name, email.addr FROM `users` left join email on email.email_id = users.email_id
rows, err := connect.DB.Table("users").Select("users.name, email.addr").Joins("left join email on email.email_id = users.email_id").Rows()
	if err != nil {
		fmt.Println(err)
	}
	type Result struct {
		Name string
		Addr string
	}
	var r Result
	for rows.Next() {

		if err = rows.Scan(&r.Name, &r.Addr); err != nil {
			fmt.Println(err.Error())
		}
		fmt.Println(r)
	}

运行结果如下：

Pluck

Pluck，查询 model 中的一个列作为切片。

var ages []int64
connect.DB.Table("users").Pluck("age", &ages)
fmt.Println(ages)

运行结果如下：

扫描

Scan用来扫描结果至一个 struct。

type Result struct {
		Name string
		Age  int
	}

	var result1, result2 Result
	var results []Result
	connect.DB.Table("users").Select("name, age").Where("name = ?", "xyg").Scan(&result1)
	//SELECT name, age FROM `users` WHERE name = 'xyg'
	fmt.Println(result1)

	connect.DB.Table("users").Select("name, age").Where("id > ?", 0).Scan(&results)
	//SELECT name, age FROM `users` WHERE id > 0
	fmt.Println(results)
	// 原生 SQL
	connect.DB.Raw("SELECT name, age FROM users WHERE name = ?", "xyg").Scan(&result2)
	//SELECT name, age FROM users WHERE name = 'xyg'
	fmt.Println(result2)