Kotlin DSL statement configuration should not call where()

This could cause an exception if no where clause is specified

Author: jeffgbutler

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

@@ -16,6 +16,7 @@
 package org.mybatis.dynamic.sql.delete;
 
 import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.jetbrains.annotations.NotNull;
@@ -26,7 +27,8 @@
 import org.mybatis.dynamic.sql.where.AbstractWhereSupport;
 import org.mybatis.dynamic.sql.where.WhereModel;
 
-public class DeleteDSL<R> extends AbstractWhereSupport<DeleteDSL<R>.DeleteWhereBuilder> implements Buildable<R> {
+public class DeleteDSL<R> extends AbstractWhereSupport<DeleteDSL<R>.DeleteWhereBuilder, DeleteDSL<R>>
+        implements Buildable<R> {
 
     private final Function<DeleteModel, R> adapterFunction;
     private final SqlTable table;
@@ -66,6 +68,12 @@ public R build() {
         return adapterFunction.apply(deleteModelBuilder.build());
     }
 
+    @Override
+    public DeleteDSL<R> configureStatement(Consumer<StatementConfiguration> consumer) {
+        consumer.accept(statementConfiguration);
+        return this;
+    }
+
     public static <R> DeleteDSL<R> deleteFrom(Function<DeleteModel, R> adapterFunction, SqlTable table,
                                               String tableAlias) {
         return new DeleteDSL<>(table, tableAlias, adapterFunction);

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

@@ -38,7 +38,7 @@
 
 public abstract class AbstractQueryExpressionDSL<W extends AbstractWhereDSL<?>,
             T extends AbstractQueryExpressionDSL<W, T>>
-        extends AbstractWhereSupport<W> {
+        extends AbstractWhereSupport<W, T> {
 
     private final List<JoinSpecification.Builder> joinSpecificationBuilders = new ArrayList<>();
     private final Map<SqlTable, String> tableAliases = new HashMap<>();

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

@@ -16,6 +16,7 @@
 package org.mybatis.dynamic.sql.select;
 
 import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.jetbrains.annotations.NotNull;
@@ -64,6 +65,12 @@ public R build() {
         return adapterFunction.apply(buildModel());
     }
 
+    @Override
+    public CountDSL<R> configureStatement(Consumer<StatementConfiguration> consumer) {
+        consumer.accept(statementConfiguration);
+        return this;
+    }
+
     private SelectModel buildModel() {
         QueryExpressionModel.Builder b = new QueryExpressionModel.Builder()
                 .withSelectColumn(countColumn)

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

@@ -33,14 +33,13 @@
 import org.mybatis.dynamic.sql.select.join.JoinSpecification;
 import org.mybatis.dynamic.sql.select.join.JoinType;
 import org.mybatis.dynamic.sql.util.Buildable;
-import org.mybatis.dynamic.sql.util.ConfigurableStatement;
 import org.mybatis.dynamic.sql.where.AbstractWhereDSL;
 import org.mybatis.dynamic.sql.where.AbstractWhereSupport;
 import org.mybatis.dynamic.sql.where.WhereModel;
 
 public class QueryExpressionDSL<R>
         extends AbstractQueryExpressionDSL<QueryExpressionDSL<R>.QueryExpressionWhereBuilder, QueryExpressionDSL<R>>
-        implements Buildable<R>, ConfigurableStatement<QueryExpressionDSL<R>> {
+        implements Buildable<R> {
 
     private final String connector;
     private final SelectDSL<R> selectDSL;
@@ -332,7 +331,8 @@ public JoinSpecificationFinisher on(BasicColumn joinColumn, JoinCondition onJoin
         }
     }
 
-    public class JoinSpecificationFinisher extends AbstractWhereSupport<QueryExpressionWhereBuilder>
+    public class JoinSpecificationFinisher
+            extends AbstractWhereSupport<QueryExpressionWhereBuilder, JoinSpecificationFinisher>
             implements Buildable<R> {
         private final JoinSpecification.Builder joinSpecificationBuilder;
 
@@ -373,6 +373,12 @@ public R build() {
             return QueryExpressionDSL.this.build();
         }
 
+        @Override
+        public JoinSpecificationFinisher configureStatement(Consumer<StatementConfiguration> consumer) {
+            consumer.accept(statementConfiguration);
+            return this;
+        }
+
         @Override
         public QueryExpressionWhereBuilder where() {
             return QueryExpressionDSL.this.where();

src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java

@@ -18,6 +18,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -41,7 +42,8 @@
 import org.mybatis.dynamic.sql.where.AbstractWhereSupport;
 import org.mybatis.dynamic.sql.where.WhereModel;
 
-public class UpdateDSL<R> extends AbstractWhereSupport<UpdateDSL<R>.UpdateWhereBuilder> implements Buildable<R> {
+public class UpdateDSL<R> extends AbstractWhereSupport<UpdateDSL<R>.UpdateWhereBuilder, UpdateDSL<R>>
+        implements Buildable<R> {
 
     private final Function<UpdateModel, R> adapterFunction;
     private final List<AbstractColumnMapping> columnMappings = new ArrayList<>();
@@ -89,6 +91,12 @@ public R build() {
         return adapterFunction.apply(updateModelBuilder.build());
     }
 
+    @Override
+    public UpdateDSL<R> configureStatement(Consumer<StatementConfiguration> consumer) {
+        consumer.accept(statementConfiguration);
+        return this;
+    }
+
     public static <R> UpdateDSL<R> update(Function<UpdateModel, R> adapterFunction, SqlTable table, String tableAlias) {
         return new UpdateDSL<>(table, tableAlias, adapterFunction);
     }

src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereSupport.java

@@ -24,6 +24,7 @@
 import org.mybatis.dynamic.sql.ExistsPredicate;
 import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.VisitableCondition;
+import org.mybatis.dynamic.sql.util.ConfigurableStatement;
 
 /**
  * Base class for DSLs that support where clauses - which is every DSL except Insert.
@@ -33,7 +34,8 @@
  *
  * @param <W> the implementation of the Where DSL customized for a particular SQL statement.
  */
-public abstract class AbstractWhereSupport<W extends AbstractWhereDSL<?>> {
+public abstract class AbstractWhereSupport<W extends AbstractWhereDSL<?>, D extends AbstractWhereSupport<W, D>>
+        implements ConfigurableStatement<D> {
 
     public abstract W where();
 

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt

@@ -38,10 +38,10 @@ fun WhereApplier.andThen(after: WhereApplier): WhereApplier = {
 
 @MyBatisDslMarker
 @Suppress("TooManyFunctions")
-abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>> {
+abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*,*>> {
 
     fun configureStatement(c: StatementConfiguration.() -> Unit) {
-        getDsl().where().configureStatement(c)
+        getDsl().configureStatement(c)
     }
 
     fun where(criteria: GroupingCriteriaReceiver): Unit =

src/test/java/examples/joins/JoinMapperTest.java

@@ -163,6 +163,7 @@ void testCompoundJoin2() {
         SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity)
                 .from(orderMaster, "om")
                 .join(orderDetail, "od").on(orderMaster.orderId, equalTo(orderDetail.orderId))
+                .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
                 .and(orderMaster.orderId, equalTo(orderDetail.orderId))
                 .build()
                 .render(RenderingStrategies.MYBATIS3);

src/test/kotlin/examples/kotlin/spring/canonical/InfixElementsTest.kt

@@ -28,11 +28,14 @@ import org.mybatis.dynamic.sql.util.kotlin.KInvalidSQLException
 import org.mybatis.dynamic.sql.util.kotlin.elements.isLike
 import org.mybatis.dynamic.sql.util.kotlin.elements.stringConstant
 import org.mybatis.dynamic.sql.util.kotlin.elements.upper
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.count
+import org.mybatis.dynamic.sql.util.kotlin.spring.countFrom
 import org.mybatis.dynamic.sql.util.kotlin.spring.delete
 import org.mybatis.dynamic.sql.util.kotlin.spring.deleteFrom
 import org.mybatis.dynamic.sql.util.kotlin.spring.select
 import org.mybatis.dynamic.sql.util.kotlin.spring.selectList
 import org.mybatis.dynamic.sql.util.kotlin.spring.selectOne
+import org.mybatis.dynamic.sql.util.kotlin.spring.update
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig
@@ -1229,4 +1232,36 @@ open class InfixElementsTest {
         assertThat(rows).hasSize(2)
         assertThat(rows[0]).isEqualTo("Pebbles")
     }
+
+    @Test
+    fun testUpdate() {
+        val updateStatement = update(person) {
+            set(id) equalTo 1
+            // following should have no impact - where clause not specified
+            configureStatement { isNonRenderingWhereClauseAllowed = false }
+        }
+
+        assertThat(updateStatement.updateStatement).isEqualTo("update Person set id = :p1")
+    }
+
+    @Test
+    fun testCount() {
+        val selectStatement = countFrom(person) {
+            // following should have no impact - where clause not specified
+            configureStatement { isNonRenderingWhereClauseAllowed = false }
+        }
+
+        assertThat(selectStatement.selectStatement).isEqualTo("select count(*) from Person")
+    }
+
+    @Test
+    fun testQueryExpression() {
+        val selectStatement = select(id) {
+            from(person)
+            // following should have no impact - where clause not specified
+            configureStatement { isNonRenderingWhereClauseAllowed = false }
+        }
+
+        assertThat(selectStatement.selectStatement).isEqualTo("select id from Person")
+    }
 }