Enum Expr 

pub enum Expr {
    Star {
        qualifier: Slice,
    },
    Column {
        name: Slice,
    },
    Literal {
        kind: LiteralKind,
        text: StrRef,
    },
    Unary {
        op: UnaryOp,
        operand: ExprRef,
    },
    Binary {
        op: BinaryOp,
        left: ExprRef,
        right: ExprRef,
    },
    Function {
        name: Slice,
        args: Slice,
        distinct: bool,
    },
    Cast {
        operand: ExprRef,
        ty: StrRef,
        try_cast: bool,
    },
    Case {
        operand: ExprRef,
        arms: Slice,
        otherwise: ExprRef,
    },
    Between {
        operand: ExprRef,
        low: ExprRef,
        high: ExprRef,
        negated: bool,
    },
    In {
        operand: ExprRef,
        list: Slice,
        negated: bool,
    },
    Parameter {
        name: StrRef,
    },
    List {
        items: Slice,
    },
    Row {
        items: Slice,
    },
    Subquery {
        query: QueryRef,
    },
}

One expression.

Twenty four bytes, which is the widest variant rounded up. The precedence chain in the grammar does not survive into here: twenty levels of X <- Y Tail* become one Expr::Binary tree, because the levels exist to make the grammar unambiguous and mean nothing afterwards.

Variants

Star

*, or t.* with a qualifier.

Fields

qualifier: Slice

The qualifier, as a run of StrRef, empty for a bare star.

Column

A column reference, qualified or not.

Fields

name: Slice

The name, as a run of StrRef, outermost first, so s.t.a is three parts.

Literal

A literal, kept as the text that was written.

Fields

kind: LiteralKind

Which kind.

text: StrRef

The text, with quotes stripped and escapes resolved for a string, NONE for a keyword literal like NULL where the kind already says everything.

Unary

A prefix or postfix operator.

Fields

op: UnaryOp

Which operator.

operand: ExprRef

What it applies to.

Binary

An infix operator.

Fields

op: BinaryOp

Which operator.

left: ExprRef

The left operand.

right: ExprRef

The right operand.

Function

A function call.

Fields

name: Slice

The name, as a run of StrRef, so main.count is two parts.

args: Slice

The arguments, as a run of ExprRef.

distinct: bool

Whether the call said DISTINCT.

Cast

CAST(x AS t) or TRY_CAST(x AS t).

Fields

operand: ExprRef

What is being cast.

ty: StrRef

The target type, as the text it was written with. Parsing it is rudb-common’s job and doing it here would put the type system in the parser.

try_cast: bool

Whether a failure yields null rather than an error.

Case

CASE, searched or simple.

Fields

operand: ExprRef

The operand of a simple CASE x WHEN, or NONE for a searched one.

arms: Slice

The arms, as a run of CaseArm.

otherwise: ExprRef

The ELSE, or NONE.

Between

x BETWEEN a AND b.

Fields

operand: ExprRef

What is being tested.

low: ExprRef

The lower bound.

high: ExprRef

The upper bound.

negated: bool

Whether it was written NOT BETWEEN.

In

x IN (a, b, c).

Fields

operand: ExprRef

What is being tested.

list: Slice

The list, as a run of ExprRef.

negated: bool

Whether it was written NOT IN.

Parameter

A prepared statement parameter, written ?, ?1, $1 or $name.

Fields

name: StrRef

The identifier, which is the number for a positional one and the word for a named one. A bare ? is numbered by where it was written, so the identifier is there either way.

List

A bracketed list of expressions, [a, b, c], which is a LIST value.

Fields

items: Slice

The items, as a run of ExprRef, in the order they were written.

Row

A parenthesised list of more than one expression, which is a row value.

Fields

items: Slice

The items, as a run of ExprRef.

Subquery

A scalar subquery, (SELECT ...) where an expression is expected.

Fields

query: QueryRef

The query.

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 Copy for Expr

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