Return deleted entity from derived deleteBy method.

We now return the deleted entity and check, guard the delete query against batch deletes if the delete yields more than done result.

Closes #3995

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/JpaCodeBlocks.java

@@ -30,6 +30,7 @@
 
 import org.springframework.core.MethodParameter;
 import org.springframework.core.annotation.MergedAnnotation;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Score;
 import org.springframework.data.domain.SliceImpl;
@@ -46,6 +47,7 @@
 import org.springframework.data.repository.aot.generate.AotQueryMethodGenerationContext;
 import org.springframework.data.repository.query.ReturnedType;
 import org.springframework.data.support.PageableExecutionUtils;
+import org.springframework.data.util.ReflectionUtils;
 import org.springframework.javapoet.CodeBlock;
 import org.springframework.javapoet.CodeBlock.Builder;
 import org.springframework.javapoet.TypeName;
@@ -662,13 +664,14 @@ public CodeBlock build() {
 					: TypeName.get(context.getDomainType());
 			builder.add("\n");
 
+			Class<?> methodReturnType = context.getMethod().getReturnType();
 			if (modifying.isPresent()) {
 
 				if (modifying.getBoolean("flushAutomatically")) {
 					builder.addStatement("this.$L.flush()", context.fieldNameOf(EntityManager.class));
 				}
 
-				Class<?> returnType = context.getMethod().getReturnType();
+				Class<?> returnType = methodReturnType;
 
 				if (returnsModifying(returnType)) {
 					builder.addStatement("int $L = $L.executeUpdate()", context.localVariable("result"), queryVariableName);
@@ -697,19 +700,42 @@ public CodeBlock build() {
 
 				builder.addStatement("$T $L = $L.getResultList()", List.class,
 						context.localVariable("resultList"), queryVariableName);
+
+				boolean returnCount = ClassUtils.isAssignable(Number.class, methodReturnType);
+				boolean simpleBatch = returnCount || ReflectionUtils.isVoid(methodReturnType);
+				boolean collectionQuery = queryMethod.isCollectionQuery();
+
+				if (!simpleBatch && !collectionQuery) {
+
+					builder.beginControlFlow("if ($L.size() > 1)", context.localVariable("resultList"));
+					builder.addStatement("throw new $1T($2S + $3L.size(), 1, $3L.size())",
+							IncorrectResultSizeDataAccessException.class,
+							"Delete query returned more than one element: expected 1, actual ", context.localVariable("resultList"));
+					builder.endControlFlow();
+
+					builder.addStatement("$L.forEach($L::remove)", context.localVariable("resultList"),
+							context.fieldNameOf(EntityManager.class));
+				}
+
 				builder.addStatement("$L.forEach($L::remove)", context.localVariable("resultList"),
 						context.fieldNameOf(EntityManager.class));
-				if (!Collection.class.isAssignableFrom(context.getReturnType().toClass())) {
-					if (ClassUtils.isAssignable(Number.class, context.getMethod().getReturnType())) {
-						builder.addStatement("return $T.valueOf($L.size())", context.getMethod().getReturnType(),
+
+				if (collectionQuery) {
+					builder.addStatement("return ($T) $L", List.class, context.localVariable("resultList"));
+
+				} else if (returnCount) {
+					builder.addStatement("return $T.valueOf($L.size())", methodReturnType,
 								context.localVariable("resultList"));
 					} else {
-						builder.addStatement("return ($T) ($L.isEmpty() ? null : $L.iterator().next())", actualReturnType,
-								context.localVariable("resultList"), context.localVariable("resultList"));
+
+						if (Optional.class.isAssignableFrom(methodReturnType)) {
+							builder.addStatement("return ($1T) $1T.ofNullable($2L.isEmpty() ? null : $2L.iterator().next())",
+									Optional.class, context.localVariable("resultList"));
+						} else {
+							builder.addStatement("return ($1T) ($2L.isEmpty() ? null : $2L.iterator().next())", actualReturnType,
+									context.localVariable("resultList"));
+						}
 					}
-				} else {
-					builder.addStatement("return ($T) $L", List.class, context.localVariable("resultList"));
-				}
 			} else if (aotQuery != null && aotQuery.isExists()) {
 				builder.addStatement("return !$L.getResultList().isEmpty()", queryVariableName);
 			} else if (aotQuery != null) {

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryExecution.java

@@ -32,6 +32,7 @@
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.support.ConfigurableConversionService;
 import org.springframework.core.convert.support.DefaultConversionService;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Score;
@@ -51,6 +52,7 @@
 import org.springframework.data.util.StreamUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ReflectionUtils;
 
 /**
@@ -399,16 +401,33 @@ public DeleteExecution(EntityManager em) {
 		}
 
 		@Override
-		protected Object doExecute(AbstractJpaQuery jpaQuery, JpaParametersParameterAccessor accessor) {
+		protected @Nullable Object doExecute(AbstractJpaQuery jpaQuery, JpaParametersParameterAccessor accessor) {
 
 			Query query = jpaQuery.createQuery(accessor);
 			List<?> resultList = query.getResultList();
 
+			boolean simpleBatch = Number.class.isAssignableFrom(jpaQuery.getQueryMethod().getReturnType())
+					|| org.springframework.data.util.ReflectionUtils.isVoid(jpaQuery.getQueryMethod().getReturnType());
+			boolean collectionQuery = jpaQuery.getQueryMethod().isCollectionQuery();
+
+			if (!simpleBatch && !collectionQuery) {
+
+				if (resultList.size() > 1) {
+					throw new IncorrectResultSizeDataAccessException(
+							"Delete query returned more than one element: expected 1, actual " + resultList.size(), 1,
+							resultList.size());
+				}
+			}
+
 			for (Object o : resultList) {
 				em.remove(o);
 			}
 
-			return jpaQuery.getQueryMethod().isCollectionQuery() ? resultList : resultList.size();
+			if (simpleBatch) {
+				return resultList.size();
+			}
+
+			return collectionQuery ? resultList : CollectionUtils.firstElement(resultList);
 		}
 	}
 

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/UserRepositoryTests.java

@@ -1582,6 +1582,38 @@ void deleteByShouldReturnListOfDeletedElementsWhenRetunTypeIsCollectionLike() {
 		assertThat(result).containsOnly(firstUser);
 	}
 
+	@Test // GH-3995
+	void deleteOneByShouldReturnDeletedElement() {
+
+		assertThat(repository.deleteOneByLastname(firstUser.getLastname())).isNull();
+
+		flushTestUsers();
+
+		User result = repository.deleteOneByLastname(firstUser.getLastname());
+		assertThat(result).isEqualTo(firstUser);
+	}
+
+	@Test // GH-3995
+	void deleteOneOptionalByShouldReturnDeletedElement() {
+
+		flushTestUsers();
+
+		Optional<User> result = repository.deleteOneOptionalByLastname(firstUser.getLastname());
+		assertThat(result).contains(firstUser);
+	}
+
+	@Test // GH-3995
+	void deleteOneShouldFailWhenMatchingMultipleResults() {
+
+		firstUser.setLastname("foo");
+		secondUser.setLastname("foo");
+		firstUser = repository.save(firstUser);
+		secondUser = repository.save(secondUser);
+
+		assertThatExceptionOfType(IncorrectResultSizeDataAccessException.class)
+				.isThrownBy(() -> repository.deleteOneByLastname(firstUser.getLastname()));
+	}
+
 	@Test // DATAJPA-460
 	void deleteByShouldRemoveElementsMatchingDerivedQuery() {
 

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/sample/UserRepository.java

@@ -302,6 +302,10 @@ Window<User> findTop3ByFirstnameStartingWithOrderByFirstnameAscEmailAddressAsc(S
 	// DATAJPA-460
 	List<User> deleteByLastname(String lastname);
 
+	User deleteOneByLastname(String lastname);
+
+	Optional<User> deleteOneOptionalByLastname(String lastname);
+
 	/**
 	 * Explicitly mapped to a procedure with name "plus1inout" in database.
 	 */