Allow using embedded Id's without Embedded annotation.

mp911de · mp911de · commit 51d95de85f9f · 2025-06-16T16:31:08.000+02:00
diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/MappingJdbcConverter.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/MappingJdbcConverter.java
@@ -454,6 +454,14 @@ private static Function<AggregatePath, Object> getWrappedValueProvider(Function<
 			AggregatePath aggregatePath) {
 
 		AggregatePath idDefiningParentPath = aggregatePath.getIdDefiningParentPath();
+
+		if (!idDefiningParentPath.hasIdProperty()) {
+			return ap -> {
+				throw new IllegalStateException(
+						"AggregatePath %s does not define an identifier property".formatted(idDefiningParentPath));
+			};
+		}
+
 		RelationalPersistentProperty idProperty = idDefiningParentPath.getRequiredIdProperty();
 		AggregatePath idPath = idProperty.isEntity() ? idDefiningParentPath.append(idProperty) : idDefiningParentPath;
 
diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/RowDocumentExtractorSupport.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/RowDocumentExtractorSupport.java
@@ -26,6 +26,7 @@
 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.data.relational.core.mapping.RelationalPredicates;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.data.relational.domain.RowDocument;
 import org.springframework.lang.Nullable;
@@ -235,7 +236,7 @@ private void readEntity(RS row, RowDocument document, AggregatePath basePath,
 
 				AggregatePath path = basePath.append(property);
 
-				if (property.isEntity() && !property.isEmbedded() && (property.isCollectionLike() || property.isQualified())) {
+				if (RelationalPredicates.isRelation(property) && (property.isCollectionLike() || property.isQualified())) {
 
 					readerState.put(property, new ContainerSink<>(aggregateContext, property, path));
 					continue;
diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlParametersFactory.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlParametersFactory.java
@@ -33,6 +33,7 @@
 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.data.relational.core.mapping.RelationalPredicates;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.lang.Nullable;
 
@@ -257,12 +258,14 @@ private <S, T> SqlIdentifierParameterSource getParameterSource(@Nullable S insta
 		PersistentPropertyAccessor<S> propertyAccessor = instance != null ? persistentEntity.getPropertyAccessor(instance)
 				: NoValuePropertyAccessor.instance();
 
+
 		persistentEntity.doWithAll(property -> {
 
 			if (skipProperty.test(property) || !property.isWritable()) {
 				return;
 			}
-			if (property.isEntity() && !property.isEmbedded()) {
+
+			if (RelationalPredicates.isRelation(property)) {
 				return;
 			}
 
diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/mapping/schema/Tables.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/mapping/schema/Tables.java
@@ -33,6 +33,7 @@
 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.data.relational.core.mapping.RelationalPredicates;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -68,7 +69,7 @@ public static Tables from(Stream<? extends RelationalPersistentEntity<?>> persis
 
 					for (RelationalPersistentProperty property : entity) {
 
-						if (property.isEntity() && !property.isEmbedded()) {
+						if (RelationalPredicates.isRelation(property)) {
 							foreignKeyMetadataList.add(createForeignKeyMetadata(entity, property, context, sqlTypeMapping));
 							continue;
 						}
diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/CompositeIdAggregateTemplateHsqlIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/CompositeIdAggregateTemplateHsqlIntegrationTests.java
@@ -255,7 +255,7 @@ private record WrappedPk(Long id) {
 	}
 
 	private record SimpleEntity( //
-			@Id @Embedded(onEmpty = Embedded.OnEmpty.USE_NULL) WrappedPk wrappedPk, //
+			@Id WrappedPk wrappedPk, //
 			String name //
 	) {
 	}
@@ -272,7 +272,7 @@ private record EmbeddedPk(Long one, String two) {
 	}
 
 	private record SimpleEntityWithEmbeddedPk( //
-			@Id @Embedded(onEmpty = Embedded.OnEmpty.USE_NULL) EmbeddedPk embeddedPk, //
+			@Id EmbeddedPk embeddedPk, //
 			String name //
 	) {
 	}
diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/MappingRelationalConverter.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/MappingRelationalConverter.java
@@ -44,7 +44,16 @@
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PersistentPropertyPathAccessor;
 import org.springframework.data.mapping.context.MappingContext;
-import org.springframework.data.mapping.model.*;
+import org.springframework.data.mapping.model.CachingValueExpressionEvaluatorFactory;
+import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
+import org.springframework.data.mapping.model.EntityInstantiator;
+import org.springframework.data.mapping.model.ParameterValueProvider;
+import org.springframework.data.mapping.model.PersistentEntityParameterValueProvider;
+import org.springframework.data.mapping.model.PropertyValueProvider;
+import org.springframework.data.mapping.model.SimpleTypeHolder;
+import org.springframework.data.mapping.model.SpELContext;
+import org.springframework.data.mapping.model.ValueExpressionEvaluator;
+import org.springframework.data.mapping.model.ValueExpressionParameterValueProvider;
 import org.springframework.data.projection.EntityProjection;
 import org.springframework.data.projection.EntityProjectionIntrospector;
 import org.springframework.data.projection.EntityProjectionIntrospector.ProjectionPredicate;
@@ -578,6 +587,10 @@ private Object readEmbedded(ConversionContext conversionContext, RelationalPrope
 	private boolean shouldReadEmbeddable(ConversionContext context, RelationalPersistentProperty property,
 			RelationalPersistentEntity<?> unwrappedEntity, RelationalPropertyValueProvider propertyValueProvider) {
 
+		if (property.isIdProperty() && !property.isAnnotationPresent(Embedded.class)) {
+			return true;
+		}
+
 		OnEmpty onEmpty = property.getRequiredAnnotation(Embedded.class).onEmpty();
 
 		if (onEmpty.equals(OnEmpty.USE_EMPTY)) {
diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/RelationalEntityDeleteWriter.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/RelationalEntityDeleteWriter.java
@@ -24,6 +24,7 @@
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.relational.core.mapping.RelationalPredicates;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
@@ -124,7 +125,7 @@ private List<DbAction<?>> deleteReferencedEntities(Object id, AggregateChange<?>
 	private void forAllTableRepresentingPaths(Class<?> entityType,
 			Consumer<PersistentPropertyPath<RelationalPersistentProperty>> pathConsumer) {
 
-		context.findPersistentPropertyPaths(entityType, property -> property.isEntity() && !property.isEmbedded()) //
+		context.findPersistentPropertyPaths(entityType, RelationalPredicates.isRelation()) //
 				.filter(path -> context.getAggregatePath(path).isWritable()) //
 				.forEach(pathConsumer);
 	}
diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/WritingContext.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/WritingContext.java
@@ -27,6 +27,7 @@
 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.data.relational.core.mapping.RelationalPredicates;
 import org.springframework.data.util.Pair;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -61,7 +62,7 @@ class WritingContext<T> {
 		this.aggregateChange = aggregateChange;
 		this.rootIdValueSource = IdValueSource.forInstance(root,
 				context.getRequiredPersistentEntity(aggregateChange.getEntityType()));
-		this.paths = context.findPersistentPropertyPaths(entityType, (p) -> p.isEntity() && !p.isEmbedded()) //
+		this.paths = context.findPersistentPropertyPaths(entityType, RelationalPredicates::isRelation) //
 				.filter(ppp -> context.getAggregatePath(ppp).isWritable()).toList();
 	}
 
diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java
@@ -250,7 +250,7 @@ public boolean isOrdered() {
 
 	@Override
 	public boolean isEmbedded() {
-		return isEmbedded;
+		return isEmbedded || (isIdProperty() && isEntity());
 	}
 
 	@Override
@@ -263,7 +263,8 @@ public boolean shouldCreateEmptyEmbedded() {
 
 		Embedded findAnnotation = findAnnotation(Embedded.class);
 
-		return findAnnotation != null && OnEmpty.USE_EMPTY.equals(findAnnotation.onEmpty());
+		return (findAnnotation != null && OnEmpty.USE_EMPTY.equals(findAnnotation.onEmpty()))
+				|| (isIdProperty() && isEntity());
 	}
 
 	@Override
diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/RelationalPredicates.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/RelationalPredicates.java
@@ -0,0 +1,47 @@
+/*
+ * 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 java.util.function.Predicate;
+
+/**
+ * Collection of relational predicates.
+ *
+ * @author Mark Paluch
+ * @since 4.0
+ */
+public class RelationalPredicates {
+
+	/**
+	 * Predicate to determine whether a property is a relation (i.e. it is an entity, not an identifier property, and not
+	 * an embedded property).
+	 *
+	 * @return a predicate that tests if the given property is a relation.
+	 */
+	public static Predicate<? super RelationalPersistentProperty> isRelation() {
+		return RelationalPredicates::isRelation;
+	}
+
+	/**
+	 * Determine whether a property is a relation (i.e. it is an entity, not an identifier property, and not an embedded
+	 * property).
+	 *
+	 * @return {@literal true} if the property is a relation; {@literal false} otherwise.
+	 */
+	public static boolean isRelation(RelationalPersistentProperty property) {
+		return !property.isIdProperty() && property.isEntity() && !property.isEmbedded();
+	}
+}
diff --git a/src/main/antora/modules/ROOT/partials/mapping-annotations.adoc b/src/main/antora/modules/ROOT/partials/mapping-annotations.adoc
@@ -1,7 +1,7 @@
 The `RelationalConverter` can use metadata to drive the mapping of objects to rows.
 The following annotations are available:
 
-* `@Embedded`: an entity with this annotation will be mapped to the table of the parent entity, instead of a separate table.
+* `@Embedded`: a property with this annotation will be mapped to the table of the parent entity, instead of a separate table.
 Allows to specify if the resulting columns should have a common prefix.
 If all columns resulting from such an entity are `null` either the annotated entity will be `null` or _empty_, i.e. all of its properties will be `null`, depending on the value of `@Embedded.onEmpty()`
 May be combined with `@Id` to form a composite id.
@@ -32,5 +32,3 @@ However, this is not recommended, since it may cause problems with other tools.
 The value is `null` (`zero` for primitive types) is considered as marker for entities to be new.
 The initially stored value is `zero` (`one` for primitive types).
 The version gets incremented automatically on every update.
-
-
diff --git a/src/main/antora/modules/ROOT/partials/mapping.adoc b/src/main/antora/modules/ROOT/partials/mapping.adoc
@@ -151,7 +151,7 @@ endif::[]
 [[entity-persistence.embedded-ids]]
 === Embedded Ids
 
-Entities may be annotated with `@Id` and `@Embedded`, resulting in a composite id on the database side.
+The identifier property can be annotated with `@Embedded` allowing to use composite ids.
 The full embedded entity is considered the id, and therefore the check for determining if an aggregate is considered a new aggregate requiring an insert or an existing one, asking for an update is based on that entity, not its elements.
 Most use cases will require a custom `BeforeConvertCallback` to set the id for new aggregate.
 
@@ -189,7 +189,7 @@ CREATE TABLE PERSON_WITH_COMPOSITE_ID (
 <2> `pk` is marked as id and embedded
 <3> the two columns from the embedded `Name` entity make up the primary key in the database.
 
-Details of the create tables will depend on the database used.
+Details of table creation depends on the used database.
 ====
 
 [[entity-persistence.read-only-properties]]

Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,7 @@ private record WrappedPk(Long id) {`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`private record SimpleEntity( //`
`258`		`- @Id @Embedded(onEmpty = Embedded.OnEmpty.USE_NULL) WrappedPk wrappedPk, //`
	`258`	`+ @Id WrappedPk wrappedPk, //`
`259`	`259`	`String name //`
`260`	`260`	`) {`
`261`	`261`	`}`
`@@ -272,7 +272,7 @@ private record EmbeddedPk(Long one, String two) {`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`private record SimpleEntityWithEmbeddedPk( //`
`275`		`- @Id @Embedded(onEmpty = Embedded.OnEmpty.USE_NULL) EmbeddedPk embeddedPk, //`
	`275`	`+ @Id EmbeddedPk embeddedPk, //`
`276`	`276`	`String name //`
`277`	`277`	`) {`
`278`	`278`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ public boolean isOrdered() {`
`250`	`250`
`251`	`251`	`@Override`
`252`	`252`	`public boolean isEmbedded() {`
`253`		`- return isEmbedded;`
	`253`	`+ return isEmbedded \|\| (isIdProperty() && isEntity());`
`254`	`254`	`}`
`255`	`255`
`256`	`256`	`@Override`
`@@ -263,7 +263,8 @@ public boolean shouldCreateEmptyEmbedded() {`
`263`	`263`
`264`	`264`	`Embedded findAnnotation = findAnnotation(Embedded.class);`
`265`	`265`
`266`		`- return findAnnotation != null && OnEmpty.USE_EMPTY.equals(findAnnotation.onEmpty());`
	`266`	`+ return (findAnnotation != null && OnEmpty.USE_EMPTY.equals(findAnnotation.onEmpty()))`
	`267`	`+ \|\| (isIdProperty() && isEntity());`
`267`	`268`	`}`
`268`	`269`
`269`	`270`	`@Override`