Add Kotlin support for javaType on SqlColumn

Author: jeffgbutler

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

@@ -19,6 +19,7 @@ import org.mybatis.dynamic.sql.SqlColumn
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.render.RenderingStrategy
 import java.sql.JDBCType
+import kotlin.reflect.KClass
 
 /**
  * This function replaces the native functions in [@see SqlColumn} such as
@@ -31,7 +32,8 @@ fun <T : Any> SqlTable.column(
     jdbcType: JDBCType? = null,
     typeHandler: String? = null,
     renderingStrategy: RenderingStrategy? = null,
-    parameterTypeConverter: ((T?) -> Any?)? = null
+    parameterTypeConverter: ((T?) -> Any?)? = null,
+    javaType: KClass<T>? = null
 ): SqlColumn<T> {
     var column: SqlColumn<T> = if (jdbcType == null) {
         column(name)
@@ -51,5 +53,9 @@ fun <T : Any> SqlTable.column(
         column = column.withParameterTypeConverter(parameterTypeConverter)
     }
 
+    if (javaType != null) {
+        column = column.withJavaType(javaType.java)
+    }
+
     return column
 }

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

@@ -25,11 +25,18 @@ object AddressDynamicSqlSupport {
     val streetAddress = address.streetAddress
     val city = address.city
     val state = address.state
+    val addressType = address.addressType
 
     class Address : SqlTable("Address") {
         val id = column<Int>(name = "address_id", jdbcType = JDBCType.INTEGER)
         val streetAddress = column<String>(name = "street_address", jdbcType = JDBCType.VARCHAR)
         val city = column<String>(name = "city", jdbcType = JDBCType.VARCHAR)
         val state = column<String>(name = "state", jdbcType = JDBCType.VARCHAR)
+        val addressType = column(
+            name = "address_type",
+            jdbcType = JDBCType.INTEGER,
+            javaType = AddressType::class,
+            typeHandler = "org.apache.ibatis.type.EnumOrdinalTypeHandler"
+        )
     }
 }

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

@@ -0,0 +1,21 @@
+/*
+ *    Copyright 2016-2021 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
+ *
+ *       http://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.mybatis3.canonical
+
+import org.mybatis.dynamic.sql.util.mybatis3.CommonInsertMapper
+import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper
+
+interface AddressMapper: CommonInsertMapper<AddressRecord>, CommonSelectMapper

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -19,5 +19,10 @@ data class AddressRecord(
     var id: Int? = null,
     var streetAddress: String? = null,
     var city: String? = null,
-    var state: String? = null
+    var state: String? = null,
+    var addressType: AddressType? = null
 )
+
+enum class AddressType {
+    HOME, BUSINESS
+}

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

@@ -15,14 +15,15 @@
  */
 package examples.kotlin.mybatis3.canonical
 
-import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+import examples.kotlin.mybatis3.canonical.AddressDynamicSqlSupport.address
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.addressId
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.birthDate
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.employed
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.lastName
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.occupation
+import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
 import org.apache.ibatis.datasource.unpooled.UnpooledDataSource
 import org.apache.ibatis.jdbc.ScriptRunner
 import org.apache.ibatis.mapping.Environment
@@ -44,9 +45,11 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.isLike
 import org.mybatis.dynamic.sql.util.kotlin.elements.isNotLike
 import org.mybatis.dynamic.sql.util.kotlin.elements.isNull
 import org.mybatis.dynamic.sql.util.kotlin.elements.isTrue
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertInto
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
 import java.sql.DriverManager
-import java.util.Date
+import java.util.*
 
 class PersonMapperTest {
     private fun newSession(executorType: ExecutorType = ExecutorType.REUSE): SqlSession {
@@ -55,7 +58,7 @@ class PersonMapperTest {
         DriverManager.getConnection(JDBC_URL, "sa", "").use { connection ->
             val sr = ScriptRunner(connection)
             sr.setLogWriter(null)
-            sr.runScript(InputStreamReader(script))
+            sr.runScript(InputStreamReader(script!!))
         }
 
         val ds = UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", "")
@@ -64,6 +67,7 @@ class PersonMapperTest {
         config.typeHandlerRegistry.register(YesNoTypeHandler::class.java)
         config.addMapper(PersonMapper::class.java)
         config.addMapper(PersonWithAddressMapper::class.java)
+        config.addMapper(AddressMapper::class.java)
         return SqlSessionFactoryBuilder().build(config).openSession(executorType)
     }
 
@@ -600,6 +604,11 @@ class PersonMapperTest {
                 assertThat(address?.streetAddress).isEqualTo("123 Main Street")
                 assertThat(address?.city).isEqualTo("Bedrock")
                 assertThat(address?.state).isEqualTo("IN")
+                assertThat(address?.addressType).isEqualTo(AddressType.HOME)
+            }
+
+            with(records[4]) {
+                assertThat(address?.addressType).isEqualTo(AddressType.BUSINESS)
             }
         }
     }
@@ -625,6 +634,7 @@ class PersonMapperTest {
                 assertThat(address?.streetAddress).isEqualTo("123 Main Street")
                 assertThat(address?.city).isEqualTo("Bedrock")
                 assertThat(address?.state).isEqualTo("IN")
+                assertThat(address?.addressType).isEqualTo(AddressType.HOME)
             }
         }
     }
@@ -650,6 +660,7 @@ class PersonMapperTest {
                 assertThat(address?.streetAddress).isEqualTo("123 Main Street")
                 assertThat(address?.city).isEqualTo("Bedrock")
                 assertThat(address?.state).isEqualTo("IN")
+                assertThat(address?.addressType).isEqualTo(AddressType.HOME)
             }
         }
     }
