golang使用gorm操作批量更新大量数据代码示例

现在有个银行网点的数据表，数据总量21万多条，数据结构如下：

因业务需求，需要对里面的id加3000，也就是需要对上面数据表的id、parent_id、depth_ids 分别加3000。这个表中的这三个字段存在上下级依赖关系，因此需要同步修改，才不会破坏原有的上下级对应关系。

修改后的效果应该是这样的：

如果只是修改单个字段值，可以直接通过SQL语句实现：

-- 注意：一定要 ORDER BY id DESC，否则升序处理会导致自增主键冲突！！！
UPDATE bank SET id=id+3000,parent_id=parent_id+3000 ORDER BY id DESC; 

由于这个表的depth_ids是所有上级id逗号分隔的字符串，因此需要编写程序实现。如下的实现方法也适用于复杂的批量更新大数据量的情况。

考虑到数据量比较大，防止把数据库跑挂，首先应该想到使用mysql的 CASE WHEN THEN END 语句。

例如，提前编写好一个测试的SQL语句，应该是这样的：

UPDATE `bank` SET
		`depth_ids`=CASE depth_ids WHEN '1,440,447,212161' THEN '3001,3440,3447,215161' WHEN '1,440,447,212160' THEN '3001,3440,3447,215160' END,
		`id`=CASE id WHEN 212161 THEN 215161 WHEN 212160 THEN 215160 END,
		`parent_id`=CASE parent_id WHEN 447 THEN 3447 WHEN 447 THEN 3447 END
WHERE id IN (212161,212160)

接下来，在go代码中，基本实现思路如下：

1、查询数据总数，确定好分页数据量

// 分页参数
pageSize := 200 // 每页记录数
var total int64
// 先查询数据总数
err := c.db.Model(&model.Bank{}).Where("1=1").Count(&total).Error
if err != nil {
  log.Fatalf("Failed to get total count: %v", err)
  return
}
//total = 7 //测试数据

// 计算总页数
totalPages := int((total + int64(pageSize) - 1) / int64(pageSize))
fmt.Println("Total count:", total, "Total pages:", totalPages)

2、循环处理每页数据，在每页中查询指定条数的记录

for page := 1; page <= totalPages; page++ {
  offset := (page - 1) * pageSize // 计算偏移量
  var dataList []*model.Bank
  err := c.db.Where("1=1").
    //Where("id<=212196").
    Order("id DESC").
    Offset(offset).Limit(pageSize).
    Find(&dataList).Error
  if err != nil {
    log.Fatalf("Failed to get dataList at page %d: %v", page, err)
    return
  }
  //fmt.Printf("DataList at page %d: %s\n", page, utils.EchoJson(dataList))

  //todo 后续逻辑... 
}

3、在查询出来的结果中，循环处理拼接 CASE WHEN THEN END 语句

var idCaseWhen strings.Builder
var parentIdCaseWhen strings.Builder
var depthIdsCaseWhen strings.Builder

var idList []int64          // 需要更新的id列表
var ids []interface{}       // id 的 CASE WHEN 语句
var parentIds []interface{} // parent_id 的 CASE WHEN 语句
var depthIds []interface{}  // depth_ids 的 CASE WHEN 语句

idCaseWhen.WriteString("CASE id ")
parentIdCaseWhen.WriteString("CASE parent_id ")
depthIdsCaseWhen.WriteString("CASE depth_ids ")
for _, data := range dataList {
  // 需要更新的id列表
  idList = append(idList, data.ID)

  // 构建 id 的 CASE WHEN 语句
  idCaseWhen.WriteString(fmt.Sprintf("WHEN ? THEN ? "))
  newId := data.ID + 3000
  ids = append(ids, data.ID, newId)

  // 构建 parent_id 的 CASE WHEN 语句
  parentIdCaseWhen.WriteString(fmt.Sprintf("WHEN ? THEN ? "))
  newParentId := data.ParentID + 3000
  parentIds = append(parentIds, data.ParentID, newParentId)

  // 构建 depth_ids 的 CASE WHEN 语句：需要把逗号分隔的字符串转为[]int64，循环处理每个值分别+3000，再转为逗号分隔的字符串
  depthIdsCaseWhen.WriteString(fmt.Sprintf("WHEN ? THEN ? "))
  dataDepthIds := utils.CommaSeparatedStringToInt64Slice(data.DepthIds)
  for i, depthId := range dataDepthIds {
    dataDepthIds[i] = depthId + 3000
  }
  newDepthIds := utils.Int64SliceToCommaSeparatedString(dataDepthIds)
  depthIds = append(depthIds, data.DepthIds, newDepthIds)
}

idCaseWhen.WriteString("END")
parentIdCaseWhen.WriteString("END")
depthIdsCaseWhen.WriteString("END")

4、执行批量更新操作，隔一段时间休息一下，防止把数据库跑挂

tx := c.db.Model(&model.Bank{}).
  Where("id IN ?", idList).
  Updates(map[string]interface{}{
    "id":        gorm.Expr(idCaseWhen.String(), ids...),
    "parent_id": gorm.Expr(parentIdCaseWhen.String(), parentIds...),
    "depth_ids": gorm.Expr(depthIdsCaseWhen.String(), depthIds...),
  })

if tx.Error != nil {
  log.Fatalf("Failed to batch update records: %v", tx.Error)
  return
}

fmt.Printf("Batch update completed successfully. Affected rows: %d\n", tx.RowsAffected)
fmt.Printf("Total pages:%d, Now page: %d", totalPages, page)

// 休息一下
if page%10 == 0 { //每处理10页休息一下
  time.Sleep(3 * time.Second)
}

接下来：没了，执行就好了：