Struct PhysicalGroupBy

pub struct PhysicalGroupBy { /* private fields */ }

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)
    ]
}

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.

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

Return grouping expressions as they occur in 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 copy 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.