如何使用GORM实现多行不同值的批量更新？

假设我们有如下Go结构体对应数据库表：

type Users struct {
    ID       int    `gorm:"column:id;primaryKey;"`
    Name     string `gorm:"column:name;"`
    IsActive bool   `gorm:"column:is_active;"`
    Remarks  string `gorm:"column:remarks;"`
}

我已经获取了各条数据的主键ID、is_active和remarks值，希望对不同ID的数据执行批量更新，替代传统的逐条更新方式：

UPDATE users SET is_active = true, remarks = 'activated_by_cron' where id = 1;
UPDATE users SET is_active = false, remarks = 'deactivated_by_cron' where id = 2;
UPDATE users SET is_active = true, remarks = 'activated_by_user' where id = 3;

期望用单条SQL完成批量更新，类似PostgreSQL的这种写法：

update users as u set
    is_active = c.is_active,
    remarks = c.remarks
from (values
    (1, true, 'activated_by_cron'),
    (2, false, 'deactivated_by_cron'),
    (3, true, 'activated_by_user')
) as c(id, is_active, remarks)
where c.id = u.id

目前我的临时方案是编写自定义工具函数生成上述原生SQL，再通过GORM执行，但我认为有更优的实现方式。请问有没有更合适的解决办法？

下面提供几种基于GORM的优雅实现方式，无需手动拼接完整SQL：

方法1：使用GORM的Update结合Expr和VALUES子句 #

可以利用GORM的表达式功能，直接构造PostgreSQL的FROM (VALUES ...)语法：

首先定义一个结构体来承载待更新的数据：

type UserUpdate struct {
    ID       int
    IsActive bool
    Remarks  string
}

// 待更新的数据集
updates := []UserUpdate{
    {ID: 1, IsActive: true, Remarks: "activated_by_cron"},
    {ID: 2, IsActive: false, Remarks: "deactivated_by_cron"},
    {ID: 3, IsActive: true, Remarks: "activated_by_user"},
}

然后通过GORM构造更新语句：

import (
    "fmt"
    "strings"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

// 构造VALUES部分的参数和占位符
valueStrings := make([]string, 0, len(updates))
valueArgs := make([]interface{}, 0, len(updates)*3)
for _, u := range updates {
    valueStrings = append(valueStrings, "(?, ?, ?)")
    valueArgs = append(valueArgs, u.ID, u.IsActive, u.Remarks)
}

// 拼接VALUES子句
valuesClause := fmt.Sprintf("(values %s) as c(id, is_active, remarks)", strings.Join(valueStrings, ","))

// 执行更新
err := db.Model(&Users{}).
    Where("id = c.id").
    Updates(map[string]interface{}{
        "is_active": gorm.Expr("c.is_active"),
        "remarks":   gorm.Expr("c.remarks"),
    }).
    Clauses(clause.From{Tables: []clause.Table{{Name: valuesClause}}}).
    Error

这种方式既利用了GORM的ORM特性，又贴合PostgreSQL的批量更新语法，避免了手动拼接完整SQL的繁琐。

方法2：使用临时表+批量插入后更新 #

如果待更新的数据量极大，可以先将数据插入临时表，再关联更新：

// 创建临时表（PostgreSQL语法）
db.Exec("CREATE TEMP TABLE temp_users_updates (id int, is_active boolean, remarks text) ON COMMIT DROP")

// 批量插入待更新数据
db.CreateInBatches(updates, len(updates))

// 执行关联更新
err := db.Model(&Users{}).
    Joins("JOIN temp_users_updates t ON users.id = t.id").
    Updates(map[string]interface{}{
        "is_active": gorm.Expr("t.is_active"),
        "remarks":   gorm.Expr("t.remarks"),
    }).
    Error

这种方式适合超大数据量的批量更新，性能更稳定，但需要额外创建临时表。

方法3：使用GORM的Raw方法简化调用 #

如果觉得第一种方法仍有拼接代码，可以封装一个工具函数，用GORM的Raw执行，但参数化传入数据：

func BatchUpdateUsers(db *gorm.DB, updates []UserUpdate) error {
    if len(updates) == 0 {
        return nil
    }

    valueStrings := make([]string, 0, len(updates))
    valueArgs := make([]interface{}, 0, len(updates)*3)
    for _, u := range updates {
        valueStrings = append(valueStrings, "(?, ?, ?)")
        valueArgs = append(valueArgs, u.ID, u.IsActive, u.Remarks)
    }

    sql := `UPDATE users u SET
        is_active = c.is_active,
        remarks = c.remarks
    FROM (VALUES ` + strings.Join(valueStrings, ",") + `) AS c(id, is_active, remarks)
    WHERE u.id = c.id`

    return db.Raw(sql, valueArgs...).Error
}

这种方式比手动拼接SQL更安全（参数化避免SQL注入），同时保持了代码的简洁性。

内容的提问来源于stack exchange，提问作者Akshay P J