Struct mz_expr::OptimizedMirRelationExpr

pub struct OptimizedMirRelationExpr(pub MirRelationExpr);

A MirRelationExpr that claims to have been optimized, e.g., by an transform::Optimizer.

Tuple Fields

0: MirRelationExpr

Implementations

impl OptimizedMirRelationExpr

pub fn declare_optimized(expr: MirRelationExpr) -> OptimizedMirRelationExpr

Declare that the input expr is optimized, without actually running it through an optimizer. This can be useful to mark as optimized literal MirRelationExprs that are obviously optimal, without invoking the whole machinery of the optimizer.

pub fn as_inner(&self) -> &MirRelationExpr

Get mutable access to the inner MirRelationExpr

Callers of this method need to ensure that the underlying expression stays optimized after any mutations are applied

pub fn as_inner_mut(&mut self) -> &mut MirRelationExpr

Get mutable access to the inner MirRelationExpr

Callers of this method need to ensure that the underlying expression stays optimized after any mutations are applied

pub fn into_inner(self) -> MirRelationExpr

Methods from Deref<Target = MirRelationExpr>

pub fn typ(&self) -> RelationType

Reports the schema of the relation.

This method determines the type through recursive traversal of the relation expression, drawing from the types of base collections. As such, this is not an especially cheap method, and should be used judiciously.

The relation type is computed incrementally with a recursive post-order traversal, that accumulates the input types for the relations yet to be visited in type_stack.

pub fn typ_with_input_types(&self, input_types: &[RelationType]) -> RelationType

Reports the schema of the relation given the schema of the input relations.

input_types is required to contain the schemas for the input relations of the current relation in the same order as they are visited by try_visit_children method, even though not all may be used for computing the schema of the current relation. For example, Let expects two input types, one for the value relation and one for the body, in that order, but only the one for the body is used to determine the type of the Let relation.

It is meant to be used during post-order traversals to compute relation schemas incrementally.

pub fn col_with_input_cols<'a, I>(&self, input_types: I) -> Vec<ColumnType>

where I: Iterator<Item = &'a Vec<ColumnType>>,

Reports the column types of the relation given the column types of the input relations.

This method delegates to try_col_with_input_cols, panicing if an Err variant is returned.

pub fn try_col_with_input_cols<'a, I>( &self, input_types: I, ) -> Result<Vec<ColumnType>, String>

where I: Iterator<Item = &'a Vec<ColumnType>>,

Reports the column types of the relation given the column types of the input relations.

input_types is required to contain the column types for the input relations of the current relation in the same order as they are visited by try_visit_children method, even though not all may be used for computing the schema of the current relation. For example, Let expects two input types, one for the value relation and one for the body, in that order, but only the one for the body is used to determine the type of the Let relation.

It is meant to be used during post-order traversals to compute column types incrementally.

pub fn keys_with_input_keys<'a, I, J>( &self, input_arities: I, input_keys: J, ) -> Vec<Vec<usize>>

where I: Iterator<Item = usize>, J: Iterator<Item = &'a Vec<Vec<usize>>>,

Reports the unique keys of the relation given the arities and the unique keys of the input relations.

input_arities and input_keys are required to contain the corresponding info for the input relations of the current relation in the same order as they are visited by try_visit_children method, even though not all may be used for computing the schema of the current relation. For example, Let expects two input types, one for the value relation and one for the body, in that order, but only the one for the body is used to determine the type of the Let relation.

It is meant to be used during post-order traversals to compute unique keys incrementally.

pub fn arity(&self) -> usize

The number of columns in the relation.

This number is determined from the type, which is determined recursively at non-trivial cost.

The arity is computed incrementally with a recursive post-order traversal, that accumulates the arities for the relations yet to be visited in arity_stack.

pub fn arity_with_input_arities<I>(&self, input_arities: I) -> usize

where I: Iterator<Item = usize>,

Reports the arity of the relation given the schema of the input relations.

input_arities is required to contain the arities for the input relations of the current relation in the same order as they are visited by try_visit_children method, even though not all may be used for computing the schema of the current relation. For example, Let expects two input types, one for the value relation and one for the body, in that order, but only the one for the body is used to determine the type of the Let relation.

It is meant to be used during post-order traversals to compute arities incrementally.

pub fn num_inputs(&self) -> usize

The number of child relations this relation has.

pub fn as_const( &self, ) -> Option<(&Result<Vec<(Row, Diff)>, EvalError>, &RelationType)>

If self is a constant, return the value and the type, otherwise None. Looks behind ArrangeBys.

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

