tweak

Author: lihaoyi

docs/tutorial.md

@@ -848,10 +848,10 @@ db.run(query) ==> Seq(
 ```
 
 You can also perform aggregates as part of your window function by using
-the `.mapAggregate` function; this provides a `SelectProxy[Q]` rather than
+the `.mapAggregate` function; this provides a `Aggregatable.Proxy[Q]` rather than
 a `Q`, letting you perform aggregates like `.sumBy` that you can then use
 as window functions via `.over`. You can reference normal columns by referencing
-the `.expr` member on each `SelectProxy`.
+the `.expr` member on each `Aggregatable.Proxy`.
 ```scala
 val query = City.select
   .mapAggregate((c, cs) =>

scalasql/core/src/Aggregatable.scala

@@ -2,10 +2,24 @@ package scalasql.core
 
 /**
  * Something that supports aggregate operations. Most commonly a [[Select]], but
- * also could be a [[SelectProxy]]
+ * also could be a [[Aggregatable.Proxy]]
  */
 trait Aggregatable[Q] extends WithSqlExpr[Q] {
   def aggregateExpr[V: TypeMapper](f: Q => Context => SqlStr)(
       implicit qr: Queryable.Row[Expr[V], V]
   ): Expr[V]
 }
+
+object Aggregatable {
+
+  /**
+   * A reference that aggregations for usage within [[Select.aggregate]], to allow
+   * the caller to perform multiple aggregations within a single query.
+   */
+  class Proxy[Q](val expr: Q) extends Aggregatable[Q] {
+    def aggregateExpr[V: TypeMapper](f: Q => Context => SqlStr)(
+        implicit qr: Queryable.Row[Expr[V], V]
+    ): Expr[V] = { Expr[V] { implicit c => f(expr)(c) } }
+  }
+
+}

scalasql/query/src/Select.scala

@@ -101,13 +101,15 @@ trait Select[Q, R]
   /**
    * Performs one or more aggregates in a single [[Select]]
    */
-  def aggregate[E, V](f: SelectProxy[Q] => E)(implicit qr: Queryable.Row[E, V]): Aggregate[E, V]
+  def aggregate[E, V](f: Aggregatable.Proxy[Q] => E)(
+      implicit qr: Queryable.Row[E, V]
+  ): Aggregate[E, V]
 
   /**
-   * Performs a `.map` which additionally provides a [[SelectProxy]] that allows you to perform aggregate
+   * Performs a `.map` which additionally provides a [[Aggregatable.Proxy]] that allows you to perform aggregate
    * functions.
    */
-  def mapAggregate[Q2, R2](f: (Q, SelectProxy[Q]) => Q2)(
+  def mapAggregate[Q2, R2](f: (Q, Aggregatable.Proxy[Q]) => Q2)(
       implicit qr: Queryable.Row[Q2, R2]
   ): Select[Q2, R2]
 
@@ -116,7 +118,7 @@ trait Select[Q, R]
    * a function specifying the group-aggregate.
    */
   def groupBy[K, V, R2, R3](groupKey: Q => K)(
-      groupAggregate: SelectProxy[Q] => V
+      groupAggregate: Aggregatable.Proxy[Q] => V
   )(implicit qrk: Queryable.Row[K, R2], qrv: Queryable.Row[V, R3]): Select[(K, V), (R2, R3)]
 
   /**
@@ -310,16 +312,16 @@ object Select {
 
     override def filter(f: Q => Expr[Boolean]): Select[Q, R] = selectToSimpleSelect().filter(f)
 
-    override def aggregate[E, V](f: SelectProxy[Q] => E)(
+    override def aggregate[E, V](f: Aggregatable.Proxy[Q] => E)(
         implicit qr: Queryable.Row[E, V]
     ): Aggregate[E, V] = selectToSimpleSelect().aggregate(f)
 
-    override def mapAggregate[Q2, R2](f: (Q, SelectProxy[Q]) => Q2)(
+    override def mapAggregate[Q2, R2](f: (Q, Aggregatable.Proxy[Q]) => Q2)(
         implicit qr: Queryable.Row[Q2, R2]
     ): Select[Q2, R2] = selectToSimpleSelect().mapAggregate(f)
 
     override def groupBy[K, V, R2, R3](groupKey: Q => K)(
-        groupAggregate: SelectProxy[Q] => V
+        groupAggregate: Aggregatable.Proxy[Q] => V
     )(implicit qrk: Queryable.Row[K, R2], qrv: Queryable.Row[V, R3]): Select[(K, V), (R2, R3)] =
       selectToSimpleSelect().groupBy(groupKey)(groupAggregate)
 

scalasql/query/src/SelectProxy.scala

@@ -1,13 +1,14 @@
 package scalasql.query
 
 import scalasql.core.{
+  Aggregatable,
   Context,
   DialectTypeMappers,
+  Expr,
+  ExprsToSql,
   JoinNullable,
   LiveExprs,
   Queryable,
-  Expr,
-  ExprsToSql,
   SqlStr,
   TypeMapper
 }
@@ -140,30 +141,32 @@ class SimpleSelect[Q, R](
     joinCopy(other, Some(on), "FULL OUTER JOIN")((e, o) => (JoinNullable(e), JoinNullable(o)))
   }
 
-  def aggregate[E, V](f: SelectProxy[Q] => E)(implicit qr: Queryable.Row[E, V]): Aggregate[E, V] = {
-    val selectProxyExpr = f(new SelectProxy[Q](expr))
-    val copied = this.copy(expr = selectProxyExpr)
+  def aggregate[E, V](
+      f: Aggregatable.Proxy[Q] => E
+  )(implicit qr: Queryable.Row[E, V]): Aggregate[E, V] = {
+    val aggregateProxy = f(new Aggregatable.Proxy[Q](expr))
+    val copied = this.copy(expr = aggregateProxy)
     new Aggregate[E, V](
       implicit ctx => copied.renderSql(ctx),
       r => Query.construct(copied, r).head,
-      selectProxyExpr,
+      aggregateProxy,
       qr
     )
   }
 
   def mapAggregate[Q2, R2](
-      f: (Q, SelectProxy[Q]) => Q2
+      f: (Q, Aggregatable.Proxy[Q]) => Q2
   )(implicit qr: Queryable.Row[Q2, R2]): Select[Q2, R2] = {
-    val selectProxyExpr = f(expr, new SelectProxy[Q](expr))
-    this.copy(expr = selectProxyExpr)
+    val aggregateProxy = f(expr, new Aggregatable.Proxy[Q](expr))
+    this.copy(expr = aggregateProxy)
   }
 
   def groupBy[K, V, R1, R2](groupKey: Q => K)(
-      groupAggregate: SelectProxy[Q] => V
+      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 SelectProxy[Q](this.expr)))
+    val newExpr = (groupKeyValue, 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

scalasql/query/src/SimpleSelect.scala

@@ -20,7 +20,7 @@ case class SqlWindow[T](
     val partitionBySql = SqlStr.opt(partitionBy0) { p => sql"PARTITION BY $p" }
     val sortBySql = CompoundSelect.orderToSqlStr(orderBy, ctx)
     val overClause = SqlStr.join(
-      Seq(partitionBySql, sortBySql).filter(!SqlStr.flatten(_).queryParts.forall(_.isEmpty)),
+      Seq(partitionBySql, sortBySql).filter(!SqlStr.flatten(_).queryParts.forall(_.length == 0)),
       sql" "
     )
 

scalasql/query/src/SqlWindow.scala

@@ -896,10 +896,10 @@ object WorldSqlTests extends TestSuite {
       test("aggregate") {
         // +DOCS
         // You can also perform aggregates as part of your window function by using
-        // the `.mapAggregate` function; this provides a `SelectProxy[Q]` rather than
+        // the `.mapAggregate` function; this provides a `Aggregatable.Proxy[Q]` rather than
         // a `Q`, letting you perform aggregates like `.sumBy` that you can then use
         // as window functions via `.over`. You can reference normal columns by referencing
-        // the `.expr` member on each `SelectProxy`.
+        // the `.expr` member on each `Aggregatable.Proxy`.
         val query = City.select
           .mapAggregate((c, cs) =>
             (