Enum mz_expr::scalar::MirScalarExpr

pub enum MirScalarExpr {
    Column(usize),
    Literal(Result<Row, EvalError>, ColumnType),
    CallUnmaterializable(UnmaterializableFunc),
    CallUnary {
        func: UnaryFunc,
        expr: Box<MirScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<MirScalarExpr>,
        expr2: Box<MirScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<MirScalarExpr>,
    },
    If {
        cond: Box<MirScalarExpr>,
        then: Box<MirScalarExpr>,
        els: Box<MirScalarExpr>,
    },
}

Variants

Column(usize)

A column of the input row

Literal(Result<Row, EvalError>, ColumnType)

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

CallUnmaterializable(UnmaterializableFunc)

A call to an unmaterializable function.

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

CallUnary

A function call that takes one expression as an argument.

Fields

func: UnaryFunc

expr: Box<MirScalarExpr>

CallBinary

A function call that takes two expressions as arguments.

Fields

func: BinaryFunc

expr1: Box<MirScalarExpr>

expr2: Box<MirScalarExpr>

CallVariadic

A function call that takes an arbitrary number of arguments.

Fields

func: VariadicFunc

exprs: Vec<MirScalarExpr>

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

then: Box<MirScalarExpr>

els: Box<MirScalarExpr>

Implementations

impl MirScalarExpr

pub fn columns(is: &[usize]) -> Vec<MirScalarExpr>

pub fn column(column: usize) -> Self

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

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

pub fn literal_null(typ: ScalarType) -> Self

pub fn literal_false() -> Self

pub fn literal_true() -> Self

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

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

pub fn if_then_else(self, t: Self, f: Self) -> Self

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

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

pub fn not(self) -> Self

pub fn call_is_null(self) -> Self

pub fn and_or_args(&self, func_to_match: VariadicFunc) -> Vec<MirScalarExpr>

Match AND or OR on self and get the args. If no match, then interpret self as if it were wrapped in a 1-arg AND/OR.

pub fn expr_eq_literal(&self, expr: &MirScalarExpr) -> Option<(Row, bool)>

Try to match a literal equality involving the given expression on one side. Return the (non-null) literal and a bool that indicates whether an inversion was needed.

More specifically: If self is an equality with a null literal on any side, then the match fails! Otherwise: for a given expr, if self is <expr> = <literal> or <literal> = <expr> then return Some((<literal>, false)). In addition to just trying to match <expr> as it is, we also try to remove an invertible function call (such as a cast). If the match succeeds with the inversion, then return Some((<inverted-literal>, true)). For more details on the inversion, see invert_casts_on_expr_eq_literal_inner.

fn expr_eq_literal_inner( expr_to_match: &MirScalarExpr, literal: Row, literal_expr: &MirScalarExpr, other_side: &MirScalarExpr, ) -> Option<(Row, bool)>

pub fn any_expr_eq_literal(&self) -> Option<MirScalarExpr>

If self is <expr> = <literal> or <literal> = <expr> then return <expr>. It also tries to remove a cast (or other invertible function call) from <expr> before returning it, see invert_casts_on_expr_eq_literal_inner.

pub fn invert_casts_on_expr_eq_literal(&self) -> MirScalarExpr

If the given MirScalarExpr is a literal equality where one side is an invertible function call, then calls the inverse function on both sides of the equality and returns the modified version of the given MirScalarExpr. Otherwise, it returns the original expression. For more details, see invert_casts_on_expr_eq_literal_inner.

fn invert_casts_on_expr_eq_literal_inner( expr: &MirScalarExpr, literal: &MirScalarExpr, ) -> (MirScalarExpr, MirScalarExpr)

Given an <expr> and a <literal> that were taken out from <expr> = <literal> or <literal> = <expr>, it tries to simplify the equality by applying the inverse function of the outermost function call of <expr> (if exists):

<literal> = func(<inner_expr>), where func is invertible –> <func^-1(literal)> = <inner_expr> if func^-1(literal) doesn’t error out, and both func and func^-1 preserve uniqueness.

The return value is the <inner_expr> and the literal value that we get by applying the inverse function.

pub fn impossible_literal_equality_because_types(&self) -> bool

Tries to remove a cast (or other invertible function) in the same way as invert_casts_on_expr_eq_literal, but if calling the inverse function fails on the literal, then it deems the equality to be impossible. For example if a is a smallint column, then it catches a::integer = 1000000 to be an always false predicate (where the ::integer could have been inserted implicitly).

fn impossible_literal_equality_because_types_inner( literal: &MirScalarExpr, other_side: &MirScalarExpr, ) -> bool

pub fn any_expr_ineq_literal(&self) -> bool

Determines if self is <expr> < <literal> or <expr> > <literal> or <literal> < <expr> or <literal> > <expr> or <expr> <= <literal> or <expr> >= <literal> or <literal> <= <expr> or <literal> >= <expr>.

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

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

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

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

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

pub fn take(&mut self) -> Self

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

pub fn as_literal_owned(&self) -> Option<Result<Row, EvalError>>

pub fn as_literal_str(&self) -> Option<&str>

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

pub fn as_literal_err(&self) -> Option<&EvalError>

pub fn is_literal(&self) -> bool

pub fn is_literal_true(&self) -> bool

pub fn is_literal_false(&self) -> bool

pub fn is_literal_null(&self) -> bool

pub fn is_literal_ok(&self) -> bool

pub fn is_literal_err(&self) -> bool

pub fn is_column(&self) -> bool

pub fn is_error_if_null(&self) -> bool

pub fn contains_error_if_null(&self) -> bool

👎Deprecated: Use might_error instead

pub fn might_error(&self) -> bool

A very crude approximation for scalar expressions that might produce an error.

