works somehow

Author: schauder

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

@@ -113,6 +113,11 @@ public class SqlGenerator {
 		this.dialect = dialect;
 	}
 
+
+	public SelectBuilder.SelectWhere createSelectBuilder(Table table, Predicate<AggregatePath> pathFilter) {
+		return createSelectBuilder(table, pathFilter, Collections.emptyList());
+	}
+
 	/**
 	 * When deleting entities there is a fundamental difference between deleting
 	 * <ol>
@@ -573,15 +578,11 @@ private SelectBuilder.SelectWhere selectBuilder() {
 
 	private SelectBuilder.SelectWhere selectBuilder(Collection<SqlIdentifier> keyColumns) {
 
-		return createSelectBuilder(keyColumns, ap -> false, getTable());
-	}
-
-	public SelectBuilder.SelectWhere createSelectBuilder(Predicate<AggregatePath> pathFilter, Table table) {
-		return createSelectBuilder(Collections.emptyList(), pathFilter, table);
+		return createSelectBuilder(getTable(), ap -> false, keyColumns);
 	}
 
-	private SelectBuilder.SelectWhere createSelectBuilder(Collection<SqlIdentifier> keyColumns,
-														  Predicate<AggregatePath> pathFilter, Table table) {
+	private SelectBuilder.SelectWhere createSelectBuilder(Table table, Predicate<AggregatePath> pathFilter,
+			Collection<SqlIdentifier> keyColumns) {
 
 		Set<Expression> columnExpressions = new LinkedHashSet<>();
 

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

@@ -15,8 +15,6 @@
  */
 package org.springframework.data.jdbc.repository.query;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Optional;
 import java.util.function.Predicate;
 
