AggregatePath caching considers property owner.

Since a PersistencePropertyPath does NOT consider it's owner for equality, this is necessary.
to distinguish different AggregatePath instances based on a inherited property.

Closes #1657
Original pull request: #1661

Author: schauder

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

@@ -52,7 +52,7 @@ class DefaultAggregatePath implements AggregatePath {
 
 		this.context = context;
 		this.path = (PersistentPropertyPath) path;
-		this.rootType = null;
+		this.rootType = path.getBaseProperty().getOwner();
 	}
 
 	DefaultAggregatePath(RelationalMappingContext context, RelationalPersistentEntity<?> rootType) {

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

@@ -186,25 +186,40 @@ protected void applyDefaults(BasicRelationalPersistentProperty persistentPropert
 	 */
 	public AggregatePath getAggregatePath(PersistentPropertyPath<? extends RelationalPersistentProperty> path) {
 
-		AggregatePath aggregatePath = aggregatePathCache.get(path);
+		AggregatePathCacheKey cacheKey = AggregatePathCacheKey.of(path);
+
+		AggregatePath aggregatePath = aggregatePathCache.get(cacheKey);
 		if (aggregatePath == null) {
 
 			aggregatePath = new DefaultAggregatePath(this, path);
-			aggregatePathCache.put(path, aggregatePath);
+			aggregatePathCache.put(cacheKey, aggregatePath);
 		}
 
 		return aggregatePath;
 	}
 
 	public AggregatePath getAggregatePath(RelationalPersistentEntity<?> type) {
 
-		AggregatePath aggregatePath = aggregatePathCache.get(type);
+		AggregatePathCacheKey cacheKey = AggregatePathCacheKey.of(type);
+
+		AggregatePath aggregatePath = aggregatePathCache.get(cacheKey);
 		if (aggregatePath == null) {
 
 			aggregatePath = new DefaultAggregatePath(this, type);
-			aggregatePathCache.put(type, aggregatePath);
+			aggregatePathCache.put(cacheKey, aggregatePath);
 		}
 
 		return aggregatePath;
 	}
+
+	private record AggregatePathCacheKey(RelationalPersistentEntity<?> root,@Nullable PersistentPropertyPath<? extends RelationalPersistentProperty> path) {
+		static AggregatePathCacheKey of(RelationalPersistentEntity<?> root) {
+			return new AggregatePathCacheKey(root, null);
+		}
+		static AggregatePathCacheKey of(PersistentPropertyPath<? extends RelationalPersistentProperty> path) {
+
+			RelationalPersistentEntity<?> root = path.getBaseProperty().getOwner();
+			return new AggregatePathCacheKey(root, path);
+		}
+	}
 }

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

@@ -104,6 +104,20 @@ void correctlyCascadesPrefix() {
 		assertThat(name.getColumnName()).isEqualTo(SqlIdentifier.quoted("PRNT_CHLD_NAME"));
 	}
 
+	@Test // GH-1657
+	void aggregatePathsOfBasePropertyForDifferentInheritedEntitiesAreDifferent() {
+
+		PersistentPropertyPath<RelationalPersistentProperty> path1 = context.getPersistentPropertyPath("name",
+				Inherit1.class);
+		PersistentPropertyPath<RelationalPersistentProperty> path2 = context.getPersistentPropertyPath("name",
+				Inherit2.class);
+
+		AggregatePath aggregatePath1 = context.getAggregatePath(path1);
+		AggregatePath aggregatePath2 = context.getAggregatePath(path2);
+
+		assertThat(aggregatePath1).isNotEqualTo(aggregatePath2);
+	}
+
 	static class EntityWithUuid {
 		@Id UUID uuid;
 	}
@@ -121,4 +135,12 @@ static class Child {
 		String name;
 	}
 
+	static class Base {
+		String name;
+	}
+
+	static class Inherit1 extends Base {}
+
+	static class Inherit2 extends Base {}
+
 }