ProviderSqlSource.java
/*
* Copyright 2009-2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.builder.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;
import org.apache.ibatis.annotations.Lang;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.reflection.ParamNameResolver;
import org.apache.ibatis.scripting.LanguageDriver;
import org.apache.ibatis.session.Configuration;
/**
* @author Clinton Begin
* @author Kazuki Shimizu
*/
public class ProviderSqlSource implements SqlSource {
private final Configuration configuration;
private final Class<?> providerType;
private final LanguageDriver languageDriver;
private final Method mapperMethod;
private final Method providerMethod;
private final String[] providerMethodArgumentNames;
private final Class<?>[] providerMethodParameterTypes;
private final ProviderContext providerContext;
private final Integer providerContextIndex;
/**
* This constructor will remove at a future version.
*
* @param configuration
* the configuration
* @param provider
* the provider
*
* @deprecated Since 3.5.3, Please use the {@link #ProviderSqlSource(Configuration, Annotation, Class, Method)}
* instead of this.
*/
@Deprecated
public ProviderSqlSource(Configuration configuration, Object provider) {
this(configuration, provider, null, null);
}
/**
* This constructor will remove at a future version.
*
* @param configuration
* the configuration
* @param provider
* the provider
* @param mapperType
* the mapper type
* @param mapperMethod
* the mapper method
*
* @since 3.4.5
*
* @deprecated Since 3.5.3, Please use the {@link #ProviderSqlSource(Configuration, Annotation, Class, Method)}
* instead of this.
*/
@Deprecated
public ProviderSqlSource(Configuration configuration, Object provider, Class<?> mapperType, Method mapperMethod) {
this(configuration, (Annotation) provider, mapperType, mapperMethod);
}
/**
* Instantiates a new provider sql source.
*
* @param configuration
* the configuration
* @param provider
* the provider
* @param mapperType
* the mapper type
* @param mapperMethod
* the mapper method
*
* @since 3.5.3
*/
public ProviderSqlSource(Configuration configuration, Annotation provider, Class<?> mapperType, Method mapperMethod) {
String candidateProviderMethodName;
Method candidateProviderMethod = null;
try {
this.configuration = configuration;
this.mapperMethod = mapperMethod;
Lang lang = mapperMethod == null ? null : mapperMethod.getAnnotation(Lang.class);
this.languageDriver = configuration.getLanguageDriver(lang == null ? null : lang.value());
this.providerType = getProviderType(configuration, provider, mapperMethod);
candidateProviderMethodName = (String) provider.annotationType().getMethod("method").invoke(provider);
if (candidateProviderMethodName.length() == 0
&& ProviderMethodResolver.class.isAssignableFrom(this.providerType)) {
candidateProviderMethod = ((ProviderMethodResolver) this.providerType.getDeclaredConstructor().newInstance())
.resolveMethod(new ProviderContext(mapperType, mapperMethod, configuration.getDatabaseId()));
}
if (candidateProviderMethod == null) {
candidateProviderMethodName = candidateProviderMethodName.length() == 0 ? "provideSql"
: candidateProviderMethodName;
for (Method m : this.providerType.getMethods()) {
if (candidateProviderMethodName.equals(m.getName())
&& CharSequence.class.isAssignableFrom(m.getReturnType())) {
if (candidateProviderMethod != null) {
throw new BuilderException("Error creating SqlSource for SqlProvider. Method '"
+ candidateProviderMethodName + "' is found multiple in SqlProvider '" + this.providerType.getName()
+ "'. Sql provider method can not overload.");
}
candidateProviderMethod = m;
}
}
}
} catch (BuilderException e) {
throw e;
} catch (Exception e) {
throw new BuilderException("Error creating SqlSource for SqlProvider. Cause: " + e, e);
}
if (candidateProviderMethod == null) {
throw new BuilderException("Error creating SqlSource for SqlProvider. Method '" + candidateProviderMethodName
+ "' not found in SqlProvider '" + this.providerType.getName() + "'.");
}
this.providerMethod = candidateProviderMethod;
this.providerMethodArgumentNames = new ParamNameResolver(configuration, this.providerMethod).getNames();
this.providerMethodParameterTypes = this.providerMethod.getParameterTypes();
ProviderContext candidateProviderContext = null;
Integer candidateProviderContextIndex = null;
for (int i = 0; i < this.providerMethodParameterTypes.length; i++) {
Class<?> parameterType = this.providerMethodParameterTypes[i];
if (parameterType == ProviderContext.class) {
if (candidateProviderContext != null) {
throw new BuilderException(
"Error creating SqlSource for SqlProvider. ProviderContext found multiple in SqlProvider method ("
+ this.providerType.getName() + "." + providerMethod.getName()
+ "). ProviderContext can not define multiple in SqlProvider method argument.");
}
candidateProviderContext = new ProviderContext(mapperType, mapperMethod, configuration.getDatabaseId());
candidateProviderContextIndex = i;
}
}
this.providerContext = candidateProviderContext;
this.providerContextIndex = candidateProviderContextIndex;
}
@Override
public BoundSql getBoundSql(Object parameterObject) {
SqlSource sqlSource = createSqlSource(parameterObject);
return sqlSource.getBoundSql(parameterObject);
}
private SqlSource createSqlSource(Object parameterObject) {
try {
String sql;
if (parameterObject instanceof Map) {
int bindParameterCount = providerMethodParameterTypes.length - (providerContext == null ? 0 : 1);
if (bindParameterCount == 1
&& providerMethodParameterTypes[Integer.valueOf(0).equals(providerContextIndex) ? 1 : 0]
.isAssignableFrom(parameterObject.getClass())) {
sql = invokeProviderMethod(extractProviderMethodArguments(parameterObject));
} else {
@SuppressWarnings("unchecked")
Map<String, Object> params = (Map<String, Object>) parameterObject;
sql = invokeProviderMethod(extractProviderMethodArguments(params, providerMethodArgumentNames));
}
} else
switch (providerMethodParameterTypes.length) {
case 0:
sql = invokeProviderMethod();
break;
case 1:
if (providerContext == null) {
sql = invokeProviderMethod(parameterObject);
} else {
sql = invokeProviderMethod(providerContext);
}
break;
case 2:
sql = invokeProviderMethod(extractProviderMethodArguments(parameterObject));
break;
default:
throw new BuilderException("Cannot invoke SqlProvider method '" + providerMethod
+ "' with specify parameter '" + (parameterObject == null ? null : parameterObject.getClass())
+ "' because SqlProvider method arguments for '" + mapperMethod + "' is an invalid combination.");
}
Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
return languageDriver.createSqlSource(configuration, sql, parameterType);
} catch (BuilderException e) {
throw e;
} catch (Exception e) {
throw new BuilderException("Error invoking SqlProvider method '" + providerMethod + "' with specify parameter '"
+ (parameterObject == null ? null : parameterObject.getClass()) + "'. Cause: " + extractRootCause(e), e);
}
}
private Throwable extractRootCause(Exception e) {
Throwable cause = e;
while (cause.getCause() != null) {
cause = cause.getCause();
}
return cause;
}
private Object[] extractProviderMethodArguments(Object parameterObject) {
if (providerContext != null) {
Object[] args = new Object[2];
args[providerContextIndex == 0 ? 1 : 0] = parameterObject;
args[providerContextIndex] = providerContext;
return args;
}
return new Object[] { parameterObject };
}
private Object[] extractProviderMethodArguments(Map<String, Object> params, String[] argumentNames) {
Object[] args = new Object[argumentNames.length];
for (int i = 0; i < args.length; i++) {
if (providerContextIndex != null && providerContextIndex == i) {
args[i] = providerContext;
} else {
args[i] = params.get(argumentNames[i]);
}
}
return args;
}
private String invokeProviderMethod(Object... args) throws Exception {
Object targetObject = null;
if (!Modifier.isStatic(providerMethod.getModifiers())) {
targetObject = providerType.getDeclaredConstructor().newInstance();
}
CharSequence sql = (CharSequence) providerMethod.invoke(targetObject, args);
return sql != null ? sql.toString() : null;
}
private Class<?> getProviderType(Configuration configuration, Annotation providerAnnotation, Method mapperMethod)
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Class<?> type = (Class<?>) providerAnnotation.annotationType().getMethod("type").invoke(providerAnnotation);
Class<?> value = (Class<?>) providerAnnotation.annotationType().getMethod("value").invoke(providerAnnotation);
if (value == void.class && type == void.class) {
if (configuration.getDefaultSqlProviderType() != null) {
return configuration.getDefaultSqlProviderType();
}
throw new BuilderException("Please specify either 'value' or 'type' attribute of @"
+ providerAnnotation.annotationType().getSimpleName() + " at the '" + mapperMethod.toString() + "'.");
}
if (value != void.class && type != void.class && value != type) {
throw new BuilderException("Cannot specify different class on 'value' and 'type' attribute of @"
+ providerAnnotation.annotationType().getSimpleName() + " at the '" + mapperMethod.toString() + "'.");
}
return value == void.class ? type : value;
}
}