Enum Expr 

pub enum Expr<'bump> {
    Between {
        lhs: &'bump Expr<'bump>,
        not: bool,
        start: &'bump Expr<'bump>,
        end: &'bump Expr<'bump>,
    },
    Binary(&'bump Expr<'bump>, Operator, &'bump Expr<'bump>),
    Case {
        base: Option<&'bump Expr<'bump>>,
        when_then_pairs: &'bump [(Expr<'bump>, Expr<'bump>)],
        else_expr: Option<&'bump Expr<'bump>>,
    },
    Cast {
        expr: &'bump Expr<'bump>,
        type_name: Option<Type<'bump>>,
    },
    Collate(&'bump Expr<'bump>, &'bump str),
    DoublyQualified(Name<'bump>, Name<'bump>, Name<'bump>),
    Exists(&'bump Select<'bump>),
    FunctionCall {
        name: Id<'bump>,
        distinctness: Option<Distinctness>,
        args: Option<&'bump [Expr<'bump>]>,
        order_by: Option<FunctionCallOrder<'bump>>,
        filter_over: Option<FunctionTail<'bump>>,
    },
    FunctionCallStar {
        name: Id<'bump>,
        filter_over: Option<FunctionTail<'bump>>,
    },
    Id(Id<'bump>),
    InList {
        lhs: &'bump Expr<'bump>,
        not: bool,
        rhs: Option<&'bump [Expr<'bump>]>,
    },
    InSelect {
        lhs: &'bump Expr<'bump>,
        not: bool,
        rhs: &'bump Select<'bump>,
    },
    InTable {
        lhs: &'bump Expr<'bump>,
        not: bool,
        rhs: QualifiedName<'bump>,
        args: Option<&'bump [Expr<'bump>]>,
    },
    IsNull(&'bump Expr<'bump>),
    Like {
        lhs: &'bump Expr<'bump>,
        not: bool,
        op: LikeOperator,
        rhs: &'bump Expr<'bump>,
        escape: Option<&'bump Expr<'bump>>,
    },
    Literal(Literal<'bump>),
    Name(Name<'bump>),
    NotNull(&'bump Expr<'bump>),
    Parenthesized(Vec<'bump, Expr<'bump>>),
    Qualified(Name<'bump>, Name<'bump>),
    Raise(ResolveType, Option<&'bump Expr<'bump>>),
    Subquery(&'bump Select<'bump>),
    Unary(UnaryOperator, &'bump Expr<'bump>),
    Variable(&'bump str),
}

SQL expression

Variants

Between

BETWEEN

Fields

lhs: &'bump Expr<'bump>

expression

not: bool

NOT

start: &'bump Expr<'bump>

start

end: &'bump Expr<'bump>

end

Binary(&'bump Expr<'bump>, Operator, &'bump Expr<'bump>)

binary expression

Case

CASE expression

Fields

base: Option<&'bump Expr<'bump>>

operand

when_then_pairs: &'bump [(Expr<'bump>, Expr<'bump>)]

WHEN condition THEN result

else_expr: Option<&'bump Expr<'bump>>

ELSE result

Cast

CAST expression

Fields

expr: &'bump Expr<'bump>

expression

type_name: Option<Type<'bump>>

AS type name

Collate(&'bump Expr<'bump>, &'bump str)

COLLATE: expression

DoublyQualified(Name<'bump>, Name<'bump>, Name<'bump>)

schema-name.table-name.column-name

Exists(&'bump Select<'bump>)

EXISTS subquery

FunctionCall

call to a built-in function

Fields

name: Id<'bump>

function name

distinctness: Option<Distinctness>

DISTINCT

args: Option<&'bump [Expr<'bump>]>

arguments

order_by: Option<FunctionCallOrder<'bump>>

ORDER BY or WITHIN GROUP

filter_over: Option<FunctionTail<'bump>>

FILTER

FunctionCallStar

Function call expression with ‘*’ as arg

Fields

name: Id<'bump>

function name

filter_over: Option<FunctionTail<'bump>>

FILTER

Id(Id<'bump>)

Identifier

InList

IN

Fields

lhs: &'bump Expr<'bump>

expression

not: bool

NOT

rhs: Option<&'bump [Expr<'bump>]>

values

InSelect

IN subselect

Fields

lhs: &'bump Expr<'bump>

expression

not: bool

NOT

rhs: &'bump Select<'bump>

subquery

InTable

IN table name / function

Fields

lhs: &'bump Expr<'bump>

expression

not: bool

NOT

rhs: QualifiedName<'bump>

table name

args: Option<&'bump [Expr<'bump>]>

table function arguments

IsNull(&'bump Expr<'bump>)

IS NULL

Like

LIKE

Fields

lhs: &'bump Expr<'bump>

expression

not: bool

NOT

op: LikeOperator

operator

rhs: &'bump Expr<'bump>

pattern

escape: Option<&'bump Expr<'bump>>

ESCAPE char

Literal(Literal<'bump>)

Literal expression

Name(Name<'bump>)

Name

NotNull(&'bump Expr<'bump>)

NOT NULL or NOTNULL

Parenthesized(Vec<'bump, Expr<'bump>>)

Parenthesized subexpression

Qualified(Name<'bump>, Name<'bump>)

Qualified name

Raise(ResolveType, Option<&'bump Expr<'bump>>)

RAISE function call

Subquery(&'bump Select<'bump>)

Subquery expression

Unary(UnaryOperator, &'bump Expr<'bump>)

Unary expression

Variable(&'bump str)

Parameters

Implementations

impl<'bump> Expr<'bump>

pub fn parenthesized(x: Self, b: &'bump Bump) -> Self

Constructor

pub fn id(xt: u16, x: Token<'_>, b: &'bump Bump) -> Self

Constructor

pub fn collate(x: Self, ct: u16, c: Token<'_>, b: &'bump Bump) -> Self

Constructor

pub fn cast(x: Self, type_name: Option<Type<'bump>>, b: &'bump Bump) -> Self

Constructor

pub fn binary(left: Self, op: u16, right: Self, b: &'bump Bump) -> Self

Constructor

pub fn ptr(left: Self, op: Token<'_>, right: Self, b: &'bump Bump) -> Self

Constructor

pub fn like( lhs: Self, not: bool, op: LikeOperator, rhs: Self, escape: Option<Self>, b: &'bump Bump, ) -> Self

Constructor

pub fn not_null(x: Self, op: u16, b: &'bump Bump) -> Self

Constructor

pub fn unary(op: UnaryOperator, x: Self, b: &'bump Bump) -> Self

Constructor

pub fn between( lhs: Self, not: bool, start: Self, end: Self, b: &'bump Bump, ) -> Self

Constructor

pub fn in_list( lhs: Self, not: bool, rhs: Option<Vec<'bump, Self>>, b: &'bump Bump, ) -> Self

Constructor

pub fn in_select( lhs: Self, not: bool, rhs: Select<'bump>, b: &'bump Bump, ) -> Self

Constructor

pub fn in_table( lhs: Self, not: bool, rhs: QualifiedName<'bump>, args: Option<Vec<'bump, Self>>, b: &'bump Bump, ) -> Self

Constructor

pub fn sub_query(query: Select<'bump>, b: &'bump Bump) -> Self

Constructor

pub fn function_call( xt: u16, x: Token<'_>, distinctness: Option<Distinctness>, args: Option<Vec<'bump, Self>>, order_by: Option<FunctionCallOrder<'bump>>, filter_over: Option<FunctionTail<'bump>>, b: &'bump Bump, ) -> Result<Self, ParserError>

Constructor

pub fn is_integer(&self) -> Option<i64>

Check if an expression is an integer

Trait Implementations

impl<'bump> Debug for Expr<'bump>

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

impl<'bump> PartialEq for Expr<'bump>

fn eq(&self, other: &Expr<'bump>) -> 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<'bump> StructuralPartialEq for Expr<'bump>

impl ToTokens for Expr<'_>

fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error>

Send token(s) to the specified stream

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

Format AST node