Enum Expr 

pub enum Expr {
    Identifier(Ident),
    CompoundIdentifier(Vec<Ident>),
    IsNull(Box<Expr>),
    IsNotNull(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,
    },
    Between {
        expr: Box<Expr>,
        negated: bool,
        low: Box<Expr>,
        high: Box<Expr>,
    },
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Cast {
        expr: Box<Expr>,
        data_type: DataType,
    },
    TryCast {
        expr: Box<Expr>,
        data_type: DataType,
    },
    Extract {
        field: DateTimeField,
        expr: Box<Expr>,
    },
    Substring {
        expr: Box<Expr>,
        substring_from: Option<Box<Expr>>,
        substring_for: Option<Box<Expr>>,
    },
    Trim {
        expr: Box<Expr>,
        trim_where: Option<(TrimWhereField, Box<Expr>)>,
    },
    Collate {
        expr: Box<Expr>,
        collation: ObjectName,
    },
    Nested(Box<Expr>),
    Value(Value),
    TypedString {
        data_type: DataType,
        value: String,
    },
    MapAccess {
        column: Box<Expr>,
        keys: Vec<Expr>,
    },
    Function(Function),
    Case {
        operand: Option<Box<Expr>>,
        conditions: Vec<Expr>,
        results: Vec<Expr>,
        else_result: Option<Box<Expr>>,
    },
    Exists(Box<Query>),
    Subquery(Box<Query>),
    ListAgg(ListAgg),
    GroupingSets(Vec<Vec<Expr>>),
    Cube(Vec<Vec<Expr>>),
    Rollup(Vec<Vec<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

IsNull(Box<Expr>)

IS NULL operator

IsNotNull(Box<Expr>)

IS NOT NULL 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

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>

UnaryOp

Unary operation e.g. NOT foo

Fields

op: UnaryOperator

expr: Box<Expr>

Cast

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

Fields

expr: Box<Expr>

data_type: DataType

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

Extract

EXTRACT(DateTimeField FROM )

Fields

field: DateTimeField

expr: Box<Expr>

Substring

SUBSTRING( [FROM ] [FOR ])

Fields

expr: Box<Expr>

substring_from: Option<Box<Expr>>

substring_for: Option<Box<Expr>>

Trim

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

Fields

expr: Box<Expr>

trim_where: Option<(TrimWhereField, 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

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

Fields

column: Box<Expr>

keys: Vec<Expr>

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

operand: Option<Box<Expr>>

conditions: Vec<Expr>

results: Vec<Expr>

else_result: Option<Box<Expr>>

Exists(Box<Query>)

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

Subquery(Box<Query>)

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

ListAgg(ListAgg)

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

GroupingSets(Vec<Vec<Expr>>)

The GROUPING SETS expr.

Cube(Vec<Vec<Expr>>)

The CUBE expr.

Rollup(Vec<Vec<Expr>>)

The ROLLUP expr.

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

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

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

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

impl StructuralPartialEq for Expr