DATAJDBC-551 - Support derived delete.

Author: nkonev

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/AbstractJdbcQuery.java

@@ -97,7 +97,7 @@ protected JdbcQueryExecution<?> getQueryExecution(JdbcQueryMethod queryMethod,
 return extractor != null ? getQueryExecution(extractor) : singleObjectQuery(rowMapper);
 }
 
-private JdbcQueryExecution<Object> createModifyingQueryExecutor() {
+JdbcQueryExecution<Object> createModifyingQueryExecutor() {
 
 return (query, parameters) -> {
 

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcDeleteQueryCreator.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2020 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
+ *
+ * https://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.query;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jdbc.core.convert.JdbcConverter;
+import org.springframework.data.jdbc.core.convert.QueryMapper;
+import org.springframework.data.mapping.PersistentPropertyPath;
+import org.springframework.data.relational.core.dialect.Dialect;
+import org.springframework.data.relational.core.dialect.RenderContextFactory;
+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.core.query.Criteria;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Conditions;
+import org.springframework.data.relational.core.sql.Delete;
+import org.springframework.data.relational.core.sql.DeleteBuilder.DeleteWhere;
+import org.springframework.data.relational.core.sql.Select;
+import org.springframework.data.relational.core.sql.SelectBuilder.SelectWhere;
+import org.springframework.data.relational.core.sql.StatementBuilder;
+import org.springframework.data.relational.core.sql.Table;
+import org.springframework.data.relational.core.sql.render.SqlRenderer;
+import org.springframework.data.relational.repository.query.RelationalEntityMetadata;
+import org.springframework.data.relational.repository.query.RelationalParameterAccessor;
+import org.springframework.data.relational.repository.query.RelationalQueryCreator;
+import org.springframework.data.repository.query.parser.PartTree;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link RelationalQueryCreator} that creates {@link Stream} of deletion {@link ParametrizedQuery}
+ * from a {@link PartTree}.
+ *
+ * @author Yunyoung LEE
+ * @since 2.3
+ */
+class JdbcDeleteQueryCreator extends RelationalQueryCreator<Stream<ParametrizedQuery>> {
+
+ private final RelationalMappingContext context;
+ private final QueryMapper queryMapper;
+ private final RelationalEntityMetadata<?> entityMetadata;
+ private final RenderContextFactory renderContextFactory;
+
+ /**
+ * Creates new instance of this class with the given {@link PartTree}, {@link JdbcConverter}, {@link Dialect},
+ * {@link RelationalEntityMetadata} and {@link RelationalParameterAccessor}.
+ *
+ * @param context
+ * @param tree part tree, must not be {@literal null}.
+ * @param converter must not be {@literal null}.
+ * @param dialect must not be {@literal null}.
+ * @param entityMetadata relational entity metadata, must not be {@literal null}.
+ * @param accessor parameter metadata provider, must not be {@literal null}.
+ */
+ JdbcDeleteQueryCreator(RelationalMappingContext context, PartTree tree, JdbcConverter converter, Dialect dialect,
+ RelationalEntityMetadata<?> entityMetadata, RelationalParameterAccessor accessor) {
+ super(tree, accessor);
+
+ Assert.notNull(converter, "JdbcConverter must not be null");
+ Assert.notNull(dialect, "Dialect must not be null");
+ Assert.notNull(entityMetadata, "Relational entity metadata must not be null");
+
+ this.context = context;
+
+ this.entityMetadata = entityMetadata;
+ this.queryMapper = new QueryMapper(dialect, converter);
+ this.renderContextFactory = new RenderContextFactory(dialect);
+ }
+
+ @Override
+ protected Stream<ParametrizedQuery> complete(@Nullable Criteria criteria, Sort sort) {
+
+ RelationalPersistentEntity<?> entity = entityMetadata.getTableEntity();
+ Table table = Table.create(entityMetadata.getTableName());
+ MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+
+ SqlContext sqlContext = new SqlContext(entity);
+
+ Condition condition = criteria == null ? null
+ : queryMapper.getMappedObject(parameterSource, criteria, table, entity);
+
+ // create select criteria query for subselect
+ SelectWhere selectBuilder = StatementBuilder.select(sqlContext.getIdColumn()).from(table);
+ Select select = condition == null ? selectBuilder.build() : selectBuilder.where(condition).build();
+
+ // create delete relation queries
+ List<Delete> deleteChain = new ArrayList<>();
+ deleteRelations(deleteChain, entity, select);
+
+ // crate delete query
+ DeleteWhere deleteBuilder = StatementBuilder.delete(table);
+ Delete delete = condition == null ? deleteBuilder.build() : deleteBuilder.where(condition).build();
+
+ deleteChain.add(delete);
+
+ SqlRenderer renderer = SqlRenderer.create(renderContextFactory.createRenderContext());
+ return deleteChain.stream().map(d -> new ParametrizedQuery(renderer.render(d), parameterSource));
+ }
+
+ private void deleteRelations(List<Delete> deleteChain, RelationalPersistentEntity<?> entity, Select parentSelect) {
+
+ for (PersistentPropertyPath<RelationalPersistentProperty> path : context
+ .findPersistentPropertyPaths(entity.getType(), p -> true)) {
+
+ PersistentPropertyPathExtension extPath = new PersistentPropertyPathExtension(context, path);
+
+ // prevent duplication on recursive call
+ if (path.getLength() > 1 && !extPath.getParentPath().isEmbedded()) {
+ continue;
+ }
+
+ if (extPath.isEntity() && !extPath.isEmbedded()) {
+
+ SqlContext sqlContext = new SqlContext(extPath.getLeafEntity());
+
+ Condition inCondition = Conditions.in(sqlContext.getTable().column(extPath.getReverseColumnName()),
+ parentSelect);
+
+ Select select = StatementBuilder
+ .select(sqlContext.getTable().column(extPath.getIdDefiningParentPath().getIdColumnName())
+ // sqlContext.getIdColumn()
+ ).from(sqlContext.getTable()).where(inCondition).build();
+ deleteRelations(deleteChain, extPath.getLeafEntity(), select);
+
+ deleteChain.add(StatementBuilder.delete(sqlContext.getTable()).where(inCondition).build());
+ }
+ }
+ }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/PartTreeJdbcQuery.java

@@ -22,6 +22,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.function.LongSupplier;
+import java.util.stream.Stream;
 
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.domain.Pageable;
@@ -120,6 +121,13 @@ public Object execute(Object[] values) {
 RelationalParametersParameterAccessor accessor = new RelationalParametersParameterAccessor(getQueryMethod(),
 values);
 
+ if (tree.isDelete()) {
+ JdbcQueryExecution<?> execution = createModifyingQueryExecutor();
+ return createDeleteQueries(accessor)
+ .map(query -> execution.execute(query.getQuery(), query.getParameterSource()))
+ .reduce((a, b) -> b);
+ }
+
 ResultProcessor processor = getQueryMethod().getResultProcessor().withDynamicProjection(accessor);
 ParametrizedQuery query = createQuery(accessor, processor.getReturnedType());
 JdbcQueryExecution<?> execution = getQueryExecution(processor, accessor);
@@ -182,6 +190,15 @@ protected ParametrizedQuery createQuery(RelationalParametersParameterAccessor ac
 return queryCreator.createQuery(getDynamicSort(accessor));
 }
 
+ private Stream<ParametrizedQuery> createDeleteQueries(RelationalParametersParameterAccessor accessor) {
+
+ RelationalEntityMetadata<?> entityMetadata = getQueryMethod().getEntityInformation();
+
+ JdbcDeleteQueryCreator queryCreator = new JdbcDeleteQueryCreator(context, tree, converter, dialect, entityMetadata,
+ accessor);
+ return queryCreator.createQuery();
+ }
+
 /**
  * {@link JdbcQueryExecution} returning a {@link org.springframework.data.domain.Slice}.
  *

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

@@ -22,6 +22,7 @@
 
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.jupiter.api.Test;
@@ -231,28 +232,52 @@ public void deleteAll() {
 assertThat(repository.findAll()).isEmpty();
 }
 
-private static DummyEntity createDummyEntity() {
-DummyEntity entity = new DummyEntity();
-entity.setTest("root");
+ @Test // DATAJDBC-551
+ public void deleteByTest() {
 
-final Embeddable embeddable = new Embeddable();
-embeddable.setTest("embedded");
+ DummyEntity one = repository.save(createDummyEntity("root1"));
+ DummyEntity two = repository.save(createDummyEntity("root2"));
+ DummyEntity three = repository.save(createDummyEntity("root3"));
 
-final DummyEntity2 dummyEntity21 = new DummyEntity2();
-dummyEntity21.setTest("entity1");
+ assertThat(repository.deleteByTest(two.getTest())).isEqualTo(1);
 
-final DummyEntity2 dummyEntity22 = new DummyEntity2();
-dummyEntity22.setTest("entity2");
+ assertThat(repository.findAll()) //
+ .extracting(DummyEntity::getId) //
+ .containsExactlyInAnyOrder(one.getId(), three.getId());
 
-embeddable.getList().add(dummyEntity21);
-embeddable.getList().add(dummyEntity22);
+ Long count = template.queryForObject("select count(1) from dummy_entity2", Collections.emptyMap(), Long.class);
+ assertThat(count).isEqualTo(4);
 
-entity.setEmbeddable(embeddable);
+ }
 
-return entity;
-}
+ private static DummyEntity createDummyEntity() {
+ return createDummyEntity("root");
+ }
+
+ private static DummyEntity createDummyEntity(String test) {
+ DummyEntity entity = new DummyEntity();
+ entity.setTest(test);
+
+ final Embeddable embeddable = new Embeddable();
+ embeddable.setTest("embedded");
+
+ final DummyEntity2 dummyEntity21 = new DummyEntity2();
+ dummyEntity21.setTest("entity1");
+
+ final DummyEntity2 dummyEntity22 = new DummyEntity2();
+ dummyEntity22.setTest("entity2");
+
+ embeddable.getList().add(dummyEntity21);
+ embeddable.getList().add(dummyEntity22);
+
+ entity.setEmbeddable(embeddable);
+
+ return entity;
+ }
 
-interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {}
+interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {
+ int deleteByTest(String test);
+ }
 
 @Data
 private static class DummyEntity {