Enum Expr

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

SQL expression

Variants

Between

BETWEEN

Fields

lhs: Box<Expr>

expression

not: bool

NOT

start: Box<Expr>

start

end: Box<Expr>

end

Binary(Box<Expr>, Operator, Box<Expr>)

binary expression

Case

CASE expression

Fields

base: Option<Box<Expr>>

operand

when_then_pairs: Vec<(Expr, Expr)>

WHEN condition THEN result

else_expr: Option<Box<Expr>>

ELSE result

Cast

CAST expression

Fields

expr: Box<Expr>

expression

type_name: Option<Type>

AS type name

Collate(Box<Expr>, Box<str>)

COLLATE: expression

DoublyQualified(Name, Name, Name)

schema-name.table-name.column-name

Exists(Box<Select>)

EXISTS subquery

FunctionCall

call to a built-in function

Fields

name: Id

function name

distinctness: Option<Distinctness>

DISTINCT

args: Option<Vec<Expr>>

arguments

order_by: Option<FunctionCallOrder>

ORDER BY or WITHIN GROUP

filter_over: Option<FunctionTail>

FILTER

FunctionCallStar

Function call expression with ‘*’ as arg

Fields

name: Id

function name

filter_over: Option<FunctionTail>

FILTER

Id(Id)

Identifier

InList

IN

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: Option<Vec<Expr>>

values

InSelect

IN subselect

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: Box<Select>

subquery

InTable

IN table name / function

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: QualifiedName

table name

args: Option<Vec<Expr>>

table function arguments

IsNull(Box<Expr>)

IS NULL

Like

LIKE

Fields

lhs: Box<Expr>

expression

not: bool

NOT

op: LikeOperator

operator

rhs: Box<Expr>

pattern

escape: Option<Box<Expr>>

ESCAPE char

Literal(Literal)

Literal expression

Name(Name)

Name

NotNull(Box<Expr>)

NOT NULL or NOTNULL

Parenthesized(Vec<Expr>)

Parenthesized subexpression

Qualified(Name, Name)

Qualified name

Raise(ResolveType, Option<Box<Expr>>)

RAISE function call

Subquery(Box<Select>)

Subquery expression

Unary(UnaryOperator, Box<Expr>)

Unary expression

Variable(Box<str>)

Parameters

Implementations

impl Expr

pub fn parenthesized(x: Self) -> Self

Constructor

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

Constructor

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

Constructor

pub fn cast(x: Self, type_name: Option<Type>) -> Self

Constructor

pub fn binary(left: Self, op: u16, right: Self) -> Self

Constructor

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

Constructor

pub fn like( lhs: Self, not: bool, op: LikeOperator, rhs: Self, escape: Option<Self>, ) -> Self

Constructor

pub fn not_null(x: Self, op: u16) -> Self

Constructor

pub fn unary(op: UnaryOperator, x: Self) -> Self

Constructor

pub fn between(lhs: Self, not: bool, start: Self, end: Self) -> Self

Constructor

pub fn in_list(lhs: Self, not: bool, rhs: Option<Vec<Self>>) -> Self

Constructor

pub fn in_select(lhs: Self, not: bool, rhs: Select) -> Self

Constructor

pub fn in_table( lhs: Self, not: bool, rhs: QualifiedName, args: Option<Vec<Self>>, ) -> Self

Constructor

pub fn sub_query(query: Select) -> Self

Constructor

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

Constructor

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

Check if an expression is an integer

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

impl Eq for Expr

impl StructuralPartialEq for Expr