Enum Expr

pub enum Expr {
    Identifier(Ident),
    Wildcard,
    QualifiedWildcard(Vec<Ident>),
    CompoundIdentifier(Vec<Ident>),
    IsNull(Box<Expr>),
    IsNotNull(Box<Expr>),
    InList(InList),
    InSubquery(InSubquery),
    Between(Between),
    BinaryOp(BinaryOp),
    UnaryOp(UnaryOp),
    Cast(Cast),
    TryCast(TryCast),
    Extract(Extract),
    Substring(Substring),
    Trim(Trim),
    Collate(Collate),
    Nested(Box<Expr>),
    Value(Value),
    TypedString(TypedString),
    MapAccess(MapAccess),
    Function(Function),
    Case(Case),
    Exists(Box<Query>),
    Subquery(Box<Query>),
    ListAgg(ListAgg),
}

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

Wildcard

Unqualified wildcard (*). SQL allows this in limited contexts, such as:

• right after SELECT (which is represented as a SelectItem::Wildcard instead)
• or as part of an aggregate function, e.g. COUNT(*),

…but we currently also accept it in contexts where it doesn’t make sense, such as * + *

QualifiedWildcard(Vec<Ident>)

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

CompoundIdentifier(Vec<Ident>)

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

IsNull(Box<Expr>)

IS NULL expression

IsNotNull(Box<Expr>)

IS NOT NULL expression

InList(InList)

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

InSubquery(InSubquery)

[ NOT ] IN (SELECT ...)

Between(Between)

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

BinaryOp(BinaryOp)

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

UnaryOp(UnaryOp)

Unary operation e.g. NOT foo

Cast(Cast)

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

TryCast(TryCast)

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

Extract(Extract)

EXTRACT(DateTimeField FROM )

Substring(Substring)

SUBSTRING( [FROM ] [FOR ])

Trim(Trim)

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

Collate(Collate)

expr COLLATE collation

Nested(Box<Expr>)

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

Value(Value)

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

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

MapAccess(MapAccess)

Function(Function)

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

Case(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

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

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