Enum sql_parser::ast::defs::expr::Expr

pub enum Expr<T: AstInfo> {
    Identifier(Vec<Ident>),
    QualifiedWildcard(Vec<Ident>),
    FieldAccess {
        expr: Box<Expr<T>>,
        field: Ident,
    },
    WildcardAccess(Box<Expr<T>>),
    Parameter(usize),
    Not {
        expr: Box<Expr<T>>,
    },
    And {
        left: Box<Expr<T>>,
        right: Box<Expr<T>>,
    },
    Or {
        left: Box<Expr<T>>,
        right: Box<Expr<T>>,
    },
    IsExpr {
        expr: Box<Expr<T>>,
        construct: IsExprConstruct,
        negated: bool,
    },
    InList {
        expr: Box<Expr<T>>,
        list: Vec<Expr<T>>,
        negated: bool,
    },
    InSubquery {
        expr: Box<Expr<T>>,
        subquery: Box<Query<T>>,
        negated: bool,
    },
    Between {
        expr: Box<Expr<T>>,
        negated: bool,
        low: Box<Expr<T>>,
        high: Box<Expr<T>>,
    },
    Op {
        op: Op,
        expr1: Box<Expr<T>>,
        expr2: Option<Box<Expr<T>>>,
    },
    Cast {
        expr: Box<Expr<T>>,
        data_type: DataType<T>,
    },
    Collate {
        expr: Box<Expr<T>>,
        collation: UnresolvedObjectName,
    },
    HomogenizingFunction {
        function: HomogenizingFunction,
        exprs: Vec<Expr<T>>,
    },
    NullIf {
        l_expr: Box<Expr<T>>,
        r_expr: Box<Expr<T>>,
    },
    Nested(Box<Expr<T>>),
    Row {
        exprs: Vec<Expr<T>>,
    },
    Value(Value),
    Function(Function<T>),
    Case {
        operand: Option<Box<Expr<T>>>,
        conditions: Vec<Expr<T>>,
        results: Vec<Expr<T>>,
        else_result: Option<Box<Expr<T>>>,
    },
    Exists(Box<Query<T>>),
    Subquery(Box<Query<T>>),
    AnySubquery {
        left: Box<Expr<T>>,
        op: Op,
        right: Box<Query<T>>,
    },
    AnyExpr {
        left: Box<Expr<T>>,
        op: Op,
        right: Box<Expr<T>>,
    },
    AllSubquery {
        left: Box<Expr<T>>,
        op: Op,
        right: Box<Query<T>>,
    },
    AllExpr {
        left: Box<Expr<T>>,
        op: Op,
        right: Box<Expr<T>>,
    },
    Array(Vec<Expr<T>>),
    List(Vec<Expr<T>>),
    ListSubquery(Box<Query<T>>),
    SubscriptScalar {
        expr: Box<Expr<T>>,
        subscript: Box<Expr<T>>,
    },
    SubscriptSlice {
        expr: Box<Expr<T>>,
        positions: Vec<SubscriptPosition<T>>,
    },
}

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(Vec<Ident>)

Tuple Fields

0: Vec<Ident>

Identifier e.g. table name or column name

QualifiedWildcard(Vec<Ident>)

Tuple Fields

0: Vec<Ident>

Qualified wildcard, e.g. alias.* or schema.table.*.

FieldAccess

Fields

expr: Box<Expr<T>>

field: Ident

A field access, like (expr).foo.

WildcardAccess(Box<Expr<T>>)

Tuple Fields

0: Box<Expr<T>>

A wildcard field access, like (expr).*.

Note that this is different from QualifiedWildcard in that the wildcard access occurs on an arbitrary expression, rather than a qualified name. The distinction is important for PostgreSQL compatibility.

Parameter(usize)

Tuple Fields

0: usize

A positional parameter, e.g., $1 or $42

Not

Fields

expr: Box<Expr<T>>

Boolean negation

And

Fields

left: Box<Expr<T>>

right: Box<Expr<T>>

Boolean and

Or

Fields

left: Box<Expr<T>>

right: Box<Expr<T>>

Boolean or

IsExpr

Fields

expr: Box<Expr<T>>

construct: IsExprConstruct

negated: bool

IS {NULL, TRUE, FALSE, UNKNOWN} expression

InList

Fields

expr: Box<Expr<T>>

list: Vec<Expr<T>>

negated: bool

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

InSubquery

Fields

expr: Box<Expr<T>>

subquery: Box<Query<T>>

negated: bool

[ NOT ] IN (SELECT ...)

Between

Fields

expr: Box<Expr<T>>

negated: bool

low: Box<Expr<T>>

high: Box<Expr<T>>

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

Op

Fields

op: Op

expr1: Box<Expr<T>>

expr2: Option<Box<Expr<T>>>

Unary or binary operator

Cast

Fields

expr: Box<Expr<T>>

data_type: DataType<T>

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

