Enum mz_compute_types::plan::reduce::ReducePlan

pub enum ReducePlan {
    Distinct,
    Accumulable(AccumulablePlan),
    Hierarchical(HierarchicalPlan),
    Basic(BasicPlan),
    Collation(CollationPlan),
}

A ReducePlan provides a concise description for how we will execute a given reduce expression.

The provided reduce expression can have no aggregations, in which case its just a Distinct and otherwise it’s composed of a combination of accumulable, hierarchical and basic aggregations.

We want to try to centralize as much decision making about the shape / general computation of the rendered dataflow graph in this plan, and then make actually rendering the graph be as simple (and compiler verifiable) as possible.

Variants

Distinct

Plan for not computing any aggregations, just determining the set of distinct keys.

Accumulable(AccumulablePlan)

Plan for computing only accumulable aggregations.

Hierarchical(HierarchicalPlan)

Plan for computing only hierarchical aggregations.

Basic(BasicPlan)

Plan for computing only basic aggregations.

Collation(CollationPlan)

Plan for computing a mix of different kinds of aggregations. We need to do extra work here to reassemble results back in the requested order.

Implementations

impl ReducePlan

pub fn create_from( aggregates: Vec<AggregateExpr>, monotonic: bool, expected_group_size: Option<u64>, fused_unnest_list: bool, ) -> Self

Generate a plan for computing the supplied aggregations.

The resulting plan summarizes what the dataflow to be created and how the aggregations will be executed.

fn create_inner( typ: ReductionType, aggregates_list: Vec<(usize, AggregateExpr)>, monotonic: bool, expected_group_size: Option<u64>, fused_unnest_list: bool, ) -> Self

Generate a plan for computing the specified type of aggregations.

This function assumes that all of the supplied aggregates are actually of the correct reduction type, and are a subsequence of the total list of requested aggregations.

pub fn keys(&self, key_arity: usize, arity: usize) -> AvailableCollections

Reports all keys of produced arrangements.

This is likely either an empty vector, for no arrangement, or a singleton vector containing the list of expressions that key a single arrangement.

pub fn extract_mfp_after( &self, mfp: MapFilterProject, key_arity: usize, ) -> (MapFilterProject, MapFilterProject, usize)

Extracts a fusable MFP for the reduction from the given mfp along with a residual non-fusable MFP and potentially revised output arity. The provided mfp must be the one sitting on top of the reduction.

Non-fusable parts include temporal predicates or any other parts that cannot be conservatively asserted to not increase the memory requirements of the output arrangement for the reduction. Either the fusable or non-fusable parts may end up being the identity MFP.

Trait Implementations

impl Arbitrary for ReducePlan

To avoid stack overflow, this limits the arbitrarily-generated test ReducePlans to involve at most 8 aggregations.

To have better coverage of realistic expected group sizes, the expected group size has a logarithmic distribution.

type Parameters = ()

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

type Strategy = BoxedStrategy<ReducePlan>

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

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 Clone for ReducePlan

fn clone(&self) -> ReducePlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ReducePlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReducePlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Ord for ReducePlan

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

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

fn partial_cmp(&self, other: &ReducePlan) -> 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 RustType<ProtoReducePlan> for ReducePlan

fn into_proto(&self) -> ProtoReducePlan

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl Serialize for ReducePlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&ReducePlan> for ReductionType

type Error = ()

The type returned in the event of a conversion error.

fn try_from(plan: &ReducePlan) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for ReducePlan

impl StructuralPartialEq for ReducePlan