Manière efficace de faire des lots INSÈRE avec JDBC

Si la question demande insérer efficacement à Oracle à l'aide de JDBC, je suis en train de jouer avec DB2 (IBM mainframe), sur le plan conceptuel de l'insertion serait similaire donc pensé qu'il pourrait être utile de voir mes statistiques entre

• l'insertion d'un enregistrement à la fois

• l'insertion d'un lot d'enregistrements (très efficace)

Voici les mesures

1) l'Insertion d'un enregistrement à la fois

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();
}
}
}

Les métriques pour les 100 transactions :

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

La première opération est autour de 120-150ms qui est pour la requête analyser et puis l'exécution, les transactions suivantes ne sont à prendre autour de 50ms. (Ce qui est encore élevé, mais ma base de données est sur un serveur différent(j'en ai besoin pour résoudre les problèmes du réseau))

2) Avec l'insertion dans un lot (efficace) - réalisé par 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");
}
}

Les mesures pour un lot de 100 transactions est

total time taken to insert the batch = 127 ms

et pour 1000 transactions

total time taken to insert the batch = 341 ms

Donc faire de 100 transactions dans ~5000ms (avec un trxn à la fois) est diminué de ~150ms (avec un lot de 100 enregistrements).

NOTE - Ignorer mon réseau qui est super lent, mais les mesures de valeurs relatives.

Vous aurez pour indice de référence, évidemment, mais plus de JDBC émission de plusieurs insertions sera beaucoup plus rapide si vous utilisez un PreparedStatement plutôt qu'un Énoncé.

Comment sur l'utilisation de l'INSÉRER déclaration ?

INSERT ALL
INTO table_name VALUES ()
INTO table_name VALUES ()
...
SELECT Statement;

Je me souviens que la dernière instruction select est obligatoire afin de faire cette demande à réussir. Ne me souviens pas mais pourquoi.
Vous pourriez envisager d'utiliser PreparedStatement plutôt bien. de nombreux avantages !

Farid

Dans mon code je n'ai pas d'accès direct à la 'preparedStatement' donc je ne peux pas utiliser le traitement par lots, je viens de passer la requête et une liste de paramètres. Le truc, cependant, est de créer une variable longueur de l'insert et une LinkedList de paramètres. L'effet est le même comme le premier exemple, avec la variable d'entrée de paramètre longueur.Voir ci-dessous (vérification des erreurs omis).
En supposant que 'myTable' a 3 champs modifiables: f1, f2 et 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);

dans mon DBInterface classe j'ai:

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;
}

Lot insérer à l'aide de déclaration

int a= 100;
try {
for (int i = 0; i < 10; i++) {
String insert = "insert into usermaster"
+ "("
+ "userid"
+ ")"
+ "values("
+ "'" + a + "'"
+ ");";
statement.addBatch(insert);
System.out.println(insert);
a++;
}
dbConnection.commit();
} catch (SQLException e) {
System.out.println(" Insert Failed");
System.out.println(e.getMessage());
} finally {
if (statement != null) {
statement.close();
}
if (dbConnection != null) {
dbConnection.close();
}
}