Struct LogicalAggBuilder

pub struct LogicalAggBuilder {
    input_proj_builder: ProjectBuilder,
    group_key: IndexSet,
    grouping_sets: Vec<IndexSet>,
    agg_calls: Vec<PlanAggCall>,
    error: Option<RwError>,
    is_in_filter_clause: bool,
}

LogicalAggBuilder extracts agg calls and references to group columns from select list and build the plan like LogicalAgg - LogicalProject. it is constructed by group_exprs and collect and rewrite the expression in selection and having clause.

Fields

input_proj_builder: ProjectBuilder

the builder of the input Project

group_key: IndexSet

the group key column indices in the project’s output

grouping_sets: Vec<IndexSet>

the grouping sets

agg_calls: Vec<PlanAggCall>

the agg calls

error: Option<RwError>

the error during the expression rewriting

is_in_filter_clause: bool

If is_in_filter_clause is true, it means that we are processing filter clause. This field is needed because input refs in these clauses are allowed to refer to any columns, while those not in filter clause are only allowed to refer to group keys.

Implementations

impl LogicalAggBuilder

fn new(group_by: GroupBy, input_schema_len: usize) -> Result<Self, RwError>

pub fn build(self, input: PlanRef) -> LogicalAgg

fn rewrite_with_error(&mut self, expr: ExprImpl) -> Result<ExprImpl, RwError>

pub fn try_as_group_expr(&self, expr: &ExprImpl) -> Option<usize>

check if the expression is a group by key, and try to return the group key

fn schema_agg_start_offset(&self) -> usize

pub(crate) fn general_rewrite_agg_call( agg_call: AggCall, push_agg_call: impl FnMut(AggCall) -> Result<InputRef, RwError>, ) -> Result<ExprImpl, RwError>

Rewrite AggCall if needed, and push it into the builder using push_agg_call. This is shared by LogicalAggBuilder and LogicalOverWindowBuilder.

fn push_agg_call(&mut self, agg_call: AggCall) -> Result<InputRef, RwError>

Push a new agg call into the builder. Return an InputRef to that agg call. For existing agg calls, return an InputRef to the existing one.

fn try_rewrite_agg_call( &mut self, agg_call: AggCall, ) -> Result<ExprImpl, RwError>

When there is an agg call, there are 3 things to do:

1. Rewrite avg, var_samp, etc. into a combination of sum, count, etc.;
2. Add exprs in arguments to input Project;
3. Add the agg call to current Agg, and return an InputRef to it.

Note that the rewriter does not traverse into inputs of agg calls.

Trait Implementations

impl ExprRewriter for LogicalAggBuilder

fn rewrite_function_call(&mut self, func_call: FunctionCall) -> ExprImpl

When there is an FunctionCall (outside of agg call), it must refers to a group column. Or all InputRefs appears in it must refer to a group column.

fn rewrite_window_function(&mut self, window_func: WindowFunction) -> ExprImpl

When there is an WindowFunction (outside of agg call), it must refers to a group column. Or all InputRefs appears in it must refer to a group column.

fn rewrite_input_ref(&mut self, input_ref: InputRef) -> ExprImpl

When there is an InputRef (outside of agg call), it must refers to a group column.

fn rewrite_agg_call(&mut self, agg_call: AggCall) -> ExprImpl

fn rewrite_subquery(&mut self, subquery: Subquery) -> ExprImpl

fn rewrite_expr(&mut self, expr: ExprImpl) -> ExprImpl

fn rewrite_function_call_with_lambda( &mut self, func_call: FunctionCallWithLambda, ) -> ExprImpl

fn rewrite_parameter(&mut self, parameter: Parameter) -> ExprImpl

fn rewrite_literal(&mut self, literal: Literal) -> ExprImpl

fn rewrite_correlated_input_ref( &mut self, input_ref: CorrelatedInputRef, ) -> ExprImpl

fn rewrite_table_function(&mut self, table_func: TableFunction) -> ExprImpl

fn rewrite_user_defined_function( &mut self, udf: UserDefinedFunction, ) -> ExprImpl

fn rewrite_now(&mut self, now: Now) -> ExprImpl