Enum risinglight::parser::Expr

pub enum Expr {
    Identifier(Ident),
    CompoundIdentifier(Vec<Ident, Global>),
    JsonAccess {
        left: Box<Expr, Global>,
        operator: JsonOperator,
        right: Box<Expr, Global>,
    },
    CompositeAccess {
        expr: Box<Expr, Global>,
        key: Ident,
    },
    IsFalse(Box<Expr, Global>),
    IsNotFalse(Box<Expr, Global>),
    IsTrue(Box<Expr, Global>),
    IsNotTrue(Box<Expr, Global>),
    IsNull(Box<Expr, Global>),
    IsNotNull(Box<Expr, Global>),
    IsUnknown(Box<Expr, Global>),
    IsNotUnknown(Box<Expr, Global>),
    IsDistinctFrom(Box<Expr, Global>, Box<Expr, Global>),
    IsNotDistinctFrom(Box<Expr, Global>, Box<Expr, Global>),
    InList {
        expr: Box<Expr, Global>,
        list: Vec<Expr, Global>,
        negated: bool,
    },
    InSubquery {
        expr: Box<Expr, Global>,
        subquery: Box<Query, Global>,
        negated: bool,
    },
    InUnnest {
        expr: Box<Expr, Global>,
        array_expr: Box<Expr, Global>,
        negated: bool,
    },
    Between {
        expr: Box<Expr, Global>,
        negated: bool,
        low: Box<Expr, Global>,
        high: Box<Expr, Global>,
    },
    BinaryOp {
        left: Box<Expr, Global>,
        op: BinaryOperator,
        right: Box<Expr, Global>,
    },
    Like {
        negated: bool,
        expr: Box<Expr, Global>,
        pattern: Box<Expr, Global>,
        escape_char: Option<char>,
    },
    ILike {
        negated: bool,
        expr: Box<Expr, Global>,
        pattern: Box<Expr, Global>,
        escape_char: Option<char>,
    },
    SimilarTo {
        negated: bool,
        expr: Box<Expr, Global>,
        pattern: Box<Expr, Global>,
        escape_char: Option<char>,
    },
    AnyOp(Box<Expr, Global>),
    AllOp(Box<Expr, Global>),
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr, Global>,
    },
    Cast {
        expr: Box<Expr, Global>,
        data_type: DataType,
    },
    TryCast {
        expr: Box<Expr, Global>,
        data_type: DataType,
    },
    SafeCast {
        expr: Box<Expr, Global>,
        data_type: DataType,
    },
    AtTimeZone {
        timestamp: Box<Expr, Global>,
        time_zone: String,
    },
    Extract {
        field: DateTimeField,
        expr: Box<Expr, Global>,
    },
    Ceil {
        expr: Box<Expr, Global>,
        field: DateTimeField,
    },
    Floor {
        expr: Box<Expr, Global>,
        field: DateTimeField,
    },
    Position {
        expr: Box<Expr, Global>,
        in: Box<Expr, Global>,
    },
    Substring {
        expr: Box<Expr, Global>,
        substring_from: Option<Box<Expr, Global>>,
        substring_for: Option<Box<Expr, Global>>,
    },
    Trim {
        expr: Box<Expr, Global>,
        trim_where: Option<TrimWhereField>,
        trim_what: Option<Box<Expr, Global>>,
    },
    Overlay {
        expr: Box<Expr, Global>,
        overlay_what: Box<Expr, Global>,
        overlay_from: Box<Expr, Global>,
        overlay_for: Option<Box<Expr, Global>>,
    },
    Collate {
        expr: Box<Expr, Global>,
        collation: ObjectName,
    },
    Nested(Box<Expr, Global>),
    Value(Value),
    TypedString {
        data_type: DataType,
        value: String,
    },
    MapAccess {
        column: Box<Expr, Global>,
        keys: Vec<Expr, Global>,
    },
    Function(Function),
    AggregateExpressionWithFilter {
        expr: Box<Expr, Global>,
        filter: Box<Expr, Global>,
    },
    Case {
        operand: Option<Box<Expr, Global>>,
        conditions: Vec<Expr, Global>,
        results: Vec<Expr, Global>,
        else_result: Option<Box<Expr, Global>>,
    },
    Exists {
        subquery: Box<Query, Global>,
        negated: bool,
    },
    Subquery(Box<Query, Global>),
    ArraySubquery(Box<Query, Global>),
    ListAgg(ListAgg),
    ArrayAgg(ArrayAgg),
    GroupingSets(Vec<Vec<Expr, Global>, Global>),
    Cube(Vec<Vec<Expr, Global>, Global>),
    Rollup(Vec<Vec<Expr, Global>, Global>),
    Tuple(Vec<Expr, Global>),
    ArrayIndex {
        obj: Box<Expr, Global>,
        indexes: Vec<Expr, Global>,
    },
    Array(Array),
    Interval {
        value: Box<Expr, Global>,
        leading_field: Option<DateTimeField>,
        leading_precision: Option<u64>,
        last_field: Option<DateTimeField>,
        fractional_seconds_precision: Option<u64>,
    },
}

