change "where" clause of agg functions to "filter" (#6465)

This commit changes the "where <expr>" clause on agg functions
to use the SQL syntax "filter ( <expr> )".

While we were here, we changed ast.Agg to ast.AggFuncExpr, removed
the Where field from ast.CallExpr, and cleaned up the grammar
for how agg functions are integrated into expressions and shortcuts.

We also fixed a big where "count(*) where ..." did not previously
parse, but "count(*) filter ( ... )" now works.

Author: mccanne

book/src/super-sql/aggregates/count.md

@@ -64,10 +64,10 @@ where grep("bar", this) | count()
 # expected output
 ```
 
-Count can return an explicit zero when using a `where` clause in the aggregation:
+Count can return an explicit zero when using a `filter` clause in the aggregation:
 ```mdtest-spq
 # spq
-count() where grep("bar", this)
+count() filter (grep("bar", this))
 # input
 1
 "foo"

book/src/super-sql/operators/aggregate.md

@@ -12,7 +12,7 @@ where `<agg>` references an [aggregate function](../aggregates/intro.md)
 optionally structured as a  [field assignment](intro.md#field-assignment)
 having the form:
 ```
-[ <field> := ] <agg-func> ( [ all | distinct ] <expr> ) [ where <pred> ]
+[ <field> := ] <agg-func> ( [ all | distinct ] <expr> ) [ filter ( <pred> ) ]
 ```
 and `<grouping>` is a grouping expression [field assignment](intro.md#field-assignment)
 having the form:
@@ -33,7 +33,7 @@ to the entire input optionally filtered by `<pred>`.
 
 In the first form, the `aggregate` operator consumes all of its input,
 applies one or more aggregate functions `<agg>` to each input value
-optionally filtered by a `where` clause and/or organized with the grouping
+optionally filtered by a `filter` clause and/or organized with the grouping
 expressions specified after the `by` keyword, and at the end of input produces one
 or more aggregations for each unique set of grouping key values.
 
@@ -44,10 +44,10 @@ keyword without applying any aggregate functions.
 The `aggregate` keyword is optional since it can be used as a
 [shortcut](intro.md#shortcuts).
 
-Each aggregate function `<agg-func>` may be optionally followed by a `where` clause,
+Each aggregate function `<agg-func>` may be optionally followed by a `filter` clause,
 which applies a Boolean expression `<pred>` that indicates, for each input value,
 whether to include it in the values operated upon by the aggregate function.
-`where` clauses are analogous
+`filter` clauses are analogous
 to the [`where`](where.md) operator but apply their filter to the input
 argument stream to the aggregate function.
 
@@ -152,10 +152,10 @@ set:=union(v) by key:=k | sort
 
 ---
 
-_Use a `where` clause_
+_Use a `filter` clause_
 ```mdtest-spq
 # spq
-set:=union(v) where v > 1 by key:=k | sort
+set:=union(v) filter (v > 1) by key:=k | sort
 # input
 {k:"foo",v:1}
 {k:"bar",v:2}
@@ -169,11 +169,11 @@ set:=union(v) where v > 1 by key:=k | sort
 
 ---
 
-_Use a separate `where` clause on each aggregate function_
+_Use a separate `filter` clause on each aggregate function_
 ```mdtest-spq
 # spq
-set:=union(v) where v > 1,
-array:=collect(v) where k=="foo"
+set:=union(v) filter (v > 1),
+array:=collect(v) filter (k=="foo")
   by key:=k
 | sort
 # input
@@ -189,11 +189,11 @@ array:=collect(v) where k=="foo"
 
 ---
 
-_Results are included for `by` groupings that generate null results when `where`
+_Results are included for `by` groupings that generate null results when `filter`
 clauses are used inside `aggregate`_
 ```mdtest-spq
 # spq
-sum(v) where k=="bar" by key:=k | sort
+sum(v) filter (k=="bar") by key:=k | sort
 # input
 {k:"foo",v:1}
 {k:"bar",v:2}

compiler/ast/expr.go

@@ -6,6 +6,14 @@ type Expr interface {
 }
 
 type (
+	AggFuncExpr struct {
+		Kind     string `json:"kind" unpack:""`
+		Name     string `json:"name"`
+		Distinct bool   `json:"distinct"`
+		Expr     Expr   `json:"expr"`
+		Filter   Expr   `json:"filter"`
+		Loc      `json:"loc"`
+	}
 	ArrayExpr struct {
 		Kind  string      `json:"kind" unpack:""`
 		Elems []ArrayElem `json:"elems"`
@@ -30,18 +38,18 @@ type (
 		Loc  `json:"loc"`
 	}
 	// A CallExpr represents different things dependending on its context.
-	// As an operator (when wrapped in an OpExpr), it is either an aggregate
-	// with no grouping keys and no duration, or a filter with a function
-	// that is boolean valued.  This is determined by the compiler rather than
-	// the syntax tree based on the specific functions and aggregators that
+	// As an operator (when wrapped in an ExprOp), it is either an aggregate
+	// function (without grouping keys, filter, or distinct/all keywords),
+	// or an implied where-operator that is boolean valued.
+	// This is determined by the semantic analysis rather than
+	// the syntax based on the specific functions and aggregators that
 	// are defined at compile time.  In expression context, a function call has
 	// the standard semantics where it takes one or more arguments and returns a result.
 	CallExpr struct {
-		Kind  string `json:"kind" unpack:""`
-		Func  Expr   `json:"func"`
-		Args  []Expr `json:"args"`
-		Where Expr   `json:"where"`
-		Loc   `json:"loc"`
+		Kind string `json:"kind" unpack:""`
+		Func Expr   `json:"func"`
+		Args []Expr `json:"args"`
+		Loc  `json:"loc"`
 	}
 	CaseExpr struct {
 		Kind  string `json:"kind" unpack:""`
@@ -260,7 +268,7 @@ type (
 func (*FStringTextElem) fStringElemNode() {}
 func (*FStringExprElem) fStringElemNode() {}
 
-func (*Agg) exprNode()             {}
+func (*AggFuncExpr) exprNode()     {}
 func (*ArrayExpr) exprNode()       {}
 func (*BetweenExpr) exprNode()     {}
 func (*BinaryExpr) exprNode()      {}

compiler/ast/op.go

@@ -376,18 +376,3 @@ func (*ValuesOp) opNode()     {}
 func (*WhereOp) opNode()      {}
 
 func (*DefaultScan) opNode() {}
-
-// An Agg is an AST node that represents a aggregate function.  The Name
-// field indicates the aggregation method while the Expr field indicates
-// an expression applied to the incoming records that is operated upon by them
-// aggregate function.  If Expr isn't present, then the aggregator doesn't act
-// upon a function of the record, e.g., count() counts up records without
-// looking into them.
-type Agg struct {
-	Kind     string `json:"kind" unpack:""`
-	Name     string `json:"name"`
-	Distinct bool   `json:"distinct"`
-	Expr     Expr   `json:"expr"`
-	Where    Expr   `json:"where"`
-	Loc      `json:"loc"`
-}

compiler/ast/unpack.go

@@ -8,7 +8,7 @@ import (
 )
 
 var unpacker = unpack.New(
-	Agg{},
+	AggFuncExpr{},
 	AggregateOp{},
 	ArgExpr{},
 	ArgText{},

compiler/dag/expr.go

@@ -32,7 +32,7 @@ type (
 		Name     string `json:"name"`
 		Distinct bool   `json:"distinct"`
 		Expr     Expr   `json:"expr"`
-		Where    Expr   `json:"where"`
+		Filter   Expr   `json:"filter"`
 	}
 	ArrayExpr struct {
 		Kind  string       `json:"kind" unpack:""`

compiler/optimizer/demand.go

@@ -155,7 +155,7 @@ func demandForExpr(expr dag.Expr) demand.Demand {
 	case nil:
 		return demand.None()
 	case *dag.AggExpr:
-		return demand.Union(demandForExpr(expr.Expr), demandForExpr(expr.Where))
+		return demand.Union(demandForExpr(expr.Expr), demandForExpr(expr.Filter))
 	case *dag.ArrayExpr:
 		return demandForArrayOrSetExpr(expr.Elems)
 	case *dag.BinaryExpr:

compiler/optimizer/vam.go

@@ -20,7 +20,7 @@ func isCount(a dag.Assignment) bool {
 		return false
 	}
 	agg, ok := a.RHS.(*dag.AggExpr)
-	return ok && agg.Name == "count" && agg.Expr == nil && agg.Where == nil
+	return ok && agg.Name == "count" && agg.Expr == nil && agg.Filter == nil
 }
 
 func isSingleField(a dag.Assignment) (string, bool) {