Struct mz_compute_types::plan::Plan

pub struct Plan<T = Timestamp> {
    pub lir_id: LirId,
    pub node: PlanNode<T>,
}

A rendering plan with as much conditional logic as possible removed.

Fields

lir_id: LirId

A dataflow-local identifier.

node: PlanNode<T>

The underlying operator.

Implementations

impl Plan

pub fn pretty(&self) -> String

Pretty-print this Plan to a string.

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

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

impl<T: Timestamp> Plan<T>

pub fn finalize_dataflow( desc: DataflowDescription<OptimizedMirRelationExpr>, features: &OptimizerFeatures, ) -> Result<DataflowDescription<Self>, String>

Convert the dataflow description into one that uses render plans.

fn lower_dataflow( desc: DataflowDescription<OptimizedMirRelationExpr>, features: &OptimizerFeatures, ) -> Result<DataflowDescription<Self>, String>

Lowers the dataflow description from MIR to LIR. To this end, the method collects all available arrangements and based on this information creates plans for every object to be built for the dataflow.

fn refine_source_mfps(dataflow: &mut DataflowDescription<Self>)

Refines the source instance descriptions for sources imported by dataflow to push down common MFP expressions.

fn refine_union_negate_consolidation(dataflow: &mut DataflowDescription<Self>)

Changes the consolidate_output flag of such Unions that have at least one Negated input.

fn refine_single_time_operator_selection( dataflow: &mut DataflowDescription<Self>, )

Refines the plans of objects to be built as part of dataflow to take advantage of monotonic operators if the dataflow refers to a single-time, i.e., is for a one-shot SELECT query.

fn refine_single_time_consolidation( dataflow: &mut DataflowDescription<Self>, config: &TransformConfig, ) -> Result<(), String>

Refines the plans of objects to be built as part of a single-time dataflow to relax the setting of the must_consolidate attribute of monotonic operators, if necessary, whenever the input is deemed to be physically monotonic.

Trait Implementations

impl Arbitrary for Plan

type Strategy = BoxedStrategy<Plan>

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

type Parameters = ()

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

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<T: Clone> Clone for Plan<T>

fn clone(&self) -> Plan<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> CollectionPlan for Plan<T>

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<T: Debug> Debug for Plan<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Plan<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DisplayText<PlanRenderingContext<'_, Plan>> for Plan

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

impl<T: Ord> Ord for Plan<T>

fn cmp(&self, other: &Plan<T>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Plan<T>

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

fn partial_cmp(&self, other: &Plan<T>) -> 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<T> Serialize for Plan<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TryFrom<Plan<T>> for LetFreePlan<T>

type Error = ()

The only error is “invalid input plan”.

fn try_from(plan: Plan<T>) -> Result<Self, Self::Error>

Convert the given Plan into a LetFreePlan.

Returns an error if the given Plan contains Let or LetRec nodes.

impl<T> TryFrom<Plan<T>> for RenderPlan<T>

type Error = ()

The only error is “invalid input plan”.

fn try_from(plan: Plan<T>) -> Result<Self, Self::Error>

Convert the given Plan into a RenderPlan.

The ids in Nodes are the same as the original LirIds.

Preconditions

A RenderPlan requires certain structure of the Plan it is converted from.

Informally, each valid plan is a sequence of Let and LetRec bindings atop a let-free expression. Each Let binding is to a let-free expression, and each LetRec binding is to a similarly valid plan.

  valid_plan := <let_free>
             |  LET v = <let_free> IN <valid_plan>
             |  LETREC (v = <valid_plan>)* IN <valid_plan>

Input Plans that do not satisfy this requirement will result in errors.

impl<T: Eq> Eq for Plan<T>

impl<T> StructuralPartialEq for Plan<T>