Kotlin support and test coverage

Author: jeffgbutler

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

@@ -18,6 +18,7 @@ package org.mybatis.dynamic.sql.util.kotlin
 import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.SortSpecification
 import org.mybatis.dynamic.sql.SqlBuilder
+import org.mybatis.dynamic.sql.configuration.StatementConfiguration
 import org.mybatis.dynamic.sql.select.MultiSelectDSL
 import org.mybatis.dynamic.sql.select.MultiSelectModel
 import org.mybatis.dynamic.sql.util.Buildable
@@ -74,6 +75,10 @@ class KotlinMultiSelectBuilder: Buildable<MultiSelectModel> {
         getDsl().fetchFirst(fetchFirstRows).rowsOnly()
     }
 
+    fun configureStatement(c: StatementConfiguration.() -> Unit) {
+        getDsl().configureStatement(c)
+    }
+
     override fun build(): MultiSelectModel =
         getDsl().build()
 

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

@@ -19,6 +19,7 @@ import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.SqlBuilder
 import org.mybatis.dynamic.sql.SqlColumn
 import org.mybatis.dynamic.sql.SqlTable
+import org.mybatis.dynamic.sql.configuration.StatementConfiguration
 import org.mybatis.dynamic.sql.insert.InsertSelectModel
 import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.util.Buildable
@@ -63,6 +64,7 @@ typealias InsertSelectCompleter = KotlinInsertSelectSubQueryBuilder.() -> Unit
 class KotlinInsertSelectSubQueryBuilder : KotlinBaseSubQueryBuilder(), Buildable<InsertSelectModel> {
     private var columnList: List<SqlColumn<*>>? = null
     private var table: SqlTable? = null
+    private var statementConfigurator: (StatementConfiguration.() -> Unit)? = null
 
     fun into(table: SqlTable) {
         this.table = table
@@ -74,18 +76,24 @@ class KotlinInsertSelectSubQueryBuilder : KotlinBaseSubQueryBuilder(), Buildable
         this.columnList = columnList
     }
 
+    fun configureStatement(c: StatementConfiguration.() -> Unit) {
+        statementConfigurator = c
+    }
+
     override fun build(): InsertSelectModel {
         assertNotNull(table, "ERROR.29") //$NON-NLS-1$
 
-        return if (columnList == null) {
+        val dsl = if (columnList == null) {
             SqlBuilder.insertInto(table)
                 .withSelectStatement { buildSelectModel() }
-                .build()
         } else {
             SqlBuilder.insertInto(table)
                 .withColumnList(columnList)
                 .withSelectStatement { buildSelectModel() }
-                .build()
         }
+
+        statementConfigurator?.let { dsl.configureStatement(it) }
+
+        return dsl.build()
     }
 }

src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt

@@ -28,10 +28,12 @@ import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
 import org.apache.ibatis.session.ExecutorType
 import org.apache.ibatis.session.SqlSessionFactory
 import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.TestInstance.Lifecycle
+import org.mybatis.dynamic.sql.exception.NonRenderingWhereClauseException
 import org.mybatis.dynamic.sql.util.kotlin.elements.add
 import org.mybatis.dynamic.sql.util.kotlin.elements.constant
 import org.mybatis.dynamic.sql.util.kotlin.elements.isIn
@@ -824,4 +826,83 @@ class PersonMapperTest {
             }
         }
     }
+
+    @Test
+    fun testMultiSelectWithNonRenderingWhereClauseDisAllowed() {
+        assertThatExceptionOfType(NonRenderingWhereClauseException::class.java).isThrownBy {
+            multiSelect {
+                select(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId) {
+                    from(person)
+                    where { id isLessThanOrEqualTo 2 }
+                    orderBy(id)
+                    limit(1)
+                }
+                union {
+                    select(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId) {
+                        from(person)
+                        where { id isGreaterThanOrEqualToWhenPresent null }
+                        orderBy(id.descending())
+                        limit(1)
+                    }
+                }
+                orderBy(sortColumn("A_ID"))
+                limit(2)
+                offset(1)
+            }
+        }
+    }
+
+    @Test
+    fun testMultiSelectWithNonRenderingWhereClauseAllowed() {
+        val selectStatement = multiSelect {
+            select(id, firstName) {
+                from(person)
+                where { id isLessThanOrEqualTo 2 }
+            }
+            union {
+                select(id, firstName) {
+                    from(person)
+                    where { id isGreaterThanOrEqualToWhenPresent null }
+                    // following should be ignored in favor of the statement configuration...
+                    configureStatement { isNonRenderingWhereClauseAllowed = false }
+                }
+            }
+            configureStatement { isNonRenderingWhereClauseAllowed = true }
+        }
+
+        val expected = "(select id, first_name from Person where id <= #{parameters.p1,jdbcType=INTEGER}) " +
+                "union (select id, first_name from Person)"
+        assertThat(selectStatement.selectStatement).isEqualTo(expected)
+    }
+
+    @Test
+    fun testInsertSelectWithNonRenderingWhereClauseDisAllowed() {
+        assertThatExceptionOfType(NonRenderingWhereClauseException::class.java).isThrownBy {
+            insertSelect {
+                into(person)
+                select(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+                    from(person)
+                    where { id isGreaterThanOrEqualToWhenPresent null }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testInsertSelectWithNonRenderingWhereClauseAllowed() {
+        val insertStatement = insertSelect {
+            into(person)
+            select(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+                from(person)
+                where { id isGreaterThanOrEqualToWhenPresent null }
+                // following should be ignored in favor of the statement configuration...
+                configureStatement { isNonRenderingWhereClauseAllowed = false }
+            }
+            configureStatement { isNonRenderingWhereClauseAllowed = true }
+        }
+
+        val expected = "insert into Person " +
+                "select id, first_name, last_name, birth_date, employed, occupation, address_id from Person"
+        assertThat(insertStatement.insertStatement).isEqualTo(expected)
+    }
 }