Method evaluate_expression_in_row

graphlite/src/exec/executor.rs:2528–2646

Evaluate an expression within a specific row context

(
        &self,
        expr: &Expression,
        row: &Row,
        context: &ExecutionContext,
    )

    /// Evaluate an expression within a specific row context
    fn evaluate_expression_in_row(
        &self,
        expr: &Expression,
        row: &Row,
        context: &ExecutionContext,
    ) -> Result<Value, ExecutionError> {
        log::debug!("Evaluating expression in row context: {:?}", expr);

        match expr {
            Expression::Variable(var) => {
                // First check the row values, then context variables
                if let Some(value) = row.values.get(&var.name) {
                    Ok(value.clone())
                } else if let Some(value) = context.variables.get(&var.name) {
                    Ok(value.clone())
                } else {
                    Err(ExecutionError::ExpressionError(format!(
                        "Variable not found: {}",
                        var.name
                    )))
                }
            }
            Expression::FunctionCall(func_call) => {
                // Handle both aggregation and non-aggregation functions
                log::debug!("Evaluating function call: '{}'", func_call.name);

                // For aggregation functions, use simplified evaluation
                match func_call.name.to_lowercase().as_str() {
                    "count" => {
                        // For count, we need to count the number of items
                        // This is a simplification - proper count should work with the aggregation context
                        Ok(Value::Number(1.0)) // For now, return 1 as placeholder
                    }
                    "avg" | "sum" | "min" | "max" => {
                        // These need proper aggregation implementation
                        // For SUM of empty result sets, return NULL instead of 0.0
                        let func_name = func_call.name.to_lowercase();
                        if func_name == "sum" {
                            log::debug!("DEBUG: evaluate_expression_in_row - SUM returning NULL");
                            Ok(Value::Null)
                        } else if func_name == "avg" {
                            log::debug!("DEBUG: evaluate_expression_in_row - AVG returning 0.0 placeholder - THIS IS THE PROBLEM!");
                            Ok(Value::Number(0.0))
                        } else {
                            // For other aggregates, return a placeholder
                            log::debug!(
                                "DEBUG: evaluate_expression_in_row - {} returning 0.0 placeholder",
                                func_name
                            );
                            Ok(Value::Number(0.0))
                        }
                    }
                    _ => {
                        // For non-aggregation functions, use the regular function evaluation
                        log::debug!(
                            "Delegating to regular function evaluation for: {}",
                            func_call.name
                        );