fixed output parameter caching issue, and created NullCacheKey instance which is a little safer (avoids accidental usage of the NULL_CACHE_KEY field)

Author: cbegin

src/main/java/org/apache/ibatis/cache/CacheKey.java

@@ -5,7 +5,7 @@
 
 public class CacheKey {
 
-  public static final CacheKey NULL_CACHE_KEY = new CacheKey();
+  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();
 
   private static final int DEFAULT_MULTIPLYER = 37;
   private static final int DEFAULT_HASHCODE = 17;

src/main/java/org/apache/ibatis/cache/NullCacheKey.java

@@ -0,0 +1,19 @@
+package org.apache.ibatis.cache;
+
+
+public final class NullCacheKey extends CacheKey {
+
+  public NullCacheKey() {
+    super();
+  }
+
+  @Override
+  public void update(Object object) {
+    throw new CacheException("Not allowed to update a NullCacheKey instance.");
+  }
+
+  @Override
+  public void updateAll(Object[] objects) {
+    throw new CacheException("Not allowed to update a NullCacheKey instance.");
+  }
+}

src/main/java/org/apache/ibatis/executor/BaseExecutor.java

@@ -3,9 +3,8 @@
 import org.apache.ibatis.cache.CacheKey;
 import org.apache.ibatis.cache.impl.PerpetualCache;
 import static org.apache.ibatis.executor.ExecutionPlaceholder.EXECUTION_PLACEHOLDER;
-import org.apache.ibatis.mapping.BoundSql;
-import org.apache.ibatis.mapping.MappedStatement;
-import org.apache.ibatis.mapping.ParameterMapping;
+
+import org.apache.ibatis.mapping.*;
 import org.apache.ibatis.reflection.MetaObject;
 import org.apache.ibatis.session.ResultHandler;
 import org.apache.ibatis.session.RowBounds;
@@ -24,6 +23,7 @@ public abstract class BaseExecutor implements Executor {
 
   protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
   protected PerpetualCache localCache;
+  protected PerpetualCache localOutputParameterCache;
   protected Configuration configuration;
 
   protected int queryStack = 0;
@@ -35,6 +35,7 @@ protected BaseExecutor(Configuration configuration, Transaction transaction) {
     this.transaction = transaction;
     this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
     this.localCache = new PerpetualCache("LocalCache");
+    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
     this.closed = false;
     this.configuration = configuration;
   }
@@ -57,6 +58,7 @@ public void close(boolean forceRollback) {
       transaction = null;
       deferredLoads = null;
       localCache = null;
+      localOutputParameterCache = null;
       batchResults = null;
       closed = true;
     }
@@ -86,17 +88,11 @@ public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, Res
     try {
       queryStack++;
       CacheKey key = createCacheKey(ms, parameter, rowBounds);
-      final List cachedList = (List) localCache.getObject(key);
-      if (cachedList != null) {
-        list = cachedList;
+      list = (List) localCache.getObject(key);
+      if (list != null) {
+        handleLocallyCachedOutputParameters(ms, key, parameter);
       } else {
-        localCache.putObject(key, EXECUTION_PLACEHOLDER);
-        try {
-          list = doQuery(ms, parameter, rowBounds, resultHandler);
-        } finally {
-          localCache.removeObject(key);
-        }
-        localCache.putObject(key, list);
+        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key);
       }
     } finally {
       queryStack--;
@@ -173,6 +169,7 @@ public void rollback(boolean required) throws SQLException {
   public void clearLocalCache() {
     if (!closed) {
       localCache.clear();
+      localOutputParameterCache.clear();
     }
   }
 
@@ -195,6 +192,38 @@ protected void closeStatement(Statement statement) {
     }
   }
 
+  private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter) {
+    if (ms.getStatementType() == StatementType.CALLABLE) {
+      final Object cachedParameter = localOutputParameterCache.getObject(key);
+      if (cachedParameter != null && parameter != null) {
+        final MetaObject metaCachedParameter = MetaObject.forObject(cachedParameter);
+        final MetaObject metaParameter = MetaObject.forObject(parameter);
+        for (ParameterMapping parameterMapping : ms.getBoundSql(parameter).getParameterMappings()) {
+          if (parameterMapping.getMode() != ParameterMode.IN) {
+            final String parameterName = parameterMapping.getProperty();
+            final Object cachedValue = metaCachedParameter.getValue(parameterName);
+            metaParameter.setValue(parameterName, cachedValue);
+          }
+        }
+      }
+    }
+  }
+
+  private List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key) throws SQLException {
+    List list;
+    localCache.putObject(key, EXECUTION_PLACEHOLDER);
+    try {
+      list = doQuery(ms, parameter, rowBounds, resultHandler);
+    } finally {
+      localCache.removeObject(key);
+    }
+    localCache.putObject(key, list);
+    if (ms.getStatementType() == StatementType.CALLABLE) {
+      localOutputParameterCache.putObject(key, parameter);
+    }
+    return list;
+  }
+  
   private class DeferredLoad {
 
     MappedStatement mappedStatement;

src/test/java/org/apache/ibatis/submitted/sptests/SPTest.java

@@ -98,8 +98,8 @@ public void testAdderAsSelectDoubleCall1() {
             spMapper.adder(parameter);
             assertEquals((Integer) 5, parameter.getSum());
 
-            // clear cache is required in this instance.
-            sqlSession.clearCache();
+            // Resolved Output Parameter Caching Issue for Callable statements
+            // sqlSession.clearCache();
 
             parameter = new Parameter();
             parameter.setAddend1(2);
@@ -276,8 +276,8 @@ public void testCallWithResultSet4() {
             assertEquals(2, parms.get("totalRows"));
             assertEquals(2, names.size());
 
-            // clear cache is required in this instance.
-            sqlSession.clearCache();
+            // Resolved Output Parameter Caching Issue for Callable statements
+            // sqlSession.clearCache();
 
             parms = new HashMap<String, Object>();
             parms.put("lowestId", 2);