QueryUtils uses JSqlParser if possible.

`QueryUtils` can now decide at runtime if a given query can be processed using the JSqlParser or the (default) custom parser implementation, that can parse more than just standard SQL queries. JSqlParser is selected if the query qualifies as a native query (which means it does not use any special features such as SpEL and is marked with `nativeQuery=true`).

Related tickets spring-projects#2409

Author: DiegoKrupitza

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2021 the original author or authors.
+ * Copyright 2008-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.

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

@@ -86,8 +86,7 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 	@Override
 	public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 
-		String sortedQueryString = DefaultQueryUtils.applySorting(query.getQueryString(), accessor.getSort(),
-				query.getAlias());
+		String sortedQueryString = QueryUtils.applySorting(query, 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

@@ -102,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/ExpressionBasedStringQuery.java

@@ -60,7 +60,7 @@ class ExpressionBasedStringQuery extends StringQuery {
 	 */
 	public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, SpelExpressionParser parser,
 			boolean nativeQuery) {
-		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser), nativeQuery);
+		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser), nativeQuery && !containsExpression(query));
 	}
 
 	/**

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

@@ -201,7 +201,7 @@ protected CriteriaQuery<? extends Object> complete(@Nullable Predicate predicate
 			query = query.select((Root) root);
 		}
 
-		CriteriaQuery<? extends Object> select = query.orderBy(DefaultQueryUtils.toOrders(sort, root, builder));
+		CriteriaQuery<? extends Object> select = query.orderBy(QueryUtils.toOrders(sort, root, builder));
 		return predicate == null ? select : select.where(predicate);
 	}
 

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

@@ -49,7 +49,8 @@ interface QueryParameterSetter {
 	void setParameter(BindableQuery query, JpaParametersParameterAccessor accessor, ErrorHandling errorHandling);
 
 	/** Noop implementation */
