当前位置：首页 > news >正文

Gorm（一）查询方法

news 2025/10/27 11:41:05

Gorm 提供了丰富的查询方法，可灵活组合实现复杂的数据库查询逻辑。以下是对核心查询方法的详细说明，按功能分类整理：

一、条件查询：`Where` / `Or` / `Not`

用于指定查询条件（对应 SQL 中的 WHERE / OR / NOT）。

1. `Where`：基础条件

指定查询的条件，支持多种格式：

// 格式1：字符串条件（带占位符）
db.Where("name = ?", "Alice").Find(&users) // WHERE name = 'Alice'// 格式2：结构体（仅匹配非零值，适合精确匹配）
db.Where(&User{Name: "Alice", Age: 20}).Find(&users) // WHERE name = 'Alice' AND age = 20// 格式3：map（所有键值对都会作为条件，包括零值）
db.Where(map[string]interface{}{"name": "Alice", "age": 0}).Find(&users) // WHERE name = 'Alice' AND age = 0// 格式4：表达式（如 IN、BETWEEN）
db.Where("age BETWEEN ? AND ?", 18, 30).Find(&users) // WHERE age BETWEEN 18 AND 30
db.Where("name IN (?)", []string{"Alice", "Bob"}).Find(&users) // WHERE name IN ('Alice','Bob')

2. `Or`：或者条件

添加“或”逻辑，与 Where 配合使用：

// WHERE name = 'Alice' OR age > 30
db.Where("name = ?", "Alice").Or("age > ?", 30).Find(&users)// 结构体/Map 同样支持
db.Where("name = 'Alice'").Or(&User{Age: 20}).Find(&users) // WHERE name = 'Alice' OR age = 20

3. `Not`：排除条件

排除符合条件的记录（对应 NOT）：

// WHERE NOT name = 'Alice'
db.Not("name = ?", "Alice").Find(&users)// 排除 IN 中的值
db.Not("name IN (?)", []string{"Alice", "Bob"}).Find(&users) // WHERE name NOT IN ('Alice','Bob')// 排除结构体匹配的记录
db.Not(&User{Age: 18}).Find(&users) // WHERE age != 18

二、单条/批量查询：`First` / `Take` / `Last` / `Find` / `FindInBatches`

1. `First` / `Take` / `Last`：查询单条记录

First：按主键升序取第一条（LIMIT 1 + ORDER BY id ASC）。
Take：直接取第一条（仅 LIMIT 1，无默认排序）。
Last：按主键降序取最后一条（LIMIT 1 + ORDER BY id DESC）。

var user User// 查询 ID 最小的用户（默认按 ID 升序）
db.First(&user) // SELECT * FROM users ORDER BY id LIMIT 1// 查询第一条符合条件的用户（无默认排序）
db.Where("age > 18").Take(&user) // SELECT * FROM users WHERE age > 18 LIMIT 1// 查询 ID 最大的用户
db.Last(&user) // SELECT * FROM users ORDER BY id DESC LIMIT 1// 注意：若查询不到记录，会返回 ErrRecordNotFound 错误
if err := db.First(&user).Error; err == gorm.ErrRecordNotFound {// 处理“记录不存在”逻辑
}

2. `Find`：查询多条记录

用于批量查询，结果会填充到切片中：

var users []User// 查询所有用户
db.Find(&users) // SELECT * FROM users// 带条件的批量查询
db.Where("age > 18").Find(&users) // SELECT * FROM users WHERE age > 18

3. `FindInBatches`：批量查询（分批处理）

当数据量较大时，可分批查询（避免一次性加载过多数据到内存）：

var users []User
batchSize := 100 // 每批 100 条// 分批查询，每次回调处理一批数据
db.Where("age > 18").FindInBatches(&users, batchSize, func(tx *gorm.DB, batch int) error {// 处理当前批次数据（users 为当前批的记录）fmt.Printf("处理第 %d 批，共 %d 条\n", batch, len(users))return nil
})

三、字段与排序：`Select` / `Omit` / `Order` / `Limit` / `Offset` / `Distinct`

