Enum Expr 

pub enum Expr {
    Column {
        table: Option<String>,
        name: String,
    },
    Literal(Literal),
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Function {
        name: String,
        args: Vec<Expr>,
    },
    Case {
        operand: Option<Box<Expr>>,
        when_then: Vec<(Expr, Expr)>,
        else_result: Option<Box<Expr>>,
    },
    Cast {
        expr: Box<Expr>,
        data_type: DataType,
    },
    IsNull(Box<Expr>),
    IsNotNull(Box<Expr>),
    InList {
        expr: Box<Expr>,
        list: Vec<Expr>,
        negated: bool,
    },
    Between {
        expr: Box<Expr>,
        low: Box<Expr>,
        high: Box<Expr>,
        negated: bool,
    },
    Subquery(Box<SelectStatement>),
    Wildcard,
}

An expression.

Variants

Column

Column reference.

Fields

table: Option<String>

Optional table qualifier.

name: String

Column name.

Literal(Literal)

Literal value.

BinaryOp

Binary operation.

Fields

left: Box<Expr>

Left operand.

op: BinaryOperator

Operator.

right: Box<Expr>

Right operand.

UnaryOp

Unary operation.

Fields

op: UnaryOperator

Operator.

expr: Box<Expr>

Operand.

Function

Function call.

Fields

name: String

Function name.

args: Vec<Expr>

Arguments.

Case

CASE expression.

Fields

operand: Option<Box<Expr>>

Optional operand (for CASE x WHEN …).

when_then: Vec<(Expr, Expr)>

WHEN conditions and results.

else_result: Option<Box<Expr>>

ELSE result.

Cast

CAST expression.

Fields

expr: Box<Expr>

Expression to cast.

data_type: DataType

Target data type.

IsNull(Box<Expr>)

IS NULL.

IsNotNull(Box<Expr>)

IS NOT NULL.

InList

IN list.

Fields

expr: Box<Expr>

Expression.

list: Vec<Expr>

List of values.

negated: bool

Negated (NOT IN).

Between

BETWEEN.

Fields

expr: Box<Expr>

Expression.

low: Box<Expr>

Lower bound.

high: Box<Expr>

Upper bound.

negated: bool

Negated (NOT BETWEEN).

Subquery(Box<SelectStatement>)

Subquery.

Wildcard

Wildcard (*).

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<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expr