Enum sqlite3_parser::ast::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: Type,
    },
    Collate(Box<Expr>, String),
    DoublyQualified(Name, Name, Name),
    Exists(Box<Select>),
    FunctionCall {
        name: Id,
        distinctness: Option<Distinctness>,
        args: Option<Vec<Expr>>,
        order_by: Option<Vec<SortedColumn>>,
        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<Name>),
    Subquery(Box<Select>),
    Unary(UnaryOperator, Box<Expr>),
    Variable(String),
}

Variants

Between

Fields

lhs: Box<Expr>

not: bool

start: Box<Expr>

end: Box<Expr>

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

Case

Fields

base: Option<Box<Expr>>

when_then_pairs: Vec<(Expr, Expr)>

else_expr: Option<Box<Expr>>

Cast

Fields

expr: Box<Expr>

type_name: Type

Collate(Box<Expr>, String)

DoublyQualified(Name, Name, Name)

Exists(Box<Select>)

FunctionCall

Fields

name: Id

distinctness: Option<Distinctness>

args: Option<Vec<Expr>>

order_by: Option<Vec<SortedColumn>>

filter_over: Option<FunctionTail>

FunctionCallStar

Fields

name: Id

filter_over: Option<FunctionTail>

Id(Id)

InList

Fields

lhs: Box<Expr>

not: bool

rhs: Option<Vec<Expr>>

InSelect

Fields

lhs: Box<Expr>

not: bool

rhs: Box<Select>

InTable

Fields

lhs: Box<Expr>

not: bool

rhs: QualifiedName

args: Option<Vec<Expr>>

IsNull(Box<Expr>)

Like

Fields

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

Subquery(Box<Select>)

Unary(UnaryOperator, Box<Expr>)

Variable(String)

Implementations

impl Expr

pub fn parenthesized(x: Expr) -> Expr

pub fn id(xt: u16, x: Token) -> Expr

pub fn collate(x: Expr, ct: u16, c: Token) -> Expr

pub fn cast(x: Expr, type_name: Type) -> Expr

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

pub fn ptr(left: Expr, op: Token, right: Expr) -> Expr

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

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

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

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

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

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

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

pub fn sub_query(query: Select) -> Expr

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

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

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

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr