Enum proof_of_sql_parser::intermediate_ast::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.

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

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