Method execute_statement

graphlite/src/exec/executor.rs:703–971

Private helper for statement execution within the unified flow

(
        &self,
        statement: &Statement,
        context: &mut ExecutionContext,
        graph_expr: Option<&GraphExpression>,
        session: Option<&Arc<std::sync::RwLock<UserSession>>>,
   

    /// Private helper for statement execution within the unified flow
    fn execute_statement(
        &self,
        statement: &Statement,
        context: &mut ExecutionContext,
        graph_expr: Option<&GraphExpression>,
        session: Option<&Arc<std::sync::RwLock<UserSession>>>,
    ) -> Result<QueryResult, ExecutionError> {
        log::debug!(
            "EXECUTOR: execute_statement called with statement type: {:?}",
            std::mem::discriminant(statement)
        );
        match statement {
            Statement::Query(query) => {
                // Handle basic queries, set operations, and limited queries
                match query {
                    crate::ast::Query::Basic(basic_query) => {
                        // Use session-aware graph resolution instead of legacy execute_basic_query

                        // Create a mini ExecutionRequest to use resolve_graph_for_execution
                        let mini_request = ExecutionRequest::new(statement.clone())
                            .with_session(session.cloned())
                            .with_graph_expr(graph_expr.cloned());

                        // Resolve graph with proper session context
                        let graph = self.resolve_graph_for_execution(&mini_request)?;

                        // Create physical plan
                        use crate::ast::{Document, Query, Statement as AstStatement};
                        use crate::plan::optimizer::QueryPlanner;

                        let query = Query::Basic(basic_query.clone());
                        let statement_ast = AstStatement::Query(query);
                        let document = Document {
                            statement: statement_ast,
                            location: crate::ast::Location {
                                line: 1,
                                column: 1,
                                offset: 0,
                            },
                        };

                        let mut planner = QueryPlanner::new();
                        let planned_query = planner.plan_query(&document).map_err(|e| {
                            ExecutionError::RuntimeError(format!("Planning error: {}", e))
                        })?;
                        self.execute_with_provided_graph_and_audit(&planned_query, &graph, context)
                    }
                    crate::ast::Query::SetOperation(set_op) => {
                        self.execute_set_operation(set_op, context)
                    }
                    crate::ast::Query::Limited {
                        query,
                        order_clause,
                        limit_clause,
                    } => {
                        // Execute the inner query first
                        let mut result = self.execute_query_recursive(query, context)?;