Method execute_basic_query_with_context

graphlite/src/exec/executor.rs:1010–1052

Execute a basic query with access to outer context variables (for correlated subqueries)

(
        &self,
        basic_query: &BasicQuery,
        outer_context: &ExecutionContext,
    )

    /// Execute a basic query with access to outer context variables (for correlated subqueries)
    fn execute_basic_query_with_context(
        &self,
        basic_query: &BasicQuery,
        outer_context: &ExecutionContext,
    ) -> Result<QueryResult, ExecutionError> {
        use crate::ast::{Document, Query, Statement};
        use crate::plan::optimizer::QueryPlanner;

        log::debug!(
            "execute_basic_query_with_context: BasicQuery has GROUP BY: {}",
            basic_query.group_clause.is_some()
        );

        // Get the graph from the execution context
        let graph = outer_context.current_graph.as_ref().ok_or_else(|| {
            ExecutionError::RuntimeError("No graph available in execution context".to_string())
        })?;

        // Create a Document and Statement wrapper for the planner
        let query = Query::Basic(basic_query.clone());
        let statement = Statement::Query(query);
        let document = Document {
            statement,
            location: Location {
                line: 1,
                column: 1,
                offset: 0,
            },
        };

        // Use the query planner to create a physical plan
        log::debug!("Calling QueryPlanner::plan_query");
        let mut planner = QueryPlanner::new();
        let planned_query = planner
            .plan_query(&document)
            .map_err(|e| ExecutionError::RuntimeError(format!("Planning error: {}", e)))?;
        log::debug!("QueryPlanner returned physical plan");

        // Execute the physical plan with the graph from execution context
        // Create a mutable copy of the context for execution
        let mut context_copy = outer_context.clone();
        self.execute_with_provided_graph_and_audit(&planned_query, graph, &mut context_copy)
    }

    /// Execute a subquery within the current execution context
    fn execute_subquery(