private <E> List<E> queryFromDatabase(
MappedStatement ms,
Object parameter,
RowBounds rowBounds,
ResultHandler resultHandler,
CacheKey key,
BoundSql boundSql)
throws SQLException {
List<E> list;
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
localCache.removeObject(key);
}
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
private void handleLocallyCachedOutputParameters(
MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
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 : boundSql.getParameterMappings()) {
if (parameterMapping.getMode() != ParameterMode.IN) {
final String parameterName = parameterMapping.getProperty();
final Object cachedValue = metaCachedParameter.getValue(parameterName);
metaParameter.setValue(parameterName, cachedValue);
}
}
}
}
}
@SuppressWarnings("unchecked")
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 (closed) throw new ExecutorException("Executor was closed.");
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
clearLocalCache(); // issue #482
}
}
return list;
}
public void load() {
Object value = null;
@SuppressWarnings("unchecked") // we suppose we get back a List
List<Object> list = (List<Object>) localCache.getObject(key);
Class<?> targetType = resultObject.getSetterType(property);
if (targetType.isAssignableFrom(list.getClass())) {
value = list;
} else if (objectFactory.isCollection(targetType)) {
value = objectFactory.create(targetType);
MetaObject metaObject = configuration.newMetaObject(value);
metaObject.addAll(list);
} else if (targetType.isArray()) {
Object[] array = (Object[]) Array.newInstance(targetType.getComponentType(), list.size());
value = list.toArray(array);
} else {
if (list != null && list.size() > 1) {
throw new ExecutorException(
"Statement returned more than one row, where no more than one was expected.");
} else if (list != null && list.size() == 1) {
value = list.get(0);
}
}
resultObject.setValue(property, value);
}
public boolean canLoad() {
return localCache.getObject(key) != null
&& localCache.getObject(key) != EXECUTION_PLACEHOLDER;
}
public void clearLocalCache() {
if (!closed) {
localCache.clear();
localOutputParameterCache.clear();
}
}
public boolean isCached(MappedStatement ms, CacheKey key) {
return localCache.getObject(key) != null;
}
