Enum HirScalarExpr

pub enum HirScalarExpr {
    Column(ColumnRef),
    Parameter(usize),
    Literal(Row, ColumnType),
    CallUnmaterializable(UnmaterializableFunc),
    CallUnary {
        func: UnaryFunc,
        expr: Box<HirScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<HirScalarExpr>,
        expr2: Box<HirScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<HirScalarExpr>,
    },
    If {
        cond: Box<HirScalarExpr>,
        then: Box<HirScalarExpr>,
        els: Box<HirScalarExpr>,
    },
    Exists(Box<HirRelationExpr>),
    Select(Box<HirRelationExpr>),
    Windowing(WindowExpr),
}

Just like mz_expr::MirScalarExpr, except where otherwise noted below.

Variants

Column(ColumnRef)

Unlike mz_expr::MirScalarExpr, we can nest HirRelationExprs via eg Exists. This means that a variable could refer to a column of the current input, or to a column of an outer relation. We use ColumnRef to denote the difference.

Parameter(usize)

Literal(Row, ColumnType)

CallUnmaterializable(UnmaterializableFunc)

CallUnary

Fields

func: UnaryFunc

expr: Box<HirScalarExpr>

CallBinary

Fields

func: BinaryFunc

expr1: Box<HirScalarExpr>

expr2: Box<HirScalarExpr>

CallVariadic

Fields

func: VariadicFunc

exprs: Vec<HirScalarExpr>

If

Fields

cond: Box<HirScalarExpr>

then: Box<HirScalarExpr>

els: Box<HirScalarExpr>

Exists(Box<HirRelationExpr>)

Returns true if expr returns any rows

Select(Box<HirRelationExpr>)

Given expr with arity 1. If expr returns:

• 0 rows, return NULL
• 1 row, return the value of that row

