Enum mz_compute_types::plan::reduce::BasicPlan

pub enum BasicPlan {
    Single(SingleBasicPlan),
    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(SingleBasicPlan)

Plan for rendering a single basic aggregation.

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

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

impl Ord for BasicPlan

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

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

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

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