Merge pull request #544 from jeffgbutler/limit-delete-update

Support "limit" and "order by" on DELETE and UPDATE Statements

Author: jeffgbutler

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 This log will detail notable changes to MyBatis Dynamic SQL. Full details are available on the GitHub milestone pages.
 
+## Release 1.5.0 - Unreleased
+
+GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/milestone/12](https://github.com/mybatis/mybatis-dynamic-sql/milestone/12)
+
+Added:
+
+1. Added support for specifying "limit" and "order by" on the DELETE and UPDATE statements. Not all databases support
+   this SQL extension, and different databases have different levels of support. For example, MySQL/MariaDB have full
+   support but HSQLDB only supports limit as an extension to the WHERE clause. If you choose to use this new capability,
+   please test to make sure it is supported in your database. ([#544](https://github.com/mybatis/mybatis-dynamic-sql/pull/544))
+
+
 ## Release 1.4.1 - October 7, 2022
 
 GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.4.1+](https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.4.1+)

pom.xml

@@ -316,6 +316,18 @@
       <version>42.5.0</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.testcontainers</groupId>
+      <artifactId>mariadb</artifactId>
+      <version>${test.containers.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mariadb.jdbc</groupId>
+      <artifactId>mariadb-java-client</artifactId>
+      <version>3.0.8</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
 </project>

src/main/java/org/mybatis/dynamic/sql/select/OrderByModel.java renamed to src/main/java/org/mybatis/dynamic/sql/common/OrderByModel.java

@@ -13,7 +13,7 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-package org.mybatis.dynamic.sql.select;
+package org.mybatis.dynamic.sql.common;
 
 import java.util.ArrayList;
 import java.util.Collection;

src/main/java/org/mybatis/dynamic/sql/common/OrderByRenderer.java

@@ -0,0 +1,37 @@
+/*
+ *    Copyright 2016-2022 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.mybatis.dynamic.sql.common;
+
+import java.util.stream.Collectors;
+
+import org.mybatis.dynamic.sql.SortSpecification;
+import org.mybatis.dynamic.sql.util.FragmentAndParameters;
+
+public class OrderByRenderer {
+    public FragmentAndParameters render(OrderByModel orderByModel) {
+        String phrase = orderByModel.mapColumns(this::calculateOrderByPhrase)
+                .collect(Collectors.joining(", ", "order by ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+        return FragmentAndParameters.withFragment(phrase).build();
+    }
+
+    private String calculateOrderByPhrase(SortSpecification column) {
+        String phrase = column.orderByName();
+        if (column.isDescending()) {
+            phrase = phrase + " DESC"; //$NON-NLS-1$
+        }
+        return phrase;
+    }
+}

src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java

@@ -15,12 +15,16 @@
  */
 package org.mybatis.dynamic.sql.delete;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.jetbrains.annotations.NotNull;
+import org.mybatis.dynamic.sql.SortSpecification;
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.configuration.StatementConfiguration;
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.mybatis.dynamic.sql.where.AbstractWhereDSL;
@@ -35,6 +39,8 @@ public class DeleteDSL<R> extends AbstractWhereSupport<DeleteDSL<R>.DeleteWhereB
     private final String tableAlias;
     private DeleteWhereBuilder whereBuilder;
     private final StatementConfiguration statementConfiguration = new StatementConfiguration();
+    private Long limit;
+    private OrderByModel orderByModel;
 
     private DeleteDSL(SqlTable table, String tableAlias, Function<DeleteModel, R> adapterFunction) {
         this.table = Objects.requireNonNull(table);
@@ -50,6 +56,20 @@ public DeleteWhereBuilder where() {
         return whereBuilder;
     }
 
+    public DeleteDSL<R> limit(long limit) {
+        this.limit = limit;
+        return this;
+    }
+
+    public DeleteDSL<R> orderBy(SortSpecification... columns) {
+        return orderBy(Arrays.asList(columns));
+    }
+
+    public DeleteDSL<R> orderBy(Collection<SortSpecification> columns) {
+        orderByModel = OrderByModel.of(columns);
+        return this;
+    }
+
     /**
      * WARNING! Calling this method could result in a delete statement that deletes
      * all rows in a table.
@@ -60,7 +80,9 @@ public DeleteWhereBuilder where() {
     @Override
     public R build() {
         DeleteModel.Builder deleteModelBuilder = DeleteModel.withTable(table)
-                .withTableAlias(tableAlias);
+                .withTableAlias(tableAlias)
+                .withLimit(limit)
+                .withOrderByModel(orderByModel);
         if (whereBuilder != null) {
             deleteModelBuilder.withWhereModel(whereBuilder.buildWhereModel());
         }
@@ -93,6 +115,19 @@ private DeleteWhereBuilder() {
             super(statementConfiguration);
         }
 
+        public DeleteDSL<R> limit(long limit) {
+            return DeleteDSL.this.limit(limit);
+        }
+
+        public DeleteDSL<R> orderBy(SortSpecification... columns) {
+            return orderBy(Arrays.asList(columns));
+        }
+
+        public DeleteDSL<R> orderBy(Collection<SortSpecification> columns) {
+            orderByModel = OrderByModel.of(columns);
+            return DeleteDSL.this;
+        }
+
         @NotNull
         @Override
         public R build() {

src/main/java/org/mybatis/dynamic/sql/delete/DeleteModel.java

@@ -20,6 +20,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.delete.render.DeleteRenderer;
 import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
@@ -29,11 +30,15 @@ public class DeleteModel {
     private final SqlTable table;
     private final String tableAlias;
     private final WhereModel whereModel;
+    private final Long limit;
+    private final OrderByModel orderByModel;
 
     private DeleteModel(Builder builder) {
         table = Objects.requireNonNull(builder.table);
         whereModel = builder.whereModel;
         tableAlias = builder.tableAlias;
+        limit = builder.limit;
+        orderByModel = builder.orderByModel;
     }
 
     public SqlTable table() {
@@ -48,6 +53,14 @@ public Optional<WhereModel> whereModel() {
         return Optional.ofNullable(whereModel);
     }
 
+    public Optional<Long> limit() {
+        return Optional.ofNullable(limit);
+    }
+
+    public Optional<OrderByModel> orderByModel() {
+        return Optional.ofNullable(orderByModel);
+    }
+
     @NotNull
     public DeleteStatementProvider render(RenderingStrategy renderingStrategy) {
         return DeleteRenderer.withDeleteModel(this)
@@ -64,6 +77,8 @@ public static class Builder {
         private SqlTable table;
         private String tableAlias;
         private WhereModel whereModel;
+        private Long limit;
+        private OrderByModel orderByModel;
 
         public Builder withTable(SqlTable table) {
             this.table = table;
@@ -80,6 +95,16 @@ public Builder withWhereModel(WhereModel whereModel) {
             return this;
         }
 
+        public Builder withLimit(Long limit) {
+            this.limit = limit;
+            return this;
+        }
+
+        public Builder withOrderByModel(OrderByModel orderByModel) {
+            this.orderByModel = orderByModel;
+            return this;
+        }
+
         public DeleteModel build() {
             return new DeleteModel(this);
         }

src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java

@@ -15,25 +15,28 @@
  */
 package org.mybatis.dynamic.sql.delete.render;
 
-import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
-
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.common.OrderByModel;
+import org.mybatis.dynamic.sql.common.OrderByRenderer;
 import org.mybatis.dynamic.sql.delete.DeleteModel;
 import org.mybatis.dynamic.sql.render.ExplicitTableAliasCalculator;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
+import org.mybatis.dynamic.sql.util.FragmentAndParameters;
+import org.mybatis.dynamic.sql.util.FragmentCollector;
 import org.mybatis.dynamic.sql.where.WhereModel;
-import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
 import org.mybatis.dynamic.sql.where.render.WhereRenderer;
 
 public class DeleteRenderer {
     private final DeleteModel deleteModel;
     private final RenderingStrategy renderingStrategy;
     private final TableAliasCalculator tableAliasCalculator;
+    private final AtomicInteger sequence = new AtomicInteger(1);
 
     private DeleteRenderer(Builder builder) {
         deleteModel = Objects.requireNonNull(builder.deleteModel);
@@ -44,46 +47,68 @@ private DeleteRenderer(Builder builder) {
     }
 
     public DeleteStatementProvider render() {
-        return deleteModel.whereModel()
-                .flatMap(this::renderWhereClause)
-                .map(this::renderWithWhereClause)
-                .orElseGet(this::renderWithoutWhereClause);
-    }
+        FragmentCollector fragmentCollector = new FragmentCollector();
 
-    private DeleteStatementProvider renderWithWhereClause(WhereClauseProvider whereClauseProvider) {
-        return DefaultDeleteStatementProvider.withDeleteStatement(calculateDeleteStatement(whereClauseProvider))
-                .withParameters(whereClauseProvider.getParameters())
-                .build();
+        fragmentCollector.add(calculateDeleteStatementStart());
+        calculateWhereClause().ifPresent(fragmentCollector::add);
+        calculateOrderByClause().ifPresent(fragmentCollector::add);
+        calculateLimitClause().ifPresent(fragmentCollector::add);
+
+        return toDeleteStatementProvider(fragmentCollector);
     }
 
-    private String calculateDeleteStatement(WhereClauseProvider whereClause) {
-        return calculateDeleteStatement()
-                + spaceBefore(whereClause.getWhereClause());
+    private DeleteStatementProvider toDeleteStatementProvider(FragmentCollector fragmentCollector) {
+        return DefaultDeleteStatementProvider
+                .withDeleteStatement(fragmentCollector.fragments().collect(Collectors.joining(" "))) //$NON-NLS-1$
+                .withParameters(fragmentCollector.parameters())
+                .build();
     }
 
-    private String calculateDeleteStatement() {
+    private FragmentAndParameters calculateDeleteStatementStart() {
         SqlTable table = deleteModel.table();
         String tableName = table.tableNameAtRuntime();
         String aliasedTableName = tableAliasCalculator.aliasForTable(table)
                 .map(a -> tableName + " " + a).orElse(tableName); //$NON-NLS-1$
 
-        return "delete from" + spaceBefore(aliasedTableName); //$NON-NLS-1$
+        return FragmentAndParameters.withFragment("delete from " + aliasedTableName) //$NON-NLS-1$
+                .build();
     }
 
-    private DeleteStatementProvider renderWithoutWhereClause() {
-        return DefaultDeleteStatementProvider.withDeleteStatement(calculateDeleteStatement())
-                .build();
+    private Optional<FragmentAndParameters> calculateWhereClause() {
+        return deleteModel.whereModel().flatMap(this::renderWhereClause);
     }
 
-    private Optional<WhereClauseProvider> renderWhereClause(WhereModel whereModel) {
+    private Optional<FragmentAndParameters> renderWhereClause(WhereModel whereModel) {
         return WhereRenderer.withWhereModel(whereModel)
                 .withRenderingStrategy(renderingStrategy)
-                .withSequence(new AtomicInteger(1))
+                .withSequence(sequence)
                 .withTableAliasCalculator(tableAliasCalculator)
                 .build()
                 .render();
     }
 
+    private Optional<FragmentAndParameters> calculateLimitClause() {
+        return deleteModel.limit().map(this::renderLimitClause);
+    }
+
+    private FragmentAndParameters renderLimitClause(Long limit) {
+        String mapKey = RenderingStrategy.formatParameterMapKey(sequence);
+        String jdbcPlaceholder =
+                renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, mapKey);
+
+        return FragmentAndParameters.withFragment("limit " + jdbcPlaceholder) //$NON-NLS-1$
+                .withParameter(mapKey, limit)
+                .build();
+    }
+
+    private Optional<FragmentAndParameters> calculateOrderByClause() {
+        return deleteModel.orderByModel().map(this::renderOrderByClause);
+    }
+
+    private FragmentAndParameters renderOrderByClause(OrderByModel orderByModel) {
+        return new OrderByRenderer().render(orderByModel);
+    }
+
     public static Builder withDeleteModel(DeleteModel deleteModel) {
         return new Builder().withDeleteModel(deleteModel);
     }

src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java

@@ -29,6 +29,7 @@
 import org.mybatis.dynamic.sql.SortSpecification;
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.TableExpression;
+import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.configuration.StatementConfiguration;
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL.FromGatherer;
 import org.mybatis.dynamic.sql.util.Buildable;
@@ -152,6 +153,10 @@ private List<QueryExpressionModel> buildModels() {
     }
 
     private PagingModel buildPagingModel() {
+        if (limit == null && offset == null && fetchFirstRows == null) {
+            return  null;
+        }
+
         return new PagingModel.Builder()
                 .withLimit(limit)
                 .withOffset(offset)
@@ -161,7 +166,7 @@ private PagingModel buildPagingModel() {
 
     public class LimitFinisher implements Buildable<R> {
         public OffsetFinisher offset(long offset) {
-            SelectDSL.this.offset = offset;
+            SelectDSL.this.offset(offset);
             return new OffsetFinisher();
         }
 
@@ -182,7 +187,7 @@ public R build() {
 
     public class OffsetFirstFinisher implements Buildable<R> {
         public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            SelectDSL.this.fetchFirstRows = fetchFirstRows;
+            SelectDSL.this.fetchFirst(fetchFirstRows);
             return new FetchFirstFinisher();
         }
 

src/main/java/org/mybatis/dynamic/sql/select/SelectModel.java

@@ -23,6 +23,7 @@
 import java.util.stream.Stream;
 
 import org.jetbrains.annotations.NotNull;
+import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.exception.InvalidSqlException;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.select.render.SelectRenderer;