1. `Select`：指定查询字段

默认查询所有字段（*），Select 可指定需要的字段：

var users []User// 只查询 name 和 age 字段
db.Select("name", "age").Find(&users) // SELECT name, age FROM users// 支持表达式（如计算字段）
db.Select("name", "age + 10 as age_plus_10").Find(&users)

2. `Omit`：排除字段

与 Select 相反，排除不需要的字段：

// 查询所有字段，除了 email
db.Omit("email").Find(&users) // SELECT id, name, age, ... FROM users（排除 email）// 排除多个字段
db.Omit("email", "created_at").Find(&users)

3. `Order`：排序

指定查询结果的排序方式（ASC 升序 / DESC 降序）：

// 按 age 升序（默认 ASC）
db.Order("age").Find(&users) // ORDER BY age// 按 age 降序
db.Order("age DESC").Find(&users) // ORDER BY age DESC// 多字段排序
db.Order("age DESC, name ASC").Find(&users) // ORDER BY age DESC, name ASC

4. `Limit` / `Offset`：限制数量与偏移量

用于分页查询：

Limit(n)：限制返回 n 条记录。
Offset(m)：跳过前 m 条记录。

// 分页：查询第 2 页，每页 10 条（跳过前 10 条，取 10 条）
db.Limit(10).Offset(10).Find(&users) // LIMIT 10 OFFSET 10

5. `Distinct`：去重

对查询结果去重（基于指定字段）：

var ages []int// 查询所有不重复的 age 值
db.Model(&User{}).Distinct("age").Pluck("age", &ages) // SELECT DISTINCT age FROM users// 多字段去重（组合去重）
db.Distinct("name", "age").Find(&users) // SELECT DISTINCT name, age FROM users

四、统计与结果处理：`Count` / `Pluck` / `Scan`

1. `Count`：统计数量

查询符合条件的记录总数（注意：需在 Limit / Offset 之前调用，否则统计的是分页后的数量）：

var total int64// 统计所有用户数量
db.Model(&User{}).Count(&total) // SELECT count(*) FROM users// 统计符合条件的数量
db.Where("age > 18").Count(&total) // SELECT count(*) FROM users WHERE age > 18

2. `Pluck`：提取单个字段值

从查询结果中提取单个字段的值，存入切片（适合快速获取某一列数据）：

var names []string
var ages []int// 提取所有用户的 name
db.Model(&User{}).Pluck("name", &names) // SELECT name FROM users// 带条件提取 age
db.Where("age > 18").Pluck("age", &ages) // SELECT age FROM users WHERE age > 18

注意：Pluck 只能提取单个字段，如需多个字段，用 Select + Find 或 Scan。

3. `Scan`：映射到自定义结构

将查询结果映射到非模型的自定义结构体（适合复杂查询或联表查询）：

// 定义自定义结构体（与查询结果字段匹配）
type UserNameAge struct {Name stringAge  int
}var result []UserNameAge// 查询结果映射到 UserNameAge
db.Table("users").Select("name", "age").Where("age > 18").Scan(&result)

五、逻辑复用：`Scopes`

Scopes 用于封装可复用的查询逻辑（如通用条件、分页、排序等），提高代码复用性。

定义 Scope 函数

Scope 是一个接收 *gorm.DB 并返回 *gorm.DB 的函数：

// 定义“成年用户”的 Scope
func AdultUsers(tx *gorm.DB) *gorm.DB {return tx.Where("age >= 18")
}// 定义“分页”的 Scope
func Pagination(page, pageSize int) func(tx *gorm.DB) *gorm.DB {return func(tx *gorm.DB) *gorm.DB {offset := (page - 1) * pageSizereturn tx.Offset(offset).Limit(pageSize)}
}

使用 `Scopes` 调用

var users []User// 复用 AdultUsers 逻辑
db.Scopes(AdultUsers).Find(&users) // WHERE age >= 18// 组合多个 Scope（成年用户 + 第 1 页，每页 10 条）
db.Scopes(AdultUsers, Pagination(1, 10)).Find(&users)