Enum databend_common_ast::ast::Expr

pub enum Expr {
    ColumnRef {
        span: Span,
        column: ColumnRef,
    },
    IsNull {
        span: Span,
        expr: Box<Expr>,
        not: bool,
    },
    IsDistinctFrom {
        span: Span,
        left: Box<Expr>,
        right: Box<Expr>,
        not: bool,
    },
    InList {
        span: Span,
        expr: Box<Expr>,
        list: Vec<Expr>,
        not: bool,
    },
    InSubquery {
        span: Span,
        expr: Box<Expr>,
        subquery: Box<Query>,
        not: bool,
    },
    Between {
        span: Span,
        expr: Box<Expr>,
        low: Box<Expr>,
        high: Box<Expr>,
        not: bool,
    },
    BinaryOp {
        span: Span,
        op: BinaryOperator,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    JsonOp {
        span: Span,
        op: JsonOperator,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    UnaryOp {
        span: Span,
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Cast {
        span: Span,
        expr: Box<Expr>,
        target_type: TypeName,
        pg_style: bool,
    },
    TryCast {
        span: Span,
        expr: Box<Expr>,
        target_type: TypeName,
    },
    Extract {
        span: Span,
        kind: IntervalKind,
        expr: Box<Expr>,
    },
    DatePart {
        span: Span,
        kind: IntervalKind,
        expr: Box<Expr>,
    },
    Position {
        span: Span,
        substr_expr: Box<Expr>,
        str_expr: Box<Expr>,
    },
    Substring {
        span: Span,
        expr: Box<Expr>,
        substring_from: Box<Expr>,
        substring_for: Option<Box<Expr>>,
    },
    Trim {
        span: Span,
        expr: Box<Expr>,
        trim_where: Option<(TrimWhere, Box<Expr>)>,
    },
    Literal {
        span: Span,
        value: Literal,
    },
    CountAll {
        span: Span,
        window: Option<Window>,
    },
    Tuple {
        span: Span,
        exprs: Vec<Expr>,
    },
    FunctionCall {
        span: Span,
        func: FunctionCall,
    },
    Case {
        span: Span,
        operand: Option<Box<Expr>>,
        conditions: Vec<Expr>,
        results: Vec<Expr>,
        else_result: Option<Box<Expr>>,
    },
    Exists {
        span: Span,
        not: bool,
        subquery: Box<Query>,
    },
    Subquery {
        span: Span,
        modifier: Option<SubqueryModifier>,
        subquery: Box<Query>,
    },
    MapAccess {
        span: Span,
        expr: Box<Expr>,
        accessor: MapAccessor,
    },
    Array {
        span: Span,
        exprs: Vec<Expr>,
    },
    Map {
        span: Span,
        kvs: Vec<(Literal, Expr)>,
    },
    Interval {
        span: Span,
        expr: Box<Expr>,
        unit: IntervalKind,
    },
    DateAdd {
        span: Span,
        unit: IntervalKind,
        interval: Box<Expr>,
        date: Box<Expr>,
    },
    DateSub {
        span: Span,
        unit: IntervalKind,
        interval: Box<Expr>,
        date: Box<Expr>,
    },
    DateTrunc {
        span: Span,
        unit: IntervalKind,
        date: Box<Expr>,
    },
    Hole {
        span: Span,
        name: String,
    },
}

Variants

ColumnRef

Column reference, with indirection like table.column

Fields

span: Span

column: ColumnRef

IsNull

IS [ NOT ] NULL expression

Fields

span: Span

expr: Box<Expr>

not: bool

IsDistinctFrom

IS [NOT] DISTINCT expression

Fields

span: Span

left: Box<Expr>

right: Box<Expr>

not: bool

InList

[ NOT ] IN (expr, ...)

Fields

span: Span

expr: Box<Expr>

list: Vec<Expr>

not: bool

InSubquery

[ NOT ] IN (SELECT ...)

Fields

span: Span

expr: Box<Expr>

subquery: Box<Query>

not: bool

Between

BETWEEN ... AND ...

Fields

span: Span

expr: Box<Expr>

low: Box<Expr>

high: Box<Expr>

not: bool

BinaryOp

Binary operation

Fields

span: Span

op: BinaryOperator

left: Box<Expr>

right: Box<Expr>

JsonOp

JSON operation

Fields

span: Span

op: JsonOperator

left: Box<Expr>

right: Box<Expr>

UnaryOp

Unary operation

Fields

span: Span

op: UnaryOperator

expr: Box<Expr>

Cast

CAST expression, like CAST(expr AS target_type)

Fields

span: Span

expr: Box<Expr>

target_type: TypeName

pg_style: bool

TryCast

TRY_CAST expression`

Fields

span: Span

expr: Box<Expr>

target_type: TypeName

Extract

EXTRACT(IntervalKind FROM )

Fields

span: Span

kind: IntervalKind

expr: Box<Expr>

DatePart

DATE_PART(IntervalKind, )

Fields

span: Span

kind: IntervalKind

expr: Box<Expr>

Position

POSITION( IN )

Fields

span: Span

substr_expr: Box<Expr>

str_expr: Box<Expr>

Substring

SUBSTRING( [FROM ] [FOR ])

Fields

span: Span

expr: Box<Expr>

substring_from: Box<Expr>

substring_for: Option<Box<Expr>>

Trim

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

Fields

span: Span

expr: Box<Expr>

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

Literal

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

Fields

span: Span

value: Literal

CountAll

COUNT(*) expression

Fields

span: Span

window: Option<Window>

Tuple

(foo, bar)

Fields

span: Span

exprs: Vec<Expr>

FunctionCall

Scalar/Agg/Window function call

Fields

span: Span

func: FunctionCall

Case

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

Fields

span: Span

operand: Option<Box<Expr>>

conditions: Vec<Expr>

results: Vec<Expr>

else_result: Option<Box<Expr>>

Exists

EXISTS expression

Fields

span: Span

not: bool

Indicate if this is a NOT EXISTS

subquery: Box<Query>

Subquery

Scalar/ANY/ALL/SOME subquery

Fields

span: Span

modifier: Option<SubqueryModifier>

subquery: Box<Query>

MapAccess

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

Fields

span: Span

expr: Box<Expr>

accessor: MapAccessor

Array

The Array expr

Fields

span: Span

exprs: Vec<Expr>

Map

The Map expr

Fields

span: Span

kvs: Vec<(Literal, Expr)>

Interval

The Interval 1 DAY expr

Fields

span: Span

expr: Box<Expr>

unit: IntervalKind

DateAdd

Fields

span: Span

unit: IntervalKind

interval: Box<Expr>

date: Box<Expr>

DateSub

Fields

span: Span

unit: IntervalKind

interval: Box<Expr>

date: Box<Expr>

DateTrunc

Fields

span: Span

unit: IntervalKind

date: Box<Expr>

Hole

Fields

span: Span

name: String

Implementations

impl Expr

pub fn span(&self) -> Span

pub fn whole_span(&self) -> Span

pub fn all_function_like_syntaxes() -> &'static [&'static str]

impl Expr

pub fn affix(&self) -> Affix

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy 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 Display for Expr

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

Formats the value using the given formatter.

impl Drive for Expr

fn drive<V: Visitor>(&self, visitor: &mut V)

impl DriveMut for Expr

fn drive_mut<V: VisitorMut>(&mut self, visitor: &mut V)

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> 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 Expr