MyBatis源码解析系列(四)--使用SqlSession去进行CRUD解析

zhaodengfeng1989

浏览: 69660 次
性别:
来自: 北京

最近访客更多访客>>

kongqingshuai

陈睿mikechen

tom2139779

石晓楠

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Mybatis

Mybatis 源码 CRUD

在源码解析篇三中，我们已经得到了SqlSession。长征已经走了一半，前途一片光明。此篇中我们要解析下如何使用SqlSession去进行CRUD（创建(Create)、查询(Retrieve)（重新得到数据）、更新(Update)和删除(Delete)）。

我们结合debug过程，逐渐深入源码解析。

一、从getMapper说起

在我们入门示例中，使用sqlSession.getMapper(MalltUserDao.class)获取到了MalltUserDao，那这中间经历了什么？下面是整个执行过程的时序图。

我们从sqlSession的getMapper方法开始深入，源码如下，源码在DefaultSqlSession类中：

public <T> T getMapper(Class<T> type) {
        return this.configuration.getMapper(type, this);
    }

这里，调用了configuration对象中的getMapper方法，传递了两个参数，一个是类类型，一个是sqlSession对象，源码如下，源码在Configuration类：

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return this.mapperRegistry.getMapper(type, sqlSession);
    }

在这里又调用了MapperRegistry类的getMapper方法，我们看下源码：

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
        if (mapperProxyFactory == null) {
            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        } else {
            try {
                return mapperProxyFactory.newInstance(sqlSession);
            } catch (Exception var5) {
                throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
            }
        }
    }

分析一下。

第一句：

MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);

其中，knownMappers是在解析核心配置文件时，使用this.mapperElement(root.evalNode("mappers"));解析的，其中最终的核心方法就是addMapper，这个我们在解析<mappers>元素时候说，这里不是我们的重点。从这里我们可以知道，knownMappers中放的就是类类型和根据类类型得到的MapperProxy工厂类MapperProxyFactory。那么MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type); 得到的就是类类型对应的MapperProxy工厂类。我们这里的类类型是interface com.zhaodf.dao.MalltUserDao。

第二句： mapperProxyFactory.newInstance(sqlSession);

在此部分，使用了mapperProxy工厂类，使用我们原来得到的sqlSession，去得到我们的接口代理类。源码如下：

public T newInstance(SqlSession sqlSession) {
        MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
        return this.newInstance(mapperProxy);
    }

我们分析下：

第一句：

MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);

使用我们传递的参数sqlSession，以及代理工厂类自身已经设置好的mapperInterface（com.zhaodf.dao.MalltUserDao），还有methodCache，这个我们没用到，它的map大小为空。

第二句：

this.newInstance(mapperProxy)；

这句，使用了MapperProxyFactory类中的newInstance方法，源码如下：

protected T newInstance(MapperProxy<T> mapperProxy) {
        return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
    }

这里就是典型的代理模式，将MalltUserDao通过类加载器，转变为代理类（代理类中包含了Mapper中所有要执行的方法以及构造函数等）。过程如下：

这样，经过一整个过程的getMapper方法，得到了我们接口类的代理类，代理类的内容如下图：

下一步，我们就要根据代理类去执行我们的CRUD方法了。

二、从执行CRUD说起

得到代理类后，那我们就可以开始执行CRUD方法了。我们先把整个执行流程图画上：

当我们执行到MalltUser user = malltUserDao.findMalltUserById(9);时，这时，代理类会去调用MapperProxy类中的invoke方法，源码如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (Object.class.equals(method.getDeclaringClass())) {
            try {
                return method.invoke(this, args);
            } catch (Throwable var5) {
                throw ExceptionUtil.unwrapThrowable(var5);
            }
        } else {
            MapperMethod mapperMethod = this.cachedMapperMethod(method);
            return mapperMethod.execute(this.sqlSession, args);
        }
    }

其中，proxy为我们的代理类，

method为原接口中的方法对象：

args为方法调用参数：

第一句if判断，if (Object.class.equals(method.getDeclaringClass())) ，因为这里method的clazz为MalltUserDao，因此，这里肯定是不成立的。

走到else，MapperMethod mapperMethod = this.cachedMapperMethod(method);这里就需要分开详细说下。

1、this.cachedMapperMethod(method);

这里调用了cachedMapperMethod方法去得到MapperMethod，我们看下这个方法源码：

private MapperMethod cachedMapperMethod(Method method) {
        MapperMethod mapperMethod = (MapperMethod)this.methodCache.get(method);
        if (mapperMethod == null) {
            mapperMethod = new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration());
            this.methodCache.put(method, mapperMethod);
        }

        return mapperMethod;
    }

