Polishing.

Remove unused methods, fix naming, group DeclaredQuery implementations in DeclaredQueries.

Author: mp911de

spring-data-jpa/src/jmh/java/org/springframework/data/jpa/repository/query/HqlParserBenchmarks.java

@@ -27,6 +27,8 @@
 import org.openjdk.jmh.annotations.Warmup;
 
 import org.springframework.data.domain.Sort;
+import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
+import org.springframework.data.repository.query.ReturnedType;
 
 /**
  * @author Mark Paluch
@@ -44,6 +46,7 @@ public static class BenchmarkParameters {
 		DeclaredQuery query;
 		Sort sort = Sort.by("foo");
 		QueryEnhancer enhancer;
+		QueryEnhancer.QueryRewriteInformation rewriteInformation;
 
 		@Setup(Level.Iteration)
 		public void doSetup() {
@@ -57,12 +60,14 @@ OR TREAT(p AS SmallProject).name LIKE 'Persist%'
 
 			query = DeclaredQuery.jpqlQuery(s);
 			enhancer = QueryEnhancerFactory.forQuery(query).create(query);
+			rewriteInformation = new DefaultQueryRewriteInformation(sort,
+					ReturnedType.of(Object.class, Object.class, new SpelAwareProxyProjectionFactory()));
 		}
 	}
 
 	@Benchmark
 	public Object measure(BenchmarkParameters parameters) {
-		return parameters.enhancer.applySorting(parameters.sort);
+		return parameters.enhancer.rewrite(parameters.rewriteInformation);
 	}
 
 }

spring-data-jpa/src/jmh/java/org/springframework/data/jpa/repository/query/JSqlParserQueryEnhancerBenchmarks.java

@@ -29,6 +29,8 @@
 import org.openjdk.jmh.annotations.Warmup;
 
 import org.springframework.data.domain.Sort;
+import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
+import org.springframework.data.repository.query.ReturnedType;
 
 /**
  * @author Mark Paluch
@@ -46,6 +48,7 @@ public static class BenchmarkParameters {
 		JSqlParserQueryEnhancer enhancer;
 		Sort sort = Sort.by("foo");
 		private byte[] serialized;
+		private QueryEnhancer.QueryRewriteInformation rewriteInformation;
 
 		@Setup(Level.Iteration)
 		public void doSetup() throws IOException {
@@ -57,12 +60,14 @@ public void doSetup() throws IOException {
 					union select SOME_COLUMN from SOME_OTHER_OTHER_TABLE""";
 
 			enhancer = new JSqlParserQueryEnhancer(DeclaredQuery.nativeQuery(s));
+			rewriteInformation = new DefaultQueryRewriteInformation(sort,
+					ReturnedType.of(Object.class, Object.class, new SpelAwareProxyProjectionFactory()));
 		}
 	}
 
 	@Benchmark
 	public Object applySortWithParsing(BenchmarkParameters p) {
-		return p.enhancer.applySorting(p.sort);
+		return p.enhancer.rewrite(p.rewriteInformation);
 	}
 
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/config/EnableJpaRepositories.java

@@ -178,4 +178,5 @@
 	 * @since 4.0
 	 */
 	Class<? extends QueryEnhancerSelector> queryEnhancerSelector() default QueryEnhancerSelector.DefaultQueryEnhancerSelector.class;
+
 }

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

@@ -32,7 +32,6 @@
 import org.springframework.data.util.Lazy;
 import org.springframework.util.Assert;
 import org.springframework.util.ConcurrentLruCache;
-import org.springframework.util.StringUtils;
 
 /**
  * Base class for {@link String} based JPA queries.
@@ -64,26 +63,42 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 	 * @param method must not be {@literal null}.
 	 * @param em must not be {@literal null}.
 	 * @param queryString must not be {@literal null}.
-	 * @param countQueryString must not be {@literal null}.
+	 * @param countQuery can be {@literal null} if not defined.
 	 * @param queryConfiguration must not be {@literal null}.
 	 */
