Add "WhenPresent" Versions of the Paging Methods

CHANGELOG.md

@@ -30,6 +30,8 @@ Other important changes:
   an empty In condition would render as invalid SQL and would usually cause a runtime exception from the database.
   With this change, the exception thrown is more predictable and the error is caught before sending the SQL to the
   database.
+- All the paging methods (limit, offset, fetchFirst) now have "WhenPresent" variations that will drop the phrase from
+  rendering if a null value is passed in 
 
 ## Release 1.5.2 - June 3, 2024
 

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

@@ -56,6 +56,10 @@ public DeleteWhereBuilder where() {
     }
 
     public DeleteDSL<R> limit(long limit) {
+        return limitWhenPresent(limit);
+    }
+
+    public DeleteDSL<R> limitWhenPresent(Long limit) {
         this.limit = limit;
         return this;
     }
@@ -115,7 +119,11 @@ private DeleteWhereBuilder() {
         }
 
         public DeleteDSL<R> limit(long limit) {
-            return DeleteDSL.this.limit(limit);
+            return limitWhenPresent(limit);
+        }
+
+        public DeleteDSL<R> limitWhenPresent(Long limit) {
+            return DeleteDSL.this.limitWhenPresent(limit);
         }
 
         public DeleteDSL<R> orderBy(SortSpecification... columns) {

src/main/java/org/mybatis/dynamic/sql/exception/NonRenderingWhereClauseException.java

@@ -15,12 +15,12 @@
  */
 package org.mybatis.dynamic.sql.exception;
 
+import java.io.Serial;
+
 import org.mybatis.dynamic.sql.configuration.GlobalConfiguration;
 import org.mybatis.dynamic.sql.configuration.StatementConfiguration;
 import org.mybatis.dynamic.sql.util.Messages;
 
-import java.io.Serial;
-
 /**
  * This exception is thrown when the where clause in a statement will not render.
  * This can happen if all the optional conditions in a where clause fail to

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

@@ -29,7 +29,8 @@
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.mybatis.dynamic.sql.util.ConfigurableStatement;
 
-public class MultiSelectDSL implements Buildable<MultiSelectModel>, ConfigurableStatement<MultiSelectDSL> {
+public class MultiSelectDSL implements Buildable<MultiSelectModel>, ConfigurableStatement<MultiSelectDSL>,
+        PagingDSL<MultiSelectModel> {
     private final List<UnionQuery> unionQueries = new ArrayList<>();
     private final SelectModel initialSelect;
     private OrderByModel orderByModel;
@@ -61,19 +62,22 @@ public MultiSelectDSL orderBy(Collection<? extends SortSpecification> columns) {
         return this;
     }
 
-    public LimitFinisher limit(long limit) {
+    @Override
+    public LimitFinisher<MultiSelectModel> limitWhenPresent(Long limit) {
         this.limit = limit;
-        return new LimitFinisher();
+        return new LF();
     }
 
-    public OffsetFirstFinisher offset(long offset) {
+    @Override
+    public OffsetFirstFinisher<MultiSelectModel> offsetWhenPresent(Long offset) {
         this.offset = offset;
-        return new OffsetFirstFinisher();
+        return new OFF();
     }
 
-    public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
+    @Override
+    public FetchFirstFinisher<MultiSelectModel> fetchFirstWhenPresent(Long fetchFirstRows) {
         this.fetchFirstRows = fetchFirstRows;
-        return new FetchFirstFinisher();
+        return new FFF();
     }
 
     @NotNull
@@ -102,31 +106,18 @@ public MultiSelectDSL configureStatement(Consumer<StatementConfiguration> consum
         return this;
     }
 
-    public class LimitFinisher implements Buildable<MultiSelectModel> {
-        public OffsetFinisher offset(long offset) {
-            MultiSelectDSL.this.offset(offset);
-            return new OffsetFinisher();
-        }
-
-        @NotNull
+    class FFF implements FetchFirstFinisher<MultiSelectModel> {
         @Override
-        public MultiSelectModel build() {
-            return MultiSelectDSL.this.build();
+        public Buildable<MultiSelectModel> rowsOnly() {
+            return MultiSelectDSL.this;
         }
     }
 
-    public class OffsetFinisher implements Buildable<MultiSelectModel> {
-        @NotNull
+    class LF implements LimitFinisher<MultiSelectModel> {
         @Override
-        public MultiSelectModel build() {
-            return MultiSelectDSL.this.build();
-        }
-    }
-
-    public class OffsetFirstFinisher implements Buildable<MultiSelectModel> {
-        public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            MultiSelectDSL.this.fetchFirst(fetchFirstRows);
-            return new FetchFirstFinisher();
+        public Buildable<MultiSelectModel> offsetWhenPresent(Long offset) {
+            MultiSelectDSL.this.offset = offset;
+            return MultiSelectDSL.this;
         }
 
         @NotNull
@@ -136,13 +127,13 @@ public MultiSelectModel build() {
         }
     }
 
-    public class FetchFirstFinisher {
-        public RowsOnlyFinisher rowsOnly() {
-            return new RowsOnlyFinisher();
+    class OFF implements OffsetFirstFinisher<MultiSelectModel> {
+        @Override
+        public FetchFirstFinisher<MultiSelectModel> fetchFirstWhenPresent(Long fetchFirstRows) {
+            MultiSelectDSL.this.fetchFirstRows = fetchFirstRows;
+            return new FFF();
         }
-    }
 
-    public class RowsOnlyFinisher implements Buildable<MultiSelectModel> {
         @NotNull
         @Override
         public MultiSelectModel build() {

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

@@ -0,0 +1,58 @@
+/*
+ *    Copyright 2016-2024 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.select;
+
+import org.mybatis.dynamic.sql.util.Buildable;
+
+public interface PagingDSL<T> {
+    default LimitFinisher<T> limit(long limit) {
+        return limitWhenPresent(limit);
+    }
+
+    LimitFinisher<T> limitWhenPresent(Long limit);
+
+    default OffsetFirstFinisher<T> offset(long offset) {
+        return offsetWhenPresent(offset);
+    }
+
+    OffsetFirstFinisher<T> offsetWhenPresent(Long offset);
+
+    default FetchFirstFinisher<T> fetchFirst(long fetchFirstRows) {
+        return fetchFirstWhenPresent(fetchFirstRows);
+    }
+
+    FetchFirstFinisher<T> fetchFirstWhenPresent(Long fetchFirstRows);
+
+    interface LimitFinisher<T> extends Buildable<T> {
+        default Buildable<T> offset(long offset) {
+            return offsetWhenPresent(offset);
+        }
+
+        Buildable<T> offsetWhenPresent(Long offset);
+    }
+
+    interface OffsetFirstFinisher<T> extends Buildable<T> {
+        default FetchFirstFinisher<T> fetchFirst(long fetchFirstRows) {
+            return fetchFirstWhenPresent(fetchFirstRows);
+        }
+
+        FetchFirstFinisher<T> fetchFirstWhenPresent(Long fetchFirstRows);
+    }
+
+    interface FetchFirstFinisher<T> {
+        Buildable<T> rowsOnly();
+    }
+}

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

@@ -42,7 +42,7 @@
 
 public class QueryExpressionDSL<R>
         extends AbstractQueryExpressionDSL<QueryExpressionDSL<R>.QueryExpressionWhereBuilder, QueryExpressionDSL<R>>
-        implements Buildable<R> {
+        implements Buildable<R>, PagingDSL<R> {
 
     private final String connector;
     private final SelectDSL<R> selectDSL;
@@ -194,16 +194,19 @@ protected QueryExpressionModel buildModel() {
                 .build();
     }
 
-    public SelectDSL<R>.LimitFinisher limit(long limit) {
-        return selectDSL.limit(limit);
+    @Override
+    public PagingDSL.LimitFinisher<R> limitWhenPresent(Long limit) {
+        return selectDSL.limitWhenPresent(limit);
     }
 
-    public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-        return selectDSL.offset(offset);
+    @Override
+    public PagingDSL.OffsetFirstFinisher<R> offsetWhenPresent(Long offset) {
+        return selectDSL.offsetWhenPresent(offset);
     }
 
-    public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-        return selectDSL.fetchFirst(fetchFirstRows);
+    @Override
+    public PagingDSL.FetchFirstFinisher<R> fetchFirstWhenPresent(Long fetchFirstRows) {
+        return selectDSL.fetchFirstWhenPresent(fetchFirstRows);
     }
 
     @Override
@@ -273,7 +276,7 @@ public FromGatherer<R> build() {
     }
 
     public class QueryExpressionWhereBuilder extends AbstractWhereFinisher<QueryExpressionWhereBuilder>
-            implements Buildable<R> {
+            implements Buildable<R>, PagingDSL<R> {
         private QueryExpressionWhereBuilder() {
             super(QueryExpressionDSL.this);
         }
@@ -302,16 +305,19 @@ public GroupByFinisher groupBy(Collection<? extends BasicColumn> columns) {
             return QueryExpressionDSL.this.groupBy(columns);
         }
 
-        public SelectDSL<R>.LimitFinisher limit(long limit) {
-            return QueryExpressionDSL.this.limit(limit);
+        @Override
+        public PagingDSL.LimitFinisher<R> limitWhenPresent(Long limit) {
+            return QueryExpressionDSL.this.limitWhenPresent(limit);
         }
 
-        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-            return QueryExpressionDSL.this.offset(offset);
+        @Override
+        public PagingDSL.OffsetFirstFinisher<R> offsetWhenPresent(Long offset) {
+            return QueryExpressionDSL.this.offsetWhenPresent(offset);
         }
 
-        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
+        @Override
+        public PagingDSL.FetchFirstFinisher<R> fetchFirstWhenPresent(Long fetchFirstRows) {
+            return QueryExpressionDSL.this.fetchFirstWhenPresent(fetchFirstRows);
         }
 
         @NotNull
@@ -351,7 +357,7 @@ public <T> JoinSpecificationFinisher on(BindableColumn<T> joinColumn, JoinCondit
 
     public class JoinSpecificationFinisher
             extends AbstractWhereStarter<QueryExpressionWhereBuilder, JoinSpecificationFinisher>
-            implements Buildable<R> {
+            implements Buildable<R>, PagingDSL<R> {
         private final JoinSpecification.Builder joinSpecificationBuilder;
 
         public <T> JoinSpecificationFinisher(TableExpression table, BindableColumn<T> joinColumn,
@@ -484,20 +490,24 @@ public SelectDSL<R> orderBy(Collection<? extends SortSpecification> columns) {
             return QueryExpressionDSL.this.orderBy(columns);
         }
 
-        public SelectDSL<R>.LimitFinisher limit(long limit) {
-            return QueryExpressionDSL.this.limit(limit);
+        @Override
+        public PagingDSL.LimitFinisher<R> limitWhenPresent(Long limit) {
+            return QueryExpressionDSL.this.limitWhenPresent(limit);
         }
 
-        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-            return QueryExpressionDSL.this.offset(offset);
+        @Override
+        public PagingDSL.OffsetFirstFinisher<R> offsetWhenPresent(Long offset) {
+            return QueryExpressionDSL.this.offsetWhenPresent(offset);
         }
 
-        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
+        @Override
+        public PagingDSL.FetchFirstFinisher<R> fetchFirstWhenPresent(Long fetchFirstRows) {
+            return QueryExpressionDSL.this.fetchFirstWhenPresent(fetchFirstRows);
         }
     }
 
-    public class GroupByFinisher extends AbstractHavingStarter<QueryExpressionHavingBuilder> implements Buildable<R> {
+    public class GroupByFinisher extends AbstractHavingStarter<QueryExpressionHavingBuilder>
+            implements Buildable<R>, PagingDSL<R> {
         public SelectDSL<R> orderBy(SortSpecification... columns) {
             return orderBy(Arrays.asList(columns));
         }
@@ -520,16 +530,19 @@ public UnionBuilder unionAll() {
             return QueryExpressionDSL.this.unionAll();
         }
 
-        public SelectDSL<R>.LimitFinisher limit(long limit) {
-            return QueryExpressionDSL.this.limit(limit);
+        @Override
+        public PagingDSL.LimitFinisher<R> limitWhenPresent(Long limit) {
+            return QueryExpressionDSL.this.limitWhenPresent(limit);
         }
 
-        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-            return QueryExpressionDSL.this.offset(offset);
+        @Override
+        public PagingDSL.OffsetFirstFinisher<R> offsetWhenPresent(Long offset) {
+            return QueryExpressionDSL.this.offsetWhenPresent(offset);
         }
 
-        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
+        @Override
+        public PagingDSL.FetchFirstFinisher<R> fetchFirstWhenPresent(Long fetchFirstRows) {
+            return QueryExpressionDSL.this.fetchFirstWhenPresent(fetchFirstRows);
         }
 
         @Override
@@ -572,18 +585,21 @@ public FromGatherer<R> selectDistinct(List<BasicColumn> selectList) {
     }
 
     public class QueryExpressionHavingBuilder extends AbstractHavingFinisher<QueryExpressionHavingBuilder>
-            implements Buildable<R> {
+            implements Buildable<R>, PagingDSL<R> {
 
-        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
+        @Override
+        public PagingDSL.LimitFinisher<R> limitWhenPresent(Long limit) {
+            return QueryExpressionDSL.this.limitWhenPresent(limit);
         }
 
-        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-            return QueryExpressionDSL.this.offset(offset);
+        @Override
+        public PagingDSL.OffsetFirstFinisher<R> offsetWhenPresent(Long offset) {
+            return QueryExpressionDSL.this.offsetWhenPresent(offset);
         }
 
-        public SelectDSL<R>.LimitFinisher limit(long limit) {
-            return QueryExpressionDSL.this.limit(limit);
+        @Override
+        public PagingDSL.FetchFirstFinisher<R> fetchFirstWhenPresent(Long fetchFirstRows) {
+            return QueryExpressionDSL.this.fetchFirstWhenPresent(fetchFirstRows);
         }
 
         public SelectDSL<R> orderBy(SortSpecification... columns) {