Introduce flag to skip JSqlParser for a given custom query.

See #2989

Author: gregturn

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

@@ -86,4 +86,12 @@
 	 * @since 3.0
 	 */
 	Class<? extends QueryRewriter> queryRewriter() default QueryRewriter.IdentityQueryRewriter.class;
+
+	/**
+	 * For native queries, indicate whether or not to skip the JSqlParser.
+	 *
+	 * @return
+	 * @since 3.2
+	 */
+	boolean skipJSql() default false;
 }

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

@@ -75,7 +75,7 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 
 		this.evaluationContextProvider = evaluationContextProvider;
 		this.query = new ExpressionBasedStringQuery(queryString, method.getEntityInformation(), parser,
-				method.isNativeQuery());
+				method.isNativeQuery(), method.skipJSql());
 
 		this.countQuery = Lazy.of(() -> {
 			DeclaredQuery countQuery = query.deriveCountQuery(countQueryString, method.getCountQueryProjection());

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

@@ -111,4 +111,8 @@ default boolean usesPaging() {
 	default boolean isNativeQuery() {
 		return false;
 	}
+
+	default boolean skipJSql() {
+		return false;
+	}
 }

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

@@ -59,9 +59,15 @@ class ExpressionBasedStringQuery extends StringQuery {
 	 * @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,
+			boolean nativeQuery, boolean skipJSql) {
+		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser), nativeQuery && !containsExpression(query),
+				skipJSql);
+	}
+
 	public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, SpelExpressionParser parser,
 			boolean nativeQuery) {
-		super(renderQueryIfExpressionOrReturnQuery(query, metadata, parser), nativeQuery && !containsExpression(query));
+		this(query, metadata, parser, nativeQuery, false);
 	}
 
 	/**
@@ -75,7 +81,7 @@ public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, S
 	 */
 	static ExpressionBasedStringQuery from(DeclaredQuery query, JpaEntityMetadata<?> metadata,
 			SpelExpressionParser parser, boolean nativeQuery) {
-		return new ExpressionBasedStringQuery(query.getQueryString(), metadata, parser, nativeQuery);
+		return new ExpressionBasedStringQuery(query.getQueryString(), metadata, parser, nativeQuery, query.skipJSql());
 	}
 
 	/**

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

@@ -94,6 +94,7 @@ public class JpaQueryMethod extends QueryMethod {
 	private final Lazy<JpaEntityGraph> jpaEntityGraph;
 	private final Lazy<Modifying> modifying;
 	private final Lazy<Boolean> isNativeQuery;
+	private final Lazy<Boolean> skipJSql;
 	private final Lazy<Boolean> isCollectionQuery;
 	private final Lazy<Boolean> isProcedureQuery;
 	private final Lazy<JpaEntityMetadata<?>> entityMetadata;
@@ -136,6 +137,7 @@ protected JpaQueryMethod(Method method, RepositoryMetadata metadata, ProjectionF
 			return new JpaEntityGraph(entityGraph, getNamedQueryName());
 		});
 		this.isNativeQuery = Lazy.of(() -> getAnnotationValue("nativeQuery", Boolean.class));
+		this.skipJSql = Lazy.of(() -> getAnnotationValue("skipJSql", Boolean.class));
 		this.isCollectionQuery = Lazy.of(() -> super.isCollectionQuery() && !NATIVE_ARRAY_TYPES.contains(this.returnType));
 		this.isProcedureQuery = Lazy.of(() -> AnnotationUtils.findAnnotation(method, Procedure.class) != null);
 		this.entityMetadata = Lazy.of(() -> new DefaultJpaEntityMetadata<>(getDomainClass()));
@@ -387,6 +389,10 @@ boolean isNativeQuery() {
 		return this.isNativeQuery.get();
 	}
 
+	boolean skipJSql() {
+		return this.skipJSql.get();
+	}
+
 	@Override
 	public String getNamedQueryName() {
 

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

@@ -60,7 +60,7 @@ public static QueryEnhancer forQuery(DeclaredQuery query) {
 
 		if (query.isNativeQuery()) {
 
-			if (jSqlParserPresent) {
+			if (jSqlParserPresent && !query.skipJSql()) {
 				/*
 				 * If JSqlParser fails, throw some alert signaling that people should write a custom Impl.
 				 */

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

