Enum mz_compute_client::plan::reduce::BasicPlan

pub enum BasicPlan {
    Single(usize, AggregateExpr),
    Multiple(Vec<(usize, AggregateExpr)>),
}

Plan for computing a set of basic aggregations.

There’s much less complexity when rendering basic aggregations. Each aggregation corresponds to one Differential reduce operator. That’s it. However, we still want to present one final arrangement so basic aggregations present results with the same interface (one arrangement containing a row with all results) that accumulable and hierarchical aggregations do. To provide that, we render an additional reduce operator whenever we have multiple reduce aggregates to combine and present results in the appropriate order. If we were only asked to compute a single aggregation, we can skip that step and return the arrangement provided by computing the aggregation directly.

Variants

Single(usize, AggregateExpr)

Plan for rendering a single basic aggregation. Here, the first element denotes the index in the set of inputs that we are aggregating over.

Multiple(Vec<(usize, AggregateExpr)>)

Plan for rendering multiple basic aggregations. These need to then be collated together in an additional reduction. Each element represents the: (index of the set of the input we are aggregating over, the aggregation function)

Trait Implementations

impl Clone for BasicPlan

fn clone(&self) -> BasicPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BasicPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BasicPlan

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<Timestamp>>> for BasicPlan

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

impl PartialEq<BasicPlan> for BasicPlan

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

fn into_proto(&self) -> ProtoBasicPlan

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl Serialize for BasicPlan

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 BasicPlan

impl StructuralEq for BasicPlan

impl StructuralPartialEq for BasicPlan