Method analyze_and_create_plan

src/optimization/read_only_optimizer.rs:244–298

Analyze query and create execution plan

(
        &self,
        query: &str,
        schema_cache: &SchemaCache,
        conn: &Connection,
    )

    /// Analyze query and create execution plan
    fn analyze_and_create_plan(
        &self,
        query: &str,
        schema_cache: &SchemaCache,
        conn: &Connection,
    ) -> Result<Option<CachedQueryPlan>, rusqlite::Error> {
        // Extract table name from query
        let table_name = match self.extract_table_name(query) {
            Some(name) => name,
            None => return Ok(None),
        };

        // Prepare statement to get column information
        let stmt = conn.prepare(query)?;
        let column_count = stmt.column_count();
        
        // Get column names
        let mut columns = Vec::new();
        for i in 0..column_count {
            columns.push(sanitize_column_name(stmt.column_name(i)?).to_string());
        }

        // Get column types from schema cache
        let mut column_types = Vec::new();
        if let Ok(table_schema) = schema_cache.get_or_load(conn, &table_name) {
            for col_name in &columns {
                if let Some(col_info) = table_schema.column_map.get(&col_name.to_lowercase()) {
                    column_types.push(Some(col_info.pg_type.clone()));
                } else {
                    column_types.push(None);
                }
            }
        } else {
            column_types.resize(columns.len(), None);
        }

        // Determine query complexity
        let complexity = self.classify_query_complexity(query);

        // Check for WHERE clause
        let has_where_clause = query.to_uppercase().contains("WHERE");

        Ok(Some(CachedQueryPlan {
            query: query.to_string(),
            table_name,
            columns,
            column_types,
            has_where_clause,
            complexity,
            last_used: Instant::now(),
            access_count: 0,
            avg_execution_time: Duration::from_millis(0),
            success_rate: 1.0,
        }))
    }

    /// Execute query using cached plan
    fn execute_with_cached_plan(