DATAJDBC-359 - Support for arbitrary chains of entities with or without Id.

Introduced a `ReadingContext` in the `EntityRowMapper` to avoid passing the `ResultSet` and the `path` all over the place.

Added a dependency test to Spring Data Relational and fixed the test failure by moving the PersistentPropertyPathExtension to core.mapping.

Original pull request: #150.

Author: schauder

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

@@ -20,7 +20,6 @@
 import java.util.Collections;
 import java.util.Map;
 
-import org.springframework.data.jdbc.core.convert.JdbcIdentifierBuilder;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.conversion.DbAction;
 import org.springframework.data.relational.core.conversion.DbAction.Delete;
@@ -33,11 +32,12 @@
 import org.springframework.data.relational.core.conversion.DbAction.Update;
 import org.springframework.data.relational.core.conversion.DbAction.UpdateRoot;
 import org.springframework.data.relational.core.conversion.Interpreter;
+import org.springframework.data.relational.core.mapping.PersistentPropertyPathExtension;
 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.lang.Nullable;
+import org.springframework.util.Assert;
 
 /**
  * {@link Interpreter} for {@link DbAction}s using a {@link DataAccessStrategy} for performing actual database
@@ -144,38 +144,67 @@ public <T> void interpret(DeleteAllRoot<T> deleteAllRoot) {
 
 	private Identifier getParentKeys(DbAction.WithDependingOn<?> action) {
 
-		DbAction.WithEntity<?> dependingOn = action.getDependingOn();
+		Object id = getParentId(action);
 
-		RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(dependingOn.getEntityType());
-
-		Object id = getIdFromEntityDependingOn(dependingOn, persistentEntity);
 		JdbcIdentifierBuilder identifier = JdbcIdentifierBuilder //
-				.forBackReferences(action.getPropertyPath(), id);
+				.forBackReferences(new PersistentPropertyPathExtension(context, action.getPropertyPath()), id);
 
 		for (Map.Entry<PersistentPropertyPath<RelationalPersistentProperty>, Object> qualifier : action.getQualifiers()
 				.entrySet()) {
-			identifier = identifier.withQualifier(qualifier.getKey(), qualifier.getValue());
+			identifier = identifier.withQualifier(new PersistentPropertyPathExtension(context, qualifier.getKey()),
+					qualifier.getValue());
 		}
 
 		return identifier.build();
 	}
 
-	@Nullable
-	private Object getIdFromEntityDependingOn(DbAction.WithEntity<?> dependingOn,
-			RelationalPersistentEntity<?> persistentEntity) {
+	private Object getParentId(DbAction.WithDependingOn<?> action) {
+
+		PersistentPropertyPathExtension path = new PersistentPropertyPathExtension(context, action.getPropertyPath());
+		PersistentPropertyPathExtension idPath = path.getIdDefiningParentPath();
+
+		DbAction.WithEntity idOwningAction = getIdOwningAction(action, idPath);
+
+		return getIdFrom(idOwningAction);
+	}
+
+	@SuppressWarnings("unchecked")
+	private DbAction.WithEntity getIdOwningAction(DbAction.WithEntity action, PersistentPropertyPathExtension idPath) {
+
+		if (!(action instanceof DbAction.WithDependingOn)) {
+
+			Assert.state(idPath.getLength() == 0,
+					"When the id path is not empty the id providing action should be of type WithDependingOn");
+
+			return action;
+		}
+
+		DbAction.WithDependingOn withDependingOn = (DbAction.WithDependingOn) action;
 
-		Object entity = dependingOn.getEntity();
+		if (idPath.matches(withDependingOn.getPropertyPath())) {
+			return action;
+		}
+
+		return getIdOwningAction(withDependingOn.getDependingOn(), idPath);
+	}
 
-		if (dependingOn instanceof DbAction.WithGeneratedId) {
+	private Object getIdFrom(DbAction.WithEntity idOwningAction) {
 
-			Object generatedId = ((DbAction.WithGeneratedId<?>) dependingOn).getGeneratedId();
+		if (idOwningAction instanceof DbAction.WithGeneratedId) {
+
+			Object generatedId = ((DbAction.WithGeneratedId<?>) idOwningAction).getGeneratedId();
 
 			if (generatedId != null) {
 				return generatedId;
 			}
 		}
 
-		return persistentEntity.getIdentifierAccessor(entity).getIdentifier();
-	}
+		RelationalPersistentEntity<?> persistentEntity = context
+				.getRequiredPersistentEntity(idOwningAction.getEntityType());
+		Object identifier = persistentEntity.getIdentifierAccessor(idOwningAction.getEntity()).getIdentifier();
 
+		Assert.state(identifier != null, "Couldn't get obtain a required id value");
+
+		return identifier;
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 the original author or authors.
+ * Copyright 2019 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.
@@ -15,209 +15,20 @@
  */
 package org.springframework.data.jdbc.core;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Map;
