Enum mz_compute_client::plan::reduce::ReducePlan

pub enum ReducePlan {
    Distinct,
    DistinctNegated,
    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.

DistinctNegated

Plan for not computing any aggregations, just determining the set of distinct keys. A specialization of ReducePlan::Distinct maintaining rows not in the output.

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

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

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

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

impl StructuralEq for ReducePlan

impl StructuralPartialEq for ReducePlan