Enum Expr

pub enum Expr {
    Identifier(Ident),
    CompoundIdentifier(Vec<Ident>),
    JsonAccess {
        left: Box<Expr>,
        operator: JsonOperator,
        right: Box<Expr>,
    },
    CompositeAccess {
        expr: Box<Expr>,
        key: Ident,
    },
    IsFalse(Box<Expr>),
    IsNotFalse(Box<Expr>),
    IsTrue(Box<Expr>),
    IsNotTrue(Box<Expr>),
    IsNull(Box<Expr>),
    IsNotNull(Box<Expr>),
    IsUnknown(Box<Expr>),
    IsNotUnknown(Box<Expr>),
    IsDistinctFrom(Box<Expr>, Box<Expr>),
    IsNotDistinctFrom(Box<Expr>, Box<Expr>),
    InList {
        expr: Box<Expr>,
        list: Vec<Expr>,
        negated: bool,
    },
    InSubquery {
        expr: Box<Expr>,
        subquery: Box<Query>,
        negated: bool,
    },
    InUnnest {
        expr: Box<Expr>,
        array_expr: Box<Expr>,
        negated: bool,
    },
    Between {
        expr: Box<Expr>,
        negated: bool,
        low: Box<Expr>,
        high: Box<Expr>,
    },
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    Like {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<char>,
    },
    ILike {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<char>,
    },
    SimilarTo {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<char>,
    },
    RLike {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        regexp: bool,
    },
    AnyOp {
        left: Box<Expr>,
        compare_op: BinaryOperator,
        right: Box<Expr>,
    },
    AllOp {
        left: Box<Expr>,
        compare_op: BinaryOperator,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Convert {
        expr: Box<Expr>,
        data_type: Option<DataType>,
        charset: Option<ObjectName>,
        target_before_value: bool,
    },
    Cast {
        expr: Box<Expr>,
        data_type: DataType,
        format: Option<CastFormat>,
    },
    TryCast {
        expr: Box<Expr>,
        data_type: DataType,
        format: Option<CastFormat>,
    },
    SafeCast {
        expr: Box<Expr>,
        data_type: DataType,
        format: Option<CastFormat>,
    },
    AtTimeZone {
        timestamp: Box<Expr>,
        time_zone: String,
    },
    Extract {
        field: DateTimeField,
        expr: Box<Expr>,
    },
    Ceil {
        expr: Box<Expr>,
        field: DateTimeField,
    },
    Floor {
        expr: Box<Expr>,
        field: DateTimeField,
    },
    Position {
        expr: Box<Expr>,
        in: Box<Expr>,
    },
    Substring {
        expr: Box<Expr>,
        substring_from: Option<Box<Expr>>,
        substring_for: Option<Box<Expr>>,
        special: bool,
    },
    Trim {
        expr: Box<Expr>,
        trim_where: Option<TrimWhereField>,
        trim_what: Option<Box<Expr>>,
        trim_characters: Option<Vec<Expr>>,
    },
    Overlay {
        expr: Box<Expr>,
        overlay_what: Box<Expr>,
        overlay_from: Box<Expr>,
        overlay_for: Option<Box<Expr>>,
    },
    Collate {
        expr: Box<Expr>,
        collation: ObjectName,
    },
    Nested(Box<Expr>),
    Value(Value),
    IntroducedString {
        introducer: String,
        value: Value,
    },
    TypedString {
        data_type: DataType,
        value: String,
    },
    MapAccess {
        column: Box<Expr>,
        keys: Vec<MapAccessKey>,
    },
    Function(Function),
    AggregateExpressionWithFilter {
        expr: Box<Expr>,
        filter: Box<Expr>,
    },
    Case {
        operand: Option<Box<Expr>>,
        conditions: Vec<Expr>,
        results: Vec<Expr>,
        else_result: Option<Box<Expr>>,
    },
    Exists {
        subquery: Box<Query>,
        negated: bool,
    },
    Subquery(Box<Query>),
    ArraySubquery(Box<Query>),
    ListAgg(ListAgg),
    ArrayAgg(ArrayAgg),
    GroupingSets(Vec<Vec<Expr>>),
    Cube(Vec<Vec<Expr>>),
    Rollup(Vec<Vec<Expr>>),
    Tuple(Vec<Expr>),
    Struct {
        values: Vec<Expr>,
        fields: Vec<StructField>,
    },
    Named {
        expr: Box<Expr>,
        name: Ident,
    },
    Dictionary(Vec<DictionaryField>),
    ArrayIndex {
        obj: Box<Expr>,
        indexes: Vec<Expr>,
    },
    Array(Array),
    Interval(Interval),
    MatchAgainst {
        columns: Vec<Ident>,
        match_value: Value,
        opt_search_modifier: Option<SearchModifier>,
    },
    Wildcard,
    QualifiedWildcard(ObjectName),
    OuterJoin(Box<Expr>),
}

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>)

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

