Function group_by_dim

nodedb-array/src/query/aggregate.rs:175–222

Group rows by one dim's values and reduce `attr_idx` per group. Returns groups in first-seen order.

(
    tile: &SparseTile,
    dim_idx: usize,
    attr_idx: usize,
    reducer: Reducer,
)

/// Group rows by one dim's values and reduce `attr_idx` per group.
/// Returns groups in first-seen order.
pub fn group_by_dim(
    tile: &SparseTile,
    dim_idx: usize,
    attr_idx: usize,
    reducer: Reducer,
) -> Vec<GroupAggregate> {
    let Some(dict) = tile.dim_dicts.get(dim_idx) else {
        return Vec::new();
    };
    let Some(col) = tile.attr_cols.get(attr_idx) else {
        return Vec::new();
    };
    let mut order: Vec<CoordValue> = Vec::new();
    let mut by_key: HashMap<CoordValue, AggregateResult> = HashMap::new();
    // Iterate physical rows; track live_idx separately because attr_cols only
    // has entries for Live rows — sentinel rows carry no attr payload.
    let mut live_idx = 0usize;
    for row in 0..tile.row_count() {
        let kind = match tile.row_kind(row) {
            Ok(k) => k,
            Err(_) => break,
        };
        if kind != RowKind::Live {
            continue;
        }
        let cell = match col.get(live_idx) {
            Some(c) => c,
            None => break,
        };
        live_idx += 1;
        let key = dict.values[dict.indices[row] as usize].clone();
        let one = single_cell(cell, reducer);
        match by_key.get_mut(&key) {
            Some(slot) => *slot = slot.merge(one),
            None => {
                order.push(key.clone());
                by_key.insert(key, empty(reducer).merge(one));
            }
        }
    }
    order
        .into_iter()
        .map(|k| GroupAggregate {
            result: by_key.remove(&k).unwrap_or(empty(reducer)),
            key: k,
        })
        .collect()
}

#[cfg(test)]
mod tests {