Method execute_aggregate

graphlite/src/exec/executor.rs:5739–5938

Common aggregation logic

(
        &self,
        group_by: &[Expression],
        aggregates: &[crate::plan::physical::AggregateItem],
        input_rows: Vec<Row>,
        context: &mut ExecutionContext,
    )

    /// Common aggregation logic
    fn execute_aggregate(
        &self,
        group_by: &[Expression],
        aggregates: &[crate::plan::physical::AggregateItem],
        input_rows: Vec<Row>,
        context: &mut ExecutionContext,
    ) -> Result<Vec<Row>, ExecutionError> {
        use std::collections::HashMap;

        // Debug: Check input data
        log::debug!("AGGREGATE DEBUG: Received {} input rows", input_rows.len());
        if !group_by.is_empty() {
            log::debug!(
                "AGGREGATE DEBUG: GROUP BY expressions: {:?}",
                group_by
                    .iter()
                    .map(|e| format!("{:?}", e))
                    .collect::<Vec<_>>()
            );
        }

        // Group rows by the group_by expressions
        let mut groups: HashMap<String, Vec<Row>> = HashMap::new();
        let mut group_key_to_values: HashMap<String, Vec<Value>> = HashMap::new();

        for row in input_rows {
            // Clear local variables from previous row to prevent variable leakage
            context.clear_locals();

            // Set row values in context for expression evaluation
            for (name, value) in &row.values {
                context.set_variable(name.clone(), value.clone());
            }

            // Create group key from group_by expressions
            let mut group_key_values = Vec::new();
            let mut group_key_strings = Vec::new();
            for expr in group_by {
                let value = self.evaluate_expression(expr, context)?;
                log::debug!(
                    "AGGREGATE DEBUG: GROUP BY expr {:?} evaluated to: {:?}",
                    expr,
                    value
                );
                group_key_values.push(value.clone());
                group_key_strings.push(value.to_string());
            }
            let group_key = group_key_strings.join("|");
            log::debug!("AGGREGATE DEBUG: Group key: '{}'", group_key);

            // Store the mapping from key to actual values for later use
            group_key_to_values.insert(group_key.clone(), group_key_values);

            // Add row to appropriate group
            groups.entry(group_key).or_default().push(row);
        }

        // Process each group