Method execute_with_clause_via_processor

graphlite/src/exec/executor.rs:1438–1591

Execute WITH clause by routing through WithClauseProcessor (comprehensive consolidation approach)

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

    /// Execute WITH clause by routing through WithClauseProcessor (comprehensive consolidation approach)
    fn execute_with_clause_via_processor(
        &self,
        with_clause: &WithClause,
        input_rows: Vec<Row>,
        context: &ExecutionContext,
    ) -> Result<Vec<Row>, ExecutionError> {
        // Create a context with the executor's function registry if not already present
        let enhanced_context = if context.function_registry.is_none() {
            // We need to copy the function registry from the executor, but since it's not Clone
            // we'll create a new context with a reference to a shared function registry
            let mut temp_context = context.clone();
            temp_context.function_registry = Some(self.get_function_registry_arc());
            temp_context
        } else {
            context.clone()
        };
        // For WITH clauses that contain non-aggregation functions,
        // we need to evaluate them row by row before using the processor

        let has_non_aggregation_functions = with_clause.items.iter().any(|item| {
            if let Expression::FunctionCall(func_call) = &item.expression {
                !Self::is_with_aggregation_function(&func_call.name)
            } else {
                false
            }
        });

        // Check if this is a simple variable pass-through (no functions at all)
        let is_simple_variable_passthrough = with_clause
            .items
            .iter()
            .all(|item| matches!(item.expression, Expression::Variable(_)));

        if is_simple_variable_passthrough && !input_rows.is_empty() {
            // Simple case: just pass through variables, preserving Node objects
            let mut result_rows = Vec::new();

            for input_row in input_rows {
                let mut output_values = std::collections::HashMap::new();

                for with_item in &with_clause.items {
                    if let Expression::Variable(var) = &with_item.expression {
                        let alias = if let Some(ref alias_name) = with_item.alias {
                            alias_name.clone()
                        } else {
                            var.name.clone()
                        };

                        if let Some(value) = input_row.values.get(&var.name) {
                            output_values.insert(alias, value.clone());
                        }
                    }
                }

                result_rows.push(Row::from_values(output_values));
            }

            return Ok(result_rows);