path = ((MetadataBackedField) propertyField).getPath();
@@ -347,9 +333,35 @@ public Object getValue() {
.getRequiredPersistentEntity(propertyField.getRequiredProperty());
Condition condition = mapEmbeddedObjectCondition(criteria, parameterSource, table, embeddedEntity, embedded);
+ if (!embedded && condition instanceof OrCondition) {
+ return Conditions.nest(condition);
+ }
return embedded || !(condition instanceof AndCondition) ? condition : Conditions.nest(condition);
}
+ // AggregateReference (and similar associations) to a composite identifier: expand IN/NOT_IN like embedded
+ if (propertyField instanceof MetadataBackedField metadataBackedField && metadataBackedField.property != null) {
+
+ RelationalPersistentProperty associationProperty = metadataBackedField.property;
+
+ if (Association.isAssociation(associationProperty)) {
+
+ Association association = Association.from(associationProperty, converter);
+
+ if (association.isComplexIdentifier() //
+ && (Comparator.IN.equals(comparator) || Comparator.NOT_IN.equals(comparator))
+ && value instanceof Collection collection) {
+
+ RelationalPersistentEntity identifierEntity = association.getRequiredTargetIdentifierEntity();
+
+ return expandInCollectionComparison(comparator, collection,
+ element -> mapEmbeddedObjectCondition(
+ new ListElementCriteria(criteria, unwrapAssociationCriteriaValue(element)), parameterSource, table,
+ identifierEntity, true));
+ }
+ }
+ }
+
TypeInformation actualType = propertyField.getTypeHint().getRequiredActualType();
Column column = table.column(propertyField.getMappedColumnName());
Object mappedValue;
@@ -384,6 +396,29 @@ public Object getValue() {
return createCondition(column, mappedValue, sqlType, parameterSource, comparator, criteria.isIgnoreCase());
}
+ /**
+ * Expands {@link Comparator#IN}/{@link Comparator#NOT_IN} over a collection to a disjunction of nested conditions,
+ * one per element (used for embedded types and composite association identifiers).
+ *
+ * IN: (col = v AND …) OR (…) per element.
+ * NOT_IN: AND over tuple negations; each negation is (col != v OR …), i.e. NOT (c1 = v1 AND c2 = v2) ≡ (c1 != v1 OR c2 != v2).
+ */
+ @SuppressWarnings("NullAway")
+ private Condition expandInCollectionComparison(Comparator comparator, Collection collection,
+ Function nestedConditionFactory) {
+
+ if (CollectionUtils.isEmpty(collection)) {
+ return Comparator.IN.equals(comparator) ? Conditions.unrestricted().not() : Conditions.unrestricted();
+ }
+
+ Condition condition = null;
+ for (Object element : collection) {
+ Condition next = Conditions.nest(nestedConditionFactory.apply(element));
+ condition = condition == null ? next : (Comparator.IN.equals(comparator) ? condition.or(next) : condition.and(next));
+ }
+ return condition;
+ }
+
/**
* Converts values while taking specific value types like arrays, {@link Iterable}, or {@link Pair}.
*
@@ -469,6 +504,15 @@ private JdbcValue getWriteValue(RelationalPersistentProperty property, Object va
);
}
+ private static Object unwrapAssociationCriteriaValue(Object value) {
+
+ if (value instanceof AggregateReference aggregateReference) {
+ return aggregateReference.getId();
+ }
+
+ return value;
+ }
+
private Condition mapEmbeddedObjectCondition(CriteriaDefinition criteria, MapSqlParameterSource parameterSource,
Table table, RelationalPersistentEntity embeddedEntity, boolean embedded) {
@@ -477,30 +521,22 @@ private Condition mapEmbeddedObjectCondition(CriteriaDefinition criteria, MapSql
PersistentPropertyAccessor