Enum Expr 

pub enum Expr {
    Column(ColumnBinding),
    Constant(ValueRef),
    Cast {
        input: ExprRef,
        try_cast: bool,
    },
    Compare {
        op: CompareOp,
        left: ExprRef,
        right: ExprRef,
    },
    Conjunction {
        op: ConjunctionOp,
        children: Slice,
    },
    Function {
        name: StrRef,
        args: Slice,
    },
    Aggregate {
        name: StrRef,
        args: Slice,
        distinct: bool,
        filter: Option<ExprRef>,
    },
    Case {
        arms: Slice,
        otherwise: Option<ExprRef>,
    },
}

One bound expression.

The type of an expression is not in here. It lives in a parallel vector in Plan, indexed by the same ExprRef, because a LogicalType owns a Vec for its nested cases and putting one inside every variant would make the common variants three times larger for the benefit of the rare ones.

Variants

Column(ColumnBinding)

A reference to a column of some operator’s output.

Constant(ValueRef)

A literal, folded constant, or bound parameter value.

Cast

A cast to the expression’s own type.

The target is the type stored for this expression, not a second copy of it, so there is no way for a cast to disagree with its own result type.

Fields

input: ExprRef

What is being cast.

try_cast: bool

Whether a failed cast yields null instead of raising.

Compare

A binary comparison.

Fields

op: CompareOp

Which comparison.

left: ExprRef

Left operand.

right: ExprRef

Right operand.

Conjunction

An AND or OR over two or more operands.

Flat rather than binary, because filter pushdown splits a conjunction into its parts and a right-leaning tree of two-argument ANDs makes that a recursion instead of a loop.

Fields

op: ConjunctionOp

Which connective.

children: Slice

Two or more operands, into the expression list pool.

Function

A scalar function, already resolved to one overload by the binder.

The name is the resolved function’s name and not the name the user wrote, so a + b is a call to + and an alias in the catalog has already been followed.

Fields

name: StrRef

The resolved function name.

args: Slice

The arguments, into the expression list pool.

Aggregate

An aggregate function.

An aggregate appears only as a direct element of Node::Aggregate’s aggregate list. Anything downstream that wants the result refers to it with a ColumnBinding into the aggregate’s table index, which is why that node has one. Plan::validate checks this, and the textual form relies on it: an aggregate and a scalar function print the same way, and it is the slot they are printed in that says which is which.

Fields

name: StrRef

The resolved aggregate name.

args: Slice

The arguments, into the expression list pool.

distinct: bool

Whether duplicate input rows are collapsed before aggregating.

filter: Option<ExprRef>

The FILTER (WHERE ...) predicate, if there is one.

Case

A searched CASE.

There is no simple CASE here. CASE x WHEN 1 THEN ... is rewritten to the searched form by the binder, because two representations of one thing is two code paths in every pass that touches either.

Fields

arms: Slice

The WHEN/THEN pairs, in order, into the arm pool.

otherwise: Option<ExprRef>

The ELSE, if there is one. Absent means null.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Expr

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Expr