private boolean applyAutomaticMappings(
     ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix)
     throws SQLException {
   final List<String> unmappedColumnNames = rsw.getUnmappedColumnNames(resultMap, columnPrefix);
   boolean foundValues = false;
   for (String columnName : unmappedColumnNames) {
     String propertyName = columnName;
     if (columnPrefix != null && columnPrefix.length() > 0) {
       // When columnPrefix is specified,
       // ignore columns without the prefix.
       if (columnName.toUpperCase(Locale.ENGLISH).startsWith(columnPrefix)) {
         propertyName = columnName.substring(columnPrefix.length());
       } else {
         continue;
       }
     }
     final String property =
         metaObject.findProperty(propertyName, configuration.isMapUnderscoreToCamelCase());
     if (property != null && metaObject.hasSetter(property)) {
       final Class<?> propertyType = metaObject.getSetterType(property);
       if (typeHandlerRegistry.hasTypeHandler(propertyType)) {
         final TypeHandler<?> typeHandler = rsw.getTypeHandler(propertyType, columnName);
         final Object value = typeHandler.getResult(rsw.getResultSet(), columnName);
         if (value != null
             || configuration.isCallSettersOnNulls()) { // issue #377, call setter on nulls
           if (value != null || !propertyType.isPrimitive()) {
             metaObject.setValue(property, value);
           }
           foundValues = true;
         }
       }
     }
   }
   return foundValues;
 }
