Introduce QueryEnhancerSelector to configure which QueryEnhancerFactory to use.

Introduce QueryEnhancerSelector to EnableJpaRepositories.

Also, split DeclaredQuery into two interfaces to resolve the inner cycle of query introspection while just a value object is being created.

Introduce JpaQueryConfiguration to capture a multitude of configuration elements.

Remove `spring.data.jpa.query.native.parser` option introduced earlier with #2989

Closes #3622
Original pull request: #3527

Author: mp911de

spring-data-jpa/src/jmh/java/org/springframework/data/jpa/repository/query/HqlParserBenchmarks.java

@@ -55,8 +55,8 @@ OR TREAT(p AS SmallProject).name LIKE 'Persist%'
 					    OR p.description LIKE "cost overrun"
 					""";
 
-			query = DeclaredQuery.of(s, false);
-			enhancer = QueryEnhancerFactory.forQuery(query);
+			query = DeclaredQuery.ofJpql(s);
+			enhancer = QueryEnhancerFactory.forQuery(query).create(query);
 		}
 	}
 

spring-data-jpa/src/jmh/java/org/springframework/data/jpa/repository/query/JSqlParserQueryEnhancerBenchmarks.java

@@ -56,7 +56,7 @@ public void doSetup() throws IOException {
 					select SOME_COLUMN from SOME_OTHER_TABLE where REPORTING_DATE = :REPORTING_DATE
 					union select SOME_COLUMN from SOME_OTHER_OTHER_TABLE""";
 
-			enhancer = new JSqlParserQueryEnhancer(DeclaredQuery.of(s, true));
+			enhancer = new JSqlParserQueryEnhancer(DeclaredQuery.ofNative(s));
 		}
 	}
 

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

@@ -28,6 +28,7 @@
 import org.springframework.context.annotation.ComponentScan.Filter;
 import org.springframework.context.annotation.Import;
 import org.springframework.context.annotation.Lazy;
+import org.springframework.data.jpa.repository.query.QueryEnhancerSelector;
 import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
 import org.springframework.data.repository.config.BootstrapMode;
 import org.springframework.data.repository.config.DefaultRepositoryBaseClass;
@@ -83,46 +84,39 @@
 	 * Returns the postfix to be used when looking up custom repository implementations. Defaults to {@literal Impl}. So
 	 * for a repository named {@code PersonRepository} the corresponding implementation class will be looked up scanning
 	 * for {@code PersonRepositoryImpl}.
-	 *
-	 * @return
 	 */
 	String repositoryImplementationPostfix() default "Impl";
 
 	/**
 	 * Configures the location of where to find the Spring Data named queries properties file. Will default to
 	 * {@code META-INF/jpa-named-queries.properties}.
-	 *
-	 * @return
 	 */
 	String namedQueriesLocation() default "";
 
 	/**
 	 * Returns the key of the {@link QueryLookupStrategy} to be used for lookup queries for query methods. Defaults to
 	 * {@link Key#CREATE_IF_NOT_FOUND}.
-	 *
-	 * @return
 	 */
 	Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;
 
 	/**
 	 * Returns the {@link FactoryBean} class to be used for each repository instance. Defaults to
 	 * {@link JpaRepositoryFactoryBean}.
-	 *
-	 * @return
 	 */
 	Class<?> repositoryFactoryBeanClass() default JpaRepositoryFactoryBean.class;
 
 	/**
 	 * Configure the repository base class to be used to create repository proxies for this particular configuration.
 	 *
-	 * @return
 	 * @since 1.9
 	 */
 	Class<?> repositoryBaseClass() default DefaultRepositoryBaseClass.class;
 
 	/**
 	 * Configure a specific {@link BeanNameGenerator} to be used when creating the repository beans.
-	 * @return the {@link BeanNameGenerator} to be used or the base {@link BeanNameGenerator} interface to indicate context default.
+	 *
+	 * @return the {@link BeanNameGenerator} to be used or the base {@link BeanNameGenerator} interface to indicate
+	 *         context default.
 	 * @since 3.4
 	 */
 	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
@@ -132,22 +126,18 @@
 	/**
 	 * Configures the name of the {@link EntityManagerFactory} bean definition to be used to create repositories
 	 * discovered through this annotation. Defaults to {@code entityManagerFactory}.
-	 *
-	 * @return
 	 */
 	String entityManagerFactoryRef() default "entityManagerFactory";
 
 	/**
 	 * Configures the name of the {@link PlatformTransactionManager} bean definition to be used to create repositories
 	 * discovered through this annotation. Defaults to {@code transactionManager}.
-	 *
-	 * @return
 	 */
 	String transactionManagerRef() default "transactionManager";
 
 	/**
 	 * Configures whether nested repository-interfaces (e.g. defined as inner classes) should be discovered by the
-	 * repositories infrastructure.
+	 * repository infrastructure.
 	 */
 	boolean considerNestedRepositories() default false;
 
