Deux déclarations préparées différentes dans un seul lot

Je veux envoyer deux déclarations préparées en un seul lot.

Actuellement, je suis en train de faire cela en deux comme vous pouvez le voir dans les lignes commentées et il fonctionne, mais ce n'est pas l'objectif principal ici. Quelqu'un peut me dire quoi mettre à la place de ces observations pour obtenir cette chose de travailler?

import java.lang.ClassNotFoundException;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.DriverManager;
public class Main
{
public static void main(String[] args)
{
Connection connection = null;
PreparedStatement preparedStatementWithdraw = null;
PreparedStatement preparedStatementDeposit = null;
try
{
Class.forName("com.mysql.jdbc.Driver");
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/youtube", "root", "root");
preparedStatementWithdraw = withdrawFromChecking(connection, preparedStatementWithdraw, new BigDecimal(100), 1);
preparedStatementDeposit = depositIntoSaving(connection, preparedStatementDeposit, new BigDecimal(300), 1);
//preparedStatementDeposit.executeBatch();
//preparedStatementWithdraw.executeBatch();
System.out.println("Account Modified!");
}
catch(ClassNotFoundException error)
{
System.out.println("Error: " + error.getMessage());
}
catch(SQLException error)
{
System.out.println("Error: " + error.getMessage());
}
finally
{
if(connection != null) try{connection.close();} catch(SQLException error) {}
if(preparedStatementDeposit != null) try{preparedStatementDeposit.close();} catch(SQLException error) {}
}
}
public static PreparedStatement withdrawFromChecking(Connection connection, PreparedStatement preparedStatement, BigDecimal balance, int id) throws SQLException
{
preparedStatement = connection.prepareStatement("UPDATE bankAccount SET checkingBalance = checkingBalance - ? WHERE id = ?");
preparedStatement.setBigDecimal(1, balance);
preparedStatement.setInt(2, id);
preparedStatement.addBatch();
return preparedStatement;
}
public static PreparedStatement depositIntoSaving(Connection connection, PreparedStatement preparedStatement, BigDecimal balance, int id) throws SQLException
{
preparedStatement = connection.prepareStatement("UPDATE bankAccount SET savingBalance = savingBalance + ? WHERE id = ?");
preparedStatement.setBigDecimal(1, balance);
preparedStatement.setInt(2, id);
preparedStatement.addBatch();
return preparedStatement;
}
}

source d'informationauteur gmustudent | 2012-10-19

  1. 7

    Vous ne pouvez pas exécuter deux états en un seul lot. @Dan mentionné que vous pouvez-et doit -- les faire en une seule opération.

    Une autre option est d'utiliser une procédure stockée qui peut tout faire dans un seul aller-retour vers le serveur, tout en conservant les avantages de la transaction unique

  2. 9

    Vous pouvez essayer d'exécuter les deux déclaration est d'une seule opération, comme ceci:

    connection.setAutoCommit(false);
try {
stmt1.execute();
stmt2.execute();
connection.commit();
} catch (Exception ex) {
connection.rollback();
}

    Le problème est que addBatch fonctionne sur une seule déclaration préparée à l'avance, voir c'est comment vous pouvez utiliser plusieurs instructions sql avec addBatch.

  3. 1

    J'essaie d'utiliser les requêtes préparées et un lot! Je dis
    états parce que je voudrais envoyer deux déclarations préparées à l'avance dans un
    lot.

    Lorsque vous parlez de PreparedStatementun lot est associé à cette PreparedStatement de l'objet lot de commandes et PAS l'inverse. Vous devriez regarder la javadoc pour addBatch() méthode pour en savoir plus à ce sujet.

    Donc dans votre cas, voici ce que j'aurais fait:

    • Créé une nouvelle transaction et de définir une limite du lot
    • Créé un ensemble de lot pour chaque PreparedStatement et incrémenter un totaliseur
    • Exécuté le lot quand j'ai franchi la limite et de réinitialiser le compteur
    • Commis ma transaction une fois que je suis fait

    De sorte que votre code devrait ressembler à quelque chose comme ceci:

    preparedStatementWithdraw = connection.prepareStatement(....);
preparedStatementDeposit  = connection.prepareStatement(....);
boolean autoCommit        = connection.getAutoCommit();
int batchLimit = 1000; //limit that you can vary
int batchCounter = 0;
try{
connection.setAutoCommit(false);
//set the params and start adding your batch statements, as per your requirement, something like
preparedStatementWithdraw.addBatch();
preparedStatementDeposit.addBatch();
batchCounter++;
if(batchCounter == batchLimit){
try{
preparedStatementWithdraw.executeBatch();
preparedStatementDeposit.executeBatch();
}catch(Exception exe){
//log your error
}finally{
preparedStatementWithdraw.clearBatch();
preparedStatementDeposit.clearBatch();
batchCounter = 0;
}
}
}finally{
//process if any more statements are remaining in the batch
try{
preparedStatementWithdraw.executeBatch();
preparedStatementDeposit.executeBatch();
}catch(Exception exe){
//log your error
}finally{
preparedStatementWithdraw.clearBatch();
preparedStatementDeposit.clearBatch();
}
//1. depending on your requirement, commit/rollback the transation
//2. Set autocommit to its original value
connection.setAutoCommit(autoCommit);
//3. Resoure management statements
}
  4. 0

    Je pense que vous souhaitez fusionner votre déclaration de requêtes sous forme de l'un et de faire quelque chose comme ceci:

     String updateAccount= "UPDATE bankAccount 
SET if(? is not null ) 
then checkingBalance = checkingBalance - ? end if, 
if(? is not null ) 
then savingBalance = savingBalance + ? end if
WHERE id = ?";                
PreparedStatement = dbConnection.prepareStatement(updateAccount);
preparedStatement.setDouble(1, new Double(100));
preparedStatement.setDouble(2, new Double(100));
preparedStatement.setDouble(3, null);
preparedStatement.setDouble(4, null);
preparedStatement.setInt(5, 1);
preparedStatement.addBatch();
preparedStatement.setDouble(1, null);
preparedStatement.setDouble(2, null);
preparedStatement.setDouble(3, new Double(100));
preparedStatement.setDouble(4, new Double(100));
preparedStatement.setInt(5, 1);
preparedStatement.addBatch();
preparedStatement.executeBatch();
dbConnection.commit();