Kotlin Support for Map to Row

Author: jeffgbutler

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

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.util.ConstantMapping
 import org.mybatis.dynamic.sql.util.NullMapping
 import org.mybatis.dynamic.sql.util.PropertyMapping
 import org.mybatis.dynamic.sql.util.PropertyWhenPresentMapping
+import org.mybatis.dynamic.sql.util.RowMapping
 import org.mybatis.dynamic.sql.util.StringConstantMapping
 import org.mybatis.dynamic.sql.util.ValueMapping
 import org.mybatis.dynamic.sql.util.ValueOrNullMapping
@@ -44,6 +45,8 @@ class MultiRowInsertColumnMapCompleter<T>(
     : AbstractInsertColumnMapCompleter<T>(column, mappingConsumer) {
 
     infix fun toProperty(property: String) = mappingConsumer.invoke(PropertyMapping.of(column, property))
+
+    fun toRow() = mappingConsumer.invoke(RowMapping.of(column))
 }
 
 class SingleRowInsertColumnMapCompleter<T>(
@@ -55,6 +58,8 @@ class SingleRowInsertColumnMapCompleter<T>(
 
     fun toPropertyWhenPresent(property: String, valueSupplier: () -> T?) =
         mappingConsumer.invoke(PropertyWhenPresentMapping.of(column, property, valueSupplier))
+
+    fun toRow() = mappingConsumer.invoke(RowMapping.of(column))
 }
 
 class GeneralInsertColumnSetCompleter<T>(

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

@@ -0,0 +1,30 @@
+/*
+ *    Copyright 2016-2023 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 examples.kotlin.spring.canonical
+
+import org.mybatis.dynamic.sql.SqlTable
+import org.mybatis.dynamic.sql.util.kotlin.elements.column
+
+object CompoundKeyDynamicSqlSupport {
+    val compoundKey = CompoundKey()
+    val id1 = compoundKey.id1
+    val id2 = compoundKey.id2
+
+    class CompoundKey : SqlTable("CompoundKey") {
+        val id1 = column<Int>(name = "id1")
+        val id2 = column<Int>(name = "id2")
+    }
+}

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

@@ -67,3 +67,8 @@ data class GeneratedAlwaysRecord(
     var lastName: String?,
     var fullName: String?
 )
+
+data class CompoundKeyRow(
+    var id1: Int,
+    var id2: Int
+)

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

@@ -55,3 +55,10 @@ val personWithAddressRowMapper: (ResultSet, Int) -> PersonWithAddress = { rs, _
         )
     )
 }
+
+val compoundKeyRowMapper: (ResultSet, Int) -> CompoundKeyRow = { rs, _ ->
+    CompoundKeyRow(
+        id1 =  rs.getInt(1),
+        id2 =  rs.getInt(2)
+    )
+}

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

@@ -0,0 +1,115 @@
+/*
+ *    Copyright 2016-2023 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 examples.kotlin.spring.canonical
+
+import examples.kotlin.spring.canonical.CompoundKeyDynamicSqlSupport.compoundKey
+import examples.kotlin.spring.canonical.CompoundKeyDynamicSqlSupport.id1
+import examples.kotlin.spring.canonical.CompoundKeyDynamicSqlSupport.id2
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.mybatis.dynamic.sql.util.kotlin.spring.insert
+import org.mybatis.dynamic.sql.util.kotlin.spring.insertBatch
+import org.mybatis.dynamic.sql.util.kotlin.spring.insertMultiple
+import org.mybatis.dynamic.sql.util.kotlin.spring.select
+import org.mybatis.dynamic.sql.util.kotlin.spring.selectList
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig
+import org.springframework.transaction.annotation.Transactional
+
+@SpringJUnitConfig(classes = [SpringConfiguration::class])
+@Transactional
+open class SpringKotlinMapToRowTest {
+    @Autowired
+    private lateinit var template: NamedParameterJdbcTemplate
+
+    @Test
+    fun testInsertOne() {
+        val i = 1
+
+        val insertStatement = insert(i) {
+            into(compoundKey)
+            map(id1).toConstant("22")
+            map(id2).toRow()
+        }
+
+        val expected = "insert into CompoundKey (id1, id2) values (22, :row)"
+        assertThat(insertStatement.insertStatement).isEqualTo(expected)
+
+        val rows = template.insert(insertStatement)
+        assertThat(rows).isEqualTo(1)
+
+        val selectStatement = select(id1, id2) {
+            from(compoundKey)
+            orderBy(id1, id2)
+        }
+
+        val records = template.selectList(selectStatement, compoundKeyRowMapper)
+        assertThat(records).hasSize(1)
+    }
+
+    @Test
+    open fun testInsertMultiple() {
+        val integers = listOf(1, 2, 3)
+
+        val insertStatement = insertMultiple(integers) {
+            into(compoundKey)
+            map(id1).toConstant("22")
+            map(id2).toRow()
+        }
+
+        val expected =
+            "insert into CompoundKey (id1, id2) values (22, :records[0]), (22, :records[1]), (22, :records[2])"
+        assertThat(insertStatement.insertStatement).isEqualTo(expected)
+
+        val rows = template.insertMultiple(insertStatement)
+        assertThat(rows).isEqualTo(3)
+
+        val selectStatement = select(id1, id2) {
+            from(compoundKey)
+            orderBy(id1, id2)
+        }
+
+        val records = template.selectList(selectStatement, compoundKeyRowMapper)
+        assertThat(records).hasSize(3)
+    }
+
+    @Test
+    open fun testInsertBatch() {
+        val integers = listOf(1, 2, 3)
+
+        val insertStatement = insertBatch(integers) {
+            into(compoundKey)
+            map(id1).toConstant("22")
+            map(id2).toRow()
+        }
+
+        val expected = "insert into CompoundKey (id1, id2) values (22, :row)"
+        assertThat(insertStatement.insertStatementSQL).isEqualTo(expected)
+
+        val rowCounts = template.insertBatch(insertStatement)
+        assertThat(rowCounts).hasSize(3)
+        assertThat(rowCounts.sum()).isEqualTo(3)
+
+        val selectStatement = select(id1, id2) {
+            from(compoundKey)
+            orderBy(id1, id2)
+        }
+
+        val records = template.selectList(selectStatement, compoundKeyRowMapper)
+        assertThat(records).hasSize(3)
+    }
+}

src/test/resources/examples/kotlin/spring/CreateSimpleDB.sql

@@ -16,6 +16,7 @@
 
 drop table Address if exists;
 drop table Person if exists;
+drop table CompoundKey if exists;
 
 create table Address (
    address_id int not null,
@@ -36,6 +37,12 @@ create table Person (
    primary key(id)
 );
 
+create table CompoundKey (
+   id1 int not null,
+   id2 int not null,
+   primary key (id1, id2)
+);
+
 insert into Address (address_id, street_address, city, state)
 values(1, '123 Main Street', 'Bedrock', 'IN');