Method query_with_optimization

src/optimization/statement_cache_optimizer.rs:73–161

Query with optimized statement caching

(
        &self,
        conn: &Connection,
        query: &str,
        params: P,
    )

    /// Query with optimized statement caching
    pub fn query_with_optimization<P: rusqlite::Params>(
        &self,
        conn: &Connection,
        query: &str,
        params: P,
    ) -> Result<(Vec<String>, crate::session::db_handler::DbRows), rusqlite::Error> {
        if !self.enabled {
            return self.execute_basic_query(conn, query, params);
        }

        // Analyze query for optimization opportunities
        let optimization_result = self.optimization_manager
            .analyze_query(query)
            .map_err(|e| rusqlite::Error::SqliteFailure(
                rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_MISUSE),
                Some(format!("Query optimization failed: {e}"))
            ))?;

        // Use enhanced statement pool for SELECT queries that benefit from caching
        // and don't require binary protocol support
        debug!("Query analysis result for '{}': pattern={:?}, cache_result={}, supports_binary={}", 
               query, optimization_result.pattern, optimization_result.hints.cache_result, 
               self.supports_binary_protocol(query));
        
        if optimization_result.hints.cache_result && 
           self.supports_binary_protocol(query) &&
           matches!(optimization_result.pattern, 
               QueryPattern::SimpleSelect | 
               QueryPattern::CountQuery | 
               QueryPattern::MaxMinQuery |
               QueryPattern::OrderByLimit
           ) {
            debug!("Using enhanced statement cache for SELECT query pattern: {:?}", optimization_result.pattern);
            let (mut stmt, metadata) = self.statement_pool.prepare_and_cache_enhanced(conn, query)?;
            
            // Execute query and collect results
            let mut results = Vec::new();
            let column_names = metadata.column_names.clone();
            info!("Statement metadata - column_names: {:?}, column_types: {:?}", column_names, metadata.column_types);
            
            let rows = stmt.query_map(params, |row| {
                let mut row_data = Vec::new();
                for i in 0..column_names.len() {
                    match row.get_ref(i)? {
                        rusqlite::types::ValueRef::Null => row_data.push(None),
                        rusqlite::types::ValueRef::Integer(val) => {
                            // Check if this column is a boolean type
                            let is_boolean = metadata.column_types.get(i)
                                .and_then(|opt| opt.as_ref())
                                .map(|pg_type| {
                                    let type_lower = pg_type.to_lowercase();
                                    type_lower == "boolean" || type_lower == "bool"
                                })
                                .unwrap_or(false);
                            
                            if is_boolean {
                                // Convert integer 0/1 to PostgreSQL f/t format
                                let bool_str = if val == 0 { "f" } else { "t" };