introduce and use new toColumnList method

Author: schauder

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

@@ -186,7 +186,7 @@ private Condition getSubselectCondition(AggregatePath path,
 			innerCondition = getSubselectCondition(parentPath, conditionFunction, selectFilterColumns);
 		}
 
-		List<Expression> idColumns = parentPathTableInfo.idColumnInfos().toList(ci -> subSelectTable.column(ci.name()));
+		List<Column> idColumns = parentPathTableInfo.idColumnInfos().toColumnList(subSelectTable);
 
 		Select select = Select.builder() //
 				.select(idColumns) //

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcDeleteQueryCreator.java

@@ -15,9 +15,6 @@
  */
 package org.springframework.data.jdbc.repository.query;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jdbc.core.convert.JdbcConverter;
 import org.springframework.data.jdbc.core.convert.QueryMapper;
@@ -29,9 +26,17 @@
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
 import org.springframework.data.relational.core.query.Criteria;
-import org.springframework.data.relational.core.sql.*;
+import org.springframework.data.relational.core.sql.Column;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Conditions;
+import org.springframework.data.relational.core.sql.Delete;
 import org.springframework.data.relational.core.sql.DeleteBuilder.DeleteWhere;
+import org.springframework.data.relational.core.sql.Expression;
+import org.springframework.data.relational.core.sql.Expressions;
+import org.springframework.data.relational.core.sql.Select;
 import org.springframework.data.relational.core.sql.SelectBuilder.SelectWhere;
+import org.springframework.data.relational.core.sql.StatementBuilder;
+import org.springframework.data.relational.core.sql.Table;
 import org.springframework.data.relational.core.sql.render.SqlRenderer;
 import org.springframework.data.relational.repository.query.RelationalEntityMetadata;
 import org.springframework.data.relational.repository.query.RelationalParameterAccessor;
@@ -41,6 +46,9 @@
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Implementation of {@link RelationalQueryCreator} that creates {@link List} of deletion {@link ParametrizedQuery} from
  * a {@link PartTree}.
