// countVars counts how many *ColumnItems and *IndexedVar nodes are in an expression.
func countVars(expr parser.Expr) (numNames, numValues int) {
v := countVarsVisitor{}
if expr != nil {
parser.WalkExprConst(&v, expr)
}
return v.numNames, v.numValues
}
// checkExpr verifies that an expression doesn't contain things that are not yet
// supported by distSQL, like subqueries.
func checkExpr(expr parser.Expr) error {
if expr == nil {
return nil
}
v := distSQLExprCheckVisitor{}
parser.WalkExprConst(&v, expr)
return v.err
}
// processExpression parses the string expression inside an Expression,
// and associates ordinal references (@1, @2, etc) with the given helper.
func processExpression(exprSpec Expression, h *parser.IndexedVarHelper) (parser.TypedExpr, error) {
if exprSpec.Expr == "" {
return nil, nil
}
expr, err := parser.ParseExprTraditional(exprSpec.Expr)
if err != nil {
return nil, err
}
// Bind IndexedVars to our eh.vars.
v := ivarBinder{h: h, err: nil}
parser.WalkExprConst(&v, expr)
if v.err != nil {
return nil, v.err
}
// Convert to a fully typed expression.
typedExpr, err := parser.TypeCheck(expr, nil, parser.NoTypePreference)
if err != nil {
return nil, err
}
return typedExpr, nil
}
// expr wraps observer.expr() and provides it with the current node's
// name. It also collects the plans for the sub-queries.
func (v *planVisitor) expr(
fieldName string, n int, expr parser.Expr, subplans []planNode,
) []planNode {
if v.err != nil {
return subplans
}
v.observer.expr(v.nodeName, fieldName, n, expr)
if expr != nil {
// Note: the recursion through WalkExprConst does nothing else
// than calling observer.subqueryNode() and collect subplans in
// v.subplans, in particular it does not recurse into the
// collected subplans (this recursion is performed by visit() only
// after all the subplans have been collected). Therefore, there
// is no risk that v.subplans will be clobbered by a recursion
// into visit().
v.subplans = subplans
parser.WalkExprConst(v, expr)
subplans = v.subplans
v.subplans = nil
}
return subplans
}
func (v aggExprVisitor) extract(typedExpr parser.TypedExpr) []distsqlrun.AggregatorSpec_Expr {
parser.WalkExprConst(&v, typedExpr)
return v.exprs
}
// Checks if the given expression only has vars that are known to the conversion function.
func exprCheckVars(expr parser.Expr, conv varConvertFunc) bool {
v := varConvertVisitor{justCheck: true, conv: conv}
parser.WalkExprConst(&v, expr)
return !v.checkFailed
}
