深入解析GORM查询：从入门到高级条件查询技巧 GORM 作为 Go 语言中最流行的 ORM 框架之一，提供了简洁且强

GORM 作为 Go 语言中最流行的 ORM 框架之一，提供了简洁且强大的查询 API。本文将围绕 GORM 的查询功能展开，重点解析 String 条件、Struct & Map 条件的使用场景与技巧，帮助你系统掌握 GORM 查询的核心能力。

一、GORM 查询基础：单个对象与集合检索

1.1 单个对象检索：First/Take/Last 方法

GORM 提供了三种高效检索单个对象的方法，它们会自动添加 LIMIT 1 条件，并根据主键排序（First 升序，Last 降序，Take 不排序）：

// 检索第一条记录（按主键升序）
var user User
db.First(&user)
// 生成 SQL: SELECT * FROM users ORDER BY id LIMIT 1;

// 检索任意一条记录（不排序）
db.Take(&user)
// 生成 SQL: SELECT * FROM users LIMIT 1;

// 检索最后一条记录（按主键降序）
db.Last(&user)
// 生成 SQL: SELECT * FROM users ORDER BY id DESC LIMIT 1;

错误处理最佳实践：

result := db.First(&user)
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
    fmt.Println("记录未找到")
} else if result.Error != nil {
    fmt.Println("查询出错:", result.Error)
} else {
    fmt.Println("查询成功，记录数:", result.RowsAffected)
}

1.2 避免 ErrRecordNotFound 错误的技巧

当你不希望查询抛出记录未找到错误时，可以使用 Find 方法结合 Limit(1)：

// 安全查询单个对象，未找到时不会报错，rowsAffected 为 0
db.Limit(1).Find(&user)

// 错误示范：直接使用 Find 不带 Limit 会查询全表
// 仅返回第一条记录，但性能差且结果不确定
db.Find(&user)

1.3 主键检索：高效定位记录

// 按数字主键检索（支持 int/string 类型）
db.First(&user, 10)          // SELECT * FROM users WHERE id = 10;
db.First(&user, "10")       // 同上，字符串形式主键

// 按主键批量检索
db.Find(&users, []int{1,2,3}) // SELECT * FROM users WHERE id IN (1,2,3);

// UUID 类型主键检索（避免 SQL 注入）
db.First(&user, "id = ?", "1b74413f-f3b8-409f-ac47-e8c062e3472a")

// 结构体主键值检索（自动使用主键条件）
var user = User{ID: 10}
db.First(&user) // SELECT * FROM users WHERE id = 10;

二、String 条件：灵活构建 SQL 表达式

String 条件是 GORM 中最接近原生 SQL 的查询方式，支持几乎所有 SQL 条件表达式，是复杂查询的首选方案。

2.1 基础条件：等于、不等于与逻辑组合

// 等于条件（最常用场景）
db.Where("name = ?", "jinzhu").First(&user)
// SQL: SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;

// 不等于条件
db.Where("name <> ?", "jinzhu").Find(&users)
// SQL: SELECT * FROM users WHERE name <> 'jinzhu';

// AND 组合条件
db.Where("name = ? AND age >= ?", "jinzhu", 22).Find(&users)
// SQL: SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;

2.2 集合与范围条件：IN/BETWEEN/LIKE

// IN 条件（支持切片/数组）
db.Where("name IN ?", []string{"jinzhu", "jinzhu 2"}).Find(&users)
// SQL: SELECT * FROM users WHERE name IN ('jinzhu','jinzhu 2');

// LIKE 模糊查询（% 表示任意字符，_ 表示单个字符）
db.Where("name LIKE ?", "%jin%").Find(&users)
// SQL: SELECT * FROM users WHERE name LIKE '%jin%';

// 时间范围查询（基于 time.Time 类型字段）
db.Where("updated_at > ?", lastWeek).Find(&users)
// SQL: SELECT * FROM users WHERE updated_at > '2020-01-01 00:00:00';

// BETWEEN 范围查询（包含边界值）
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
// SQL: SELECT * FROM users WHERE created_at BETWEEN '2020-01-01' AND '2020-01-08';

2.3 内联条件：简化查询链式调用

内联条件允许在 First/Find 等方法中直接传递条件，功能等同于 Where 方法：

// 主键非整型时的内联查询
db.First(&user, "id = ?", "string_primary_key")
// SQL: SELECT * FROM users WHERE id = 'string_primary_key';

// 原生 SQL 风格内联
db.Find(&user, "name = ?", "jinzhu")
// SQL: SELECT * FROM users WHERE name = "jinzhu";

// 多条件内联组合
db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
// SQL: SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;

2.4 高级条件：NOT/OR 与复杂逻辑

