Struct GroupOrderingPartial

pub struct GroupOrderingPartial { /* private fields */ }

Tracks grouping state when the data is ordered by some subset of the group keys.

Once the next sort key value is seen, never see groups with that sort key again, so we can emit all groups with the previous sort key and earlier.

For example, given SUM(amt) GROUP BY id, state if the input is sorted by state, when a new value of state is seen, all groups with prior values of state can be emitted.

The state is tracked like this:

                                           ┏━━━━━━━━━━━━━━━━━┓ ┏━━━━━━━┓
    ┌─────┐    ┌───────────────────┐ ┌─────┃        9        ┃ ┃ "MD"  ┃
    │┌───┐│    │ ┌──────────────┐  │ │     ┗━━━━━━━━━━━━━━━━━┛ ┗━━━━━━━┛
    ││ 0 ││    │ │  123, "MA"   │  │ │        current_sort      sort_key
    │└───┘│    │ └──────────────┘  │ │
    │ ... │    │    ...            │ │      current_sort tracks the
    │┌───┐│    │ ┌──────────────┐  │ │      smallest group index that had
    ││ 8 ││    │ │  765, "MA"   │  │ │      the same sort_key as current
    │├───┤│    │ ├──────────────┤  │ │
    ││ 9 ││    │ │  923, "MD"   │◀─┼─┘
    │├───┤│    │ ├──────────────┤  │        ┏━━━━━━━━━━━━━━┓
    ││10 ││    │ │  345, "MD"   │  │  ┌─────┃      11      ┃
    │├───┤│    │ ├──────────────┤  │  │     ┗━━━━━━━━━━━━━━┛
    ││11 ││    │ │  124, "MD"   │◀─┼──┘         current
    │└───┘│    │ └──────────────┘  │
    └─────┘    └───────────────────┘

 group indices
(in group value  group_values               current tracks the most
     order)                                    recent group index

Implementations

impl GroupOrderingPartial

pub fn try_new( input_schema: &Schema, order_indices: &[usize], ordering: LexOrderingRef<'_>, ) -> Result<Self>

pub fn emit_to(&self) -> Option<EmitTo>

How many groups be emitted, or None if no data can be emitted

pub fn remove_groups(&mut self, n: usize)

remove the first n groups from the internal state, shifting all existing indexes down by n

pub fn input_done(&mut self)

Note that the input is complete so any outstanding groups are done as well

pub fn new_groups( &mut self, batch_group_values: &[ArrayRef], group_indices: &[usize], total_num_groups: usize, ) -> Result<()>

Called when new groups are added in a batch. See documentation on super::GroupOrdering::new_groups

Trait Implementations

impl Debug for GroupOrderingPartial

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

Formats the value using the given formatter.