基础 CRUD

user := User{Name: "张三", Age: 18, Email: "zhangsan@example.com"}
result := db.Create(&user)

fmt.Println(user.ID)             // 自动回填主键
fmt.Println(result.RowsAffected) // 1
fmt.Println(result.Error)        // nil

users := []User{
    {Name: "张三", Age: 18},
    {Name: "李四", Age: 20},
    {Name: "王五", Age: 22},
}

// 方式一：单条 INSERT 全部数据
db.Create(&users)

// 方式二：分批插入（大量数据时推荐）
db.CreateInBatches(users, 100) // 每批 100 条

// 方式三：原生 SQL
db.Exec("INSERT INTO users (name, age) VALUES (?, ?), (?, ?)",
    "张三", 18, "李四", 20)

// 只创建指定字段
db.Select("Name", "Age").Create(&user)

// 忽略指定字段
db.Omit("Email", "Bio").Create(&user)

// 创建时不触发 Hook
db.Session(&gorm.Session{SkipHooks: true}).Create(&user)

// map[string]interface{}
db.Model(&User{}).Create(map[string]interface{}{
    "Name": "张三",
    "Age":  18,
})

// 带类型的 map
db.Model(&User{}).Create(map[string]any{"Name": "张三", "Age": 18})

// MySQL: ON DUPLICATE KEY UPDATE
user := User{ID: 1, Name: "张三改名", Age: 25}

// 方式一：Clauses
db.Clauses(clause.OnConflict{
    Columns:   []clause.Column{{Name: "id"}},          // 冲突列
    DoUpdates: clause.AssignmentColumns([]string{"name", "age"}), // 更新列
}).Create(&user)

// 方式二：Clauses + UpdateAll（全部非零值更新）
db.Clauses(clause.OnConflict{
    UpdateAll: true,
}).Create(&user)

// PostgreSQL: ON CONFLICT ... DO UPDATE
db.Clauses(clause.OnConflict{
    Columns:   []clause.Column{{Name: "email"}},          // 冲突列（需有唯一约束）
    DoUpdates: clause.AssignmentColumns([]string{"name"}), // 更新列
}).Create(&user)

// 忽略冲突（重复时不操作）
db.Clauses(clause.OnConflict{DoNothing: true}).Create(&user)

// 根据条件查找，未找到则创建
db.Where(User{Email: "test@example.com"}).FirstOrCreate(&user)
// 等价于：SELECT * FROM users WHERE email = 'test@example.com' LIMIT 1
//         未找到 → INSERT INTO users (email) VALUES ('test@example.com')

// 带额外属性的 FirstOrCreate
db.Where(User{Email: "test@example.com"}).
    Attrs(User{Name: "默认名", Age: 18}).   // 仅在创建时赋值
    FirstOrCreate(&user)

// 用 Assign 替代 Attrs（无论创建还是找到，都更新）
db.Where(User{Email: "test@example.com"}).
    Assign(User{Name: "强制更新"}).
    FirstOrCreate(&user)

// 按主键
user := User{}
db.First(&user, 1)            // SELECT * FROM users WHERE id = 1 ORDER BY id LIMIT 1
db.First(&user, "id = ?", 1)  // 同上

// 按条件
db.First(&user, "name = ?", "张三")     // 第一个匹配的
db.Take(&user)                           // 无特定顺序的第一个
db.Last(&user)                           // 最后一个（按主键降序）

// 未找到记录时，First/Last/Take 返回 gorm.ErrRecordNotFound
err := db.First(&user, 999).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
    fmt.Println("用户不存在")
}

// 查询指定 ID 的用户
var users []User
db.Find(&users, []int{1, 2, 3})
// SELECT * FROM users WHERE id IN (1, 2, 3)

// 主键为字符串类型
db.Find(&users, []string{"uuid-1", "uuid-2"})

var users []User
result := db.Find(&users)
fmt.Println(result.RowsAffected) // 总行数

// 遍历大量记录（避免一次性加载全部到内存）
rows, _ := db.Model(&User{}).Where("age > ?", 18).Rows()
defer rows.Close()
for rows.Next() {
    var user User
    db.ScanRows(rows, &user)
    // 处理 user
}

// 获取第一条匹配记录
var user User
db.Where("name = ?", "张三").First(&user)

// 获取所有匹配记录
var users []User
db.Where("age > ?", 18).Find(&users)

