Added fallback mechanism for QueryEnhancer.

In spring-projects#2564 we discovered that sometimes queries contain content that cannot be parsed by special implementation such as `JSqlParserQueryEnhancer`. Therefore, we implement a fallback mechanism that tries to use the first possible suitable implementation for a given query, that does not fail with an exception on creation. If the first one fails we fallback to the next one until we have reached the `DefaultQueryEnhancer`.

Closes spring-projects#2564

Author: DiegoKrupitza

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

@@ -15,8 +15,12 @@
  */
 package org.springframework.data.jpa.repository.query;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.springframework.data.util.Lazy;
 
 /**
  * Encapsulates different strategies for the creation of a {@link QueryEnhancer} from a {@link DeclaredQuery}.
@@ -33,19 +37,63 @@ public final class QueryEnhancerFactory {
 
 	private QueryEnhancerFactory() {}
 
+	/**
+	 * Creates a {@link List} containing all the possible {@link QueryEnhancer} implementations for native queries. The
+	 * order of the entries indicates that the first {@link QueryEnhancer} should be used. If this is not possible the
+	 * next until the last one is reached which will be always {@link DefaultQueryEnhancer}.
+	 *
+	 * @param query the query for which the list should be created for
+	 * @return list containing all the suitable implementations for the given query
+	 */
+	private static List<Lazy<QueryEnhancer>> nativeQueryEnhancers(DeclaredQuery query) {
+		ArrayList<Lazy<QueryEnhancer>> suitableImplementations = new ArrayList<>();
+
+		if (qualifiesForJSqlParserUsage(query)) {
+			suitableImplementations.add(Lazy.of(() -> new JSqlParserQueryEnhancer(query)));
+		}
+
+		// DefaultQueryEnhancer has to be the last since this is our fallback
+		suitableImplementations.add(Lazy.of(() -> new DefaultQueryEnhancer(query)));
+		return suitableImplementations;
+	}
+
+	/**
+	 * Creates a {@link List} containing all the possible {@link QueryEnhancer} implementations for non-native queries.
+	 * The order of the entries indicates that the first {@link QueryEnhancer} should be used. If this is not possible the
+	 * next until the last one is reached which will be always {@link DefaultQueryEnhancer}.
+	 *
+	 * @param query the query for which the list should be created for
+	 * @return list containing all the suitable implementations for the given query
+	 */
+	private static List<Lazy<QueryEnhancer>> nonNativeQueryEnhancers(DeclaredQuery query) {
+		ArrayList<Lazy<QueryEnhancer>> suitableImplementations = new ArrayList<>();
+
+		// DefaultQueryEnhancer has to be the last since this is our fallback
+		suitableImplementations.add(Lazy.of(() -> new DefaultQueryEnhancer(query)));
+		return suitableImplementations;
+	}
+
 	/**
 	 * Creates a new {@link QueryEnhancer} for the given {@link DeclaredQuery}.
 	 *
 	 * @param query must not be {@literal null}.
 	 * @return an implementation of {@link QueryEnhancer} that suits the query the most
 	 */
 	public static QueryEnhancer forQuery(DeclaredQuery query) {
+		List<Lazy<QueryEnhancer>> suitableQueryEnhancers = query.isNativeQuery() ? nativeQueryEnhancers(query)
+				: nonNativeQueryEnhancers(query);
 
-		if (qualifiesForJSqlParserUsage(query)) {
-			return new JSqlParserQueryEnhancer(query);
-		} else {
-			return new DefaultQueryEnhancer(query);
+		for (Lazy<QueryEnhancer> suitableQueryEnhancer : suitableQueryEnhancers) {
+			try {
+				return suitableQueryEnhancer.get();
+			} catch (Exception e) {
+				LOG.debug("Falling back to next QueryEnhancer implementation, due to exception.", e);
+			}
 		}
+
+		throw new IllegalStateException(
+				"No QueryEnhancer found for the query [%s]! This should not happen since the default implementation (DefaultQueryEnhancer) should have been called!"
+						.formatted(query.getQueryString()));
 	}
 
 	/**

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

@@ -2969,7 +2969,7 @@ void complexWithNativeStatement() {
 	}
 
 	@Test // GH-2607
-	void containsWithCollection(){
+	void containsWithCollection() {
 
 		firstUser.getAttributes().add("cool");
 		firstUser.getAttributes().add("hip");
@@ -2986,6 +2986,25 @@ void containsWithCollection(){
 		assertThat(result).containsOnly(firstUser, secondUser);
 	}
 
+	@Test
+	void nativeQueryWithSpELStatementTest() {
+
+		String exampleFirstName = "Peter";
+		User firstPeter = new User(exampleFirstName, "2", "[email protected]");
+		repository.save(firstPeter);
+
+		User secondPeter = new User(exampleFirstName, "2", "[email protected]");
+		repository.save(secondPeter);
+
+		User firstDiego = new User("Diego", "2", "[email protected]");
+		repository.save(secondPeter);
+
+		User exampleUser = new User(exampleFirstName, "IGNORE", "[email protected]");
+		List<User> foundData = repository.nativeQueryWithSpELStatement(exampleUser);
+
+		assertThat(foundData).hasSize(2);
+	}
+
 	private Page<User> executeSpecWithSort(Sort sort) {
 
 		flushTestUsers();

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

@@ -47,4 +47,15 @@ void createsJSqlImplementationForNativeQuery() {
 		assertThat(queryEnhancer) //
 				.isInstanceOf(JSqlParserQueryEnhancer.class);
 	}
+
+	@Test
+	void fallsBackToOtherQueryEnhancerWhenUsingHibernatePlaceHolder() {
+		StringQuery query = new StringQuery("SELECT c.* FROM {h-schema}countries c", true);
+
+		QueryEnhancer queryEnhancer = QueryEnhancerFactory.forQuery(query);
+
+		assertThat(queryEnhancer) //
+				.isNotInstanceOf(JSqlParserQueryEnhancer.class);
+	}
+
 }

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

@@ -418,14 +418,6 @@ void doesNotPrefixAliasedFunctionCallNameWithDots() {
 		assertThat(getEnhancer(query).applySorting(sort, "m")).endsWith("order by m.avg asc");
 	}
 
-	@Test // DATAJPA-965, DATAJPA-970
-	void doesNotPrefixAliasedFunctionCallNameWithDotsNativeQuery() {
-
-		// this is invalid since the '.' character is not allowed. Not in sql nor in JPQL.
-		assertThatThrownBy(() -> new StringQuery("SELECT AVG(m.price) AS m.avg FROM Magazine m", true)) //
-				.isInstanceOf(IllegalArgumentException.class);
-	}
-
 	@Test // DATAJPA-965, DATAJPA-970
 	void doesNotPrefixAliasedFunctionCallNameWhenQueryStringContainsMultipleWhiteSpaces() {
 

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

@@ -679,6 +679,9 @@ List<String> findAllAndSortByFunctionResultNamedParameter(@Param("namedParameter
 	// GH-2607
 	List<User> findByAttributesContains(String attribute);
 
+	@Query(value = "SELECT c.* FROM SD_User c WHERE c.firstname = :#{#example.firstname}", nativeQuery = true)
+	List<User> nativeQueryWithSpELStatement(User example);
+
 	interface RolesAndFirstname {
 
 		String getFirstname();