refactor grouping aggregateColumnsN

Author: vincentlauvlwj

ktorm-core/generate-tuples.gradle

@@ -253,30 +253,82 @@ def generateGroupingAggregateColumns(Writer writer, int tupleNumber) {
          * Group elements from the source sequence by key and perform the given aggregations for elements in each group,
          * then store the results in a new [Map].
          * 
-         * See [EntityGrouping.aggregateColumns] for more details. 
+         * The key for each group is provided by the [EntityGrouping.keySelector] function, and the generated SQL is like:
+         * `select key, aggregation from source group by key`.
          *
          * @param aggregationSelector a function that accepts the source table and returns a tuple of aggregate expressions.
          * @return a [Map] associating the key of each group with the results of aggregations of the group elements.
          */
+        @Deprecated(
+            message = "This function will be removed in the future. Please use aggregateColumns { .. } instead.",
+            replaceWith = ReplaceWith("aggregateColumns(aggregationSelector)")
+        )
         public inline fun <E : Any, T : BaseTable<E>, K : Any, $typeParams> EntityGrouping<E, T, K>.aggregateColumns$tupleNumber(
             aggregationSelector: (T) -> Tuple$tupleNumber<$columnDeclarings>
         ): Map<K?, Tuple$tupleNumber<$resultTypes>> {
-            return aggregateColumns${tupleNumber}To(LinkedHashMap(), aggregationSelector)
+            return aggregateColumns(aggregationSelector)
         }
         
         /**
          * Group elements from the source sequence by key and perform the given aggregations for elements in each group,
          * then store the results in the [destination] map.
          *
-         * See [EntityGrouping.aggregateColumnsTo] for more details. 
+         * The key for each group is provided by the [EntityGrouping.keySelector] function, and the generated SQL is like:
+         * `select key, aggregation from source group by key`.
          *
          * @param destination a [MutableMap] used to store the results.
          * @param aggregationSelector a function that accepts the source table and returns a tuple of aggregate expressions.
          * @return the [destination] map associating the key of each group with the result of aggregations of the group elements.
          */
+        @Deprecated(
+            message = "This function will be removed in the future. Please use aggregateColumns(destination) { .. } instead.",
+            replaceWith = ReplaceWith("aggregateColumns(destination, aggregationSelector)")
+        )
         public inline fun <E : Any, T : BaseTable<E>, K : Any, $typeParams, M> EntityGrouping<E, T, K>.aggregateColumns${tupleNumber}To(
             destination: M,
             aggregationSelector: (T) -> Tuple$tupleNumber<$columnDeclarings>
+        ): M where M : MutableMap<in K?, in Tuple$tupleNumber<$resultTypes>> {
+            return aggregateColumnsTo(destination, aggregationSelector)
+        }
+        
+        /**
+         * Group elements from the source sequence by key and perform the given aggregations for elements in each group,
+         * then store the results in a new [Map].
+         *
+         * The key for each group is provided by the [EntityGrouping.keySelector] function, and the generated SQL is like:
+         * `select key, aggregation from source group by key`.
+         *
+         * @param aggregationSelector a function that accepts the source table and returns a tuple of aggregate expressions.
+         * @return a [Map] associating the key of each group with the results of aggregations of the group elements.
+         * @since 3.1.0
+         */
+        @JvmName("_aggregateColumns$tupleNumber")
+        @OptIn(ExperimentalTypeInference::class)
+        @OverloadResolutionByLambdaReturnType
+        public inline fun <E : Any, T : BaseTable<E>, K : Any, $typeParams> EntityGrouping<E, T, K>.aggregateColumns(
+            aggregationSelector: (T) -> Tuple$tupleNumber<$columnDeclarings>
+        ): Map<K?, Tuple$tupleNumber<$resultTypes>> {
+            return aggregateColumnsTo(LinkedHashMap(), aggregationSelector)
+        }
+        
+        /**
+         * Group elements from the source sequence by key and perform the given aggregations for elements in each group,
+         * then store the results in the [destination] map.
+         *
+         * The key for each group is provided by the [EntityGrouping.keySelector] function, and the generated SQL is like:
+         * `select key, aggregation from source group by key`.
+         *
+         * @param destination a [MutableMap] used to store the results.
+         * @param aggregationSelector a function that accepts the source table and returns a tuple of aggregate expressions.
+         * @return the [destination] map associating the key of each group with the result of aggregations of the group elements.
+         * @since 3.1.0
+         */
+        @JvmName("_aggregateColumns${tupleNumber}To")
+        @OptIn(ExperimentalTypeInference::class)
+        @OverloadResolutionByLambdaReturnType
+        public inline fun <E : Any, T : BaseTable<E>, K : Any, $typeParams, M> EntityGrouping<E, T, K>.aggregateColumnsTo(
+            destination: M,
+            aggregationSelector: (T) -> Tuple$tupleNumber<$columnDeclarings>
         ): M where M : MutableMap<in K?, in Tuple$tupleNumber<$resultTypes>> {
             val keyColumn = keySelector(sequence.sourceTable)
             val ($variableNames) = aggregationSelector(sequence.sourceTable)
@@ -288,7 +340,7 @@ def generateGroupingAggregateColumns(Writer writer, int tupleNumber) {
         
             for (row in Query(sequence.database, expr)) {
                 val key = keyColumn.sqlType.getResult(row, 1)
-                destination[key] = Tuple$tupleNumber($resultExtractors)
+                destination[key] = tupleOf($resultExtractors)
             }
         
             return destination

ktorm-core/src/main/kotlin/me/liuwj/ktorm/entity/EntityGrouping.kt

@@ -22,6 +22,7 @@ import me.liuwj.ktorm.schema.ColumnDeclaring
 import java.util.*
 import kotlin.collections.ArrayList
 import kotlin.collections.LinkedHashMap
+import kotlin.experimental.ExperimentalTypeInference
 
 /**
  * Wraps an [EntitySequence] with a [keySelector] function, which can be applied to each record to get its key,
@@ -88,6 +89,8 @@ public class EntityGrouping<E : Any, T : BaseTable<E>, K : Any>(
  * @param aggregationSelector a function that accepts the source table and returns the aggregate expression.
  * @return a [Map] associating the key of each group with the result of aggregation of the group elements.
  */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
 public inline fun <E : Any, T : BaseTable<E>, K, C> EntityGrouping<E, T, K>.aggregateColumns(
     aggregationSelector: (T) -> ColumnDeclaring<C>
 ): Map<K?, C?> where K : Any, C : Any {
@@ -109,6 +112,8 @@ public inline fun <E : Any, T : BaseTable<E>, K, C> EntityGrouping<E, T, K>.aggr
  * @param aggregationSelector a function that accepts the source table and returns the aggregate expression.
  * @return the [destination] map associating the key of each group with the result of aggregation of the group elements.
  */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
 public inline fun <E : Any, T : BaseTable<E>, K, C, M> EntityGrouping<E, T, K>.aggregateColumnsTo(
     destination: M,
     aggregationSelector: (T) -> ColumnDeclaring<C>

ktorm-core/src/main/kotlin/me/liuwj/ktorm/entity/EntitySequence.kt

@@ -652,6 +652,8 @@ public fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.take(n: Int): Entity
  * @param aggregationSelector a function that accepts the source table and returns the aggregate expression.
  * @return the aggregate result.
  */
+@OptIn(ExperimentalTypeInference::class)
+@OverloadResolutionByLambdaReturnType
 public inline fun <E : Any, T : BaseTable<E>, C : Any> EntitySequence<E, T>.aggregateColumns(
     aggregationSelector: (T) -> ColumnDeclaring<C>
 ): C? {

ktorm-core/src/test/kotlin/me/liuwj/ktorm/dsl/AggregationTest.kt

@@ -78,7 +78,7 @@ class AggregationTest : BaseTest() {
     fun testGroupAggregate3() {
         database.employees
             .groupingBy { it.departmentId }
-            .aggregateColumns2 { tupleOf(max(it.salary), min(it.salary)) }
+            .aggregateColumns { tupleOf(max(it.salary), min(it.salary)) }
             .forEach { departmentId, (max, min) ->
                 println("$departmentId:$max:$min")
             }

ktorm-core/src/test/kotlin/me/liuwj/ktorm/entity/DataClassTest.kt

@@ -167,7 +167,7 @@ class DataClassTest : BaseTest() {
     fun testGroupingAggregate() {
         database.staffs
             .groupingBy { it.sectionId }
-            .aggregateColumns2 { tupleOf(max(it.salary), min(it.salary)) }
+            .aggregateColumns { tupleOf(max(it.salary), min(it.salary)) }
             .forEach { sectionId, (max, min) ->
                 println("$sectionId:$max:$min")
             }

ktorm-global/src/test/kotlin/me/liuwj/ktorm/global/GlobalAggregationTest.kt

@@ -2,7 +2,6 @@ package me.liuwj.ktorm.global
 
 import me.liuwj.ktorm.dsl.*
 import me.liuwj.ktorm.entity.aggregateColumns
-import me.liuwj.ktorm.entity.aggregateColumns2
 import me.liuwj.ktorm.entity.groupingBy
 import me.liuwj.ktorm.entity.tupleOf
 import org.junit.Test
@@ -82,7 +81,7 @@ class GlobalAggregationTest : BaseGlobalTest() {
         Employees
             .asSequence()
             .groupingBy { it.departmentId }
-            .aggregateColumns2 { tupleOf(max(it.salary), min(it.salary)) }
+            .aggregateColumns { tupleOf(max(it.salary), min(it.salary)) }
             .forEach { departmentId, (max, min) ->
                 println("$departmentId:$max:$min")
             }