org.apache.ibatis.executor.BatchResult Java Examples

protected FlushResult postProcessBatchFailure(List<DbOperation> operations, RuntimeException e) {
  BatchExecutorException batchExecutorException = ExceptionUtil.findBatchExecutorException(e);

  if (batchExecutorException == null) {
    // Unexpected exception
    throw e;
  }

  List<BatchResult> successfulBatches = batchExecutorException.getSuccessfulBatchResults();
  BatchUpdateException cause = batchExecutorException.getBatchUpdateException();

  Iterator<DbOperation> operationsIt = operations.iterator();
  List<DbOperation> failedOperations = new ArrayList<>();

  for (BatchResult successfulBatch : successfulBatches) {
    postProcessJdbcBatchResult(operationsIt, successfulBatch.getUpdateCounts(), null, failedOperations);
  }

  int[] failedBatchUpdateCounts = cause.getUpdateCounts();
  postProcessJdbcBatchResult(operationsIt, failedBatchUpdateCounts, e, failedOperations);

  List<DbOperation> remainingOperations = CollectionUtil.collectInList(operationsIt);
  return FlushResult.withFailuresAndRemaining(failedOperations, remainingOperations);
}
 

protected FlushResult postProcessBatchSuccess(List<DbOperation> operations, List<BatchResult> batchResults) {
  Iterator<DbOperation> operationsIt = operations.iterator();
  List<DbOperation> failedOperations = new ArrayList<>();
  for (BatchResult successfulBatch : batchResults) {
    // even if all batches are successful, there can be concurrent modification failures
    // (e.g. 0 rows updated)
    postProcessJdbcBatchResult(operationsIt, successfulBatch.getUpdateCounts(), null, failedOperations);
  }

  // there should be no more operations remaining
  if (operationsIt.hasNext()) {
    throw LOG.wrongBatchResultsSizeException(operations);
  }

  return FlushResult.withFailures(failedOperations);
}
 

@Override
public FlushResult executeDbOperations(List<DbOperation> operations) {
  for (int i = 0; i < operations.size(); i++) {

    DbOperation operation = operations.get(i);

    // stages all operations
    executeDbOperation(operation);
  }

  List<BatchResult> batchResults;
  try {
    // applies all operations
    batchResults = flushBatchOperations();
  } catch (RuntimeException e) {
    return postProcessBatchFailure(operations, e);
  }

  return postProcessBatchSuccess(operations, batchResults);
}
 

@Ignore // Not supported yet in PostgreSQL
@Test
public void testInsertMappedBatch() throws Exception {
  Reader reader = Resources.getResourceAsReader("org/apache/ibatis/submitted/keycolumn/MapperConfig.xml");
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
  try {
    InsertMapper mapper = sqlSession.getMapper(InsertMapper.class);
    Name name = new Name();
    name.setFirstName("Fred");
    name.setLastName("Flintstone");
    mapper.insertNameMapped(name);
    Name name2 = new Name();
    name2.setFirstName("Wilma");
    name2.setLastName("Flintstone");
    mapper.insertNameMapped(name2);
    List<BatchResult> batchResults = sqlSession.flushStatements();
    assertNotNull(name.getId());
    assertNotNull(name2.getId());
    assertEquals(1, batchResults.size());
  } finally {
    sqlSession.close();
  }
}
 

@Test
public void shouldAcceptDifferentTypeInTheSameBatch() {
  SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
  try {
    ObjA a = new ObjA();
    a.setId(1);
    a.setName(111);
    sqlSession.insert("insertUser", a);
    ObjB b = new ObjB();
    b.setId(2);
    b.setName("222");
    sqlSession.insert("insertUser", b);
    List<BatchResult> batchResults = sqlSession.flushStatements();
    batchResults.clear();
    sqlSession.clearCache();
    sqlSession.commit();
    List<User> users = sqlSession.selectList("selectUser");
    assertEquals(2, users.size());
  } finally {
    sqlSession.close();
  }
}
 

@Ignore // Not supported yet in PostgreSQL
@Test
public void testInsertMappedBatch() throws Exception {
  Reader reader = Resources.getResourceAsReader("org/apache/ibatis/submitted/keycolumn/MapperConfig.xml");
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
  try {
    InsertMapper mapper = sqlSession.getMapper(InsertMapper.class);
    Name name = new Name();
    name.setFirstName("Fred");
    name.setLastName("Flintstone");
    mapper.insertNameMapped(name);
    Name name2 = new Name();
    name2.setFirstName("Wilma");
    name2.setLastName("Flintstone");
    mapper.insertNameMapped(name2);
    List<BatchResult> batchResults = sqlSession.flushStatements();
    assertNotNull(name.getId());
    assertNotNull(name2.getId());
    assertEquals(1, batchResults.size());
  } finally {
    sqlSession.close();
  }
}
 

