backReferenceColumnInfo

Author: schauder

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

@@ -65,7 +65,7 @@ public static Identifier forBackReference(JdbcConverter converter, AggregatePath
 		// references and possibly keys, that form an id
 		if (idDefiningParentPath.hasIdProperty()) {
 
-			AggregatePath.ColumnInfos infos = path.getTableInfo().reverseColumnInfos();
+			AggregatePath.ColumnInfos infos = path.getTableInfo().backReferenceColumnInfos();
 			identifierToUse = infos.reduce(Identifier.empty(), (ap, ci) -> {
 
 				RelationalPersistentProperty property = ap.getRequiredLeafProperty();

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

@@ -408,7 +408,7 @@ public boolean hasValue(RelationalPersistentProperty property) {
 					return delegate.hasValue(toUse);
 				}
 
-				return delegate.hasValue(aggregatePath.getTableInfo().reverseColumnInfos().any().alias());
+				return delegate.hasValue(aggregatePath.getTableInfo().backReferenceColumnInfos().any().alias());
 			}
 
 			return delegate.hasValue(aggregatePath);
@@ -434,7 +434,7 @@ public boolean hasNonEmptyValue(RelationalPersistentProperty property) {
 					return delegate.hasValue(toUse);
 				}
 
-				return delegate.hasValue(aggregatePath.getTableInfo().reverseColumnInfos().any().alias());
+				return delegate.hasValue(aggregatePath.getTableInfo().backReferenceColumnInfos().any().alias());
 			}
 
 			return delegate.hasNonEmptyValue(aggregatePath);

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

@@ -69,7 +69,7 @@ Column getColumn(AggregatePath path) {
 	 */
 	Column getAnyReverseColumn(AggregatePath path) {
 
-		AggregatePath.ColumnInfo columnInfo = path.getTableInfo().reverseColumnInfos().any();
+		AggregatePath.ColumnInfo columnInfo = path.getTableInfo().backReferenceColumnInfos().any();
 		return getTable(path).column(columnInfo.name()).as(columnInfo.alias());
 	}
 }

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

@@ -35,7 +35,6 @@
 import org.springframework.data.relational.core.sql.*;
 import org.springframework.data.relational.core.sql.render.SqlRenderer;
 import org.springframework.data.util.Lazy;
-import org.springframework.data.util.Pair;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -684,7 +683,7 @@ Join getJoin(AggregatePath path) {
 		}
 
 		Table currentTable = sqlContext.getTable(path);
-		AggregatePath.ColumnInfos backRefColumnInfos = path.getTableInfo().reverseColumnInfos();
+		AggregatePath.ColumnInfos backRefColumnInfos = path.getTableInfo().backReferenceColumnInfos();
 
 		AggregatePath idDefiningParentPath = path.getIdDefiningParentPath();
 		Table parentTable = sqlContext.getTable(idDefiningParentPath);
@@ -840,7 +839,7 @@ private String createDeleteByPathAndCriteria(AggregatePath path,
 		Delete delete;
 
 		Map<AggregatePath, Column> columns = new TreeMap<>();
-		AggregatePath.ColumnInfos columnInfos = path.getTableInfo().reverseColumnInfos();
+		AggregatePath.ColumnInfos columnInfos = path.getTableInfo().backReferenceColumnInfos();
 		columnInfos.forEach((ag, ci) -> columns.put(ag, table.column(ci.name())));
 
 		if (isFirstNonRoot(path)) {

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

@@ -138,7 +138,7 @@ private void deleteRelations(List<Delete> deleteChain, RelationalPersistentEntit
 				// MariaDB prior to 11.6 does not  support aliases for delete statements
 				Table table = sqlContext.getUnaliasedTable(aggregatePath);
 
-				List<Column> reverseColumns = aggregatePath.getTableInfo().reverseColumnInfos()
+				List<Column> reverseColumns = aggregatePath.getTableInfo().backReferenceColumnInfos()
 						.toList(ci -> table.column(ci.name()));
 				Expression expression = TupleExpression.maybeWrap(reverseColumns);
 

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

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

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

@@ -47,7 +47,7 @@ Column getColumn(AggregatePath path) {
 
 	Column getAnyReverseColumn(AggregatePath path) {
 
-		AggregatePath.ColumnInfo anyReverseColumnInfo = path.getTableInfo().reverseColumnInfos().any();
+		AggregatePath.ColumnInfo anyReverseColumnInfo = path.getTableInfo().backReferenceColumnInfos().any();
 		return getTable(path).column(anyReverseColumnInfo.name()).as(anyReverseColumnInfo.alias());
 	}
 

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

@@ -40,9 +40,9 @@
  * Represents a path within an aggregate starting from the aggregate root. The path can be iterated from the leaf to its
  * root.
  *
- * @since 3.2
  * @author Jens Schauder
  * @author Mark Paluch
+ * @since 3.2
  */
 public interface AggregatePath extends Iterable<AggregatePath>, Comparable<AggregatePath> {
 
@@ -242,42 +242,36 @@ default Stream<AggregatePath> stream() {
 	 * Returns the longest ancestor path that has an {@link org.springframework.data.annotation.Id} property.
 	 *
 	 * @return A path that starts just as this path but is shorter. Guaranteed to be not {@literal null}. TODO: throws
-	 *         NoSuchElementException: No value present for empty paths
+	 * NoSuchElementException: No value present for empty paths
 	 */
 	AggregatePath getIdDefiningParentPath();
 
+	/**
+	 * The path resulting from removing the first element of the {@link AggregatePath}.
+	 *
+	 * @return {@literal null} for any {@link AggregatePath} having less than two elements.
+	 * @since 3.5.0
+	 */
 	@Nullable
 	AggregatePath getTail();
 
+	/**
+	 * Information about a table underlying an entity.
+	 *
+	 * @param qualifiedTableName       the fully qualified name of the table this path is tied to or of the longest ancestor path that is actually
+	 *                                 tied to a table. Must not be {@literal null}.
+	 * @param tableAlias               the alias used for the table on which this path is based. May be {@literal null}.
+	 * @param backReferenceColumnInfos information about the columns used to reference back to the owning entity. Must not be {@literal null}. Since 3.5.
+	 * @param qualifierColumnInfo      the column used for the list index or map key of the leaf property of this path. May be {@literal null}.
+	 * @param qualifierColumnType      the type of the qualifier column of the leaf property of this path or {@literal null} if this is not applicable. May be {@literal null}.
+	 * @param idColumnInfos            the column name of the id column of the ancestor path that represents an actual table. Must not be {@literal null}.
+	 */
 	record TableInfo(
-
-			/*
-			 * The fully qualified name of the table this path is tied to or of the longest ancestor path that is actually
-			 * tied to a table.
-			 */
 			SqlIdentifier qualifiedTableName,
-
-			/*
-			 * The alias used for the table on which this path is based.
-			 */
 			@Nullable SqlIdentifier tableAlias,
-
-			ColumnInfos reverseColumnInfos,
-
-			/*
-			 * The column used for the list index or map key of the leaf property of this path.
-			 */
+			ColumnInfos backReferenceColumnInfos,
 			@Nullable ColumnInfo qualifierColumnInfo,
-
-			/*
-			 * The type of the qualifier column of the leaf property of this path or {@literal null} if this is not
-			 * applicable.
-			 */
 			@Nullable Class<?> qualifierColumnType,
-
-			/*
-			 * The column name of the id column of the ancestor path that represents an actual table.
-			 */
 			ColumnInfos idColumnInfos) {
 
 		static TableInfo of(AggregatePath path) {
@@ -313,7 +307,7 @@ static TableInfo of(AggregatePath path) {
 		}
 
 		private static ColumnInfos computeIdColumnInfos(AggregatePath tableOwner,
-				RelationalPersistentEntity<?> leafEntity) {
+														RelationalPersistentEntity<?> leafEntity) {
 
 			ColumnInfos idColumnInfos = ColumnInfos.empty(tableOwner);
 			if (!leafEntity.hasIdProperty()) {
@@ -394,16 +388,16 @@ private static ColumnInfos computeReverseColumnInfo(AggregatePath path) {
 
 		@Deprecated(forRemoval = true)
 		public ColumnInfo reverseColumnInfo() {
-			return reverseColumnInfos.unique();
+			return backReferenceColumnInfos.unique();
 		}
 
 		public ColumnInfos effectiveIdColumnInfos() {
-			return reverseColumnInfos.columnInfos.isEmpty() ? idColumnInfos : reverseColumnInfos;
+			return backReferenceColumnInfos.columnInfos.isEmpty() ? idColumnInfos : backReferenceColumnInfos;
 		}
 	}
 
 	/**
-	 * @param name The name of the column used to represent this property in the database.
+	 * @param name  The name of the column used to represent this property in the database.
 	 * @param alias The alias for the column used to represent this property in the database.
 	 */
 	record ColumnInfo(SqlIdentifier name, SqlIdentifier alias) {
@@ -415,7 +409,7 @@ record ColumnInfo(SqlIdentifier name, SqlIdentifier alias) {
 		 * @param path the path to the {@literal ColumnInfo} for.
 		 * @return the {@link ColumnInfo}.
 		 * @throws IllegalArgumentException if the path is {@link #isRoot()}, {@link #isEmbedded()} or
-		 *           {@link #isMultiValued()}.
+		 *                                  {@link #isMultiValued()}.
 		 */
 		static ColumnInfo of(AggregatePath path) {
 
@@ -435,7 +429,7 @@ static ColumnInfo of(AggregatePath path) {
 	 * A group of {@link ColumnInfo} values referenced by there respective {@link AggregatePath}. It is used in a similar
 	 * way as {@literal ColumnInfo} when one needs to consider more than a single column. This is relevant for composite
 	 * ids and references to such ids.
-	 * 
+	 *
 	 * @author Jens Schauder
 	 **/
 	class ColumnInfos {
@@ -445,9 +439,9 @@ class ColumnInfos {
 
 		/**
 		 * Creates a new ColumnInfos instances based on the arguments.
-		 * 
-		 * @param basePath The path on which all other paths in the other argument are based on. For the typical case of a
-		 *          composite id, this would be the path to the composite ids.
+		 *
+		 * @param basePath    The path on which all other paths in the other argument are based on. For the typical case of a
+		 *                    composite id, this would be the path to the composite ids.
 		 * @param columnInfos A map, mapping {@literal AggregatePath} instances to the respective {@literal ColumnInfo}
 		 */
 		private ColumnInfos(AggregatePath basePath, Map<AggregatePath, ColumnInfo> columnInfos) {
@@ -482,7 +476,7 @@ public ColumnInfo unique() {
 
 		/**
 		 * Any of the contained {@link ColumnInfo} instances.
-		 * 
+		 *
 		 * @return a {@link ColumnInfo} instance.
 		 * @throws java.util.NoSuchElementException if no instance is available.
 		 */
@@ -494,7 +488,7 @@ public ColumnInfo any() {
 
 		/**
 		 * Checks if {@literal this} instance is empty, i.e. does not contain any {@link ColumnInfo} instance.
-		 * 
+		 *
 		 * @return {@literal true} iff the collection of {@literal ColumnInfo} is empty.
 		 */
 		public boolean isEmpty() {
@@ -503,10 +497,10 @@ public boolean isEmpty() {
 
 		/**
 		 * Applies a function to all the {@link ColumnInfo} instances and returns the result in a list.
-		 * 
+		 *
 		 * @param mapper the function to be applied
+		 * @param <T>    the type returned by {@literal mapper} and contained in the resulting {@literal List}
 		 * @return the list of results from mapper.
-		 * @param <T> the type returned by {@literal mapper} and contained in the resulting {@literal List}
 		 */
 		public <T> List<T> toList(Function<ColumnInfo, T> mapper) {
 			return columnInfos.values().stream().map(mapper).toList();
@@ -520,13 +514,13 @@ public <T> List<T> toList(Function<ColumnInfo, T> mapper) {
 		 * {@link BinaryOperator combiner} is called with the current state (or initial {@code identity}) and the
 		 * accumulated {@code T} state to combine both into a single return value.
 		 *
-		 * @param identity the identity (initial) value for the combiner function.
+		 * @param identity    the identity (initial) value for the combiner function.
 		 * @param accumulator an associative, non-interfering (free of side effects), stateless function for incorporating
-		 *          an additional element into a result.
-		 * @param combiner an associative, non-interfering, stateless function for combining two values, which must be
-		 *          compatible with the {@code accumulator} function.
+		 *                    an additional element into a result.
+		 * @param combiner    an associative, non-interfering, stateless function for combining two values, which must be
+		 *                    compatible with the {@code accumulator} function.
+		 * @param <T>         type of the result.
 		 * @return result of the function.
-		 * @param <T> type of the result.
 		 * @since 3.5
 		 */
 		public <T> T reduce(T identity, BiFunction<AggregatePath, ColumnInfo, T> accumulator, BinaryOperator<T> combiner) {
@@ -544,7 +538,7 @@ public <T> T reduce(T identity, BiFunction<AggregatePath, ColumnInfo, T> accumul
 
 		/**
 		 * Calls the consumer for each pair of {@link AggregatePath} and {@literal ColumnInfo}.
-		 * 
+		 *
 		 * @param consumer the function to call.
 		 */
 		public void forEach(BiConsumer<AggregatePath, ColumnInfo> consumer) {
@@ -567,7 +561,7 @@ public <T> T any(BiFunction<AggregatePath, ColumnInfo, T> mapper) {
 
 		/**
 		 * Gets the {@link ColumnInfo} for the provided {@link AggregatePath}
-		 * 
+		 *
 		 * @param path for which to return the {@literal ColumnInfo}
 		 * @return {@literal ColumnInfo} for the given path.
 		 */
@@ -577,7 +571,7 @@ public ColumnInfo get(AggregatePath path) {
 
 		/**
 		 * Constructs an {@link AggregatePath} from the {@literal basePath} and the provided argument.
-		 * 
+		 *
 		 * @param ap {@literal AggregatePath} to be appended to the {@literal basePath}.
 		 * @return the combined (@literal AggregatePath}
 		 */
@@ -597,7 +591,7 @@ public int size() {
 
 	/**
 	 * A builder for {@link ColumnInfos} instances.
-	 * 
+	 *
 	 * @author Jens Schauder
 	 */
 	class ColumInfosBuilder {
@@ -617,8 +611,8 @@ public ColumInfosBuilder(AggregatePath basePath) {
 		/**
 		 * Adds a {@link ColumnInfo} to the {@link ColumnInfos} under construction.
 		 *
-		 * @param path referencing the {@literal ColumnInfo}.
-		 * @param name of the column.
+		 * @param path  referencing the {@literal ColumnInfo}.
+		 * @param name  of the column.
 		 * @param alias alias for the column.
 		 */
 		void add(AggregatePath path, SqlIdentifier name, SqlIdentifier alias) {
@@ -629,8 +623,8 @@ void add(AggregatePath path, SqlIdentifier name, SqlIdentifier alias) {
 		 * Adds a {@link ColumnInfo} to the {@link ColumnInfos} under construction.
 		 *
 		 * @param property referencing the {@literal ColumnInfo}.
-		 * @param name of the column.
-		 * @param alias alias for the column.
+		 * @param name     of the column.
+		 * @param alias    alias for the column.
 		 */
 		public void add(RelationalPersistentProperty property, SqlIdentifier name, SqlIdentifier alias) {
 			add(basePath.append(property), name, alias);
@@ -639,15 +633,16 @@ public void add(RelationalPersistentProperty property, SqlIdentifier name, SqlId
 		/**
 		 * Adds a {@link ColumnInfo} to the {@link ColumnInfos} under construction.
 		 *
-		 * @param path the path referencing the {@literal ColumnInfo}
+		 * @param path       the path referencing the {@literal ColumnInfo}
 		 * @param columnInfo the {@literal ColumnInfo} added.
-		 *
 		 */
 		public void add(AggregatePath path, ColumnInfo columnInfo) {
 			columnInfoMap.put(path.subtract(basePath), columnInfo);
 		}
+
 		/**
 		 * Build the final {@link ColumnInfos} instance.
+		 *
 		 * @return a {@literal ColumnInfos} instance containing all the added {@link ColumnInfo} instances.
 		 */
 		ColumnInfos build() {
@@ -658,6 +653,7 @@ ColumnInfos build() {
 
 	/**
 	 * Subtract the {@literal basePath} from {@literal this} {@literal AggregatePath} by removing the {@literal basePath} from the beginning of {@literal this}.
+	 *
 	 * @param basePath the path to be removed.
 	 * @return an AggregatePath that ends like the original {@literal AggregatePath} but has {@literal basePath} removed from the beginning.
 	 */

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

@@ -170,7 +170,7 @@ private QueryMeta createInlineQuery(AggregatePath basePath, @Nullable Condition
 		Expression count = basePath.isRoot() ? new AliasedExpression(SQL.literalOf(1), rowCountAlias) //
 				: AnalyticFunction.create("count", Expressions.just("*")) //
 						.partitionBy( //
-								basePath.getTableInfo().reverseColumnInfos().toList( //
+								basePath.getTableInfo().backReferenceColumnInfos().toList( //
 										ci -> table.column(ci.name()) //
 								) //
 						).as(rowCountAlias);
@@ -182,7 +182,7 @@ private QueryMeta createInlineQuery(AggregatePath basePath, @Nullable Condition
 		if (!basePath.isRoot()) {
 
 			backReferenceAlias = aliases.getBackReferenceAlias(basePath);
-			columns.add(table.column(basePath.getTableInfo().reverseColumnInfos().unique().name()).as(backReferenceAlias));
+			columns.add(table.column(basePath.getTableInfo().backReferenceColumnInfos().unique().name()).as(backReferenceAlias));
 
 			keyAlias = aliases.getKeyAlias(basePath);
 			Expression keyExpression = basePath.isQualified()
@@ -242,7 +242,7 @@ private String getIdentifierProperty(List<AggregatePath> paths) {
 
 	private static AnalyticFunction createRowNumberExpression(AggregatePath basePath, Table table,
 			String rowNumberAlias) {
-		AggregatePath.ColumnInfos reverseColumnInfos = basePath.getTableInfo().reverseColumnInfos();
+		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()))) //

spring-data-relational/src/test/java/org/springframework/data/relational/core/mapping/DefaultAggregatePathUnitTests.java

@@ -147,7 +147,7 @@ void reverseColumnName() {
 	void reverseColumnNames() {
 
 		assertSoftly(softly -> {
-			softly.assertThat(path(CompoundIdEntity.class, "second").getTableInfo().reverseColumnInfos().toList(x -> x))
+			softly.assertThat(path(CompoundIdEntity.class, "second").getTableInfo().backReferenceColumnInfos().toList(x -> x))
 					.extracting(AggregatePath.ColumnInfo::name)
 					.containsExactlyInAnyOrder(quoted("COMPOUND_ID_ENTITY_ONE"), quoted("COMPOUND_ID_ENTITY_TWO"));