因为我们的methodCache是个空的map，因此执行MapperMethod mapperMethod = (MapperMethod)this.methodCache.get(method)得到的mapperMethod为null。

继续执行if判断中内容。

在if判断体内，初始化了MapperMethod对象，我们看下它做了些什么。

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
        this.command = new MapperMethod.SqlCommand(config, mapperInterface, method);
        this.method = new MapperMethod.MethodSignature(config, method);
    }

这里初始化了两个MapperMethod的静态内部类，SqlCommand和MethodSignature。

我们先看下SqlCommand的构造函数：

public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
            String statementName = mapperInterface.getName() + "." + method.getName();
            MappedStatement ms = null;
            if (configuration.hasStatement(statementName)) {
                ms = configuration.getMappedStatement(statementName);
            } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) {
                String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
                if (configuration.hasStatement(parentStatementName)) {
                    ms = configuration.getMappedStatement(parentStatementName);
                }
            }

            if (ms == null) {
                throw new BindingException("Invalid bound statement (not found): " + statementName);
            } else {
                this.name = ms.getId();
                this.type = ms.getSqlCommandType();
                if (this.type == SqlCommandType.UNKNOWN) {
                    throw new BindingException("Unknown execution method for: " + this.name);
                }
            }
        }

因为在前期获取到configuration对象中，解析mapper标签时，设置了mapperStatement，如下图：

因此，这里得到的MapperStatement就是上面图的value值。执行完SqlCommand的构造函数后，得到的各参数内容如下：

设置完的SqlCommand，name为：com.zhaodf.dao.MalltUserDao.findMalltUserById；

type为SELECT。

我们再看下另外一个静态内部类干了些啥，MethodSignature的构造函数源码如下：

public MethodSignature(Configuration configuration, Method method) throws BindingException {
            this.returnType = method.getReturnType();
            this.returnsVoid = Void.TYPE.equals(this.returnType);
            this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
            this.mapKey = this.getMapKey(method);
            this.returnsMap = this.mapKey != null;
            this.hasNamedParameters = this.hasNamedParams(method);
            this.rowBoundsIndex = this.getUniqueParamIndex(method, RowBounds.class);
            this.resultHandlerIndex = this.getUniqueParamIndex(method, ResultHandler.class);
            this.params = Collections.unmodifiableSortedMap(this.getParams(method, this.hasNamedParameters));
        }

我们逐行来说明。我们先看下method对象的内容：

this.returnType = method.getReturnType();获取方法的返回类型就是com.zhaodf.model.MalltUser。
this.returnsVoid = Void.TYPE.equals(this.returnType);我们返回的不是void，因此returnsVoid 为false。
this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();这里，我们的返回类型是对象，不是数组和集合，因此returnsMany为false。
this.mapKey = this.getMapKey(method);在getMapKey的方法源码中，调用了类类型对象的isAssignableFrom方法，源码如下：
```
private String getMapKey(Method method) {
            String mapKey = null;
            if (Map.class.isAssignableFrom(method.getReturnType())) {
                MapKey mapKeyAnnotation = (MapKey)method.getAnnotation(MapKey.class);
                if (mapKeyAnnotation != null) {
                    mapKey = mapKeyAnnotation.value();
                }
            }

            return mapKey;
        }
```
这里的isAssignableFrom方法是一个本地方法，关于该方法的执行解释如下：有两个Class类型的类象，一个是调用isAssignableFrom方法的类对象（后称对象a），以及方法中作为参数的这个类对象（称之为对象b），这两个对象如果满足以下条件则返回true，否则返回false： a对象所对应类信息是b对象所对应的类信息的父类或者是父接口，简单理解即a是b的父类或接口 a对象所对应类信息与b对象所对应的类信息相同，简单理解即a和b为同一个类或同一个接口。因此if不成立，得到的mapKey为null。
this.returnsMap = this.mapKey != null;因为mapKey为null，因此returnsMap 为false。
this.hasNamedParameters = this.hasNamedParams(method);这里我们没有使用参数注解，因此hasNamedParameters为false。
this.rowBoundsIndex = this.getUniqueParamIndex(method, RowBounds.class);
得到的index为null。
this.resultHandlerIndex = this.getUniqueParamIndex(method, ResultHandler.class);与上一步一样，得到的resultHandlerIndex 也为null。
this.params = Collections.unmodifiableSortedMap(this.getParams(method, this.hasNamedParameters));这一步得到方法传递参数的map（经过排序的）--SortedMap