@Test
public void shouldAcceptDifferentTypeInTheSameBatch() {
  SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
  try {
    ObjA a = new ObjA();
    a.setId(1);
    a.setName(111);
    sqlSession.insert("insertUser", a);
    ObjB b = new ObjB();
    b.setId(2);
    b.setName("222");
    sqlSession.insert("insertUser", b);
    List<BatchResult> batchResults = sqlSession.flushStatements();
    batchResults.clear();
    sqlSession.clearCache();
    sqlSession.commit();
    List<User> users = sqlSession.selectList("selectUser");
    assertEquals(2, users.size());
  } finally {
    sqlSession.close();
  }
}
 

@Override
public List<BatchResult> flushStatements() {
  try {
    //转而用执行器来flushStatements
    return executor.flushStatements();
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error flushing statements.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}
 

public void printBatchResults(List<BatchResult> results) {
  if (results.size() > 0) {
    StringBuilder sb = new StringBuilder();
    sb.append("Batch summary:\n");
    for (int i = 0; i < results.size(); i++) {
      BatchResult result = results.get(i);
      sb.append("Result ").append(i).append(":\t");
      sb.append(result.getSql().replaceAll("\n", "").replaceAll("\\s+", " ")).append("\t");
      sb.append("Update counts: ").append(Arrays.toString(result.getUpdateCounts())).append("\n");
    }
    logDebug("082", sb.toString());
  }
}
 

@Override
public List<BatchResult> flushStatements() {
  final SqlSession sqlSession = localSqlSession.get();
  if (sqlSession == null) {
    throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
  }
  return sqlSession.flushStatements();
}
 

@Override
public List<BatchResult> flushStatements() {
  try {
    //转而用执行器来flushStatements
    return executor.flushStatements();
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error flushing statements.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}
 

@Override
public List<BatchResult> flushStatements() {
  final SqlSession sqlSession = localSqlSession.get();
  if (sqlSession == null) {
    throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
  }
  return sqlSession.flushStatements();
}
 

@Override
public List<BatchResult> flushStatements()
{
    return this.sqlSession.flushStatements();
}
 

public List<BatchResult> flushStatements() {
  return wrappedSession.flushStatements();
}
 

public List<BatchResult> flushBatchOperations() {
  return sqlSession.flushStatements();
}
 

@Override
protected List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
  throw new UnsupportedOperationException("Not supported.");
}
 

@Override
public List<BatchResult> flushStatements() {
	return real.flushStatements();
}
 

@Override
protected List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
  throw new UnsupportedOperationException("Not supported.");
}
 

@Override
public List<BatchResult> flushStatements() throws SQLException {
  return delegate.flushStatements();
}
 

@Override
public List<BatchResult> flushStatements() {
	return this.writeSession().flushStatements();
}
 

/**
 * Flushes batch statements.
 * 刷新批处理语句,返回批处理结果
 * @return BatchResult list of updated records
 * @since 3.0.6
 */
List<BatchResult> flushStatements();
 

/**
 * このメソッドは {@link org.apache.ibatis.session.SqlSession#flushStatements()} への単純な委譲です。
 * {@inheritDoc}
 */
public List<BatchResult> flushStatements() {
    return delegate.flushStatements();
}
 

/**
 * Flushes batch statements.
 * 刷新批处理语句,返回批处理结果
 * @return BatchResult list of updated records
 * @since 3.0.6
 */
List<BatchResult> flushStatements();
 

/**
 * {@inheritDoc}
 * @since 1.0.2
 */
public List<BatchResult> flushStatements() {
    return this.sqlSessionProxy.flushStatements();
}
 

/**
 * {@inheritDoc}
 * @since 1.0.2
 */
public List<BatchResult> flushStatements() {
    return this.sqlSessionProxy.flushStatements();
}
 

/**
 * {@inheritDoc}
 *
 * @since 1.0.2
 */
public List<BatchResult> flushStatements() {
    return this.sqlSessionProxy.flushStatements();
}