Enum ExprElement 

pub enum ExprElement {
    ColumnRef {
        column: ColumnRef,
    },
    DotAccess {
        key: ColumnID,
    },
    IsNull {
        not: bool,
    },
    IsDistinctFrom {
        not: bool,
    },
    InList {
        list: Vec<Expr>,
        not: bool,
    },
    InSubquery {
        subquery: Box<Query>,
        not: bool,
    },
    LikeSubquery {
        modifier: SubqueryModifier,
        subquery: Box<Query>,
        escape: Option<String>,
    },
    Escape {
        escape: String,
    },
    Between {
        low: Box<Expr>,
        high: Box<Expr>,
        not: bool,
    },
    BinaryOp {
        op: BinaryOperator,
    },
    JsonOp {
        op: JsonOperator,
    },
    UnaryOp {
        op: UnaryOperator,
    },
    VariableAccess(String),
    Cast {
        expr: Box<Expr>,
        target_type: TypeName,
    },
    TryCast {
        expr: Box<Expr>,
        target_type: TypeName,
    },
    PgCast {
        target_type: TypeName,
    },
    Extract {
        field: IntervalKind,
        expr: Box<Expr>,
    },
    DatePart {
        field: IntervalKind,
        expr: Box<Expr>,
    },
    Position {
        substr_expr: Box<Expr>,
        str_expr: Box<Expr>,
    },
    SubString {
        expr: Box<Expr>,
        substring_from: Box<Expr>,
        substring_for: Option<Box<Expr>>,
    },
    Trim {
        expr: Box<Expr>,
        trim_where: Option<(TrimWhere, Box<Expr>)>,
    },
    Literal {
        value: Literal,
    },
    CountAll {
        qualified: QualifiedName,
        window: Option<Window>,
    },
    Tuple {
        exprs: Vec<Expr>,
    },
    FunctionCall {
        func: FunctionCall,
    },
    Case {
        operand: Option<Box<Expr>>,
        conditions: Vec<Expr>,
        results: Vec<Expr>,
        else_result: Option<Box<Expr>>,
    },
    Exists {
        subquery: Query,
        not: bool,
    },
    Subquery {
        modifier: Option<SubqueryModifier>,
        subquery: Query,
    },
    MapAccess {
        accessor: MapAccessor,
    },
    ChainFunctionCall {
        name: Identifier,
        args: Vec<Expr>,
        lambda: Option<Lambda>,
    },
    ListComprehension {
        source: Expr,
        param: Identifier,
        filter: Option<Expr>,
        result: Expr,
    },
    Group(Expr),
    Array {
        exprs: Vec<Expr>,
    },
    Map {
        kvs: Vec<(Literal, Expr)>,
    },
    Interval {
        expr: Expr,
        unit: IntervalKind,
    },
    DateAdd {
        unit: IntervalKind,
        interval: Expr,
        date: Expr,
    },
    DateDiff {
        unit: IntervalKind,
        date_start: Expr,
        date_end: Expr,
    },
    DateBetween {
        unit: IntervalKind,
        date_start: Expr,
        date_end: Expr,
    },
    DateSub {
        unit: IntervalKind,
        interval: Expr,
        date: Expr,
    },
    DateTrunc {
        unit: IntervalKind,
        date: Expr,
    },
    TimeSlice {
        unit: IntervalKind,
        date: Expr,
        slice_length: u64,
        start_or_end: Option<String>,
    },
    LastDay {
        unit: IntervalKind,
        date: Expr,
    },
    PreviousDay {
        unit: Weekday,
        date: Expr,
    },
    NextDay {
        unit: Weekday,
        date: Expr,
    },
    Hole {
        name: String,
    },
    Placeholder,
    StageLocation {
        location: String,
    },
}

A ‘flattened’ AST of expressions.

This is used to parse expressions in Pratt parser. The Pratt parser is not able to parse expressions by grammar. So we need to extract the expression operands and operators to be the input of Pratt parser, by running a nom parser in advance.

For example, a + b AND c is null is parsed as [col(a), PLUS, col(b), AND, col(c), ISNULL] by nom parsers. Then the Pratt parser is able to parse the expression into AND(PLUS(col(a), col(b)), ISNULL(col(c))).

Variants

ColumnRef

Column reference, with indirection like table.column

Fields

column: ColumnRef

DotAccess

.a.b after column ref, currently it’ll be taken as column reference

Fields

key: ColumnID

IsNull

IS [NOT] NULL expression

