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

Fields

func: UnaryFunc

expr: Box<MirScalarExpr>

A function call that takes one expression as an argument.

CallBinary

Fields

func: BinaryFunc

expr1: Box<MirScalarExpr>

expr2: Box<MirScalarExpr>

A function call that takes two expressions as arguments.

CallVariadic

Fields

func: VariadicFunc

exprs: Vec<MirScalarExpr>

A function call that takes an arbitrary number of arguments.

If

Fields

cond: Box<MirScalarExpr>

then: Box<MirScalarExpr>

els: Box<MirScalarExpr>

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.

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

For a given expr, if self is <expr> = <literal> or <literal> = <expr> then return (<literal>, false). In addition to just trying to match <expr> as it is, it also tries to remove an invertible function call (such as a cast). If the match match succeeds with the inversion, then it returns (<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):

= func(<inner_expr>), where f is invertible –> <func^-1(literal)> = <inner_expr> (if func^-1(literal) doesn’t error out)

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: &HashMap<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 support(&self) -> HashSet<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_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 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.

Also canonicalizes the expression.

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

let expr_0 = MirScalarExpr::Column(0);
let expr_t = MirScalarExpr::literal_ok(Datum::True, ScalarType::Bool);
let expr_f = MirScalarExpr::literal_ok(Datum::False, ScalarType::Bool);

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 HashSet<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 size(&self) -> Result<usize, RecursionLimitError>

impl MirScalarExpr

pub fn could_error(&self) -> bool

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

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<(), Error>

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,

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<MirScalarExpr> for MirScalarExpr

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

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

impl StructuralPartialEq for MirScalarExpr