fix for http://code.google.com/p/mybatis/issues/detail?id=354 File order matters when extending resultMaps

Author: emacarron

src/main/java/org/apache/ibatis/builder/IncompleteResultMapException.java

@@ -0,0 +1,19 @@
+package org.apache.ibatis.builder;
+
+import org.apache.ibatis.builder.BuilderException;
+
+public class IncompleteResultMapException extends BuilderException {
+  private static final long serialVersionUID = 5710340627945568032L;
+  public IncompleteResultMapException() {
+		super();
+	}
+	public IncompleteResultMapException(String message, Throwable cause) {
+		super(message, cause);
+	}
+	public IncompleteResultMapException(String message) {
+		super(message);
+	}
+	public IncompleteResultMapException(Throwable cause) {
+		super(cause);
+	}
+}

src/main/java/org/apache/ibatis/builder/MapperBuilderAssistant.java

@@ -131,6 +131,9 @@ public ResultMap addResultMap(
 
     ResultMap.Builder resultMapBuilder = new ResultMap.Builder(configuration, id, type, resultMappings);
     if (extend != null) {
+      if (!configuration.hasResultMap(extend)) {
+        throw new IncompleteResultMapException("Could not find a parent resultmap with id '" + extend + "'");
+      }
       ResultMap resultMap = configuration.getResultMap(extend);
       List<ResultMapping> extendedResultMappings = new ArrayList<ResultMapping>(resultMap.getResultMappings());
       extendedResultMappings.removeAll(resultMappings);

src/main/java/org/apache/ibatis/builder/ResultMapResolver.java

@@ -0,0 +1,33 @@
+package org.apache.ibatis.builder;
+
+import java.util.List;
+
+import org.apache.ibatis.mapping.Discriminator;
+import org.apache.ibatis.mapping.ResultMap;
+import org.apache.ibatis.mapping.ResultMapping;
+
+public class ResultMapResolver {
+  private final MapperBuilderAssistant assistant;
+  private String id;
+  private Class<?> type;
+  private String extend;
+  private Discriminator discriminator;
+  private String notNullColumn;
+  private List<ResultMapping> resultMappings;
+
+  public ResultMapResolver(MapperBuilderAssistant assistant, String id, Class<?> type, String extend, Discriminator discriminator, String notNullColumn,
+      List<ResultMapping> resultMappings) {
+    this.assistant = assistant;
+    this.id = id;
+    this.type = type;
+    this.extend = extend;
+    this.discriminator = discriminator;
+    this.notNullColumn = notNullColumn;
+    this.resultMappings = resultMappings;
+  }
+
+  public ResultMap resolve() {
+    return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.notNullColumn, this.resultMappings);
+  }
+  
+}

src/main/java/org/apache/ibatis/builder/xml/XMLMapperBuilder.java

@@ -15,7 +15,9 @@
 import org.apache.ibatis.builder.BuilderException;
 import org.apache.ibatis.builder.CacheRefResolver;
 import org.apache.ibatis.builder.IncompleteCacheException;
+import org.apache.ibatis.builder.IncompleteResultMapException;
 import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.apache.ibatis.builder.ResultMapResolver;
 import org.apache.ibatis.cache.Cache;
 import org.apache.ibatis.executor.ErrorContext;
 import org.apache.ibatis.io.Resources;
@@ -75,6 +77,7 @@ public void parse() {
       bindMapperForNamespace();
     }
 
+    parsePendingResultMaps();
     parsePendingChacheRefs();
     parsePendingStatements();
   }
@@ -109,6 +112,21 @@ private void buildStatementFromContext(List<XNode> list) {
     }
   }
 
