Enum Expr 

pub enum Expr {
    Column(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 {
        when_then: Vec<(Expr, Expr)>,
        else_expr: Option<Box<Expr>>,
    },
    Cast {
        expr: Box<Expr>,
        data_type: ExprDataType,
    },
    Coalesce {
        exprs: Vec<Expr>,
    },
}

Represents an expression that can be used in a distributed computation

Variants

Column(String)

Column reference

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 statement

Fields

when_then: Vec<(Expr, Expr)>

When conditions and results

else_expr: Option<Box<Expr>>

Default result

Cast

CAST expression

Fields

expr: Box<Expr>

Input expression

data_type: ExprDataType

Target data type

Coalesce

COALESCE expression

Fields

exprs: Vec<Expr>

Expressions to check

Implementations

impl Expr

pub fn col(name: impl Into<String>) -> Self

Creates a column reference

pub fn lit<T: Into<Literal>>(value: T) -> Self

Creates a literal value

pub fn null() -> Self

Creates a literal NULL value

pub fn call(name: impl Into<String>, args: Vec<Expr>) -> Self

Creates a function call

pub fn binary(left: Expr, op: BinaryOperator, right: Expr) -> Self

Creates a binary operation

pub fn unary(op: UnaryOperator, expr: Expr) -> Self

Creates a unary operation

pub fn case(when_then: Vec<(Expr, Expr)>, else_expr: Option<Expr>) -> Self

Creates a CASE expression

pub fn cast(expr: Expr, data_type: ExprDataType) -> Self

Creates a CAST expression

pub fn coalesce(exprs: Vec<Expr>) -> Self

Creates a COALESCE expression

pub fn add(self, other: Expr) -> Self

Adds two expressions

pub fn sub(self, other: Expr) -> Self

Subtracts an expression from this one

pub fn mul(self, other: Expr) -> Self

Multiplies this expression by another

pub fn div(self, other: Expr) -> Self

Divides this expression by another

pub fn modulo(self, other: Expr) -> Self

Applies modulo operation

pub fn eq(self, other: Expr) -> Self

Checks if this expression equals another

pub fn neq(self, other: Expr) -> Self

Checks if this expression does not equal another

pub fn lt(self, other: Expr) -> Self

Checks if this expression is less than another

pub fn lte(self, other: Expr) -> Self

Checks if this expression is less than or equal to another

pub fn gt(self, other: Expr) -> Self

Checks if this expression is greater than another

pub fn gte(self, other: Expr) -> Self

Checks if this expression is greater than or equal to another

pub fn and(self, other: Expr) -> Self

Applies logical AND

pub fn or(self, other: Expr) -> Self

Applies logical OR

pub fn like(self, pattern: impl Into<String>) -> Self

Applies LIKE pattern matching

pub fn concat(self, other: Expr) -> Self

Concatenates with another string expression

pub fn negate(self) -> Self

Negates this expression

pub fn not(self) -> Self

Applies logical NOT

pub fn is_null(self) -> Self

Checks if this expression is NULL

pub fn is_not_null(self) -> Self

Checks if this expression is NOT NULL

pub fn to_boolean(self) -> Self

Casts this expression to boolean

pub fn to_integer(self) -> Self

Casts this expression to integer

pub fn to_float(self) -> Self

Casts this expression to float

pub fn to_string(self) -> Self

Casts this expression to string

pub fn to_date(self) -> Self

Casts this expression to date

pub fn to_timestamp(self) -> Self

Casts this expression to timestamp

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