An SQL expression of any type.

The parser does not distinguish between expressions of different types (e.g. boolean vs string), so the caller must handle expressions of inappropriate type, like WHERE 1 or SELECT 1=1, as necessary.

Variants

Identifier(Ident)

Identifier e.g. table name or column name

CompoundIdentifier(Vec<Ident, Global>)

Multi-part identifier, e.g. table_alias.column or schema.table.col

JsonAccess

Fields

left: Box<Expr, Global>

operator: JsonOperator

right: Box<Expr, Global>

JSON access (postgres) eg: data->‘tags’

CompositeAccess

Fields

expr: Box<Expr, Global>

key: Ident

CompositeAccess (postgres) eg: SELECT (information_schema._pg_expandarray(array[‘i’,‘i’])).n

IsFalse(Box<Expr, Global>)

IS FALSE operator

IsNotFalse(Box<Expr, Global>)

IS NOT FALSE operator

IsTrue(Box<Expr, Global>)

IS TRUE operator

IsNotTrue(Box<Expr, Global>)

IS NOT TRUE operator

IsNull(Box<Expr, Global>)

IS NULL operator

IsNotNull(Box<Expr, Global>)

IS NOT NULL operator

IsUnknown(Box<Expr, Global>)

IS UNKNOWN operator

IsNotUnknown(Box<Expr, Global>)

IS NOT UNKNOWN operator

IsDistinctFrom(Box<Expr, Global>, Box<Expr, Global>)

IS DISTINCT FROM operator

IsNotDistinctFrom(Box<Expr, Global>, Box<Expr, Global>)

IS NOT DISTINCT FROM operator

InList

Fields

expr: Box<Expr, Global>

list: Vec<Expr, Global>

negated: bool

[ NOT ] IN (val1, val2, ...)

InSubquery

Fields

expr: Box<Expr, Global>

subquery: Box<Query, Global>

negated: bool

[ NOT ] IN (SELECT ...)

InUnnest

Fields

expr: Box<Expr, Global>

array_expr: Box<Expr, Global>

negated: bool

[ NOT ] IN UNNEST(array_expression)

Between

Fields

expr: Box<Expr, Global>

negated: bool

low: Box<Expr, Global>

high: Box<Expr, Global>

<expr> [ NOT ] BETWEEN <low> AND <high>

BinaryOp

Fields

left: Box<Expr, Global>

op: BinaryOperator

right: Box<Expr, Global>

Binary operation e.g. 1 + 1 or foo > bar

Like

Fields

negated: bool

expr: Box<Expr, Global>

pattern: Box<Expr, Global>

escape_char: Option<char>

LIKE

ILike

Fields

negated: bool

expr: Box<Expr, Global>

pattern: Box<Expr, Global>

escape_char: Option<char>

ILIKE (case-insensitive LIKE)

SimilarTo

Fields

negated: bool

expr: Box<Expr, Global>

pattern: Box<Expr, Global>

escape_char: Option<char>

SIMILAR TO regex

AnyOp(Box<Expr, Global>)

Any operation e.g. 1 ANY (1) or foo > ANY(bar), It will be wrapped in the right side of BinaryExpr

AllOp(Box<Expr, Global>)

ALL operation e.g. 1 ALL (1) or foo > ALL(bar), It will be wrapped in the right side of BinaryExpr

UnaryOp

Fields

op: UnaryOperator

expr: Box<Expr, Global>

Unary operation e.g. NOT foo

Cast

Fields

expr: Box<Expr, Global>

data_type: DataType

CAST an expression to a different data type e.g. CAST(foo AS VARCHAR(123))

TryCast

Fields

expr: Box<Expr, Global>

data_type: DataType

TRY_CAST an expression to a different data type e.g. TRY_CAST(foo AS VARCHAR(123))

SafeCast

Fields

expr: Box<Expr, Global>

data_type: DataType

SAFE_CAST an expression to a different data type e.g. SAFE_CAST(foo AS FLOAT64)

AtTimeZone

Fields

timestamp: Box<Expr, Global>

time_zone: String

AT a timestamp to a different timezone e.g. FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'

Extract

Fields

field: DateTimeField

expr: Box<Expr, Global>

EXTRACT(DateTimeField FROM )

