Enum models_parser::ast::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

Tuple Fields of Identifier

0: Ident

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

Tuple Fields of QualifiedWildcard

0: Vec<Ident>

CompoundIdentifier(Vec<Ident>)

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

Tuple Fields of CompoundIdentifier

0: Vec<Ident>

IsNull(Box<Expr>)

IS NULL expression

Tuple Fields of IsNull

0: Box<Expr>

IsNotNull(Box<Expr>)

IS NOT NULL expression

Tuple Fields of IsNotNull

0: Box<Expr>

InList(InList)

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

Tuple Fields of InList

0: InList

InSubquery(InSubquery)

[ NOT ] IN (SELECT ...)

Tuple Fields of InSubquery

0: InSubquery

Between(Between)

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

Tuple Fields of Between

0: Between

BinaryOp(BinaryOp)

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

Tuple Fields of BinaryOp

0: BinaryOp

UnaryOp(UnaryOp)

Unary operation e.g. NOT foo

Tuple Fields of UnaryOp

0: UnaryOp

Cast(Cast)

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

Tuple Fields of Cast

0: Cast

TryCast(TryCast)

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

Tuple Fields of TryCast

0: TryCast

Extract(Extract)

EXTRACT(DateTimeField FROM )

Tuple Fields of Extract

0: Extract

Substring(Substring)

SUBSTRING( [FROM ] [FOR ])

Tuple Fields of Substring

0: Substring

Trim(Trim)

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

Tuple Fields of Trim

0: Trim

Collate(Collate)

expr COLLATE collation

Tuple Fields of Collate

0: Collate

Nested(Box<Expr>)

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

Tuple Fields of Nested

0: Box<Expr>

Value(Value)

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

Tuple Fields of Value

0: Value

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

Tuple Fields of TypedString

0: TypedString

MapAccess(MapAccess)

Tuple Fields of MapAccess

0: MapAccess

Function(Function)

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

Tuple Fields of Function

0: Function

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

Tuple Fields of Case

0: Case

Exists(Box<Query>)

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

Tuple Fields of Exists

0: Box<Query>

Subquery(Box<Query>)

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

Tuple Fields of Subquery

0: Box<Query>

ListAgg(ListAgg)

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

Tuple Fields of ListAgg

0: ListAgg

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

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, 

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: &Expr) -> bool

This method tests for !=.

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr