如何使用GORM实现高效的批量差异化数据更新？

针对你遇到的GORM默认批量更新只能设相同值、循环更新效率低的问题，以下是几种实用的高效批量更新方案：

1. 构造CASE WHEN语句（通用所有关系型数据库） #

这是最通用的方案，通过拼接CASE WHEN语句实现单条SQL完成批量更新，避免多次数据库请求。

示例代码 #

// 假设你的模型结构体定义如下
type TestModel struct {
    ID    uint   `gorm:"primaryKey"`
    Ip    string `gorm:"column:ip"`
    Test1 int    `gorm:"column:test1"`
    Test2 int    `gorm:"column:test2"`
    Test3 int    `gorm:"column:test3"`
}

func BatchUpdateDifferentValues(db *gorm.DB, data []TestModel) error {
    if len(data) == 0 {
        return nil
    }

    // 构建test1字段的CASE WHEN逻辑
    buildCase := func(field string) (string, []interface{}) {
        clauses := make([]string, 0, len(data))
        args := make([]interface{}, 0, len(data)*2)
        for _, item := range data {
            clauses = append(clauses, "WHEN ID = ? THEN ?")
            switch field {
            case "test1":
                args = append(args, item.ID, item.Test1)
            case "test2":
                args = append(args, item.ID, item.Test2)
            case "test3":
                args = append(args, item.ID, item.Test3)
            case "ip":
                args = append(args, item.ID, item.Ip)
            }
        }
        return fmt.Sprintf("%s = CASE %s ELSE %s END", field, strings.Join(clauses, " "), field), args
    }

    test1Clause, test1Args := buildCase("test1")
    test2Clause, test2Args := buildCase("test2")
    test3Clause, test3Args := buildCase("test3")
    ipClause, ipArgs := buildCase("ip")

    // 收集所有ID用于WHERE条件
    ids := make([]interface{}, len(data))
    for i, item := range data {
        ids[i] = item.ID
    }

    // 拼接完整SQL并执行
    updateSQL := fmt.Sprintf("UPDATE test_models SET %s, %s, %s, %s WHERE ID IN (?)", test1Clause, test2Clause, test3Clause, ipClause)
    allArgs := append(append(append(test1Args, test2Args...), test3Args...), ipArgs...)
    allArgs = append(allArgs, ids)

    return db.Exec(updateSQL, allArgs...).Error
}

2. MySQL专属：ON DUPLICATE KEY UPDATE #

如果你的数据库是MySQL，且ID是主键或唯一索引，可以利用INSERT ... ON DUPLICATE KEY UPDATE语句，将批量更新转为"插入冲突则更新"的操作，效率极高。

示例代码 #

func BatchUpdateWithDuplicateKey(db *gorm.DB, data []TestModel) error {
    // 插入数据，当ID冲突时更新指定字段
    return db.Clauses(clause.OnConflict{
        Columns:   []clause.Column{{Name: "ID"}}, // 冲突判断的主键/唯一键
        DoUpdates: clause.Assignments(map[string]interface{}{
            "ip":    clause.Column{Name: "ip"},
            "test1": clause.Column{Name: "test1"},
            "test2": clause.Column{Name: "test2"},
            "test3": clause.Column{Name: "test3"},
        }),
    }).CreateInBatches(data, 100).Error // 100为批量插入批次大小，可根据数据量调整
}

注意：此方法要求ID字段必须是主键或唯一约束，否则会触发重复插入而非更新。

3. GORM 2.x 自定义Clause方案 #

GORM 2.x支持自定义Clause，可以更贴合框架风格实现批量更新：

func BatchUpdateWithCustomClause(db *gorm.DB, data []TestModel) error {
    // 收集所有待更新的ID
    ids := make([]uint, len(data))
    for i, item := range data {
        ids[i] = item.ID
    }

    // 构造批量更新的CASE表达式
    updateExpr := clause.Expr{
        SQL: `
            ip = CASE ID 
                %s 
                ELSE ip END,
            test1 = CASE ID 
                %s 
                ELSE test1 END,
            test2 = CASE ID 
                %s 
                ELSE test2 END,
            test3 = CASE ID 
                %s 
                ELSE test3 END
        `,
        Vars: []interface{}{},
    }

    // 填充每个字段的WHEN子句和参数
    fillCase := func(field string) string {
        clauses := []string{}
        for _, item := range data {
            clauses = append(clauses, "WHEN ? THEN ?")
            switch field {
            case "ip":
                updateExpr.Vars = append(updateExpr.Vars, item.ID, item.Ip)
            case "test1":
                updateExpr.Vars = append(updateExpr.Vars, item.ID, item.Test1)
            case "test2":
                updateExpr.Vars = append(updateExpr.Vars, item.ID, item.Test2)
            case "test3":
                updateExpr.Vars = append(updateExpr.Vars, item.ID, item.Test3)
            }
        }
        return strings.Join(clauses, " ")
    }

    updateExpr.SQL = fmt.Sprintf(updateExpr.SQL, fillCase("ip"), fillCase("test1"), fillCase("test2"), fillCase("test3"))
    updateExpr.Vars = append(updateExpr.Vars, ids)

    // 执行更新
    return db.Model(&TestModel{}).Clauses(clause.Update{Expression: updateExpr}).Where("ID IN (?)", ids).Error
}

方案对比 #

• CASE WHEN方案：通用所有数据库，无特殊约束，但需要拼接SQL逻辑，适合跨数据库场景。
• ON DUPLICATE KEY UPDATE：MySQL专属，代码简洁，执行效率最高，但依赖主键/唯一键约束。
• 自定义Clause方案：贴合GORM框架风格，可读性较好，本质仍是CASE WHEN逻辑的封装。

内容的提问来源于stack exchange，提问作者moluzhui