Currently, this is restricted only to expressions that either contain a literal error or a VariadicFunc::ErrorIfNull call.

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

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

pub fn reduce(&mut self, column_types: &[ColumnType])

Reduces a complex expression where possible.

This function uses nullability information present in column_types, and the result may only continue to be a correct transformation as long as this information continues to hold (nullability may not hold as expressions migrate around).

(If you’d like to not use nullability information here, then you can tweak the nullabilities in column_types before passing it to this function, see e.g. in EquivalenceClasses::minimize.)

Also performs partial canonicalization on the expression.

use mz_expr::MirScalarExpr;
use mz_repr::{ColumnType, Datum, ScalarType};

let expr_0 = MirScalarExpr::Column(0);
let expr_t = MirScalarExpr::literal_true();
let expr_f = MirScalarExpr::literal_false();

let mut test =
expr_t
    .clone()
    .and(expr_f.clone())
    .if_then_else(expr_0, expr_t.clone());

let input_type = vec![ScalarType::Int32.nullable(false)];
test.reduce(&input_type);
assert_eq!(test, expr_t);

fn decompose_is_null(&mut self) -> Option<MirScalarExpr>

Decompose an IsNull expression into a disjunction of simpler expressions.

Assumes that self is the expression inside of an IsNull. Returns Some(expressions) if the outer IsNull is to be replaced by some other expression. Note: if it returns None, it might still have mutated *self.

pub fn flatten_associative(&mut self)

Flattens a chain of calls to associative variadic functions (For example: ORs or ANDs)

fn reduce_and_canonicalize_and_or(&mut self)

Canonicalizes AND/OR, and does some straightforward simplifications

fn demorgans(&mut self)

Transforms !(a && b) into !a || !b, and !(a || b) into !a && !b

fn undistribute_and_or(&mut self)

AND/OR undistribution (factoring out) to apply at each MirScalarExpr.

This method attempts to apply one of the distribution laws (in a direction opposite to the their name):

(a && b) || (a && c) --> a && (b || c)  // Undistribute-OR
(a || b) && (a || c) --> a || (b && c)  // Undistribute-AND

or one of their corresponding two absorption law special cases:

a || (a && c)  -->  a  // Absorb-OR
a && (a || c)  -->  a  // Absorb-AND

The method also works with more than 2 arguments at the top, e.g.

(a && b) || (a && c) || (a && d)  -->  a && (b || c || d)

It can also factor out only a subset of the top arguments, e.g.

(a && b) || (a && c) || (d && e)  -->  (a && (b || c)) || (d && e)

Note that sometimes there are two overlapping possibilities to factor out from, e.g.

(a && b) || (a && c) || (d && c)

Here we can factor out a from from the 1. and 2. terms, or we can factor out c from the 2. and 3. terms. One of these might lead to more/better undistribution opportunities later, but we just pick one locally, because recursively trying out all of them would lead to exponential run time.

The local heuristic is that we prefer a candidate that leads to an absorption, or if there is no such one then we simply pick the first. In case of multiple absorption candidates, it doesn’t matter which one we pick, because applying an absorption cannot adversely effect the possibility of applying other absorptions.

Assumption

Assumes that nested chains of AND/OR applications are flattened (this can be enforced with Self::flatten_associative).

Examples

Absorb-OR:

a || (a && c) || (a && d)
-->
a && (true || c || d)
-->
a && true
-->
a

Here only the first step is performed by this method. The rest is done by Self::reduce_and_canonicalize_and_or called after us in reduce().

pub fn non_null_requirements(&self, columns: &mut BTreeSet<usize>)

Adds any columns that must be non-Null for self to be non-Null.

pub fn typ(&self, column_types: &[ColumnType]) -> ColumnType

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

pub fn contains_temporal(&self) -> bool

True iff the expression contains UnmaterializableFunc::MzNow.

pub fn contains_unmaterializable(&self) -> bool

True iff the expression contains an UnmaterializableFunc.

pub fn contains_unmaterializable_except( &self, exceptions: &[UnmaterializableFunc], ) -> bool

True iff the expression contains an UnmaterializableFunc that is not in the exceptions list.

pub fn contains_column(&self) -> bool

True iff the expression contains a Column.

pub fn contains_dummy(&self) -> bool

True iff the expression contains a Dummy.

pub fn size(&self) -> usize

The size of the expression as a tree.

impl MirScalarExpr

pub fn could_error(&self) -> bool

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

impl MirScalarExpr

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.

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.

impl MirScalarExpr

pub fn format( &self, f: &mut Formatter<'_>, cols: Option<&Vec<String>>, ) -> Result

Trait Implementations

impl Arbitrary for MirScalarExpr

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<MirScalarExpr>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for MirScalarExpr

fn clone(&self) -> MirScalarExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MirScalarExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MirScalarExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MirScalarExpr

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

Formats the value using the given formatter.

impl Hash for MirScalarExpr

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 MzReflect for MirScalarExpr

fn add_to_reflected_type_info(rti: &mut ReflectedTypeInfo)

Adds names and types of the fields of the struct or enum to rti.

impl Ord for MirScalarExpr

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

Restrict a value to a certain interval.

impl PartialEq for MirScalarExpr

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

fn partial_cmp(&self, other: &MirScalarExpr) -> 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 RustType<ProtoMirScalarExpr> for MirScalarExpr

fn into_proto(&self) -> ProtoMirScalarExpr

Convert a Self into a Proto value.

fn from_proto(proto: ProtoMirScalarExpr) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl ScalarOps for MirScalarExpr

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

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

impl Serialize for MirScalarExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl VisitChildren<MirScalarExpr> for MirScalarExpr

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>, E: From<RecursionLimitError>,

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>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl Eq for MirScalarExpr

impl StructuralPartialEq for MirScalarExpr