Struct Agg

pub struct Agg<PlanRef> {
    pub agg_calls: Vec<PlanAggCall>,
    pub group_key: IndexSet,
    pub grouping_sets: Vec<IndexSet>,
    pub input: PlanRef,
    pub enable_two_phase: bool,
}

Agg groups input data by their group key and computes aggregation functions.

It corresponds to the GROUP BY operator in a SQL query statement together with the aggregate functions in the SELECT clause.

The output schema will first include the group key and then the aggregation calls.

Fields

agg_calls: Vec<PlanAggCall>

group_key: IndexSet

grouping_sets: Vec<IndexSet>

input: PlanRef

enable_two_phase: bool

Implementations

impl<PlanRef: GenericPlanRef> Agg<PlanRef>

pub(crate) fn rewrite_exprs(&mut self, r: &mut dyn ExprRewriter)

pub(crate) fn visit_exprs(&self, v: &mut dyn ExprVisitor)

pub(crate) fn output_len(&self) -> usize

pub fn o2i_col_mapping(&self) -> ColIndexMapping

get the Mapping of columnIndex from input column index to output column index,if a input column corresponds more than one out columns, mapping to any one

pub fn i2o_col_mapping(&self) -> ColIndexMapping

get the Mapping of columnIndex from input column index to out column index

fn two_phase_agg_forced(&self) -> bool

pub fn two_phase_agg_enabled(&self) -> bool

pub(crate) fn can_two_phase_agg(&self) -> bool

pub(crate) fn must_try_two_phase_agg(&self) -> bool

Must try two phase agg iff we are forced to, and we satisfy the constraints.

pub(crate) fn hash_agg_dist_satisfied_by_input_dist( &self, input_dist: &Distribution, ) -> bool

Generally used by two phase hash agg. If input dist already satisfies hash agg distribution, it will be more expensive to do two phase agg, should just do shuffle agg.

pub(crate) fn all_local_aggs_are_stateless( &self, stream_input_append_only: bool, ) -> bool

See if all stream aggregation calls have a stateless local agg counterpart.

pub(crate) fn watermark_group_key( &self, input_watermark_columns: &FixedBitSet, ) -> Vec<usize>

pub fn new( agg_calls: Vec<PlanAggCall>, group_key: IndexSet, input: PlanRef, ) -> Self

pub fn with_grouping_sets(self, grouping_sets: Vec<IndexSet>) -> Self

pub fn with_enable_two_phase(self, enable_two_phase: bool) -> Self

impl<PlanRef: BatchPlanRef> Agg<PlanRef>

pub(crate) fn input_provides_order_on_group_keys(&self) -> bool

impl<PlanRef: StreamPlanRef> Agg<PlanRef>

pub fn infer_tables( &self, me: impl StreamPlanRef, vnode_col_idx: Option<usize>, window_col_idx: Option<usize>, ) -> (TableCatalog, Vec<AggCallState>, HashMap<usize, TableCatalog>)

fn get_ordered_group_key(&self, window_col_idx: Option<usize>) -> Vec<usize>

fn create_table_builder( &self, _ctx: OptimizerContextRef, window_col_idx: Option<usize>, ) -> (TableCatalogBuilder, Vec<usize>, BTreeMap<usize, usize>)

Create a new table builder with group key columns added.

Returns

• table builder with group key columns added
• included upstream indices
• column mapping from upstream to table

pub fn infer_stream_agg_state( &self, me: impl StreamPlanRef, vnode_col_idx: Option<usize>, window_col_idx: Option<usize>, ) -> Vec<AggCallState>

Infer AggCallStates for streaming agg.

pub fn infer_intermediate_state_table( &self, me: impl GenericPlanRef, vnode_col_idx: Option<usize>, window_col_idx: Option<usize>, ) -> TableCatalog

table schema: group key | state for AGG1 | state for AGG2 | …

pub fn infer_distinct_dedup_tables( &self, me: impl GenericPlanRef, vnode_col_idx: Option<usize>, window_col_idx: Option<usize>, ) -> HashMap<usize, TableCatalog>

Infer dedup tables for distinct agg calls, partitioned by distinct columns. Since distinct agg calls only dedup on the first argument, the key of the result map is usize, i.e. the distinct column index.

Dedup table schema: group key | distinct key | count for AGG1(distinct x) | count for AGG2(distinct x) | …

pub fn decompose( self, ) -> (Vec<PlanAggCall>, IndexSet, Vec<IndexSet>, PlanRef, bool)

pub fn fields_pretty<'a>(&self) -> StrAssocArr<'a>

fn agg_calls_pretty<'a>(&self) -> Pretty<'a>

fn group_key_pretty<'a>(&self) -> Pretty<'a>

Trait Implementations

impl<PlanRef: Clone> Clone for Agg<PlanRef>

fn clone(&self) -> Agg<PlanRef>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<PlanRef: Debug> Debug for Agg<PlanRef>

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

Formats the value using the given formatter.

impl<PlanRef: StreamPlanRef> DistillUnit for Agg<PlanRef>

fn distill_with_name<'a>(&self, name: impl Into<Cow<'a, str>>) -> XmlNode<'a>

impl From<Agg<PlanRef>> for LogicalAgg

fn from(core: Agg<PlanRef>) -> Self

Converts to this type from the input type.

impl From<Agg<PlanRef>> for PlanRef

Because From/Into are not transitive

fn from(core: Agg<PlanRef>) -> Self

Converts to this type from the input type.

impl<PlanRef: GenericPlanRef> GenericPlanNode for Agg<PlanRef>

fn schema(&self) -> Schema

fn stream_key(&self) -> Option<Vec<usize>>

fn ctx(&self) -> OptimizerContextRef

fn functional_dependency(&self) -> FunctionalDependencySet

impl<PlanRef: Hash> Hash for Agg<PlanRef>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<PlanRef: PartialEq> PartialEq for Agg<PlanRef>

fn eq(&self, other: &Agg<PlanRef>) -> 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<PlanRef: Eq> Eq for Agg<PlanRef>

impl<PlanRef> StructuralPartialEq for Agg<PlanRef>