+  private void parsePendingResultMaps() {
+    Collection<ResultMapResolver> incompleteResultMaps = configuration.getIncompleteResultMaps();
+    synchronized (incompleteResultMaps) {
+      Iterator<ResultMapResolver> iter = incompleteResultMaps.iterator();
+      while (iter.hasNext()) {
+        try {
+          iter.next().resolve();
+          iter.remove();
+        } catch (IncompleteResultMapException e) {
+          // ResultMap is still missing a resource...
+        }
+      }
+    }
+  }
+
   private void parsePendingChacheRefs() {
 	  Collection<CacheRefResolver> incompleteCacheRefs = configuration.getIncompleteCacheRefs();
 	  synchronized (incompleteCacheRefs) {
@@ -193,7 +211,11 @@ private void parameterMapElement(List<XNode> list) throws Exception {
 
   private void resultMapElements(List<XNode> list) throws Exception {
     for (XNode resultMapNode : list) {
-      resultMapElement(resultMapNode);
+      try {
+        resultMapElement(resultMapNode);
+      } catch (IncompleteResultMapException e) {
+        // ignore, it will be retried
+      }
     }
   }
 
@@ -229,7 +251,13 @@ private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> addi
         resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
       }
     }
-    return builderAssistant.addResultMap(id, typeClass, extend, discriminator, notNullColumn, resultMappings);
+    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, notNullColumn, resultMappings);
+    try {
+      return resultMapResolver.resolve();
+    } catch (IncompleteResultMapException e) {
+      configuration.addIncompleteResultMap(resultMapResolver);
+      throw e;
+    }
   }
 
   private void processConstructorElement(XNode resultChild, Class<?> resultType, List<ResultMapping> resultMappings) throws Exception {

src/main/java/org/apache/ibatis/session/Configuration.java

@@ -10,6 +10,7 @@
 
 import org.apache.ibatis.binding.MapperRegistry;
 import org.apache.ibatis.builder.CacheRefResolver;
+import org.apache.ibatis.builder.ResultMapResolver;
 import org.apache.ibatis.builder.xml.XMLStatementBuilder;
 import org.apache.ibatis.cache.Cache;
 import org.apache.ibatis.cache.decorators.FifoCache;
@@ -76,23 +77,18 @@ public class Configuration {
   protected final InterceptorChain interceptorChain = new InterceptorChain();
   protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
   protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
-  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<String, MappedStatement>(
-      "Mapped Statements collection");
-  protected final Map<String, Cache> caches = new StrictMap<String, Cache>(
-      "Caches collection");
-  protected final Map<String, ResultMap> resultMaps = new StrictMap<String, ResultMap>(
-      "Result Maps collection");
-  protected final Map<String, ParameterMap> parameterMaps = new StrictMap<String, ParameterMap>(
-      "Parameter Maps collection");
-  protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<String, KeyGenerator>(
-      "Key Generators collection");
+  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<String, MappedStatement>("Mapped Statements collection");
+  protected final Map<String, Cache> caches = new StrictMap<String, Cache>("Caches collection");
+  protected final Map<String, ResultMap> resultMaps = new StrictMap<String, ResultMap>("Result Maps collection");
+  protected final Map<String, ParameterMap> parameterMaps = new StrictMap<String, ParameterMap>("Parameter Maps collection");
+  protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<String, KeyGenerator>("Key Generators collection");
 
   protected final Set<String> loadedResources = new HashSet<String>();
-  protected final Map<String, XNode> sqlFragments = new StrictMap<String, XNode>(
-      "XML fragments parsed from previous mappers");
+  protected final Map<String, XNode> sqlFragments = new StrictMap<String, XNode>("XML fragments parsed from previous mappers");
 
   protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
   protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
+  protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
   /**
    * A map holds cache-ref relationship. The key is the namespace that
    * references a cache bound to another namespace and the value is the
@@ -106,19 +102,13 @@ public Configuration(Environment environment) {
   }
 
   public Configuration() {
-    typeAliasRegistry.registerAlias("JDBC",
-        JdbcTransactionFactory.class.getName());
-    typeAliasRegistry.registerAlias("MANAGED",
-        ManagedTransactionFactory.class.getName());
-    typeAliasRegistry.registerAlias("JNDI",
-        JndiDataSourceFactory.class.getName());
-    typeAliasRegistry.registerAlias("POOLED",
-        PooledDataSourceFactory.class.getName());
-    typeAliasRegistry.registerAlias("UNPOOLED",
-        UnpooledDataSourceFactory.class.getName());
-
-    typeAliasRegistry
-        .registerAlias("PERPETUAL", PerpetualCache.class.getName());
+    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class.getName());
+    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class.getName());
+    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class.getName());
+    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class.getName());
+    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class.getName());
+
+    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class.getName());
     typeAliasRegistry.registerAlias("FIFO", FifoCache.class.getName());
     typeAliasRegistry.registerAlias("LRU", LruCache.class.getName());
     typeAliasRegistry.registerAlias("SOFT", SoftCache.class.getName());
@@ -158,9 +148,7 @@ public void setLazyLoadingEnabled(boolean lazyLoadingEnabled) {
       try {
         Resources.classForName("net.sf.cglib.proxy.Enhancer");
       } catch (Throwable e) {
-        throw new IllegalStateException(
-            "Cannot enable lazy loading because CGLIB is not available. Add CGLIB to your classpath.",
-            e);
+        throw new IllegalStateException("Cannot enable lazy loading because CGLIB is not available. Add CGLIB to your classpath.", e);
       }
     }
     this.lazyLoadingEnabled = lazyLoadingEnabled;
@@ -258,35 +246,23 @@ public MetaObject newMetaObject(Object object) {
     return MetaObject.forObject(object, objectFactory, objectWrapperFactory);
   }
 
-  public ParameterHandler newParameterHandler(MappedStatement mappedStatement,
-      Object parameterObject, BoundSql boundSql) {
-    ParameterHandler parameterHandler = new DefaultParameterHandler(
-        mappedStatement, parameterObject, boundSql);
-    parameterHandler = (ParameterHandler) interceptorChain
-        .pluginAll(parameterHandler);
+  public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
+    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
+    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
     return parameterHandler;
   }
 
-  public ResultSetHandler newResultSetHandler(Executor executor,
-      MappedStatement mappedStatement, RowBounds rowBounds,
-      ParameterHandler parameterHandler, ResultHandler resultHandler,
-      BoundSql boundSql) {
-    ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? new NestedResultSetHandler(
-        executor, mappedStatement, parameterHandler, resultHandler, boundSql,
-        rowBounds) : new FastResultSetHandler(executor, mappedStatement,
-        parameterHandler, resultHandler, boundSql, rowBounds);
-    resultSetHandler = (ResultSetHandler) interceptorChain
-        .pluginAll(resultSetHandler);
+  public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
+      ResultHandler resultHandler, BoundSql boundSql) {
+    ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? new NestedResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql,
+        rowBounds) : new FastResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
+    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
     return resultSetHandler;
   }
 
-  public StatementHandler newStatementHandler(Executor executor,
-      MappedStatement mappedStatement, Object parameterObject,
-      RowBounds rowBounds, ResultHandler resultHandler) {
-    StatementHandler statementHandler = new RoutingStatementHandler(executor,
-        mappedStatement, parameterObject, rowBounds, resultHandler);
-    statementHandler = (StatementHandler) interceptorChain
-        .pluginAll(statementHandler);
+  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) {
+    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler);
+    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
     return statementHandler;
   }
 
@@ -407,13 +383,13 @@ public void addMappedStatement(MappedStatement ms, String databaseId) {
           if (previous == null || previous.getDatabaseId() == null) {
             mappedStatements.put(ms.getId(), ms);
           }
-        }        
+        }
       } else {
-        mappedStatements.put(ms.getId(), ms);      
+        mappedStatements.put(ms.getId(), ms);
       }
     }
   }
-  
+
   public void addMappedStatement(MappedStatement ms) {
     addMappedStatement(ms, null);
   }
@@ -444,12 +420,19 @@ public void addIncompleteCacheRef(CacheRefResolver incompleteCacheRef) {
     incompleteCacheRefs.add(incompleteCacheRef);
   }
 
+  public Collection<ResultMapResolver> getIncompleteResultMaps() {
+    return incompleteResultMaps;
+  }
+
+  public void addIncompleteResultMap(ResultMapResolver resultMapResolver) {
+    incompleteResultMaps.add(resultMapResolver);
+  }
+
   public MappedStatement getMappedStatement(String id) {
     return this.getMappedStatement(id, true);
   }
 
-  public MappedStatement getMappedStatement(String id,
-      boolean validateIncompleteStatements) {
+  public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
     if (validateIncompleteStatements) {
       buildAllStatements();
     }
@@ -486,7 +469,7 @@ public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
     return mapperRegistry.getMapper(type, sqlSession);
   }
 
-  public boolean hasMapper(Class type) {
+  public boolean hasMapper(Class<?> type) {
     return mapperRegistry.hasMapper(type);
   }
 
@@ -505,6 +488,12 @@ public void addCacheRef(String namespace, String referencedNamespace) {
    * statement validation.
    */
   protected void buildAllStatements() {
+    if (!incompleteResultMaps.isEmpty()) {
+      synchronized (incompleteResultMaps) {
+        // This always throws a BuilderException.
+        incompleteResultMaps.iterator().next().resolve();
+      }
+    }
     if (!incompleteCacheRefs.isEmpty()) {
       synchronized (incompleteCacheRefs) {
         // This always throws a BuilderException.
@@ -537,10 +526,8 @@ protected void checkGloballyForDiscriminatedNestedResultMaps(ResultMap rm) {
         Object value = entry.getValue();
         if (value instanceof ResultMap) {
           ResultMap entryResultMap = (ResultMap) value;
-          if (!entryResultMap.hasNestedResultMaps()
-              && entryResultMap.getDiscriminator() != null) {
-            Collection<String> discriminatedResultMapNames = entryResultMap
-                .getDiscriminator().getDiscriminatorMap().values();
+          if (!entryResultMap.hasNestedResultMaps() && entryResultMap.getDiscriminator() != null) {
+            Collection<String> discriminatedResultMapNames = entryResultMap.getDiscriminator().getDiscriminatorMap().values();
             if (discriminatedResultMapNames.contains(rm.getId())) {
               entryResultMap.forceNestedResultMaps();
             }
@@ -553,12 +540,10 @@ protected void checkGloballyForDiscriminatedNestedResultMaps(ResultMap rm) {
   // Slow but a one time cost. A better solution is welcome.
   protected void checkLocallyForDiscriminatedNestedResultMaps(ResultMap rm) {
     if (!rm.hasNestedResultMaps() && rm.getDiscriminator() != null) {
-      for (Map.Entry entry : rm.getDiscriminator().getDiscriminatorMap()
-          .entrySet()) {
+      for (Map.Entry entry : rm.getDiscriminator().getDiscriminatorMap().entrySet()) {
         String discriminatedResultMapName = (String) entry.getValue();
         if (hasResultMap(discriminatedResultMapName)) {
-          ResultMap discriminatedResultMap = resultMaps
-              .get(discriminatedResultMapName);
+          ResultMap discriminatedResultMap = resultMaps.get(discriminatedResultMapName);
           if (discriminatedResultMap.hasNestedResultMaps()) {
             rm.forceNestedResultMaps();
             break;
@@ -568,8 +553,7 @@ protected void checkLocallyForDiscriminatedNestedResultMaps(ResultMap rm) {
     }
   }
 
-  protected static class StrictMap<J extends String, K extends Object> extends
-      HashMap<J, K> {
+  protected static class StrictMap<J extends String, K extends Object> extends HashMap<J, K> {
 
     private String name;
 
@@ -595,8 +579,7 @@ public StrictMap(String name, Map<? extends J, ? extends K> m) {
 
     public K put(J key, K value) {
       if (containsKey(key))
-        throw new IllegalArgumentException(name
-            + " already contains value for " + key);
+        throw new IllegalArgumentException(name + " already contains value for " + key);
       if (key.contains(".")) {
         final String shortKey = getShortName(key);
         if (super.get(shortKey) == null) {
@@ -611,15 +594,11 @@ public K put(J key, K value) {
     public K get(Object key) {
       K value = super.get(key);
       if (value == null) {
-        throw new IllegalArgumentException(name
-            + " does not contain value for " + key);
+        throw new IllegalArgumentException(name + " does not contain value for " + key);
       }
       if (value instanceof Ambiguity) {
-        throw new IllegalArgumentException(
-            ((Ambiguity) value).getSubject()
-                + " is ambiguous in "
-                + name
-                + " (try using the full name including the namespace, or rename one of the entries)");
+        throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
+            + " (try using the full name including the namespace, or rename one of the entries)");
       }
       return value;
     }

src/test/java/org/apache/ibatis/submitted/xml_external_ref/Dog.java

@@ -0,0 +1,5 @@
+package org.apache.ibatis.submitted.xml_external_ref;
+
+public class Dog extends Pet {
+
+}