import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void exceptionsThrownShouldBeTraced() throws Exception {
    // Given
    when(this.mockSqlMapExecutorDelegate.beginSessionScope()).thenReturn(null);
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    try {
        sqlMapClient.insert("insertShouldThrowNPE");
        fail("sqlMapClient.insert should throw NullPointerException");
    } catch (NullPointerException e) {
        // Then
        final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
        assertThat(spanEvents.size(), is(1));
        final SpanEventBo exceptionSpanEventBo = spanEvents.get(0);
        assertThat(exceptionSpanEventBo.hasException(), is(true));
        assertThat(exceptionSpanEventBo.getExceptionId(), not(0));
    }
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void nullParametersShouldNotBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.insert(null);
    sqlMapClient.queryForList(null);
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(2));

    // Check Method
    final SpanEventBo insertSpanEventBo = spanEvents.get(0);
    final SpanEventBo queryForListSpanEventBo = spanEvents.get(1);
    assertThat(insertSpanEventBo.getApiId(), not(0));
    assertThat(queryForListSpanEventBo.getApiId(), not(0));
    assertThat(insertSpanEventBo.getApiId(), not(queryForListSpanEventBo.getApiId()));

    // Check Parameter
    assertNull(insertSpanEventBo.getAnnotationBoList());
    assertNull(queryForListSpanEventBo.getAnnotationBoList());
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void sameApiCallsShouldHaveTheSameApiId() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.insert("insertA");
    sqlMapClient.insert("insertB");
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(2));

    // Check Method
    final SpanEventBo insertASpanEventBo = spanEvents.get(0);
    final SpanEventBo insertBSpanEventBo = spanEvents.get(1);
    assertThat(insertASpanEventBo.getApiId(), not(0));
    assertThat(insertBSpanEventBo.getApiId(), not(0));
    assertThat(insertASpanEventBo.getApiId(), is(insertBSpanEventBo.getApiId()));

}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void queryForListShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.queryForList("abc");
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(1));

    // Check Method
    final SpanEventBo apiCallSpanEventBo = spanEvents.get(0);
    assertThat(apiCallSpanEventBo.getApiId(), not(0));

    // Check Parameter
    final List<AnnotationBo> annotationBoList = apiCallSpanEventBo.getAnnotationBoList();
    assertThat(annotationBoList.size(), is(1));

    final AnnotationBo parameterAnnotationBo = annotationBoList.get(0);
    assertThat(parameterAnnotationBo.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void queryForObjectShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.queryForObject("abrgrgfdaghertah", new Object());
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(1));

    // Check Method
    final SpanEventBo apiCallSpanEventBo = spanEvents.get(0);
    assertThat(apiCallSpanEventBo.getApiId(), not(0));

    // Check Parameter
    final List<AnnotationBo> annotationBoList = apiCallSpanEventBo.getAnnotationBoList();
    assertThat(annotationBoList.size(), is(1));

    final AnnotationBo parameterAnnotationBo = annotationBoList.get(0);
    assertThat(parameterAnnotationBo.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
protected static Object getResult(SqlMapClientImpl client, String statementName, Object parameterObject,
    Class targetType) throws SQLException {
  Object value = null;
  if (DomCollectionTypeMarker.class.isAssignableFrom(targetType)) {
    value = client.queryForList(statementName, parameterObject);
  } else if (Set.class.isAssignableFrom(targetType)) {
    value = new HashSet(client.queryForList(statementName, parameterObject));
  } else if (Collection.class.isAssignableFrom(targetType)) {
    value = client.queryForList(statementName, parameterObject);
  } else if (targetType.isArray()) {
    List list = client.queryForList(statementName, parameterObject);
    value = listToArray(list, targetType.getComponentType());
  } else {
    value = client.queryForObject(statementName, parameterObject);
  }
  return value;
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
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);
      }
    }
  }
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
/**
 * Mock a {@link SqlMapClientImpl} which returns a {@link Bean1} for the id <code>bean1</code> and {@link Bean2} for
 * id <code>bean2</code>.
 */