Fields

not: bool

IsDistinctFrom

IS [NOT] DISTINCT FROM expression

Fields

not: bool

InList

[ NOT ] IN (list, ...)

Fields

list: Vec<Expr>

not: bool

InSubquery

[ NOT ] IN (SELECT ...)

Fields

subquery: Box<Query>

not: bool

LikeSubquery

LIKE (SELECT ...) [ESCAPE '<escape>']

Fields

modifier: SubqueryModifier

subquery: Box<Query>

escape: Option<String>

Escape

ESCAPE '<escape>'

Fields

escape: String

Between

BETWEEN ... AND ...

Fields

low: Box<Expr>

high: Box<Expr>

not: bool

BinaryOp

Binary operation

Fields

op: BinaryOperator

JsonOp

JSON operation

Fields

op: JsonOperator

UnaryOp

Unary operation

Fields

op: UnaryOperator

VariableAccess(String)

Cast

CAST expression, like CAST(expr AS target_type)

Fields

expr: Box<Expr>

target_type: TypeName

TryCast

TRY_CAST expression`

Fields

expr: Box<Expr>

target_type: TypeName

PgCast

::<type_name> expression

Fields

target_type: TypeName

Extract

EXTRACT(IntervalKind FROM )

Fields

field: IntervalKind

expr: Box<Expr>

DatePart

DATE_PART(IntervalKind, )

Fields

field: IntervalKind

expr: Box<Expr>

Position

POSITION( IN )

Fields

substr_expr: Box<Expr>

str_expr: Box<Expr>

SubString

SUBSTRING( [FROM ] [FOR ])

Fields

expr: Box<Expr>

substring_from: Box<Expr>

substring_for: Option<Box<Expr>>

Trim

TRIM([[BOTH | LEADING | TRAILING] FROM] ) Or TRIM()

Fields

expr: Box<Expr>

trim_where: Option<(TrimWhere, Box<Expr>)>

Literal

A literal value, such as string, number, date or NULL

Fields

value: Literal

CountAll

Count(*) expression

Fields

qualified: QualifiedName

window: Option<Window>

Tuple

(foo, bar)

Fields

exprs: Vec<Expr>

FunctionCall

Scalar function call

Fields

func: FunctionCall

Case

CASE ... WHEN ... ELSE ... expression

Fields

operand: Option<Box<Expr>>

conditions: Vec<Expr>

results: Vec<Expr>

else_result: Option<Box<Expr>>

Exists

EXISTS expression

Fields

subquery: Query

not: bool

Subquery

Scalar/ANY/ALL/SOME subquery

Fields

modifier: Option<SubqueryModifier>

subquery: Query

MapAccess

Access elements of Array, Object and Variant by index or key, like arr[0], or obj:k1

Fields

accessor: MapAccessor

ChainFunctionCall

python/rust style function call, like a.foo(b).bar(c) —> bar(foo(a, b), c)

Fields

name: Identifier

args: Vec<Expr>

lambda: Option<Lambda>

ListComprehension

python/rust list comprehension

Fields

source: Expr

param: Identifier

filter: Option<Expr>

result: Expr

Group(Expr)

An expression between parentheses

Array

[1, 2, 3]

Fields

exprs: Vec<Expr>

Map

{'k1':'v1','k2':'v2'}

Fields

kvs: Vec<(Literal, Expr)>

Interval

Fields

expr: Expr

unit: IntervalKind

DateAdd

Fields

unit: IntervalKind

interval: Expr

date: Expr

DateDiff

Fields

unit: IntervalKind

date_start: Expr

date_end: Expr

DateBetween

Fields

unit: IntervalKind

date_start: Expr

date_end: Expr

DateSub

Fields

unit: IntervalKind

interval: Expr

date: Expr

DateTrunc

Fields

unit: IntervalKind

date: Expr

TimeSlice

Fields

unit: IntervalKind

date: Expr

slice_length: u64

start_or_end: Option<String>

LastDay

Fields

unit: IntervalKind

date: Expr

PreviousDay

Fields

unit: Weekday

date: Expr

NextDay

Fields

unit: Weekday

date: Expr

Hole

Fields

name: String

Placeholder

StageLocation

Fields

location: String

Implementations

impl ExprElement

pub fn affix(&self) -> Affix

Trait Implementations

impl Clone for ExprElement

fn clone(&self) -> ExprElement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprElement

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

Formats the value using the given formatter.

impl PartialEq for ExprElement

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ExprElement