@@ -169,7 +159,6 @@
 	 * completed its bootstrap. {@link BootstrapMode#DEFERRED} is fundamentally the same as {@link BootstrapMode#LAZY},
 	 * but triggers repository initialization when the application context finishes its bootstrap.
 	 *
-	 * @return
 	 * @since 2.1
 	 */
 	BootstrapMode bootstrapMode() default BootstrapMode.DEFAULT;
@@ -181,4 +170,12 @@
 	 * @return a single character used for escaping.
 	 */
 	char escapeCharacter() default '\\';
+
+	/**
+	 * Configures the {@link QueryEnhancerSelector} to select a query enhancer for query introspection and transformation.
+	 *
+	 * @return a {@link QueryEnhancerSelector} class providing a no-args constructor.
+	 * @since 4.0
+	 */
+	Class<? extends QueryEnhancerSelector> queryEnhancerSelector() default QueryEnhancerSelector.DefaultQueryEnhancerSelector.class;
 }

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

@@ -122,6 +122,11 @@ public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSo
 		}
 		builder.addPropertyValue(ESCAPE_CHARACTER_PROPERTY, getEscapeCharacter(source).orElse('\\'));
 		builder.addPropertyReference("mappingContext", JPA_MAPPING_CONTEXT_BEAN_NAME);
+
+		if (source instanceof AnnotationRepositoryConfigurationSource) {
+			builder.addPropertyValue("queryEnhancerSelector",
+					source.getAttribute("queryEnhancerSelector", Class.class).orElse(null));
+		}
 	}
 
 	@Override

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

@@ -56,7 +56,7 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 
 	private final StringQuery query;
 	private final Map<Class<?>, Boolean> knownProjections = new ConcurrentHashMap<>();
-	private final Lazy<DeclaredQuery> countQuery;
+	private final Lazy<IntrospectedQuery> countQuery;
 	private final ValueExpressionDelegate valueExpressionDelegate;
 	private final QueryRewriter queryRewriter;
 	private final QuerySortRewriter querySortRewriter;
@@ -71,37 +71,32 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 	 * @param em must not be {@literal null}.
 	 * @param queryString must not be {@literal null}.
 	 * @param countQueryString must not be {@literal null}.
-	 * @param queryRewriter must not be {@literal null}.
-	 * @param valueExpressionDelegate must not be {@literal null}.
+	 * @param queryConfiguration must not be {@literal null}.
 	 */
 	public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, String queryString,
-			@Nullable String countQueryString, QueryRewriter queryRewriter, ValueExpressionDelegate valueExpressionDelegate) {
+			@Nullable String countQueryString, JpaQueryConfiguration queryConfiguration) {
 
 		super(method, em);
 
 		Assert.hasText(queryString, "Query string must not be null or empty");
-		Assert.notNull(valueExpressionDelegate, "ValueExpressionDelegate must not be null");
-		Assert.notNull(queryRewriter, "QueryRewriter must not be null");
+		Assert.notNull(queryConfiguration, "JpaQueryConfiguration must not be null");
 
-		this.valueExpressionDelegate = valueExpressionDelegate;
+		this.valueExpressionDelegate = queryConfiguration.getValueExpressionDelegate();
 		this.valueExpressionContextProvider = valueExpressionDelegate.createValueContextProvider(method.getParameters());
-		this.query = new ExpressionBasedStringQuery(queryString, method.getEntityInformation(), valueExpressionDelegate,
-				method.isNativeQuery());
+		this.query = ExpressionBasedStringQuery.create(queryString, method, queryConfiguration);
 
 		this.countQuery = Lazy.of(() -> {
 
 			if (StringUtils.hasText(countQueryString)) {
-
-				return new ExpressionBasedStringQuery(countQueryString, method.getEntityInformation(), valueExpressionDelegate,
-						method.isNativeQuery());
+				return ExpressionBasedStringQuery.create(countQueryString, method, queryConfiguration);
 			}
 
-			return query.deriveCountQuery(method.getCountQueryProjection());
+			return this.query.deriveCountQuery(method.getCountQueryProjection());
 		});
 
 		this.countParameterBinder = Lazy.of(() -> this.createBinder(this.countQuery.get()));
 
-		this.queryRewriter = queryRewriter;
+		this.queryRewriter = queryConfiguration.getQueryRewriter(method);
 
 		JpaParameters parameters = method.getParameters();
 
@@ -115,7 +110,7 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 			}
 		}
 
