Support AggregateReference in query derivation.

For a property of type AggregateReference one may provide an aggregate, an AggregateReference, or the id of the aggregate.

Closes #987
Original pull request: #999.

Author: schauder

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/AggregateReferenceConverters.java

@@ -78,7 +78,7 @@ public Object convert(@Nullable Object source, TypeDescriptor sourceDescriptor,
 				return null;
 			}
 
-			// if the target type is an AggregateReference we just going to assume it is of the correct type,
+			// if the target type is an AggregateReference we are going to assume it is of the correct type,
 			// because it was already converted.
 			Class<?> objectType = targetDescriptor.getObjectType();
 			if (objectType.isAssignableFrom(AggregateReference.class)) {

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/BasicJdbcConverter.java

@@ -232,7 +232,8 @@ public Object readValue(@Nullable Object value, TypeInformation<?> type) {
 					targetDescriptor);
 		}
 
-		if (value instanceof Array) {
+		if ( !getConversions().hasCustomReadTarget(value.getClass(), type.getType()) &&
+				value instanceof Array) {
 			try {
 				return readValue(((Array) value).getArray(), type);
 			} catch (SQLException | ConverterNotFoundException e) {

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/JdbcCustomConversions.java

@@ -20,6 +20,7 @@
 import java.util.Collections;
 import java.util.List;
 
+import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.converter.GenericConverter.ConvertiblePair;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.convert.CustomConversions;
@@ -50,6 +51,7 @@ public class JdbcCustomConversions extends CustomConversions {
 		STORE_CONVERTERS = Collections.unmodifiableCollection(converters);
 
 	}
+
 	private static final StoreConversions STORE_CONVERSIONS = StoreConversions.of(JdbcSimpleTypes.HOLDER,
 			STORE_CONVERTERS);
 

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

@@ -146,11 +146,6 @@ private static void validateProperty(PersistentPropertyPathExtension path) {
 			throw new IllegalArgumentException(
 					String.format("Cannot query by nested entity: %s", path.getRequiredPersistentPropertyPath().toDotPath()));
 		}
-
-		if (path.getRequiredPersistentPropertyPath().getLeafProperty().isReference()) {
-			throw new IllegalArgumentException(
-					String.format("Cannot query by reference: %s", path.getRequiredPersistentPropertyPath().toDotPath()));
-		}
 	}
 
 	/**

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/QueryMapper.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.jdbc.repository.query;
 
+import java.sql.JDBCType;
 import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -245,8 +246,8 @@ private Condition getCondition(CriteriaDefinition criteria, MapSqlParameterSourc
 		return mapCondition(criteria, parameterSource, table, entity);
 	}
 
-	private Condition combine(@Nullable Condition currentCondition,
-			CriteriaDefinition.Combinator combinator, Condition nextCondition) {
+	private Condition combine(@Nullable Condition currentCondition, CriteriaDefinition.Combinator combinator,
+			Condition nextCondition) {
 
 		if (currentCondition == null) {
 			currentCondition = nextCondition;
@@ -292,6 +293,17 @@ private Condition mapCondition(CriteriaDefinition criteria, MapSqlParameterSourc
 
 			mappedValue = convertValue(value, propertyField.getTypeHint());
 			sqlType = propertyField.getSqlType();
+
+		} else if (propertyField instanceof MetadataBackedField //
+				&& ((MetadataBackedField) propertyField).property != null //
+				&& (criteria.getValue() == null || !criteria.getValue().getClass().isArray())) {
+
+			RelationalPersistentProperty property = ((MetadataBackedField) propertyField).property;
+			JdbcValue jdbcValue = convertSpecial(property, criteria.getValue());
+			mappedValue = jdbcValue.getValue();
+			sqlType = jdbcValue.getJdbcType() != null ? jdbcValue.getJdbcType().getVendorTypeNumber()
+					: propertyField.getSqlType();
+
 		} else {
 
 			mappedValue = convertValue(criteria.getValue(), propertyField.getTypeHint());
@@ -302,6 +314,84 @@ private Condition mapCondition(CriteriaDefinition criteria, MapSqlParameterSourc
 				criteria.isIgnoreCase());
 	}
 
+	/**
+	 * Converts values while taking special value types like arrays, {@link Iterable}, or {@link Pair}.
+	 * 
+	 * @param property the property to which the value relates. It determines the type to convert to. Must not be
+	 *          {@literal null}.
+	 * @param value the value to be converted.
+	 * @return a non null {@link JdbcValue} holding the converted value and the appropriate JDBC type information.
+	 */
+	private JdbcValue convertSpecial(RelationalPersistentProperty property, @Nullable Object value) {
+
+		if (value == null) {
+			return JdbcValue.of(null, JDBCType.NULL);
+		}
+
+		if (value instanceof Pair) {
+
+			final JdbcValue first = convertSimple(property, ((Pair<?, ?>) value).getFirst());
+			final JdbcValue second = convertSimple(property, ((Pair<?, ?>) value).getSecond());
+			return JdbcValue.of(Pair.of(first.getValue(), second.getValue()), first.getJdbcType());
+		}
+
+		if (value instanceof Iterable) {
+
+			List<Object> mapped = new ArrayList<>();
+			JDBCType jdbcType = null;
+
+			for (Object o : (Iterable<?>) value) {
+
+				final JdbcValue jdbcValue = convertSimple(property, o);
+				if (jdbcType == null) {
+					jdbcType = jdbcValue.getJdbcType();
+				}
+
+				mapped.add(jdbcValue.getValue());
+			}
+
+			return JdbcValue.of(mapped, jdbcType);
+		}
+
+		if (value.getClass().isArray()) {
+
+			final Object[] valueAsArray = (Object[]) value;
+			final Object[] mappedValueArray = new Object[valueAsArray.length];
+			JDBCType jdbcType = null;
+
+			for (int i = 0; i < valueAsArray.length; i++) {
+
+				final JdbcValue jdbcValue = convertSimple(property, valueAsArray[i]);
+				if (jdbcType == null) {
+					jdbcType = jdbcValue.getJdbcType();
+				}
+
+				mappedValueArray[i] = jdbcValue.getValue();
+			}
+
+			return JdbcValue.of(mappedValueArray, jdbcType);
+		}
+
+		return convertSimple(property, value);
+	}
+
+	/**
+	 * Converts values to a {@link JdbcValue}.
+	 *
+	 * @param property the property to which the value relates. It determines the type to convert to. Must not be
+	 *          {@literal null}.
+	 * @param value the value to be converted.
+	 * @return a non null {@link JdbcValue} holding the converted value and the appropriate JDBC type information.
+	 */
+	private JdbcValue convertSimple(RelationalPersistentProperty property, Object value) {
+
+		return converter.writeJdbcValue( //
+				value, //
+				converter.getColumnType(property), //
+				converter.getSqlType(property) //
+		);
+	}
+
 	private Condition mapEmbeddedObjectCondition(CriteriaDefinition criteria, MapSqlParameterSource parameterSource,
 			Table table, RelationalPersistentProperty embeddedProperty) {
 
@@ -740,11 +830,6 @@ public TypeInformation<?> getTypeHint() {
 				return this.property.getTypeInformation();
 			}
 
-			if (this.property.getType().isInterface()
-					|| (java.lang.reflect.Modifier.isAbstract(this.property.getType().getModifiers()))) {
-				return ClassTypeInformation.OBJECT;
-			}
-
 			return this.property.getTypeInformation();
 		}
 

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/AggregateReferenceConvertersUnitTests.java

@@ -46,7 +46,8 @@ void setUp() {
 	@Test // GH-992
 	void convertsFromSimpleValue() {
 
-		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class, String.class, Integer.class);
+		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class,
+				String.class, Integer.class);
 		Object converted = conversionService.convert(23, TypeDescriptor.forObject(23),
 				new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
 
@@ -56,7 +57,8 @@ void convertsFromSimpleValue() {
 	@Test // GH-992
 	void convertsFromSimpleValueThatNeedsSeparateConversion() {
 
-		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class, String.class, Long.class);
+		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class,
+				String.class, Long.class);
 		Object converted = conversionService.convert(23, TypeDescriptor.forObject(23),
 				new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
 

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/JdbcRepositoryIntegrationTests.java

@@ -50,6 +50,7 @@
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
+import org.springframework.data.jdbc.core.mapping.AggregateReference;
 import org.springframework.data.jdbc.repository.query.Modifying;
 import org.springframework.data.jdbc.repository.query.Query;
 import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
@@ -514,6 +515,32 @@ void derivedQueryWithBooleanLiteralFindsCorrectValues() {
 		assertThat(result).extracting(e -> e.idProp).containsExactly(entity.idProp);
 	}
 
+	@Test // #987
+	void queryBySimpleReference() {
+
+		final DummyEntity one = repository.save(createDummyEntity());
+		DummyEntity two = createDummyEntity();
+		two.ref = AggregateReference.to(one.idProp);
+		two = repository.save(two);
+
+		List<DummyEntity> result = repository.findByRef(one.idProp.intValue());
+
+		assertThat(result).extracting(e -> e.idProp).containsExactly(two.idProp);
+	}
+
+	@Test // #987
+	void queryByAggregateReference() {
+
+		final DummyEntity one = repository.save(createDummyEntity());
+		DummyEntity two = createDummyEntity();
+		two.ref = AggregateReference.to(one.idProp);
+		two = repository.save(two);
+
+		List<DummyEntity> result = repository.findByRef(two.ref);
+
+		assertThat(result).extracting(e -> e.idProp).containsExactly(two.idProp);
+	}
+
 	private Instant createDummyBeforeAndAfterNow() {
 
 		Instant now = Instant.now();
@@ -585,6 +612,9 @@ interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {
 		void updateWithIntervalCalculation(@Param("id") Long id, @Param("start") LocalDateTime start);
 
 		List<DummyEntity> findByFlagTrue();
+
+		List<DummyEntity> findByRef(int ref);
+		List<DummyEntity> findByRef(AggregateReference<DummyEntity, Long> ref);
 	}
 
 	@Configuration
@@ -637,6 +667,7 @@ static class DummyEntity {
 		OffsetDateTime offsetDateTime;
 		@Id private Long idProp;
 		boolean flag;
+		AggregateReference<DummyEntity, Long> ref;
 
 		public DummyEntity(String name) {
 			this.name = name;