Allow multiple keys in GroupBy (#56)

This pull request extends the GroupBy class so it can use multiple
fields as keys.
I've also added two tests to make sure it works fine and that I did not
break filtering (HAVING) feature.
Fixes #52

Author: michalliss

docs/reference.md

@@ -1108,6 +1108,81 @@ Purchase.select
 
 
 
+### Select.groupBy.multipleKeys
+
+
+
+```scala
+Purchase.select.groupBy(x => (x.shippingInfoId, x.productId))(_.sumBy(_.total))
+```
+
+
+*
+    ```sql
+    SELECT
+      purchase0.shipping_info_id AS res_0_0,
+      purchase0.product_id AS res_0_1,
+      SUM(purchase0.total) AS res_1
+    FROM 
+      purchase purchase0
+    GROUP BY
+      purchase0.shipping_info_id,
+      purchase0.product_id
+    ```
+
+
+
+*
+    ```scala
+    Seq(
+      ((1, 1), 888.0),
+      ((1, 2), 900.0),
+      ((1, 3), 15.7),
+      ((2, 4), 493.8),
+      ((2, 5), 10000.0),
+      ((3, 1), 44.4),
+      ((3, 6), 1.3)
+    )
+    ```
+
+
+
+### Select.groupBy.multipleKeysHaving
+
+
+
+```scala
+Purchase.select
+  .groupBy(x => (x.shippingInfoId, x.productId))(_.sumBy(_.total))
+  .filter(_._2 > 10)
+  .filter(_._2 < 100)
+```
+
+
+*
+    ```sql
+    SELECT
+      purchase0.shipping_info_id AS res_0_0,
+      purchase0.product_id AS res_0_1,
+      SUM(purchase0.total) AS res_1
+    FROM 
+      purchase purchase0
+    GROUP BY
+      purchase0.shipping_info_id,
+      purchase0.product_id
+    HAVING 
+      (SUM(purchase0.total) > ?) AND (SUM(purchase0.total) < ?)
+    ```
+
+
+
+*
+    ```scala
+    Seq(((1, 3), 15.7), ((3, 1), 44.4))
+    ```
+
+
+
 ### Select.distinct.nondistinct
 
 Normal queries can allow duplicates in the returned row values, as seen below.

scalasql/query/src/Model.scala

@@ -40,7 +40,7 @@ object Nulls {
 /**
  * Models a SQL `GROUP BY` clause
  */
-case class GroupBy(key: Expr[?], select: () => Select[?, ?], having: Seq[Expr[?]])
+case class GroupBy(keys: Seq[Expr[?]], select: () => Select[?, ?], having: Seq[Expr[?]])
 
 /**
  * Models a SQL `JOIN` clause

scalasql/query/src/SimpleSelect.scala

@@ -170,14 +170,14 @@ class SimpleSelect[Q, R](
   def groupBy[K, V, R1, R2](groupKey: Q => K)(
       groupAggregate: Aggregatable.Proxy[Q] => V
   )(implicit qrk: Queryable.Row[K, R1], qrv: Queryable.Row[V, R2]): Select[(K, V), (R1, R2)] = {
-    val groupKeyValue = groupKey(expr)
-    val Seq(groupKeyExpr) = qrk.walkExprs(groupKeyValue)
-    val newExpr = (groupKeyValue, groupAggregate(new Aggregatable.Proxy[Q](this.expr)))
+    val groupKeysValue = groupKey(expr)
+    val groupKeysExpr = qrk.walkExprs(groupKeysValue)
+    val newExpr = (groupKeysValue, groupAggregate(new Aggregatable.Proxy[Q](this.expr)))
 
     // Weird hack to store the post-groupby `Select` as part of the `GroupBy`
     // object, because `.flatMap` sometimes need us to roll back any subsequent
     // `.map`s (???)
-    lazy val groupByOpt: Option[GroupBy] = Some(GroupBy(groupKeyExpr, () => res, Nil))
+    lazy val groupByOpt: Option[GroupBy] = Some(GroupBy(groupKeysExpr, () => res, Nil))
     lazy val res =
       if (groupBy0.isEmpty) this.copy(expr = newExpr, groupBy0 = groupByOpt)
       else
@@ -265,7 +265,9 @@ object SimpleSelect {
 
     lazy val groupByOpt = SqlStr.flatten(SqlStr.opt(query.groupBy0) { groupBy =>
       val havingOpt = ExprsToSql.booleanExprs(sql" HAVING ", groupBy.having)
-      sql" GROUP BY ${groupBy.key}${havingOpt}"
+      val groupByJoined =
+        SqlStr.join(groupBy.keys.map(x => Renderable.renderSql(x)(context)), SqlStr.commaSep)
+      sql" GROUP BY ${groupByJoined}${havingOpt}"
     })
 
     def render(liveExprs0: LiveExprs) = {

scalasql/test/src/query/SelectTests.scala

@@ -352,6 +352,57 @@ trait SelectTests extends ScalaSqlSuite {
         value = Seq((1, 888.0), (5, 10000.0)),
         normalize = (x: Seq[(Int, Double)]) => x.sorted
       )
+
+      test("multipleKeys") - checker(
+        query = Text {
+          Purchase.select.groupBy(x => (x.shippingInfoId, x.productId))(_.sumBy(_.total))
+        },
+        sql = """
+          SELECT
+            purchase0.shipping_info_id AS res_0_0,
+            purchase0.product_id AS res_0_1,
+            SUM(purchase0.total) AS res_1
+          FROM 
+            purchase purchase0
+          GROUP BY
+            purchase0.shipping_info_id,
+            purchase0.product_id
+        """,
+        value = Seq(
+          ((1, 1), 888.0),
+          ((1, 2), 900.0),
+          ((1, 3), 15.7),
+          ((2, 4), 493.8),
+          ((2, 5), 10000.0),
+          ((3, 1), 44.4),
+          ((3, 6), 1.3)
+        ),
+        normalize = (x: Seq[((Int, Int), Double)]) => x.sorted
+      )
+
+      test("multipleKeysHaving") - checker(
+        query = Text {
+          Purchase.select
+            .groupBy(x => (x.shippingInfoId, x.productId))(_.sumBy(_.total))
+            .filter(_._2 > 10)
+            .filter(_._2 < 100)
+        },
+        sql = """
+          SELECT
+            purchase0.shipping_info_id AS res_0_0,
+            purchase0.product_id AS res_0_1,
+            SUM(purchase0.total) AS res_1
+          FROM 
+            purchase purchase0
+          GROUP BY
+            purchase0.shipping_info_id,
+            purchase0.product_id
+          HAVING 
+            (SUM(purchase0.total) > ?) AND (SUM(purchase0.total) < ?)
+        """,
+        value = Seq(((1, 3), 15.7), ((3, 1), 44.4)),
+        normalize = (x: Seq[((Int, Int), Double)]) => x.sorted
+      )
     }
 
     test("distinct") {