• 1 rows, the sql spec says we should throw an error but we can’t (see https://github.com/MaterializeInc/database-issues/issues/154) so instead we return all the rows. If there are multiple Select expressions in a single SQL query, the result is that we take the product of all of them. This is counter to the spec, but is consistent with eg postgres’ treatment of multiple set-returning-functions (see https://tapoueh.org/blog/2017/10/set-returning-functions-and-postgresql-10/).

Windowing(WindowExpr)

Implementations

impl HirScalarExpr

pub fn bind_parameters(&mut self, params: &Params) -> Result<(), PlanError>

Replaces any parameter references in the expression with the corresponding datum in params.

pub fn splice_parameters(&mut self, params: &[HirScalarExpr], depth: usize)

Like HirScalarExpr::bind_parameters, except that parameters are replaced with the corresponding expression fragment from params rather than a datum.

Specifically, the parameter $1 will be replaced with params[0], the parameter $2 will be replaced with params[1], and so on. Parameters in self that refer to invalid indices of params will cause a panic.

Column references in parameters will be corrected to account for the depth at which they are spliced.

pub fn contains_temporal(&self) -> bool

Whether the expression contains an UnmaterializableFunc::MzNow call.

pub fn column(index: usize) -> HirScalarExpr

Constructs a column reference in the current scope.

pub fn literal(datum: Datum<'_>, scalar_type: ScalarType) -> HirScalarExpr

pub fn literal_true() -> HirScalarExpr

pub fn literal_false() -> HirScalarExpr

pub fn literal_null(scalar_type: ScalarType) -> HirScalarExpr

pub fn literal_1d_array( datums: Vec<Datum<'_>>, element_scalar_type: ScalarType, ) -> Result<HirScalarExpr, PlanError>

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

pub fn is_literal_true(&self) -> bool

pub fn is_literal_false(&self) -> bool

pub fn is_literal_null(&self) -> bool

pub fn is_constant(&self) -> bool

Return true iff self consists only of constants, function calls, and if-else statements.

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

pub fn call_binary(self, other: Self, func: BinaryFunc) -> 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 variadic_and(args: Vec<HirScalarExpr>) -> HirScalarExpr

Calls AND with the given arguments. Simplifies if 0 or 1 args.

pub fn variadic_or(args: Vec<HirScalarExpr>) -> HirScalarExpr

Calls OR with the given arguments. Simplifies if 0 or 1 args.

pub fn take(&mut self) -> Self

pub fn visit<'a, F>(&'a self, f: &mut F)

where F: FnMut(&'a Self),

pub fn visit1<'a, F>(&'a self, f: F)

where F: FnMut(&'a Self),

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

where F: FnMut(&mut Self),

👎Deprecated: Use Visit::visit_post instead.

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

where F: FnMut(&mut Self),

👎Deprecated: Use Visit::visit_mut_pre instead.

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

where F: FnMut(&mut Self),

👎Deprecated: Use VisitChildren<HirScalarExpr>::visit_children instead.

pub fn visit_pre_post<F1, F2>(&self, pre: &mut F1, post: &mut F2)

where F1: FnMut(&Self) -> Option<Vec<&Self>>, F2: FnMut(&Self),

👎Deprecated: Use Visit::visit_pre_post instead.

A generalization of visit. The function pre runs on a HirScalarExpr before it runs on any of the child HirScalarExprs. The function post runs on child HirScalarExprs first before the parent. Optionally, pre can return which child HirScalarExprs, if any, should be visited (default is to visit all children).

pub fn visit_columns<F>(&self, depth: usize, f: &mut F)

where F: FnMut(usize, &ColumnRef),

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Visits the column references in this scalar expression.

The depth argument should indicate the subquery nesting depth of the expression, which will be incremented with each subquery entered and presented to the supplied function f.

pub fn visit_columns_mut<F>(&mut self, depth: usize, f: &mut F)

where F: FnMut(usize, &mut ColumnRef),

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Like visit_columns, but permits mutating the column references.

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

where F: FnMut(usize),

Visits those column references in this scalar expression that refer to the root level. These include column references that are at the root level, as well as column references that are at a deeper subquery nesting depth, but refer back to the root level. (Note that even if self is embedded inside a larger expression, we consider the “root level” to be self’s level.)

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

where F: FnMut(&mut usize),

Like visit_columns_referring_to_root_level, but permits mutating the column references.

pub fn visit_recursively<F, E>(&self, depth: usize, f: &mut F) -> Result<(), E>

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

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Like visit but it enters the subqueries visiting the scalar expressions contained in them. It takes the current depth of the expression and increases it when entering a subquery.

pub fn visit_recursively_mut<F, E>( &mut self, depth: usize, f: &mut F, ) -> Result<(), E>

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

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Like visit_recursively, but permits mutating the scalar expressions.

fn simplify_to_literal(self) -> Option<Row>

pub fn into_literal_int64(self) -> Option<i64>

Attempts to simplify this expression to a literal 64-bit integer.

Returns None if this expression cannot be simplified, e.g. because it contains non-literal values.

Panics

Panics if this expression does not have type ScalarType::Int64.

pub fn into_literal_string(self) -> Option<String>

Attempts to simplify this expression to a literal string.

Returns None if this expression cannot be simplified, e.g. because it contains non-literal values.

Panics

Panics if this expression does not have type ScalarType::String.

pub fn into_literal_mz_timestamp(self) -> Option<Timestamp>

Attempts to simplify this expression to a literal MzTimestamp.

Returns None if this expression cannot be simplified, e.g. because it contains non-literal values.

TODO: Make this (and the other similar fns above) return Result, so that we can show the error when it fails. (E.g., there can be non-trivial cast errors.)

Panics

Panics if this expression does not have type ScalarType::MzTimestamp.

impl HirScalarExpr

fn applied_to( self, id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: &mut MirRelationExpr, subquery_map: &Option<&BTreeMap<HirScalarExpr, usize>>, context: &Context<'_>, ) -> Result<MirScalarExpr, PlanError>

Rewrite self into a mz_expr::ScalarExpr which can be applied to the modified inner.

This method is responsible for decorrelating subqueries in self by introducing further columns to inner, and rewriting self to refer to its physical columns (specified by usize positions). The most complicated logic is for the scalar expressions that involve subqueries, each of which are documented in more detail closer to their logic.

This process presumes that inner is the result of decorrelation, meaning its first several columns may be inherited from outer relations. The col_map column map should provide specific offsets where each of these references can be found.

fn window_func_applied_to<F>( id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: &mut MirRelationExpr, subquery_map: &Option<&BTreeMap<HirScalarExpr, usize>>, partition_by: Vec<HirScalarExpr>, order_by: Vec<HirScalarExpr>, mir_aggr_func: AggregateFunc, lower_args: F, context: &Context<'_>, ) -> Result<MirScalarExpr, PlanError>

where F: FnOnce(&mut IdGen, &ColumnMap, &mut BTreeMap<LocalId, CteDesc>, &mut MirRelationExpr, &Option<&BTreeMap<HirScalarExpr, usize>>, Vec<MirScalarExpr>, MirScalarExpr, ScalarType) -> Result<(MirScalarExpr, ColumnType), PlanError>,

fn lower_subqueries( exprs: &[Self], id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: MirRelationExpr, context: &Context<'_>, ) -> Result<(MirRelationExpr, BTreeMap<HirScalarExpr, usize>), PlanError>

Applies the subqueries in the given list of scalar expressions to every distinct value of the given relation and returns a join of the given relation with all the subqueries found, and the mapping of scalar expressions with columns projected by the returned join that will hold their results.

pub fn lower_uncorrelated(self) -> Result<MirScalarExpr, PlanError>

Rewrites self into a mz_expr::ScalarExpr.

impl HirScalarExpr

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

Similar to MirScalarExpr::support, but adapted to HirScalarExpr in a special way: it considers column references that target the root level. (See visit_columns_referring_to_root_level.)

fn remap(self, idx_map: &BTreeMap<usize, usize>) -> HirScalarExpr

Changes column references in self by the given remapping. Panics if a referred column is not present in idx_map!

Trait Implementations

impl AbstractExpr for HirScalarExpr

type Type = ColumnType

fn typ( &self, outers: &[RelationType], inner: &RelationType, params: &BTreeMap<usize, ScalarType>, ) -> Self::Type

Computes the type of the expression.

impl Clone for HirScalarExpr

fn clone(&self) -> HirScalarExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HirScalarExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HirScalarExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for HirScalarExpr

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

Formats the value using the given formatter.

impl From<HirScalarExpr> for CoercibleScalarExpr

fn from(expr: HirScalarExpr) -> CoercibleScalarExpr

Converts to this type from the input type.

impl Hash for HirScalarExpr

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 HirScalarExpr

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

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

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

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

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

impl Serialize for HirScalarExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl VisitChildren<HirScalarExpr> for AggregateWindowExpr

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

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

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

where F: FnMut(&HirScalarExpr) -> 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 HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for HirRelationExpr

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

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

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

where F: FnMut(&HirScalarExpr) -> 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 HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for HirScalarExpr

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 VisitChildren<HirScalarExpr> for ValueWindowExpr

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

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

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

where F: FnMut(&HirScalarExpr) -> 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 HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for WindowExpr

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

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

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

where F: FnMut(&HirScalarExpr) -> 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 HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for WindowExprType

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

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

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

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

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

where F: FnMut(&HirScalarExpr) -> 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 HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl Eq for HirScalarExpr

impl StructuralPartialEq for HirScalarExpr