Method analyze_query

src/optimization/mod.rs:51–101

Analyze a query and return optimization recommendations

(&self, query: &str)

    /// Analyze a query and return optimization recommendations
    pub fn analyze_query(&self, query: &str) -> Result<QueryOptimizationResult, PgSqliteError> {
        if !self.enabled {
            return Ok(QueryOptimizationResult::no_optimization());
        }

        let start_time = Instant::now();
        
        // Update statistics
        {
            let mut stats = self.optimization_stats.write().unwrap();
            stats.total_queries += 1;
        }

        // Pattern recognition
        let (pattern, hints) = {
            let mut pattern_optimizer = self.pattern_optimizer.write().unwrap();
            let result = pattern_optimizer.analyze_query(query);
            
            // Update stats
            {
                let mut stats = self.optimization_stats.write().unwrap();
                stats.pattern_recognition_hits += 1;
            }
            
            result
        };

        // Generate optimization result
        let result = QueryOptimizationResult {
            pattern,
            should_use_fast_path: hints.use_fast_path,
            should_cache_result: hints.cache_result,
            should_use_batch_processing: hints.use_batch_processing,
            should_skip_translation: hints.skip_translation,
            should_use_prepared_statement: hints.use_prepared_statement,
            estimated_complexity: hints.complexity,
            recommended_execution_strategy: self.recommend_execution_strategy(&hints),
            hints,
        };

        // Update timing statistics
        {
            let mut stats = self.optimization_stats.write().unwrap();
            stats.total_optimization_time_ms += start_time.elapsed().as_millis() as u64;
        }

        debug!("Query optimization analysis completed in {}ms: {:?}", 
               start_time.elapsed().as_millis(), result);

        Ok(result)
    }

    /// Get schema for a table using lazy loading
    pub fn get_table_schema(&self, conn: &Connection, table_name: &str) -> Result<Option<crate::cache::schema::TableSchema>, rusqlite::Error> {