JsonAccess

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

Fields

left: Box<Expr>

operator: JsonOperator

right: Box<Expr>

CompositeAccess

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

Fields

expr: Box<Expr>

key: Ident

IsFalse(Box<Expr>)

IS FALSE operator

IsNotFalse(Box<Expr>)

IS NOT FALSE operator

IsTrue(Box<Expr>)

IS TRUE operator

IsNotTrue(Box<Expr>)

IS NOT TRUE operator

IsNull(Box<Expr>)

IS NULL operator

IsNotNull(Box<Expr>)

IS NOT NULL operator

IsUnknown(Box<Expr>)

IS UNKNOWN operator

IsNotUnknown(Box<Expr>)

IS NOT UNKNOWN operator

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

IS DISTINCT FROM operator

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

IS NOT DISTINCT FROM operator

InList

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

Fields

expr: Box<Expr>

list: Vec<Expr>

negated: bool

InSubquery

[ NOT ] IN (SELECT ...)

Fields

expr: Box<Expr>

subquery: Box<Query>

negated: bool

InUnnest

[ NOT ] IN UNNEST(array_expression)

Fields

expr: Box<Expr>

array_expr: Box<Expr>

negated: bool

Between

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

Fields

expr: Box<Expr>

negated: bool

low: Box<Expr>

high: Box<Expr>

BinaryOp

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

Fields

left: Box<Expr>

op: BinaryOperator

right: Box<Expr>

Like

[NOT] LIKE <pattern> [ESCAPE <escape_character>]

Fields

negated: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<char>

ILike

ILIKE (case-insensitive LIKE)

Fields

negated: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<char>

SimilarTo

SIMILAR TO regex

Fields

negated: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<char>

RLike

MySQL: RLIKE regex or REGEXP regex

Fields

negated: bool

expr: Box<Expr>

pattern: Box<Expr>

regexp: bool

AnyOp

ANY operation e.g. foo > ANY(bar), comparison operator is one of [=, >, <, =>, =<, !=]

Fields

left: Box<Expr>

compare_op: BinaryOperator

right: Box<Expr>

AllOp

ALL operation e.g. foo > ALL(bar), comparison operator is one of [=, >, <, =>, =<, !=]

Fields

left: Box<Expr>

compare_op: BinaryOperator

right: Box<Expr>

UnaryOp

Unary operation e.g. NOT foo

Fields

op: UnaryOperator

expr: Box<Expr>

Convert

CONVERT a value to a different data type or character encoding. e.g. CONVERT(foo USING utf8mb4)

Fields

expr: Box<Expr>

The expression to convert

data_type: Option<DataType>

The target data type

charset: Option<ObjectName>

The target character encoding

target_before_value: bool

whether the target comes before the expr (MSSQL syntax)

Cast

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

Fields

expr: Box<Expr>

data_type: DataType

format: Option<CastFormat>

TryCast

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

Fields

expr: Box<Expr>

data_type: DataType

format: Option<CastFormat>

SafeCast

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

Fields

expr: Box<Expr>

data_type: DataType

format: Option<CastFormat>

AtTimeZone

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

Fields

timestamp: Box<Expr>

time_zone: String

Extract

Extract a field from a timestamp e.g. EXTRACT(MONTH FROM foo)

Syntax:

EXTRACT(DateTimeField FROM <expr>)

Fields

field: DateTimeField

expr: Box<Expr>

Ceil

CEIL(<expr> [TO DateTimeField])

Fields

expr: Box<Expr>

field: DateTimeField

Floor

FLOOR(<expr> [TO DateTimeField])

Fields

expr: Box<Expr>

field: DateTimeField

Position

POSITION(<expr> in <expr>)

Fields

expr: Box<Expr>

in: Box<Expr>

Substring