这样最后设置完的MethodSignature的内容如下：

这样，我们的MapperMethod初始化完成，然后将该MapperMethod放在了methodCache中，内容如下：

2、经过上面一系列的步骤，终于到了执行的时候了。mapperMethod.execute(this.sqlSession, args);

源码如下：

public Object execute(SqlSession sqlSession, Object[] args) {
        Object param;
        Object result;
        if (SqlCommandType.INSERT == this.command.getType()) {
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
        } else if (SqlCommandType.UPDATE == this.command.getType()) {
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
        } else if (SqlCommandType.DELETE == this.command.getType()) {
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
        } else {
            if (SqlCommandType.SELECT != this.command.getType()) {
                throw new BindingException("Unknown execution method for: " + this.command.getName());
            }

            if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                this.executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (this.method.returnsMany()) {
                result = this.executeForMany(sqlSession, args);
            } else if (this.method.returnsMap()) {
                result = this.executeForMap(sqlSession, args);
            } else {
                param = this.method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(this.command.getName(), param);
            }
        }

        if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
            throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
        } else {
            return result;
        }
    }

源码内容很多，其实很简单，就是根据我们步骤1中得到的command，去执行不同的调用。我们现在得到的是SELECT，因此，直接找到最后一步的else。根据步骤1得到的MapperMethod.MethodSignature method中的各项参数，我们逐步判断，走到了最后：

param = this.method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(this.command.getName(), param);

我们逐句分析下。

在方法this.method.convertArgsToSqlCommandParam(args)中，按照方法含义，就是将我们传递的实际参数值传递到我们的sql语句中，源码如下：

public Object convertArgsToSqlCommandParam(Object[] args) {
            int paramCount = this.params.size();
            if (args != null && paramCount != 0) {
                if (!this.hasNamedParameters && paramCount == 1) {
                    return args[(Integer)this.params.keySet().iterator().next()];
                } else {
                    Map<String, Object> param = new MapperMethod.ParamMap();
                    int i = 0;

                    for(Iterator i$ = this.params.entrySet().iterator(); i$.hasNext(); ++i) {
                        Entry<Integer, String> entry = (Entry)i$.next();
                        param.put(entry.getValue(), args[(Integer)entry.getKey()]);
                        String genericParamName = "param" + String.valueOf(i + 1);
                        if (!param.containsKey(genericParamName)) {
                            param.put(genericParamName, args[(Integer)entry.getKey()]);
                        }
                    }

                    return param;
                }
            } else {
                return null;
            }
        }

因为我们的args参数数组的大小为1，且根据我们构造MapperMethod.MethodSignature method得到的hasNamedParameters为false，因此直接走了 return args[(Integer)this.params.keySet().iterator().next()];

得到的param=9。

在方法result = sqlSession.selectOne(this.command.getName(), param);中，我们调用了sqlSession的selectOne方法。这里的this.command.getName()为com.zhaodf.dao.MalltUserDao.findMalltUserById，param就是第一步得到的param--Object对象，内容为9。DefaultSqlSession的selectOne源码如下：

public <T> T selectOne(String statement, Object parameter) {
        List<T> list = this.selectList(statement, parameter);
        if (list.size() == 1) {
            return list.get(0);
        } else if (list.size() > 1) {
            throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
        } else {
            return null;
        }
    }

方法里调用了this.selectList(statement, parameter);源码如下：

public <E> List<E> selectList(String statement, Object parameter) {
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
    }

继续往下找重载的selectList方法，源码如下：

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        List var6;
        try {
            MappedStatement ms = this.configuration.getMappedStatement(statement);
            List<E> result = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
            var6 = result;
        } catch (Exception var10) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + var10, var10);
        } finally {
            ErrorContext.instance().reset();
        }

        return var6;
    }

我们逐句分析，MappedStatement ms = this.configuration.getMappedStatement(statement);这里就是根据我们在mapper配置文件中的唯一性id去得到对应的MappedStatement。内容如下：

public MappedStatement getMappedStatement(String id) {
        return this.getMappedStatement(id, true);
    }

    public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
            this.buildAllStatements();
        }

        return (MappedStatement)this.mappedStatements.get(id);
    }

得到的MappedStatement如下图：

接着，执行List<E> result = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);这里面包含了4个参数，第一个就是我们上一步得到的ms，第二个参数，就是将参数对象根据所属的不同实例类型进行包装，源码如下：