@@ -93,7 +101,7 @@ protected List<ParametrizedQuery> complete(@Nullable Criteria criteria, Sort sor
 				: queryMapper.getMappedObject(parameterSource, criteria, table, entity);
 
 		List<Column> idColumns = context.getAggregatePath(entity).getTableInfo().idColumnInfos()
-				.toList(ci -> table.column(ci.name()));
+				.toColumnList(table);
 
 		// create select criteria query for subselect
 		SelectWhere selectBuilder = StatementBuilder.select(idColumns).from(table);
@@ -139,13 +147,13 @@ private void deleteRelations(List<Delete> deleteChain, RelationalPersistentEntit
 				Table table = sqlContext.getUnaliasedTable(aggregatePath);
 
 				List<Column> reverseColumns = aggregatePath.getTableInfo().backReferenceColumnInfos()
-						.toList(ci -> table.column(ci.name()));
+						.toColumnList(table);
 				Expression expression = Expressions.of(reverseColumns);
 
 				Condition inCondition = Conditions.in(expression, parentSelect);
 
 				List<Column> parentIdColumns = aggregatePath.getIdDefiningParentPath().getTableInfo().idColumnInfos()
-						.toList(ci -> table.column(ci.name()));
+						.toColumnList(table);
 
 				Select select = StatementBuilder.select( //
 						parentIdColumns //

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcQueryCreator.java

@@ -325,9 +325,9 @@ Join getJoin(SqlContext sqlContext, AggregatePath path) {
 		AggregatePath idDefiningParentPath = path.getIdDefiningParentPath();
 		Table parentTable = sqlContext.getTable(idDefiningParentPath);
 
-		List<Column> reverseColumns = path.getTableInfo().backReferenceColumnInfos().toList(ci -> currentTable.column(ci.name()));
+		List<Column> reverseColumns = path.getTableInfo().backReferenceColumnInfos().toColumnList(currentTable);
 		List<Column> idColumns = idDefiningParentPath.getTableInfo().idColumnInfos()
-				.toList(ci -> parentTable.column(ci.name()));
+				.toColumnList(parentTable);
 		return new Join( //
 				currentTable, //
 				reverseColumns, //

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/AggregatePath.java

@@ -31,15 +31,17 @@
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.relational.core.sql.Column;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
+import org.springframework.data.relational.core.sql.Table;
 import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
  * Represents a path within an aggregate starting from the aggregate root. The path can be iterated from the leaf to its
  * root.
- *
+ * <p>
  * It implements {@link Comparable} so that collections of {@code AggregatePath} instances can be sorted in a consistent way.
  *
  * @author Jens Schauder
@@ -547,6 +549,10 @@ public <T> List<T> toList(Function<ColumnInfo, T> mapper) {
 			return columnInfos.values().stream().map(mapper).toList();
 		}
 
+		public List<Column> toColumnList(Table table) {
+			return toList(columnInfo -> table.column(columnInfo.name));
+		}
+
 		/**
 		 * Performs a {@link Stream#reduce(Object, BiFunction, BinaryOperator)} on {@link ColumnInfo} and
 		 * {@link AggregatePath} to reduce the results into a single {@code T} return value.

spring-data-relational/src/main/java/org/springframework/data/relational/core/sql/AnalyticFunction.java

@@ -64,7 +64,7 @@ public AnalyticFunction partitionBy(Expression... partitionBy) {
 	 *         previously present.
 	 * @since 3.5
 	 */
-	public AnalyticFunction partitionBy(Collection<Expression> partitionBy) {
+	public AnalyticFunction partitionBy(Collection<? extends Expression> partitionBy) {
 		return partitionBy(partitionBy.toArray(new Expression[0]));
 	}
 
@@ -87,7 +87,7 @@ public AnalyticFunction orderBy(OrderByField... orderBy) {
 	 *         previously present.
 	 * @since 3.5
 	 */
-	public AnalyticFunction orderBy(Collection<Expression> orderBy) {
+	public AnalyticFunction orderBy(Collection<? extends Expression> orderBy) {
 		return orderBy(orderBy.toArray(new Expression[0]));
 	}
 

spring-data-relational/src/main/java/org/springframework/data/relational/core/sqlgeneration/SingleQuerySqlGenerator.java

@@ -113,7 +113,7 @@ private static List<Expression> getSelectList(QueryMeta queryMeta, List<QueryMet
 	}
 
 	private InlineQuery createMainSelect(List<Expression> columns, AggregatePath rootPath, InlineQuery rootQuery,
-			List<QueryMeta> inlineQueries) {
+										 List<QueryMeta> inlineQueries) {
 
 		SelectBuilder.SelectJoin select = StatementBuilder.select(columns).from(rootQuery);
 		select = applyJoins(rootPath, inlineQueries, select);
@@ -127,7 +127,7 @@ private InlineQuery createMainSelect(List<Expression> columns, AggregatePath roo
 	 *
 	 * @param paths the paths to consider.
 	 * @return a {@link Map} that contains all the inline queries indexed by the path to the entity that gets loaded by
-	 *         the subquery.
+	 * the subquery.
 	 */
 	private List<QueryMeta> createInlineQueries(PersistentPropertyPaths<?, RelationalPersistentProperty> paths) {
 
@@ -149,7 +149,7 @@ private List<QueryMeta> createInlineQueries(PersistentPropertyPaths<?, Relationa
 	 * that are not unique across tables and also the generated SQL doesn't contain quotes and funny column names, making
 	 * them easier to understand and also potentially shorter.
 	 *
-	 * @param basePath the path for which to create the inline query.
+	 * @param basePath  the path for which to create the inline query.
 	 * @param condition a condition that is to be applied to the query. May be {@literal null}.
 	 * @return an inline query for the given path.
 	 */
@@ -169,11 +169,8 @@ private QueryMeta createInlineQuery(AggregatePath basePath, @Nullable Condition
 		String rowCountAlias = aliases.getRowCountAlias(basePath);
 		Expression count = basePath.isRoot() ? new AliasedExpression(SQL.literalOf(1), rowCountAlias) //
 				: AnalyticFunction.create("count", Expressions.just("*")) //
-						.partitionBy( //
-								basePath.getTableInfo().backReferenceColumnInfos().toList( //
-										ci -> table.column(ci.name()) //
-								) //
-						).as(rowCountAlias);
+				.partitionBy(basePath.getTableInfo().backReferenceColumnInfos().toColumnList(table) //
+				).as(rowCountAlias);
 		columns.add(count);
 
 		String backReferenceAlias = null;
@@ -241,25 +238,25 @@ private String getIdentifierProperty(List<AggregatePath> paths) {
 	}
 
 	private static AnalyticFunction createRowNumberExpression(AggregatePath basePath, Table table,
-			String rowNumberAlias) {
+															  String rowNumberAlias) {
 		AggregatePath.ColumnInfos reverseColumnInfos = basePath.getTableInfo().backReferenceColumnInfos();
 		return AnalyticFunction.create("row_number") //
-				.partitionBy(reverseColumnInfos.toList(ci -> table.column(ci.name()))) //
-				.orderBy(reverseColumnInfos.toList(ci -> table.column(ci.name()))) //
+				.partitionBy(reverseColumnInfos.toColumnList(table)) //
+				.orderBy(reverseColumnInfos.toColumnList(table)) //
 				.as(rowNumberAlias);
 	}
 
 	/**
 	 * Adds joins to a select.
 	 *
-	 * @param rootPath the AggregatePath that gets selected by the select in question.
+	 * @param rootPath      the AggregatePath that gets selected by the select in question.
 	 * @param inlineQueries all the inline queries to added as joins as returned by
-	 *          {@link #createInlineQueries(PersistentPropertyPaths)}
-	 * @param select the select to modify.
+	 *                      {@link #createInlineQueries(PersistentPropertyPaths)}
+	 * @param select        the select to modify.
 	 * @return the original select but with added joins
 	 */
 	private SelectBuilder.SelectJoin applyJoins(AggregatePath rootPath, List<QueryMeta> inlineQueries,
-			SelectBuilder.SelectJoin select) {
+												SelectBuilder.SelectJoin select) {
 
 		RelationalPersistentProperty rootIdProperty = rootPath.getRequiredIdProperty();
 		AggregatePath rootIdPath = rootPath.append(rootIdProperty);
@@ -286,12 +283,12 @@ private SelectBuilder.SelectJoin applyJoins(AggregatePath rootPath, List<QueryMe
 	 * </ol>
 	 *
 	 * @param inlineQueries all in the inline queries for all the children, as returned by
-	 *          {@link #createInlineQueries(PersistentPropertyPaths)}
-	 * @param select the select to which the where clause gets added.
+	 *                      {@link #createInlineQueries(PersistentPropertyPaths)}
+	 * @param select        the select to which the where clause gets added.
 	 * @return the modified select.
 	 */
 	private SelectBuilder.SelectOrdered applyWhereCondition(List<QueryMeta> inlineQueries,
-			SelectBuilder.SelectJoin select) {
+															SelectBuilder.SelectJoin select) {
 
 		SelectBuilder.SelectWhere selectWhere = (SelectBuilder.SelectWhere) select;
 
@@ -389,8 +386,8 @@ public AliasFactory getAliasFactory() {
 	 * </table>
 	 *
 	 * @param rowNumberAlias the alias of the rownumber column of the subselect under consideration. This determines if
-	 *          the other value is replaced by null or not.
-	 * @param alias the column potentially to be replaced by null
+	 *                       the other value is replaced by null or not.
+	 * @param alias          the column potentially to be replaced by null
 	 * @return a SQL expression.
 	 */
 	private static Expression filteredColumnExpression(String rowNumberAlias, String alias) {
@@ -422,11 +419,12 @@ private static SimpleFunction greatest(List<Expression> expressions) {
 	}
 
 	record QueryMeta(AggregatePath basePath, InlineQuery inlineQuery, Collection<Expression> simpleColumns,
-			Collection<Expression> selectableExpressions, Expression id, Expression backReference, Expression key,
-			Expression rowNumber, Expression rowCount) {
+					 Collection<Expression> selectableExpressions, Expression id, Expression backReference,
+					 Expression key,
+					 Expression rowNumber, Expression rowCount) {
 
 		static QueryMeta of(AggregatePath basePath, InlineQuery inlineQuery, Collection<Expression> simpleColumns,
-				Expression id, Expression backReference, Expression key, Expression rowNumber, Expression rowCount) {
+							Expression id, Expression backReference, Expression key, Expression rowNumber, Expression rowCount) {
 
 			List<Expression> selectableExpressions = new ArrayList<>(simpleColumns);
 			selectableExpressions.add(rowNumber);