-		Assert.isTrue(method.isNativeQuery() || !query.usesJdbcStyleParameters(),
+		Assert.isTrue(method.isNativeQuery() || !this.query.usesJdbcStyleParameters(),
 				"JDBC style parameters (?) are not supported for JPA queries");
 	}
 
@@ -217,7 +212,7 @@ protected ParameterBinder createBinder() {
 		return createBinder(query);
 	}
 
-	protected ParameterBinder createBinder(DeclaredQuery query) {
+	protected ParameterBinder createBinder(IntrospectedQuery query) {
 		return ParameterBinderFactory.createQueryAwareBinder(getQueryMethod().getParameters(), query,
 				valueExpressionDelegate, valueExpressionContextProvider);
 	}
@@ -243,14 +238,14 @@ protected Query doCreateCountQuery(JpaParametersParameterAccessor accessor) {
 	/**
 	 * @return the query
 	 */
-	public DeclaredQuery getQuery() {
+	public EntityQuery getQuery() {
 		return query;
 	}
 
 	/**
 	 * @return the countQuery
 	 */
-	public DeclaredQuery getCountQuery() {
+	public IntrospectedQuery getCountQuery() {
 		return countQuery.get();
 	}
 
@@ -292,16 +287,15 @@ protected String potentiallyRewriteQuery(String originalQuery, Sort sort, @Nulla
 	}
 
 	String applySorting(CachableQuery cachableQuery) {
-
-		return QueryEnhancerFactory.forQuery(cachableQuery.getDeclaredQuery())
+		return cachableQuery.getDeclaredQuery().getQueryEnhancer()
 				.rewrite(new DefaultQueryRewriteInformation(cachableQuery.getSort(), cachableQuery.getReturnedType()));
 	}
 
 	/**
 	 * Query Sort Rewriter interface.
 	 */
 	interface QuerySortRewriter {
-		String getSorted(DeclaredQuery query, Sort sort, ReturnedType returnedType);
+		String getSorted(StringQuery query, Sort sort, ReturnedType returnedType);
 	}
 
 	/**
@@ -311,25 +305,24 @@ enum SimpleQuerySortRewriter implements QuerySortRewriter {
 
 		INSTANCE;
 
-		public String getSorted(DeclaredQuery query, Sort sort, ReturnedType returnedType) {
-
-			return QueryEnhancerFactory.forQuery(query).rewrite(new DefaultQueryRewriteInformation(sort, returnedType));
+		public String getSorted(StringQuery query, Sort sort, ReturnedType returnedType) {
+			return query.getQueryEnhancer().rewrite(new DefaultQueryRewriteInformation(sort, returnedType));
 		}
 	}
 
 	static class UnsortedCachingQuerySortRewriter implements QuerySortRewriter {
 
 		private volatile @Nullable String cachedQueryString;
 
-		public String getSorted(DeclaredQuery query, Sort sort, ReturnedType returnedType) {
+		public String getSorted(StringQuery query, Sort sort, ReturnedType returnedType) {
 
 			if (sort.isSorted()) {
 				throw new UnsupportedOperationException("NoOpQueryCache does not support sorting");
 			}
 
 			String cachedQueryString = this.cachedQueryString;
 			if (cachedQueryString == null) {
-				this.cachedQueryString = cachedQueryString = QueryEnhancerFactory.forQuery(query)
+				this.cachedQueryString = cachedQueryString = query.getQueryEnhancer()
 						.rewrite(new DefaultQueryRewriteInformation(sort, returnedType));
 			}
 
@@ -348,7 +341,7 @@ class CachingQuerySortRewriter implements QuerySortRewriter {
 		private volatile @Nullable String cachedQueryString;
 
 		@Override
-		public String getSorted(DeclaredQuery query, Sort sort, ReturnedType returnedType) {
+		public String getSorted(StringQuery query, Sort sort, ReturnedType returnedType) {
 
 			if (sort.isUnsorted()) {
 
@@ -373,21 +366,21 @@ public String getSorted(DeclaredQuery query, Sort sort, ReturnedType returnedTyp
 	 */
 	static class CachableQuery {
 
-		private final DeclaredQuery declaredQuery;
+		private final StringQuery query;
 		private final String queryString;
 		private final Sort sort;
 		private final ReturnedType returnedType;
 
-		CachableQuery(DeclaredQuery query, Sort sort, ReturnedType returnedType) {
+		CachableQuery(StringQuery query, Sort sort, ReturnedType returnedType) {
 
-			this.declaredQuery = query;
+			this.query = query;
 			this.queryString = query.getQueryString();
 			this.sort = sort;
 			this.returnedType = returnedType;
 		}
 
-		DeclaredQuery getDeclaredQuery() {
-			return declaredQuery;
+		StringQuery getDeclaredQuery() {
+			return query;
 		}
 
 		Sort getSort() {