package org.springframework.data.jpa.repository.query;
import java.util.List;
import java.util.function.Function;
import javax.persistence.Query;
import javax.persistence.TemporalType;
import org.springframework.data.jpa.repository.query.JpaParameters.JpaParameter;
import org.springframework.data.jpa.repository.query.ParameterMetadataProvider.ParameterMetadata;
import org.springframework.data.jpa.repository.query.QueryParameterSetter.NamedOrIndexedQueryParameterSetter;
import org.springframework.data.jpa.repository.query.StringQuery.ParameterBinding;
import org.springframework.data.repository.query.Parameter;
import org.springframework.data.repository.query.Parameters;
import org.springframework.data.repository.query.QueryMethodEvaluationContextProvider;
import org.springframework.data.spel.EvaluationContextProvider;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
abstract class QueryParameterSetterFactory {
@Nullable
abstract QueryParameterSetter create(ParameterBinding binding, DeclaredQuery declaredQuery);
static QueryParameterSetterFactory basic(JpaParameters parameters) {
Assert.notNull(parameters, "JpaParameters must not be null!");
return new BasicQueryParameterSetterFactory(parameters);
}
static QueryParameterSetterFactory forCriteriaQuery(JpaParameters parameters, List<ParameterMetadata<?>> metadata) {
Assert.notNull(parameters, "JpaParameters must not be null!");
Assert.notNull(metadata, "ParameterMetadata must not be null!");
return new CriteriaQueryParameterSetterFactory(parameters, metadata);
}
static QueryParameterSetterFactory parsing(SpelExpressionParser parser,
QueryMethodEvaluationContextProvider evaluationContextProvider, Parameters<?, ?> parameters) {
Assert.notNull(parser, "SpelExpressionParser must not be null!");
Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
Assert.notNull(parameters, "Parameters must not be null!");
return new ExpressionBasedQueryParameterSetterFactory(parser, evaluationContextProvider, parameters);
}
private static QueryParameterSetter createSetter(Function<JpaParametersParameterAccessor, Object> valueExtractor,
ParameterBinding binding, @Nullable JpaParameter parameter) {
TemporalType temporalType = parameter != null && parameter.isTemporalParameter()
? parameter.getRequiredTemporalType()
: null;
return new NamedOrIndexedQueryParameterSetter(valueExtractor.andThen(binding::prepare),
ParameterImpl.of(parameter, binding), temporalType);
}
private static class ExpressionBasedQueryParameterSetterFactory extends QueryParameterSetterFactory {
private final SpelExpressionParser parser;
private final QueryMethodEvaluationContextProvider evaluationContextProvider;
private final Parameters<?, ?> parameters;
ExpressionBasedQueryParameterSetterFactory(SpelExpressionParser parser,
QueryMethodEvaluationContextProvider evaluationContextProvider, Parameters<?, ?> parameters) {
Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
Assert.notNull(parser, "SpelExpressionParser must not be null!");
Assert.notNull(parameters, "Parameters must not be null!");
this.evaluationContextProvider = evaluationContextProvider;
this.parser = parser;
this.parameters = parameters;
}
@Nullable
@Override
public QueryParameterSetter create(ParameterBinding binding, DeclaredQuery declaredQuery) {
if (!binding.isExpression()) {
return null;
}
Expression expression = parser.parseExpression(binding.getExpression());
return createSetter(values -> evaluateExpression(expression, values), binding, null);
}
@Nullable
private Object evaluateExpression(Expression expression, JpaParametersParameterAccessor accessor) {
EvaluationContext context = evaluationContextProvider.getEvaluationContext(parameters, accessor.getValues());
return expression.getValue(context, Object.class);
}
}
private static class BasicQueryParameterSetterFactory extends QueryParameterSetterFactory {
private final JpaParameters parameters;
BasicQueryParameterSetterFactory(JpaParameters parameters) {
Assert.notNull(parameters, "JpaParameters must not be null!");
this.parameters = parameters;
}
@Override
public QueryParameterSetter create(ParameterBinding binding, DeclaredQuery declaredQuery) {
Assert.notNull(binding, "Binding must not be null.");
JpaParameter parameter;
if (declaredQuery.hasNamedParameter()) {
parameter = findParameterForBinding(binding);
} else {
int parameterIndex = binding.getRequiredPosition() - 1;
JpaParameters bindableParameters = parameters.getBindableParameters();
Assert.isTrue(
parameterIndex < bindableParameters.getNumberOfParameters(),
() -> String.format(
"At least %s parameter(s) provided but only %s parameter(s) present in query.",
binding.getRequiredPosition(),
bindableParameters.getNumberOfParameters()
)
);
parameter = bindableParameters.getParameter(binding.getRequiredPosition() - 1);
}
return parameter == null
? QueryParameterSetter.NOOP
: createSetter(values -> getValue(values, parameter), binding, parameter);
}
@Nullable
private JpaParameter findParameterForBinding(ParameterBinding binding) {
JpaParameters bindableParameters = parameters.getBindableParameters();
for (JpaParameter bindableParameter : bindableParameters) {
if (binding.getRequiredName().equals(getName(bindableParameter))) {
return bindableParameter;
}
}
return null;
}
private Object getValue(JpaParametersParameterAccessor accessor, Parameter parameter) {
return accessor.getValue(parameter);
}
private static String getName(JpaParameter p) {
return p.getName().orElseThrow(() -> new IllegalStateException(ParameterBinder.PARAMETER_NEEDS_TO_BE_NAMED));
}
}
private static class CriteriaQueryParameterSetterFactory extends QueryParameterSetterFactory {
private final JpaParameters parameters;
private final List<ParameterMetadata<?>> expressions;
CriteriaQueryParameterSetterFactory(JpaParameters parameters, List<ParameterMetadata<?>> metadata) {
Assert.notNull(parameters, "JpaParameters must not be null!");
Assert.notNull(metadata, "Expressions must not be null!");
this.parameters = parameters;
this.expressions = metadata;
}
@Override
public QueryParameterSetter create(ParameterBinding binding, DeclaredQuery declaredQuery) {
int parameterIndex = binding.getRequiredPosition() - 1;
Assert.isTrue(
parameterIndex < expressions.size(),
() -> String.format(
"At least %s parameter(s) provided but only %s parameter(s) present in query.",
binding.getRequiredPosition(),
expressions.size()
)
);
ParameterMetadata<?> metadata = expressions.get(parameterIndex);
if (metadata.isIsNullParameter()) {
return QueryParameterSetter.NOOP;
}
JpaParameter parameter = parameters.getBindableParameter(parameterIndex);
TemporalType temporalType = parameter.isTemporalParameter() ? parameter.getRequiredTemporalType() : null;
return new NamedOrIndexedQueryParameterSetter(values -> {
return getAndPrepare(parameter, metadata, values);
}, metadata.getExpression(), temporalType);
}
@Nullable
private Object getAndPrepare(JpaParameter parameter, ParameterMetadata<?> metadata,
JpaParametersParameterAccessor accessor) {
return metadata.prepare(accessor.getValue(parameter));
}
}
private static class ParameterImpl<T> implements javax.persistence.Parameter<T> {
private final Class<T> parameterType;
private final @Nullable String name;
private final @Nullable Integer position;
static javax.persistence.Parameter<?> of(@Nullable JpaParameter parameter, ParameterBinding binding) {
Class<?> type = parameter == null ? Object.class : parameter.getType();
return new ParameterImpl<>(type, getName(parameter, binding), binding.getPosition());
}
private ParameterImpl(Class<T> parameterType, @Nullable String name, @Nullable Integer position) {
this.name = name;
this.position = position;
this.parameterType = parameterType;
}
@Nullable
@Override
public String getName() {
return name;
}
@Nullable
@Override
public Integer getPosition() {
return position;
}
@Override
public Class<T> getParameterType() {
return parameterType;
}
@Nullable
private static String getName(@Nullable JpaParameter parameter, ParameterBinding binding) {
if (parameter == null) {
return binding.getName();
}
return parameter.isNamedParameter()
? parameter.getName().orElseThrow(() -> new IllegalArgumentException("o_O parameter needs to have a name!"))
: null;
}
}
}