Collate

Fields

expr: Box<Expr<T>>

collation: UnresolvedObjectName

expr COLLATE collation

HomogenizingFunction

Fields

function: HomogenizingFunction

exprs: Vec<Expr<T>>

COALESCE(, …) or GREATEST(, …) or LEAST(, …)

While COALESCE/GREATEST/LEAST have the same syntax as a function call, their semantics are extremely unusual, and are better captured with a dedicated AST node.

NullIf

Fields

l_expr: Box<Expr<T>>

r_expr: Box<Expr<T>>

NULLIF(expr, expr)

While NULLIF has the same syntax as a function call, it is not evaluated as a function within Postgres.

Nested(Box<Expr<T>>)

Tuple Fields

0: Box<Expr<T>>

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

Row

Fields

exprs: Vec<Expr<T>>

A row constructor like ROW(<expr>...) or (<expr>, <expr>...).

Value(Value)

Tuple Fields

0: Value

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

Function(Function<T>)

Tuple Fields

0: Function<T>

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

Case

Fields

operand: Option<Box<Expr<T>>>

conditions: Vec<Expr<T>>

results: Vec<Expr<T>>

else_result: Option<Box<Expr<T>>>

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

Tuple Fields

0: Box<Query<T>>

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

Subquery(Box<Query<T>>)

Tuple Fields

0: Box<Query<T>>

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

AnySubquery

Fields

left: Box<Expr<T>>

op: Op

right: Box<Query<T>>

<expr> <op> ANY/SOME (<query>)

AnyExpr

Fields

left: Box<Expr<T>>

op: Op

right: Box<Expr<T>>

<expr> <op> ANY (<array_expr>)

AllSubquery

Fields

left: Box<Expr<T>>

op: Op

right: Box<Query<T>>

<expr> <op> ALL (<query>)

AllExpr

Fields

left: Box<Expr<T>>

op: Op

right: Box<Expr<T>>

<expr> <op> ALL (<array_expr>)

Array(Vec<Expr<T>>)

Tuple Fields

0: Vec<Expr<T>>

ARRAY[<expr>*]

List(Vec<Expr<T>>)

Tuple Fields

0: Vec<Expr<T>>

LIST[<expr>*]

ListSubquery(Box<Query<T>>)

Tuple Fields

0: Box<Query<T>>

SubscriptScalar

Fields

expr: Box<Expr<T>>

subscript: Box<Expr<T>>

<expr>[<expr>]

SubscriptSlice

Fields

expr: Box<Expr<T>>

positions: Vec<SubscriptPosition<T>>

<expr>[<expr>:<expr>(, <expr>?:<expr>?)*]

Implementations

impl<T: AstInfo> Expr<T>

pub fn null() -> Expr<T>

pub fn number<S>(n: S) -> Expr<T> where
    S: Into<String>, 

pub fn negate(self) -> Expr<T>

pub fn and(self, right: Expr<T>) -> Expr<T>

pub fn or(self, right: Expr<T>) -> Expr<T>

pub fn binop(self, op: Op, right: Expr<T>) -> Expr<T>

pub fn lt(self, right: Expr<T>) -> Expr<T>

pub fn lt_eq(self, right: Expr<T>) -> Expr<T>

pub fn gt(self, right: Expr<T>) -> Expr<T>

pub fn gt_eq(self, right: Expr<T>) -> Expr<T>

pub fn equals(self, right: Expr<T>) -> Expr<T>

pub fn minus(self, right: Expr<T>) -> Expr<T>

pub fn multiply(self, right: Expr<T>) -> Expr<T>

pub fn modulo(self, right: Expr<T>) -> Expr<T>

pub fn divide(self, right: Expr<T>) -> Expr<T>

pub fn call(name: Vec<&str>, args: Vec<Expr<T>>) -> Expr<T>

pub fn call_nullary(name: Vec<&str>) -> Expr<T>

pub fn call_unary(self, name: Vec<&str>) -> Expr<T>

pub fn take(&mut self) -> Expr<T>

Trait Implementations

impl<T: AstInfo> AstDisplay for Expr<T>

fn fmt<W: Write>(&self, f: &mut AstFormatter<W>)

fn to_ast_string(&self) -> String

fn to_ast_string_stable(&self) -> String

impl<T: Clone + AstInfo> Clone for Expr<T>

fn clone(&self) -> Expr<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + AstInfo> Debug for Expr<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: AstInfo> Display for Expr<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Hash + AstInfo> Hash for Expr<T>

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<T: PartialEq + AstInfo> PartialEq<Expr<T>> for Expr<T>

fn eq(&self, other: &Expr<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Expr<T>) -> bool

This method tests for !=.

impl<T: Eq + AstInfo> Eq for Expr<T>

impl<T: AstInfo> StructuralEq for Expr<T>

impl<T: AstInfo> StructuralPartialEq for Expr<T>