-
-import org.springframework.core.convert.converter.Converter;
-import org.springframework.data.mapping.MappingException;
-import org.springframework.data.mapping.PersistentEntity;
-import org.springframework.data.mapping.PersistentPropertyAccessor;
-import org.springframework.data.mapping.PreferredConstructor;
-import org.springframework.data.relational.core.conversion.RelationalConverter;
-import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.jdbc.core.convert.JdbcConverter;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
-import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
-import org.springframework.jdbc.core.RowMapper;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
 
 /**
- * Maps a {@link ResultSet} to an entity of type {@code T}, including entities referenced. This {@link RowMapper} might
- * trigger additional SQL statements in order to load other members of the same aggregate.
- *
  * @author Jens Schauder
- * @author Oliver Gierke
- * @author Mark Paluch
- * @author Maciej Walkowiak
- * @author Bastian Wilhelm
+ *
+ * @deprecated Use {@link org.springframework.data.jdbc.core.convert.EntityRowMapper} instead.
  */
-public class EntityRowMapper<T> implements RowMapper<T> {
-
-	private static final Converter<Iterable<?>, Map<?, ?>> ITERABLE_OF_ENTRY_TO_MAP_CONVERTER = new IterableOfEntryToMapConverter();
-
-	private final RelationalPersistentEntity<T> entity;
-
-	private final RelationalConverter converter;
-	private final RelationalMappingContext context;
-	private final DataAccessStrategy accessStrategy;
-	private final RelationalPersistentProperty idProperty;
-
-	public EntityRowMapper(RelationalPersistentEntity<T> entity, RelationalMappingContext context,
-			RelationalConverter converter, DataAccessStrategy accessStrategy) {
-
-		this.entity = entity;
-		this.converter = converter;
-		this.context = context;
-		this.accessStrategy = accessStrategy;
-		this.idProperty = entity.getIdProperty();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.jdbc.core.RowMapper#mapRow(java.sql.ResultSet, int)
-	 */
-	@Override
-	public T mapRow(ResultSet resultSet, int rowNumber) {
-
-		String prefix = "";
-
-		RelationalPersistentProperty idProperty = entity.getIdProperty();
-
-		Object idValue = null;
-		if (idProperty != null) {
-			idValue = readFrom(resultSet, idProperty, prefix);
-		}
-
-		T result = createInstance(entity, resultSet, idValue, prefix);
-
-		return entity.requiresPropertyPopulation() //
-				? populateProperties(result, resultSet) //
-				: result;
-	}
-
-	private T populateProperties(T result, ResultSet resultSet) {
-
-		PersistentPropertyAccessor<T> propertyAccessor = converter.getPropertyAccessor(entity, result);
-
-		Object id = idProperty == null ? null : readFrom(resultSet, idProperty, "");
-
-		PreferredConstructor<T, RelationalPersistentProperty> persistenceConstructor = entity.getPersistenceConstructor();
-
-		for (RelationalPersistentProperty property : entity) {
-
-			if (persistenceConstructor != null && persistenceConstructor.isConstructorParameter(property)) {
-				continue;
-			}
-
-			propertyAccessor.setProperty(property, readOrLoadProperty(resultSet, id, property, ""));
-		}
-
-		return propertyAccessor.getBean();
-	}
-
-	@Nullable
-	private Object readOrLoadProperty(ResultSet resultSet, @Nullable Object id, RelationalPersistentProperty property,
-			String prefix) {
-
-		if (property.isCollectionLike() && property.isEntity() && id != null) {
-			return accessStrategy.findAllByProperty(id, property);
-		} else if (property.isMap() && id != null) {
-			return ITERABLE_OF_ENTRY_TO_MAP_CONVERTER.convert(accessStrategy.findAllByProperty(id, property));
-		} else if (property.isEmbedded()) {
-			return readEmbeddedEntityFrom(resultSet, id, property, prefix);
-		} else {
-			return readFrom(resultSet, property, prefix);
-		}
-	}
-
-	/**
-	 * Read a single value or a complete Entity from the {@link ResultSet} passed as an argument.
-	 *
-	 * @param resultSet the {@link ResultSet} to extract the value from. Must not be {@code null}.
-	 * @param property the {@link RelationalPersistentProperty} for which the value is intended. Must not be {@code null}.
-	 * @param prefix to be used for all column names accessed by this method. Must not be {@code null}.
-	 * @return the value read from the {@link ResultSet}. May be {@code null}.
-	 */
-	@Nullable
-	private Object readFrom(ResultSet resultSet, RelationalPersistentProperty property, String prefix) {
-
-		if (property.isEntity()) {
-			return readEntityFrom(resultSet, property, prefix);
-		}
+@Deprecated
+public class EntityRowMapper<T> extends org.springframework.data.jdbc.core.convert.EntityRowMapper<T> {
 
-		Object value = getObjectFromResultSet(resultSet, prefix + property.getColumnName());
-		return converter.readValue(value, property.getTypeInformation());
-
-	}
-
-	private Object readEmbeddedEntityFrom(ResultSet rs, @Nullable Object id, RelationalPersistentProperty property,
-			String prefix) {
-
-		String newPrefix = prefix + property.getEmbeddedPrefix();
-
-		RelationalPersistentEntity<?> entity = context.getRequiredPersistentEntity(property.getActualType());
-
-		Object instance = createInstance(entity, rs, null, newPrefix);
-
-		@SuppressWarnings("unchecked")
-		PersistentPropertyAccessor<?> accessor = converter.getPropertyAccessor((PersistentEntity<Object, ?>) entity,
-				instance);
-
-		for (RelationalPersistentProperty p : entity) {
-			accessor.setProperty(p, readOrLoadProperty(rs, id, p, newPrefix));
-		}
-
-		return instance;
-	}
-
-	@Nullable
-	private <S> S readEntityFrom(ResultSet rs, RelationalPersistentProperty property, String prefix) {
-
-		String newPrefix = prefix + property.getName() + "_";
-
-		@SuppressWarnings("unchecked")
-		RelationalPersistentEntity<S> entity = (RelationalPersistentEntity<S>) context
-				.getRequiredPersistentEntity(property.getActualType());
-
-		RelationalPersistentProperty idProperty = entity.getIdProperty();
-
-		Object idValue = null;
-
-		if (idProperty != null) {
-			idValue = readFrom(rs, idProperty, newPrefix);
-		}
-
-		if ((idProperty != null //
-				? idValue //
-				: getObjectFromResultSet(rs, newPrefix + property.getReverseColumnName()) //
-		) == null) {
-			return null;
-		}
-
-		S instance = createInstance(entity, rs, idValue, newPrefix);
-
-		PersistentPropertyAccessor<S> accessor = converter.getPropertyAccessor(entity, instance);
-
-		for (RelationalPersistentProperty p : entity) {
-			accessor.setProperty(p, readOrLoadProperty(rs, idValue, p, newPrefix));
-		}
-
-		return instance;
+	public EntityRowMapper(RelationalPersistentEntity<T> entity, JdbcConverter converter,
+			DataAccessStrategy accessStrategy) {
+		super(entity, converter, accessStrategy);
 	}
 
-	@Nullable
-	private Object getObjectFromResultSet(ResultSet rs, String backreferenceName) {
-
-		try {
-			return rs.getObject(backreferenceName);
-		} catch (SQLException o_O) {
-			throw new MappingException(String.format("Could not read value %s from result set!", backreferenceName), o_O);
-		}
-	}
-
-	private <S> S createInstance(RelationalPersistentEntity<S> entity, ResultSet rs, @Nullable Object idValue,
-			String prefix) {
-
-		return converter.createInstance(entity, parameter -> {
-
-			String parameterName = parameter.getName();
-
-			Assert.notNull(parameterName, "A constructor parameter name must not be null to be used with Spring Data JDBC");
-
-			RelationalPersistentProperty property = entity.getRequiredPersistentProperty(parameterName);
-
-			return readOrLoadProperty(rs, idValue, property, prefix);
-		});
-	}
 }