private SqlMapClientImpl setupMockSqlMapClientImpl() {
  SqlMapExecutorDelegate delegate = new SqlMapExecutorDelegate();
  SqlMapClientImpl client = new SqlMapClientImpl(delegate) {
    @Override
    public Object queryForObject(String id, Object paramObject) throws SQLException {
      if ("bean1".equals(id)) {
        return new Bean1();
      } else if ("bean2".equals(id)) {
        Bean2 bean = new Bean2();
        EnhancedLazyResultLoader loader = new EnhancedLazyResultLoader(this, "bean1", null, Bean1.class);
        bean.setBean1((Bean1) loader.loadResult());
        return bean;
      } else if ("bean3".equals(id)) {
        return null;
      }
      fail();
      return null;
    }
  };
  return client;
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
public String getSQL(String id,Object params){
	
	try {
		SqlMapClientImpl sci = (SqlMapClientImpl)this.sqlMapClientTemplate.getSqlMapClient();  
    	MappedStatement ms = sci.getMappedStatement(id);  
    	          
    	Sql sql = ms.getSql();    
    	        
    	SessionScope sessionScope = new SessionScope();       
    	sessionScope.incrementRequestStackDepth();       
    	StatementScope statementScope = new StatementScope(sessionScope);       
    	ms.initRequest(statementScope);      
    	ms.getCacheKey(statementScope, params);  
    	
    	String sqlString = sql.getSql(statementScope, params);
    	Object[] sqlParam = sql.getParameterMap(statementScope, params).getParameterObjectValues(statementScope, params);  
    	
    	int sqlParamLen = sqlParam.length;
    	if (sqlParam != null && sqlParamLen > 0) {
    		for (int i=0; i < sqlParamLen; i++) {
    			if (sqlParam[i] instanceof Integer) {
    				sqlString = sqlString.replaceFirst("\\?", sqlParam[i].toString());
    			}
    			else if (sqlParam[i] instanceof String) {
    				sqlString = sqlString.replaceFirst("\\?", "'" + sqlParam[i].toString() + "'");
    			}
    		}
    	}
    	return sqlString;
	} catch (Exception ex) {
		LogConstant.error(ex.getMessage(), ex);
		LogConstant.error("获取SQL 出错, id: " + id);
	}
	
	return "[未能获取 SQL语句](id: " + id + ")";

}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test(expected=NullPointerException.class)
public void test() throws SQLException {
    // Given
    when(this.mockSqlMapExecutorDelegate.beginSessionScope()).thenReturn(null);
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.insert("insertShouldThrowNPE");
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void insertShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.insert("insertId");
    sqlMapClient.insert("insertId", new Object());
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(2));

    // Check Method
    final SpanEventBo insertWith1ArgSpanEventBo = spanEvents.get(0);
    final SpanEventBo insertWith2ArgSpanEventBo = spanEvents.get(1);
    assertThat(insertWith1ArgSpanEventBo.getApiId(), not(0));
    assertThat(insertWith2ArgSpanEventBo.getApiId(), not(0));
    assertThat(insertWith1ArgSpanEventBo.getApiId(), not(insertWith2ArgSpanEventBo.getApiId()));

    // Check Parameter
    final List<AnnotationBo> insertWith1ArgAnnotations = insertWith1ArgSpanEventBo.getAnnotationBoList();
    assertThat(insertWith1ArgAnnotations.size(), is(1));
    final AnnotationBo insertWith1ArgParameterAnnotation = insertWith1ArgAnnotations.get(0);
    assertThat(insertWith1ArgParameterAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));

    final List<AnnotationBo> insertWith2ArgAnnotations = insertWith2ArgSpanEventBo.getAnnotationBoList();
    assertThat(insertWith2ArgAnnotations.size(), is(1));
    final AnnotationBo insertWith2ArgAnnotation = insertWith2ArgAnnotations.get(0);
    assertThat(insertWith2ArgAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));

}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void deleteShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.delete("deleteId");
    sqlMapClient.delete("deleteId", new Object());
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(2));

    // Check Method
    final SpanEventBo deleteWith1ArgSpanEvent = spanEvents.get(0);
    final SpanEventBo deleteWith2ArgSpanEvent = spanEvents.get(1);
    assertThat(deleteWith1ArgSpanEvent.getApiId(), not(0));
    assertThat(deleteWith2ArgSpanEvent.getApiId(), not(0));
    assertThat(deleteWith1ArgSpanEvent.getApiId(), not(deleteWith2ArgSpanEvent.getApiId()));

    // Check Parameter
    final List<AnnotationBo> deleteWith1ArgAnnotations = deleteWith1ArgSpanEvent.getAnnotationBoList();
    assertThat(deleteWith1ArgAnnotations.size(), is(1));
    final AnnotationBo deleteWith1ArgParameterAnnotation = deleteWith1ArgAnnotations.get(0);
    assertThat(deleteWith1ArgParameterAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));

    final List<AnnotationBo> deleteWith2ArgAnnotations = deleteWith2ArgSpanEvent.getAnnotationBoList();
    assertThat(deleteWith2ArgAnnotations.size(), is(1));
    final AnnotationBo deleteWith2ArgAnnotation = deleteWith2ArgAnnotations.get(0);
    assertThat(deleteWith2ArgAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Test
public void updateShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.update("updateId");
    sqlMapClient.update("updateId", new Object());
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(2));

    // Check Method
    final SpanEventBo updateWith1ArgSpanEvent = spanEvents.get(0);
    final SpanEventBo updateWith2ArgSpanEvent = spanEvents.get(1);
    assertThat(updateWith1ArgSpanEvent.getApiId(), not(0));
    assertThat(updateWith2ArgSpanEvent.getApiId(), not(0));
    assertThat(updateWith1ArgSpanEvent.getApiId(), not(updateWith2ArgSpanEvent.getApiId()));

    // Check Parameter
    final List<AnnotationBo> updateWith1ArgAnnotations = updateWith1ArgSpanEvent.getAnnotationBoList();
    assertThat(updateWith1ArgAnnotations.size(), is(1));
    final AnnotationBo updateWith1ArgParameterAnnotation = updateWith1ArgAnnotations.get(0);
    assertThat(updateWith1ArgParameterAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));

    final List<AnnotationBo> updateWith2ArgAnnotations = updateWith2ArgSpanEvent.getAnnotationBoList();
    assertThat(updateWith2ArgAnnotations.size(), is(1));
    final AnnotationBo updateWith2ArgAnnotation = updateWith2ArgAnnotations.get(0);
    assertThat(updateWith2ArgAnnotation.getKey(), is(AnnotationKey.CACHE_ARGS0.getCode()));

}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
@Ignore // Changed to trace only query operations
@Test
public void transactionsShouldBeTraced() throws Exception {
    // Given
    SqlMapClient sqlMapClient = new SqlMapClientImpl(this.mockSqlMapExecutorDelegate);
    // When
    sqlMapClient.startTransaction();
    sqlMapClient.commitTransaction();
    sqlMapClient.endTransaction();
    // Then
    final List<SpanEventBo> spanEvents = getCurrentSpanEvents();
    assertThat(spanEvents.size(), is(3));

    // Check Method
    final SpanEventBo startTransactionSpanEventBo = spanEvents.get(0);
    final SpanEventBo commitTransactionSpanEventBo = spanEvents.get(1);
    final SpanEventBo endTransactionSpanEventBo = spanEvents.get(2);

    assertThat(startTransactionSpanEventBo.getApiId(), not(0));
    assertThat(commitTransactionSpanEventBo.getApiId(), not(0));
    assertThat(endTransactionSpanEventBo.getApiId(), not(0));

    assertThat(startTransactionSpanEventBo.getApiId(), not(commitTransactionSpanEventBo.getApiId()));
    assertThat(commitTransactionSpanEventBo.getApiId(), not(endTransactionSpanEventBo.getApiId()));
    assertThat(endTransactionSpanEventBo.getApiId(), not(startTransactionSpanEventBo.getApiId()));

    // Check Parameter
    assertNull(startTransactionSpanEventBo.getAnnotationBoList());
    assertNull(commitTransactionSpanEventBo.getAnnotationBoList());
    assertNull(endTransactionSpanEventBo.getAnnotationBoList());
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
private String translateStatementName(String statementName) {
    if (systemEnvironment.isDefaultDbProvider()) {
        return statementName;
    }
    String forExternalDb = String.format("%s-%s", statementName, database.getType());
    MappedStatement statement;
    try {
        statement = ((SqlMapClientImpl) super.getSqlMapClient()).getMappedStatement(forExternalDb);
    } catch (Exception e) {
        statement = null;
    }
    return statement != null ? forExternalDb : statementName;
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
protected String getSqlByStatementName(String statementName, Object parameterObject) {
    SqlMapClientImpl sqlMapClientImpl = (SqlMapClientImpl) getSqlMapClient();
    Sql sql = sqlMapClientImpl.getMappedStatement(statementName).getSql();
    if (sql instanceof StaticSql) {
        return sql.getSql(null, parameterObject);
    } else {
        logger.info("dynamic sql can only return sql id.");
        return statementName;
    }
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
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;
  }
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
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;
  }
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
/**
 * Test if a method in a proxied object can access a default method of another class in the same package with default
 * access modifier.
 * <p>
 * Depending of the implementation of the Cglib-proxy the access will throw an IllegalAccessException.
 */
public void testProxyMethodAccess() throws SQLException {
  SqlMapClientImpl client = setupMockSqlMapClientImpl();

  EnhancedLazyResultLoader loader = new EnhancedLazyResultLoader(client, "bean2", null, Bean2.class);
  Bean2 bean2 = (Bean2) loader.loadResult();

  // cglib might throw an IllegalAccessException
  bean2.testDefaultAccess();
}
 

import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl; //导入依赖的package包/类
/**
 * Test if a proxy for a null nevertheless dispatch to a default object.
 */
public void testNullProxy() throws SQLException {
  SqlMapClientImpl client = setupMockSqlMapClientImpl();

  EnhancedLazyResultLoader loader = new EnhancedLazyResultLoader(client, "bean3", null, TestBean3.class);
  TestBean3 bean = (TestBean3) loader.loadResult();

  assertEquals("foobar", bean.getText());
}