@@ -81,14 +79,16 @@ class JdbcQueryCreator extends RelationalQueryCreator<ParametrizedQuery> {
 	 * @param accessor parameter metadata provider, must not be {@literal null}.
 	 * @param isSliceQuery flag denoting if the query returns a {@link org.springframework.data.domain.Slice}.
 	 * @param returnedType the {@link ReturnedType} to be returned by the query. Must not be {@literal null}.
-	 *
-	 * @deprecated use {@link JdbcQueryCreator#JdbcQueryCreator(RelationalMappingContext, PartTree, JdbcConverter, Dialect, RelationalEntityMetadata, RelationalParameterAccessor, boolean, ReturnedType, Optional, SqlGeneratorSource)} instead.
+	 * @deprecated use
+	 *             {@link JdbcQueryCreator#JdbcQueryCreator(RelationalMappingContext, PartTree, JdbcConverter, Dialect, RelationalEntityMetadata, RelationalParameterAccessor, boolean, ReturnedType, Optional, SqlGeneratorSource)}
+	 *             instead.
 	 */
 	@Deprecated(since = "4.0", forRemoval = true)
 	JdbcQueryCreator(RelationalMappingContext context, PartTree tree, JdbcConverter converter, Dialect dialect,
 			RelationalEntityMetadata<?> entityMetadata, RelationalParameterAccessor accessor, boolean isSliceQuery,
 			ReturnedType returnedType, Optional<Lock> lockMode) {
-		this(context, tree, converter, dialect, entityMetadata, accessor, isSliceQuery, returnedType, lockMode, new SqlGeneratorSource(context, converter, dialect));
+		this(context, tree, converter, dialect, entityMetadata, accessor, isSliceQuery, returnedType, lockMode,
+				new SqlGeneratorSource(context, converter, dialect));
 	}
 
 	/**
@@ -104,8 +104,8 @@ class JdbcQueryCreator extends RelationalQueryCreator<ParametrizedQuery> {
 	 * @param isSliceQuery flag denoting if the query returns a {@link org.springframework.data.domain.Slice}.
 	 * @param returnedType the {@link ReturnedType} to be returned by the query. Must not be {@literal null}.
 	 * @param lockMode lock mode to be used for the query.
-	 * @param sqlGeneratorSource the source providing SqlGenerator instances for generating SQL. Must not be {@literal null}
-	 *
+	 * @param sqlGeneratorSource the source providing SqlGenerator instances for generating SQL. Must not be
+	 *          {@literal null}
 	 */
 	JdbcQueryCreator(RelationalMappingContext context, PartTree tree, JdbcConverter converter, Dialect dialect,
 			RelationalEntityMetadata<?> entityMetadata, RelationalParameterAccessor accessor, boolean isSliceQuery,
@@ -258,125 +258,13 @@ SelectBuilder.SelectLimitOffset createSelectClause(RelationalPersistentEntity<?>
 
 	private SelectBuilder.SelectJoin selectBuilder(Table table) {
 
-
-		List<Expression> columnExpressions = new ArrayList<>();
 		RelationalPersistentEntity<?> entity = entityMetadata.getTableEntity();
 
-		Predicate<AggregatePath> filter = ap -> returnedType.needsCustomConstruction() && !returnedType.getInputProperties().contains(ap.getRequiredBaseProperty().getName());
-
-		return (SelectBuilder.SelectJoin) sqlGeneratorSource.getSqlGenerator(entity.getType()).createSelectBuilder(
-				filter
-				, table);
-//
-//		SqlContext sqlContext = new SqlContext();
-//
-//		List<Join> joinTables = new ArrayList<>();
-//		for (PersistentPropertyPath<RelationalPersistentProperty> path : context
-//				.findPersistentPropertyPaths(entity.getType(), p -> true)) {
-//
-//			AggregatePath aggregatePath = context.getAggregatePath(path);
-//
-//			if (filter.test(aggregatePath)) {	continue;}
-//
-//			// add a join if necessary
-//			Join join = getJoin(sqlContext, aggregatePath);
-//			if (join != null) {
-//				joinTables.add(join);
-//			}
-//
-//			Column column = getColumn(sqlContext, aggregatePath);
-//			if (column != null) {
-//				columnExpressions.add(column);
-//			}
-//		}
-//
-//		SelectBuilder.SelectJoin baseSelect = StatementBuilder.select(columnExpressions).from(table);
-//
-//		// TODO: included in SqlGenerator.Join
-//		for (Join join : joinTables) {
-//
-//			Condition condition = null;
-//
-//			for (int i = 0; i < join.joinColumns.size(); i++) {
-//				Column parentColumn = join.parentId.get(i);
-//				Column joinColumn = join.joinColumns.get(i);
-//				Comparison singleCondition = joinColumn.isEqualTo(parentColumn);
-//				condition = condition == null ? singleCondition : condition.and(singleCondition);
-//			}
-//
-//			Assert.state(condition != null, "No condition found");
-//
-//			baseSelect = baseSelect.leftOuterJoin(join.joinTable).on(condition);
-//		}
-//
-//		return baseSelect;
-	}
-
-	/**
-	 * Create a {@link Column} for {@link AggregatePath}.
-	 *
-	 * @param sqlContext for generating SQL constructs.
-	 * @param path the path to the column in question.
-	 * @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
-	 */
-	@Nullable
-	private Column getColumn(SqlContext sqlContext, AggregatePath path) {
-
-		// an embedded itself doesn't give an column, its members will though.
-		// if there is a collection or map on the path it won't get selected at all, but it will get loaded with a separate
-		// select
-		// only the parent path is considered in order to handle arrays that get stored as BINARY properly
-		if (path.isEmbedded() || path.getParentPath().isMultiValued()) {
-			return null;
-		}
-
-		if (path.isEntity()) {
-
-			if (path.isQualified() //
-					|| path.isCollectionLike() //
-					|| path.hasIdProperty() //
-			) {
-				return null;
-			}
-
-			// Simple entities without id include there backreference as an synthetic id in order to distinguish null entities
-			// from entities with only null values.
-			return sqlContext.getAnyReverseColumn(path);
-		}
+		Predicate<AggregatePath> filter = ap -> returnedType.needsCustomConstruction()
+				&& !returnedType.getInputProperties().contains(ap.getRequiredBaseProperty().getName());
 
-		return sqlContext.getColumn(path);
-	}
-
-	@Nullable
-	Join getJoin(SqlContext sqlContext, AggregatePath path) {
-
-		if (!path.isEntity() || path.isEmbedded() || path.isMultiValued()) {
-			return null;
-		}
-
-		Table currentTable = sqlContext.getTable(path);
-
-		AggregatePath idDefiningParentPath = path.getIdDefiningParentPath();
-		Table parentTable = sqlContext.getTable(idDefiningParentPath);
-
-		List<Column> reverseColumns = path.getTableInfo().backReferenceColumnInfos().toColumnList(currentTable);
-		List<Column> idColumns = idDefiningParentPath.getTableInfo().idColumnInfos().toColumnList(parentTable);
-		return new Join( //
-				currentTable, //
-				reverseColumns, //
-				idColumns //
+		return (SelectBuilder.SelectJoin) sqlGeneratorSource.getSqlGenerator(entity.getType()).createSelectBuilder(table, filter
 		);
 	}
 
-	/**
-	 * Value object representing a {@code JOIN} association.
-	 */
-	private record Join(Table joinTable, List<Column> joinColumns, List<Column> parentId) {
-
-		Join {
-			Assert.isTrue(joinColumns.size() == parentId.size(),
-					"Both sides of a join condition must have the same number of columns");
-		}
-
-	}
 }

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 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.relational.core.mapping;
+
+import org.assertj.core.api.AbstractAssert;
+
+public class AggregatePathAssertions extends AbstractAssert<AggregatePathAssertions, AggregatePath> {
+
+	// Constructor for initializing with an AggregatePath instance
+	public AggregatePathAssertions(AggregatePath actual) {
+		super(actual, AggregatePathAssertions.class);
+	}
+
+	/**
+	 * Entry point for creating assertions for AggregatePath.
+	 */
+	public static AggregatePathAssertions assertThat(AggregatePath actual) {
+		return new AggregatePathAssertions(actual);
+	}
+
+	/**
+	 * Example custom assertion method: Asserts that the AggregatePath has a specific property.
+	 */
+	public AggregatePathAssertions hasPath(String expectedPath) {
+		isNotNull();
+
+		if (!actual.toString().equals(expectedPath)) { // Adjust this condition based on your AggregatePath's path logic
+			failWithMessage("Expected path to be <%s> but was <%s>", expectedPath, actual.toString());
+		}
+		return this;
+	}
+
+	/**
+	 * Example custom assertion method: Checks if the AggregatePath is empty.
+	 */
+	public AggregatePathAssertions isRoot() {
+		isNotNull();
+
+		if (!actual.isRoot()) {
+			failWithMessage("Expected AggregatePath to be root path, but it was not");
+		}
+		return this;
+	}
+
+	/**
+	 * Example custom assertion method: Validates the depth of the path.
+	 */
+	public AggregatePathAssertions hasLength(int expectedLength) {
+		isNotNull();
+
+		if (actual.getLength() != expectedLength) {
+			failWithMessage("Expected path length to be <%d> but was <%d>", expectedLength, actual.getLength());
+		}
+		return this;
+	}
+
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 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.relational.core.mapping;
+
+import org.assertj.core.api.SoftAssertions;
+import org.assertj.core.api.SoftAssertionsProvider;
+
+import java.util.function.Consumer;
+
+public class AggregatePathSoftAssertions extends SoftAssertions {
+	public AggregatePathAssertions assertAggregatePath(AggregatePath actual) {
+		return proxy(AggregatePathAssertions.class, AggregatePath.class, actual);
+	}
+
+	static void assertNewSoftly(Consumer<AggregatePathSoftAssertions> softly) {
+		SoftAssertionsProvider.assertSoftly(AggregatePathSoftAssertions.class, softly);
+	}
+}

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

@@ -64,11 +64,11 @@ void isRootForRootPath() {
 	@Test // GH-1525
 	void getParentPath() {
 
-		assertSoftly(softly -> {
+		AggregatePathSoftAssertions.assertNewSoftly(softly -> {
 
-			softly.assertThat((Object) path("second.third2.value").getParentPath()).isEqualTo(path("second.third2"));
-			softly.assertThat((Object) path("second.third2").getParentPath()).isEqualTo(path("second"));
-			softly.assertThat((Object) path("second").getParentPath()).isEqualTo(path());
+			softly.assertAggregatePath(path("second.third2.value").getParentPath()).hasPath("second.third2");
+			softly.assertAggregatePath(path("second.third2").getParentPath()).hasPath("second");
+			softly.assertAggregatePath(path("second").getParentPath()).isRoot();
 
 			softly.assertThatThrownBy(() -> path().getParentPath()).isInstanceOf(IllegalStateException.class);
 		});
@@ -489,7 +489,7 @@ void getTail() {
 	void append() {
 
 		assertSoftly(softly -> {
-
+			// assert that( .... ) matches ("second")
 			softly.assertThat(path("second").append(path()).toDotPath()).isEqualTo("second");
 			softly.assertThat(path().append(path("second")).toDotPath()).isEqualTo("second");
 			softly.assertThat(path().append(path("second.third")).toDotPath()).isEqualTo("second.third");