DATAJDBC-326 - Support conversion of backreferences.

Ids used as backreferences now get properly converted.

Introduced Identifier to hold information about data that needs to be considered for inserts or updates but is not part of the entity.
Apart from column names and values they also hold information about the desired JdbcType in order to facilitate conversions.
This replaces the Map handed around in the past.

Original pull request: #118.

Author: schauder

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

@@ -21,6 +21,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import org.springframework.data.relational.domain.Identifier;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
 
@@ -47,6 +48,15 @@ public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> ad
 		return collect(das -> das.insert(instance, domainType, additionalParameters));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, org.springframework.data.jdbc.core.ParentKeys)
+	 */
+	@Override
+	public <T> Object insert(T instance, Class<T> domainType, Identifier identifier) {
+		return collect(das -> das.insert(instance, domainType, identifier));
+	}
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#update(java.lang.Object, java.lang.Class)
@@ -149,7 +159,7 @@ public <T> boolean existsById(Object id, Class<T> domainType) {
 	private <T> T collect(Function<DataAccessStrategy, T> function) {
 
 		// Keep <T> as Eclipse fails to compile if <> is used.
-		return strategies.stream().collect(new FunctionCollector<T>(function));
+		return strategies.stream().collect(new FunctionCollector<>(function));
 	}
 
 	private void collectVoid(Consumer<DataAccessStrategy> consumer) {

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

@@ -17,6 +17,7 @@
 
 import java.util.Map;
 
+import org.springframework.data.relational.domain.Identifier;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
 import org.springframework.lang.Nullable;
@@ -39,9 +40,27 @@ public interface DataAccessStrategy {
 	 *          to get referenced are contained in this map. Must not be {@code null}.
 	 * @param <T> the type of the instance.
 	 * @return the id generated by the database if any.
+	 *
+	 * @deprecated use {@link #insert(Object, Class, Identifier)} instead.
 	 */
+	@Deprecated
 	<T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters);
 
+
+	/**
+	 * Inserts a the data of a single entity. Referenced entities don't get handled.
+	 *
+	 * @param instance the instance to be stored. Must not be {@code null}.
+	 * @param domainType the type of the instance. Must not be {@code null}.
+	 * @param identifier information about data that needs to be considered for the insert but which is not part of the  entity.
+	 *                   Namely references back to a parent entity and key/index columns for entities that are stored in a {@link Map} or {@link java.util.List}.
+	 * @param <T> the type of the instance.
+	 * @return the id generated by the database if any.
+	 */
+	default <T> Object insert(T instance, Class<T> domainType, Identifier identifier){
+		return insert(instance, domainType, identifier.getParametersByName());
+	}
+
 	/**
 	 * Updates the data of a single entity in the database. Referenced entities don't get handled.
 	 *

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

@@ -29,6 +29,7 @@
 import org.springframework.dao.DataRetrievalFailureException;
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.data.jdbc.core.convert.JdbcIdentifierBuilder;
 import org.springframework.data.jdbc.support.JdbcUtil;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PersistentPropertyPath;
@@ -37,6 +38,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.domain.Identifier;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
@@ -87,10 +89,24 @@ public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, Relation
 	 */
 	@Override
 	public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters) {
+		return insert(instance, domainType, JdbcIdentifierBuilder.from(additionalParameters).build());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, java.util.Map)
+	 */
+	@Override
+	public <T> Object insert(T instance, Class<T> domainType, Identifier identifier) {
 
 		KeyHolder holder = new GeneratedKeyHolder();
 		RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
-		Map<String, Object> parameters = new LinkedHashMap<>(additionalParameters);
+
+		Map<String, Object> parameters = new LinkedHashMap<>();
+		identifier.forEach(identifierValue -> {
+			parameters.put(identifierValue.getName(),
+					converter.writeValue(identifierValue.getValue(), ClassTypeInformation.from(identifierValue.getTargetType())));
+		});
 
 		MapSqlParameterSource parameterSource = getPropertyMap(instance, persistentEntity, "");
 
@@ -282,7 +298,8 @@ public <T> boolean existsById(Object id, Class<T> domainType) {
 		return result;
 	}
 
-	private <S, T> MapSqlParameterSource getPropertyMap(final S instance, RelationalPersistentEntity<S> persistentEntity, String prefix) {
+	private <S, T> MapSqlParameterSource getPropertyMap(final S instance, RelationalPersistentEntity<S> persistentEntity,
+			String prefix) {
 
 		MapSqlParameterSource parameters = new MapSqlParameterSource();
 
@@ -294,23 +311,26 @@ private <S, T> MapSqlParameterSource getPropertyMap(final S instance, Relational
 				return;
 			}
 
-			if(property.isEmbedded()){
+			if (property.isEmbedded()) {
 
 				Object value = propertyAccessor.getProperty(property);
-				final RelationalPersistentEntity<?> embeddedEntity =  context.getPersistentEntity(property.getType());
-				final MapSqlParameterSource additionalParameters = getPropertyMap((T)value, (RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix());
+				final RelationalPersistentEntity<?> embeddedEntity = context.getPersistentEntity(property.getType());
+				final MapSqlParameterSource additionalParameters = getPropertyMap((T) value,
+						(RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix());
 				parameters.addValues(additionalParameters.getValues());
 			} else {
 
 				Object value = propertyAccessor.getProperty(property);
 				Object convertedValue = convertForWrite(property, value);
 
-				parameters.addValue(prefix + property.getColumnName(), convertedValue, JdbcUtil.sqlTypeFor(property.getColumnType()));
+				parameters.addValue(prefix + property.getColumnName(), convertedValue,
+						JdbcUtil.sqlTypeFor(property.getColumnType()));
 			}
 		});
 
 		return parameters;
 	}
+
 	@Nullable
 	private Object convertForWrite(RelationalPersistentProperty property, @Nullable Object value) {
 
@@ -327,9 +347,8 @@ private Object convertForWrite(RelationalPersistentProperty property, @Nullable
 
 		String typeName = JDBCType.valueOf(JdbcUtil.sqlTypeFor(componentType)).getName();
 
-		return operations.getJdbcOperations().execute(
-				(Connection c) -> c.createArrayOf(typeName, (Object[]) convertedValue)
-		);
+		return operations.getJdbcOperations()
+				.execute((Connection c) -> c.createArrayOf(typeName, (Object[]) convertedValue));
 	}
 
 	@SuppressWarnings("unchecked")
@@ -354,22 +373,22 @@ private static <S, ID> boolean isIdPropertyNullOrScalarZero(@Nullable ID idValue
 	@Nullable
 	private <S> Object getIdFromHolder(KeyHolder holder, RelationalPersistentEntity<S> persistentEntity) {
 
-        try {
-            // MySQL just returns one value with a special name
-            return holder.getKey();
-        } catch (DataRetrievalFailureException | InvalidDataAccessApiUsageException e) {
-            // Postgres returns a value for each column
+		try {
+			// MySQL just returns one value with a special name
+			return holder.getKey();
+		} catch (DataRetrievalFailureException | InvalidDataAccessApiUsageException e) {
+			// Postgres returns a value for each column
 			// MS SQL Server returns a value that might be null.
 
-            Map<String, Object> keys = holder.getKeys();
+			Map<String, Object> keys = holder.getKeys();
 
-            if (keys == null || persistentEntity.getIdProperty() == null) {
-                return null;
-            }
+			if (keys == null || persistentEntity.getIdProperty() == null) {
+				return null;
+			}
 
-            return keys.get(persistentEntity.getIdColumn());
-        }
-    }
+			return keys.get(persistentEntity.getIdColumn());
+		}
+	}
 
 	private EntityRowMapper<?> getEntityRowMapper(Class<?> domainType) {
 		return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, converter, accessStrategy);

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

@@ -18,9 +18,10 @@
 import lombok.RequiredArgsConstructor;
 
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 
+import org.springframework.data.jdbc.core.convert.JdbcIdentifierBuilder;
+import org.springframework.data.relational.domain.Identifier;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.conversion.DbAction;
 import org.springframework.data.relational.core.conversion.DbAction.Delete;
@@ -58,7 +59,7 @@ class DefaultJdbcInterpreter implements Interpreter {
 	@Override
 	public <T> void interpret(Insert<T> insert) {
 
-		Object id = accessStrategy.insert(insert.getEntity(), insert.getEntityType(), createAdditionalColumnValues(insert));
+		Object id = accessStrategy.insert(insert.getEntity(), insert.getEntityType(), getParentKeys(insert));
 
 		insert.setGeneratedId(id);
 	}
@@ -101,7 +102,7 @@ public <T> void interpret(Merge<T> merge) {
 
 		// temporary implementation
 		if (!accessStrategy.update(merge.getEntity(), merge.getEntityType())) {
-			accessStrategy.insert(merge.getEntity(), merge.getEntityType(), createAdditionalColumnValues(merge));
+			accessStrategy.insert(merge.getEntity(), merge.getEntityType(), getParentKeys(merge));
 		}
 	}
 
@@ -141,27 +142,21 @@ public <T> void interpret(DeleteAllRoot<T> deleteAllRoot) {
 		accessStrategy.deleteAll(deleteAllRoot.getEntityType());
 	}
 
-	private <T> Map<String, Object> createAdditionalColumnValues(DbAction.WithDependingOn<T> action) {
-
-		Map<String, Object> additionalColumnValues = new HashMap<>();
-		addDependingOnInformation(action, additionalColumnValues);
-		additionalColumnValues.putAll(action.getAdditionalValues());
-
-		return additionalColumnValues;
-	}
-
-	private <T> void addDependingOnInformation(DbAction.WithDependingOn<T> action,
-			Map<String, Object> additionalColumnValues) {
+	private <T> Identifier getParentKeys(DbAction.WithDependingOn<?> action) {
 
 		DbAction.WithEntity<?> dependingOn = action.getDependingOn();
 
 		RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(dependingOn.getEntityType());
 
-		String columnName = getColumnNameForReverseColumn(action);
+		Object id = getIdFromEntityDependingOn(dependingOn, persistentEntity);
+		JdbcIdentifierBuilder identifier = JdbcIdentifierBuilder //
+				.forBackReferences(action.getPropertyPath(), id);
 
-		Object identifier = getIdFromEntityDependingOn(dependingOn, persistentEntity);
+		for (Map.Entry<PersistentPropertyPath<RelationalPersistentProperty>, Object> qualifier : action.getQualifiers().entrySet()) {
+			identifier = identifier.withQualifier(qualifier.getKey(), qualifier.getValue());
+		}
 
-		additionalColumnValues.put(columnName, identifier);
+		return identifier.build();
 	}
 
 	@Nullable
@@ -182,9 +177,4 @@ private Object getIdFromEntityDependingOn(DbAction.WithEntity<?> dependingOn,
 		return persistentEntity.getIdentifierAccessor(entity).getIdentifier();
 	}
 
-	private String getColumnNameForReverseColumn(DbAction.WithPropertyPath<?> action) {
-
-		PersistentPropertyPath<RelationalPersistentProperty> path = action.getPropertyPath();
-		return path.getRequiredLeafProperty().getReverseColumnName();
-	}
 }

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

@@ -17,6 +17,7 @@
 
 import java.util.Map;
 
+import org.springframework.data.relational.domain.Identifier;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
 import org.springframework.util.Assert;
@@ -40,6 +41,15 @@ public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> ad
 		return delegate.insert(instance, domainType, additionalParameters);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, org.springframework.data.jdbc.core.ParentKeys)
+	 */
+	@Override
+	public <T> Object insert(T instance, Class<T> domainType, Identifier identifier) {
+		return delegate.insert(instance, domainType, identifier);
+	}
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#update(java.lang.Object, java.lang.Class)

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

@@ -20,17 +20,23 @@
 import org.springframework.core.convert.ConverterNotFoundException;
 import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.jdbc.core.mapping.AggregateReference;
+import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.relational.core.conversion.BasicRelationalConverter;
 import org.springframework.data.relational.core.conversion.RelationalConverter;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.relational.domain.Identifier;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.lang.Nullable;
 
 import java.sql.Array;
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 /**
  * {@link RelationalConverter} that uses a {@link MappingContext} to apply basic conversion of relational values to
@@ -122,4 +128,6 @@ public Object writeValue(@Nullable Object value, TypeInformation<?> type) {
 
 		return super.writeValue(value, type);
 	}
+
+
 }