-	public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, String queryString,
+	AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, String queryString,
 			@Nullable String countQueryString, JpaQueryConfiguration queryConfiguration) {
+		this(method, em, method.getDeclaredQuery(queryString),
+				countQueryString != null ? method.getDeclaredQuery(countQueryString) : null, queryConfiguration);
+	}
+
+	/**
+	 * Creates a new {@link AbstractStringBasedJpaQuery} from the given {@link JpaQueryMethod}, {@link EntityManager} and
+	 * query {@link String}.
+	 *
+	 * @param method must not be {@literal null}.
+	 * @param em must not be {@literal null}.
+	 * @param query must not be {@literal null}.
+	 * @param countQuery can be {@literal null}.
+	 * @param queryConfiguration must not be {@literal null}.
+	 */
+	public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, DeclaredQuery query,
+			@Nullable DeclaredQuery countQuery, JpaQueryConfiguration queryConfiguration) {
 
 		super(method, em);
 
-		Assert.hasText(queryString, "Query string must not be null or empty");
+		Assert.notNull(query, "Query must not be null");
 		Assert.notNull(queryConfiguration, "JpaQueryConfiguration must not be null");
 
 		this.valueExpressionDelegate = queryConfiguration.getValueExpressionDelegate();
 		this.valueExpressionContextProvider = valueExpressionDelegate.createValueContextProvider(method.getParameters());
 
-		this.query = TemplatedQuery.create(queryString, method, queryConfiguration);
+		this.query = TemplatedQuery.create(query, method.getEntityInformation(), queryConfiguration);
 
 		this.countQuery = Lazy.of(() -> {
 
-			if (StringUtils.hasText(countQueryString)) {
-				return TemplatedQuery.create(countQueryString, method, queryConfiguration);
+			if (countQuery != null) {
+				return TemplatedQuery.create(countQuery, method.getEntityInformation(), queryConfiguration);
 			}
 
 			return this.query.deriveCountQuery(method.getCountQueryProjection());
@@ -119,15 +134,15 @@ public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 		Sort sort = accessor.getSort();
 		ResultProcessor processor = getQueryMethod().getResultProcessor().withDynamicProjection(accessor);
 		ReturnedType returnedType = processor.getReturnedType();
-		QueryProvider sortedQueryString = getSortedQueryString(sort, returnedType);
-		Query query = createJpaQuery(sortedQueryString, sort, accessor.getPageable(), returnedType);
+		QueryProvider sortedQuery = getSortedQuery(sort, returnedType);
+		Query query = createJpaQuery(sortedQuery, sort, accessor.getPageable(), returnedType);
 
 		// 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, accessor);
 	}
 
-	QueryProvider getSortedQueryString(Sort sort, ReturnedType returnedType) {
+	QueryProvider getSortedQuery(Sort sort, ReturnedType returnedType) {
 		return querySortRewriter.getSorted(query, sort, returnedType);
 	}
 
@@ -175,20 +190,20 @@ public StructuredQuery getCountQuery() {
 	 * Creates an appropriate JPA query from an {@link EntityManager} according to the current {@link AbstractJpaQuery}
 	 * type.
 	 */
-	protected Query createJpaQuery(QueryProvider queryString, Sort sort, @Nullable Pageable pageable,
+	protected Query createJpaQuery(QueryProvider query, Sort sort, @Nullable Pageable pageable,
 			ReturnedType returnedType) {
 
 		EntityManager em = getEntityManager();
 
 		if (this.query.hasConstructorExpression() || this.query.isDefaultProjection()) {
-			return em.createQuery(potentiallyRewriteQuery(queryString.getQueryString(), sort, pageable));
+			return em.createQuery(potentiallyRewriteQuery(query.getQueryString(), sort, pageable));
 		}
 
 		Class<?> typeToRead = getTypeToRead(returnedType);
 
 		return typeToRead == null //
-				? em.createQuery(potentiallyRewriteQuery(queryString.getQueryString(), sort, pageable)) //
-				: em.createQuery(potentiallyRewriteQuery(queryString.getQueryString(), sort, pageable), typeToRead);
+				? em.createQuery(potentiallyRewriteQuery(query.getQueryString(), sort, pageable)) //
+				: em.createQuery(potentiallyRewriteQuery(query.getQueryString(), sort, pageable), typeToRead);
 	}
 
 	/**
@@ -233,21 +248,21 @@ public QueryProvider getSorted(EntityQuery query, Sort sort, ReturnedType return
 
 	static class UnsortedCachingQuerySortRewriter implements QuerySortRewriter {
 
-		private volatile @Nullable QueryProvider cachedQueryString;
+		private volatile @Nullable QueryProvider cachedQuery;
 
 		public QueryProvider getSorted(EntityQuery query, Sort sort, ReturnedType returnedType) {
 
 			if (sort.isSorted()) {
 				throw new UnsupportedOperationException("NoOpQueryCache does not support sorting");
 			}
 
-			QueryProvider cachedQueryString = this.cachedQueryString;
-			if (cachedQueryString == null) {
-				this.cachedQueryString = cachedQueryString = query
+			QueryProvider cachedQuery = this.cachedQuery;
+			if (cachedQuery == null) {
+				this.cachedQuery = cachedQuery = query
 						.rewrite(new DefaultQueryRewriteInformation(sort, returnedType));
 			}
 
-			return cachedQueryString;
+			return cachedQuery;
 		}
 	}
 
@@ -259,19 +274,19 @@ class CachingQuerySortRewriter implements QuerySortRewriter {
 		private final ConcurrentLruCache<CachableQuery, QueryProvider> queryCache = new ConcurrentLruCache<>(16,
 				AbstractStringBasedJpaQuery.this::applySorting);
 
-		private volatile @Nullable QueryProvider cachedQueryString;
+		private volatile @Nullable QueryProvider cachedQuery;
 
 		@Override
 		public QueryProvider getSorted(EntityQuery query, Sort sort, ReturnedType returnedType) {
 
 			if (sort.isUnsorted()) {
 
-				QueryProvider cachedQueryString = this.cachedQueryString;
-				if (cachedQueryString == null) {
-					this.cachedQueryString = cachedQueryString = queryCache.get(new CachableQuery(query, sort, returnedType));
+				QueryProvider cachedQuery = this.cachedQuery;
+				if (cachedQuery == null) {
+					this.cachedQuery = cachedQuery = queryCache.get(new CachableQuery(query, sort, returnedType));
 				}
 
-				return cachedQueryString;
+				return cachedQuery;
 			}
 
 			return queryCache.get(new CachableQuery(query, sort, returnedType));

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

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2025 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.springframework.data.jpa.repository.query;
+
+import org.springframework.util.ObjectUtils;
+
+/**
+ * Utility class encapsulating {@code DeclaredQuery} implementations.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 4.0
+ */
+class DeclaredQueries {
+
+	static final class JpqlQuery implements DeclaredQuery {
+
+		private final String jpql;
+
+		JpqlQuery(String jpql) {
+			this.jpql = jpql;
+		}
+
+		@Override
+		public boolean isNative() {
+			return false;
+		}
+
+		@Override
+		public String getQueryString() {
+			return jpql;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (!(o instanceof JpqlQuery jpqlQuery)) {
+				return false;
+			}
+			return ObjectUtils.nullSafeEquals(jpql, jpqlQuery.jpql);
+		}
+
+		@Override
+		public int hashCode() {
+			return ObjectUtils.nullSafeHashCode(jpql);
+		}
+
+		@Override
+		public String toString() {
+			return "JPQL[" + jpql + "]";
+		}
+
+	}
+
+	static final class NativeQuery implements DeclaredQuery {
+
+		private final String sql;
+
+		NativeQuery(String sql) {
+			this.sql = sql;
+		}
+
+		@Override
+		public boolean isNative() {
+			return true;
+		}
+
+		@Override
+		public String getQueryString() {
+			return sql;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (!(o instanceof NativeQuery that)) {
+				return false;
+			}
+			return ObjectUtils.nullSafeEquals(sql, that.sql);
+		}
+
+		@Override
+		public int hashCode() {
+			return ObjectUtils.nullSafeHashCode(sql);
+		}
+
+		@Override
+		public String toString() {
+			return "Native[" + sql + "]";
+		}
+
+	}
+
+	/**
+	 * A rewritten {@link DeclaredQuery} holding a reference to its original query.
+	 */
+	static class RewrittenQuery implements DeclaredQuery {
+
+		private final DeclaredQuery source;
+		private final String queryString;
+
+		public RewrittenQuery(DeclaredQuery source, String queryString) {
+			this.source = source;
+			this.queryString = queryString;
+		}
+
+		@Override
+		public boolean isNative() {
+			return source.isNative();
+		}
+
+		@Override
+		public String getQueryString() {
+			return queryString;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (!(o instanceof RewrittenQuery that)) {
+				return false;
+			}
+			return ObjectUtils.nullSafeEquals(queryString, that.queryString);
+		}
+
+		@Override
+		public int hashCode() {
+			return ObjectUtils.nullSafeHashCode(queryString);
+		}
+
+		@Override
+		public String toString() {
+			return isNative() ? "Rewritten Native[" + queryString + "]" : "Rewritten JPQL[" + queryString + "]";
+		}
+
+	}
+
+}