Refactor EQL, HQL & JPQL query rendering.

This commit turns existing query transformers into introspectors using eager parsing and detection of query parts.
Query transformation has also been split up into dedicated Count and Sort Query parts.
To reduce duplicate code across the existing parses we introduced a reusable functional configuration.
For better testing support a query assertion has been introduced to query parser tests and we adjusted invalid formatting.

See: #3309
Closes: #3326

Author: mp911de

spring-data-jpa-performance/src/main/java/org/springframework/data/jpa/repository/PersonRepository.java

@@ -17,6 +17,7 @@
 
 import java.util.List;
 
+import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.model.IPersonProjection;
 import org.springframework.data.jpa.model.Person;
 import org.springframework.data.repository.ListCrudRepository;
@@ -33,6 +34,9 @@ public interface PersonRepository extends ListCrudRepository<Person, Integer> {
     @Query("SELECT p FROM org.springframework.data.jpa.model.Person p WHERE p.firstname = ?1")
     List<Person> findAllWithAnnotatedQueryByFirstname(String firstname);
 
+		@Query("SELECT p FROM org.springframework.data.jpa.model.Person p WHERE p.firstname = ?1")
+		List<Person> findAllWithAnnotatedQueryByFirstname(String firstname, Sort sort);
+
     @Query(value = "SELECT * FROM person WHERE firstname = ?1", nativeQuery = true)
     List<Person> findAllWithNativeQueryByFirstname(String firstname);
 }

spring-data-jpa-performance/src/test/java/org/springframework/data/jpa/repository/Profiler.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 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;
+
+import org.springframework.data.domain.Sort;
+
+/**
+ * @author Mark Paluch
+ */
+public class Profiler {
+
+	public static void main(String[] args) throws InterruptedException {
+
+		RepositoryFinderTests tests = new RepositoryFinderTests();
+		RepositoryFinderTests.BenchmarkParameters params = new RepositoryFinderTests.BenchmarkParameters();
+		params.doSetup();
+
+		System.out.println("Ready. Waiting 10sec");
+		Thread.sleep(10000);
+
+		System.out.println("Go!");
+
+		while (true) {
+			params.repositoryProxy.findAllWithAnnotatedQueryByFirstname("first", Sort.by("firstname"));
+		}
+
+	}
+}

spring-data-jpa-performance/src/test/java/org/springframework/data/jpa/repository/RepositoryFinderTests.java

@@ -40,6 +40,8 @@
 import org.openjdk.jmh.annotations.TearDown;
 import org.openjdk.jmh.annotations.Timeout;
 import org.openjdk.jmh.annotations.Warmup;
+
+import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.model.IPersonProjection;
 import org.springframework.data.jpa.model.Person;
 import org.springframework.data.jpa.model.Profile;
@@ -151,11 +153,17 @@ public List<IPersonProjection> derivedFinderMethodWithInterfaceProjection(Benchm
 		return parameters.repositoryProxy.findAllAndProjectToInterfaceByFirstname("first");
 	}
 
+
 	@Benchmark
 	public List<Person> stringBasedQuery(BenchmarkParameters parameters) {
 		return parameters.repositoryProxy.findAllWithAnnotatedQueryByFirstname("first");
 	}
 
