Reusing a PreparedStatement multiple times

Question

in the case of using PreparedStatement with a single common connection without any pool, can I recreate an instance for every dml/sql operation mantaining the power of prepared statements?

I mean:

for (int i=0; i<1000; i++) {     PreparedStatement preparedStatement = connection.prepareStatement(sql);     preparedStatement.setObject(1, someValue);     preparedStatement.executeQuery();     preparedStatement.close(); } 

instead of:

PreparedStatement preparedStatement = connection.prepareStatement(sql); for (int i=0; i<1000; i++) {     preparedStatement.clearParameters();     preparedStatement.setObject(1, someValue);     preparedStatement.executeQuery(); } preparedStatement.close(); 

my question arises by the fact that I want to put this code into a multithreaded environment, can you give me some advice? thanks

Answer 1

The second way is a tad more efficient, but a much better way is to execute them in batches:

public void executeBatch(List<Entity> entities) throws SQLException {      try (         Connection connection = dataSource.getConnection();         PreparedStatement statement = connection.prepareStatement(SQL);     ) {         for (Entity entity : entities) {             statement.setObject(1, entity.getSomeProperty());             // ...              statement.addBatch();         }          statement.executeBatch();     } } 

You're however dependent on the JDBC driver implementation how many batches you could execute at once. You may for example want to execute them every 1000 batches:

public void executeBatch(List<Entity> entities) throws SQLException {      try (         Connection connection = dataSource.getConnection();         PreparedStatement statement = connection.prepareStatement(SQL);     ) {         int i = 0;          for (Entity entity : entities) {             statement.setObject(1, entity.getSomeProperty());             // ...              statement.addBatch();             i++;              if (i % 1000 == 0 || i == entities.size()) {                 statement.executeBatch(); // Execute every 1000 items.             }         }     } } 

As to the multithreaded environments, you don't need to worry about this if you acquire and close the connection and the statement in the shortest possible scope inside the same method block according the normal JDBC idiom using try-with-resources statement as shown in above snippets.

If those batches are transactional, then you'd like to turn off autocommit of the connection and only commit the transaction when all batches are finished. Otherwise it may result in a dirty database when the first bunch of batches succeeded and the later not.

public void executeBatch(List<Entity> entities) throws SQLException {      try (Connection connection = dataSource.getConnection()) {         connection.setAutoCommit(false);          try (PreparedStatement statement = connection.prepareStatement(SQL)) {             // ...              try {                 connection.commit();             } catch (SQLException e) {                 connection.rollback();                 throw e;             }         }     } }