SUBSTRING(<expr> [FROM <expr>] [FOR <expr>])

or

SUBSTRING(<expr>, <expr>, <expr>)

Fields

expr: Box<Expr>

substring_from: Option<Box<Expr>>

substring_for: Option<Box<Expr>>

special: bool

false if the expression is represented using the SUBSTRING(expr [FROM start] [FOR len]) syntax true if the expression is represented using the SUBSTRING(expr, start, len) syntax This flag is used for formatting.

Trim

TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)
TRIM(<expr>)
TRIM(<expr>, [, characters]) -- only Snowflake or Bigquery

Fields

expr: Box<Expr>

trim_where: Option<TrimWhereField>

trim_what: Option<Box<Expr>>

trim_characters: Option<Vec<Expr>>

Overlay

OVERLAY(<expr> PLACING <expr> FROM <expr>[ FOR <expr> ]

Fields

expr: Box<Expr>

overlay_what: Box<Expr>

overlay_from: Box<Expr>

overlay_for: Option<Box<Expr>>

Collate

expr COLLATE collation

Fields

expr: Box<Expr>

collation: ObjectName

Nested(Box<Expr>)

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

Value(Value)

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

IntroducedString

https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html

Fields

introducer: String

value: Value

TypedString

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).

Fields

data_type: DataType

value: String

MapAccess

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/

Fields

column: Box<Expr>

keys: Vec<MapAccessKey>

Function(Function)

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

AggregateExpressionWithFilter

Aggregate function with filter

Fields

expr: Box<Expr>

filter: Box<Expr>

Case

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

Fields

operand: Option<Box<Expr>>

conditions: Vec<Expr>

results: Vec<Expr>

else_result: Option<Box<Expr>>

Exists

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

Fields

subquery: Box<Query>

negated: bool

Subquery(Box<Query>)

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

ArraySubquery(Box<Query>)

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>>)

The GROUPING SETS expr.

Cube(Vec<Vec<Expr>>)

The CUBE expr.

Rollup(Vec<Vec<Expr>>)

The ROLLUP expr.

Tuple(Vec<Expr>)

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

Struct

BigQuery specific Struct literal expression 1 Syntax:

STRUCT<[field_name] field_type, ...>( expr1 [, ... ])

Fields

values: Vec<Expr>

Struct values.

fields: Vec<StructField>

Struct field definitions.

Named

BigQuery specific: An named expression in a typeless struct 1

Syntax

1 AS A

Fields

expr: Box<Expr>

name: Ident

Dictionary(Vec<DictionaryField>)

DuckDB specific Struct literal expression 1

Syntax:

syntax: {'field_name': expr1[, ... ]}

ArrayIndex

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

Fields

obj: Box<Expr>

indexes: Vec<Expr>

Array(Array)

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

Interval(Interval)

An interval expression e.g. INTERVAL '1' YEAR

MatchAgainst

MySQL specific text search function (1).

Syntax:

MATCH (<col>, <col>, ...) AGAINST (<expr> [<search modifier>])

<col> = CompoundIdentifier
<expr> = String literal

Fields

columns: Vec<Ident>

(<col>, <col>, ...).

match_value: Value

<expr>.

opt_search_modifier: Option<SearchModifier>

<search modifier>

Wildcard

QualifiedWildcard(ObjectName)

Qualified wildcard, e.g. alias.* or schema.table.*. (Same caveats apply to QualifiedWildcard as to Wildcard.)

OuterJoin(Box<Expr>)

Some dialects support an older syntax for outer joins where columns are marked with the (+) operator in the WHERE clause, for example:

SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)

which is equivalent to

SELECT t1.c1, t2.c2 FROM t1 LEFT OUTER JOIN t2 ON t1.c1 = t2.c2

See https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause.

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 From<Expr> for FunctionArgExpr

fn from(wildcard_expr: Expr) -> FunctionArgExpr

Converts to this type from the input type.

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

fn cmp(&self, other: &Expr) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn partial_cmp(&self, other: &Expr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

fn visit<V>(&self, visitor: &mut V) -> ControlFlow<<V as Visitor>::Break>

where V: Visitor,

impl VisitMut for Expr

fn visit<V>(&mut self, visitor: &mut V) -> ControlFlow<<V as VisitorMut>::Break>

where V: VisitorMut,

impl Eq for Expr

impl StructuralPartialEq for Expr