// NOT 条件（取反查询）
db.Not("name = ?", "jinzhu").First(&user)
// SQL: SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;

// NOT IN 条件
db.Not(map[string]interface{}{"name": []string{"jinzhu", "jinzhu 2"}}).Find(&users)
// SQL: SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");

// OR 条件（逻辑或）
db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
// SQL: SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';

// 复杂 OR 组合（混合 String 与 Struct 条件）
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2", Age: 18}).Find(&users)
// SQL: SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

三、Struct & Map 条件：面向对象的查询方式

Struct 与 Map 条件是 GORM 提供的「对象化查询」方案，适合基于模型结构构建查询条件，代码可读性更强。

3.1 Struct 条件：基于模型字段的查询

// 基础 Struct 条件（仅使用非零字段）
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
// SQL: SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;

// 注意：Struct 条件会忽略零值字段
db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users)
// SQL: SELECT * FROM users WHERE name = "jinzhu";（Age=0 被忽略）

// 指定结构体查询字段（强制包含某些字段）
db.Where(&User{Name: "jinzhu"}, "name", "Age").Find(&users)
// SQL: SELECT * FROM users WHERE name = "jinzhu" AND age = 0;

3.2 Map 条件：灵活的键值对查询

// 基础 Map 条件（包含所有键值对）
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
// SQL: SELECT * FROM users WHERE name = "jinzhu" AND age = 20;

// Map 条件包含零值字段（解决 Struct 忽略零值问题）
db.Where(map[string]interface{}{"Name": "jinzhu", "Age": 0}).Find(&users)
// SQL: SELECT * FROM users WHERE name = "jinzhu" AND age = 0;

// 主键切片查询（Map 风格）
db.Where([]int64{20, 21, 22}).Find(&users)
// SQL: SELECT * FROM users WHERE id IN (20, 21, 22);

3.3 Struct 与 Map 条件对比表

特性	Struct 条件	Map 条件
字段处理原则	仅使用非零值字段	包含所有键值对（包括零值）
代码可读性	强（基于模型结构）	中（键值对形式）
动态字段支持	不支持（需预定义模型）	强（任意键值对）
防止 SQL 注入	自动转义（安全）	自动转义（安全）
复杂条件组合	需配合 String 条件	直接支持 Map 嵌套

四、条件查询最佳实践与注意事项

4.1 主键冲突陷阱与解决方案

当结构体已设置主键值时，GORM 会自动将主键作为查询条件，与其他条件使用 AND 连接：

// 错误示例：主键冲突导致查询失败
var user = User{ID: 10}
db.Where("id = ?", 20).First(&user)
// SQL: SELECT * FROM users WHERE id = 10 AND id = 20 LIMIT 1;
// 结果：Record not found（永远无法满足条件）

// 正确做法：查询前将主键设为零值
var user = User{ID: 0} // 或使用指针类型，初始为 nil
db.Where("id = ?", 20).First(&user)
// SQL: SELECT * FROM users WHERE id = 20 LIMIT 1;

4.2 性能优化关键点

避免全表查询：始终使用 Limit 或条件限制结果集
合理使用索引：对高频查询字段添加索引（通过 GORM 标签 gorm:"index"）
批量查询替代循环：使用 Find 配合 ID 切片替代多次单条查询
只查询必要字段：通过 Select 指定需要的字段，减少数据传输量

// 只查询 name 和 age 字段（性能优化）
db.Select("name", "age").Find(&users)
// SQL: SELECT name, age FROM users;

4.3 条件查询流程决策图

编辑

五、总结：GORM 查询条件核心要点

单个对象检索：First/Take/Last 是首选，注意处理 ErrRecordNotFound 错误
String 条件：
- 支持所有 SQL 原生条件表达式（=, <>, IN, LIKE 等）
- 内联条件可简化代码，但可读性略低于链式调用
- NOT 和 OR 可构建复杂逻辑查询
Struct & Map 条件：
- Struct 条件基于模型字段，自动忽略零值，适合「按对象属性查询」
- Map 条件灵活支持任意键值对，包括零值，适合动态条件
- 指定结构体查询字段可强制包含特定字段，解决零值忽略问题
最佳实践：
- 避免主键冲突，查询前重置主键值
- 始终限制查询结果集（Limit），防止全表扫描
- 根据场景选择条件类型：复杂逻辑用 String，对象化查询用 Struct/Map

通过掌握这些 GORM 查询技巧，你可以在开发中更高效地操作数据库，同时保持代码的清晰与安全。建议在实际项目中多练习不同条件的组合使用，加深理解与记忆。

如果这篇文章对大家有帮助可以点赞关注，你的支持就是我的动力😊！