快速入门
GORM 简介
安装与配置
第一个 GORM 应用
GORM 与原生 SQL 对比
模型定义
模型基础
字段定义
字段标签
主键与自增
表名设置
模型嵌套
数据库连接
MySQL 连接
PostgreSQL 连接
SQLite 连接
SQL Server 连接
连接池配置
CRUD 操作
创建记录
查询记录
更新记录
删除记录
批量操作
软删除
高级查询
条件查询
排序与限制
分页查询
分组与聚合
子查询
Join 查询
预加载
关联关系
一对一关联
一对多关联
多对多关联
多态关联
关联操作
关联预加载
事务处理
事务基础
事务嵌套
事务保存点
事务最佳实践
数据库迁移
自动迁移
创建表
修改表结构
索引管理
迁移最佳实践
钩子函数
创建钩子
更新钩子
删除钩子
查询钩子
高级特性
原生 SQL
命名参数
SQL 构建器
Scope 复用
上下文支持
复合主键
性能优化
查询优化
预加载优化
批量操作优化
连接池调优
日志与调试
测试与部署
单元测试
集成测试
Mock 数据库
生产环境配置
  1. GORM
  2. 高级查询
  3. 子查询

子查询

子查询是嵌套在其他查询中的查询。复杂业务场景下，子查询能解决很多问题。

Where 子查询

在 WHERE 条件中使用子查询：

db.Where("age > (?)", db.Model(&User{}).Select("avg(age)")).Find(&users)

生成的 SQL：

SELECT * FROM users WHERE age > (SELECT avg(age) FROM users)

IN 子查询

db.Where("id IN (?)", db.Model(&Order{}).Select("user_id").Where("amount > ?", 1000)).Find(&users)

生成的 SQL：

SELECT * FROM users WHERE id IN (SELECT user_id FROM orders WHERE amount > 1000)

From 子查询

在 FROM 中使用子查询：

type Result struct {
    Age   int
    Count int
}

var results []Result
db.Table("(?) as u", db.Model(&User{}).Select("age, count(*) as count").Group("age")).Find(&results)

Select 子查询

在 SELECT 中使用子查询：

type UserOrderCount struct {
    ID        uint
    Name      string
    OrderCnt  int
}

var results []UserOrderCount
db.Model(&User{}).
    Select("id, name, (SELECT count(*) FROM orders WHERE orders.user_id = users.id) as order_cnt").
    Find(&results)

Exists 子查询

db.Where("EXISTS (?)", db.Model(&Order{}).Select("1").Where("orders.user_id = users.id")).Find(&users)

查询有订单的用户。

Not Exists：

db.Where("NOT EXISTS (?)", db.Model(&Order{}).Select("1").Where("orders.user_id = users.id")).Find(&users)

查询没有订单的用户。

多层嵌套

子查询可以多层嵌套：

subQuery := db.Model(&Order{}).
    Select("user_id, sum(amount) as total").
    Group("user_id")

db.Table("(?) as o", subQuery).
    Where("total > ?", 1000).
    Find(&results)

子查询与关联

查询每个用户的最新订单：

type UserLatestOrder struct {
    UserID    uint
    OrderID   uint
    Amount    float64
    CreatedAt time.Time
}

var results []UserLatestOrder
db.Table("orders o1").
    Select("o1.user_id, o1.id as order_id, o1.amount, o1.created_at").
    Where("o1.created_at = (?)", 
        db.Table("orders o2").
            Select("max(o2.created_at)").
            Where("o2.user_id = o1.user_id"),
    ).
    Find(&results)

使用 Raw 构建子查询

复杂子查询用 Raw 更清晰：

var users []User
db.Raw(`
    SELECT * FROM users 
    WHERE id IN (
        SELECT user_id FROM orders 
        WHERE amount > ? 
        GROUP BY user_id 
        HAVING count(*) > ?
    )
`, 1000, 5).Scan(&users)

子查询性能

子查询可能影响性能，注意：

相关子查询

子查询依赖外部查询，每行都要执行一次：

db.Where("age > (?)", db.Model(&User{}).Select("avg(age)")).Find(&users)

这个例子不相关，只执行一次。

相关子查询：

db.Where("EXISTS (?)", 
    db.Model(&Order{}).Select("1").Where("orders.user_id = users.id"),
).Find(&users)

每行用户都要执行一次子查询。

优化方案

用 JOIN 替代：

db.Distinct("users.id").Joins("JOIN orders ON orders.user_id = users.id").Find(&users)

子查询 vs JOIN

很多子查询可以改写成 JOIN：

子查询方式

db.Where("id IN (?)", 
    db.Model(&Order{}).Select("user_id").Where("amount > ?", 1000),
).Find(&users)

JOIN 方式

db.Distinct().Joins("JOIN orders ON orders.user_id = users.id AND orders.amount > ?", 1000).Find(&users)

JOIN 通常性能更好，但子查询有时更直观。

实际案例

查询高于平均分的用户

db.Where("score > (?)", db.Model(&User{}).Select("avg(score)")).Find(&users)

查询每个分类的最新文章

db.Raw(`
    SELECT a.* FROM articles a
    INNER JOIN (
        SELECT category, max(created_at) as max_created
        FROM articles
        GROUP BY category
    ) b ON a.category = b.category AND a.created_at = b.max_created
`).Scan(&articles)

查询订单总额前 10 的用户

type UserTotal struct {
    UserID uint
    Name   string
    Total  float64
}

var results []UserTotal
db.Table("users").
    Select("users.id, users.name, sum(orders.amount) as total").
    Joins("JOIN orders ON orders.user_id = users.id").
    Group("users.id").
    Order("total desc").
    Limit(10).
    Find(&results)

小结

子查询是复杂查询的利器，但要注意性能。能用 JOIN 替代的尽量用 JOIN，实在复杂的用 Raw SQL 更清晰。

上一章：分组与聚合
下一章：Join 查询