Struct PhysicalGroupBy 

pub struct PhysicalGroupBy {
    expr: Vec<(Arc<dyn PhysicalExpr>, String)>,
    null_expr: Vec<(Arc<dyn PhysicalExpr>, String)>,
    groups: Vec<Vec<bool>>,
}

Represents GROUP BY clause in the plan (including the more general GROUPING SET) In the case of a simple GROUP BY a, b clause, this will contain the expression [a, b] and a single group [false, false]. In the case of GROUP BY GROUPING SETS/CUBE/ROLLUP the planner will expand the expression into multiple groups, using null expressions to align each group. For example, with a group by clause GROUP BY GROUPING SETS ((a,b),(a),(b)) the planner should create a PhysicalGroupBy like

PhysicalGroupBy {
    expr: [(col(a), a), (col(b), b)],
    null_expr: [(NULL, a), (NULL, b)],
    groups: [
        [false, false], // (a,b)
        [false, true],  // (a) <=> (a, NULL)
        [true, false]   // (b) <=> (NULL, b)
    ]
}

Fields

expr: Vec<(Arc<dyn PhysicalExpr>, String)>

Distinct (Physical Expr, Alias) in the grouping set

null_expr: Vec<(Arc<dyn PhysicalExpr>, String)>

Corresponding NULL expressions for expr

groups: Vec<Vec<bool>>

Null mask for each group in this grouping set. Each group is composed of either one of the group expressions in expr or a null expression in null_expr. If groups[i][j] is true, then the j-th expression in the i-th group is NULL, otherwise it is expr[j].

Implementations

impl PhysicalGroupBy

pub fn new( expr: Vec<(Arc<dyn PhysicalExpr>, String)>, null_expr: Vec<(Arc<dyn PhysicalExpr>, String)>, groups: Vec<Vec<bool>>, ) -> Self

Create a new PhysicalGroupBy

pub fn new_single(expr: Vec<(Arc<dyn PhysicalExpr>, String)>) -> Self

Create a GROUPING SET with only a single group. This is the “standard” case when building a plan from an expression such as GROUP BY a,b,c

pub fn exprs_nullable(&self) -> Vec<bool>

Calculate GROUP BY expressions nullable

pub fn expr(&self) -> &[(Arc<dyn PhysicalExpr>, String)]

Returns the group expressions

pub fn null_expr(&self) -> &[(Arc<dyn PhysicalExpr>, String)]

Returns the null expressions

pub fn groups(&self) -> &[Vec<bool>]

Returns the group null masks

pub fn is_empty(&self) -> bool

Returns true if this PhysicalGroupBy has no group expressions

pub fn is_single(&self) -> bool

Check whether grouping set is single group

pub fn input_exprs(&self) -> Vec<Arc<dyn PhysicalExpr>>

Calculate GROUP BY expressions according to input schema.

fn num_output_exprs(&self) -> usize

The number of expressions in the output schema.

pub fn output_exprs(&self) -> Vec<Arc<dyn PhysicalExpr>>

Return grouping expressions as they occur in the output schema.

pub fn num_group_exprs(&self) -> usize

Returns the number expression as grouping keys.

pub fn group_schema(&self, schema: &Schema) -> Result<SchemaRef>

fn group_fields(&self, input_schema: &Schema) -> Result<Vec<FieldRef>>

Returns the fields that are used as the grouping keys.

fn output_fields(&self, input_schema: &Schema) -> Result<Vec<FieldRef>>

Returns the output fields of the group by.

This might be different from the group_fields that might contain internal expressions that should not be part of the output schema.

pub fn as_final(&self) -> PhysicalGroupBy

Returns the PhysicalGroupBy for a final aggregation if self is used for a partial aggregation.

Trait Implementations

impl Clone for PhysicalGroupBy

fn clone(&self) -> PhysicalGroupBy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalGroupBy

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

Formats the value using the given formatter.

impl Default for PhysicalGroupBy

fn default() -> PhysicalGroupBy

Returns the “default value” for a type.

impl PartialEq for PhysicalGroupBy

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