Enum Expr 

pub enum Expr {
    Literal(Literal),
    Param(Param),
    Idiom(Idiom),
    Table(String),
    Mock(Mock),
    Block(Box<Block>),
    Constant(Constant),
    Prefix {
        op: PrefixOperator,
        expr: Box<Expr>,
    },
    Postfix {
        expr: Box<Expr>,
        op: PostfixOperator,
    },
    Binary {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    FunctionCall(Box<FunctionCall>),
    Closure(Box<Closure>),
    Break,
    Continue,
    Throw(Box<Expr>),
    Return(Box<OutputStatement>),
    IfElse(Box<IfelseStatement>),
    Select(Box<SelectStatement>),
    Create(Box<CreateStatement>),
    Update(Box<UpdateStatement>),
    Delete(Box<DeleteStatement>),
    Relate(Box<RelateStatement>),
    Insert(Box<InsertStatement>),
    Define(Box<DefineStatement>),
    Remove(Box<RemoveStatement>),
    Rebuild(Box<RebuildStatement>),
    Upsert(Box<UpsertStatement>),
    Alter(Box<AlterStatement>),
    Info(Box<InfoStatement>),
    Foreach(Box<ForeachStatement>),
    Let(Box<SetStatement>),
    Sleep(Box<SleepStatement>),
    Explain {
        format: ExplainFormat,
        analyze: bool,
        statement: Box<Expr>,
    },
}

Variants

Literal(Literal)

Param(Param)

Idiom(Idiom)

Table(String)

Mock(Mock)

Block(Box<Block>)

Constant(Constant)

Prefix

Fields

op: PrefixOperator

expr: Box<Expr>

Postfix

Fields

expr: Box<Expr>

op: PostfixOperator

Binary

Fields

left: Box<Expr>

op: BinaryOperator

right: Box<Expr>

FunctionCall(Box<FunctionCall>)

Closure(Box<Closure>)

Break

Continue

Throw(Box<Expr>)

Return(Box<OutputStatement>)

IfElse(Box<IfelseStatement>)

Select(Box<SelectStatement>)

Create(Box<CreateStatement>)

Update(Box<UpdateStatement>)

Delete(Box<DeleteStatement>)

Relate(Box<RelateStatement>)

Insert(Box<InsertStatement>)

Define(Box<DefineStatement>)

Remove(Box<RemoveStatement>)

Rebuild(Box<RebuildStatement>)

Upsert(Box<UpsertStatement>)

Alter(Box<AlterStatement>)

Info(Box<InfoStatement>)

Foreach(Box<ForeachStatement>)

Let(Box<SetStatement>)

Sleep(Box<SleepStatement>)

Explain

Fields

format: ExplainFormat

analyze: bool

statement: Box<Expr>

Implementations

impl Expr

pub fn to_idiom(&self) -> Idiom

pub fn from_public_value(value: PublicValue) -> Self

pub fn needs_parentheses(&self) -> bool

Returns if this expression needs to be parenthesized when inside another expression.

pub fn has_left_none_null(&self) -> bool

Returns true if there is a NONE or NULL value in the left most spot when formatting. returns true for NONE + 1, NULL(), NONE, NULL.. etc.

Required for proper formatting when NONE can conflict with a clause.

pub fn has_left_minus(&self) -> bool

pub fn has_left_idiom(&self) -> bool

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 From<Box<Expr>> for Expr

fn from(b: Box<Expr>) -> Self

Converts to this type from the input type.

impl From<Cond> for Expr

fn from(c: Cond) -> Self

Converts to this type from the input type.

impl From<Expr> for Cond

fn from(e: Expr) -> Self

Converts to this type from the input type.

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 ToSql for Expr

fn fmt_sql(&self, f: &mut String, fmt: SqlFormat)

Format the type to a SQL string.

fn to_sql(&self) -> String

Convert the type to a SQL string.

fn to_sql_pretty(&self) -> String

Convert the type to a pretty-printed SQL string with indentation.

impl Eq for Expr

impl StructuralPartialEq for Expr