Method execute_with_optimization

src/optimization/statement_cache_optimizer.rs:28–70

Execute a query with optimized statement caching

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

    /// Execute a query with optimized statement caching
    pub fn execute_with_optimization<P: rusqlite::Params>(
        &self,
        conn: &Connection,
        query: &str,
        params: P,
    ) -> Result<usize, rusqlite::Error> {
        if !self.enabled {
            return conn.execute(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 intelligent caching
        if self.should_use_statement_cache(&optimization_result.pattern, &optimization_result.hints) &&
           self.supports_binary_protocol(query) {
            debug!("Using enhanced statement cache for query pattern: {:?}", optimization_result.pattern);
            let (mut stmt, _metadata) = self.statement_pool.prepare_and_cache_enhanced(conn, query)?;
            let result = stmt.execute(params)?;
            
            // Log performance information if this is a significant query
            if matches!(optimization_result.pattern, 
                QueryPattern::BatchInsert | 
                QueryPattern::JoinWithWhere | 
                QueryPattern::GroupByAggregation
            ) {
                let cache_info = self.statement_pool.get_cache_info();
                debug!("Statement cache stats - Size: {}/{}, Hit rate: {:.2}%", 
                       cache_info.0, cache_info.1, cache_info.2 * 100.0);
            }
            
            Ok(result)
        } else {
            // Execute without caching for queries that don't benefit
            debug!("Executing without statement cache: {:?}", optimization_result.pattern);
            conn.execute(query, params)
        }
    }

    /// Query with optimized statement caching
    pub fn query_with_optimization<P: rusqlite::Params>(