Java: inserisci più righe in MySQL con PreparedStatement

Voglio inserire più righe in una tabella MySQL contemporaneamente usando Java. Il numero di righe è dinamico. In passato stavo facendo ...

for (String element : array) {
    myStatement.setString(1, element[0]);
    myStatement.setString(2, element[1]);

    myStatement.executeUpdate();
}

Vorrei ottimizzarlo per utilizzare la sintassi supportata da MySQL:

INSERT INTO table (col1, col2) VALUES ('val1', 'val2'), ('val1', 'val2')[, ...]

ma con un PreparedStatementnon so come farlo poiché non so in anticipo quanti elementi arrayconterrà. Se non è possibile con a PreparedStatement, in quale altro modo posso farlo (e comunque sfuggire ai valori nell'array)?

Puoi creare un batch da PreparedStatement#addBatch()ed eseguirlo da PreparedStatement#executeBatch().

Ecco un esempio di kickoff:

public void save(List<Entity> entities) throws SQLException {
    try (
        Connection connection = database.getConnection();
        PreparedStatement statement = connection.prepareStatement(SQL_INSERT);
    ) {
        int i = 0;

        for (Entity entity : entities) {
            statement.setString(1, entity.getSomeProperty());
            // ...

            statement.addBatch();
            i++;

            if (i % 1000 == 0 || i == entities.size()) {
                statement.executeBatch(); // Execute every 1000 items.
            }
        }
    }
}

Viene eseguito ogni 1000 elementi perché alcuni driver JDBC e / o DB potrebbero avere una limitazione sulla lunghezza del batch.

Vedi anche :

• Tutorial JDBC - Utilizzo di PreparedStatement
• Esercitazione JDBC - Utilizzo di oggetti istruzione per aggiornamenti batch

Quando viene utilizzato il driver MySQL, è necessario impostare il parametro di connessione rewriteBatchedStatementssu true ( jdbc:mysql://localhost:3306/TestDB?**rewriteBatchedStatements=true**).

Con questo parametro l'istruzione viene riscritta per l'inserimento in blocco quando la tabella è bloccata solo una volta e gli indici vengono aggiornati solo una volta. Quindi è molto più veloce.

Senza questo parametro l'unico vantaggio è un codice sorgente più pulito.

Se è possibile creare dinamicamente l'istruzione sql, è possibile eseguire la seguente soluzione alternativa:

String myArray[][] = { { "1-1", "1-2" }, { "2-1", "2-2" }, { "3-1", "3-2" } };

StringBuffer mySql = new StringBuffer("insert into MyTable (col1, col2) values (?, ?)");

for (int i = 0; i < myArray.length - 1; i++) {
    mySql.append(", (?, ?)");
}

myStatement = myConnection.prepareStatement(mySql.toString());

for (int i = 0; i < myArray.length; i++) {
    myStatement.setString(i, myArray[i][1]);
    myStatement.setString(i, myArray[i][2]);
}
myStatement.executeUpdate();

Nel caso in cui si dispone dell'incremento automatico nella tabella e si necessita di accedervi .. è possibile utilizzare il seguente approccio ... Eseguire un test prima dell'uso perché getGeneratedKeys () in Statement perché dipende dal driver utilizzato. Il codice seguente è testato su Maria DB 10.0.12 e sul driver Maria JDBC 1.2

Ricorda che l'aumento della dimensione del batch migliora le prestazioni solo in una certa misura ... per la mia configurazione, l'aumento della dimensione del batch oltre 500 stava effettivamente degradando le prestazioni.

public Connection getConnection(boolean autoCommit) throws SQLException {
    Connection conn = dataSource.getConnection();
    conn.setAutoCommit(autoCommit);
    return conn;
}

private void testBatchInsert(int count, int maxBatchSize) {
    String querySql = "insert into batch_test(keyword) values(?)";
    try {
        Connection connection = getConnection(false);
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        boolean success = true;
        int[] executeResult = null;
        try {
            pstmt = connection.prepareStatement(querySql, Statement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < count; i++) {
                pstmt.setString(1, UUID.randomUUID().toString());
                pstmt.addBatch();
                if ((i + 1) % maxBatchSize == 0 || (i + 1) == count) {
                    executeResult = pstmt.executeBatch();
                }
            }
            ResultSet ids = pstmt.getGeneratedKeys();
            for (int i = 0; i < executeResult.length; i++) {
                ids.next();
                if (executeResult[i] == 1) {
                    System.out.println("Execute Result: " + i + ", Update Count: " + executeResult[i] + ", id: "
                            + ids.getLong(1));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            success = false;
        } finally {
            if (rs != null) {
                rs.close();
            }
            if (pstmt != null) {
                pstmt.close();
            }
            if (connection != null) {
                if (success) {
                    connection.commit();
                } else {
                    connection.rollback();
                }
                connection.close();
            }
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@Ali Shakiba il tuo codice necessita di alcune modifiche. Parte errore:

for (int i = 0; i < myArray.length; i++) {
     myStatement.setString(i, myArray[i][1]);
     myStatement.setString(i, myArray[i][2]);
}

Codice aggiornato:

String myArray[][] = {
    {"1-1", "1-2"},
    {"2-1", "2-2"},
    {"3-1", "3-2"}
};

StringBuffer mySql = new StringBuffer("insert into MyTable (col1, col2) values (?, ?)");

for (int i = 0; i < myArray.length - 1; i++) {
    mySql.append(", (?, ?)");
}

mysql.append(";"); //also add the terminator at the end of sql statement
myStatement = myConnection.prepareStatement(mySql.toString());

for (int i = 0; i < myArray.length; i++) {
    myStatement.setString((2 * i) + 1, myArray[i][1]);
    myStatement.setString((2 * i) + 2, myArray[i][2]);
}

myStatement.executeUpdate();

possiamo inviare più aggiornamenti insieme in JDBC per inviare aggiornamenti in batch.

possiamo usare gli oggetti Statement, PreparedStatement e CallableStatement per l'aggiornamento del bacth con disabilitare autocommit

Le funzioni addBatch () ed executeBatch () sono disponibili con tutti gli oggetti istruzione per avere BatchUpdate

qui il metodo addBatch () aggiunge una serie di istruzioni o parametri al batch corrente.