Enum databend_common_ast::parser::expr::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,
    },
    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 {
        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,
    },
    DateSub {
        unit: IntervalKind,
        interval: Expr,
        date: Expr,
    },
    DateTrunc {
        unit: IntervalKind,
        date: Expr,
    },
    Hole {
        name: 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

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

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

DateSub

Fields

unit: IntervalKind

interval: Expr

date: Expr

DateTrunc

Fields

unit: IntervalKind

date: Expr

Hole

Fields

name: String

Implementations

impl ExprElement

pub fn affix(&self) -> Affix

Trait Implementations

impl Clone for ExprElement

fn clone(&self) -> ExprElement

Returns a copy 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