Add Kotlin Utility Functions to Avoid platform type issue

Author: jeffgbutler

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/UtilityFunctions.kt

@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.util.kotlin.mybatis3
 
+import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.SqlBuilder
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.insert.InsertDSL
@@ -24,6 +25,7 @@ import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider
 import org.mybatis.dynamic.sql.render.RenderingStrategies
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 import org.mybatis.dynamic.sql.select.SelectModel
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
 import org.mybatis.dynamic.sql.util.kotlin.DeleteCompleter
 import org.mybatis.dynamic.sql.util.kotlin.SelectCompleter
 import org.mybatis.dynamic.sql.util.kotlin.UpdateCompleter
@@ -50,3 +52,19 @@ fun QueryExpressionDSL.FromGatherer<SelectModel>.from(table: SqlTable, alias: St
 
 fun update(table: SqlTable, complete: UpdateCompleter) =
         complete(SqlBuilder.update(table)).build().render(RenderingStrategies.MYBATIS3)
+
+/**
+ * Function to handle platform type issues. Use this function, instead of calling MyBatis3Utils directly, to
+ * avoid having to specify a return type explicitly.
+ */
+fun <T> selectDistinct(mapper: (SelectStatementProvider) -> List<T>, selectList: Array<out BasicColumn>, table: SqlTable,
+                       completer: SelectCompleter): List<T> =
+        MyBatis3Utils.selectDistinct(mapper, selectList, table, completer)
+
+/**
+ * Function to handle platform type issues. Use this function, instead of calling MyBatis3Utils directly, to
+ * avoid having to specify a return type explicitly.
+ */
+fun <T> selectList(mapper: (SelectStatementProvider) -> List<T>, selectList: Array<out BasicColumn>, table: SqlTable,
+                   completer: SelectCompleter): List<T> =
+        MyBatis3Utils.selectList(mapper, selectList, table, completer)

src/site/markdown/docs/kotlin.md

@@ -54,10 +54,10 @@ interface PersonMapper {
 And then extensions could be added to make a shortcut method as follows:
 
 ```kotlin
-private val selectList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
 fun PersonMapper.select(completer: SelectCompleter): List<PersonRecord> =
-        MyBatis3Utils.selectList(this::selectMany, selectList, Person, completer)
+        selectList(this::selectMany, columnList, Person, completer)
 ```
 
 The extension method shows the use of the `SelectCompleter` type alias. This is a DSL extension supplied with the library. We will detail its use below. For now see that the extension method can be used in client code as follows:
@@ -251,19 +251,19 @@ interface PersonMapper {
 These methods can be used to create simplified select methods with Kotlin extension methods:
 
 ```kotlin
-private val selectList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
 fun PersonMapper.selectOne(completer: SelectCompleter) =
-        MyBatis3Utils.selectOne(this::selectOne, selectList, Person, completer)
+        MyBatis3Utils.selectOne(this::selectOne, columnList, Person, completer)
 
-fun PersonMapper.select(completer: SelectCompleter): List<PersonRecord> =
-        MyBatis3Utils.selectList(this::selectMany, selectList, Person, completer)
+fun PersonMapper.select(completer: SelectCompleter) =
+        selectList(this::selectMany, columnList, Person, completer)
 
-fun PersonMapper.selectDistinct(completer: SelectCompleter): List<PersonRecord> =
-        MyBatis3Utils.selectDistinct(this::selectMany, selectList, Person, completer)
+fun PersonMapper.selectDistinct(completer: SelectCompleter) =
+        selectDistinct(this::selectMany, columnList, Person, completer)
 ```
 
-These methods show the use of `SelectCompleter` which is a which is a Kotlin typealias for a function with a receiver that will allow a user to supply a where clause. The `selectMany` method can be used to implement generalized select methods where a user can specify a where clause and/or an order by clause. Typically we recommend two of these methods - for select, and select distinct. The `selectOne` method is used to create a generalized select method where a user can specify a where clause. 
+These methods show the use of `SelectCompleter` which is a which is a Kotlin typealias for a function with a receiver that will allow a user to supply a where clause. The `selectMany` method can be used to implement generalized select methods where a user can specify a where clause and/or an order by clause. Typically we recommend two of these methods - for select, and select distinct. The `selectOne` method is used to create a generalized select method where a user can specify a where clause. These methods also show the use of the built in Kotlin functions `selectDistinct` and `selectList`. These functions help to avoid platform type issues in Kotlin and enable the Kotlin compiler to correctly infer the result type (`List<PersonRecord>` in this case). 
 
 The general `selectOne` method can also be used to implement a `selectByPrimaryKey` method:
 

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

@@ -26,9 +26,14 @@ import examples.kotlin.canonical.PersonDynamicSqlSupport.Person.occupation
 import org.mybatis.dynamic.sql.SqlBuilder.isEqualTo
 import org.mybatis.dynamic.sql.update.UpdateDSL
 import org.mybatis.dynamic.sql.update.UpdateModel
-import org.mybatis.dynamic.sql.util.kotlin.*
+import org.mybatis.dynamic.sql.util.kotlin.CountCompleter
+import org.mybatis.dynamic.sql.util.kotlin.DeleteCompleter
+import org.mybatis.dynamic.sql.util.kotlin.SelectCompleter
+import org.mybatis.dynamic.sql.util.kotlin.UpdateCompleter
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insert
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertMultiple
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.selectDistinct
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.selectList
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils
 
 fun PersonMapper.count(completer: CountCompleter) =
@@ -78,16 +83,16 @@ fun PersonMapper.insertSelective(record: PersonRecord) =
             map(addressId).toPropertyWhenPresent("addressId", record::addressId)
         }
 
-private val selectList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
 fun PersonMapper.selectOne(completer: SelectCompleter) =
-        MyBatis3Utils.selectOne(this::selectOne, selectList, Person, completer)
+        MyBatis3Utils.selectOne(this::selectOne, columnList, Person, completer)
 
-fun PersonMapper.select(completer: SelectCompleter): List<PersonRecord> =
-        MyBatis3Utils.selectList(this::selectMany, selectList, Person, completer)
+fun PersonMapper.select(completer: SelectCompleter) =
+        selectList(this::selectMany, columnList, Person, completer)
 
-fun PersonMapper.selectDistinct(completer: SelectCompleter): List<PersonRecord> =
-        MyBatis3Utils.selectDistinct(this::selectMany, selectList, Person, completer)
+fun PersonMapper.selectDistinct(completer: SelectCompleter) =
+        selectDistinct(this::selectMany, columnList, Person, completer)
 
 fun PersonMapper.selectByPrimaryKey(id_: Int) =
         selectOne {

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

@@ -29,11 +29,11 @@ import org.mybatis.dynamic.sql.util.kotlin.fromJoining
 import org.mybatis.dynamic.sql.util.kotlin.fullJoin
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils
 
-private val selectList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, Address.id,
+private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, Address.id,
         Address.streetAddress, Address.city, Address.state)
 
 fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAddress? {
-    val start = select(*selectList).fromJoining(Person) {
+    val start = select(*columnList).fromJoining(Person) {
         fullJoin(Address) {
             on(Person.addressId, equalTo(Address.id))
         }
@@ -43,7 +43,7 @@ fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAdd
 }
 
 fun PersonWithAddressMapper.select(completer: SelectCompleter): List<PersonWithAddress> {
-    val start = select(*selectList).fromJoining(Person, "p") {
+    val start = select(*columnList).fromJoining(Person, "p") {
         fullJoin(Address) {
             on(Person.addressId, equalTo(Address.id))
         }