使用 JDBC 进行批量 INSERTS 的有效方法

Question

在我的应用中，我需要做很多 INSERTS。它是一个 Java 应用程序，我使用普通的 JDBC 来执行查询。数据库是 Oracle。我已经启用了批处理，所以它可以节省我执行查询的网络延迟。但是查询作为单独的 INSERT 串行执行：

insert into some_table (col1, col2) values (val1, val2)
insert into some_table (col1, col2) values (val3, val4)
insert into some_table (col1, col2) values (val5, val6)

我想知道以下形式的 INSERT 是否更有效：

insert into some_table (col1, col2) values (val1, val2), (val3, val4), (val5, val6)

即将多个 INSERT 合并为一个。

还有其他加快批量 INSERT 的技巧吗？

Answer 1

这是前面两个答案的混合：

  PreparedStatement ps = c.prepareStatement("INSERT INTO employees VALUES (?, ?)");

  ps.setString(1, "John");
  ps.setString(2,"Doe");
  ps.addBatch();

  ps.clearParameters();
  ps.setString(1, "Dave");
  ps.setString(2,"Smith");
  ps.addBatch();

  ps.clearParameters();
  int[] results = ps.executeBatch();

Answer 2

虽然问题询问使用 JDBC 有效地插入 Oracle，但我目前正在使用 DB2（在 IBM 大型机上），从概念上讲，插入将是相似的，因此认为查看我的指标可能会有所帮助

• 一次插入一条记录

• 插入一批记录（效率很高）

这里是指标

1) 一次插入一条记录

public void writeWithCompileQuery(int records) {
    PreparedStatement statement;

    try {
        Connection connection = getDatabaseConnection();
        connection.setAutoCommit(true);

        String compiledQuery = "INSERT INTO TESTDB.EMPLOYEE(EMPNO, EMPNM, DEPT, RANK, USERNAME)" +
                " VALUES" + "(?, ?, ?, ?, ?)";
        statement = connection.prepareStatement(compiledQuery);

        long start = System.currentTimeMillis();

        for(int index = 1; index < records; index++) {
            statement.setInt(1, index);
            statement.setString(2, "emp number-"+index);
            statement.setInt(3, index);
            statement.setInt(4, index);
            statement.setString(5, "username");

            long startInternal = System.currentTimeMillis();
            statement.executeUpdate();
            System.out.println("each transaction time taken = " + (System.currentTimeMillis() - startInternal) + " ms");
        }

        long end = System.currentTimeMillis();
        System.out.println("total time taken = " + (end - start) + " ms");
        System.out.println("avg total time taken = " + (end - start)/ records + " ms");

        statement.close();
        connection.close();

    } catch (SQLException ex) {
        System.err.println("SQLException information");
        while (ex != null) {
            System.err.println("Error msg: " + ex.getMessage());
            ex = ex.getNextException();
        }
    }
}

100 笔交易的指标：

each transaction time taken = 123 ms
each transaction time taken = 53 ms
each transaction time taken = 48 ms
each transaction time taken = 48 ms
each transaction time taken = 49 ms
each transaction time taken = 49 ms
...
..
.
each transaction time taken = 49 ms
each transaction time taken = 49 ms
total time taken = 4935 ms
avg total time taken = 49 ms

第一个事务在120-150ms 周围进行，用于the query parse 然后执行，后续事务仅在50ms 周围进行。 （仍然很高，但我的数据库在不同的服务器上（我需要对网络进行故障排除））

2) 批量插入（高效） - 由preparedStatement.executeBatch() 实现

public int[] writeInABatchWithCompiledQuery(int records) {
    PreparedStatement preparedStatement;

    try {
        Connection connection = getDatabaseConnection();
        connection.setAutoCommit(true);

        String compiledQuery = "INSERT INTO TESTDB.EMPLOYEE(EMPNO, EMPNM, DEPT, RANK, USERNAME)" +
                " VALUES" + "(?, ?, ?, ?, ?)";
        preparedStatement = connection.prepareStatement(compiledQuery);

        for(int index = 1; index <= records; index++) {
            preparedStatement.setInt(1, index);
            preparedStatement.setString(2, "empo number-"+index);
            preparedStatement.setInt(3, index+100);
            preparedStatement.setInt(4, index+200);
            preparedStatement.setString(5, "usernames");
            preparedStatement.addBatch();
        }

        long start = System.currentTimeMillis();
        int[] inserted = preparedStatement.executeBatch();
        long end = System.currentTimeMillis();

        System.out.println("total time taken to insert the batch = " + (end - start) + " ms");
        System.out.println("total time taken = " + (end - start)/records + " s");

        preparedStatement.close();
        connection.close();

        return inserted;

    } catch (SQLException ex) {
        System.err.println("SQLException information");
        while (ex != null) {
            System.err.println("Error msg: " + ex.getMessage());
            ex = ex.getNextException();
        }
        throw new RuntimeException("Error");
    }
}

一批 100 笔交易的指标是

total time taken to insert the batch = 127 ms

1000 笔交易

