Refactor ParameterMetadata to PartTreeParameterBinding.

Avoid having two similar approaches while setter factories operate on ParameterBinding.

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/AbstractStringBasedJpaQuery.java

@@ -52,7 +52,6 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 	private final Lazy<DeclaredQuery> countQuery;
 	private final QueryMethodEvaluationContextProvider evaluationContextProvider;
 	private final SpelExpressionParser parser;
-	private final QueryParameterSetter.QueryMetadataCache metadataCache = new QueryParameterSetter.QueryMetadataCache();
 	private final QueryRewriter queryRewriter;
 	private final QuerySortRewriter querySortRewriter;
 	private final Lazy<ParameterBinder> countParameterBinder;
@@ -123,11 +122,9 @@ public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 
 		Query query = createJpaQuery(sortedQueryString, sort, accessor.getPageable(), processor.getReturnedType());
 
-		QueryParameterSetter.QueryMetadata metadata = metadataCache.getMetadata(sortedQueryString, query);
-
 		// it is ok to reuse the binding contained in the ParameterBinder although we create a new query String because the
 		// parameters in the query do not change.
-		return parameterBinder.get().bindAndPrepare(query, metadata, accessor);
+		return parameterBinder.get().bindAndPrepare(query, accessor);
 	}
 
 	String getSortedQueryString(Sort sort) {
@@ -154,9 +151,8 @@ protected Query doCreateCountQuery(JpaParametersParameterAccessor accessor) {
 				? em.createNativeQuery(queryString) //
 				: em.createQuery(queryString, Long.class);
 
-		QueryParameterSetter.QueryMetadata metadata = metadataCache.getMetadata(queryString, query);
-
-		countParameterBinder.get().bind(metadata.withQuery(query), accessor, QueryParameterSetter.ErrorHandling.LENIENT);
+		countParameterBinder.get().bind(new QueryParameterSetter.BindableQuery(query), accessor,
+				QueryParameterSetter.ErrorHandling.LENIENT);
 
 		return query;
 	}

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaKeysetScrollQueryCreator.java

@@ -43,7 +43,7 @@ class JpaKeysetScrollQueryCreator extends JpaQueryCreator {
 	private final JpaEntityInformation<?, ?> entityInformation;
 	private final KeysetScrollPosition scrollPosition;
 	private final ParameterMetadataProvider provider;
-	private final List<ParameterBinding.Synthetic> bindings = new ArrayList<>();
+	private final List<ParameterBinding> syntheticBindings = new ArrayList<>();
 
 	public JpaKeysetScrollQueryCreator(PartTree tree, ReturnedType type, ParameterMetadataProvider provider,
 			JpqlQueryTemplates templates, JpaEntityInformation<?, ?> entityInformation, KeysetScrollPosition scrollPosition,
@@ -57,7 +57,13 @@ public JpaKeysetScrollQueryCreator(PartTree tree, ReturnedType type, ParameterMe
 	}
 
 	@Override
-	List<ParameterBinding.Synthetic> getSyntheticParameterBindings() {
+	public List<ParameterBinding> getBindings() {
+
+		List<ParameterBinding> partTreeBindings = super.getBindings();
+		List<ParameterBinding> bindings = new ArrayList<>(partTreeBindings.size() + this.syntheticBindings.size());
+		bindings.addAll(partTreeBindings);
+		bindings.addAll(this.syntheticBindings);
+
 		return bindings;
 	}
 
@@ -69,11 +75,11 @@ protected JpqlQueryBuilder.AbstractJpqlQuery createQuery(@Nullable JpqlQueryBuil
 
 		JpqlQueryBuilder.Select query = buildQuery(keysetSpec.sort());
 
-		AtomicInteger counter = new AtomicInteger(provider.getExpressions().size());
+		AtomicInteger counter = new AtomicInteger(provider.getBindings().size());
 		JpqlQueryBuilder.Predicate keysetPredicate = keysetSpec.createJpqlPredicate(getFrom(), getEntity(), value -> {
 
-			bindings.add(ParameterBinding.ParameterOrigin.synthetic(value));
-			return JpqlQueryBuilder.expression(render(counter.getAndIncrement()));
+			syntheticBindings.add(provider.nextSynthetic(value, scrollPosition));
+			return JpqlQueryBuilder.expression(render(counter.incrementAndGet()));
 		});
 		JpqlQueryBuilder.Predicate predicateToUse = getPredicate(predicate, keysetPredicate);
 

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java

@@ -27,13 +27,13 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.domain.JpaSort;
 import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.PathAndOrigin;
+import org.springframework.data.jpa.repository.query.ParameterBinding.PartTreeParameterBinding;
 import org.springframework.data.jpa.repository.query.ParameterMetadataProvider.ParameterMetadata;
 import org.springframework.data.jpa.repository.support.JpqlQueryTemplates;
 import org.springframework.data.mapping.PropertyPath;
@@ -58,7 +58,7 @@
  * @author Andrey Kovalev
  * @author Greg Turnquist
  */
-public class JpaQueryCreator extends AbstractQueryCreator<String, JpqlQueryBuilder.Predicate> {
+class JpaQueryCreator extends AbstractQueryCreator<String, JpqlQueryBuilder.Predicate> {
 
 	private final ReturnedType returnedType;
 	private final ParameterMetadataProvider provider;
@@ -109,12 +109,8 @@ public boolean useTupleQuery() {
 	 *
 	 * @return the parameterExpressions
 	 */
-	public List<ParameterMetadata> getParameterExpressions() {
-		return provider.getExpressions();
-	}
-
-	List<ParameterBinding.Synthetic> getSyntheticParameterBindings() {
-		return Collections.emptyList();
+	public List<ParameterBinding> getBindings() {
+		return provider.getBindings();
 	}
 
 	@Override
@@ -254,8 +250,12 @@ Collection<String> getRequiredSelection(Sort sort, ReturnedType returnedType) {
 		return returnedType.getInputProperties();
 	}
 
+	String render(ParameterBinding binding) {
+		return render(binding.getRequiredPosition());
+	}
+
 	String render(int position) {
-		return "?" + (position + 1);
+		return "?" + position;
 	}
 
 	private String render(ParameterMetadata metadata) {
@@ -311,8 +311,8 @@ public JpqlQueryBuilder.Predicate build() {
 
 			switch (type) {
 				case BETWEEN:
-					ParameterMetadata first = provider.next(part);
-					ParameterMetadata second = provider.next(part);
+					PartTreeParameterBinding first = provider.next(part);
+					ParameterBinding second = provider.next(part);
 					return where.between(render(first), render(second));
 				case AFTER:
 				case GREATER_THAN:
@@ -347,7 +347,7 @@ public JpqlQueryBuilder.Predicate build() {
 				case LIKE:
 				case NOT_LIKE:
 
-					ParameterMetadata parameter = provider.next(part, String.class);
+					PartTreeParameterBinding parameter = provider.next(part, String.class);
 					JpqlQueryBuilder.Expression parameterExpression = potentiallyIgnoreCase(part.getProperty(),
 							JpqlQueryBuilder.parameter(render(parameter)));
 					// Predicate like = builder.like(propertyExpression, parameterExpression, escape.getEscapeCharacter());
@@ -362,7 +362,7 @@ public JpqlQueryBuilder.Predicate build() {
 				case FALSE:
 					return where.isFalse();
 				case SIMPLE_PROPERTY:
-					ParameterMetadata metadata = provider.next(part);
+					PartTreeParameterBinding metadata = provider.next(part);
 
 					if (metadata.isIsNullParameter()) {
 						return where.isNull();

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/NamedQuery.java

@@ -52,7 +52,6 @@ final class NamedQuery extends AbstractJpaQuery {
 	private final @Nullable String countProjection;
 	private final boolean namedCountQueryIsPresent;
 	private final Lazy<DeclaredQuery> declaredQuery;
-	private final QueryParameterSetter.QueryMetadataCache metadataCache;
 
 	/**
 	 * Creates a new {@link NamedQuery}.
@@ -93,7 +92,6 @@ private NamedQuery(JpaQueryMethod method, EntityManager em) {
 
 		// TODO: Detect whether a named query is a native one.
 		this.declaredQuery = Lazy.of(() -> DeclaredQuery.of(queryString, query.toString().contains("NativeQuery")));
-		this.metadataCache = new QueryParameterSetter.QueryMetadataCache();
 	}
 
 	/**
@@ -165,9 +163,7 @@ protected Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 				? em.createNamedQuery(queryName) //
 				: em.createNamedQuery(queryName, typeToRead);
 
-		QueryParameterSetter.QueryMetadata metadata = metadataCache.getMetadata(queryName, query);
-
-		return parameterBinder.get().bindAndPrepare(query, metadata, accessor);
+		return parameterBinder.get().bindAndPrepare(query, accessor);
 	}
 
 	@Override
@@ -188,9 +184,7 @@ protected TypedQuery<Long> doCreateCountQuery(JpaParametersParameterAccessor acc
 			countQuery = em.createQuery(countQueryString, Long.class);
 		}
 
-		QueryParameterSetter.QueryMetadata metadata = metadataCache.getMetadata(cacheKey, countQuery);
-
-		return parameterBinder.get().bind(countQuery, metadata, accessor);
+		return parameterBinder.get().bind(countQuery, accessor);
 	}
 
 	@Override

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/ParameterBinder.java

@@ -72,10 +72,10 @@ public ParameterBinder(JpaParameters parameters, Iterable<QueryParameterSetter>
 		this.useJpaForPaging = useJpaForPaging;
 	}
 
-	public <T extends Query> T bind(T jpaQuery, QueryParameterSetter.QueryMetadata metadata,
+	public <T extends Query> T bind(T jpaQuery,
 			JpaParametersParameterAccessor accessor) {
 
-		bind(metadata.withQuery(jpaQuery), accessor, ErrorHandling.STRICT);
+		bind(new QueryParameterSetter.BindableQuery(jpaQuery), accessor, ErrorHandling.STRICT);
 		return jpaQuery;
 	}
 
@@ -94,10 +94,10 @@ public void bind(QueryParameterSetter.BindableQuery query, JpaParametersParamete
 	 * @param metadata must not be {@literal null}.
 	 * @param accessor must not be {@literal null}.
 	 */
-	Query bindAndPrepare(Query query, QueryParameterSetter.QueryMetadata metadata,
+	Query bindAndPrepare(Query query,
 			JpaParametersParameterAccessor accessor) {
 
-		bind(query, metadata, accessor);
+		bind(query, accessor);
 
 		Pageable pageable = accessor.getPageable();
 

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/ParameterBinderFactory.java

@@ -21,7 +21,6 @@
 import org.springframework.data.jpa.repository.query.JpaParameters.JpaParameter;
 import org.springframework.data.jpa.repository.query.ParameterBinding.BindingIdentifier;
 import org.springframework.data.jpa.repository.query.ParameterBinding.ParameterOrigin;
-import org.springframework.data.jpa.repository.query.ParameterMetadataProvider.ParameterMetadata;
 import org.springframework.data.repository.query.QueryMethodEvaluationContextProvider;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.util.Assert;
@@ -54,29 +53,21 @@ static ParameterBinder createBinder(JpaParameters parameters) {
 	}
 
 	/**
-	 * Creates a {@link ParameterBinder} that just matches method parameter to parameters of a
-	 * {@link jakarta.persistence.criteria.CriteriaQuery}.
+	 * Creates a {@link ParameterBinder} that matches method parameter to parameters of a
+	 * {@link jakarta.persistence.Query} and that can bind synthetic parameters.
 	 *
 	 * @param parameters method parameters that are available for binding, must not be {@literal null}.
-	 * @param metadata parameter metadata for method argument parameters, must not be {@literal null}.
-	 * @param syntheticBindings additional (e.g. synthetic) syntheticBindings, must not be {@literal null}.
+	 * @param bindings parameter bindings for method argument and synthetic parameters, must not be {@literal null}.
 	 * @return a {@link ParameterBinder} that can assign values for the method parameters to query parameters of a
-	 *         {@link jakarta.persistence.criteria.CriteriaQuery}
+	 *         {@link jakarta.persistence.Query}
 	 */
-	static ParameterBinder createCriteriaBinder(JpaParameters parameters, List<ParameterMetadata> metadata,
-			List<ParameterBinding.Synthetic> syntheticBindings) {
+	static ParameterBinder createBinder(JpaParameters parameters, List<ParameterBinding> bindings) {
 
 		Assert.notNull(parameters, "JpaParameters must not be null");
-		Assert.notNull(metadata, "Parameter metadata must not be null");
-
-		List<ParameterBinding> bindingsToUse = getBindings(parameters);
-		int offset = bindingsToUse.size();
-		for (ParameterBinding.Synthetic binding : syntheticBindings) {
-			bindingsToUse.add(new ParameterBinding(BindingIdentifier.of(++offset), binding));
-		}
+		Assert.notNull(bindings, "Parameter bindings must not be null");
 
 		return new ParameterBinder(parameters,
-				createSetters(bindingsToUse, QueryParameterSetterFactory.forPartTreeQuery(parameters, metadata),
+				createSetters(bindings, QueryParameterSetterFactory.forPartTreeQuery(parameters),
 						QueryParameterSetterFactory.forSynthetic()));
 	}