Exemple #2
0
 public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
   String statementName = mapperInterface.getName() + "." + method.getName();
   MappedStatement ms = null;
   if (configuration.hasStatement(statementName)) {
     ms = configuration.getMappedStatement(statementName);
   } else if (!mapperInterface.equals(method.getDeclaringClass())) { // issue #35
     String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
     if (configuration.hasStatement(parentStatementName)) {
       ms = configuration.getMappedStatement(parentStatementName);
     }
   }
   if (ms == null) {
     if (method.getAnnotation(Flush.class) != null) {
       name = null;
       type = SqlCommandType.FLUSH;
     } else {
       throw new BindingException("Invalid bound statement (not found): " + statementName);
     }
   } else {
     name = ms.getId();
     type = ms.getSqlCommandType();
     if (type == SqlCommandType.UNKNOWN) {
       throw new BindingException("Unknown execution method for: " + name);
     }
   }
 }
 private void processGeneratedKeys(Executor executor, MappedStatement ms, Object parameter) {
   try {
     if (parameter != null && keyStatement != null && keyStatement.getKeyProperties() != null) {
       String keyProperty =
           keyStatement.getKeyProperties()[0]; // just one key property is supported
       final Configuration configuration = ms.getConfiguration();
       final MetaObject metaParam = configuration.newMetaObject(parameter);
       if (keyProperty != null && metaParam.hasSetter(keyProperty)) {
         // Do not close keyExecutor.
         // The transaction will be closed by parent executor.
         Executor keyExecutor =
             configuration.newExecutor(executor.getTransaction(), ExecutorType.SIMPLE);
         List<Object> values =
             keyExecutor.query(
                 keyStatement, parameter, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);
         if (values.size() == 0) {
           throw new ExecutorException("SelectKey returned no data.");
         } else if (values.size() > 1) {
           throw new ExecutorException("SelectKey returned more than one value.");
         } else {
           metaParam.setValue(keyProperty, values.get(0));
         }
       }
     }
   } catch (ExecutorException e) {
     throw e;
   } catch (Exception e) {
     throw new ExecutorException(
         "Error selecting key or setting result to parameter object. Cause: " + e, e);
   }
 }
  /**
   * 构建ResultMap对象
   *
   * @param id
   * @param clazz
   * @param configuration
   * @return
   */
  private ResultMap buildResultMap(String id, Class<?> clazz, Configuration configuration) {
    // 判断是否已经存在缓存里
    if (configuration.hasResultMap(id)) {
      return configuration.getResultMap(id);
    }
    List<ResultMapping> resultMappings = Lists.newArrayList();
    Map<String, Field> columns = EntityUtil.getFields(clazz);
    for (Map.Entry<String, Field> column : columns.entrySet()) {
      Field field = column.getValue();
      String fieldName = field.getName();
      Class<?> columnTypeClass = resolveResultJavaType(clazz, fieldName, null);
      List<ResultFlag> flags = Lists.newArrayList();
      if (field.isAnnotationPresent(Id.class)) {
        flags.add(ResultFlag.ID);
      }
      String columnName = column.getKey();
      resultMappings.add(
          buildResultMapping(configuration, fieldName, columnName, columnTypeClass, flags));
    }

    // 构建ResultMap
    ResultMap.Builder resultMapBuilder =
        new ResultMap.Builder(configuration, id, clazz, resultMappings);
    ResultMap rm = resultMapBuilder.build();
    // 放到缓存中
    configuration.addResultMap(rm);
    return rm;
  }
 public Builder(
     Configuration configuration,
     String id,
     SqlSource sqlSource,
     SqlCommandType sqlCommandType) {
   mappedStatement.configuration = configuration;
   mappedStatement.id = id;
   mappedStatement.sqlSource = sqlSource;
   mappedStatement.statementType = StatementType.PREPARED;
   mappedStatement.parameterMap =
       new ParameterMap.Builder(
               configuration, "defaultParameterMap", null, new ArrayList<ParameterMapping>())
           .build();
   mappedStatement.resultMaps = new ArrayList<ResultMap>();
   mappedStatement.timeout = configuration.getDefaultStatementTimeout();
   mappedStatement.sqlCommandType = sqlCommandType;
   mappedStatement.keyGenerator =
       configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)
           ? new Jdbc3KeyGenerator()
           : new NoKeyGenerator();
   String logId = id;
   if (configuration.getLogPrefix() != null) logId = configuration.getLogPrefix() + id;
   mappedStatement.statementLog = LogFactory.getLog(logId);
   mappedStatement.lang = configuration.getDefaultScriptingLanuageInstance();
 }
 /**
  * 使用DataSource初始化SqlSessionFactory
  *
  * @param ds
  */
 public static void initialize(DataSource ds) {
   TransactionFactory transactionFactory = new MybatisTransactionFactory();
   Environment environment = new Environment("snaker", transactionFactory, ds);
   Configuration configuration = new Configuration(environment);
   configuration.getTypeAliasRegistry().registerAliases(SCAN_PACKAGE, Object.class);
   if (log.isInfoEnabled()) {
     Map<String, Class<?>> typeAliases = configuration.getTypeAliasRegistry().getTypeAliases();
     for (Entry<String, Class<?>> entry : typeAliases.entrySet()) {
       log.info(
           "Scanned class:[name=" + entry.getKey() + ",class=" + entry.getValue().getName() + "]");
     }
   }
   try {
     for (String resource : resources) {
       InputStream in = Resources.getResourceAsStream(resource);
       XMLMapperBuilder xmlMapperBuilder =
           new XMLMapperBuilder(in, configuration, resource, configuration.getSqlFragments());
       xmlMapperBuilder.parse();
     }
   } catch (Exception e) {
     e.printStackTrace();
   } finally {
     ErrorContext.instance().reset();
   }
   sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
 }
 private void resolveTypeHandler() {
   if (resultMapping.typeHandler == null && resultMapping.javaType != null) {
     Configuration configuration = resultMapping.configuration;
     TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
     resultMapping.typeHandler =
         typeHandlerRegistry.getTypeHandler(resultMapping.javaType, resultMapping.jdbcType);
   }
 }
 /** 验证Statement */
 private void validateStatement() {
   if (!config.hasStatement(commandName)) {
     throw new BindingException("Invalid bound statement (not found): " + commandName);
   }
   if (!config.hasStatement(commandCountName)) {
     throw new BindingException("Invalid bound statement (not found): " + commandCountName);
   }
 }
 @Test(groups = {"tidb"})
 public void shouldSuccessfullyLoadXMLMapperFile() throws Exception {
   Configuration configuration = new Configuration();
   String resource = "org/apache/ibatis/builder/AuthorMapper.xml";
   InputStream inputStream = Resources.getResourceAsStream(resource);
   XMLMapperBuilder builder =
       new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
   builder.parse();
 }