-	QueryParameterSetter NOOP = (query, values, errorHandling) -> {};
+	QueryParameterSetter NOOP = (query, values, errorHandling) -> {
+	};
 
 	/**
 	 * {@link QueryParameterSetter} for named or indexed parameters that might have a {@link TemporalType} specified.
@@ -211,7 +212,7 @@ class QueryMetadata {
 
 		QueryMetadata(Query query) {
 
-			this.namedParameters = DefaultQueryUtils.hasNamedParameter(query);
+			this.namedParameters = QueryUtils.hasNamedParameter(query);
 			this.parameters = query.getParameters();
 
 			// DATAJPA-1172

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

@@ -0,0 +1,306 @@
+/*
+ * 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 java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.From;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.data.domain.Sort;
+import org.springframework.lang.Nullable;
+
+/**
+ * Simple utility class to create JPA queries.
+ *
+ * @author Diego Krupitza
+ */
+public abstract class QueryUtils {
+
+	private static final Log LOG = LogFactory.getLog(QueryUtils.class);
+
+	private static final boolean JSQLPARSER_IN_CLASSPATH = isJSqlParserInClassPath();
+
+	private QueryUtils() {
+	}
+
+	/**
+	 * Returns the query string to execute an exists query for the given id attributes.
+	 *
+	 * @param entityName the name of the entity to create the query for, must not be {@literal null}.
+	 * @param countQueryPlaceHolder the placeholder for the count clause, must not be {@literal null}.
+	 * @param idAttributes the id attributes for the entity, must not be {@literal null}.
+	 */
+	public static String getExistsQueryString(String entityName, String countQueryPlaceHolder,
+			Iterable<String> idAttributes) {
+		if (JSQLPARSER_IN_CLASSPATH) {
+			return JSqlParserQueryUtils.getExistsQueryString(entityName, countQueryPlaceHolder, idAttributes);
+		} else {
+			return DefaultQueryUtils.getExistsQueryString(entityName, countQueryPlaceHolder, idAttributes);
+		}
+	}
+
+	/**
+	 * Returns the query string for the given class name.
+	 *
+	 * @param template must not be {@literal null}.
+	 * @param entityName must not be {@literal null}.
+	 * @return the template with placeholders replaced by the {@literal entityName}. Guaranteed to be not {@literal null}.
+	 */
+	public static String getQueryString(String template, String entityName) {
+		if (JSQLPARSER_IN_CLASSPATH) {
+			return JSqlParserQueryUtils.getQueryString(template, entityName);
+		} else {
+			return DefaultQueryUtils.getQueryString(template, entityName);
+		}
+	}
+
+	/**
+	 * Adds {@literal order by} clause to the JPQL query. Uses the first alias to bind the sorting property to.
+	 *
+	 * @param query the query string to which sorting is applied
+	 * @param sort the sort specification to apply.
+	 * @return the modified query string.
+	 * @deprecated in favor of {@link QueryUtils#applySorting(DeclaredQuery, Sort)}
+	 */
+	@Deprecated
+	public static String applySorting(String query, Sort sort) {
+		return applySorting(query, sort, detectAlias(query));
+	}
+
+	/**
+	 * Adds {@literal order by} clause to the JPQL query.
+	 *
+	 * @param query the query string to which sorting is applied. Must not be {@literal null} or empty.
+	 * @param sort the sort specification to apply.
+	 * @param alias the alias to be used in the order by clause. May be {@literal null} or empty.
+	 * @return the modified query string.
+	 * @deprecated in favour of {@link QueryUtils#applySorting(DeclaredQuery, Sort, String)}
+	 */
+	@Deprecated
+	public static String applySorting(String query, Sort sort, @Nullable String alias) {
+		return DefaultQueryUtils.applySorting(query, sort, alias);
+	}
+
+	/**
+	 * Adds {@literal order by} clause to the JPQL query. Uses the first alias to bind the sorting property to.
+	 *
+	 * @param query the query string to which sorting is applied
+	 * @param sort the sort specification to apply.
+	 * @return the modified query string.
+	 */
+	public static String applySorting(DeclaredQuery query, Sort sort) {
+		return applySorting(query, sort, detectAlias(query));
+	}
+
+	/**
+	 * Adds {@literal order by} clause to the JPQL query.
+	 *
+	 * @param query the query string to which sorting is applied. Must not be {@literal null} or empty.
+	 * @param sort the sort specification to apply.
+	 * @param alias the alias to be used in the order by clause. May be {@literal null} or empty.
+	 * @return the modified query string.
+	 */
+	public static String applySorting(DeclaredQuery query, Sort sort, @Nullable String alias) {
+		if (qualifiesForJSqlParserUsage(query)) {
+			return JSqlParserQueryUtils.applySorting(query.getQueryString(), sort, alias);
+		} else {
+			return DefaultQueryUtils.applySorting(query.getQueryString(), sort, alias);
+		}
+	}
+
+	/**
+	 * Resolves the alias for the entity to be retrieved from the given JPA query.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @return Might return {@literal null}.
+	 * @deprecated in favor of {@link QueryUtils#detectAlias(DeclaredQuery)}
+	 */
+	@Nullable
+	@Deprecated
+	public static String detectAlias(String query) {
+		return DeclaredQuery.of(query, false).getAlias();
+	}
+
+	/**
+	 * Resolves the alias for the entity to be retrieved from the given JPA query.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @return Might return {@literal null}.
+	 */
+	@Nullable
+	public static String detectAlias(DeclaredQuery query) {
+		if (qualifiesForJSqlParserUsage(query)) {
+			return JSqlParserQueryUtils.detectAlias(query.getQueryString());
+		} else {
+			return DefaultQueryUtils.detectAlias(query.getQueryString());
+		}
+	}
+
+	/**
+	 * Creates a where-clause referencing the given entities and appends it to the given query string. Binds the given
+	 * entities to the query.
+	 *
+	 * @param <T> type of the entities.
+	 * @param queryString must not be {@literal null}.
+	 * @param entities must not be {@literal null}.
+	 * @param entityManager must not be {@literal null}.
+	 * @return Guaranteed to be not {@literal null}.
+	 */
+	public static <T> Query applyAndBind(String queryString, Iterable<T> entities, EntityManager entityManager) {
+		return DefaultQueryUtils.applyAndBind(queryString, entities, entityManager);
+	}
+
+	/**
+	 * Creates a count projected query from the given original query.
+	 *
+	 * @param originalQuery must not be {@literal null} or empty.
+	 * @return Guaranteed to be not {@literal null}.
+	 * @deprecated in favor of {@link QueryUtils#createCountQueryFor(DeclaredQuery)}
+	 */
+	@Deprecated
+	public static String createCountQueryFor(String originalQuery) {
+		return createCountQueryFor(originalQuery, null);
+	}
+
+	/**
+	 * Creates a count projected query from the given original query.
+	 *
+	 * @param originalQuery must not be {@literal null}.
+	 * @param countProjection may be {@literal null}.
+	 * @return a query String to be used a count query for pagination. Guaranteed to be not {@literal null}.
+	 * @since 1.6
+	 * @deprecated in favor of {@link QueryUtils#createCountQueryFor(DeclaredQuery, String)}
+	 */
+	@Deprecated
+	public static String createCountQueryFor(String originalQuery, @Nullable String countProjection) {
+		return DefaultQueryUtils.createCountQueryFor(originalQuery, countProjection);
+	}
+
+	/**
+	 * Creates a count projected query from the given original query.
+	 *
+	 * @param originalQuery must not be {@literal null} or empty.
+	 * @return Guaranteed to be not {@literal null}.
+	 */
+	public static String createCountQueryFor(DeclaredQuery originalQuery) {
+		return createCountQueryFor(originalQuery, null);
+	}
+
+	/**
+	 * Creates a count projected query from the given original query.
+	 *
+	 * @param originalQuery must not be {@literal null}.
+	 * @param countProjection may be {@literal null}.
+	 * @return a query String to be used a count query for pagination. Guaranteed to be not {@literal null}.
+	 */
+	public static String createCountQueryFor(DeclaredQuery originalQuery, @Nullable String countProjection) {
+		if (qualifiesForJSqlParserUsage(originalQuery)) {
+			return JSqlParserQueryUtils.createCountQueryFor(originalQuery.getQueryString(), countProjection);
+		} else {
+			return DefaultQueryUtils.createCountQueryFor(originalQuery.getQueryString(), countProjection);
+		}
+	}
+
+	/**
+	 * Returns whether the given {@link Query} contains named parameters.
+	 *
+	 * @param query Must not be {@literal null}.
+	 * @return whether the given {@link Query} contains named parameters.
+	 */
+	public static boolean hasNamedParameter(Query query) {
+		return DefaultQueryUtils.hasNamedParameter(query);
+	}
+
+	/**
+	 * Turns the given {@link Sort} into {@link javax.persistence.criteria.Order}s.
+	 *
+	 * @param sort the {@link Sort} instance to be transformed into JPA {@link javax.persistence.criteria.Order}s.
+	 * @param from must not be {@literal null}.
+	 * @param cb must not be {@literal null}.
+	 * @return a {@link List} of {@link javax.persistence.criteria.Order}s.
+	 */
+	public static List<javax.persistence.criteria.Order> toOrders(Sort sort, From<?, ?> from, CriteriaBuilder cb) {
+		return DefaultQueryUtils.toOrders(sort, from, cb);
+	}
+
+	/**
+	 * Returns whether the given JPQL query contains a constructor expression.
+	 *
+	 * @param query must not be {@literal null} or empty.
+	 * @return whether the given JPQL query contains a constructor expression.
+	 */
+	public static boolean hasConstructorExpression(String query) {
+		return DefaultQueryUtils.hasConstructorExpression(query);
+	}
+
+	/**
+	 * Returns the projection part of the query, i.e. everything between {@code select} and {@code from}.
+	 *
+	 * @param query must not be {@literal null} or empty.
+	 * @return the projection part of the query.
+	 * @deprecated in favor of {@link QueryUtils#getProjection(DeclaredQuery)}
+	 */
+	@Deprecated
+	public static String getProjection(String query) {
+		return DefaultQueryUtils.getProjection(query);
+	}
+
+	/**
+	 * Returns the projection part of the query, i.e. everything between {@code select} and {@code from}.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @return the projection part of the query.
+	 */
+	public static String getProjection(DeclaredQuery query) {
+		if (qualifiesForJSqlParserUsage(query)) {
+			return JSqlParserQueryUtils.getProjection(query.getQueryString());
+		} else {
+			return DefaultQueryUtils.getProjection(query.getQueryString());
+		}
+	}
+
+	/**
+	 * Checks if a given query can be process with the JSqlParser under the condition that the parser is in the classpath.
+	 * 
+	 * @param query the query we want to check
+	 * @return <code>true</code> if JSqlParser is in the classpath and the query is classified as a native query otherwise
+	 *         <code>false</code>
+	 */
+	private static boolean qualifiesForJSqlParserUsage(DeclaredQuery query) {
+		return JSQLPARSER_IN_CLASSPATH && query.isNativeQuery();
+	}
+
+	/**
+	 * Checks whether JSqlParser is in classpath or not.
+	 *
+	 * @return <code>true</code> when in classpath otherwise <code>false</code>
+	 */
+	private static boolean isJSqlParserInClassPath() {
+		try {
+			Class.forName("net.sf.jsqlparser.parser.JSqlParser", false, QueryUtils.class.getClassLoader());
+			LOG.info("JSqlParser is in classpath. If applicable JSqlParser will be used.");
+			return true;
+		} catch (ClassNotFoundException e) {
+			return false;
+		}
+	}
+
+}