Method execute_call_statement_without_graph

graphlite/src/exec/executor.rs:3035–3118

Execute a CALL statement with specific graph Execute a call statement without any graph context (for graph-independent procedures) Internal method for call statements without graph

(
        &self,
        call_stmt: &crate::ast::CallStatement,
        context: &ExecutionContext,
        session_id: Option<&str>,
    )

    /// Execute a call statement without any graph context (for graph-independent procedures)
    /// Internal method for call statements without graph
    fn execute_call_statement_without_graph(
        &self,
        call_stmt: &crate::ast::CallStatement,
        context: &ExecutionContext,
        session_id: Option<&str>,
    ) -> Result<QueryResult, ExecutionError> {
        // Evaluate arguments using the passed context
        let mut evaluated_args = Vec::new();

        for arg in &call_stmt.arguments {
            let value = self.evaluate_expression(arg, context)?;
            evaluated_args.push(value);
        }

        // Execute the system procedure with the actual session_id
        let mut result = self.system_procedures.execute_procedure(
            &call_stmt.procedure_name,
            evaluated_args,
            session_id,
        )?;

        // If there's a YIELD clause, filter the columns
        if let Some(yield_clause) = &call_stmt.yield_clause {
            for row in &mut result.rows {
                let mut filtered_values = std::collections::HashMap::new();

                for yield_item in &yield_clause.items {
                    let column_name = &yield_item.column_name;
                    let output_name = yield_item.alias.as_ref().unwrap_or(column_name);

                    if let Some(value) = row.values.get(column_name) {
                        filtered_values.insert(output_name.clone(), value.clone());
                    }
                }

                row.values = filtered_values;
            }

            // Update column list
            result.variables = yield_clause
                .items
                .iter()
                .map(|item| item.alias.as_ref().unwrap_or(&item.column_name).clone())
                .collect();
        }

        // Apply WHERE clause filtering after YIELD (per ISO GQL standard)
        if let Some(where_clause) = &call_stmt.where_clause {
            let filtered_rows: Result<Vec<_>, ExecutionError> = result
                .rows
                .into_iter()
                .filter_map(|row| {
                    // Clone the passed context and add row variables for WHERE evaluation
                    let mut temp_context = context.clone();
                    for (key, value) in &row.values {
                        temp_context.variables.insert(key.clone(), value.clone());
                    }