Introduce JSqlParser as option for parsing native queries.

Introduce a library that makes it possible to parse native SQL statements.

See #2409.

Author: DiegoKrupitza

pom.xml

@@ -27,6 +27,7 @@
 		<postgresql>42.2.19</postgresql>
 		<springdata.commons>2.7.0-SNAPSHOT</springdata.commons>
 		<vavr>0.10.3</vavr>
+		<jsqlparser.version>4.3</jsqlparser.version>
 
 		<hibernate.groupId>org.hibernate</hibernate.groupId>
 
@@ -372,6 +373,13 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>com.github.jsqlparser</groupId>
+			<artifactId>jsqlparser</artifactId>
+			<version>${jsqlparser.version}</version>
+			<scope>provided</scope>
+			<optional>true</optional>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/org/springframework/data/jpa/repository/query/AbstractJpaQuery.java

@@ -69,7 +69,7 @@ public abstract class AbstractJpaQuery implements RepositoryQuery {
 	private final PersistenceProvider provider;
 	private final Lazy<JpaQueryExecution> execution;
 
-	final Lazy<ParameterBinder> parameterBinder = Lazy.of(this::createBinder);
+	final Lazy<ParameterBinder> parameterBinder = new Lazy<>(this::createBinder);
 
 	/**
 	 * Creates a new {@link AbstractJpaQuery} from the given {@link JpaQueryMethod}.

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

@@ -34,6 +34,7 @@
  * @author Tom Hombergs
  * @author David Madden
  * @author Mark Paluch
+ * @author Diego Krupitza
  */
 abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 
@@ -55,8 +56,8 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 	 * @param parser must not be {@literal null}.
 	 */
 	public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, String queryString,
-			@Nullable String countQueryString,
-			QueryMethodEvaluationContextProvider evaluationContextProvider, SpelExpressionParser parser) {
+			@Nullable String countQueryString, QueryMethodEvaluationContextProvider evaluationContextProvider,
+			SpelExpressionParser parser) {
 
 		super(method, em);
 
@@ -65,10 +66,12 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 		Assert.notNull(parser, "Parser must not be null!");
 
 		this.evaluationContextProvider = evaluationContextProvider;
-		this.query = new ExpressionBasedStringQuery(queryString, method.getEntityInformation(), parser);
+		this.query = new ExpressionBasedStringQuery(queryString, method.getEntityInformation(), parser,
+				method.isNativeQuery());
 
 		DeclaredQuery countQuery = query.deriveCountQuery(countQueryString, method.getCountQueryProjection());
-		this.countQuery = ExpressionBasedStringQuery.from(countQuery, method.getEntityInformation(), parser);
+		this.countQuery = ExpressionBasedStringQuery.from(countQuery, method.getEntityInformation(), parser,
+				method.isNativeQuery());
 
 		this.parser = parser;
 
@@ -83,7 +86,8 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 	@Override
 	public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 
-		String sortedQueryString = QueryUtils.applySorting(query.getQueryString(), accessor.getSort(), query.getAlias());
+		String sortedQueryString = QueryEnhancerFactory.forQuery(query) //
+				.applySorting(accessor.getSort(), query.getAlias());
 		ResultProcessor processor = getQueryMethod().getResultProcessor().withDynamicProjection(accessor);
 
 		Query query = createJpaQuery(sortedQueryString, processor.getReturnedType());

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

@@ -24,6 +24,7 @@
  * A wrapper for a String representation of a query offering information about the query.
  *
  * @author Jens Schauder
+ * @author Diego Krupitza
  * @since 2.0.3
  */
 interface DeclaredQuery {
@@ -32,10 +33,11 @@ interface DeclaredQuery {
 	 * Creates a {@literal DeclaredQuery} from a query {@literal String}.
 	 *
 	 * @param query might be {@literal null} or empty.
+	 * @param nativeQuery is a given query is native or not
 	 * @return a {@literal DeclaredQuery} instance even for a {@literal null} or empty argument.
 	 */
-	static DeclaredQuery of(@Nullable String query) {
-		return ObjectUtils.isEmpty(query) ? EmptyDeclaredQuery.EMPTY_QUERY : new StringQuery(query);
+	static DeclaredQuery of(@Nullable String query, boolean nativeQuery) {
+		return ObjectUtils.isEmpty(query) ? EmptyDeclaredQuery.EMPTY_QUERY : new StringQuery(query, nativeQuery);
 	}
 
 	/**
@@ -100,4 +102,13 @@ default boolean usesPaging() {
 	 * @since 2.0.6
 	 */
 	boolean usesJdbcStyleParameters();
+
+	/**
+	 * Return whether the query is a native query of not.
+	 * 
+	 * @return <code>true</code> if native query otherwise <code>false</code>
+	 */
+	default boolean isNativeQuery() {
+		return false;
+	}
 }

src/main/java/org/springframework/data/jpa/repository/query/DefaultQueryEnhancer.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 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.data.domain.Sort;
+
+import java.util.Set;
+
+/**
+ * The implementation of {@link QueryEnhancer} using {@link QueryUtils}.
+ *
+ * @author Diego Krupitza
+ */
+public class DefaultQueryEnhancer implements QueryEnhancer {
+
+	private final DeclaredQuery query;
+
+	public DefaultQueryEnhancer(DeclaredQuery query) {
+		this.query = query;
+	}
+
+	@Override
+	public String getExistsQueryString(String entityName, String countQueryPlaceHolder, Iterable<String> idAttributes) {
+		return QueryUtils.getExistsQueryString(entityName, countQueryPlaceHolder, idAttributes);
+	}
+
+	@Override
+	public String getQueryString(String template, String entityName) {
+		return QueryUtils.getQueryString(template, entityName);
+	}
+
+	@Override
+	public String applySorting(Sort sort, String alias) {
+		return QueryUtils.applySorting(this.query.getQueryString(), sort, alias);
+	}
+
+	@Override
+	public String detectAlias() {
+		return QueryUtils.detectAlias(this.query.getQueryString());
+	}
+
+	@Override
+	public String createCountQueryFor(String countProjection) {
+		return QueryUtils.createCountQueryFor(this.query.getQueryString(), countProjection);
+	}
+
+	@Override
+	public String getProjection() {
+		return QueryUtils.getProjection(this.query.getQueryString());
+	}
+
+	@Override
+	public Set<String> getJoinAliases() {
+		return QueryUtils.getOuterJoinAliases(this.query.getQueryString());
+	}
+
+	@Override
+	public DeclaredQuery getQuery() {
+		return this.query;
+	}
+}

src/main/java/org/springframework/data/jpa/repository/query/EmptyDeclaredQuery.java

@@ -97,7 +97,7 @@ public DeclaredQuery deriveCountQuery(@Nullable String countQuery, @Nullable Str
 
 		Assert.hasText(countQuery, "CountQuery must not be empty!");
 
-		return DeclaredQuery.of(countQuery);
+		return DeclaredQuery.of(countQuery, false);
 	}
 
 	/*

src/main/java/org/springframework/data/jpa/repository/query/ExpressionBasedStringQuery.java

@@ -36,6 +36,7 @@
  * @author Oliver Gierke
  * @author Tom Hombergs
  * @author Michael J. Simons
+ * @author Diego Krupitza
  */
 class ExpressionBasedStringQuery extends StringQuery {
 
@@ -55,9 +56,11 @@ class ExpressionBasedStringQuery extends StringQuery {
 	 * @param query must not be {@literal null} or empty.
 	 * @param metadata must not be {@literal null}.
 	 * @param parser must not be {@literal null}.
+	 * @param nativeQuery is a given query is native or not
 	 */
-	public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, SpelExpressionParser parser) {
-		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser));
+	public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, SpelExpressionParser parser,
+			boolean nativeQuery) {
+		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser), nativeQuery && !containsExpression(query));
 	}
 
 	/**
@@ -66,11 +69,12 @@ public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, S
 	 * @param query the original query. Must not be {@literal null}.
 	 * @param metadata the {@link JpaEntityMetadata} for the given entity. Must not be {@literal null}.
 	 * @param parser Parser for resolving SpEL expressions. Must not be {@literal null}.
+	 * @param nativeQuery
 	 * @return A query supporting SpEL expressions.
 	 */
-	static ExpressionBasedStringQuery from(DeclaredQuery query, JpaEntityMetadata metadata,
-			SpelExpressionParser parser) {
-		return new ExpressionBasedStringQuery(query.getQueryString(), metadata, parser);
+	static ExpressionBasedStringQuery from(DeclaredQuery query, JpaEntityMetadata metadata, SpelExpressionParser parser,
+			boolean nativeQuery) {
+		return new ExpressionBasedStringQuery(query.getQueryString(), metadata, parser, nativeQuery);
 	}
 
 	/**