Method execute_query

graphlite/src/exec/executor.rs:151–239

Unified execution entry point - all queries flow through here

(&self, request: ExecutionRequest)

    /// Unified execution entry point - all queries flow through here
    pub fn execute_query(&self, request: ExecutionRequest) -> Result<QueryResult, ExecutionError> {
        log::debug!(
            "EXECUTE_QUERY: Statement type: {:?}",
            std::mem::discriminant(&request.statement)
        );
        let start_time = std::time::Instant::now();

        // PHASE 1: Check if this is an UNWIND query that needs preprocessing
        if let Some(ref query_text) = request.query_text {
            if crate::exec::unwind_preprocessor::UnwindPreprocessor::is_unwind_query(query_text) {
                log::debug!("EXECUTOR: Detected UNWIND query, using preprocessor");

                // Use the preprocessor to handle this query
                let executor_fn =
                    |query: &str| -> Result<crate::exec::result::QueryResult, ExecutionError> {
                        // Create a new request without the UNWIND (the individual queries won't have UNWIND)
                        let parsed_query = crate::ast::parser::parse_query(query).map_err(|e| {
                            ExecutionError::RuntimeError(format!(
                                "Failed to parse individual query: {}",
                                e
                            ))
                        })?;

                        let new_request = ExecutionRequest {
                            statement: parsed_query.statement,
                            session: request.session.clone(),
                            graph_expr: request.graph_expr.clone(),
                            query_text: Some(query.to_string()),
                            physical_plan: None,
                            requires_graph_context: request.requires_graph_context,
                        };

                        // Execute the individual query normally
                        self.execute_query(new_request)
                    };

                return crate::exec::unwind_preprocessor::UnwindPreprocessor::execute_unwind_query(
                    query_text,
                    executor_fn,
                );
            }
        }

        // Step 1: Resolve execution context based on session and graph requirements
        let needs_graph = if let Some(requires_graph) = request.requires_graph_context {
            // Use the flag from validator if available (preferred)
            requires_graph
        } else {
            // Fallback to statement-based detection
            self.statement_needs_graph_context(&request.statement)
        };

        // Step 2: Resolve graph using PostgreSQL-style precedence:
        // 1. Explicit graph expression in query (FROM clause)
        // 2. Session's current graph
        // 3. Error if needed but not available
        let resolved_graph = if needs_graph {
            Some(self.resolve_graph_for_execution(&request)?)