Enum expr::MirScalarExpr

pub enum MirScalarExpr {
    Column(usize),
    Literal(Result<Row, EvalError>, ColumnType),
    CallNullary(NullaryFunc),
    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)

Tuple Fields

0: usize

A column of the input row

Literal(Result<Row, EvalError>, ColumnType)

Tuple Fields

0: Result<Row, EvalError>

1: ColumnType

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

CallNullary(NullaryFunc)

Tuple Fields

0: NullaryFunc

A function call that takes no arguments.

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 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 visit_children<'a, F>(&'a self, f: F) where
    F: FnMut(&'a Self), 

Applies an infallible immutable f to each child of type MirScalarExpr.

Deletages to MirScalarExprVisitor::visit_children.

pub fn visit_mut_children<'a, F>(&'a mut self, f: F) where
    F: FnMut(&'a mut Self), 

Applies an infallible mutable f to each child of type MirScalarExpr.

Deletages to MirScalarExprVisitor::visit_mut_children.

pub fn visit_post<'a, F>(&'a self, f: &mut F) where
    F: FnMut(&'a Self), 

Post-order immutable infallible MirScalarExpr visitor.

Deletages to MirScalarExprVisitor::visit_post.

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

Post-order mutable infallible MirScalarExpr visitor.

Deletages to MirScalarExprVisitor::visit_mut_post.

pub fn visit_mut_pre_post<F1, F2>(&mut self, pre: &mut F1, post: &mut F2) where
    F1: FnMut(&mut Self) -> Option<Vec<&mut MirScalarExpr>>,
    F2: FnMut(&mut Self), 

A generalization of visit_mut.

Deletages to MirScalarExprVisitor::visit_mut_pre_post.

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_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, relation_type: &RelationType)

Reduces a complex expression where possible.

Also canonicalizes the expression.

use expr::{BinaryFunc, MirScalarExpr};
use repr::{ColumnType, Datum, RelationType, 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()
    .call_binary(expr_f.clone(), BinaryFunc::And)
    .if_then_else(expr_0, expr_t.clone());

let input_type = RelationType::new(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.

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 to apply at each ScalarExpr. Transforms (a && b) || (a && c) into a && (b || c) Transforms (a || b) && (a || c) into a || (b && c)

fn harvest_operands(&mut self, operands: &mut Vec<MirScalarExpr>, and: bool)

Collects undistributable terms from X expressions. If and, X is AND. If not and, X is OR.

fn suppress_operands(&mut self, operands: &[MirScalarExpr], and: bool)

Removes undistributed terms from AND expressions. If and, X is AND. If not and, X is OR.

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, relation_type: &RelationType) -> 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 NullaryFunc::MzLogicalTimestamp.

Trait Implementations

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) -> 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: &MirScalarExpr) -> bool

This method tests for !=.

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

impl StructuralEq for MirScalarExpr

impl StructuralPartialEq for MirScalarExpr