java - update - ¿Se puede usar PreparedStatement.addBatch() para las consultas SELECT?

preparedstatement java update

Question

Imagina que tengo 100 consultas SELECT que difieren en una entrada. Se puede usar una declaración preparada para el valor.

Toda la documentación que veo en la Web es para insertar / actualizar / eliminar por lotes. Nunca he visto lotes utilizados para declaraciones selectas.

Se puede hacer esto? Si es así, por favor, ayúdame cuando el código de muestra a continuación.

Supongo que esto se puede hacer usando una cláusula "IN", pero preferiría usar sentencias de selección por lotes.

Código de muestra:

public void run(Connection db_conn, List value_list) { String sql = "SELECT * FROM DATA_TABLE WHERE ATTR = ?"; PreparedStatement pstmt = db_conn.prepareStatement(sql); for (String value: value_list) { pstmt.clearParameters(); pstmt.setObject(1, value); pstmt.addBatch(); } // What do I call here? int[] result_array = pstmt.executeBatch() while (pstmt.getMoreResults()) { ResultSet result_set = pstmt.getResultSet(); // do work here } }

Supongo que esto también puede ser un comportamiento dependiente del conductor. Estoy escribiendo consultas contra la base de datos IBM AS / 400 DB2 utilizando su controlador JDBC.

Answer 1

AddBatch () es para las declaraciones ''delete'' / ''insert'' / ''update'', y no las declaraciones ''select''.

Answer 2

JDBC no permite crear consultas SELECT lotes, lo que en mi opinión es una limitación frustrante, particularmente porque las declaraciones preparadas no le permiten especificar un número variable de argumentos, como una cláusula IN (...) .

El artículo de JavaRanch que FJ enlaza sugiere simular la creación de lotes creando una serie de consultas de tamaño fijo y uniendo sus resultados, lo que me parece una solución incómoda y subóptima; tienes que construir manualmente y procesar múltiples consultas ahora, y golpear la base de datos varias veces. Si los números elegidos para los lotes definidos manualmente son pobres, podría terminar golpeando la base de datos varias veces solo para responder a una consulta simple.

En su lugar, me he dedicado a construir dinámicamente objetos PreparedStatement con la cantidad de campos que necesito. Esto significa que potencialmente creamos un mayor número de PreparedStatement s de lo que lo haríamos con el procesamiento por lotes por lotes manual, pero limitamos la frecuencia con la que accedemos a la base de datos y simplificamos nuestra implementación, las cuales veo como un tema más importante.

/**
* Use this method to create batch-able queries, e.g:
* "SELECT * FROM t WHERE x IN (?, ?, ?, ?)"
* Can be built as:
* "SELECT * FROM t where x IN ("+getLineOfQs(4)+")"
*/
public static String getLineOfQs(int num) {
// Joiner and Iterables from the Guava library
return Joiner.on(", ").join(Iterables.limit(Iterables.cycle("?"), num));
}
/**
* Gets the set of IDs associated with a given list of words
*/
public Set<Integer> find(Connection conn, List<String> words)
throws SQLException {
Set<Integer> result = new HashSet<>();
try(PreparedStatement ps = conn.prepareStatement(
"SELECT id FROM my_table WHERE word IN ("+
getLineOfQs(words.size())+")")) {
for(int i = 0; i < words.size(); i++) {
ps.setString(i+1, words.get(i));
}
try (ResultSet rs = ps.executeQuery()) {
while(rs.next()) {
result.add(rs.getInt("id"));
}
}
}
return result;
}

Esto no es demasiado difícil de codificar, le brinda la seguridad de usar PreparedStatement y evita accesos innecesarios a la base de datos.

Answer 3

Ver el Tutorial de Java :

Esta lista puede contener instrucciones para actualizar, insertar o eliminar una fila; y también puede contener sentencias DDL como CREATE TABLE y DROP TABLE. Sin embargo, no puede contener una declaración que produzca un objeto ResultSet, como una instrucción SELECT. En otras palabras, la lista puede contener solo declaraciones que producen un recuento de actualizaciones.

La lista, que está asociada con un objeto Statement en su creación, está inicialmente vacía. Puede agregar comandos SQL a esta lista con el método addBatch.