Generating Sql and using it to read aggregates works for:

- Simple Entities
- single references
- single collections (List, Set, Map)
- conversions get applied on reading
- integrated for the supported databases and findById and findAll.
- integration tests work for Postgres, DB2, MS SqlServer

Next Todos:
- Fix integration tests with Oracle which fail because the magic join doesn't return all expected rows.
- Support for the missing find* methods in SingleSelectDataAccessStrategy

See #1446

Author: schauder

pom.xml

@@ -46,6 +46,7 @@
 		<!-- test utilities-->
 		<awaitility.version>4.2.0</awaitility.version>
 		<archunit.version>1.0.1</archunit.version>
+		<jsqlparser.version>4.5</jsqlparser.version>
 	</properties>
 
 	<inceptionYear>2017</inceptionYear>

spring-data-jdbc/pom.xml

@@ -269,6 +269,12 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>com.github.jsqlparser</groupId>
+			<artifactId>jsqlparser</artifactId>
+			<version>${jsqlparser.version}</version>
+		</dependency>
+
 	</dependencies>
 
 

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/AggregateReader.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2023 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.jdbc.core.convert;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.data.jdbc.core.convert.sqlgeneration.AggregateToStructure;
+import org.springframework.data.jdbc.core.convert.sqlgeneration.AliasFactory;
+import org.springframework.data.jdbc.core.convert.sqlgeneration.AnalyticSqlGenerator;
+import org.springframework.data.jdbc.core.convert.sqlgeneration.StructureToSelect;
+import org.springframework.data.mapping.PersistentPropertyPath;
+import org.springframework.data.relational.core.dialect.Dialect;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
+import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
+import org.springframework.util.Assert;
+
+public class AggregateReader<T> {
+
+	private final RelationalMappingContext mappingContext;
+	private final RelationalPersistentEntity<T> aggregate;
+	private final AliasFactory aliasFactory = new AliasFactory();
+	private final AnalyticSqlGenerator sqlGenerator;
+	private final JdbcConverter converter;
+	private final NamedParameterJdbcOperations jdbcTemplate;
+
+	AggregateReader(RelationalMappingContext mappingContext, Dialect dialect, JdbcConverter converter,
+			NamedParameterJdbcOperations jdbcTemplate, RelationalPersistentEntity<T> aggregate) {
+
+		this.mappingContext = mappingContext;
+
+		this.aggregate = aggregate;
+		this.converter = converter;
+		this.jdbcTemplate = jdbcTemplate;
+
+		this.sqlGenerator = new AnalyticSqlGenerator(dialect, new AggregateToStructure(mappingContext),
+				new StructureToSelect(aliasFactory));
+	}
+
+	public List<T> findAll() {
+
+		String sql = sqlGenerator.findAll(aggregate);
+
+		PathToColumnMapping pathToColumn = createPathToColumnMapping(aliasFactory);
+		AggregateResultSetExtractor<T> extractor = new AggregateResultSetExtractor<>(mappingContext, aggregate, converter,
+				pathToColumn);
+
+		Iterable<T> result = jdbcTemplate.query(sql, extractor);
+
+		return (List<T>) result;
+	}
+
+	public T findById(Object id) {
+
+		PathToColumnMapping pathToColumn = createPathToColumnMapping(aliasFactory);
+		AggregateResultSetExtractor<T> extractor = new AggregateResultSetExtractor<>(mappingContext, aggregate, converter,
+				pathToColumn);
+
+		String sql = sqlGenerator.findById(aggregate);
+		// TODO: apply writing converter
+		id = converter.writeValue(id, aggregate.getIdProperty().getTypeInformation());
+
+		Iterator<T> result = jdbcTemplate.query(sql, Map.of("id", id), extractor).iterator();
+
+		return result.hasNext() ? result.next() : null;
+	}
+
+	private PathToColumnMapping createPathToColumnMapping(AliasFactory aliasFactory) {
+		return new PathToColumnMapping() {
+			@Override
+			public String column(PersistentPropertyPath<RelationalPersistentProperty> propertyPath) {
+
+				RelationalPersistentProperty leafProperty = propertyPath.getRequiredLeafProperty();
+				Object aliasLookUpKey;
+				if (leafProperty.isEntity()) {
+					aliasLookUpKey = mappingContext.getRequiredPersistentEntity(leafProperty.getActualType());
+				} else {
+					aliasLookUpKey = propertyPath;
+				}
+				String alias = aliasFactory.getAlias(aliasLookUpKey);
+				Assert.notNull(alias, () -> "alias for >" + aliasLookUpKey + "<must not be null");
+				return alias;
+			}
+
+			@Override
+			public String keyColumn(PersistentPropertyPath<RelationalPersistentProperty> propertyPath) {
+				return aliasFactory.getKeyAlias(propertyPath);
+			}
+		};
+	}
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/AggregateReaderFactory.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2023 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.jdbc.core.convert;
+
+import java.util.HashMap;
+
+import org.springframework.data.relational.core.dialect.Dialect;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
+
+public class AggregateReaderFactory {
+
+	private final RelationalMappingContext mappingContext;
+	private final Dialect dialect;
+	private final JdbcConverter converter;
+	private final NamedParameterJdbcOperations jdbcTemplate;
+
+	private final HashMap<RelationalPersistentEntity<?>, AggregateReader> cash = new HashMap<>();
+
+	public AggregateReaderFactory(RelationalMappingContext mappingContext, Dialect dialect, JdbcConverter converter,
+			NamedParameterJdbcOperations jdbcTemplate) {
+		this.mappingContext = mappingContext;
+		this.dialect = dialect;
+		this.converter = converter;
+		this.jdbcTemplate = jdbcTemplate;
+	}
+
+	<T> AggregateReader<T> createAggregateReaderFor(RelationalPersistentEntity<T> entity) {
+		return cash.computeIfAbsent(entity, e -> new AggregateReader<>(mappingContext, dialect, converter, jdbcTemplate, e));
+	}
+}