Go实现Oracle批量插入：如何对标JDBC批量操作提升性能

问题背景 #

我编写了一个简单脚本，用于读取单列文本文件，并将文件内容与一个常量值写入Oracle数据库表。目前遇到的问题是，处理最大的文件（约3000行）时，整个流程耗时超过1分钟，这显然不合理。而使用JDBC批量操作处理相同文件仅需毫秒级。因此我有两个问题：

1. 我的Go脚本存在什么问题？
2. Go中有什么方案可以模拟Java Oracle驱动的JDBC批量操作？

我的Go脚本 #

func execute(udid, schema string, file *os.File, db *sql.DB) {
    scanner := bufio.NewScanner(file)
    query := fmt.Sprintf("INSERT INTO %s.UD_GeneId VALUES (:1, :2)", schema)

    tx := mustReturn(db.Begin())
    defer tx.Rollback()

    stmt := mustReturn(tx.Prepare(query))

    for scanner.Scan() {
        _ = mustReturn(stmt.Exec(udid, scanner.Text()))
    }

    must(tx.Commit())
}

性能达标Kotlin实现 #

fun execute(datasetId: String, schema: String, file: File, db: DataSource) {
  db.connection.use { conn ->
    conn.prepareStatement("INSERT INTO ${schema}.UD_GeneId VALUES (?, ?)").use { ps ->
      file.bufferedReader().useLines { lines ->
        lines.filter { it.isNotBlank() }
          .forEach { geneId ->
            ps.setString(1, datasetId)
            ps.setString(2, geneId)
            ps.addBatch()
          }
      }

      ps.executeBatch()
    }
  }
}

问题解答 #

1. Go脚本性能差的核心原因 #

• 单次插入循环执行：当前代码每读取一行就调用一次stmt.Exec()，相当于发起3000次独立的数据库请求，每次请求都要经历网络往返、数据库解析执行等流程，累计下来的开销直接导致速度缓慢。
• 事务仅保证操作的原子性，无法减少多次请求的交互成本，本质还是单条插入的循环逻辑，和JDBC的批量操作完全不同。

2. Go中模拟JDBC批量操作的方案 #

Go标准库database/sql没有提供JDBC那样的批量API，但Oracle官方推荐的Go驱动godror支持批量参数绑定，可以实现类似JDBC批量操作的效果，核心是把所有参数打包成数组一次性发送给数据库，大幅减少网络交互次数。

优化后的Go代码示例

import (
    "bufio"
    "fmt"
    "os"
    "database/sql"
    "github.com/godror/godror"
)

func execute(udid, schema string, file *os.File, db *sql.DB) {
    scanner := bufio.NewScanner(file)
    query := fmt.Sprintf("INSERT INTO %s.UD_GeneId VALUES (:1, :2)", schema)

    // 先收集所有有效geneId
    var geneIds []string
    for scanner.Scan() {
        geneId := scanner.Text()
        if geneId != "" {
            geneIds = append(geneIds, geneId)
        }
    }
    if err := scanner.Err(); err != nil {
        must(err)
    }

    tx := mustReturn(db.Begin())
    defer tx.Rollback()

    stmt := mustReturn(tx.Prepare(query))
    defer stmt.Close()

    // 构造批量参数：常量udid重复对应每个geneId
    udidBatch := make([]string, len(geneIds))
    for i := range udidBatch {
        udidBatch[i] = udid
    }

    // 使用godror.Array包装切片，实现批量参数绑定
    _, err := stmt.Exec(godror.Array(udidBatch), godror.Array(geneIds))
    must(err)

    must(tx.Commit())
}

// 保留你的错误处理辅助函数
func must(err error) {
    if err != nil {
        panic(err) // 实际项目建议替换为更优雅的错误处理
    }
}

func mustReturn[T any](val T, err error) T {
    must(err)
    return val
}

关键优化点说明

• 批量参数绑定：通过godror.Array()将参数切片包装成Oracle支持的批量参数，让数据库一次性处理所有插入请求，把3000次网络往返缩减为1次。
• 预收集数据：先把文件所有有效行读到内存（3000行的内存占用可以忽略），再统一执行插入，避免边读边插的多次交互。
• 对齐Kotlin逻辑：增加空行过滤，减少无效插入操作。

确保使用godror驱动（这是Oracle官方维护的Go驱动），它对Oracle的批量操作、绑定变量等特性支持更完善。

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