@@ -65,6 +65,7 @@ class StringQuery implements DeclaredQuery {
 	private final boolean containsPageableInSpel;
 	private final boolean usesJdbcStyleParameters;
 	private final boolean isNative;
+	private final boolean skipJSql;
 	private final QueryEnhancer queryEnhancer;
 
 	/**
@@ -73,11 +74,12 @@ class StringQuery implements DeclaredQuery {
 	 * @param query must not be {@literal null} or empty.
 	 */
 	@SuppressWarnings("deprecation")
-	StringQuery(String query, boolean isNative) {
+	StringQuery(String query, boolean isNative, boolean skipJSql) {
 
 		Assert.hasText(query, "Query must not be null or empty");
 
 		this.isNative = isNative;
+		this.skipJSql = skipJSql;
 		this.bindings = new ArrayList<>();
 		this.containsPageableInSpel = query.contains("#pageable");
 
@@ -92,6 +94,10 @@ class StringQuery implements DeclaredQuery {
 		this.hasConstructorExpression = this.queryEnhancer.hasConstructorExpression();
 	}
 
+	StringQuery(String query, boolean isNative) {
+		this(query, isNative, false);
+	}
+
 	/**
 	 * Returns whether we have found some like bindings.
 	 */
@@ -157,6 +163,11 @@ public boolean isNativeQuery() {
 		return isNative;
 	}
 
+	@Override
+	public boolean skipJSql() {
+		return skipJSql;
+	}
+
 	/**
 	 * A parser that extracts the parameter bindings from a given query string.
 	 *

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

@@ -2914,6 +2914,19 @@ void supportsProjectionsWithNativeQueries() {
 		assertThat(result.getLastname()).isEqualTo(user.getLastname());
 	}
 
+	@Test // GH-2989
+	void supportsProjectionsWithNativeQueriesSkippingJSql() {
+
+		flushTestUsers();
+
+		User user = repository.findAll().get(0);
+
+		NameOnly result = repository.findByNativeQueryWithNoJSql(user.getId());
+
+		assertThat(result.getFirstname()).isEqualTo(user.getFirstname());
+		assertThat(result.getLastname()).isEqualTo(user.getLastname());
+	}
+
 	@Test // DATAJPA-1248
 	void supportsProjectionsWithNativeQueriesAndCamelCaseProperty() {
 

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

@@ -625,6 +625,13 @@ void modifyingQueriesAreDetectedCorrectly() {
 		assertThat(QueryEnhancerFactory.forQuery(modiQuery).createCountQueryFor()).isEqualToIgnoringCase(modifyingQuery);
 	}
 
+	@Test // GH-2989
+	void skippingJSqlShouldRevertToDefaultQueryEnhancer() {
+
+		assertThat(getEnhancer(new StringQuery(QUERY, true, false))).isInstanceOf(JSqlParserQueryEnhancer.class);
+		assertThat(getEnhancer(new StringQuery(QUERY, true, true))).isInstanceOf(DefaultQueryEnhancer.class);
+	}
+
 	@ParameterizedTest // GH-2593
 	@MethodSource("insertStatementIsProcessedSameAsDefaultSource")
 	void insertStatementIsProcessedSameAsDefault(String insertQuery) {

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/sample/UserRepository.java

@@ -585,6 +585,11 @@ List<User> findUsersByFirstnameForSpELExpressionWithParameterIndexOnlyWithEntity
 	@Query(value = "SELECT firstname, lastname FROM SD_User WHERE id = ?1", nativeQuery = true)
 	NameOnly findByNativeQuery(Integer id);
 
+	// GH-2989
+	@Query(value = "SELECT firstname, lastname FROM SD_User WHERE id = ?1", nativeQuery = true, skipJSql = true)
+	NameOnly findByNativeQueryWithNoJSql(Integer id);
+
+
 	// DATAJPA-1248
 	@Query(value = "SELECT emailaddress FROM SD_User WHERE id = ?1", nativeQuery = true)
 	EmailOnly findEmailOnlyByNativeQuery(Integer id);