Exemple #10
0
  private SessionFactory() {
    DataSource dataSource = SessionManager.getInstance().getDataSource();
    TransactionFactory transactionFactory = new JdbcTransactionFactory();
    Environment environment = new Environment("development", transactionFactory, dataSource);

    Configuration configuration = new Configuration(environment);
    configuration.addMapper(TableMapper.class);

    sqlMapper = new SqlSessionFactoryBuilder().build(configuration);
  }
 public DynamicContext(Configuration configuration, Object parameterObject) {
   if (parameterObject != null && !(parameterObject instanceof Map)) {
     MetaObject metaObject = configuration.newMetaObject(parameterObject);
     bindings = new ContextMap(metaObject);
   } else {
     bindings = new ContextMap(null);
   }
   bindings.put(PARAMETER_OBJECT_KEY, parameterObject);
   bindings.put(DATABASE_ID_KEY, configuration.getDatabaseId());
 }
Exemple #12
0
 /**
  * 对SQL参数(?)设值, 参考org.apache.ibatis.executor.parameter.DefaultParameterHandler。
  *
  * @param ps 表示预编译的 SQL 语句的对象。
  * @param mappedStatement MappedStatement
  * @param boundSql SQL
  * @param parameterObject 参数对象
  * @throws java.sql.SQLException 数据库异常
  */
 @SuppressWarnings("unchecked")
 public static void setParameters(
     PreparedStatement ps,
     MappedStatement mappedStatement,
     BoundSql boundSql,
     Object parameterObject)
     throws SQLException {
   ErrorContext.instance()
       .activity("setting parameters")
       .object(mappedStatement.getParameterMap().getId());
   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
   if (parameterMappings != null) {
     Configuration configuration = mappedStatement.getConfiguration();
     TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
     MetaObject metaObject =
         parameterObject == null ? null : configuration.newMetaObject(parameterObject);
     for (int i = 0; i < parameterMappings.size(); i++) {
       ParameterMapping parameterMapping = parameterMappings.get(i);
       if (parameterMapping.getMode() != ParameterMode.OUT) {
         Object value;
         String propertyName = parameterMapping.getProperty();
         PropertyTokenizer prop = new PropertyTokenizer(propertyName);
         if (parameterObject == null) {
           value = null;
         } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
           value = parameterObject;
         } else if (boundSql.hasAdditionalParameter(propertyName)) {
           value = boundSql.getAdditionalParameter(propertyName);
         } else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)
             && boundSql.hasAdditionalParameter(prop.getName())) {
           value = boundSql.getAdditionalParameter(prop.getName());
           if (value != null) {
             value =
                 configuration
                     .newMetaObject(value)
                     .getValue(propertyName.substring(prop.getName().length()));
           }
         } else {
           value = metaObject == null ? null : metaObject.getValue(propertyName);
         }
         @SuppressWarnings("rawtypes")
         TypeHandler typeHandler = parameterMapping.getTypeHandler();
         if (typeHandler == null) {
           throw new ExecutorException(
               "There was no TypeHandler found for parameter "
                   + propertyName
                   + " of statement "
                   + mappedStatement.getId());
         }
         typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
       }
     }
   }
 }
 private void makeSureGeneratedKeysAreNotUsedInBatchInserts(String statement) {
   Configuration configuration = session.getConfiguration();
   if (null != configuration) {
     MappedStatement mappedStatement = configuration.getMappedStatement(statement);
     if (null != mappedStatement) {
       KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
       if (keyGenerator instanceof Jdbc3KeyGenerator) {
         throw new IllegalStateException("Batch inserts cannot use generated keys");
       }
     }
   }
 }
 private Executor newExecutor() throws SQLException {
   final Environment environment = configuration.getEnvironment();
   if (environment == null)
     throw new ExecutorException(
         "ResultLoader could not load lazily.  Environment was not configured.");
   final DataSource ds = environment.getDataSource();
   if (ds == null)
     throw new ExecutorException(
         "ResultLoader could not load lazily.  DataSource was not configured.");
   final TransactionFactory transactionFactory = environment.getTransactionFactory();
   final Transaction tx = transactionFactory.newTransaction(ds, null, false);
   return configuration.newExecutor(tx, ExecutorType.SIMPLE);
 }
