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>>,
        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 of Between

lhs: Box<Expr>not: boolstart: Box<Expr>end: Box<Expr>

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

Case

Fields of Case

base: Option<Box<Expr>>when_then_pairs: Vec<(Expr, Expr)>else_expr: Option<Box<Expr>>

Cast

Fields of Cast

expr: Box<Expr>type_name: Type

Collate(Box<Expr>, String)

DoublyQualified(Name, Name, Name)

Exists(Box<Select>)

FunctionCall

Fields of FunctionCall

name: Iddistinctness: Option<Distinctness>args: Option<Vec<Expr>>filter_over: Option<FunctionTail>

FunctionCallStar

Fields of FunctionCallStar

name: Idfilter_over: Option<FunctionTail>

Id(Id)

InList

Fields of InList

lhs: Box<Expr>not: boolrhs: Option<Vec<Expr>>

InSelect

Fields of InSelect

lhs: Box<Expr>not: boolrhs: Box<Select>

InTable

Fields of InTable

lhs: Box<Expr>not: boolrhs: QualifiedNameargs: Option<Vec<Expr>>

IsNull(Box<Expr>)

Like

Fields of Like

lhs: Box<Expr>not: boolop: LikeOperatorrhs: 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 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.

pub 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 Eq for Expr

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

This method tests for !=.

impl StructuralEq for Expr

impl StructuralPartialEq for Expr

impl ToTokens for Expr

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

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