If self is a constant error, return the error, otherwise None. Looks behind ArrangeBys.

pub fn is_constant_singleton(&self) -> bool

Checks if self is the single element collection with no columns.

pub fn is_empty(&self) -> bool

Indicates if this is a constant empty collection.

A false value does not mean the collection is known to be non-empty, only that we cannot currently determine that it is statically empty.

pub fn is_negated_project(&self) -> Option<(&MirRelationExpr, &[usize])>

If the expression is a negated project, return the input and the projection.

pub fn pretty(&self) -> String

Pretty-print this MirRelationExpr to a string.

pub fn explain( &self, config: &ExplainConfig, humanizer: Option<&dyn ExprHumanizer>, ) -> String

Pretty-print this MirRelationExpr to a string using a custom ExplainConfig and an optionally provided ExprHumanizer.

pub fn contains_temporal(&self) -> bool

True iff the expression contains a NullaryFunc::MzLogicalTimestamp.

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

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

Fallible visitor for the MirScalarExprs directly owned by this relation expression.

The f visitor should not recursively descend into owned MirRelationExprs.

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

where F: FnMut(&MirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Fallible immutable visitor for the MirScalarExprs in the MirRelationExpr subtree rooted at self.

Note that this does not recurse into MirRelationExpr subtrees within MirScalarExpr nodes.

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

where F: FnMut(&MirScalarExpr),

Infallible immutable visitor for the MirScalarExprs in the MirRelationExpr subtree rooted at self.

Note that this does not recurse into MirRelationExpr subtrees within MirScalarExpr nodes.

pub fn debug_size_and_depth(&self) -> (usize, usize)

Computes the size (total number of nodes) and maximum depth of a MirRelationExpr for debug printing purposes.

pub fn could_run_expensive_function(&self) -> bool

The MirRelationExpr is considered potentially expensive if and only if at least one of the following conditions is true:

• It contains at least one FlatMap or a Reduce operator.
• It contains at least one MirScalarExpr with a function call.

!!!WARNING!!!: this method has an HirRelationExpr counterpart. The two should be kept in sync w.r.t. HIR ⇒ MIR lowering!

pub fn hash_to_u64(&self) -> u64

Hash to an u64 using Rust’s default Hasher. (Which is a somewhat slower, but better Hasher than what Hashable::hashed would give us.)

pub fn is_recursive(self: &MirRelationExpr) -> bool

True when expr contains a LetRec AST node.

pub fn size(&self) -> usize

Return the number of sub-expressions in the tree (including self).

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

Iterates through references to child expressions.

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

Iterative pre-order visitor.

pub fn post_order_vec(&self) -> Vec<&Self>

Return a vector of references to the subtrees of this expression in post-visit order (the last element is &self).

fn fmt_virtual_syntax( &self, f: &mut Formatter<'_>, ctx: &mut PlanRenderingContext<'_, MirRelationExpr>, ) -> Result

fn fmt_raw_syntax( &self, f: &mut Formatter<'_>, ctx: &mut PlanRenderingContext<'_, MirRelationExpr>, ) -> Result

fn fmt_attributes( &self, f: &mut Formatter<'_>, ctx: &PlanRenderingContext<'_, MirRelationExpr>, ) -> Result

fn column_names<'a>( &'a self, ctx: &'a PlanRenderingContext<'_, MirRelationExpr>, ) -> Option<&Vec<String>>

Trait Implementations

impl Arbitrary for OptimizedMirRelationExpr

type Parameters = <MirRelationExpr as Arbitrary>::Parameters

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

type Strategy = Map<<MirRelationExpr as Arbitrary>::Strategy, fn(_: MirRelationExpr) -> OptimizedMirRelationExpr>

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

fn arbitrary_with(_top: 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 OptimizedMirRelationExpr

fn clone(&self) -> OptimizedMirRelationExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CollectionPlan for OptimizedMirRelationExpr

fn depends_on_into(&self, out: &mut BTreeSet<GlobalId>)

Collects the set of global identifiers from dataflows referenced in Get.

fn depends_on(&self) -> BTreeSet<GlobalId>

Returns the set of global identifiers from dataflows referenced in Get.

impl Debug for OptimizedMirRelationExpr

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

Formats the value using the given formatter.

impl Deref for OptimizedMirRelationExpr

type Target = MirRelationExpr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for OptimizedMirRelationExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OptimizedMirRelationExpr

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

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 OptimizedMirRelationExpr

impl StructuralPartialEq for OptimizedMirRelationExpr