Exemple #15
0
 private void loadMapper(Configuration configuration, String mapperName) {
   InputStream input = null;
   try {
     input = getClass().getResourceAsStream("/" + mapperName.replace('.', '/') + ".xml");
     new XMLMapperBuilder(input, configuration, mapperName, configuration.getSqlFragments())
         .parse();
     configuration.addLoadedResource(mapperName);
     logback.setLoggerLevel(mapperName, Level.INFO);
   } catch (Exception e) {
     throw new IllegalArgumentException("Unable to load mapper " + mapperName, e);
   } finally {
     Closeables.closeQuietly(input);
   }
 }
 private EnhancedResultObjectProxyImpl(
     Class<?> type,
     ResultLoaderMap lazyLoader,
     Configuration configuration,
     ObjectFactory objectFactory,
     List<Class<?>> constructorArgTypes,
     List<Object> constructorArgs) {
   this.type = type;
   this.lazyLoader = lazyLoader;
   this.aggressive = configuration.isAggressiveLazyLoading();
   this.lazyLoadTriggerMethods = configuration.getLazyLoadTriggerMethods();
   this.objectFactory = objectFactory;
   this.constructorArgTypes = constructorArgTypes;
   this.constructorArgs = constructorArgs;
 }
 // TODO: Not supported.
 @Test(
     groups = {"tidb-todo"},
     enabled = false)
 public void shouldNotLoadTheSameNamespaceFromTwoResourcesWithDifferentNames() throws Exception {
   Configuration configuration = new Configuration();
   String resource = "org/apache/ibatis/builder/AuthorMapper.xml";
   InputStream inputStream = Resources.getResourceAsStream(resource);
   XMLMapperBuilder builder =
       new XMLMapperBuilder(inputStream, configuration, "name1", configuration.getSqlFragments());
   builder.parse();
   InputStream inputStream2 = Resources.getResourceAsStream(resource);
   XMLMapperBuilder builder2 =
       new XMLMapperBuilder(inputStream2, configuration, "name2", configuration.getSqlFragments());
   builder2.parse();
 }
 private boolean applyPropertyMappings(
     ResultSetWrapper rsw,
     ResultMap resultMap,
     MetaObject metaObject,
     ResultLoaderMap lazyLoader,
     String columnPrefix)
     throws SQLException {
   final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
   boolean foundValues = false;
   final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
   for (ResultMapping propertyMapping : propertyMappings) {
     final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
     if (propertyMapping.isCompositeResult()
         || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
         || propertyMapping.getResultSet() != null) {
       Object value =
           getPropertyMappingValue(
               rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
       final String property = propertyMapping.getProperty(); // issue #541 make property optional
       if (value != NO_VALUE
           && property != null
           && (value != null
               || configuration.isCallSettersOnNulls())) { // issue #377, call setter on nulls
         if (value != null || !metaObject.getSetterType(property).isPrimitive()) {
           metaObject.setValue(property, value);
         }
         foundValues = true;
       }
     }
   }
   return foundValues;
 }
 /** 设置当前的参数的类型信息 */
 private void setupCommandType() {
   MappedStatement ms = config.getMappedStatement(commandName);
   type = ms.getSqlCommandType();
   if (type != SqlCommandType.SELECT) {
     throw new BindingException("Unsupport execution method for: " + commandName);
   }
 }
Exemple #20
0
  public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.size() <= 0) {
      boundSql =
          new BoundSql(
              configuration,
              boundSql.getSql(),
              parameterMap.getParameterMappings(),
              parameterObject);
    }

    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }

    return boundSql;
  }
