Struct mz_compute_types::plan::flat_plan::FlatPlan

pub struct FlatPlan<T = Timestamp> { /* private fields */ }

A flat representation of LIR plans.

In contrast to Plan, which recursively contains its subplans, this type encodes references between nodes with their unique LirId. Doing so has some benefits:

• Operations that visit all nodes in a FlatPlan have natural iterative implementations, avoiding the risk of stack overflows.
• Because nodes can be referenced multiple times, a FlatPlan can represent DAGs, not just trees. This better matches the structure of rendered dataflows and avoids the need for a Let construct.

Note that the LetRec operator is still present in FlatPlans. While we could replace it with cyclic references between nodes, keeping it simplifies rendering as the sources of recursion are clearly marked.

A FlatPlan can be constructed from a Plan using the corresponding From impl.

Invariants

A FlatPlan maintains the following internal invariants:

Validity of node references:

(1) The root ID is contained in the nodes map. (2) For each node in the nodes map, each LirId contained within the node is contained in the nodes map. (3) Each LirId contained withing topological_order is contained in the nodes map.

Constrained recursive structure:

(4) LetRec nodes only occur at the root or as inputs of other LetRec nodes. (5) Only LetRec nodes may introduce cycles into the plan. (6) Each input to a LetRec node is the root of an independent subplan.

Topological order:

(7) topological_order lists the nodes in a valid topological order.

The implementation of FlatPlan must ensure that all its methods uphold these invariants and that users are not able to break them.

Implementations

impl<T> FlatPlan<T>

pub fn root_id(&self) -> LirId

Return the ID of the root node.

pub fn is_recursive(&self) -> bool

Return whether the plan contains recursion.

pub fn split_recursive( self ) -> (Vec<(LocalId, FlatPlan<T>, Option<LetRecLimit>)>, FlatPlan<T>)

Split a recursive plan into its constituent (values, body) subplans.

Panics

Panics if this plan does not have a LetRec at the root.

pub fn destruct(self) -> (BTreeMap<LirId, FlatPlanNode<T>>, LirId, Vec<LirId>)

Destruct the plan and return its raw parts.

This allows consuming the plan without being required to uphold the FlatPlan invariants.

pub fn replace_ids<F>(&mut self, func: F)

where F: FnMut(GlobalId) -> GlobalId,

Replace references to global IDs by the result of func.

impl<T: Clone> FlatPlan<T>

pub fn partition_among(self, parts: usize) -> Vec<Self>

Partitions the plan into parts many disjoint pieces.

This is used to partition Plan::Constant stages so that the work can be distributed across many workers.

Trait Implementations

impl Arbitrary for FlatPlan

type Strategy = BoxedStrategy<FlatPlan>

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 FlatPlan<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> CollectionPlan for FlatPlan<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 FlatPlan<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for FlatPlan<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<T> From<Plan<T>> for FlatPlan<T>

fn from(plan: Plan<T>) -> Self

Flatten the given Plan into a FlatPlan.

impl<T: PartialEq> PartialEq for FlatPlan<T>

fn eq(&self, other: &FlatPlan<T>) -> 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 RustType<ProtoFlatPlan> for FlatPlan

fn into_proto(&self) -> ProtoFlatPlan

Convert a Self into a Proto value.

fn from_proto(proto: ProtoFlatPlan) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

impl<T> Serialize for FlatPlan<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> StructuralPartialEq for FlatPlan<T>