Enum Expr 

pub enum Expr {
    Identifier(Ident),
    CompoundIdentifier(Vec<Ident>),
    CompoundFieldAccess {
        root: Box<Expr>,
        access_chain: Vec<AccessExpr>,
    },
    JsonAccess {
        value: Box<Expr>,
        path: JsonPath,
    },
    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>),
    IsNormalized {
        expr: Box<Expr>,
        form: Option<NormalizationForm>,
        negated: bool,
    },
    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,
        any: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<Value>,
    },
    ILike {
        negated: bool,
        any: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<Value>,
    },
    SimilarTo {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        escape_char: Option<Value>,
    },
    RLike {
        negated: bool,
        expr: Box<Expr>,
        pattern: Box<Expr>,
        regexp: bool,
    },
    AnyOp {
        left: Box<Expr>,
        compare_op: BinaryOperator,
        right: Box<Expr>,
        is_some: bool,
    },
    AllOp {
        left: Box<Expr>,
        compare_op: BinaryOperator,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Convert {
        is_try: bool,
        expr: Box<Expr>,
        data_type: Option<DataType>,
        charset: Option<ObjectName>,
        target_before_value: bool,
        styles: Vec<Expr>,
    },
    Cast {
        kind: CastKind,
        expr: Box<Expr>,
        data_type: DataType,
        format: Option<CastFormat>,
    },
    AtTimeZone {
        timestamp: Box<Expr>,
        time_zone: Box<Expr>,
    },
    Extract {
        field: DateTimeField,
        syntax: ExtractSyntax,
        expr: Box<Expr>,
    },
    Ceil {
        expr: Box<Expr>,
        field: CeilFloorKind,
    },
    Floor {
        expr: Box<Expr>,
        field: CeilFloorKind,
    },
    Position {
        expr: Box<Expr>,
        in: Box<Expr>,
    },
    Substring {
        expr: Box<Expr>,
        substring_from: Option<Box<Expr>>,
        substring_for: Option<Box<Expr>>,
        special: bool,
        shorthand: 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(ValueWithSpan),
    Prefixed {
        prefix: Ident,
        value: Box<Expr>,
    },
    TypedString {
        data_type: DataType,
        value: ValueWithSpan,
    },
    Function(Function),
    Case {
        case_token: AttachedToken,
        end_token: AttachedToken,
        operand: Option<Box<Expr>>,
        conditions: Vec<CaseWhen>,
        else_result: Option<Box<Expr>>,
    },
    Exists {
        subquery: Box<Query>,
        negated: bool,
    },
    Subquery(Box<Query>),
    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>),
    Map(Map),
    Array(Array),
    Interval(Interval),
    MatchAgainst {
        columns: Vec<ObjectName>,
        match_value: Value,
        opt_search_modifier: Option<SearchModifier>,
    },
    Wildcard(AttachedToken),
    QualifiedWildcard(ObjectName, AttachedToken),
    OuterJoin(Box<Expr>),
    Prior(Box<Expr>),
    Lambda(LambdaFunction),
    MemberOf(MemberOf),
}

An SQL expression of any type.

Semantics / Type Checking

The parser does not distinguish between expressions of different types (e.g. boolean vs string). The caller is responsible for detecting and validating types as necessary (for example WHERE 1 vs SELECT 1=1) See the README.md for more details.

Equality and Hashing Does not Include Source Locations

The Expr type implements PartialEq and Eq based on the semantic value of the expression (not bitwise comparison). This means that Expr instances that are semantically equivalent but have different spans (locations in the source tree) will compare as equal.

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

CompoundFieldAccess

Multi-part expression access.

This structure represents an access chain in structured / nested types such as maps, arrays, and lists:

• Array
  • A 1-dim array a[1] will be represented like: CompoundFieldAccess(Ident('a'), vec![Subscript(1)]
  • A 2-dim array a[1][2] will be represented like: CompoundFieldAccess(Ident('a'), vec![Subscript(1), Subscript(2)]
• Map or Struct (Bracket-style)
  • A map a['field1'] will be represented like: CompoundFieldAccess(Ident('a'), vec![Subscript('field')]
  • A 2-dim map a['field1']['field2'] will be represented like: CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Subscript('field2')]
• Struct (Dot-style) (only effect when the chain contains both subscript and expr)
  • A struct access a[field1].field2 will be represented like: CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Ident('field2')]
• If a struct access likes a.field1.field2, it will be represented by CompoundIdentifier([a, field1, field2])

Fields

root: Box<Expr>

access_chain: Vec<AccessExpr>

JsonAccess

Access data nested in a value containing semi-structured data, such as the VARIANT type on Snowflake. for example src:customer[0].name.

See https://docs.snowflake.com/en/user-guide/querying-semistructured. See https://docs.databricks.com/en/sql/language-manual/functions/colonsign.html.

Fields

value: Box<Expr>

The value being queried.

path: JsonPath

The path to the data to extract.

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

IsNormalized

<expr> IS [ NOT ] [ form ] NORMALIZED

Fields

expr: Box<Expr>

form: Option<NormalizationForm>

negated: bool

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

any: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<Value>

ILike

ILIKE (case-insensitive LIKE)

Fields

negated: bool

any: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<Value>

SimilarTo

SIMILAR TO regex

Fields

negated: bool

expr: Box<Expr>

pattern: Box<Expr>

escape_char: Option<Value>

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 [=, >, <, =>, =<, !=] https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any

Fields

left: Box<Expr>

compare_op: BinaryOperator

right: Box<Expr>

is_some: bool

AllOp

ALL operation e.g. foo > ALL(bar), comparison operator is one of [=, >, <, =>, =<, !=] https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any

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

is_try: bool

CONVERT (false) or TRY_CONVERT (true) https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16

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)

styles: Vec<Expr>

How to translate the expression.

Cast

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

Fields

kind: CastKind

expr: Box<Expr>

data_type: DataType

format: Option<CastFormat>

Optional CAST(string_expression AS type FORMAT format_string_expression) as used by BigQuery

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: Box<Expr>

Extract

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

Syntax:

EXTRACT(DateTimeField FROM <expr>) | EXTRACT(DateTimeField, <expr>)

Fields

field: DateTimeField

syntax: ExtractSyntax

expr: Box<Expr>

Ceil

CEIL(<expr> [TO DateTimeField])

CEIL( <input_expr> [, <scale_expr> ] )

Fields

expr: Box<Expr>

field: CeilFloorKind

Floor

FLOOR(<expr> [TO DateTimeField])

FLOOR( <input_expr> [, <scale_expr> ] )

Fields

expr: Box<Expr>

field: CeilFloorKind

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.

shorthand: bool

true if the expression is represented using the SUBSTR shorthand 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(ValueWithSpan)

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

Prefixed

Prefixed expression, e.g. introducer strings, projection prefix https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html https://docs.snowflake.com/en/sql-reference/constructs/connect-by

Fields

prefix: Ident

value: Box<Expr>

The value of the constant. Hint: you can unwrap the string value using value.into_string().

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: ValueWithSpan

The value of the constant. Hint: you can unwrap the string value using value.into_string().

Function(Function)

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

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

case_token: AttachedToken

end_token: AttachedToken

operand: Option<Box<Expr>>

conditions: Vec<CaseWhen>

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

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

Struct literal expression Syntax:

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

[BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type)
[Databricks](https://docs.databricks.com/en/sql/language-manual/functions/struct.html)

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[, ... ]}

Map(Map)

DuckDB specific Map literal expression 1

Syntax:

syntax: Map {key1: value1[, ... ]}

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

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

match_value: Value

<expr>.

opt_search_modifier: Option<SearchModifier>

<search modifier>

Wildcard(AttachedToken)

QualifiedWildcard(ObjectName, AttachedToken)

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.

Prior(Box<Expr>)

A reference to the prior level in a CONNECT BY clause.

Lambda(LambdaFunction)

A lambda function.

Syntax:

param -> expr | (param1, ...) -> expr

ClickHouse Databricks DuckDb

MemberOf(MemberOf)

Checks membership of a value in a JSON array

Implementations

impl Expr

pub fn value(value: impl Into<ValueWithSpan>) -> Expr

Creates a new Expr::Value

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate 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 Spanned for Expr

partial span

Most expressions are missing keywords in their spans. f.e. IS NULL <expr> reports as <expr>::span.

Missing spans:

• Expr::MatchAgainst # MySQL specific
• Expr::RLike # MySQL specific
• Expr::Struct # BigQuery specific
• Expr::Named # BigQuery specific
• Expr::Dictionary # DuckDB specific
• Expr::Map # DuckDB specific
• Expr::Lambda

fn span(&self) -> Span

Return the [Span] (the minimum and maximum Location) for this AST node, by recursively combining the spans of its children.

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