Enum LirScalarExpr 

pub enum LirScalarExpr {
    Column(usize, TreatAsEqual<Option<Arc<str>>>),
    Literal(Result<Row, EvalError>, ReprColumnType),
    CallUnary {
        func: UnaryFunc,
        expr: Box<LirScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<LirScalarExpr>,
        expr2: Box<LirScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<LirScalarExpr>,
    },
    If {
        cond: Box<LirScalarExpr>,
        then: Box<LirScalarExpr>,
        els: Box<LirScalarExpr>,
    },
}

Scalar expressions, as appear in MFPs. This is the stable, low-level, LIR definition of scalr expressions.

Variants

Column(usize, TreatAsEqual<Option<Arc<str>>>)

A column of the input row

Literal(Result<Row, EvalError>, ReprColumnType)

A literal value. (Stored as a row, because we can’t own a Datum)

CallUnary

A function call that takes one expression as an argument.

Fields

func: UnaryFunc

Function

expr: Box<LirScalarExpr>

Argument

CallBinary

A function call that takes two expressions as arguments.

Fields

func: BinaryFunc

Function

expr1: Box<LirScalarExpr>

First argument

expr2: Box<LirScalarExpr>

Second argument

CallVariadic

A function call that takes an arbitrary number of arguments.

Fields

func: VariadicFunc

Function

exprs: Vec<LirScalarExpr>

Arguments

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

Condition

then: Box<LirScalarExpr>

Then branch

els: Box<LirScalarExpr>

Else branch

Implementations

impl LirScalarExpr

pub fn column(c: usize) -> Self

Generates an LSE representing the given column reference.

pub fn literal(res: Result<Datum<'_>, EvalError>, typ: ReprScalarType) -> Self

Packs a Datum or EvalError into a literal row of the given type.

pub fn literal_ok(datum: Datum<'_>, typ: ReprScalarType) -> Self

Generates a literal of the given type.

pub fn as_literal(&self) -> Option<Result<Datum<'_>, &EvalError>>

If the expression is a literal, this returns the literal’s Datum or the literal’s EvalError. Otherwise, it returns None.

pub fn is_literal_true(&self) -> bool

Returns true if the expression is a literal true.

pub fn as_literal_int64(&self) -> Option<i64>

If the expression is an int64, returns the literal.

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

Calls a unary function, with self as the argument.

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

Calls a binary function, with self as the first argument other as the second.

pub fn visit_pre<F>(&self, f: F)

where F: FnMut(&Self),

Visits all subexpressions in DFS preorder.

pub fn visit_pre_mut<F: FnMut(&mut Self)>(&mut self, f: F)

Iterative pre-order visitor.

pub fn children(&self) -> impl DoubleEndedIterator<Item = &Self>

Iterates through references to child expressions.

pub fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Self>

Iterates through mutable references to child expressions.

Trait Implementations

impl Clone for LirScalarExpr

fn clone(&self) -> LirScalarExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Columns for LirScalarExpr

fn visit_columns<F>(&mut self, action: F)

where F: FnMut(&mut usize),

Visits each column reference and applies action to the column.

Useful for remapping columns, or for collecting expression support.

fn column(c: usize) -> Self

Construct a column reference expression.

fn is_column(&self) -> bool

True when the outermost structure is a column.

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

If self is a column, return the column index, otherwise None.

fn as_column_mut(&mut self) -> Option<&mut usize>

If self is a column, return a mutable reference to the column index.

fn support_into(&self, support: &mut BTreeSet<usize>)

Adds the support of the given set, i.e., the columns that are actually used, to the given set.

fn support(&self) -> BTreeSet<usize>

The support of the given set, i.e., the columns that are actually used.

fn permute(&mut self, permutation: &[usize])

Rewrites column indices with their value in permutation.

fn permute_map(&mut self, permutation: &BTreeMap<usize, usize>)

Rewrites column indices with their value in permutation.

impl Debug for LirScalarExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LirScalarExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LirScalarExpr

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

Formats the value using the given formatter.

impl Eval for LirScalarExpr

fn could_error(&self) -> bool

True iff evaluation could possibly error on non-error input Datum.

fn eval<'a>( &'a self, datums: &[Datum<'a>], temp_storage: &'a RowArena, ) -> Result<Datum<'a>, EvalError>

Evaluates, where datums are column references and temp_storage is used for allocation.

impl From<&LirScalarExpr> for MirScalarExpr

fn from(value: &LirScalarExpr) -> Self

Converts to this type from the input type.

impl Hash for LirScalarExpr

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 HumanizeDisplay for LirScalarExpr

fn humanize<'a, M: HumanizerMode>( e: &HumanizedExpr<'a, Self, M>, f: &mut Formatter<'_>, ) -> Result

impl OptimizableExpr for LirScalarExpr

fn is_literal(&self) -> bool

True if this expression is a literal.

fn is_literal_err(&self) -> bool

True if this expression is a literal error.

fn contains_temporal(&self) -> bool

True if this expression contains a temporal reference (mz_now()).

fn size(&self) -> usize

Count of AST nodes in the expression tree.

fn eager_children(&mut self) -> Option<Vec<&mut Self>>

For memoization: which children should be eagerly memoized?

fn equality_column_alias( predicate: &Self, expr: &Self, threshold: usize, ) -> Option<Self>

If predicate is col = expr (or expr = col) where col is a column with index < threshold, return a clone of that column expression.

fn extract_temporal_bounds( temporal: Vec<Self>, ) -> Result<(Vec<Self>, Vec<Self>), String>

Extract temporal bounds from a list of temporal predicates.

impl Ord for LirScalarExpr

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

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

fn partial_cmp(&self, other: &LirScalarExpr) -> 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 ScalarOps for LirScalarExpr

fn match_col_ref(&self) -> Option<usize>

If this expression is a column-reference, return the column referenced.

fn references(&self, column: usize) -> bool

Returns true if this expression is a reference to the given column.

impl Serialize for LirScalarExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&MirScalarExpr> for LirScalarExpr

type Error = Vec<UnmaterializableFunc>

The type returned in the event of a conversion error.

fn try_from(value: &MirScalarExpr) -> Result<Self, Self::Error>

Performs the conversion.

impl VisitChildren<LirScalarExpr> for LirScalarExpr

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

where F: FnMut(&Self),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut Self),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

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

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

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

Apply a fallible mutable function f to each direct child.

fn children<'a>(&'a self) -> impl DoubleEndedIterator<Item = &'a LirScalarExpr>

where LirScalarExpr: 'a,

The T-typed children of this element.

fn children_mut<'a>( &'a mut self, ) -> impl DoubleEndedIterator<Item = &'a mut LirScalarExpr>

where LirScalarExpr: 'a,

The &mut T-typed children of this element.

impl Eq for LirScalarExpr

impl StructuralPartialEq for LirScalarExpr