Method evaluate_aggregate_expression

graphlite/src/exec/executor.rs:1836–1938

ROADMAP v0.5.0 - Aggregate expression evaluation helper

(
        &self,
        expr: &Expression,
        group_rows: &[&Row],
        context: &ExecutionContext,
    )

    /// Evaluate an aggregate expression over a group of rows
    #[allow(dead_code)] // ROADMAP v0.5.0 - Aggregate expression evaluation helper
    fn evaluate_aggregate_expression(
        &self,
        expr: &Expression,
        group_rows: &[&Row],
        context: &ExecutionContext,
    ) -> Result<Value, ExecutionError> {
        match expr {
            Expression::FunctionCall(func_call) => {
                log::debug!("Evaluating aggregate function: '{}'", func_call.name);
                match func_call.name.to_lowercase().as_str() {
                    "count" => {
                        // Count non-null values
                        if let Some(arg) = func_call.arguments.first() {
                            let mut count = 0;
                            for row in group_rows {
                                let value = self.evaluate_expression_in_row(arg, row, context)?;
                                if !matches!(value, Value::Null) {
                                    count += 1;
                                }
                            }
                            Ok(Value::Number(count as f64))
                        } else {
                            // COUNT(*) - count all rows
                            Ok(Value::Number(group_rows.len() as f64))
                        }
                    }
                    "avg" => {
                        // Compute average of non-null numeric values
                        if let Some(arg) = func_call.arguments.first() {
                            let mut sum = 0.0;
                            let mut count = 0;

                            for row in group_rows {
                                let value = self.evaluate_expression_in_row(arg, row, context)?;
                                match value {
                                    Value::Number(n) => {
                                        sum += n;
                                        count += 1;
                                    }
                                    Value::Null => {
                                        // Skip null values in average computation
                                    }
                                    _ => {
                                        return Err(ExecutionError::ExpressionError(format!(
                                            "Cannot compute average of non-numeric value: {:?}",
                                            value
                                        )));
                                    }
                                }
                            }

                            if count > 0 {
                                Ok(Value::Number(sum / count as f64))
                            } else {
                                Ok(Value::Null) // Average of no values is NULL
                            }
                        } else {
                            Err(ExecutionError::ExpressionError(