Add Kotlin Support for MappedColumns with inserts

Author: jeffgbutler

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

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.insert.BatchInsertDSL
 import org.mybatis.dynamic.sql.insert.BatchInsertModel
 import org.mybatis.dynamic.sql.util.AbstractColumnMapping
 import org.mybatis.dynamic.sql.util.Buildable
+import org.mybatis.dynamic.sql.util.MappedColumnMapping
 
 typealias KotlinBatchInsertCompleter<T> = KotlinBatchInsertBuilder<T>.() -> Unit
 
@@ -37,6 +38,10 @@ class KotlinBatchInsertBuilder<T : Any> (private val rows: Collection<T>): Build
         columnMappings.add(it)
     }
 
+    fun <C : Any> withMappedColumn(column: SqlColumn<C>) {
+        columnMappings.add(MappedColumnMapping.of(column))
+    }
+
     override fun build(): BatchInsertModel<T> {
         assertNotNull(table, "ERROR.23") //$NON-NLS-1$
         return with(BatchInsertDSL.Builder<T>()) {

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

@@ -21,6 +21,8 @@ import org.mybatis.dynamic.sql.insert.InsertDSL
 import org.mybatis.dynamic.sql.insert.InsertModel
 import org.mybatis.dynamic.sql.util.AbstractColumnMapping
 import org.mybatis.dynamic.sql.util.Buildable
+import org.mybatis.dynamic.sql.util.MappedColumnMapping
+import org.mybatis.dynamic.sql.util.MappedColumnWhenPresentMapping
 
 typealias KotlinInsertCompleter<T> = KotlinInsertBuilder<T>.() -> Unit
 
@@ -37,6 +39,14 @@ class KotlinInsertBuilder<T : Any> (private val row: T): Buildable<InsertModel<T
         columnMappings.add(it)
     }
 
+    fun <C : Any> withMappedColumn(column: SqlColumn<C>) {
+        columnMappings.add(MappedColumnMapping.of(column))
+    }
+
+    fun <C : Any> withMappedColumnWhenPresent(column: SqlColumn<C>, valueSupplier: () -> Any?) {
+        columnMappings.add(MappedColumnWhenPresentMapping.of(column, valueSupplier))
+    }
+
     override fun build(): InsertModel<T> {
         assertNotNull(table, "ERROR.25") //$NON-NLS-1$
         return with(InsertDSL.Builder<T>()) {

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

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL
 import org.mybatis.dynamic.sql.insert.MultiRowInsertModel
 import org.mybatis.dynamic.sql.util.AbstractColumnMapping
 import org.mybatis.dynamic.sql.util.Buildable
+import org.mybatis.dynamic.sql.util.MappedColumnMapping
 
 typealias KotlinMultiRowInsertCompleter<T> = KotlinMultiRowInsertBuilder<T>.() -> Unit
 
@@ -37,6 +38,10 @@ class KotlinMultiRowInsertBuilder<T : Any> (private val rows: Collection<T>): Bu
         columnMappings.add(it)
     }
 
+    fun <C : Any> withMappedColumn(column: SqlColumn<C>) {
+        columnMappings.add(MappedColumnMapping.of(column))
+    }
+
     override fun build(): MultiRowInsertModel<T> {
         assertNotNull(table, "ERROR.26") //$NON-NLS-1$
         return with(MultiRowInsertDSL.Builder<T>()) {

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlTableExtensions.kt

@@ -34,7 +34,8 @@ fun <T : Any> SqlTable.column(
     typeHandler: String? = null,
     renderingStrategy: RenderingStrategy? = null,
     parameterTypeConverter: ((T?) -> Any?) = { it },
-    javaType: KClass<T>? = null
+    javaType: KClass<T>? = null,
+    javaProperty: String? = null,
 ): SqlColumn<T> = SqlColumn.Builder<T>().run {
     withTable(this@column)
     withName(name)
@@ -43,5 +44,6 @@ fun <T : Any> SqlTable.column(
     withRenderingStrategy(renderingStrategy)
     withParameterTypeConverter(parameterTypeConverter)
     withJavaType(javaType?.java)
+    withJavaProperty(javaProperty)
     build()
 }

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

@@ -31,20 +31,22 @@ object PersonDynamicSqlSupport {
     val addressId = person.addressId
 
     class Person : SqlTable("Person") {
-        val id = column<Int>(name = "id", jdbcType = JDBCType.INTEGER)
-        val firstName = column<String>(name = "first_name", jdbcType = JDBCType.VARCHAR)
+        val id = column<Int>(name = "id", jdbcType = JDBCType.INTEGER, javaProperty = "id")
+        val firstName = column<String>(name = "first_name", jdbcType = JDBCType.VARCHAR, javaProperty = "firstName")
         val lastName = column<LastName>(
             name = "last_name",
             jdbcType = JDBCType.VARCHAR,
-            typeHandler = "examples.kotlin.mybatis3.canonical.LastNameTypeHandler"
+            typeHandler = "examples.kotlin.mybatis3.canonical.LastNameTypeHandler",
+            javaProperty = "lastName"
         )
-        val birthDate = column<Date>(name = "birth_date", jdbcType = JDBCType.DATE)
+        val birthDate = column<Date>(name = "birth_date", jdbcType = JDBCType.DATE, javaProperty = "birthDate")
         val employed = column<Boolean>(
             name = "employed",
             JDBCType.VARCHAR,
-            typeHandler = "examples.kotlin.mybatis3.canonical.YesNoTypeHandler"
+            typeHandler = "examples.kotlin.mybatis3.canonical.YesNoTypeHandler",
+            javaProperty = "employed"
         )
-        val occupation = column<String>(name = "occupation", jdbcType = JDBCType.VARCHAR)
-        val addressId = column<Int>(name = "address_id", jdbcType = JDBCType.INTEGER)
+        val occupation = column<String>(name = "occupation", jdbcType = JDBCType.VARCHAR, javaProperty = "occupation")
+        val addressId = column<Int>(name = "address_id", jdbcType = JDBCType.INTEGER, javaProperty = "addressId")
     }
 }

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

@@ -65,13 +65,13 @@ fun PersonMapper.deleteByPrimaryKey(id_: Int) =
 
 fun PersonMapper.insert(record: PersonRecord) =
     insert(this::insert, record, person) {
-        map(id) toProperty "id"
-        map(firstName) toProperty "firstName"
-        map(lastName) toProperty "lastName"
-        map(birthDate) toProperty "birthDate"
-        map(employed) toProperty "employed"
-        map(occupation) toProperty "occupation"
-        map(addressId) toProperty "addressId"
+        withMappedColumn(id)
+        withMappedColumn(firstName)
+        withMappedColumn(lastName)
+        withMappedColumn(birthDate)
+        withMappedColumn(employed)
+        withMappedColumn(occupation)
+        withMappedColumn(addressId)
     }
 
 fun PersonMapper.generalInsert(completer: GeneralInsertCompleter) =
@@ -85,38 +85,38 @@ fun PersonMapper.insertBatch(vararg records: PersonRecord): List<Int> =
 
 fun PersonMapper.insertBatch(records: Collection<PersonRecord>): List<Int> =
     insertBatch(this::insert, records, person) {
-        map(id) toProperty "id"
-        map(firstName) toProperty "firstName"
-        map(lastName) toProperty "lastName"
-        map(birthDate) toProperty "birthDate"
-        map(employed) toProperty "employed"
-        map(occupation) toProperty "occupation"
-        map(addressId) toProperty "addressId"
+        withMappedColumn(id)
+        withMappedColumn(firstName)
+        withMappedColumn(lastName)
+        withMappedColumn(birthDate)
+        withMappedColumn(employed)
+        withMappedColumn(occupation)
+        withMappedColumn(addressId)
     }
 
 fun PersonMapper.insertMultiple(vararg records: PersonRecord) =
     insertMultiple(records.toList())
 
 fun PersonMapper.insertMultiple(records: Collection<PersonRecord>) =
     insertMultiple(this::insertMultiple, records, person) {
-        map(id) toProperty "id"
-        map(firstName) toProperty "firstName"
-        map(lastName) toProperty "lastName"
-        map(birthDate) toProperty "birthDate"
-        map(employed) toProperty "employed"
-        map(occupation) toProperty "occupation"
-        map(addressId) toProperty "addressId"
+        withMappedColumn(id)
+        withMappedColumn(firstName)
+        withMappedColumn(lastName)
+        withMappedColumn(birthDate)
+        withMappedColumn(employed)
+        withMappedColumn(occupation)
+        withMappedColumn(addressId)
     }
 
 fun PersonMapper.insertSelective(record: PersonRecord) =
     insert(this::insert, record, person) {
-        map(id).toPropertyWhenPresent("id", record::id)
-        map(firstName).toPropertyWhenPresent("firstName", record::firstName)
-        map(lastName).toPropertyWhenPresent("lastName", record::lastName)
-        map(birthDate).toPropertyWhenPresent("birthDate", record::birthDate)
-        map(employed).toPropertyWhenPresent("employed", record::employed)
-        map(occupation).toPropertyWhenPresent("occupation", record::occupation)
-        map(addressId).toPropertyWhenPresent("addressId", record::addressId)
+        withMappedColumnWhenPresent(id, record::id)
+        withMappedColumnWhenPresent(firstName, record::firstName)
+        withMappedColumnWhenPresent(lastName, record::lastName)
+        withMappedColumnWhenPresent(birthDate, record::birthDate)
+        withMappedColumnWhenPresent(employed, record::employed)
+        withMappedColumnWhenPresent(occupation, record::occupation)
+        withMappedColumnWhenPresent(addressId, record::addressId)
     }
 
 private val columnList = listOf(id `as` "A_ID", firstName, lastName, birthDate, employed, occupation, addressId)