// 多条件（AND）
db.Where("name = ? AND age > ?", "张三", 18).Find(&users)
db.Where("name = ?", "张三").Where("age > ?", 18).Find(&users) // 等效

db.Model(&User{}).Where("name = ?", "张三").Update("age", 20)

// 更新单列（有条件）
db.Model(&user).Update("name", "张三改名") // user 必须有主键值
// UPDATE users SET name = '张三改名' WHERE id = user.ID

// 方式一：结构体（零值不更新）
db.Model(&User{}).Where("age > ?", 18).Updates(User{
    Name:   "批量改名",
    Age:    0,    // ← 零值被忽略
    IsVIP:  false, // ← 零值被忽略
})
// UPDATE users SET name = '批量改名', updated_at = NOW() WHERE age > 18

// 方式二：map（零值也会更新）
db.Model(&User{}).Where("age > ?", 18).Updates(map[string]interface{}{
    "name":   "批量改名",
    "age":    0,     // ← 零值会写入
    "is_vip": false, // ← 零值会写入
})
// UPDATE users SET name = '批量改名', age = 0, is_vip = false, updated_at = NOW() WHERE age > 18

// 方式三：Select 指定要更新的字段（零值也会写入）
db.Model(&User{}).Where("age > ?", 18).Select("Name", "Age").Updates(User{
    Name: "批量改名",
    Age:  0, // ← 通过 Select 指定后，零值也会写入
})

// 字段自增
db.Model(&User{ID: 1}).Update("age", gorm.Expr("age + ?", 1))

// 多列表达式
db.Model(&User{ID: 1}).Updates(map[string]interface{}{
    "age":      gorm.Expr("age + ?", 1),
    "login_at": gorm.Expr("NOW()"),
})

// 使用子查询
db.Model(&user).Update("follower_count",
    db.Model(&Follow{}).Select("COUNT(*)").Where("followed_id = ?", user.ID),
)

user := User{ID: 1, Name: "张三", Age: 25, Email: "test@example.com"}
db.Save(&user)
// UPDATE users SET name='张三', age=25, email='test@example', updated_at=NOW() WHERE id=1

// Save 基于主键匹配——无主键则 Create
newUser := User{Name: "新用户", Age: 20}
db.Save(&newUser) // INSERT（无主键）

type User struct {
    gorm.Model   // 内含 DeletedAt gorm.DeletedAt
    Name string
}

// 删除 → 设置 DeletedAt = NOW()
db.Delete(&User{}, 1)
// UPDATE users SET deleted_at = NOW() WHERE id = 1

// 此后所有查询自动过滤已删除记录
db.Find(&users) // WHERE deleted_at IS NULL

// Unscoped 绕过软删除过滤
db.Unscoped().Delete(&User{}, 1)
// DELETE FROM users WHERE id = 1

// 批量硬删除
db.Unscoped().Where("age < ?", 18).Delete(&User{})

// 只查已删除的记录
var deletedUsers []User
db.Unscoped().Where("deleted_at IS NOT NULL").Find(&deletedUsers)

// 查所有记录（包括已删除）
db.Unscoped().Find(&users)

// 按条件批量删除（必须带 WHERE，否则报错）
db.Where("age < ?", 18).Delete(&User{})

// 按主键列表
db.Delete(&User{}, []int{1, 2, 3})

// 带 WHERE 的速记
db.Delete(&User{}, "name = ?", "张三")

// 软删除场景下，唯一索引需包含 deleted_at
type User struct {
    gorm.Model
    Email string `gorm:"uniqueIndex:,where:deleted_at IS NULL"` // 部分唯一索引
}

// 或使用复合唯一索引
type User struct {
    gorm.Model
    Email string `gorm:"uniqueIndex:idx_email_deleted,expression:DEFAULT"` // MySQL
}

var count int64

// 统计全表
db.Model(&User{}).Count(&count)

// 带条件的统计
db.Model(&User{}).Where("age > ?", 18).Count(&count)

// 分组统计
db.Model(&User{}).Select("age, COUNT(*) as count").Group("age").Find(&results)

var ages []int
db.Model(&User{}).Pluck("age", &ages)

var names []string
db.Model(&User{}).Where("age > ?", 18).Pluck("name", &names)

// 提取多列到 map
var result []map[string]interface{}
db.Model(&User{}).Where("age > ?", 18).Find(&result)