Method plan_query_with_alternatives

graphlite/src/plan/optimizer.rs:322–373

ROADMAP v0.3.0 - Multi-plan generation for cost-based optimization (see ROADMAP.md §5)

(
        &mut self,
        document: &Document,
    )

    /// Plan a query with multiple alternatives for comparison
    #[allow(dead_code)] // ROADMAP v0.3.0 - Multi-plan generation for cost-based optimization (see ROADMAP.md §5)
    pub fn plan_query_with_alternatives(
        &mut self,
        document: &Document,
    ) -> Result<QueryPlanAlternatives, PlanningError> {
        let _start_time = std::time::Instant::now();

        // Extract query from document
        let query = match &document.statement {
            crate::ast::Statement::Query(q) => q,
            _ => {
                return Err(PlanningError::InvalidQuery(
                    "Document does not contain a query statement".to_string(),
                ))
            }
        };

        // Generate logical plan
        let logical_plan = self.create_logical_plan(query)?;

        // Generate multiple physical plan alternatives
        let mut physical_plans = Vec::new();

        // Plan 1: Basic plan without heavy optimization
        let basic_physical = PhysicalPlan::from_logical(&logical_plan);
        physical_plans.push(basic_physical.clone());

        // Plan 2: Optimized plan
        let optimized_logical = self.optimize_logical_plan(logical_plan.clone())?;
        let optimized_physical = self.create_physical_plan(optimized_logical)?;
        physical_plans.push(optimized_physical.clone());

        // Plan 3: Alternative join orders (if applicable)
        if matches!(
            self.optimization_level,
            OptimizationLevel::Advanced | OptimizationLevel::Aggressive
        ) {
            if let Ok(alternative) = self.generate_join_alternatives(&logical_plan) {
                physical_plans.push(alternative);
            }
        }

        // Select best plan based on cost
        let best_plan = self.select_best_plan(&physical_plans)?;

        let planning_time = _start_time.elapsed().as_millis() as u64;

        Ok(QueryPlanAlternatives {
            plans: physical_plans,
            best_plan,
            planning_time_ms: planning_time,
        })
    }

    /// Create logical plan from query AST
    fn create_logical_plan(&mut self, query: &Query) -> Result<LogicalPlan, PlanningError> {