@@ -673,6 +684,7 @@ class PersonMapperTest {
                 assertThat(address?.streetAddress).isEqualTo("123 Main Street")
                 assertThat(address?.city).isEqualTo("Bedrock")
                 assertThat(address?.state).isEqualTo("IN")
+                assertThat(address?.addressType).isEqualTo(AddressType.HOME)
             }
         }
     }
@@ -688,6 +700,33 @@ class PersonMapperTest {
         }
     }
 
+    @Test
+    fun testWithEnumOrdinalTypeHandler() {
+        newSession().use { session ->
+            val mapper: AddressMapper = session.getMapper(AddressMapper::class.java)
+
+            val insertStatement = insertInto(address) {
+                set(address.id).toValue(4)
+                set(address.streetAddress).toValue("987 Elm Street")
+                set(address.city).toValue("Mayberry")
+                set(address.state).toValue("NC")
+                set(address.addressType).toValue(AddressType.HOME)
+            }
+
+            val rows = mapper.generalInsert(insertStatement)
+            assertThat(rows).isEqualTo(1)
+
+            val selectStatement = select(address.addressType) {
+                from(address)
+                where(address.id, isEqualTo(4))
+            }
+
+            val type = mapper.selectOptionalInteger(selectStatement)
+
+            assertThat(type).hasValueSatisfying { assertThat(it).isEqualTo(0) }
+        }
+    }
+
     companion object {
         const val JDBC_URL = "jdbc:hsqldb:mem:aname"
         const val JDBC_DRIVER = "org.hsqldb.jdbcDriver"

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

@@ -20,6 +20,7 @@ import org.apache.ibatis.annotations.Result
 import org.apache.ibatis.annotations.ResultMap
 import org.apache.ibatis.annotations.Results
 import org.apache.ibatis.annotations.SelectProvider
+import org.apache.ibatis.type.EnumOrdinalTypeHandler
 import org.apache.ibatis.type.JdbcType
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter
@@ -55,7 +56,13 @@ interface PersonWithAddressMapper {
             Result(column = "address_id", property = "address.id", jdbcType = JdbcType.INTEGER),
             Result(column = "street_address", property = "address.streetAddress", jdbcType = JdbcType.VARCHAR),
             Result(column = "city", property = "address.city", jdbcType = JdbcType.VARCHAR),
-            Result(column = "state", property = "address.state", jdbcType = JdbcType.CHAR)
+            Result(column = "state", property = "address.state", jdbcType = JdbcType.CHAR),
+            Result(
+                column = "address_type",
+                property = "address.addressType",
+                jdbcType = JdbcType.INTEGER,
+                typeHandler = EnumOrdinalTypeHandler::class
+            )
         ]
     )
     fun selectMany(selectStatement: SelectStatementProvider): List<PersonWithAddress>

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

@@ -29,11 +29,12 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.selectDistinct
 
+private val columnList = listOf(id.`as`("A_ID"), firstName, lastName, birthDate,
+    employed, occupation, address.id, address.streetAddress, address.city, address.state, address.addressType
+)
+
 fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAddress? =
-    select(
-        id.`as`("A_ID"), firstName, lastName, birthDate,
-        employed, occupation, address.id, address.streetAddress, address.city, address.state
-    ) {
+    select(columnList) {
         from(person)
         fullJoin(address) {
             on(person.addressId, equalTo(address.id))
@@ -42,10 +43,7 @@ fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAdd
     }.run(this::selectOne)
 
 fun PersonWithAddressMapper.select(completer: SelectCompleter): List<PersonWithAddress> =
-    select(
-        id.`as`("A_ID"), firstName, lastName, birthDate,
-        employed, occupation, address.id, address.streetAddress, address.city, address.state
-    ) {
+    select(columnList) {
         from(person, "p")
         fullJoin(address) {
             on(person.addressId, equalTo(address.id))
@@ -54,10 +52,7 @@ fun PersonWithAddressMapper.select(completer: SelectCompleter): List<PersonWithA
     }.run(this::selectMany)
 
 fun PersonWithAddressMapper.selectDistinct(completer: SelectCompleter): List<PersonWithAddress> =
-    selectDistinct(
-        id.`as`("A_ID"), firstName, lastName,
-        birthDate, employed, occupation, address.id, address.streetAddress, address.city, address.state
-    ) {
+    selectDistinct(columnList) {
         from(person)
         fullJoin(address) {
             on(person.addressId, equalTo(address.id))

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

@@ -1,5 +1,5 @@
 --
---    Copyright 2016-2019 the original author or authors.
+--    Copyright 2016-2021 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.
@@ -22,6 +22,7 @@ create table Address (
    street_address varchar(50) not null,
    city varchar(20) not null,
    state varchar(2) not null,
+   address_type int not null,
    primary key(address_id)
 );
 
@@ -36,11 +37,11 @@ create table Person (
    primary key(id)
 );
 
-insert into Address (address_id, street_address, city, state)
-values(1, '123 Main Street', 'Bedrock', 'IN');
+insert into Address (address_id, street_address, city, state, address_type)
+values(1, '123 Main Street', 'Bedrock', 'IN', 0);
 
-insert into Address (address_id, street_address, city, state)
-values(2, '456 Main Street', 'Bedrock', 'IN');
+insert into Address (address_id, street_address, city, state, address_type)
+values(2, '456 Main Street', 'Bedrock', 'IN', 1);
 
 insert into Person values(1, 'Fred', 'Flintstone', '1935-02-01', 'Yes', 'Brontosaurus Operator', 1);