+	@Benchmark
+	public List<Person> stringBasedQueryDynamicSort(BenchmarkParameters parameters) {
+		return parameters.repositoryProxy.findAllWithAnnotatedQueryByFirstname("first", Sort.by("firstname"));
+	}
+
 	@Benchmark
 	public List<Person> stringBasedNativeQuery(BenchmarkParameters parameters) {
 		return parameters.repositoryProxy.findAllWithNativeQueryByFirstname("first");

spring-data-jpa-performance/src/test/java/org/springframework/data/jpa/repository/query/HqlParserTests.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2024 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 jmh.mbr.junit5.Microbenchmark;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Timeout;
+import org.openjdk.jmh.annotations.Warmup;
+
+import org.springframework.data.domain.Sort;
+
+/**
+ * @author Mark Paluch
+ */
+@Microbenchmark
+@Fork(1)
+@Warmup(time = 2, iterations = 3)
+@Measurement(time = 2)
+@Timeout(time = 2)
+public class HqlParserTests {
+
+	@State(Scope.Benchmark)
+	public static class BenchmarkParameters {
+
+		DeclaredQuery query;
+		Sort sort = Sort.by("foo");
+		QueryEnhancer enhancer;
+
+		@Setup(Level.Iteration)
+		public void doSetup() {
+
+			String s = """
+					SELECT e FROM Employee e JOIN e.projects p
+					WHERE TREAT(p AS LargeProject).budget > 1000
+					    OR TREAT(p AS SmallProject).name LIKE 'Persist%'
+					    OR p.description LIKE "cost overrun"
+					""";
+
+			query = DeclaredQuery.of(s, false);
+			enhancer = QueryEnhancerFactory.forQuery(query);
+		}
+	}
+
+	@Benchmark
+	public Object measure(BenchmarkParameters parameters) {
+		return parameters.enhancer.applySorting(parameters.sort);
+	}
+
+}

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

@@ -40,6 +40,15 @@ static DeclaredQuery of(@Nullable String query, boolean nativeQuery) {
 		return ObjectUtils.isEmpty(query) ? EmptyDeclaredQuery.EMPTY_QUERY : new StringQuery(query, nativeQuery);
 	}
 
+	static boolean hasNamedParameter(String query) {
+
+		if (ObjectUtils.isEmpty(query)) {
+			return false;
+		}
+
+		return StringQuery.hasNamedParameter(query);
+	}
+
 	/**
 	 * @return whether the underlying query has at least one named parameter.
 	 */

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023-2024 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 static org.springframework.data.jpa.repository.query.JpaQueryParsingToken.*;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.query.QueryRenderer.QueryRendererBuilder;
+import org.springframework.lang.Nullable;
+
+/**
+ * An ANTLR {@link org.antlr.v4.runtime.tree.ParseTreeVisitor} that transforms a parsed EQL query into a
+ * {@code COUNT(…)} query.
+ *
+ * @author Greg Turnquist
+ * @author Mark Paluch
+ * @since 3.4
+ */
+@SuppressWarnings("ConstantValue")
+class EqlCountQueryTransformer extends EqlQueryRenderer {
+
+	private final @Nullable String countProjection;
+	private final @Nullable String primaryFromAlias;
+
+	EqlCountQueryTransformer(@Nullable String countProjection, @Nullable String primaryFromAlias) {
+		this.countProjection = countProjection;
+		this.primaryFromAlias = primaryFromAlias;
+	}
+
+	@Override
+	public QueryRendererBuilder visitSelect_statement(EqlParser.Select_statementContext ctx) {
+
+		QueryRendererBuilder builder = QueryRenderer.builder();
+
+		builder.appendExpression(visit(ctx.select_clause()));
+		builder.appendExpression(visit(ctx.from_clause()));
+
+		if (ctx.where_clause() != null) {
+			builder.appendExpression(visit(ctx.where_clause()));
+		}
+		if (ctx.groupby_clause() != null) {
+			builder.appendExpression(visit(ctx.groupby_clause()));
+		}
+		if (ctx.having_clause() != null) {
+			builder.appendExpression(visit(ctx.having_clause()));
+		}
+
+		return builder;
+	}
+
+	@Override
+	public QueryRendererBuilder visitSelect_clause(EqlParser.Select_clauseContext ctx) {
+
+		QueryRendererBuilder builder = QueryRenderer.builder();
+
+		builder.append(JpaQueryParsingToken.expression(ctx.SELECT()));
+		builder.append(TOKEN_COUNT_FUNC);
+
+		if (countProjection != null) {
+			builder.append(JpaQueryParsingToken.token(countProjection));
+		}
+
+		QueryRendererBuilder nested = QueryRenderer.builder();
+
+		if (ctx.DISTINCT() != null) {
+			nested.append(JpaQueryParsingToken.expression(ctx.DISTINCT()));
+		}
+
+		if (countProjection == null) {
+
+			if (ctx.DISTINCT() != null) {
+
+				QueryRendererBuilder selectionListbuilder = QueryRendererBuilder.concat(ctx.select_item(), this::visit,
+						TOKEN_COMMA);
+
+				List<JpaQueryParsingToken> countSelection = QueryTransformers
+						.filterCountSelection(selectionListbuilder.build().stream().toList());
+
+				if (countSelection.stream().anyMatch(eqlToken -> eqlToken.getToken().contains("new"))) {
+					// constructor
+					nested.append(new JpaQueryParsingToken(primaryFromAlias));
+				} else {
+					// keep all the select items to distinct against
+					nested.append(countSelection);
+				}
+			} else {
+				nested.append(new JpaQueryParsingToken(primaryFromAlias));
+			}
+		}
+
+		builder.appendInline(nested);
+		builder.append(TOKEN_CLOSE_PAREN);
+
+		return builder;
+	}
+
+}

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

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2024 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 static org.springframework.data.jpa.repository.query.JpaQueryParsingToken.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link ParsedQueryIntrospector} for EQL queries.
+ *
+ * @author Mark Paluch
+ */
+@SuppressWarnings("UnreachableCode")
+class EqlQueryIntrospector extends EqlBaseVisitor<Void> implements ParsedQueryIntrospector {
+
+	private final EqlQueryRenderer renderer = new EqlQueryRenderer();
+
+	private @Nullable String primaryFromAlias = null;
+	private @Nullable List<JpaQueryParsingToken> projection;
+	private boolean projectionProcessed;
+	private boolean hasConstructorExpression = false;
+
+	@Override
+	public String getAlias() {
+		return primaryFromAlias;
+	}
+
+	@Override
+	public List<JpaQueryParsingToken> getProjection() {
+		return projection == null ? Collections.emptyList() : projection;
+	}
+
+	@Override
+	public boolean hasConstructorExpression() {
+		return hasConstructorExpression;
+	}
+
+	@Override
+	public Void visitSelect_clause(EqlParser.Select_clauseContext ctx) {
+
+		List<EqlParser.Select_itemContext> selections = ctx.select_item();
+		List<JpaQueryParsingToken> selectItemTokens = new ArrayList<>(selections.size() * 2);
+
+		for (EqlParser.Select_itemContext selection : selections) {
+
+			if (!selectItemTokens.isEmpty()) {
+				selectItemTokens.add(TOKEN_COMMA);
+			}
+
+			selectItemTokens.add(JpaQueryParsingToken.token(renderer.visitSelect_item(selection).build().render()));
+		}
+
+		if (!projectionProcessed) {
+			projection = selectItemTokens;
+			projectionProcessed = true;
+		}
+
+		return super.visitSelect_clause(ctx);
+	}
+
+	@Override
+	public Void visitRange_variable_declaration(EqlParser.Range_variable_declarationContext ctx) {
+
+		if (primaryFromAlias == null) {
+			primaryFromAlias = ctx.identification_variable() != null ? ctx.identification_variable().getText()
+					: ctx.entity_name().getText();
+		}
+
+		return super.visitRange_variable_declaration(ctx);
+	}
+
+	@Override
+	public Void visitConstructor_expression(EqlParser.Constructor_expressionContext ctx) {
+
+		hasConstructorExpression = true;
+
+		return super.visitConstructor_expression(ctx);
+	}
+
+}