Add Kotlin support for new count functions

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java

@@ -110,29 +110,20 @@ public interface SqlBuilder {
 
     /**
      * Renders as select count(distinct column) from table...
-     * 
-     * @param table
-     * @return CountDSL for adding an optional where clause
      */
-    static CountDSL<SelectModel> countDistinctFrom(BasicColumn column, SqlTable table) {
-        return CountDSL.countDistinct(column).from(table);
+    static CountDSL.FromGatherer<SelectModel> countDistinctColumn(BasicColumn column) {
+        return CountDSL.countDistinct(column);
     }
 
     /**
      * Renders as select count(column) from table...
-     * 
-     * @param table
-     * @return CountDSL for adding an optional where clause
      */
-    static CountDSL<SelectModel> countFrom(BasicColumn column, SqlTable table) {
-        return CountDSL.count(column).from(table);
+    static CountDSL.FromGatherer<SelectModel> countColumn(BasicColumn column) {
+        return CountDSL.count(column);
     }
 
     /**
      * Renders as select count(*) from table...
-     * 
-     * @param table
-     * @return CountDSL for adding an optional where clause
      */
     static CountDSL<SelectModel> countFrom(SqlTable table) {
         return CountDSL.countFrom(table);

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3Utils.java

@@ -58,7 +58,7 @@ public static long count(ToLongFunction<SelectStatementProvider> mapper, BasicCo
     }
 
     public static SelectStatementProvider count(BasicColumn column, SqlTable table, CountDSLCompleter completer) {
-        return countFrom(SqlBuilder.countFrom(column, table), completer);
+        return countFrom(SqlBuilder.countColumn(column).from(table), completer);
     }
 
     public static long countDistinct(ToLongFunction<SelectStatementProvider> mapper, BasicColumn column, SqlTable table,
@@ -67,7 +67,7 @@ public static long countDistinct(ToLongFunction<SelectStatementProvider> mapper,
     }
 
     public static SelectStatementProvider countDistinct(BasicColumn column, SqlTable table, CountDSLCompleter completer) {
-        return countFrom(SqlBuilder.countDistinctFrom(column, table), completer);
+        return countFrom(SqlBuilder.countDistinctColumn(column).from(table), completer);
     }
 
     public static SelectStatementProvider countFrom(SqlTable table, CountDSLCompleter completer) {

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

@@ -28,6 +28,12 @@ import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider
 import org.mybatis.dynamic.sql.util.kotlin.*
 
+fun count(mapper: (SelectStatementProvider) -> Long, column: BasicColumn, table: SqlTable, completer: CountCompleter) =
+    mapper(SqlBuilder.countColumn(column).from(table, completer))
+
+fun countDistinct(mapper: (SelectStatementProvider) -> Long, column: BasicColumn, table: SqlTable, completer: CountCompleter) =
+    mapper(SqlBuilder.countDistinctColumn(column).from(table, completer))
+
 fun countFrom(mapper: (SelectStatementProvider) -> Long, table: SqlTable, completer: CountCompleter) =
     mapper(countFrom(table, completer))
 

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

@@ -25,6 +25,7 @@ import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider
 import org.mybatis.dynamic.sql.render.RenderingStrategies
+import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
@@ -52,6 +53,15 @@ fun <T> MultiRowInsertDSL.IntoGatherer<T>.into(
 ): MultiRowInsertStatementProvider<T> =
     completer(into(table)).build().render(RenderingStrategies.MYBATIS3)
 
+fun CountDSL.FromGatherer<SelectModel>.from(
+    table: SqlTable,
+    completer: CountCompleter
+): SelectStatementProvider {
+    val builder = KotlinCountBuilder(from(table))
+    completer(builder)
+    return builder.build().render(RenderingStrategies.MYBATIS3)
+}
+
 fun QueryExpressionDSL.FromGatherer<SelectModel>.from(
     table: SqlTable,
     completer: SelectCompleter

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider
 import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider
+import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider
 import org.mybatis.dynamic.sql.util.kotlin.*
@@ -31,6 +32,12 @@ import java.sql.ResultSet
 fun NamedParameterJdbcTemplate.count(selectStatement: SelectStatementProvider) =
     queryForObject(selectStatement.selectStatement, selectStatement.parameters, Long::class.java)!!
 
+fun NamedParameterJdbcTemplate.count(column: BasicColumn) =
+    CountFromGatherer(column, this)
+
+fun NamedParameterJdbcTemplate.countDistinct(column: BasicColumn) =
+    CountDistinctFromGatherer(column, this)
+
 fun NamedParameterJdbcTemplate.countFrom(table: SqlTable, completer: CountCompleter) =
     count(org.mybatis.dynamic.sql.util.kotlin.spring.countFrom(table, completer))
 
@@ -79,6 +86,23 @@ fun NamedParameterJdbcTemplate.update(updateStatement: UpdateStatementProvider)
 fun NamedParameterJdbcTemplate.update(table: SqlTable, completer: UpdateCompleter) =
     update(org.mybatis.dynamic.sql.util.kotlin.spring.update(table, completer))
 
+// support classes for count DSL
+class CountFromGatherer(
+    private val column: BasicColumn,
+    private val template: NamedParameterJdbcTemplate
+) {
+    fun from(table: SqlTable, completer: CountCompleter) =
+        template.count(CountDSL.count(column).from(table, completer))
+}
+
+class CountDistinctFromGatherer(
+    private val column: BasicColumn,
+    private val template: NamedParameterJdbcTemplate
+) {
+    fun from(table: SqlTable, completer: CountCompleter) =
+        template.count(CountDSL.countDistinct(column).from(table, completer))
+}
+
 // support classes for select DSL
 class SelectListFromGatherer(
     private val selectList: List<BasicColumn>,

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt

@@ -23,27 +23,37 @@ import org.mybatis.dynamic.sql.insert.InsertDSL
 import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider
 import org.mybatis.dynamic.sql.render.RenderingStrategies
+import org.mybatis.dynamic.sql.select.CountDSL
 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.update.render.UpdateStatementProvider
 import org.mybatis.dynamic.sql.util.kotlin.*
 
-fun countFrom(table: SqlTable, completer: CountCompleter): SelectStatementProvider {
-    val builder = KotlinCountBuilder(SqlBuilder.countFrom(table))
+fun deleteFrom(table: SqlTable, completer: DeleteCompleter): DeleteStatementProvider {
+    val builder = KotlinDeleteBuilder(SqlBuilder.deleteFrom(table))
     completer(builder)
     return builder.build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 }
 
-fun deleteFrom(table: SqlTable, completer: DeleteCompleter): DeleteStatementProvider {
-    val builder = KotlinDeleteBuilder(SqlBuilder.deleteFrom(table))
+fun countFrom(table: SqlTable, completer: CountCompleter): SelectStatementProvider {
+    val builder = KotlinCountBuilder(SqlBuilder.countFrom(table))
     completer(builder)
     return builder.build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 }
 
 fun <T> InsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: InsertCompleter<T>): InsertStatementProvider<T> =
     completer(into(table)).build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
+fun CountDSL.FromGatherer<SelectModel>.from(
+    table: SqlTable,
+    completer: CountCompleter
+): SelectStatementProvider {
+    val builder = KotlinCountBuilder(from(table))
+    completer(builder)
+    return builder.build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
+}
+
 fun QueryExpressionDSL.FromGatherer<SelectModel>.from(
     table: SqlTable,
     completer: SelectCompleter

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

@@ -23,10 +23,17 @@ import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.Person.firstNa
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.Person.id
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.Person.lastName
 import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.Person.occupation
+import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.SqlBuilder.isEqualTo
 import org.mybatis.dynamic.sql.util.kotlin.*
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.*
 
+fun PersonMapper.count(column: BasicColumn, completer: CountCompleter) =
+    count(this::count, column, Person, completer)
+
+fun PersonMapper.countDistinct(column: BasicColumn, completer: CountCompleter) =
+    countDistinct(this::count, column, Person, completer)
+
 fun PersonMapper.count(completer: CountCompleter) =
     countFrom(this::count, Person, completer)
 

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

@@ -483,6 +483,28 @@ class PersonMapperTest {
         }
     }
 
+    @Test
+    fun testCountLastName() {
+        newSession().use { session ->
+            val mapper = session.getMapper(PersonMapper::class.java)
+
+            val rows = mapper.count(lastName) { allRows() }
+
+            assertThat(rows).isEqualTo(6L)
+        }
+    }
+
+    @Test
+    fun testCountDistinctLastName() {
+        newSession().use { session ->
+            val mapper = session.getMapper(PersonMapper::class.java)
+
+            val rows = mapper.countDistinct(lastName) { allRows() }
+
+            assertThat(rows).isEqualTo(2L)
+        }
+    }
+
     @Test
     fun testTypeHandledLike() {
         newSession().use { session ->

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

@@ -65,6 +65,24 @@ class CanonicalSpringKotlinTemplateDirectTest {
         assertThat(rows).isEqualTo(6)
     }
 
+    @Test
+    fun testCountLastName() {
+        val rows = template.count(lastName).from(Person) {
+            allRows()
+        }
+
+        assertThat(rows).isEqualTo(6)
+    }
+
+    @Test
+    fun testCountDistinctLastName() {
+        val rows = template.countDistinct(lastName).from(Person) {
+            allRows()
+        }
+
+        assertThat(rows).isEqualTo(2)
+    }
+
     @Test
     fun testAllRows() {
         val rows = template.deleteFrom(Person) {