Enum ScalarExpr

pub enum ScalarExpr {
    Column(usize),
    Literal(Value, ConcreteDataType),
    CallUnmaterializable(UnmaterializableFunc),
    CallUnary {
        func: UnaryFunc,
        expr: Box<ScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<ScalarExpr>,
        expr2: Box<ScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<ScalarExpr>,
    },
    CallDf {
        df_scalar_fn: DfScalarFunction,
        exprs: Vec<ScalarExpr>,
    },
    If {
        cond: Box<ScalarExpr>,
        then: Box<ScalarExpr>,
        els: Box<ScalarExpr>,
    },
}

A scalar expression, which can be evaluated to a value.

Variants

Column(usize)

A column of the input row

Literal(Value, ConcreteDataType)

A literal value. Extra type info to know original type even when it is null

CallUnmaterializable(UnmaterializableFunc)

A call to an unmaterializable function.

These functions cannot be evaluated by ScalarExpr::eval. They must be transformed away by a higher layer.

CallUnary

Fields

func: UnaryFunc

expr: Box<ScalarExpr>

CallBinary

Fields

func: BinaryFunc

expr1: Box<ScalarExpr>

expr2: Box<ScalarExpr>

CallVariadic

Fields

func: VariadicFunc

exprs: Vec<ScalarExpr>

CallDf

Fields

df_scalar_fn: DfScalarFunction

invariant: the input args set inside this DfScalarFunction is always col(0) to col(n-1) where n is the length of expr

exprs: Vec<ScalarExpr>

If

Conditionally evaluated expressions.

It is important that then and els only be evaluated if cond is true or not, respectively. This is the only way users can guard execution (other logical operator do not short-circuit) and we need to preserve that.

Fields

cond: Box<ScalarExpr>

then: Box<ScalarExpr>

els: Box<ScalarExpr>

Implementations

impl ScalarExpr

pub fn with_type(self, typ: ColumnType) -> TypedExpr

pub fn typ(&self, context: &[ColumnType]) -> Result<ColumnType, Error>

try to determine the type of the expression

impl ScalarExpr

pub fn cast(self, typ: ConcreteDataType) -> Self

pub fn optimize(&mut self)

apply optimization to the expression, like flatten variadic function

fn flatten_variadic_fn(&mut self)

Because Substrait’s And/Or function is binary, but FlowPlan’s And/Or function is variadic, we need to flatten the And function if multiple And/Or functions are nested.

impl ScalarExpr

pub fn call_unary(self, func: UnaryFunc) -> Self

Call a unary function on this expression.

pub fn call_binary(self, other: Self, func: BinaryFunc) -> Self

Call a binary function on this expression and another.

pub fn eval_batch(&self, batch: &Batch) -> Result<VectorRef, EvalError>

fn eval_if_then( batch: &Batch, cond: &ScalarExpr, then: &ScalarExpr, els: &ScalarExpr, ) -> Result<VectorRef, EvalError>

NOTE: this if then eval impl assume all given expr are pure, and will not change the state of the world since it will evaluate both then and else branch and filter the result

pub fn eval(&self, values: &[Value]) -> Result<Value, EvalError>

Eval this expression with the given values.

TODO(discord9): add tests to make sure eval_batch is the same as eval in most cases

pub fn permute(&mut self, permutation: &[usize]) -> Result<(), Error>

Rewrites column indices with their value in permutation.

This method is applicable even when permutation is not a strict permutation, and it only needs to have entries for each column referenced in self.

pub fn permute_map( &mut self, permutation: &BTreeMap<usize, usize>, ) -> Result<(), Error>

Rewrites column indices with their value in permutation.

This method is applicable even when permutation is not a strict permutation, and it only needs to have entries for each column referenced in self.

pub fn get_all_ref_columns(&self) -> BTreeSet<usize>

Returns the set of columns that are referenced by self.

pub fn is_column(&self) -> bool

Return true if the expression is a column reference.

pub fn as_column(&self) -> Option<usize>

Cast the expression to a column reference if it is one.

pub fn as_literal(&self) -> Option<Value>

Cast the expression to a literal if it is one.

pub fn is_literal(&self) -> bool

Return true if the expression is a literal.

pub fn is_literal_true(&self) -> bool

Return true if the expression is a literal true.

pub fn is_literal_false(&self) -> bool

Return true if the expression is a literal false.

pub fn is_literal_null(&self) -> bool

Return true if the expression is a literal null.

pub fn literal_null() -> Self

Build a literal null

pub fn literal(res: Value, typ: ConcreteDataType) -> Self

Build a literal from value and type

pub fn literal_false() -> Self

Build a literal false

pub fn literal_true() -> Self

Build a literal true

impl ScalarExpr

fn visit_post_nolimit<F>(&self, f: &mut F) -> Result<(), EvalError>

where F: FnMut(&Self) -> Result<(), EvalError>,

visit post-order without stack call limit, but may cause stack overflow

fn visit_children<F>(&self, f: F) -> Result<(), EvalError>

where F: FnMut(&Self) -> Result<(), EvalError>,

fn visit_mut_post_nolimit<F>(&mut self, f: &mut F) -> Result<(), Error>

where F: FnMut(&mut Self) -> Result<(), Error>,

fn visit_mut_children<F>(&mut self, f: F) -> Result<(), Error>

where F: FnMut(&mut Self) -> Result<(), Error>,

impl ScalarExpr

pub fn contains_temporal(&self) -> bool

if expr contains function Now

pub fn extract_bound(&self) -> Result<(Option<Self>, Option<Self>), Error>

extract lower or upper bound of Now for expr, where lower bound <= expr < upper bound

returned bool indicates whether the bound is upper bound:

false for lower bound, true for upper bound TODO(discord9): allow simple transform like now() + a < b to now() < b - a

Trait Implementations

impl Clone for ScalarExpr

fn clone(&self) -> ScalarExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ScalarExpr

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

Formats the value using the given formatter.

impl Hash for ScalarExpr

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 Ord for ScalarExpr

fn cmp(&self, other: &ScalarExpr) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ScalarExpr

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

fn partial_cmp(&self, other: &ScalarExpr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for ScalarExpr

impl StructuralPartialEq for ScalarExpr