Exemple #21
0
 public CacheKey createCacheKey(
     MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
   if (closed) throw new ExecutorException("Executor was closed.");
   CacheKey cacheKey = new CacheKey();
   cacheKey.update(ms.getId());
   cacheKey.update(rowBounds.getOffset());
   cacheKey.update(rowBounds.getLimit());
   cacheKey.update(boundSql.getSql());
   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
   if (parameterMappings.size() > 0 && parameterObject != null) {
     TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
     if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
       cacheKey.update(parameterObject);
     } else {
       MetaObject metaObject = configuration.newMetaObject(parameterObject);
       for (ParameterMapping parameterMapping : parameterMappings) {
         String propertyName = parameterMapping.getProperty();
         if (metaObject.hasGetter(propertyName)) {
           cacheKey.update(metaObject.getValue(propertyName));
         } else if (boundSql.hasAdditionalParameter(propertyName)) {
           cacheKey.update(boundSql.getAdditionalParameter(propertyName));
         }
       }
     }
   }
   return cacheKey;
 }
 private Object getNestedQueryConstructorValue(
     ResultSet rs, ResultMapping constructorMapping, String columnPrefix) throws SQLException {
   final String nestedQueryId = constructorMapping.getNestedQueryId();
   final MappedStatement nestedQuery = configuration.getMappedStatement(nestedQueryId);
   final Class<?> nestedQueryParameterType = nestedQuery.getParameterMap().getType();
   final Object nestedQueryParameterObject =
       prepareParameterForNestedQuery(
           rs, constructorMapping, nestedQueryParameterType, columnPrefix);
   Object value = null;
   if (nestedQueryParameterObject != null) {
     final BoundSql nestedBoundSql = nestedQuery.getBoundSql(nestedQueryParameterObject);
     final CacheKey key =
         executor.createCacheKey(
             nestedQuery, nestedQueryParameterObject, RowBounds.DEFAULT, nestedBoundSql);
     final Class<?> targetType = constructorMapping.getJavaType();
     final ResultLoader resultLoader =
         new ResultLoader(
             configuration,
             executor,
             nestedQuery,
             nestedQueryParameterObject,
             targetType,
             key,
             nestedBoundSql);
     value = resultLoader.loadResult();
   }
   return value;
 }
 private Object createParameterizedResultObject(
     ResultSetWrapper rsw,
     Class<?> resultType,
     List<ResultMapping> constructorMappings,
     List<Class<?>> constructorArgTypes,
     List<Object> constructorArgs,
     String columnPrefix)
     throws SQLException {
   boolean foundValues = false;
   for (ResultMapping constructorMapping : constructorMappings) {
     final Class<?> parameterType = constructorMapping.getJavaType();
     final String column = constructorMapping.getColumn();
     final Object value;
     if (constructorMapping.getNestedQueryId() != null) {
       value =
           getNestedQueryConstructorValue(rsw.getResultSet(), constructorMapping, columnPrefix);
     } else if (constructorMapping.getNestedResultMapId() != null) {
       final ResultMap resultMap =
           configuration.getResultMap(constructorMapping.getNestedResultMapId());
       value = getRowValue(rsw, resultMap);
     } else {
       final TypeHandler<?> typeHandler = constructorMapping.getTypeHandler();
       value = typeHandler.getResult(rsw.getResultSet(), prependPrefix(column, columnPrefix));
     }
     constructorArgTypes.add(parameterType);
     constructorArgs.add(value);
     foundValues = value != null || foundValues;
   }
   return foundValues
       ? objectFactory.create(resultType, constructorArgTypes, constructorArgs)
       : null;
 }
 private void createRowKeyForMappedProperties(
     ResultMap resultMap,
     ResultSetWrapper rsw,
     CacheKey cacheKey,
     List<ResultMapping> resultMappings,
     String columnPrefix)
     throws SQLException {
   for (ResultMapping resultMapping : resultMappings) {
     if (resultMapping.getNestedResultMapId() != null
         && resultMapping.getResultSet() == null) { // Issue #392
       final ResultMap nestedResultMap =
           configuration.getResultMap(resultMapping.getNestedResultMapId());
       createRowKeyForMappedProperties(
           nestedResultMap,
           rsw,
           cacheKey,
           nestedResultMap.getConstructorResultMappings(),
           prependPrefix(resultMapping.getColumnPrefix(), columnPrefix));
     } else if (resultMapping.getNestedQueryId() == null) {
       final String column = prependPrefix(resultMapping.getColumn(), columnPrefix);
       final TypeHandler<?> th = resultMapping.getTypeHandler();
       List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
       if (column != null
           && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH))) { // Issue #114
         final Object value = th.getResult(rsw.getResultSet(), column);
         if (value != null) {
           cacheKey.update(column);
           cacheKey.update(value);
         }
       }
     }
   }
 }
 private void createRowKeyForUnmappedProperties(
     ResultMap resultMap, ResultSetWrapper rsw, CacheKey cacheKey, String columnPrefix)
     throws SQLException {
   final MetaClass metaType = MetaClass.forClass(resultMap.getType());
   List<String> unmappedColumnNames = rsw.getUnmappedColumnNames(resultMap, columnPrefix);
   for (String column : unmappedColumnNames) {
     String property = column;
     if (columnPrefix != null && columnPrefix.length() > 0) {
       // When columnPrefix is specified,
       // ignore columns without the prefix.
       if (column.toUpperCase(Locale.ENGLISH).startsWith(columnPrefix)) {
         property = column.substring(columnPrefix.length());
       } else {
         continue;
       }
     }
     if (metaType.findProperty(property, configuration.isMapUnderscoreToCamelCase()) != null) {
       String value = rsw.getResultSet().getString(column);
       if (value != null) {
         cacheKey.update(column);
         cacheKey.update(value);
       }
     }
   }
 }
  public List<Object> handleResultSets(Statement stmt) throws SQLException {
    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResulSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }
 private Object createResultObject(
     ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix)
     throws SQLException {
   final List<Class<?>> constructorArgTypes = new ArrayList<Class<?>>();
   final List<Object> constructorArgs = new ArrayList<Object>();
   final Object resultObject =
       createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
   if (resultObject != null && !typeHandlerRegistry.hasTypeHandler(resultMap.getType())) {
     final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
     for (ResultMapping propertyMapping : propertyMappings) {
       if (propertyMapping.getNestedQueryId() != null
           && propertyMapping.isLazy()) { // issue gcode #109 && issue #149
         return configuration
             .getProxyFactory()
             .createProxy(
                 resultObject,
                 lazyLoader,
                 configuration,
                 objectFactory,
                 constructorArgTypes,
                 constructorArgs);
       }
     }
   }
   return resultObject;
 }
 public Builder(Configuration configuration, String property) {
   resultMapping.configuration = configuration;
   resultMapping.property = property;
   resultMapping.flags = new ArrayList<org.apache.ibatis.mapping.ResultFlag>();
   resultMapping.composites = new ArrayList<org.apache.ibatis.mapping.ResultMapping>();
   resultMapping.lazy = configuration.isLazyLoadingEnabled();
 }
 /**
  * 获取数据库类型
  *
  * @param metaObject
  * @return 返回数据库类型的枚举对象
  */
 private Dialect.Type searchDbTypeByConfig(Configuration configuration) {
   String dialectConfig = configuration.getVariables().getProperty("dialect");
   if (dialectConfig != null && !"".equals(dialectConfig)) {
     return Dialect.Type.valueOf(dialectConfig.toUpperCase());
   } else {
     throw new RuntimeException("databaseType is null , please check your mybatis configuration!");
   }
 }
 public DefaultResultSetHandler(
     Executor executor,
     MappedStatement mappedStatement,
     ParameterHandler parameterHandler,
     ResultHandler resultHandler,
     BoundSql boundSql,
     RowBounds rowBounds) {
   this.executor = executor;
   this.configuration = mappedStatement.getConfiguration();
   this.mappedStatement = mappedStatement;
   this.rowBounds = rowBounds;
   this.parameterHandler = parameterHandler;
   this.boundSql = boundSql;
   this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
   this.objectFactory = configuration.getObjectFactory();
   this.resultHandler = resultHandler;
 }