DATAJDBC-282 - Polishing.

Formatting.
Removed AbstractRelationalEntityWriter.
Fixed integration test for MS-SQL.
Extracted some common test infrastructure.

Original pull request: #107.

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

@@ -21,6 +21,7 @@ import org.springframework.lang.Nullable;
  * Specifies a operations one can perform on a database, based on an <em>Domain Type</em>.
  *
  * @author Jens Schauder
+ * @author Thomas Lang
  */
 public interface JdbcAggregateOperations {
 
@@ -34,7 +35,10 @@ public interface JdbcAggregateOperations {
 	<T> T save(T instance);
 
 	/**
-     * Dedicated insert function to do just the insert of an instance of an aggregate, including all the members of the aggregate.
+	 * Dedicated insert function. This skips the test if the aggregate root is new and makes an insert.
+	 * <p>
+	 * This is useful if the client provides an id for new aggregate roots.
+	 * </p>
 	 * 
 	 * @param instance the aggregate root of the aggregate to be inserted. Must not be {@code null}.
 	 * @param <T> the type of the aggregate root.
@@ -43,7 +47,8 @@ public interface JdbcAggregateOperations {
 	<T> T insert(T instance);
 
 	/**
-     * Dedicated update function to do just an update of an instance of an aggregate, including all the members of the aggregate.
+	 * Dedicated update function. This skips the test if the aggregate root is new or not and always performs an update
+	 * operation.
 	 *
 	 * @param instance the aggregate root of the aggregate to be inserted. Must not be {@code null}.
 	 * @param <T> the type of the aggregate root.

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

@@ -44,6 +44,7 @@ import org.springframework.util.Assert;
  *
  * @author Jens Schauder
  * @author Mark Paluch
+ * @author Thomas Lang
  */
 public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 
@@ -59,30 +60,6 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 
 	private final DataAccessStrategy accessStrategy;
 
-	private <T> T store(T instance, IdentifierAccessor identifierAccessor, AggregateChange<T> change,
-			RelationalPersistentEntity<?> persistentEntity) {
-		Assert.notNull(instance, "Aggregate instance must not be null!");
-		publisher.publishEvent(new BeforeSaveEvent( //
-				Identifier.ofNullable(identifierAccessor.getIdentifier()), //
-				instance, //
-				change //
-		));
-
-		change.executeWith(interpreter, context, converter);
-
-		Object identifier = persistentEntity.getIdentifierAccessor(change.getEntity()).getIdentifier();
-
-		Assert.notNull(identifier, "After saving the identifier must not be null");
-
-		publisher.publishEvent(new AfterSaveEvent( //
-				Identifier.of(identifier), //
-				change.getEntity(), //
-				change //
-		));
-
-		return (T) change.getEntity();
-	}
-
 	/**
 	 * Creates a new {@link JdbcAggregateTemplate} given {@link ApplicationEventPublisher},
 	 * {@link RelationalMappingContext} and {@link DataAccessStrategy}.
@@ -115,7 +92,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#save(java.lang.Object)
 	 */
-	@Override public <T> T save(T instance) {
+	@Override
+	public <T> T save(T instance) {
 
 		Assert.notNull(instance, "Aggregate instance must not be null!");
 
@@ -128,12 +106,15 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	}
 
 	/**
-	 * Dedicated insert function to do just the insert of an instance of an aggregate, including all the members of the aggregate.
+	 * Dedicated insert function to do just the insert of an instance of an aggregate, including all the members of the
+	 * aggregate.
 	 *
 	 * @param instance the aggregate root of the aggregate to be inserted. Must not be {@code null}.
 	 * @return the saved instance.
 	 */
-	@Override public <T> T insert(T instance) {
+	@Override
+	public <T> T insert(T instance) {
+
 		Assert.notNull(instance, "Aggregate instance must not be null!");
 
 		RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(instance.getClass());
@@ -145,12 +126,15 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	}
 
 	/**
-	 * Dedicated update function to do just an update of an instance of an aggregate, including all the members of the aggregate.
+	 * Dedicated update function to do just an update of an instance of an aggregate, including all the members of the
+	 * aggregate.
 	 *
 	 * @param instance the aggregate root of the aggregate to be inserted. Must not be {@code null}.
 	 * @return the saved instance.
 	 */
-	@Override public <T> T update(T instance) {
+	@Override
+	public <T> T update(T instance) {
+
 		Assert.notNull(instance, "Aggregate instance must not be null!");
 
 		RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(instance.getClass());
@@ -165,7 +149,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#count(java.lang.Class)
 	 */
-	@Override public long count(Class<?> domainType) {
+	@Override
+	public long count(Class<?> domainType) {
 		return accessStrategy.count(domainType);
 	}
 
@@ -173,7 +158,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#findById(java.lang.Object, java.lang.Class)
 	 */
-	@Override public <T> T findById(Object id, Class<T> domainType) {
+	@Override
+	public <T> T findById(Object id, Class<T> domainType) {
 
 		T entity = accessStrategy.findById(id, domainType);
 		if (entity != null) {
@@ -186,7 +172,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#existsById(java.lang.Object, java.lang.Class)
 	 */
-	@Override public <T> boolean existsById(Object id, Class<T> domainType) {
+	@Override
+	public <T> boolean existsById(Object id, Class<T> domainType) {
 		return accessStrategy.existsById(id, domainType);
 	}
 
@@ -194,7 +181,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#findAll(java.lang.Class)
 	 */
-	@Override public <T> Iterable<T> findAll(Class<T> domainType) {
+	@Override
+	public <T> Iterable<T> findAll(Class<T> domainType) {
 
 		Iterable<T> all = accessStrategy.findAll(domainType);
 		publishAfterLoad(all);
@@ -205,7 +193,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#findAllById(java.lang.Iterable, java.lang.Class)
 	 */
-	@Override public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
+	@Override
+	public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 
 		Iterable<T> allById = accessStrategy.findAllById(ids, domainType);
 		publishAfterLoad(allById);
@@ -216,7 +205,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#delete(java.lang.Object, java.lang.Class)
 	 */
-	@Override public <S> void delete(S aggregateRoot, Class<S> domainType) {
+	@Override
+	public <S> void delete(S aggregateRoot, Class<S> domainType) {
 
 		IdentifierAccessor identifierAccessor = context.getRequiredPersistentEntity(domainType)
 				.getIdentifierAccessor(aggregateRoot);
@@ -228,7 +218,8 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#deleteById(java.lang.Object, java.lang.Class)
 	 */
-	@Override public <S> void deleteById(Object id, Class<S> domainType) {
+	@Override
+	public <S> void deleteById(Object id, Class<S> domainType) {
 		deleteTree(id, null, domainType);
 	}
 
@@ -236,12 +227,39 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#deleteAll(java.lang.Class)
 	 */
-	@Override public void deleteAll(Class<?> domainType) {
+	@Override
+	public void deleteAll(Class<?> domainType) {
 
 		AggregateChange<?> change = createDeletingChange(domainType);
 		change.executeWith(interpreter, context, converter);
 	}
 
+	private <T> T store(T instance, IdentifierAccessor identifierAccessor, AggregateChange<T> change,
+			RelationalPersistentEntity<?> persistentEntity) {
+
+		Assert.notNull(instance, "Aggregate instance must not be null!");
+
+		publisher.publishEvent(new BeforeSaveEvent( //
+				Identifier.ofNullable(identifierAccessor.getIdentifier()), //
+				instance, //
+				change //
+		));
+
+		change.executeWith(interpreter, context, converter);
+
+		Object identifier = persistentEntity.getIdentifierAccessor(change.getEntity()).getIdentifier();
+
+		Assert.notNull(identifier, "After saving the identifier must not be null");
+
+		publisher.publishEvent(new AfterSaveEvent( //
+				Identifier.of(identifier), //
+				change.getEntity(), //
+				change //
+		));
+
+		return (T) change.getEntity();
+	}
+
 	private void deleteTree(Object id, @Nullable Object entity, Class<?> domainType) {
 
 		AggregateChange<?> change = createDeletingChange(id, entity, domainType);
@@ -255,21 +273,24 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 		publisher.publishEvent(new AfterDeleteEvent(specifiedId, optionalEntity, change));
 	}
 
-	@SuppressWarnings({ "unchecked", "rawtypes" }) private <T> AggregateChange<T> createChange(T instance) {
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private <T> AggregateChange<T> createChange(T instance) {
 
 		AggregateChange<T> aggregateChange = new AggregateChange(Kind.SAVE, instance.getClass(), instance);
 		jdbcEntityWriter.write(instance, aggregateChange);
 		return aggregateChange;
 	}
 
-	@SuppressWarnings({ "unchecked", "rawtypes" }) private <T> AggregateChange<T> createInsertChange(T instance) {
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private <T> AggregateChange<T> createInsertChange(T instance) {
 
 		AggregateChange<T> aggregateChange = new AggregateChange(Kind.SAVE, instance.getClass(), instance);
 		jdbcEntityInsertWriter.write(instance, aggregateChange);
 		return aggregateChange;
 	}
 
-	@SuppressWarnings({ "unchecked", "rawtypes" }) private <T> AggregateChange<T> createUpdateChange(T instance) {
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private <T> AggregateChange<T> createUpdateChange(T instance) {
 
 		AggregateChange<T> aggregateChange = new AggregateChange(Kind.SAVE, instance.getClass(), instance);
 		jdbcEntityUpdateWriter.write(instance, aggregateChange);

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

@@ -3,16 +3,36 @@ package org.springframework.data.jdbc.core;
 import org.springframework.data.repository.Repository;
 
 /**
- * Jdbc repository for dedicated insert(), update() and upsert() sql functions.
+ * Jdbc repository for dedicated insert(), update() and upsert() sql functions. Other than
- * Other than {@link org.springframework.data.jdbc.repository.support.SimpleJdbcRepository}
+ * {@link org.springframework.data.jdbc.repository.support.SimpleJdbcRepository} there should be bypassing of the isNew
- * there should be bypassing of the isNew check.
+ * check.
  *
  * @author Thomas Lang
- * @see <a href="https://jira.spring.io/browse/DATAJDBC-282">DATAJDBC-282</a>
+ * @since 1.1
  */
 public interface JdbcRepository<T, ID> extends Repository<T, ID> {
 
-    <S extends T> S insert(S var1);
+	/**
+	 * Dedicated insert function. This skips the test if the aggregate root is new and makes an insert.
+	 * <p>
+	 * This is useful if the client provides an id for new aggregate roots.
+	 * </p>
+	 *
+	 * @param aggregateRoot the aggregate root to be saved in the database. Must not be {@code null}.
+	 * @param <S> Type of the aggregate root.
+	 * @return the saved aggregate root. If the provided aggregate root was immutable and a value needed changing, e.g.
+	 *         the id this will be a new instance.
+	 */
+	<S extends T> S insert(S aggregateRoot);
 
-    <S extends T> S update(S var1);
+	/**
+	 * Dedicated update function. This skips the test if the aggregate root is new or not and always performs an update
+	 * operation.
+	 * 
+	 * @param aggregateRoot the aggregate root to be saved in the database. Must not be {@code null}.
+	 * @param <S> Type of the aggregate root.
+	 * @return the saved aggregate root. If the provided aggregate root was immutable and a value needed changing, e.g.
+	 *         the id this will be a new instance.
+	 */
+	<S extends T> S update(S aggregateRoot);
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/SimpleJdbcRepository.java

@@ -152,7 +152,7 @@ public class SimpleJdbcRepository<T, ID> implements CrudRepository<T, ID>, JdbcR
      * @see org.springframework.data.repository.JdbcRepository#update(T t)
      */
     @Override
-    public <S extends T> S update(S var1) {
+    public <S extends T> S update(S aggregateRoot) {
-        return entityOperations.update(var1);
+        return entityOperations.update(aggregateRoot);
     }
 }

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/JdbcRepositoryInsertExistingIntegrationTests.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2017-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.
+ * You may obtain a copy of the License at
+ *
+ *      http://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.jdbc.repository;
+
+import static org.assertj.core.api.Assertions.*;
+
+import lombok.Data;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.jdbc.core.JdbcRepository;
+import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
+import org.springframework.data.jdbc.testing.TestConfiguration;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.rules.SpringClassRule;
+import org.springframework.test.context.junit4.rules.SpringMethodRule;
+import org.springframework.test.jdbc.JdbcTestUtils;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Very simple use cases for creation and usage of JdbcRepositories.
+ *
+ * @author Jens Schauder
+ */
+@ContextConfiguration
+@Transactional
+public class JdbcRepositoryInsertExistingIntegrationTests {
+
+	@Configuration
+	@Import(TestConfiguration.class)
+	static class Config {
+
+		@Autowired JdbcRepositoryFactory factory;
+
+		@Bean
+		Class<?> testClass() {
+			return JdbcRepositoryInsertExistingIntegrationTests.class;
+		}
+
+		@Bean
+		DummyEntityRepository dummyEntityRepository() {
+			return factory.getRepository(DummyEntityRepository.class);
+		}
+
+	}
+
+	@ClassRule public static final SpringClassRule classRule = new SpringClassRule();
+	@Rule public SpringMethodRule methodRule = new SpringMethodRule();
+
+	@Autowired NamedParameterJdbcTemplate template;
+	@Autowired DummyEntityRepository repository;
+
+	@Test // DATAJDBC-282
+	public void insertAnExistingEntity() {
+
+		DummyEntity existingDummyEntity = createDummyEntity();
+		existingDummyEntity.idProp = 123L;
+
+		DummyEntity entity = repository.insert(existingDummyEntity);
+
+		assertThat(JdbcTestUtils.countRowsInTableWhere((JdbcTemplate) template.getJdbcOperations(), "dummy_entity",
+				"id_Prop = " + existingDummyEntity.getIdProp())).isEqualTo(1);
+	}
+
+	private static DummyEntity createDummyEntity() {
+
+		DummyEntity entity = new DummyEntity();
+		entity.setName("Entity Name");
+		return entity;
+	}
+
+	interface DummyEntityRepository extends CrudRepository<DummyEntity, Long>, JdbcRepository<DummyEntity, Long> {}
+
+	@Data
+	static class DummyEntity {
+
+		String name;
+		@Id private Long idProp;
+	}
+}

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

@@ -40,6 +40,8 @@ import org.springframework.test.context.junit4.rules.SpringMethodRule;
 import org.springframework.test.jdbc.JdbcTestUtils;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.HashMap;
+
 /**
  * Very simple use cases for creation and usage of JdbcRepositories.
  *
@@ -53,8 +55,7 @@ public class JdbcRepositoryIntegrationTests {
 	@Import(TestConfiguration.class)
 	static class Config {
 
-        @Autowired
+		@Autowired JdbcRepositoryFactory factory;
-        JdbcRepositoryFactory factory;
 
 		@Bean
 		Class<?> testClass() {
@@ -68,15 +69,11 @@ public class JdbcRepositoryIntegrationTests {
 
 	}
 
-    @ClassRule
+	@ClassRule public static final SpringClassRule classRule = new SpringClassRule();
-    public static final SpringClassRule classRule = new SpringClassRule();
+	@Rule public SpringMethodRule methodRule = new SpringMethodRule();
-    @Rule
-    public SpringMethodRule methodRule = new SpringMethodRule();
 
-    @Autowired
+	@Autowired NamedParameterJdbcTemplate template;
-    NamedParameterJdbcTemplate template;
+	@Autowired DummyEntityRepository repository;
-    @Autowired
-    DummyEntityRepository repository;
 
 	@Test // DATAJDBC-95
 	public void savesAnEntity() {
@@ -96,15 +93,6 @@ public class JdbcRepositoryIntegrationTests {
 				"id_Prop = " + entity.getIdProp())).isEqualTo(1);
 	}
 
-    @Test // DATAJDBC-282
-    public void insertAnExistingEntity() {
-
-        DummyEntity existingDummyEntity = createExistingDummyEntity();
-        DummyEntity entity = repository.insert(existingDummyEntity);
-        assertThat(JdbcTestUtils.countRowsInTableWhere((JdbcTemplate) template.getJdbcOperations(), "dummy_entity",
-                "id_Prop = " + existingDummyEntity.getIdProp())).isEqualTo(1);
-    }
-
 	@Test // DATAJDBC-95
 	public void saveAndLoadAnEntity() {
 
@@ -273,22 +261,12 @@ public class JdbcRepositoryIntegrationTests {
 		return entity;
 	}
 
-    private static DummyEntity createExistingDummyEntity() {
+	interface DummyEntityRepository extends CrudRepository<DummyEntity, Long>, JdbcRepository<DummyEntity, Long> {}
-
-        DummyEntity entity = new DummyEntity();
-        entity.setIdProp(Long.parseLong("123"));
-        entity.setName("Entity Name");
-        return entity;
-    }
-
-    interface DummyEntityRepository extends CrudRepository<DummyEntity, Long>, JdbcRepository<DummyEntity, Long> {
-    }
 
 	@Data
 	static class DummyEntity {
 
 		String name;
-        @Id
+		@Id private Long idProp;
-        private Long idProp;
 	}
 }

spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.repository/JdbcRepositoryInsertExistingIntegrationTests-hsql.sql

@@ -0,0 +1 @@
+CREATE TABLE dummy_entity ( id_Prop BIGINT PRIMARY KEY, NAME VARCHAR(100))

spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.repository/JdbcRepositoryInsertExistingIntegrationTests-mariadb.sql

@@ -0,0 +1 @@
+CREATE TABLE dummy_entity (id_Prop BIGINT PRIMARY KEY, NAME VARCHAR(100));

spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.repository/JdbcRepositoryInsertExistingIntegrationTests-mssql.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS dummy_entity;
+CREATE TABLE dummy_entity (id_Prop BIGINT PRIMARY KEY, NAME VARCHAR(100));

spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.repository/JdbcRepositoryInsertExistingIntegrationTests-mysql.sql

@@ -0,0 +1 @@
+CREATE TABLE dummy_entity (id_Prop BIGINT PRIMARY KEY, NAME VARCHAR(100));

spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.repository/JdbcRepositoryInsertExistingIntegrationTests-postgres.sql

@@ -0,0 +1,2 @@
+DROP TABLE dummy_entity;
+CREATE TABLE dummy_entity (id_Prop INTEGER PRIMARY KEY, NAME VARCHAR(100));

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/AbstractRelationalEntityWriter.java

@@ -1,274 +0,0 @@
-package org.springframework.data.relational.core.conversion;
-
-import lombok.Value;
-import org.springframework.data.convert.EntityWriter;
-import org.springframework.data.mapping.PersistentProperty;
-import org.springframework.data.mapping.PersistentPropertyPath;
-import org.springframework.data.mapping.PersistentPropertyPaths;
-import org.springframework.data.relational.core.mapping.RelationalMappingContext;
-import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
-import org.springframework.data.util.Pair;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Used as an abstract class to derive relational writer actions (save, insert, update).
- * Implementations see {@link RelationalEntityWriter} and {@link RelationalEntityInsertWriter}
- *
- * @author Thomas Lang
- */
-abstract class AbstractRelationalEntityWriter implements EntityWriter<Object, AggregateChange<?>> {
-
-    protected final RelationalMappingContext context;
-
-    AbstractRelationalEntityWriter(RelationalMappingContext context) {
-        this.context = context;
-    }
-
-    /**
-     * Holds context information for the current save operation.
-     */
-    class WritingContext {
-
-        private final Object root;
-        private final Object entity;
-        private final Class<?> entityType;
-        private final PersistentPropertyPaths<?, RelationalPersistentProperty> paths;
-        private final Map<PathNode, DbAction> previousActions = new HashMap<>();
-        private Map<PersistentPropertyPath<RelationalPersistentProperty>, List<PathNode>> nodesCache = new HashMap<>();
-
-        WritingContext(Object root, AggregateChange<?> aggregateChange) {
-
-            this.root = root;
-            this.entity = aggregateChange.getEntity();
-            this.entityType = aggregateChange.getEntityType();
-            this.paths = context.findPersistentPropertyPaths(entityType, PersistentProperty::isEntity);
-        }
-
-        /**
-         * Leaves out the isNew check as defined in #DATAJDBC-282
-         *
-         * @return List of {@link DbAction}s
-         * @see <a href="https://jira.spring.io/browse/DATAJDBC-282">DAJDBC-282</a>
-         */
-        List<DbAction<?>> insert() {
-
-            List<DbAction<?>> actions = new ArrayList<>();
-            actions.add(setRootAction(new DbAction.InsertRoot<>(entity)));
-            actions.addAll(insertReferenced());
-            return actions;
-        }
-
-        /**
-         * Leaves out the isNew check as defined in #DATAJDBC-282
-         *
-         * @return List of {@link DbAction}s
-         * @see <a href="https://jira.spring.io/browse/DATAJDBC-282">DAJDBC-282</a>
-         */
-        List<DbAction<?>> update() {
-
-            List<DbAction<?>> actions = new ArrayList<>(deleteReferenced());
-            actions.add(setRootAction(new DbAction.UpdateRoot<>(entity)));
-            actions.addAll(insertReferenced());
-            return actions;
-        }
-
-        List<DbAction<?>> save() {
-
-            List<DbAction<?>> actions = new ArrayList<>();
-            if (isNew(root)) {
-
-                actions.add(setRootAction(new DbAction.InsertRoot<>(entity)));
-                actions.addAll(insertReferenced());
-            } else {
-
-                actions.addAll(deleteReferenced());
-                actions.add(setRootAction(new DbAction.UpdateRoot<>(entity)));
-                actions.addAll(insertReferenced());
-            }
-
-            return actions;
-        }
-
-        private boolean isNew(Object o) {
-            return context.getRequiredPersistentEntity(o.getClass()).isNew(o);
-        }
-
-        //// Operations on all paths
-
-        private List<DbAction<?>> insertReferenced() {
-
-            List<DbAction<?>> actions = new ArrayList<>();
-
-            paths.forEach(path -> actions.addAll(insertAll(path)));
-
-            return actions;
-        }
-
-        private List<DbAction<?>> insertAll(PersistentPropertyPath<RelationalPersistentProperty> path) {
-
-            List<DbAction<?>> actions = new ArrayList<>();
-
-            from(path).forEach(node -> {
-
-                DbAction.Insert<Object> insert;
-                if (node.path.getRequiredLeafProperty().isQualified()) {
-
-                    Pair<Object, Object> value = (Pair) node.getValue();
-                    insert = new DbAction.Insert<>(value.getSecond(), path, getAction(node.parent));
-                    insert.getAdditionalValues().put(node.path.getRequiredLeafProperty().getKeyColumn(), value.getFirst());
-
-                } else {
-                    insert = new DbAction.Insert<>(node.getValue(), path, getAction(node.parent));
-                }
-
-                previousActions.put(node, insert);
-                actions.add(insert);
-            });
-
-            return actions;
-        }
-
-        private List<DbAction<?>> deleteReferenced() {
-
-            List<DbAction<?>> deletes = new ArrayList<>();
-            paths.forEach(path -> deletes.add(0, deleteReferenced(path)));
-
-            return deletes;
-        }
-
-        /// Operations on a single path
-
-        private DbAction.Delete<?> deleteReferenced(PersistentPropertyPath<RelationalPersistentProperty> path) {
-
-            Object id = context.getRequiredPersistentEntity(entityType).getIdentifierAccessor(entity).getIdentifier();
-
-            return new DbAction.Delete<>(id, path);
-        }
-
-        //// methods not directly related to the creation of DbActions
-
-        private DbAction<?> setRootAction(DbAction<?> dbAction) {
-
-            previousActions.put(null, dbAction);
-            return dbAction;
-        }
-
-        @Nullable
-        private DbAction.WithEntity<?> getAction(@Nullable RelationalEntityInsertWriter.PathNode parent) {
-
-            DbAction action = previousActions.get(parent);
-
-            if (action != null) {
-
-                Assert.isInstanceOf( //
-                        DbAction.WithEntity.class, //
-                        action, //
-                        "dependsOn action is not a WithEntity, but " + action.getClass().getSimpleName() //
-                );
-
-                return (DbAction.WithEntity<?>) action;
-            }
-
-            return null;
-        }
-        //        commented as of #DATAJDBC-282
-        //        private boolean isNew(Object o) {
-        //            return context.getRequiredPersistentEntity(o.getClass()).isNew(o);
-        //        }
-
-        private List<RelationalEntityInsertWriter.PathNode> from(
-                PersistentPropertyPath<RelationalPersistentProperty> path) {
-
-            List<RelationalEntityInsertWriter.PathNode> nodes = new ArrayList<>();
-
-            if (path.getLength() == 1) {
-
-                Object value = context //
-                        .getRequiredPersistentEntity(entityType) //
-                        .getPropertyAccessor(entity) //
-                        .getProperty(path.getRequiredLeafProperty());
-
-                nodes.addAll(createNodes(path, null, value));
-
-            } else {
-
-                List<RelationalEntityInsertWriter.PathNode> pathNodes = nodesCache.get(path.getParentPath());
-                pathNodes.forEach(parentNode -> {
-
-                    Object value = path.getRequiredLeafProperty().getOwner().getPropertyAccessor(parentNode.getValue())
-                            .getProperty(path.getRequiredLeafProperty());
-
-                    nodes.addAll(createNodes(path, parentNode, value));
-                });
-            }
-
-            nodesCache.put(path, nodes);
-
-            return nodes;
-        }
-
-        private List<RelationalEntityInsertWriter.PathNode> createNodes(
-                PersistentPropertyPath<RelationalPersistentProperty> path,
-                @Nullable RelationalEntityInsertWriter.PathNode parentNode, @Nullable Object value) {
-
-            if (value == null) {
-                return Collections.emptyList();
-            }
-
-            List<RelationalEntityInsertWriter.PathNode> nodes = new ArrayList<>();
-
-            if (path.getRequiredLeafProperty().isQualified()) {
-
-                if (path.getRequiredLeafProperty().isMap()) {
-                    ((Map<?, ?>) value)
-                            .forEach((k, v) -> nodes.add(new RelationalEntityInsertWriter.PathNode(path, parentNode, Pair.of(k, v))));
-                } else {
-
-                    List listValue = (List) value;
-                    for (int k = 0; k < listValue.size(); k++) {
-                        nodes.add(new RelationalEntityInsertWriter.PathNode(path, parentNode, Pair.of(k, listValue.get(k))));
-                    }
-                }
-            } else if (path.getRequiredLeafProperty().isCollectionLike()) { // collection value
-                ((Collection<?>) value).forEach(v -> nodes.add(new RelationalEntityInsertWriter.PathNode(path, parentNode, v)));
-            } else { // single entity value
-                nodes.add(new RelationalEntityInsertWriter.PathNode(path, parentNode, value));
-            }
-
-            return nodes;
-        }
-
-    }
-
-    /**
-     * Represents a single entity in an aggregate along with its property path from the root entity and the chain of
-     * objects to traverse a long this path.
-     */
-    @Value
-    static class PathNode {
-
-        /**
-         * The path to this entity
-         */
-        PersistentPropertyPath<RelationalPersistentProperty> path;
-
-        /**
-         * The parent {@link PathNode}. This is {@code null} if this is the root entity.
-         */
-        @Nullable
-        PathNode parent;
-
-        /**
-         * The value of the entity.
-         */
-        Object value;
-    }
-}

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/PathNode.java

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://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.conversion;
+
+import lombok.Value;
+import org.springframework.data.mapping.PersistentPropertyPath;
+import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.lang.Nullable;
+
+/**
+ * Represents a single entity in an aggregate along with its property path from the root entity and the chain of
+ * objects to traverse a long this path.
+ *
+ * @author Jens Schauder
+ */
+@Value
+class PathNode {
+
+	/**
+	 * The path to this entity
+	 */
+	PersistentPropertyPath<RelationalPersistentProperty> path;
+
+	/**
+	 * The parent {@link PathNode}. This is {@code null} if this is the root entity.
+	 */
+	@Nullable
+	PathNode parent;
+
+	/**
+	 * The value of the entity.
+	 */
+	Object value;
+}

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/RelationalEntityInsertWriter.java

@@ -15,30 +15,34 @@
  */
 package org.springframework.data.relational.core.conversion;
 
-import org.springframework.data.relational.core.mapping.RelationalMappingContext;
-
 import java.util.List;
 
+import org.springframework.data.convert.EntityWriter;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+
 /**
- * Converts an aggregate represented by its root into an {@link AggregateChange}.
+ * Converts an aggregate represented by its root into an {@link AggregateChange}. Does not perform any isNew check.
- * Does not perform any isNew check.
  *
- * @author Jens Schauder
- * @author Mark Paluch
  * @author Thomas Lang
+ * @author Jens Schauder
+ * @since 1.1
  */
-public class RelationalEntityInsertWriter extends AbstractRelationalEntityWriter {
+public class RelationalEntityInsertWriter implements EntityWriter<Object, AggregateChange<?>> {
+
+	private final RelationalMappingContext context;
 
 	public RelationalEntityInsertWriter(RelationalMappingContext context) {
-		super(context);
+		this.context = context;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.convert.EntityWriter#save(java.lang.Object, java.lang.Object)
 	 */
-	@Override public void write(Object root, AggregateChange<?> aggregateChange) {
+	@Override
-		List<DbAction<?>> actions = new WritingContext(root, aggregateChange).insert();
+	public void write(Object root, AggregateChange<?> aggregateChange) {
+
+		List<DbAction<?>> actions = new WritingContext(context, root, aggregateChange).insert();
 		actions.forEach(aggregateChange::addAction);
 	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/RelationalEntityUpdateWriter.java

@@ -15,30 +15,34 @@
  */
 package org.springframework.data.relational.core.conversion;
 
-import org.springframework.data.relational.core.mapping.RelationalMappingContext;
-
 import java.util.List;
 
+import org.springframework.data.convert.EntityWriter;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+
 /**
- * Converts an aggregate represented by its root into an {@link AggregateChange}.
+ * Converts an aggregate represented by its root into an {@link AggregateChange}. Does not perform any isNew check.
- * Does not perform any isNew check.
  *
- * @author Jens Schauder
- * @author Mark Paluch
  * @author Thomas Lang
+ * @author Jens Schauder
+ * @since 1.1
  */
-public class RelationalEntityUpdateWriter extends AbstractRelationalEntityWriter {
+public class RelationalEntityUpdateWriter implements EntityWriter<Object, AggregateChange<?>> {
+
+	private final RelationalMappingContext context;
 
 	public RelationalEntityUpdateWriter(RelationalMappingContext context) {
-		super(context);
+		this.context = context;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.convert.EntityWriter#save(java.lang.Object, java.lang.Object)
 	 */
-	@Override public void write(Object root, AggregateChange<?> aggregateChange) {
+	@Override
-		List<DbAction<?>> actions = new WritingContext(root, aggregateChange).update();
+	public void write(Object root, AggregateChange<?> aggregateChange) {
+
+		List<DbAction<?>> actions = new WritingContext(context, root, aggregateChange).update();
 		actions.forEach(aggregateChange::addAction);
 	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/RelationalEntityWriter.java

@@ -15,28 +15,33 @@
  */
 package org.springframework.data.relational.core.conversion;
 
-import org.springframework.data.relational.core.mapping.RelationalMappingContext;
-
 import java.util.List;
 
+import org.springframework.data.convert.EntityWriter;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+
 /**
  * Converts an aggregate represented by its root into an {@link AggregateChange}.
  *
  * @author Jens Schauder
  * @author Mark Paluch
  */
-public class RelationalEntityWriter extends AbstractRelationalEntityWriter {
+public class RelationalEntityWriter implements EntityWriter<Object, AggregateChange<?>> {
+
+	private final RelationalMappingContext context;
 
 	public RelationalEntityWriter(RelationalMappingContext context) {
-		super(context);
+		this.context = context;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.convert.EntityWriter#save(java.lang.Object, java.lang.Object)
 	 */
-	@Override public void write(Object root, AggregateChange<?> aggregateChange) {
+	@Override
-		List<DbAction<?>> actions = new WritingContext(root, aggregateChange).save();
+	public void write(Object root, AggregateChange<?> aggregateChange) {
+
+		List<DbAction<?>> actions = new WritingContext(context, root, aggregateChange).save();
 		actions.forEach(aggregateChange::addAction);
 	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/WritingContext.java

@@ -0,0 +1,252 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://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.conversion;
+
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.PersistentPropertyPath;
+import org.springframework.data.mapping.PersistentPropertyPaths;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.util.Pair;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Holds context information for the current save operation.
+ *
+ * @author Jens Schauder
+ */
+class WritingContext {
+
+	private final RelationalMappingContext context;
+	private final Object root;
+	private final Object entity;
+	private final Class<?> entityType;
+	private final PersistentPropertyPaths<?, RelationalPersistentProperty> paths;
+	private final Map<PathNode, DbAction> previousActions = new HashMap<>();
+	private Map<PersistentPropertyPath<RelationalPersistentProperty>, List<PathNode>> nodesCache = new HashMap<>();
+
+	WritingContext(RelationalMappingContext context, Object root, AggregateChange<?> aggregateChange) {
+
+		this.context = context;
+		this.root = root;
+		this.entity = aggregateChange.getEntity();
+		this.entityType = aggregateChange.getEntityType();
+		this.paths = context.findPersistentPropertyPaths(entityType, PersistentProperty::isEntity);
+	}
+
+	/**
+	 * Leaves out the isNew check as defined in #DATAJDBC-282
+	 *
+	 * @return List of {@link DbAction}s
+	 * @see <a href="https://jira.spring.io/browse/DATAJDBC-282">DAJDBC-282</a>
+	 */
+	List<DbAction<?>> insert() {
+
+		List<DbAction<?>> actions = new ArrayList<>();
+		actions.add(setRootAction(new DbAction.InsertRoot<>(entity)));
+		actions.addAll(insertReferenced());
+		return actions;
+	}
+
+	/**
+	 * Leaves out the isNew check as defined in #DATAJDBC-282
+	 *
+	 * @return List of {@link DbAction}s
+	 * @see <a href="https://jira.spring.io/browse/DATAJDBC-282">DAJDBC-282</a>
+	 */
+	List<DbAction<?>> update() {
+
+		List<DbAction<?>> actions = new ArrayList<>(deleteReferenced());
+		actions.add(setRootAction(new DbAction.UpdateRoot<>(entity)));
+		actions.addAll(insertReferenced());
+		return actions;
+	}
+
+	List<DbAction<?>> save() {
+
+		List<DbAction<?>> actions = new ArrayList<>();
+		if (isNew(root)) {
+
+			actions.add(setRootAction(new DbAction.InsertRoot<>(entity)));
+			actions.addAll(insertReferenced());
+		} else {
+
+			actions.addAll(deleteReferenced());
+			actions.add(setRootAction(new DbAction.UpdateRoot<>(entity)));
+			actions.addAll(insertReferenced());
+		}
+
+		return actions;
+	}
+
+	private boolean isNew(Object o) {
+		return context.getRequiredPersistentEntity(o.getClass()).isNew(o);
+	}
+
+	//// Operations on all paths
+
+	private List<DbAction<?>> insertReferenced() {
+
+		List<DbAction<?>> actions = new ArrayList<>();
+
+		paths.forEach(path -> actions.addAll(insertAll(path)));
+
+		return actions;
+	}
+
+	private List<DbAction<?>> insertAll(PersistentPropertyPath<RelationalPersistentProperty> path) {
+
+		List<DbAction<?>> actions = new ArrayList<>();
+
+		from(path).forEach(node -> {
+
+			DbAction.Insert<Object> insert;
+			if (node.getPath().getRequiredLeafProperty().isQualified()) {
+
+				Pair<Object, Object> value = (Pair) node.getValue();
+				insert = new DbAction.Insert<>(value.getSecond(), path, getAction(node.getParent()));
+				insert.getAdditionalValues().put(node.getPath().getRequiredLeafProperty().getKeyColumn(), value.getFirst());
+
+			} else {
+				insert = new DbAction.Insert<>(node.getValue(), path, getAction(node.getParent()));
+			}
+
+			previousActions.put(node, insert);
+			actions.add(insert);
+		});
+
+		return actions;
+	}
+
+	private List<DbAction<?>> deleteReferenced() {
+
+		List<DbAction<?>> deletes = new ArrayList<>();
+		paths.forEach(path -> deletes.add(0, deleteReferenced(path)));
+
+		return deletes;
+	}
+
+	/// Operations on a single path
+
+	private DbAction.Delete<?> deleteReferenced(PersistentPropertyPath<RelationalPersistentProperty> path) {
+
+		Object id = context.getRequiredPersistentEntity(entityType).getIdentifierAccessor(entity).getIdentifier();
+
+		return new DbAction.Delete<>(id, path);
+	}
+
+	//// methods not directly related to the creation of DbActions
+
+	private DbAction<?> setRootAction(DbAction<?> dbAction) {
+
+		previousActions.put(null, dbAction);
+		return dbAction;
+	}
+
+	@Nullable
+	private DbAction.WithEntity<?> getAction(@Nullable PathNode parent) {
+
+		DbAction action = previousActions.get(parent);
+
+		if (action != null) {
+
+			Assert.isInstanceOf( //
+					DbAction.WithEntity.class, //
+					action, //
+					"dependsOn action is not a WithEntity, but " + action.getClass().getSimpleName() //
+			);
+
+			return (DbAction.WithEntity<?>) action;
+		}
+
+		return null;
+	}
+	// commented as of #DATAJDBC-282
+	// private boolean isNew(Object o) {
+	// return context.getRequiredPersistentEntity(o.getClass()).isNew(o);
+	// }
+
+	private List<PathNode> from(
+			PersistentPropertyPath<RelationalPersistentProperty> path) {
+
+		List<PathNode> nodes = new ArrayList<>();
+
+		if (path.getLength() == 1) {
+
+			Object value = context //
+					.getRequiredPersistentEntity(entityType) //
+					.getPropertyAccessor(entity) //
+					.getProperty(path.getRequiredLeafProperty());
+
+			nodes.addAll(createNodes(path, null, value));
+
+		} else {
+
+			List<PathNode> pathNodes = nodesCache.get(path.getParentPath());
+			pathNodes.forEach(parentNode -> {
+
+				Object value = path.getRequiredLeafProperty().getOwner().getPropertyAccessor(parentNode.getValue())
+						.getProperty(path.getRequiredLeafProperty());
+
+				nodes.addAll(createNodes(path, parentNode, value));
+			});
+		}
+
+		nodesCache.put(path, nodes);
+
+		return nodes;
+	}
+
+	private List<PathNode> createNodes(
+			PersistentPropertyPath<RelationalPersistentProperty> path,
+			@Nullable PathNode parentNode, @Nullable Object value) {
+
+		if (value == null) {
+			return Collections.emptyList();
+		}
+
+		List<PathNode> nodes = new ArrayList<>();
+
+		if (path.getRequiredLeafProperty().isQualified()) {
+
+			if (path.getRequiredLeafProperty().isMap()) {
+				((Map<?, ?>) value)
+						.forEach((k, v) -> nodes.add(new PathNode(path, parentNode, Pair.of(k, v))));
+			} else {
+
+				List listValue = (List) value;
+				for (int k = 0; k < listValue.size(); k++) {
+					nodes.add(new PathNode(path, parentNode, Pair.of(k, listValue.get(k))));
+				}
+			}
+		} else if (path.getRequiredLeafProperty().isCollectionLike()) { // collection value
+			((Collection<?>) value).forEach(v -> nodes.add(new PathNode(path, parentNode, v)));
+		} else { // single entity value
+			nodes.add(new PathNode(path, parentNode, value));
+		}
+
+		return nodes;
+	}
+
+}

spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/DbActionTestSupport.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018 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
+ *
+ *      http://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.conversion;
+
+import lombok.experimental.UtilityClass;
+
+/**
+ * Utility class for analyzing DbActions in tests.
+ * @author Jens Schauder
+ */
+@UtilityClass
+class DbActionTestSupport {
+
+	static String extractPath(DbAction action) {
+
+		if (action instanceof DbAction.WithPropertyPath) {
+			return ((DbAction.WithPropertyPath<?>) action).getPropertyPath().toDotPath();
+		}
+
+		return "";
+	}
+
+	static boolean isWithDependsOn(DbAction dbAction) {
+		return dbAction instanceof DbAction.WithDependingOn;
+	}
+
+	static Class<?> actualEntityType(DbAction a) {
+
+		if (a instanceof DbAction.WithEntity) {
+			return ((DbAction.WithEntity) a).getEntity().getClass();
+		}
+		return null;
+	}
+}

spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/RelationalEntityDeleteWriterUnitTests.java

@@ -23,7 +23,6 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.springframework.data.annotation.Id;
-import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.conversion.AggregateChange.Kind;
 import org.springframework.data.relational.core.conversion.DbAction.Delete;
 import org.springframework.data.relational.core.conversion.DbAction.DeleteAll;
@@ -41,15 +40,6 @@ public class RelationalEntityDeleteWriterUnitTests {
 
 	RelationalEntityDeleteWriter converter = new RelationalEntityDeleteWriter(new RelationalMappingContext());
 
-	private static Object dotPath(DbAction dba) {
-		if (dba instanceof DbAction.WithPropertyPath) {
-			PersistentPropertyPath propertyPath = ((DbAction.WithPropertyPath<?>) dba).getPropertyPath();
-			return propertyPath == null ? null : propertyPath.toDotPath();
-		} else {
-			return null;
-		}
-	}
-
 	@Test // DATAJDBC-112
 	public void deleteDeletesTheEntityAndReferencedEntities() {
 
@@ -60,11 +50,11 @@ public class RelationalEntityDeleteWriterUnitTests {
 		converter.write(entity.id, aggregateChange);
 
 		Assertions.assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, RelationalEntityDeleteWriterUnitTests::dotPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						Tuple.tuple(Delete.class, YetAnother.class, "other.yetAnother"), //
 						Tuple.tuple(Delete.class, OtherEntity.class, "other"), //
-						Tuple.tuple(DeleteRoot.class, SomeEntity.class, null) //
+						Tuple.tuple(DeleteRoot.class, SomeEntity.class, "") //
 				);
 	}
 
@@ -76,11 +66,11 @@ public class RelationalEntityDeleteWriterUnitTests {
 		converter.write(null, aggregateChange);
 
 		Assertions.assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, RelationalEntityDeleteWriterUnitTests::dotPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						Tuple.tuple(DeleteAll.class, YetAnother.class, "other.yetAnother"), //
 						Tuple.tuple(DeleteAll.class, OtherEntity.class, "other"), //
-						Tuple.tuple(DeleteAllRoot.class, SomeEntity.class, null) //
+						Tuple.tuple(DeleteAllRoot.class, SomeEntity.class, "") //
 				);
 	}
 

spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/RelationalEntityInsertWriterUnitTests.java

@@ -15,7 +15,10 @@
  */
 package org.springframework.data.relational.core.conversion;
 
+import static org.assertj.core.api.Assertions.*;
+
 import lombok.RequiredArgsConstructor;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -24,15 +27,13 @@ import org.springframework.data.relational.core.conversion.AggregateChange.Kind;
 import org.springframework.data.relational.core.conversion.DbAction.InsertRoot;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 
-import static org.assertj.core.api.Assertions.*;
-
 /**
  * Unit tests for the {@link RelationalEntityInsertWriter}
  *
- * @author Jens Schauder
  * @author Thomas Lang
  */
-@RunWith(MockitoJUnitRunner.class) public class RelationalEntityInsertWriterUnitTests {
+@RunWith(MockitoJUnitRunner.class)
+public class RelationalEntityInsertWriterUnitTests {
 
 	public static final long SOME_ENTITY_ID = 23L;
 	RelationalEntityInsertWriter converter = new RelationalEntityInsertWriter(new RelationalMappingContext());
@@ -47,8 +48,8 @@ import static org.assertj.core.api.Assertions.*;
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath,
-						this::isWithDependsOn) //
+						DbActionTestSupport::actualEntityType, DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false) //
 				);
@@ -65,39 +66,16 @@ import static org.assertj.core.api.Assertions.*;
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath,
-						this::isWithDependsOn) //
+						DbActionTestSupport::actualEntityType, DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false) //
 				);
 
-		assertThat(aggregateChange.getEntity()).isNotNull();
-		// the new id should not be the same as the origin one - should do insert, not update
-		// assertThat(aggregateChange.getEntity().id).isNotEqualTo(SOME_ENTITY_ID);
-	}
-
-	private String extractPath(DbAction action) {
-
-		if (action instanceof DbAction.WithPropertyPath) {
-			return ((DbAction.WithPropertyPath<?>) action).getPropertyPath().toDotPath();
-		}
-
-		return "";
-	}
-
-	private boolean isWithDependsOn(DbAction dbAction) {
-		return dbAction instanceof DbAction.WithDependingOn;
-	}
-
-	private Class<?> actualEntityType(DbAction a) {
-
-		if (a instanceof DbAction.WithEntity) {
-			return ((DbAction.WithEntity) a).getEntity().getClass();
-		}
-		return null;
 	}
 
-	@RequiredArgsConstructor static class SingleReferenceEntity {
+	@RequiredArgsConstructor
+	static class SingleReferenceEntity {
 
 		@Id final Long id;
 		Element other;
@@ -105,7 +83,8 @@ import static org.assertj.core.api.Assertions.*;
 		String name;
 	}
 
-	@RequiredArgsConstructor private static class Element {
+	@RequiredArgsConstructor
+	private static class Element {
 		@Id final Long id;
 	}
 }

spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/RelationalEntityUpdateWriterUnitTests.java

@@ -15,7 +15,10 @@
  */
 package org.springframework.data.relational.core.conversion;
 
+import static org.assertj.core.api.Assertions.*;
+
 import lombok.RequiredArgsConstructor;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -23,12 +26,9 @@ import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.conversion.AggregateChange.Kind;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 
-import static org.assertj.core.api.Assertions.*;
-
 /**
  * Unit tests for the {@link RelationalEntityUpdateWriter}
  *
- * @author Jens Schauder
  * @author Thomas Lang
  */
 @RunWith(MockitoJUnitRunner.class)
@@ -48,40 +48,18 @@ public class RelationalEntityUpdateWriterUnitTests {
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-                .extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-                        this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(DbAction.Delete.class, Element.class, "other", null, false), //
 						tuple(DbAction.UpdateRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false) //
 				);
 	}
 
-    private String extractPath(DbAction action) {
-
-        if (action instanceof DbAction.WithPropertyPath) {
-            return ((DbAction.WithPropertyPath<?>) action).getPropertyPath().toDotPath();
-        }
-
-        return "";
-    }
-
-    private boolean isWithDependsOn(DbAction dbAction) {
-        return dbAction instanceof DbAction.WithDependingOn;
-    }
-
-    private Class<?> actualEntityType(DbAction a) {
-
-        if (a instanceof DbAction.WithEntity) {
-            return ((DbAction.WithEntity) a).getEntity().getClass();
-        }
-        return null;
-    }
-
 	@RequiredArgsConstructor
 	static class SingleReferenceEntity {
 
-        @Id
+		@Id final Long id;
-        final Long id;
 		Element other;
 		// should not trigger own Dbaction
 		String name;
@@ -89,8 +67,7 @@ public class RelationalEntityUpdateWriterUnitTests {
 
 	@RequiredArgsConstructor
 	private static class Element {
-        @Id
+		@Id final Long id;
-        final Long id;
 	}
 
 }

spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/RelationalEntityWriterUnitTests.java

@@ -53,13 +53,13 @@ public class RelationalEntityWriterUnitTests {
 
 		SingleReferenceEntity entity = new SingleReferenceEntity(null);
 		AggregateChange<SingleReferenceEntity> aggregateChange = //
-				new AggregateChange(Kind.SAVE, SingleReferenceEntity.class, entity);
+				new AggregateChange<>(Kind.SAVE, SingleReferenceEntity.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false) //
 				);
@@ -72,13 +72,13 @@ public class RelationalEntityWriterUnitTests {
 		entity.other = new Element(null);
 
 		AggregateChange<SingleReferenceEntity> aggregateChange = //
-				new AggregateChange(Kind.SAVE, SingleReferenceEntity.class, entity);
+				new AggregateChange<>(Kind.SAVE, SingleReferenceEntity.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false), //
 						tuple(Insert.class, Element.class, "other", Element.class, true) //
@@ -91,13 +91,13 @@ public class RelationalEntityWriterUnitTests {
 		SingleReferenceEntity entity = new SingleReferenceEntity(SOME_ENTITY_ID);
 
 		AggregateChange<SingleReferenceEntity> aggregateChange = //
-				new AggregateChange(Kind.SAVE, SingleReferenceEntity.class, entity);
+				new AggregateChange<>(Kind.SAVE, SingleReferenceEntity.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(Delete.class, Element.class, "other", null, false), //
 						tuple(UpdateRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false) //
@@ -110,14 +110,14 @@ public class RelationalEntityWriterUnitTests {
 		SingleReferenceEntity entity = new SingleReferenceEntity(SOME_ENTITY_ID);
 		entity.other = new Element(null);
 
-		AggregateChange<SingleReferenceEntity> aggregateChange = new AggregateChange(Kind.SAVE, SingleReferenceEntity.class,
+		AggregateChange<SingleReferenceEntity> aggregateChange = new AggregateChange<>(Kind.SAVE, SingleReferenceEntity.class,
 				entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(Delete.class, Element.class, "other", null, false), //
 						tuple(UpdateRoot.class, SingleReferenceEntity.class, "", SingleReferenceEntity.class, false), //
@@ -129,14 +129,14 @@ public class RelationalEntityWriterUnitTests {
 	public void newEntityWithEmptySetResultsInSingleInsert() {
 
 		SetContainer entity = new SetContainer(null);
-		AggregateChange<RelationalEntityWriterUnitTests.SingleReferenceEntity> aggregateChange = new AggregateChange(
+		AggregateChange<RelationalEntityWriterUnitTests.SetContainer> aggregateChange = new AggregateChange<>(
 				Kind.SAVE, SetContainer.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SetContainer.class, "", SetContainer.class, false));
 	}
@@ -148,12 +148,12 @@ public class RelationalEntityWriterUnitTests {
 		entity.elements.add(new Element(null));
 		entity.elements.add(new Element(null));
 
-		AggregateChange<SingleReferenceEntity> aggregateChange = new AggregateChange(Kind.SAVE, SetContainer.class, entity);
+		AggregateChange<SetContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, SetContainer.class, entity);
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, SetContainer.class, "", SetContainer.class, false), //
 						tuple(Insert.class, Element.class, "elements", Element.class, true), //
@@ -176,14 +176,14 @@ public class RelationalEntityWriterUnitTests {
 				new Element(null)) //
 		);
 
-		AggregateChange<SingleReferenceEntity> aggregateChange = new AggregateChange(Kind.SAVE,
+		AggregateChange<CascadingReferenceEntity> aggregateChange = new AggregateChange<>(Kind.SAVE,
 				CascadingReferenceEntity.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(InsertRoot.class, CascadingReferenceEntity.class, "", CascadingReferenceEntity.class, false), //
 						tuple(Insert.class, CascadingReferenceMiddleElement.class, "other", CascadingReferenceMiddleElement.class,
@@ -212,14 +212,14 @@ public class RelationalEntityWriterUnitTests {
 				new Element(null)) //
 		);
 
-		AggregateChange<SingleReferenceEntity> aggregateChange = new AggregateChange(Kind.SAVE,
+		AggregateChange<CascadingReferenceEntity> aggregateChange = new AggregateChange<>(Kind.SAVE,
 				CascadingReferenceEntity.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath, this::actualEntityType,
+				.extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath, DbActionTestSupport::actualEntityType,
-						this::isWithDependsOn) //
+						DbActionTestSupport::isWithDependsOn) //
 				.containsExactly( //
 						tuple(Delete.class, Element.class, "other.element", null, false),
 						tuple(Delete.class, CascadingReferenceMiddleElement.class, "other", null, false),
@@ -239,11 +239,11 @@ public class RelationalEntityWriterUnitTests {
 	public void newEntityWithEmptyMapResultsInSingleInsert() {
 
 		MapContainer entity = new MapContainer(null);
-		AggregateChange<MapContainer> aggregateChange = new AggregateChange(Kind.SAVE, MapContainer.class, entity);
+		AggregateChange<MapContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, MapContainer.class, entity);
 
 		converter.write(entity, aggregateChange);
 
-		assertThat(aggregateChange.getActions()).extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath) //
+		assertThat(aggregateChange.getActions()).extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						tuple(InsertRoot.class, MapContainer.class, ""));
 	}
@@ -255,11 +255,11 @@ public class RelationalEntityWriterUnitTests {
 		entity.elements.put("one", new Element(null));
 		entity.elements.put("two", new Element(null));
 
-		AggregateChange<MapContainer> aggregateChange = new AggregateChange(Kind.SAVE, MapContainer.class, entity);
+		AggregateChange<MapContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, MapContainer.class, entity);
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, this::extractPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, DbActionTestSupport::extractPath) //
 				.containsExactlyInAnyOrder( //
 						tuple(InsertRoot.class, MapContainer.class, null, ""), //
 						tuple(Insert.class, Element.class, "one", "elements"), //
@@ -290,11 +290,11 @@ public class RelationalEntityWriterUnitTests {
 		entity.elements.put("a", new Element(null));
 		entity.elements.put("b", new Element(null));
 
-		AggregateChange<MapContainer> aggregateChange = new AggregateChange(Kind.SAVE, MapContainer.class, entity);
+		AggregateChange<MapContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, MapContainer.class, entity);
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, this::extractPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, DbActionTestSupport::extractPath) //
 				.containsExactlyInAnyOrder( //
 						tuple(InsertRoot.class, MapContainer.class, null, ""), //
 						tuple(Insert.class, Element.class, "1", "elements"), //
@@ -316,11 +316,11 @@ public class RelationalEntityWriterUnitTests {
 	public void newEntityWithEmptyListResultsInSingleInsert() {
 
 		ListContainer entity = new ListContainer(null);
-		AggregateChange<ListContainer> aggregateChange = new AggregateChange(Kind.SAVE, ListContainer.class, entity);
+		AggregateChange<ListContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, ListContainer.class, entity);
 
 		converter.write(entity, aggregateChange);
 
-		assertThat(aggregateChange.getActions()).extracting(DbAction::getClass, DbAction::getEntityType, this::extractPath) //
+		assertThat(aggregateChange.getActions()).extracting(DbAction::getClass, DbAction::getEntityType, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						tuple(InsertRoot.class, ListContainer.class, ""));
 	}
@@ -332,11 +332,11 @@ public class RelationalEntityWriterUnitTests {
 		entity.elements.add(new Element(null));
 		entity.elements.add(new Element(null));
 
-		AggregateChange<ListContainer> aggregateChange = new AggregateChange(Kind.SAVE, ListContainer.class, entity);
+		AggregateChange<ListContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, ListContainer.class, entity);
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions())
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::getListKey, this::extractPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, this::getListKey, DbActionTestSupport::extractPath) //
 				.containsExactlyInAnyOrder( //
 						tuple(InsertRoot.class, ListContainer.class, null, ""), //
 						tuple(Insert.class, Element.class, 0, "elements"), //
@@ -356,12 +356,12 @@ public class RelationalEntityWriterUnitTests {
 		MapContainer entity = new MapContainer(SOME_ENTITY_ID);
 		entity.elements.put("one", new Element(null));
 
-		AggregateChange<MapContainer> aggregateChange = new AggregateChange(Kind.SAVE, MapContainer.class, entity);
+		AggregateChange<MapContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, MapContainer.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, this::extractPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, this::getMapKey, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						tuple(Delete.class, Element.class, null, "elements"), //
 						tuple(UpdateRoot.class, MapContainer.class, null, ""), //
@@ -375,12 +375,12 @@ public class RelationalEntityWriterUnitTests {
 		ListContainer entity = new ListContainer(SOME_ENTITY_ID);
 		entity.elements.add(new Element(null));
 
-		AggregateChange<ListContainer> aggregateChange = new AggregateChange(Kind.SAVE, ListContainer.class, entity);
+		AggregateChange<ListContainer> aggregateChange = new AggregateChange<>(Kind.SAVE, ListContainer.class, entity);
 
 		converter.write(entity, aggregateChange);
 
 		assertThat(aggregateChange.getActions()) //
-				.extracting(DbAction::getClass, DbAction::getEntityType, this::getListKey, this::extractPath) //
+				.extracting(DbAction::getClass, DbAction::getEntityType, this::getListKey, DbActionTestSupport::extractPath) //
 				.containsExactly( //
 						tuple(Delete.class, Element.class, null, "elements"), //
 						tuple(UpdateRoot.class, ListContainer.class, null, ""), //
@@ -408,27 +408,6 @@ public class RelationalEntityWriterUnitTests {
 				: null;
 	}
 
-	private String extractPath(DbAction action) {
-
-		if (action instanceof DbAction.WithPropertyPath) {
-			return ((DbAction.WithPropertyPath<?>) action).getPropertyPath().toDotPath();
-		}
-
-		return "";
-	}
-
-	private boolean isWithDependsOn(DbAction dbAction) {
-		return dbAction instanceof DbAction.WithDependingOn;
-	}
-
-	private Class<?> actualEntityType(DbAction a) {
-
-		if (a instanceof DbAction.WithEntity) {
-			return ((DbAction.WithEntity) a).getEntity().getClass();
-		}
-		return null;
-	}
-
 	@RequiredArgsConstructor
 	static class SingleReferenceEntity {