1
db.Where("name = ? AND age >= ?", name, minAge).Find(&users)

1
db.Where(&User{Name: "Alice", Age: 18}).Find(&users)

1
db.Where(map[string]any{"age": 0}).Find(&users)
2
db.Where(&User{}, "Age").Find(&users)

1
db.Where("id IN ?", []uint{1, 2, 3}).Find(&users)
2
db.Where("name LIKE ?", "%alice%").Find(&users)

1
db.Select("id", "name", "email").Find(&users)
2
db.Omit("password").Find(&users)
3

4
var names []string
5
db.Model(&User{}).Where("active = ?", true).Pluck("name", &names)

1
db.Where("status = ?", "active").
2
  Order("created_at DESC, id DESC").
3
  Find(&users)
4

5
var stats []struct {
6
  Status string
7
  Count  int64
8
}
9
db.Model(&User{}).
10
  Select("status, COUNT(*) AS count").
11
  Group("status").
12
  Scan(&stats)

1
allowedSort := map[string]string{
2
  "newest": "created_at DESC, id DESC",
3
  "name":   "name ASC, id ASC",
4
}
5
order, ok := allowedSort[sortKey]
6
if !ok {
7
  order = allowedSort["newest"]
8
}
9
db.Order(order).Find(&users)

1
type Page[T any] struct {
2
  Items      []T   `json:"items"`
3
  Page       int   `json:"page"`
4
  PageSize   int   `json:"page_size"`
5
  Total      int64 `json:"total"`
6
  TotalPages int   `json:"total_pages"`
7
}
8

9
func ListUsers(db *gorm.DB, page, pageSize int) (Page[User], error) {
10
  if page < 1 {
11
    page = 1
12
  }
13
  if pageSize < 1 {
14
    pageSize = 20
15
  }
16
  if pageSize > 100 {
17
    pageSize = 100
18
  }
19

20
  query := db.Model(&User{}).Where("deleted_at IS NULL")
21
  var total int64
22
  if err := query.Count(&total).Error; err != nil {
23
    return Page[User]{}, err
24
  }
25

26
  items := make([]User, 0, pageSize)
27
  offset := (page - 1) * pageSize
28
  if err := query.
29
    Select("id", "name", "email", "created_at").
30
    Order("created_at DESC, id DESC").
31
    Offset(offset).
32
    Limit(pageSize).
33
    Find(&items).Error; err != nil {
34
    return Page[User]{}, err
35
  }
36

37
  totalPages := int((total + int64(pageSize) - 1) / int64(pageSize))
38
  return Page[User]{
39
    Items: items, Page: page, PageSize: pageSize,
40
    Total: total, TotalPages: totalPages,
41
  }, nil
42
}

1
func Active(db *gorm.DB) *gorm.DB {
2
  return db.Where("status = ?", "active")
3
}
4

5
func CreatedAfter(t time.Time) func(*gorm.DB) *gorm.DB {
6
  return func(db *gorm.DB) *gorm.DB {
7
    return db.Where("created_at >= ?", t)
8
  }
9
}
10

11
db.Scopes(Active, CreatedAfter(startAt)).Find(&users)

1
err := db.Where("status = ?", "pending").
2
  FindInBatches(&users, 500, func(tx *gorm.DB, batch int) error {
3
    for _, user := range users {
4
      // 处理当前批次
5
      _ = user
6
    }
7
    return tx.Error
8
  }).Error