Method execute_with_clause

graphlite/src/exec/executor.rs:1352–1400

Execute a WITH clause to transform query results

(
        &self,
        with_clause: &WithClause,
        input_rows: Vec<Row>,
        context: &ExecutionContext,
    )

    /// Execute a WITH clause to transform query results
    fn execute_with_clause(
        &self,
        with_clause: &WithClause,
        input_rows: Vec<Row>,
        context: &ExecutionContext,
    ) -> Result<Vec<Row>, ExecutionError> {
        log::debug!("Executing WITH clause with {} input rows", input_rows.len());

        // DEBUG: Inspect the structure of input rows to understand conversion needs
        if !input_rows.is_empty() {
            log::debug!("DEBUG: execute_with_clause input row sample:");
            log::debug!(
                "  Variables: {:?}",
                input_rows[0].values.keys().collect::<Vec<_>>()
            );
            for (key, value) in input_rows[0].values.iter() {
                log::debug!("  {}: {:?} (type: {})", key, value, value.type_name());
            }
        }

        // Separate grouping expressions from aggregate expressions
        let mut grouping_exprs = Vec::new();
        let mut aggregate_exprs = Vec::new();

        for with_item in &with_clause.items {
            match &with_item.expression {
                Expression::FunctionCall(func_call) => {
                    // Check if it's an aggregate function
                    match func_call.name.to_lowercase().as_str() {
                        "count" | "avg" | "sum" | "min" | "max" => {
                            aggregate_exprs.push(with_item);
                        }
                        _ => {
                            grouping_exprs.push(with_item);
                        }
                    }
                }
                _ => {
                    // Non-function expressions are grouping expressions
                    grouping_exprs.push(with_item);
                }
            }
        }

        // COMPREHENSIVE ROUTING CONSOLIDATION: Route ALL WITH clauses through WithClauseProcessor
        // This eliminates the problematic execute_with_clause_simple path entirely
        // Route through WithClauseProcessor
        self.execute_with_clause_via_processor(with_clause, input_rows, context)
    }

    /// Execute a WITH clause without aggregation (fallback for simple cases)
    #[allow(dead_code)] // ROADMAP v0.5.0 - Alternative WITH clause implementation