private Object wrapCollection(Object object) {
        DefaultSqlSession.StrictMap map;
        if (object instanceof List) {
            map = new DefaultSqlSession.StrictMap();
            map.put("list", object);
            return map;
        } else if (object != null && object.getClass().isArray()) {
            map = new DefaultSqlSession.StrictMap();
            map.put("array", object);
            return map;
        } else {
            return object;
        }
    }

因为我们这里的Object实际内容是Integer的9，因此，返回的object还是Integer 9。所有参数确定后，我们看下CachingExecutor中query方法的源码：

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

在源码中，第一句BoundSql boundSql = ms.getBoundSql(parameterObject);根据传递的参数对象，获取到BoundSql。BoundSql 包含了sql语句、参数等信息：

第二句中，CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);得到该语句的缓存key值，见下图：

第三句中，调用了CachingExecutor中重载的方法，this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);并将结果返回。我们看下源码：

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
            this.flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                this.ensureNoOutParams(ms, parameterObject, boundSql);
                List<E> list = (List)this.tcm.getObject(cache, key);
                if (list == null) {
                    list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    this.tcm.putObject(cache, key, list);
                }

                return list;
            }
        }

        return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

这里，我们的cache为null，因此直接调用了BaseExecutor类中的query方法，看下源码：

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (this.closed) {
            throw new ExecutorException("Executor was closed.");
        } else {
            if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
                this.clearLocalCache();
            }

            List list;
            try {
                ++this.queryStack;
                list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
                if (list != null) {
                    this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
                } else {
                    list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
                }
            } finally {
                --this.queryStack;
            }

            if (this.queryStack == 0) {
                Iterator i$ = this.deferredLoads.iterator();

                while(i$.hasNext()) {
                    BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)i$.next();
                    deferredLoad.load();
                }

                this.deferredLoads.clear();
                if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                    this.clearLocalCache();
                }
            }

            return list;
        }
    }

我们直接看关键一句：

list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);

        List list;
        try {
            list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            this.localCache.removeObject(key);
        }

        this.localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
            this.localOutputParameterCache.putObject(key, parameter);
        }

        return list;
    }

这里关键代码也只有一句，list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);是用来做查询的，其他操作只是将我们查询出来的结果缓存，放在localCache中。我们分析下doQuery方法，这个方法在SimpleExecutor类中，我们去看看：

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;

        List var9;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var9 = handler.query(stmt, resultHandler);
        } finally {
            this.closeStatement(stmt);
        }

        return var9;
    }

这里使用ms获取到我们configuration，然后使用configuration去得到对应的Statement处理器，关键的代码如下：

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        StatementHandler statementHandler = (StatementHandler)this.interceptorChain.pluginAll(statementHandler);
        return statementHandler;
    }

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        switch(ms.getStatementType()) {
        case STATEMENT:
            this.delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case PREPARED:
            this.delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case CALLABLE:
            this.delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        default:
            throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
        }

    }

代码看似很多，实际上就做了一个动作，根据我们statementType（有三种：STATEMENT，PREPARED 或 CALLABLE ，默认情况下是PREPARED ）去得到不同的statement处理器，因此我们这里得到的是PreparedStatementHandler。在PreparedStatementHandler中，又初始化了参数处理器和结果集处理器：

我们看下最关键的一行代码，var9 = handler.query(stmt, resultHandler);源码追踪，最后跟踪到PreparedStatementHandler类的query方法，这里跟jdbc处理的方法一样：

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement)statement;
        ps.execute();
        return this.resultSetHandler.handleResultSets(ps);
    }

this.resultSetHandler.handleResultSets(ps)结果集处理的源码如下：

public List<Object> handleResultSets(Statement stmt) throws SQLException {
        List<Object> multipleResults = new ArrayList();
        int resultSetCount = 0;
        ResultSetWrapper rsw = this.getFirstResultSet(stmt);
        List<ResultMap> resultMaps = this.mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        this.validateResultMapsCount(rsw, resultMapCount);

        while(rsw != null && resultMapCount > resultSetCount) {
            ResultMap resultMap = (ResultMap)resultMaps.get(resultSetCount);
            this.handleResultSet(rsw, resultMap, multipleResults, (ResultMapping)null);
            rsw = this.getNextResultSet(stmt);
            this.cleanUpAfterHandlingResultSet();
            ++resultSetCount;
        }

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

                rsw = this.getNextResultSet(stmt);
                this.cleanUpAfterHandlingResultSet();
                ++resultSetCount;
            }
        }

        return this.collapseSingleResultList(multipleResults);
    }