total time taken to insert the batch = 341 ms

因此，在 ~5000ms 中进行 100 笔交易（一次只有一个 trxn）减少到 ~150ms（一批 100 条记录）。

注意 - 忽略我的超级慢的网络，但指标值是相对的。

Answer 3

Statement 为您提供以下选项：

Statement stmt = con.createStatement();

stmt.addBatch("INSERT INTO employees VALUES (1000, 'Joe Jones')");
stmt.addBatch("INSERT INTO departments VALUES (260, 'Shoe')");
stmt.addBatch("INSERT INTO emp_dept VALUES (1000, 260)");

// submit a batch of update commands for execution
int[] updateCounts = stmt.executeBatch();

Answer 4

显然，您必须进行基准测试，但是如果您使用 PreparedStatement 而不是 Statement，则通过 JDBC 发出多个插入会快得多。

Answer 5

您可以使用此rewriteBatchedStatements 参数使批量插入更快。

您可以在此处阅读有关参数的信息：MySQL and JDBC with rewriteBatchedStatements=true

Answer 6

SQLite：以上答案都是正确的。对于 SQLite，它有点不同。没有什么真正有帮助的，即使将它放在一个批次中（有时）也不会提高性能。在这种情况下，请尝试禁用自动提交并在完成后手动提交（警告！当多个连接同时写入时，您可能会与这些操作发生冲突）

// connect(), yourList and compiledQuery you have to implement/define beforehand
try (Connection conn = connect()) {
     conn.setAutoCommit(false);
     preparedStatement pstmt = conn.prepareStatement(compiledQuery);
     for(Object o : yourList){
        pstmt.setString(o.toString());
        pstmt.executeUpdate();
        pstmt.getGeneratedKeys(); //if you need the generated keys
     }
     pstmt.close();
     conn.commit();

}

Answer 7

如何使用 INSERT ALL 语句？

INSERT ALL

INTO table_name VALUES ()

INTO table_name VALUES ()

...

SELECT Statement;

我记得最后一个 select 语句是强制性的，才能使这个请求成功。不过不记得为什么了。 您也可以考虑使用 PreparedStatement。很多优点！

法里德

Answer 8

您可以在 java 中使用 addBatch 和 executeBatch 进行批量插入参见示例：Batch Insert In Java

Answer 9

在我的代码中，我无法直接访问“preparedStatement”，因此无法使用批处理，我只是将查询和参数列表传递给它。然而，诀窍是创建一个可变长度的插入语句和一个 LinkedList 参数。效果和上面的例子一样，可变参数输入长度。见下文（省略错误检查）。 假设“myTable”有 3 个可更新字段：f1、f2 和 f3

String []args={"A","B","C", "X","Y","Z" }; // etc, input list of triplets
final String QUERY="INSERT INTO [myTable] (f1,f2,f3) values ";
LinkedList params=new LinkedList();
String comma="";
StringBuilder q=QUERY;
for(int nl=0; nl< args.length; nl+=3 ) { // args is a list of triplets values
    params.add(args[nl]);
    params.add(args[nl+1]);
    params.add(args[nl+2]);
    q.append(comma+"(?,?,?)");
    comma=",";
}      
int nr=insertIntoDB(q, params);

在我的 DBInterface 类中，我有：

int insertIntoDB(String query, LinkedList <String>params) {
    preparedUPDStmt = connectionSQL.prepareStatement(query);
    int n=1;
    for(String x:params) {
        preparedUPDStmt.setString(n++, x);
    }
    int updates=preparedUPDStmt.executeUpdate();
    return updates;
}

Answer 10

如果你使用 jdbcTemplate 那么：

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;

    public int[] batchInsert(List<Book> books) {

        return this.jdbcTemplate.batchUpdate(
            "insert into books (name, price) values(?,?)",
            new BatchPreparedStatementSetter() {

                public void setValues(PreparedStatement ps, int i) throws SQLException {
                    ps.setString(1, books.get(i).getName());
                    ps.setBigDecimal(2, books.get(i).getPrice());
                }

                public int getBatchSize() {
                    return books.size();
                }

            });
    }

或更高级的配置

  import org.springframework.jdbc.core.JdbcTemplate;
  import org.springframework.jdbc.core.ParameterizedPreparedStatementSetter;

    public int[][] batchInsert(List<Book> books, int batchSize) {

        int[][] updateCounts = jdbcTemplate.batchUpdate(
                "insert into books (name, price) values(?,?)",
                books,
                batchSize,
                new ParameterizedPreparedStatementSetter<Book>() {
                    public void setValues(PreparedStatement ps, Book argument) 
                        throws SQLException {
                        ps.setString(1, argument.getName());
                        ps.setBigDecimal(2, argument.getPrice());
                    }
                });
        return updateCounts;

    }

链接到source

Answer 11

如果迭代次数少，使用 PreparedStatements 将比 Statements 慢得多。要通过在语句上使用 PrepareStatement 来获得性能优势，您需要在迭代次数至少为 50 次或更高的循环中使用它。