[Kotlin] Improve the insertSelect DSL methods

jeffgbutler · jeffgbutler · commit 4f76d0e89bc2 · 2022-08-30T10:53:26.000-04:00
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSubQueryBuilders.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSubQueryBuilders.kt
@@ -18,6 +18,8 @@ package org.mybatis.dynamic.sql.util.kotlin
 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.insert.InsertSelectModel
 import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.util.Buildable
 import org.mybatis.dynamic.sql.util.Messages
@@ -57,11 +59,34 @@ class KotlinQualifiedSubQueryBuilder : KotlinBaseSubQueryBuilder() {
 typealias InsertSelectCompleter = KotlinInsertSelectSubQueryBuilder.() -> Unit
 
 class KotlinInsertSelectSubQueryBuilder : KotlinBaseSubQueryBuilder() {
-    internal var columnList: List<SqlColumn<*>>? = null
+    private var columnList: List<SqlColumn<*>>? = null
+    private var table: SqlTable? = null
+
+    fun into(table: SqlTable) {
+        this.table = table
+    }
 
     fun columns(vararg columnList: SqlColumn<*>): Unit = columns(columnList.asList())
 
     fun columns(columnList: List<SqlColumn<*>>) {
         this.columnList = columnList
     }
+
+    // TODO - should just be build()
+    fun buildInsertSelectModel(): InsertSelectModel {
+        if (table == null) {
+            throw KInvalidSQLException(Messages.getString("ERROR.29")) //$NON-NLS-1$
+        }
+
+        return if (columnList == null) {
+            SqlBuilder.insertInto(table)
+                .withSelectStatement(this)
+                .build()
+        } else {
+            SqlBuilder.insertInto(table)
+                .withColumnList(columnList)
+                .withSelectStatement(this)
+                .build()
+        }
+    }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt
@@ -77,20 +77,17 @@ fun insertInto(table: SqlTable, completer: GeneralInsertCompleter): GeneralInser
 fun <T : Any> insertMultiple(rows: Collection<T>, completer: KotlinMultiRowInsertCompleter<T>): MultiRowInsertModel<T> =
     KotlinMultiRowInsertBuilder(rows).apply(completer).build()
 
+@Deprecated("Please use the new form - move the table into the lambda with into(table)")
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectModel =
-    with(KotlinInsertSelectSubQueryBuilder().apply(completer)) {
-        if (columnList == null) {
-            SqlBuilder.insertInto(table)
-                .withSelectStatement(this)
-                .build()
-        } else {
-            SqlBuilder.insertInto(table)
-                .withColumnList(columnList)
-                .withSelectStatement(this)
-                .build()
-        }
+    with(KotlinInsertSelectSubQueryBuilder()) {
+        into(table)
+        apply(completer)
+        buildInsertSelectModel()
     }
 
+fun insertSelect(completer: InsertSelectCompleter): InsertSelectModel =
+    KotlinInsertSelectSubQueryBuilder().apply(completer).buildInsertSelectModel()
+
 @Deprecated("Please switch to the insertBatch statement in the model package")
 fun <T> BatchInsertDSL.IntoGatherer<T>.into(
     table: SqlTable,
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt
@@ -128,7 +128,10 @@ fun insertSelect(
     table: SqlTable,
     completer: InsertSelectCompleter
 ): Int =
-    insertSelect(table, completer).run(mapper)
+    insertSelect {
+        into(table)
+        run(completer)
+    }.run(mapper)
 
 fun <T> selectDistinct(
     mapper: (SelectStatementProvider) -> List<T>,
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt
@@ -83,9 +83,13 @@ fun <T : Any> insertMultiple(
 ): MultiRowInsertStatementProvider<T> =
     insertMultiple(rows, completer).render(RenderingStrategies.MYBATIS3)
 
+@Deprecated("Please use the new form - move the table into the lambda with into(table)")
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectStatementProvider =
     insertSelect(table, completer).render(RenderingStrategies.MYBATIS3)
 
+fun insertSelect(completer: InsertSelectCompleter): InsertSelectStatementProvider =
+    insertSelect(completer).render(RenderingStrategies.MYBATIS3)
+
 @Deprecated("Please switch to the insertBatch statement in the mybatis3 package")
 fun <T> BatchInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: BatchInsertDSL<T>.() -> Unit): BatchInsert<T> =
     into(table, completer).render(RenderingStrategies.MYBATIS3)
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt
@@ -148,9 +148,13 @@ fun <T> NamedParameterJdbcTemplate.insertMultiple(
 ): Int =
     update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement), keyHolder)
 
+@Deprecated("Please use the new form - move the table into the lambda with into(table)")
 fun NamedParameterJdbcTemplate.insertSelect(table: SqlTable, completer: InsertSelectCompleter): Int =
     insertSelect(org.mybatis.dynamic.sql.util.kotlin.spring.insertSelect(table, completer))
 
+fun NamedParameterJdbcTemplate.insertSelect(completer: InsertSelectCompleter): Int =
+    insertSelect(org.mybatis.dynamic.sql.util.kotlin.spring.insertSelect(completer))
+
 fun NamedParameterJdbcTemplate.insertSelect(insertStatement: InsertSelectStatementProvider): Int =
     update(insertStatement.insertStatement, MapSqlParameterSource(insertStatement.parameters))
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt
@@ -83,9 +83,13 @@ fun <T : Any> insertMultiple(
 ): MultiRowInsertStatementProvider<T> =
     insertMultiple(rows, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
+@Deprecated("Please use the new form - move the table into the lambda with into(table)")
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectStatementProvider =
     insertSelect(table, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
+fun insertSelect(completer: InsertSelectCompleter): InsertSelectStatementProvider =
+    insertSelect(completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
+
 @Deprecated("Please switch to the insertBatch statement in the spring package")
 fun <T> BatchInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: BatchInsertDSL<T>.() -> Unit): BatchInsert<T> =
     into(table, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
diff --git a/src/main/resources/org/mybatis/dynamic/sql/util/messages.properties b/src/main/resources/org/mybatis/dynamic/sql/util/messages.properties
@@ -44,3 +44,4 @@ ERROR.25=Insert Statements Must Contain an "into" phrase
 ERROR.26=Multiple Row Insert Statements Must Contain an "into" phrase
 ERROR.27=You must specify a "from" clause before any other clauses in a select statement
 ERROR.28=You must specify a select statement in a sub query
+ERROR.29=Insert Select Statements Must Contain an "into" phrase
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
@@ -38,6 +38,7 @@ 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
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertInto
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertSelect
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
 import java.sql.DriverManager
@@ -258,6 +259,32 @@ class PersonMapperTest {
         }
     }
 
+    @Test
+    fun testDeprecatedInsertSelect() {
+        newSession().use { session ->
+            val mapper = session.getMapper(PersonMapper::class.java)
+
+            val insertStatement = insertSelect(person) {
+                columns(id, firstName, lastName, employed, occupation, addressId, birthDate)
+                select(add(id, constant<Int>("100")), firstName, lastName, employed, occupation, addressId, birthDate) {
+                    from(person)
+                    orderBy(id)
+                }
+            }
+
+            val expected = "insert into Person " +
+                    "(id, first_name, last_name, employed, occupation, address_id, birth_date) " +
+                    "select (id + 100), first_name, last_name, employed, occupation, address_id, birth_date " +
+                    "from Person order by id"
+
+            assertThat(insertStatement.insertStatement).isEqualTo(expected)
+
+            val rows = mapper.insertSelect(insertStatement)
+
+            assertThat(rows).isEqualTo(6)
+        }
+    }
+
     @Test
     fun testInsertBatch() {
         newSession(ExecutorType.BATCH).use { session ->
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt
@@ -303,6 +303,39 @@ open class CanonicalSpringKotlinTemplateDirectTest {
 
     @Test
     fun testInsertSelect() {
+        val rows = template.insertSelect {
+            into(person)
+            columns(id, firstName, lastName, birthDate, employed, occupation, addressId)
+            select(
+                add(id, constant<Int>("100")), firstName, lastName, birthDate, employed, occupation, addressId
+            ) {
+                from(person)
+                orderBy(id)
+            }
+        }
+
+        assertThat(rows).isEqualTo(6)
+
+        val records = template.select(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+            from(person)
+            where { id isGreaterThanOrEqualTo 100 }
+            orderBy(id)
+        }.withRowMapper(personRowMapper)
+
+        assertThat(records).hasSize(6)
+        with(records[1]) {
+            assertThat(id).isEqualTo(102)
+            assertThat(firstName).isEqualTo("Wilma")
+            assertThat(lastName).isEqualTo(LastName("Flintstone"))
+            assertThat(birthDate).isNotNull
+            assertThat(employed).isTrue
+            assertThat(occupation).isEqualTo("Accountant")
+            assertThat(addressId).isEqualTo(1)
+        }
+    }
+
+    @Test
+    fun testDeprecatedInsertSelect() {
         val rows = template.insertSelect(person) {
             columns(id, firstName, lastName, birthDate, employed, occupation, addressId)
             select(
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
@@ -512,7 +512,8 @@ open class CanonicalSpringKotlinTest {
 
     @Test
     fun testInsertSelect() {
-        val insertStatement = insertSelect(person) {
+        val insertStatement = insertSelect {
+            into(person)
             columns(id, firstName, lastName, birthDate, employed, occupation, addressId)
             select(add(id, constant<Int>("100")), firstName, lastName, birthDate, employed, occupation, addressId) {
                 from(person)
@@ -547,6 +548,56 @@ open class CanonicalSpringKotlinTest {
         }
     }
 
+    @Test
+    fun testInsertSelectNoTable() {
+        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
+            insertSelect {
+                columns(id, firstName, lastName, birthDate, employed, occupation, addressId)
+                select(add(id, constant<Int>("100")), firstName, lastName, birthDate, employed, occupation, addressId) {
+                    from(person)
+                    orderBy(id)
+                }
+            }
+        }.withMessage(Messages.getString("ERROR.29"))
+    }
+
+    @Test
+    fun testDeprecatedInsertSelect() {
+        val insertStatement = insertSelect(person) {
+            columns(id, firstName, lastName, birthDate, employed, occupation, addressId)
+            select(add(id, constant<Int>("100")), firstName, lastName, birthDate, employed, occupation, addressId) {
+                from(person)
+                orderBy(id)
+            }
+        }
+
+        assertThat(insertStatement.insertStatement).isEqualTo(
+            "insert into Person (id, first_name, last_name, birth_date, employed, occupation, address_id) " +
+                    "select (id + 100), first_name, last_name, birth_date, employed, occupation, address_id " +
+                    "from Person " +
+                    "order by id"
+        )
+        val rows = template.insertSelect(insertStatement)
+        assertThat(rows).isEqualTo(6)
+
+        val records = template.select(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+            from(person)
+            where { id isGreaterThanOrEqualTo 100 }
+            orderBy(id)
+        }.withRowMapper(personRowMapper)
+
+        assertThat(records).hasSize(6)
+        with(records[1]) {
+            assertThat(id).isEqualTo(102)
+            assertThat(firstName).isEqualTo("Wilma")
+            assertThat(lastName).isEqualTo(LastName("Flintstone"))
+            assertThat(birthDate).isNotNull
+            assertThat(employed).isTrue
+            assertThat(occupation).isEqualTo("Accountant")
+            assertThat(addressId).isEqualTo(1)
+        }
+    }
+
     @Test
     fun testInsertSelectNoColumns() {
         val insertStatement = insertSelect(person) {
