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.

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<'a, I>(&self, input_arities: I) -> usizewhere
    I: Iterator<Item = &'a 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 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. Might grow the stack to a size proportional to the maximum depth.

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

True when expr contains a LetRec AST node.

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

Trait Implementations

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

Appends global identifiers on which this plan depends to out.

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

Returns the global identifiers on which this plan depends.

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 Hash for OptimizedMirRelationExpr

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 PartialEq<OptimizedMirRelationExpr> for OptimizedMirRelationExpr

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

impl StructuralPartialEq for OptimizedMirRelationExpr