Enum mz_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<T>,
        negated: bool,
    },
    InList {
        expr: Box<Expr<T>>,
        list: Vec<Expr<T>>,
        negated: bool,
    },
    InSubquery {
        expr: Box<Expr<T>>,
        subquery: Box<Query<T>>,
        negated: bool,
    },
    Like {
        expr: Box<Expr<T>>,
        pattern: Box<Expr<T>>,
        escape: Option<Box<Expr<T>>>,
        case_insensitive: bool,
        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: T::DataType,
    },
    Collate {
        expr: Box<Expr<T>>,
        collation: UnresolvedItemName,
    },
    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>>),
    ArraySubquery(Box<Query<T>>),
    List(Vec<Expr<T>>),
    ListSubquery(Box<Query<T>>),
    Map(Vec<MapEntry<T>>),
    MapSubquery(Box<Query<T>>),
    Subscript {
        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>)

Identifier e.g. table name or column name

QualifiedWildcard(Vec<Ident>)

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

FieldAccess

A field access, like (expr).foo.

Fields

expr: Box<Expr<T>>

field: Ident

WildcardAccess(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)

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

Not

Boolean negation

Fields

expr: Box<Expr<T>>

And

Boolean and

Fields

left: Box<Expr<T>>

right: Box<Expr<T>>

Or

Boolean or

Fields

left: Box<Expr<T>>

right: Box<Expr<T>>

IsExpr

IS {NULL, TRUE, FALSE, UNKNOWN} expression

Fields

expr: Box<Expr<T>>

construct: IsExprConstruct<T>

negated: bool

InList

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

Fields

expr: Box<Expr<T>>

list: Vec<Expr<T>>

negated: bool

InSubquery

[ NOT ] IN (SELECT ...)

Fields

expr: Box<Expr<T>>

subquery: Box<Query<T>>

negated: bool

Like

<expr> [ NOT ] {LIKE, ILIKE} <pattern> [ ESCAPE <escape> ]

Fields

expr: Box<Expr<T>>

pattern: Box<Expr<T>>

escape: Option<Box<Expr<T>>>

case_insensitive: bool

negated: bool

Between

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

Fields

expr: Box<Expr<T>>

negated: bool

low: Box<Expr<T>>

high: Box<Expr<T>>

Op

Unary or binary operator

Fields

op: Op

expr1: Box<Expr<T>>

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

Cast

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

Fields

expr: Box<Expr<T>>

data_type: T::DataType

Collate

expr COLLATE collation

Fields

expr: Box<Expr<T>>

collation: UnresolvedItemName

HomogenizingFunction

COALESCE(<expr>, ...) or GREATEST(<expr>, ...) or LEAST(<expr>, …)

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.

Fields

function: HomogenizingFunction

exprs: Vec<Expr<T>>

NullIf

NULLIF(expr, expr)

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

Fields

l_expr: Box<Expr<T>>

r_expr: Box<Expr<T>>

Nested(Box<Expr<T>>)

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

Row

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

Fields

exprs: Vec<Expr<T>>

Value(Value)

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

Function(Function<T>)

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

conditions: Vec<Expr<T>>

results: Vec<Expr<T>>

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

Exists(Box<Query<T>>)

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

Subquery(Box<Query<T>>)

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

AnySubquery

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

Fields

left: Box<Expr<T>>

op: Op

right: Box<Query<T>>

AnyExpr

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

Fields

left: Box<Expr<T>>

op: Op

right: Box<Expr<T>>

AllSubquery

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

Fields

left: Box<Expr<T>>

op: Op

right: Box<Query<T>>

AllExpr

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

Fields

left: Box<Expr<T>>

op: Op

right: Box<Expr<T>>

Array(Vec<Expr<T>>)

ARRAY[<expr>*]

ArraySubquery(Box<Query<T>>)

List(Vec<Expr<T>>)

LIST[<expr>*]

ListSubquery(Box<Query<T>>)

Map(Vec<MapEntry<T>>)

MAP[<expr>*]

MapSubquery(Box<Query<T>>)

Subscript

<expr>([<expr>(:<expr>)?])+

Fields

expr: Box<Expr<T>>

positions: Vec<SubscriptPosition<T>>

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 not_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 cast(self, data_type: T::DataType) -> Expr<T>

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

pub fn call_nullary(name: T::ItemName) -> Expr<T>

pub fn call_unary(self, name: T::ItemName) -> 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

fn to_ast_string_redacted(&self) -> String

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

where T::DataType: Clone,

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>

where T::DataType: Debug,

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: AstInfo, T2: AstInfo> FoldNode<T, T2> for Expr<T>

type Folded = Expr<T2>

fn fold<F: Fold<T, T2>>(self, folder: &mut F) -> Self::Folded

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

where T::DataType: Hash,

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

where T::DataType: Ord,

fn cmp(&self, other: &Expr<T>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

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

where T::DataType: PartialEq,

fn eq(&self, other: &Expr<T>) -> 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<T: PartialOrd + AstInfo> PartialOrd for Expr<T>

where T::DataType: PartialOrd,

fn partial_cmp(&self, other: &Expr<T>) -> 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<'ast, T: AstInfo> VisitMutNode<'ast, T> for Expr<T>

fn visit_mut<V: VisitMut<'ast, T>>(&'ast mut self, visitor: &mut V)

impl<'ast, T: AstInfo> VisitNode<'ast, T> for Expr<T>

fn visit<V: Visit<'ast, T>>(&'ast self, visitor: &mut V)

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

where T::DataType: Eq,

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