Java tutorial
/* * Copyright 2004 Clinton Begin * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.toxind.benchmark.thrid.ibatis.sqlmap.engine.execution; import java.sql.BatchUpdateException; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.sql.Types; import java.util.ArrayList; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.ibatis.sqlmap.engine.execution.BatchException; import com.ibatis.sqlmap.engine.execution.BatchResult; import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate; import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap; import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping; import com.ibatis.sqlmap.engine.mapping.result.ResultMap; import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactoryUtil; import com.ibatis.sqlmap.engine.mapping.statement.DefaultRowHandler; import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement; import com.ibatis.sqlmap.engine.mapping.statement.RowHandlerCallback; import com.ibatis.sqlmap.engine.scope.ErrorContext; import com.ibatis.sqlmap.engine.scope.SessionScope; import com.ibatis.sqlmap.engine.scope.StatementScope; /** * Class responsible for executing the SQL */ public class SqlExecutor { // // Constants // /** * Constant to let us know not to skip anything */ public static final int NO_SKIPPED_RESULTS = 0; /** * Constant to let us know to include all records */ public static final int NO_MAXIMUM_RESULTS = -999999; private static final Log log = LogFactory.getLog(SqlExecutor.class); // // Public Methods // /** * Execute an update * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the sql statement to execute * @param parameters * - the parameters for the sql statement * @return - the number of records changed * @throws SQLException * - if the update fails */ public int executeUpdate(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException { ErrorContext errorContext = statementScope.getErrorContext(); errorContext.setActivity("executing update"); errorContext.setObjectId(sql); PreparedStatement ps = null; setupResultObjectFactory(statementScope); int rows = 0; try { errorContext.setMoreInfo("Check the SQL Statement (preparation failed)."); ps = prepareStatement(statementScope.getSession(), conn, sql); setStatementTimeout(statementScope.getStatement(), ps); errorContext.setMoreInfo("Check the parameters (set parameters failed)."); statementScope.getParameterMap().setParameters(statementScope, ps, parameters); errorContext.setMoreInfo("Check the statement (update failed)."); // ========================== print try { if (log.isInfoEnabled()) { int count = ps.getParameterMetaData().getParameterCount(); for (int i = 0; i < count; i++) { sql = sql.replaceFirst("\\?", parameters[i].getClass().getName().equals("java.lang.String") ? "'" + parameters[i].toString() + "'" : parameters[i].toString()); } String[] unPrintSql = { "update dw_websql_sqlcommand a set a.status = 1" }; printSql(sql, unPrintSql); } } catch (Throwable t) { } // =========================== print ps.execute(); rows = ps.getUpdateCount(); } finally { closeStatement(statementScope.getSession(), ps); } return rows; } /** * Adds a statement to a batch * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the sql statement * @param parameters * - the parameters for the statement * @throws SQLException * - if the statement fails */ public void addBatch(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException { Batch batch = (Batch) statementScope.getSession().getBatch(); if (batch == null) { batch = new Batch(); statementScope.getSession().setBatch(batch); } batch.addBatch(statementScope, conn, sql, parameters); } /** * Execute a batch of statements * * @param sessionScope * - the session scope * @return - the number of rows impacted by the batch * @throws SQLException * - if a statement fails */ public int executeBatch(SessionScope sessionScope) throws SQLException { int rows = 0; Batch batch = (Batch) sessionScope.getBatch(); if (batch != null) { try { rows = batch.executeBatch(); } finally { batch.cleanupBatch(sessionScope); } } return rows; } /** * Execute a batch of statements * * @param sessionScope * - the session scope * @return - a List of BatchResult objects (may be null if no batch has been * initiated). There will be one BatchResult object in the list for * each sub-batch executed * @throws SQLException * if a database access error occurs, or the drive does not * support batch statements * @throws BatchException * if the driver throws BatchUpdateException */ @SuppressWarnings("rawtypes") public List executeBatchDetailed(SessionScope sessionScope) throws SQLException, BatchException { List answer = null; Batch batch = (Batch) sessionScope.getBatch(); if (batch != null) { try { answer = batch.executeBatchDetailed(); } finally { batch.cleanupBatch(sessionScope); } } return answer; } /** * Long form of the method to execute a query * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the SQL statement to execute * @param parameters * - the parameters for the statement * @param skipResults * - the number of results to skip * @param maxResults * - the maximum number of results to return * @param callback * - the row handler for the query * @throws SQLException * - if the query fails */ public void executeQuery(StatementScope statementScope, Connection conn, String sql, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException { ErrorContext errorContext = statementScope.getErrorContext(); errorContext.setActivity("executing query"); errorContext.setObjectId(sql); PreparedStatement ps = null; ResultSet rs = null; setupResultObjectFactory(statementScope); try { errorContext.setMoreInfo("Check the SQL Statement (preparation failed)."); Integer rsType = statementScope.getStatement().getResultSetType(); if (rsType != null) { ps = prepareStatement(statementScope.getSession(), conn, sql, rsType); } else { ps = prepareStatement(statementScope.getSession(), conn, sql); } setStatementTimeout(statementScope.getStatement(), ps); Integer fetchSize = statementScope.getStatement().getFetchSize(); if (fetchSize != null) { ps.setFetchSize(fetchSize.intValue()); } errorContext.setMoreInfo("Check the parameters (set parameters failed)."); statementScope.getParameterMap().setParameters(statementScope, ps, parameters); errorContext.setMoreInfo("Check the statement (query failed)."); // ========================== print if (log.isInfoEnabled()) { int count = ps.getParameterMetaData().getParameterCount(); for (int i = 0; i < count; i++) { sql = sql.replaceFirst("\\?", parameters[i].getClass().getName().equals("java.lang.String") ? "'" + parameters[i].toString() + "'" : parameters[i].toString()); } String[] unPrintSql = { "select * from dw_websql_sqlcommand a where a.ds_id ", "select count(1) from dw_websql_sqlcommand ", "select sql_id , user_code , submit_sql ,", "select * from dw_websql_sqlcommand" }; printSql(sql, unPrintSql); } // =========================== print ps.execute(); errorContext.setMoreInfo("Check the results (failed to retrieve results)."); // Begin ResultSet Handling rs = handleMultipleResults(ps, statementScope, skipResults, maxResults, callback); // End ResultSet Handling } finally { try { closeResultSet(rs); } finally { closeStatement(statementScope.getSession(), ps); } } } private void printSql(String sql, String[] unPrintSql) { boolean isPrint = true; for (String str : unPrintSql) { if (sql.trim().replaceAll(" +", " ").startsWith(str)) { isPrint = false; break; } } if (isPrint) { // String printSql = sql.replaceAll(" +", " "); // int printSqlLen = printSql.length(); // String tmp = ""; // int lineCount = 70; // boolean isFirstLine = true; // boolean addTail = false; // String pre = "\t\t\t"; // while(printSqlLen > lineCount){ // if(!isFirstLine){ // tmp += pre; // } // tmp += printSql.substring(0, lineCount); // tmp += "\r\n"; // printSql = printSql.substring(lineCount); // printSqlLen = printSql.length(); // if(isFirstLine){ // lineCount += 30; // } // isFirstLine = false; // addTail = true; // // } // log.info("## " + tmp + (addTail?pre:"")+printSql + " ##"); log.info("## " + sql.trim().replaceAll(" +", " ") + " ##"); } } /** * Execute a stored procedure that updates data * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the SQL to call the procedure * @param parameters * - the parameters for the procedure * @return - the rows impacted by the procedure * @throws SQLException * - if the procedure fails */ public int executeUpdateProcedure(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException { ErrorContext errorContext = statementScope.getErrorContext(); errorContext.setActivity("executing update procedure"); errorContext.setObjectId(sql); CallableStatement cs = null; setupResultObjectFactory(statementScope); int rows = 0; try { errorContext.setMoreInfo("Check the SQL Statement (preparation failed)."); cs = prepareCall(statementScope.getSession(), conn, sql); setStatementTimeout(statementScope.getStatement(), cs); ParameterMap parameterMap = statementScope.getParameterMap(); ParameterMapping[] mappings = parameterMap.getParameterMappings(); errorContext.setMoreInfo("Check the output parameters (register output parameters failed)."); registerOutputParameters(cs, mappings); errorContext.setMoreInfo("Check the parameters (set parameters failed)."); parameterMap.setParameters(statementScope, cs, parameters); errorContext.setMoreInfo("Check the statement (update procedure failed)."); cs.execute(); rows = cs.getUpdateCount(); errorContext.setMoreInfo("Check the output parameters (retrieval of output parameters failed)."); retrieveOutputParameters(statementScope, cs, mappings, parameters, null); } finally { closeStatement(statementScope.getSession(), cs); } return rows; } /** * Execute a stored procedure * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the sql to call the procedure * @param parameters * - the parameters for the procedure * @param skipResults * - the number of results to skip * @param maxResults * - the maximum number of results to return * @param callback * - a row handler for processing the results * @throws SQLException * - if the procedure fails */ public void executeQueryProcedure(StatementScope statementScope, Connection conn, String sql, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException { ErrorContext errorContext = statementScope.getErrorContext(); errorContext.setActivity("executing query procedure"); errorContext.setObjectId(sql); CallableStatement cs = null; ResultSet rs = null; setupResultObjectFactory(statementScope); try { errorContext.setMoreInfo("Check the SQL Statement (preparation failed)."); Integer rsType = statementScope.getStatement().getResultSetType(); if (rsType != null) { cs = prepareCall(statementScope.getSession(), conn, sql, rsType); } else { cs = prepareCall(statementScope.getSession(), conn, sql); } setStatementTimeout(statementScope.getStatement(), cs); Integer fetchSize = statementScope.getStatement().getFetchSize(); if (fetchSize != null) { cs.setFetchSize(fetchSize.intValue()); } ParameterMap parameterMap = statementScope.getParameterMap(); ParameterMapping[] mappings = parameterMap.getParameterMappings(); errorContext.setMoreInfo("Check the output parameters (register output parameters failed)."); registerOutputParameters(cs, mappings); errorContext.setMoreInfo("Check the parameters (set parameters failed)."); parameterMap.setParameters(statementScope, cs, parameters); errorContext.setMoreInfo("Check the statement (update procedure failed)."); cs.execute(); errorContext.setMoreInfo("Check the results (failed to retrieve results)."); // Begin ResultSet Handling rs = handleMultipleResults(cs, statementScope, skipResults, maxResults, callback); // End ResultSet Handling errorContext.setMoreInfo("Check the output parameters (retrieval of output parameters failed)."); retrieveOutputParameters(statementScope, cs, mappings, parameters, callback); } finally { try { closeResultSet(rs); } finally { closeStatement(statementScope.getSession(), cs); } } } @SuppressWarnings({ "unchecked", "rawtypes" }) private ResultSet handleMultipleResults(PreparedStatement ps, StatementScope statementScope, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException { ResultSet rs; rs = getFirstResultSet(statementScope, ps); if (rs != null) { handleResults(statementScope, rs, skipResults, maxResults, callback); } // Multiple ResultSet handling if (callback.getRowHandler() instanceof DefaultRowHandler) { MappedStatement statement = statementScope.getStatement(); DefaultRowHandler defaultRowHandler = ((DefaultRowHandler) callback.getRowHandler()); if (statement.hasMultipleResultMaps()) { List multipleResults = new ArrayList(); multipleResults.add(defaultRowHandler.getList()); ResultMap[] resultMaps = statement.getAdditionalResultMaps(); int i = 0; while (moveToNextResultsSafely(statementScope, ps)) { if (i >= resultMaps.length) break; ResultMap rm = resultMaps[i]; statementScope.setResultMap(rm); rs = ps.getResultSet(); DefaultRowHandler rh = new DefaultRowHandler(); handleResults(statementScope, rs, skipResults, maxResults, new RowHandlerCallback(rm, null, rh)); multipleResults.add(rh.getList()); i++; } defaultRowHandler.setList(multipleResults); statementScope.setResultMap(statement.getResultMap()); } else { while (moveToNextResultsSafely(statementScope, ps)) ; } } // End additional ResultSet handling return rs; } private ResultSet getFirstResultSet(StatementScope scope, Statement stmt) throws SQLException { ResultSet rs = null; boolean hasMoreResults = true; while (hasMoreResults) { rs = stmt.getResultSet(); if (rs != null) { break; } hasMoreResults = moveToNextResultsIfPresent(scope, stmt); } return rs; } private boolean moveToNextResultsIfPresent(StatementScope scope, Statement stmt) throws SQLException { boolean moreResults; // This is the messed up JDBC approach for determining if there are more // results moreResults = !(((moveToNextResultsSafely(scope, stmt) == false) && (stmt.getUpdateCount() == -1))); return moreResults; } private boolean moveToNextResultsSafely(StatementScope scope, Statement stmt) throws SQLException { if (forceMultipleResultSetSupport(scope) || stmt.getConnection().getMetaData().supportsMultipleResultSets()) { return stmt.getMoreResults(); } return false; } private boolean forceMultipleResultSetSupport(StatementScope scope) { return ((SqlMapClientImpl) scope.getSession().getSqlMapClient()).getDelegate() .isForceMultipleResultSetSupport(); } private void handleResults(StatementScope statementScope, ResultSet rs, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException { try { statementScope.setResultSet(rs); ResultMap resultMap = statementScope.getResultMap(); if (resultMap != null) { // Skip Results if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) { if (skipResults > 0) { rs.absolute(skipResults); } } else { for (int i = 0; i < skipResults; i++) { if (!rs.next()) { return; } } } // Get Results int resultsFetched = 0; while ((maxResults == SqlExecutor.NO_MAXIMUM_RESULTS || resultsFetched < maxResults) && rs.next()) { Object[] columnValues = resultMap.resolveSubMap(statementScope, rs).getResults(statementScope, rs); callback.handleResultObject(statementScope, columnValues, rs); resultsFetched++; } } } finally { statementScope.setResultSet(null); } } private void retrieveOutputParameters(StatementScope statementScope, CallableStatement cs, ParameterMapping[] mappings, Object[] parameters, RowHandlerCallback callback) throws SQLException { for (int i = 0; i < mappings.length; i++) { ParameterMapping mapping = ((ParameterMapping) mappings[i]); if (mapping.isOutputAllowed()) { if ("java.sql.ResultSet".equalsIgnoreCase(mapping.getJavaTypeName())) { ResultSet rs = (ResultSet) cs.getObject(i + 1); ResultMap resultMap; if (mapping.getResultMapName() == null) { resultMap = statementScope.getResultMap(); handleOutputParameterResults(statementScope, resultMap, rs, callback); } else { SqlMapClientImpl client = (SqlMapClientImpl) statementScope.getSession().getSqlMapClient(); resultMap = client.getDelegate().getResultMap(mapping.getResultMapName()); DefaultRowHandler rowHandler = new DefaultRowHandler(); RowHandlerCallback handlerCallback = new RowHandlerCallback(resultMap, null, rowHandler); handleOutputParameterResults(statementScope, resultMap, rs, handlerCallback); parameters[i] = rowHandler.getList(); } rs.close(); } else { parameters[i] = mapping.getTypeHandler().getResult(cs, i + 1); } } } } private void registerOutputParameters(CallableStatement cs, ParameterMapping[] mappings) throws SQLException { for (int i = 0; i < mappings.length; i++) { ParameterMapping mapping = ((ParameterMapping) mappings[i]); if (mapping.isOutputAllowed()) { if (null != mapping.getTypeName() && !mapping.getTypeName().equals("")) { // @added cs.registerOutParameter(i + 1, mapping.getJdbcType(), mapping.getTypeName()); } else { if (mapping.getNumericScale() != null && (mapping.getJdbcType() == Types.NUMERIC || mapping.getJdbcType() == Types.DECIMAL)) { cs.registerOutParameter(i + 1, mapping.getJdbcType(), mapping.getNumericScale().intValue()); } else { cs.registerOutParameter(i + 1, mapping.getJdbcType()); } } } } } private void handleOutputParameterResults(StatementScope statementScope, ResultMap resultMap, ResultSet rs, RowHandlerCallback callback) throws SQLException { ResultMap orig = statementScope.getResultMap(); try { statementScope.setResultSet(rs); if (resultMap != null) { statementScope.setResultMap(resultMap); // Get Results while (rs.next()) { Object[] columnValues = resultMap.resolveSubMap(statementScope, rs).getResults(statementScope, rs); callback.handleResultObject(statementScope, columnValues, rs); } } } finally { statementScope.setResultSet(null); statementScope.setResultMap(orig); } } /** * Clean up any batches on the session * * @param sessionScope * - the session to clean up */ public void cleanup(SessionScope sessionScope) { Batch batch = (Batch) sessionScope.getBatch(); if (batch != null) { batch.cleanupBatch(sessionScope); sessionScope.setBatch(null); } } private PreparedStatement prepareStatement(SessionScope sessionScope, Connection conn, String sql, Integer rsType) throws SQLException { SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate(); if (sessionScope.hasPreparedStatementFor(sql)) { return sessionScope.getPreparedStatement((sql)); } else { PreparedStatement ps = conn.prepareStatement(sql, rsType.intValue(), ResultSet.CONCUR_READ_ONLY); sessionScope.putPreparedStatement(delegate, sql, ps); return ps; } } private CallableStatement prepareCall(SessionScope sessionScope, Connection conn, String sql, Integer rsType) throws SQLException { SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate(); if (sessionScope.hasPreparedStatementFor(sql)) { return (CallableStatement) sessionScope.getPreparedStatement((sql)); } else { CallableStatement cs = conn.prepareCall(sql, rsType.intValue(), ResultSet.CONCUR_READ_ONLY); sessionScope.putPreparedStatement(delegate, sql, cs); return cs; } } private static PreparedStatement prepareStatement(SessionScope sessionScope, Connection conn, String sql) throws SQLException { SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate(); if (sessionScope.hasPreparedStatementFor(sql)) { return sessionScope.getPreparedStatement((sql)); } else { PreparedStatement ps = conn.prepareStatement(sql); sessionScope.putPreparedStatement(delegate, sql, ps); return ps; } } private CallableStatement prepareCall(SessionScope sessionScope, Connection conn, String sql) throws SQLException { SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate(); if (sessionScope.hasPreparedStatementFor(sql)) { return (CallableStatement) sessionScope.getPreparedStatement((sql)); } else { CallableStatement cs = conn.prepareCall(sql); sessionScope.putPreparedStatement(delegate, sql, cs); return cs; } } private static void closeStatement(SessionScope sessionScope, PreparedStatement ps) { if (ps != null) { if (!sessionScope.hasPreparedStatement(ps)) { try { ps.close(); } catch (SQLException e) { // ignore } } } } /** * @param rs */ private static void closeResultSet(ResultSet rs) { if (rs != null) { try { rs.close(); } catch (SQLException e) { // ignore } } } private static void setStatementTimeout(MappedStatement mappedStatement, Statement statement) throws SQLException { if (mappedStatement.getTimeout() != null) { statement.setQueryTimeout(mappedStatement.getTimeout().intValue()); } } // // Inner Classes // private static class Batch { private String currentSql; @SuppressWarnings("rawtypes") private List statementList = new ArrayList(); @SuppressWarnings("rawtypes") private List batchResultList = new ArrayList(); private int size; /** * Create a new batch */ public Batch() { this.size = 0; } /** * Getter for the batch size * * @return - the batch size */ @SuppressWarnings("unused") public int getSize() { return size; } /** * Add a prepared statement to the batch * * @param statementScope * - the request scope * @param conn * - the database connection * @param sql * - the SQL to add * @param parameters * - the parameters for the SQL * @throws SQLException * - if the prepare for the SQL fails */ @SuppressWarnings("unchecked") public void addBatch(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException { PreparedStatement ps = null; if (currentSql != null && currentSql.equals(sql)) { int last = statementList.size() - 1; ps = (PreparedStatement) statementList.get(last); } else { ps = prepareStatement(statementScope.getSession(), conn, sql); setStatementTimeout(statementScope.getStatement(), ps); currentSql = sql; statementList.add(ps); batchResultList.add(new BatchResult(statementScope.getStatement().getId(), sql)); } statementScope.getParameterMap().setParameters(statementScope, ps, parameters); ps.addBatch(); size++; } /** * TODO (Jeff Butler) - maybe this method should be deprecated in some * release, and then removed in some even later release. * executeBatchDetailed gives much more complete information. * <p/> * Execute the current session's batch * * @return - the number of rows updated * @throws SQLException * - if the batch fails */ public int executeBatch() throws SQLException { int totalRowCount = 0; for (int i = 0, n = statementList.size(); i < n; i++) { PreparedStatement ps = (PreparedStatement) statementList.get(i); int[] rowCounts = ps.executeBatch(); for (int j = 0; j < rowCounts.length; j++) { if (rowCounts[j] == Statement.SUCCESS_NO_INFO) { // do nothing } else if (rowCounts[j] == Statement.EXECUTE_FAILED) { throw new SQLException("The batched statement at index " + j + " failed to execute."); } else { totalRowCount += rowCounts[j]; } } } return totalRowCount; } /** * Batch execution method that returns all the information the driver * has to offer. * * @return a List of BatchResult objects * @throws BatchException * (an SQLException sub class) if any nested batch fails * @throws SQLException * if a database access error occurs, or the drive does not * support batch statements * @throws BatchException * if the driver throws BatchUpdateException */ @SuppressWarnings({ "rawtypes", "unchecked" }) public List executeBatchDetailed() throws SQLException, BatchException { List answer = new ArrayList(); for (int i = 0, n = statementList.size(); i < n; i++) { BatchResult br = (BatchResult) batchResultList.get(i); PreparedStatement ps = (PreparedStatement) statementList.get(i); try { br.setUpdateCounts(ps.executeBatch()); } catch (BatchUpdateException e) { StringBuffer message = new StringBuffer(); message.append("Sub batch number "); message.append(i + 1); message.append(" failed."); if (i > 0) { message.append(" "); message.append(i); message.append(" prior sub batch(s) completed successfully, but will be rolled back."); } throw new BatchException(message.toString(), e, answer, br.getStatementId(), br.getSql()); } answer.add(br); } return answer; } /** * Close all the statements in the batch and clear all the statements * * @param sessionScope */ public void cleanupBatch(SessionScope sessionScope) { for (int i = 0, n = statementList.size(); i < n; i++) { PreparedStatement ps = (PreparedStatement) statementList.get(i); closeStatement(sessionScope, ps); } currentSql = null; statementList.clear(); batchResultList.clear(); size = 0; } } private void setupResultObjectFactory(StatementScope statementScope) { SqlMapClientImpl client = (SqlMapClientImpl) statementScope.getSession().getSqlMapClient(); ResultObjectFactoryUtil.setResultObjectFactory(client.getResultObjectFactory()); ResultObjectFactoryUtil.setStatementId(statementScope.getStatement().getId()); } }