Method execute_aggregate_projection

graphlite/src/exec/executor.rs:6056–6122

Execute projection with aggregate functions (returns single row)

(
        &self,
        expressions: &[ProjectionItem],
        input_rows: Vec<Row>,
        context: &mut ExecutionContext,
    )

    /// Execute projection with aggregate functions (returns single row)
    fn execute_aggregate_projection(
        &self,
        expressions: &[ProjectionItem],
        input_rows: Vec<Row>,
        context: &mut ExecutionContext,
    ) -> Result<Vec<Row>, ExecutionError> {
        let mut result_row = Row::new();

        // Evaluate each projection expression with all input rows
        for proj_item in expressions {
            let value = if let Expression::FunctionCall(func_call) = &proj_item.expression {
                // Handle aggregate function
                let function = self.function_registry.get(&func_call.name).ok_or_else(|| {
                    ExecutionError::UnsupportedOperator(format!(
                        "Function not found: {}",
                        func_call.name
                    ))
                })?;

                // Evaluate arguments (currently COUNT has no arguments, but others might)
                let mut evaluated_args = Vec::new();
                for arg in &func_call.arguments {
                    // For arguments like AVERAGE(account.balance), we need to pass the full property path
                    if let Expression::PropertyAccess(prop) = arg {
                        // Pass the full property path (e.g., "account.balance", "account.id")
                        let full_property = format!("{}.{}", prop.object, prop.property);
                        evaluated_args.push(Value::String(full_property));
                    } else if let Expression::Variable(var) = arg {
                        evaluated_args.push(Value::String(var.name.clone()));
                    } else {
                        // For other expression types, evaluate them using the existing context
                        let value = self.evaluate_expression(arg, context)?;
                        evaluated_args.push(value);
                    }
                }

                // Create function context with all input rows and storage access
                let function_context = FunctionContext::with_storage(
                    input_rows.clone(),
                    HashMap::new(),
                    evaluated_args,
                    context.storage_manager.clone(),
                    context.current_graph.clone(),
                    context.get_current_graph_name(),
                );

                // Execute the function
                function.execute(&function_context).map_err(|e| {
                    ExecutionError::UnsupportedOperator(format!("Function execution error: {}", e))
                })?
            } else {
                // Non-aggregate expression in aggregate context - this is usually invalid SQL
                // but for simplicity, we'll return null or error
                return Err(ExecutionError::ExpressionError(
                    "Non-aggregate expressions not allowed with aggregate functions".to_string(),
                ));
            };