Method aggFunc

compiler/semantic/expr.go:1143–1188

(n ast.Node, name string, arg ast.Expr, filter ast.Expr, distinct bool, inType super.Type)

}

func (t *translator) aggFunc(n ast.Node, name string, arg ast.Expr, filter ast.Expr, distinct bool, inType super.Type) (sem.Expr, super.Type) {
	// If we are in the context of a having clause, re-expose the select schema
	// since the agg func's arguments and where clause operate on the input relation
	// not the output.
	scope, ok := t.scope.sql.(*selectScope)
	if ok {
		if !scope.aggOk {
			if scope.groupByLoc != nil {
				t.error(scope.groupByLoc, fmt.Errorf("aggregate function %q cannot appear in GROUP BY via positional reference", name))
			} else {
				t.error(n, fmt.Errorf("aggregate function %q called in non-aggregate context", name))
			}
			return badExpr, t.checker.unknown
		}
		scope.aggOk = false
		save := scope.out
		defer func() {
			scope.aggOk = true
			scope.out = save
		}()
		scope.out = nil
	}
	argExpr, argType := t.exprNullable(arg, inType)
	filterExpr, filterType := t.exprNullable(filter, inType)
	f := &sem.AggFunc{
		Node:     n,
		Name:     name,
		Expr:     argExpr,
		Filter:   filterExpr,
		Distinct: distinct,
	}
	if !ok {
		typ := t.checker.aggFunc(name, arg, argType, filter, filterType)
		return f, typ
	}
	for k, previous := range scope.aggs {
		if f.Name == previous.Name && f.Distinct == previous.Distinct && eqExpr(f.Expr, previous.Expr) && eqExpr(f.Filter, previous.Filter) {
			return &sem.AggRef{Node: n, Index: k}, scope.aggTypes[k]
		}
	}
	typ := t.checker.aggFunc(name, arg, argType, filter, filterType)
	ref := &sem.AggRef{Node: f, Index: len(scope.aggs)}
	scope.aggs = append(scope.aggs, f)
	scope.aggTypes = append(scope.aggTypes, typ)
	return ref, typ
}

func DotExprToFieldPath(e ast.Expr) *sem.ThisExpr {
	switch e := e.(type) {