如何使用GORM在PostgreSQL中高效批量更新多行数据？

你的现有代码存在两个核心问题：一是循环执行单条更新，每次都发起独立SQL请求，效率低下；二是未检查循环中每一步的执行错误，即便某条更新失败，事务仍会提交，完全不具备健壮性。下面给出几种更优的解决方案：

方案1：修复事务的错误处理逻辑 #

如果暂时不想改动更新方式，至少要保证事务的健壮性——每执行一次更新就检查错误，一旦出错立即回滚事务并返回错误：

func UpdateInfos(ctx context.Context, db *gorm.DB, infos []Info) error {
    tx := db.Begin()
    if tx.Error != nil {
        return tx.Error
    }

    for _, info := range infos {
        if err := tx.Model(&Info{}).Where("id = ?", info.ID).Updates(map[string]interface{}{
            "name":  info.Name,
            "email": info.Email,
        }).Error; err != nil {
            tx.Rollback()
            return err
        }
    }

    return tx.Commit().Error
}

注意：这里直接指定Model(&Info{})而非&info，避免GORM误判更新条件；同时用map明确指定更新字段，防止意外更新gorm.Model里的CreatedAt等不需要修改的字段。

方案2：使用PostgreSQL的CASE WHEN语法批量更新 #

这是性能最优的方案——仅需发送一条SQL语句完成所有更新，大幅减少数据库交互开销。可以借助GORM构造对应的SQL：

import "strings"
import "fmt"

func BatchUpdateInfos(ctx context.Context, db *gorm.DB, infos []Info) error {
    if len(infos) == 0 {
        return nil
    }

    tx := db.Begin()
    if tx.Error != nil {
        return tx.Error
    }

    // 构造CASE WHEN语句的碎片
    var idList []uint
    var nameCases []string
    var emailCases []string
    var args []interface{}

    for _, info := range infos {
        idList = append(idList, info.ID)
        nameCases = append(nameCases, fmt.Sprintf("WHEN ? THEN ?"))
        emailCases = append(emailCases, fmt.Sprintf("WHEN ? THEN ?"))
        args = append(args, info.ID, info.Name, info.ID, info.Email)
    }

    nameCaseStr := strings.Join(nameCases, " ")
    emailCaseStr := strings.Join(emailCases, " ")
    args = append(args, idList...)

    // 拼接完整SQL
    sql := fmt.Sprintf(`
        UPDATE infos 
        SET name = CASE id %s END,
            email = CASE id %s END
        WHERE id IN (%s)
    `, nameCaseStr, emailCaseStr, strings.Repeat("?,", len(idList)-1)+"?")

    if err := tx.Exec(sql, args...).Error; err != nil {
        tx.Rollback()
        return err
    }

    return tx.Commit().Error
}

这种方式的优势是单次SQL请求完成所有更新，性能远优于循环单条更新；缺点是需要手动构造SQL，对复杂结构体的适配性稍差。

方案3：使用Upsert语法（适用于存在则更新、不存在则插入的场景） #

如果你的业务场景允许同时处理“更新已有记录+插入新记录”，可以用PostgreSQL的ON CONFLICT DO UPDATE语法，GORM原生支持：

import "gorm.io/gorm/clause"

func UpsertInfos(ctx context.Context, db *gorm.DB, infos []Info) error {
    tx := db.Begin()
    if tx.Error != nil {
        return tx.Error
    }

    // 以id为冲突键，存在则更新name和email字段
    if err := tx.Clauses(clause.OnConflict{
        Columns:   []clause.Column{{Name: "id"}},
        DoUpdates: clause.Assignments(map[string]interface{}{"name": clause.Column{Name: "excluded.name"}, "email": clause.Column{Name: "excluded.email"}}),
    }).Create(&infos).Error; err != nil {
        tx.Rollback()
        return err
    }

    return tx.Commit().Error
}

这个方案无需手动构造SQL，GORM会自动生成高效的Upsert语句，但仅适用于需要同时处理插入和更新的场景。

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