Ceil

Fields

expr: Box<Expr, Global>

field: DateTimeField

CEIL( [TO DateTimeField])

Floor

Fields

expr: Box<Expr, Global>

field: DateTimeField

FLOOR( [TO DateTimeField])

Position

Fields

expr: Box<Expr, Global>

in: Box<Expr, Global>

POSITION( in )

Substring

Fields

expr: Box<Expr, Global>

substring_from: Option<Box<Expr, Global>>

substring_for: Option<Box<Expr, Global>>

SUBSTRING( [FROM ] [FOR ])

Trim

Fields

expr: Box<Expr, Global>

trim_where: Option<TrimWhereField>

trim_what: Option<Box<Expr, Global>>

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

Overlay

Fields

expr: Box<Expr, Global>

overlay_what: Box<Expr, Global>

overlay_from: Box<Expr, Global>

overlay_for: Option<Box<Expr, Global>>

OVERLAY( PLACING FROM [ FOR ]

Collate

Fields

expr: Box<Expr, Global>

collation: ObjectName

expr COLLATE collation

Nested(Box<Expr, Global>)

Nested expression e.g. (foo > bar) or (1)

Value(Value)

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

TypedString

Fields

data_type: DataType

value: String

A constant of form <data_type> 'value'. This can represent ANSI SQL DATE, TIME, and TIMESTAMP literals (such as DATE '2020-01-01'), as well as constants of other types (a non-standard PostgreSQL extension).

MapAccess

Fields

column: Box<Expr, Global>

keys: Vec<Expr, Global>

Access a map-like object by field (e.g. column['field'] or column[4] Note that depending on the dialect, struct like accesses may be parsed as [ArrayIndex] or [MapAccess] https://clickhouse.com/docs/en/sql-reference/data-types/map/

Function(Function)

Scalar function call e.g. LEFT(foo, 5)

AggregateExpressionWithFilter

Fields

expr: Box<Expr, Global>

filter: Box<Expr, Global>

Aggregate function with filter

Case

Fields

operand: Option<Box<Expr, Global>>

conditions: Vec<Expr, Global>

results: Vec<Expr, Global>

else_result: Option<Box<Expr, Global>>

CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END

Note we only recognize a complete single expression as <condition>, not < 0 nor 1, 2, 3 as allowed in a <simple when clause> per https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause

Exists

Fields

subquery: Box<Query, Global>

negated: bool

An exists expression [ NOT ] EXISTS(SELECT ...), used in expressions like WHERE [ NOT ] EXISTS (SELECT ...).

Subquery(Box<Query, Global>)

A parenthesized subquery (SELECT ...), used in expression like SELECT (subquery) AS x or WHERE (subquery) = x

ArraySubquery(Box<Query, Global>)

An array subquery constructor, e.g. SELECT ARRAY(SELECT 1 UNION SELECT 2)

ListAgg(ListAgg)

The LISTAGG function SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)

ArrayAgg(ArrayAgg)

The ARRAY_AGG function SELECT ARRAY_AGG(... ORDER BY ...)

GroupingSets(Vec<Vec<Expr, Global>, Global>)

The GROUPING SETS expr.

Cube(Vec<Vec<Expr, Global>, Global>)

The CUBE expr.

Rollup(Vec<Vec<Expr, Global>, Global>)

The ROLLUP expr.

Tuple(Vec<Expr, Global>)

ROW / TUPLE a single value, such as SELECT (1, 2)

ArrayIndex

Fields

obj: Box<Expr, Global>

indexes: Vec<Expr, Global>

An array index expression e.g. (ARRAY[1, 2])[1] or (current_schemas(FALSE))[1]

Array(Array)

An array expression e.g. ARRAY[1, 2]

Interval

Fields

value: Box<Expr, Global>

leading_field: Option<DateTimeField>

leading_precision: Option<u64>

last_field: Option<DateTimeField>

fractional_seconds_precision: Option<u64>

The seconds precision can be specified in SQL source as INTERVAL '__' SECOND(_, x) (in which case the leading_field will be Second and the last_field will be None), or as __ TO SECOND(x).

INTERVAL literals, roughly in the following format: INTERVAL '<value>' [ <leading_field> [ (<leading_precision>) ] ] [ TO <last_field> [ (<fractional_seconds_precision>) ] ], e.g. INTERVAL '123:45.67' MINUTE(3) TO SECOND(2).

The parser does not validate the <value>, nor does it ensure that the <leading_field> units >= the units in <last_field>, so the user will have to reject intervals like HOUR TO YEAR.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Expr, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expr

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

Formats the value using the given formatter.

impl Hash for Expr

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Expr> for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Expr

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr