Enum Expression

pub enum Expression {
    Literal(Literal),
    Column(Identifier),
    Unary {
        op: UnaryOperator,
        expr: Box<Expression>,
    },
    Binary {
        op: BinaryOperator,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Wildcard,
    Aggregation {
        op: AggregationOperator,
        expr: Box<Expression>,
    },
}

Boolean Expressions

Variants

Literal(Literal)

Literal

Column(Identifier)

Column

Unary

Unary operation

Fields

op: UnaryOperator

The unary operator

expr: Box<Expression>

The expression to apply the operator to

Binary

Binary operation

Fields

op: BinaryOperator

The binary operator

left: Box<Expression>

The left hand side of the operation

right: Box<Expression>

The right hand side of the operation

Wildcard

• expression

Aggregation

Aggregation operation

Fields

op: AggregationOperator

The aggregation operator

expr: Box<Expression>

The expression to aggregate

Implementations

impl Expression

pub fn sum(self) -> Box<Self>

Create a new SUM()

pub fn max(self) -> Box<Self>

Create a new MAX()

pub fn min(self) -> Box<Self>

Create a new MIN()

pub fn count(self) -> Box<Self>

Create a new COUNT()

pub fn first(self) -> Box<Self>

Create a new FIRST()

pub fn alias(self, alias: &str) -> AliasedResultExpr

Create an AliasedResultExpr from an Expression using the provided alias.

Panics

This function will panic if the provided alias cannot be parsed into an Identifier. It will also panic if self cannot be boxed.

Trait Implementations

impl Add for Box<Expression>

type Output = Box<Expression>

The resulting type after applying the + operator.

fn add(self, rhs: Box<Expression>) -> Box<Expression>

Performs the + operation.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div for Box<Expression>

type Output = Box<Expression>

The resulting type after applying the / operator.

fn div(self, rhs: Box<Expression>) -> Box<Expression>

Performs the / operation.

impl From<Expression> for Expr

fn from(expr: Expression) -> Self

Converts to this type from the input type.

impl From<Expression> for FunctionArgExpr

fn from(expr: Expression) -> Self

Converts to this type from the input type.

impl Hash for Expression

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Box<Expression>

type Output = Box<Expression>

The resulting type after applying the * operator.

fn mul(self, rhs: Box<Expression>) -> Box<Expression>

Performs the * operation.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 Expression

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Box<Expression>

type Output = Box<Expression>

The resulting type after applying the - operator.

fn sub(self, rhs: Box<Expression>) -> Box<Expression>

Performs the - operation.

impl Eq for Expression

impl StructuralPartialEq for Expression