批处理执行失败后，如何重试未执行的语句？

Question

I'm need to update a table with data from a CSV. All data is validated before the update takes place: a validation method (witch is not presented bellow) checks if some assumptions are true and "flags" the object as valid or invalid. I've already test it a lot and it's working exactly as I want.

Even so, I would like to guarantee that all Statements will be executed even if there's a fail on a batch, something that I was not able to think about. If this happens, I want the batch in witch this fail statement is to be skipped and that the next one is executed.

public void updateTable(List<PersonBean> personList) {

    Connection connection = null;
    PreparedStatement ps = null;

    String updateDBPersonSQL = "UPDATE Person set merge_parent_id = ? WHERE id = ?";

    try {
        logger.info("DATA UPDATING STARTED");

        input = new FileInputStream("resources/propertiesFiles/applications.properties");
        properties.load(input);

        final int batchSize = Integer.parseInt(properties.getProperty("batchSize"));

        connection = DBConnection.getConnection();
        connection.setAutoCommit(false);

        int validObj = 0;

        ps = connection.prepareStatement(updateDBPersonSQL);

        for (int i = 0; i < personList.size(); i++) {

            PersonBean person = personList.get(i);

            if (person.getValidationStatus().equals("valid")) {

                ps.setInt(1, person.getMerge_parent_id());
                ps.setInt(2, person.getId());
                ps.addBatch();

                validObj++;

                if (validObj % batchSize == 0 && validObj != 0) {
                    ps.executeBatch();
                    connection.commit();

                    logger.info((batchSize) + " rows updated");
                } 
            }
        }
        int [] batchCount = ps.executeBatch();
        connection.commit();

        logger.info(batchCount.length + " rows updated");

        writeValidationStatusToCSV(personList);

    } catch (BatchUpdateException e) {
        int [] updateCount = e.getUpdateCounts();

            for (int i = 0; i < updateCount.length; i++) {

                if (updateCount[i] >= 0) {

                    logger.info(updateCount.length + " objects updated.");

                } else if (updateCount[i] == Statement.EXECUTE_FAILED) {

                    ?????
                }
            }
        logger.error(updateCount.length);
        logger.error("BatchUpdateException: " + e);
        logger.error("getNextException: " + e.getNextException());

        try {
            connection.rollback();
        } catch (SQLException e1) {
            logger.error("Rollback error: " + e1, e1);
        }
    } finally {
        if (ps!= null) {
            try {
                ps.close();
            } catch (SQLException e) {
                logger.info(e);
            }
        }
    }
    logger.info("DATA UPDATING FINISHED");
}

I saw a lot of material about how to handle the exception, but none explained or pointed me to the direction of how to retry the next Statements, it means, how to execute the next batch.

How do I manage to do this?

EDIT: I'm using Postgresql

Answer 1

I manage to retry the next batches by surrounding the batch execution with try and catch statements. This way I'm able to catch the BatchUpdateException and call a continue statement.

try {
ps.executeBatch();
connection.commit();
/*Some more code*/

} catch (BatchUpdateException e) {

connection.rollback();
/*Some more code*/

continue;
}

I also used some control logic to "flag" the statements and batches that were already executed and logged them, making it easier to troubleshoot if some statement fails.

Here is the full code:

public void updateTable(List<PersonBean> personList) throws Exception {

logger.info("TABLE UPDATE STARTED");

List <PersonBean> personListValidated = createValidStmtList(personList);

Connection connection = null;
PreparedStatement ps = null;

String updatePersonSQL = "UPDATE Person SET merge_parent_id = ? WHERE id = ?";

input = new FileInputStream("resources/propertiesFiles/applications.properties");
properties.load(input);

final int batchSize = Integer.parseInt(properties.getProperty("batchSize"));

/*A list was used to "flag" the batches that were already executed. BatchStatus objs have only two parameters, number (incremented as the batches are being executed) and status (success or fail).*/
List <BatchStatus> batchStatusList = new ArrayList<BatchStatus>();

 /*This variables will be used to help flag the batches and statements that were already executed.*/
int batchCount = 0;
int stmtAddedToBatchCount = 0;

try {
    connection = DBConnection.getConnection();
    connection.setAutoCommit(false);

    ps = connection.prepareStatement(updatePersonSQL);

    /*personListValidated contains the objects that will be updated in the table. Instead of doing the validation on the update method, I decomposed
     * this part in other 2 methods, making it easier to control of the statements added to the batch.
     */
    for (int i = 0; i < personListValidated.size(); i++) {

        PersonBean personValid = personListValidated.get(i);

        ps.setInt(1, personValid.getMerge_parent_id());
        ps.setInt(2, personValid.getId());
        ps.addBatch();

        personValid.setToBatch("true");

        stmtAddedToBatchCount++;

        logger.info("Row added to batch (count: " + stmtAddedToBatchCount + ")");

        if (stmtAddedToBatchCount % batchSize == 0) {
            batchCount++;

            try {
                ps.executeBatch();
                connection.commit();

                for (int j = stmtAddedToBatchCount - batchSize; j < stmtAddedToBatchCount; j++){

                    personValid = personListValidated.get(j);
                    personValid.setValidationStatus("success");
                }

                BatchStatus batchStatusObj = new BatchStatus(batchCount, "sucess");
                batchStatusList.add(batchStatusObj);   

                logger.info(batchStatusList.get(batchCount - 1));

            } catch (BatchUpdateException e) {

                connection.rollback();

                for (int j = stmtAddedToBatchCount - batchSize; j < stmtAddedToBatchCount; j++){

                    personValid = personListValidated.get(j);
                    personValid.setValidationStatus("fail");
                }

                BatchStatus batchStatusObj = new BatchStatus(batchCount, "fail");
                batchStatusList.add(batchStatusObj);

                logger.info(batchStatusList.get(batchCount - 1));
                logger.error("Bacth execution fail: " + e, e);

                continue;
            }
        }
    }

} catch (SQLException e) {
    logger.error(e, e);
}
int[] lastBatchCount = null;

/*Try and catch to handle the statements executed on the last batch*/
try {
    lastBatchCount = ps.executeBatch();
    connection.commit();

    for (int j = batchStatusList.size() * batchSize; j < stmtAddedToBatchCount; j++){

        PersonBean personValid = personListValidated.get(j);
        personValid.setValidationStatus("success");
    }

    logger.info(lastBatchCount.length + " rows inserted on the last batch");
    logger.info("Last batch excuted");

} catch (BatchUpdateException e) {

    connection.rollback();

    for (int j = batchStatusList.size() * batchSize; j < stmtAddedToBatchCount; j++){

        PersonBean personValid = personListValidated.get(j);
        personValid.setValidationStatus("fail");
    }

    logger.error("Last batch fail to execute: " + e, e);
}
writeValidationStatusToCSV(personList);

logger.info("TABLE UPDATE FINISHED");

}