Method extract_enhanced_metadata

src/cache/enhanced_statement_pool.rs:199–241

Extract enhanced metadata including optimization information

(
        &self,
        stmt: &Statement,
        query: &str,
        _pattern: &QueryPattern,
        hints: &OptimizationHints,
    )

    /// Extract enhanced metadata including optimization information
    fn extract_enhanced_metadata(
        &self,
        stmt: &Statement,
        query: &str,
        _pattern: &QueryPattern,
        hints: &OptimizationHints,
    ) -> Result<StatementMetadata, rusqlite::Error> {
        let columns = stmt.columns();
        let mut column_names = Vec::with_capacity(columns.len());
        let mut column_types = Vec::with_capacity(columns.len());

        for column in columns {
            let column_name = column.name().to_string();
            column_names.push(column_name.clone());
            
            // Extract column type information from the column
            let mut column_type = column.decl_type().map(|s| s.to_string());
            
            // Special handling for PostgreSQL datetime functions
            // If SQLite returns no type info but we know this is a datetime function,
            // override with the correct PostgreSQL type
            if column_type.is_none() && is_datetime_function_result(query, &column_name) {
                column_type = Some("timestamptz".to_string());
            }
            
            column_types.push(column_type);
        }

        let parameter_count = stmt.parameter_count();
        let is_select = query.trim().to_uppercase().starts_with("SELECT") || 
                       query.trim().to_uppercase().starts_with("WITH");

        Ok(StatementMetadata {
            column_names,
            column_types,
            parameter_count,
            is_select,
            complexity: hints.complexity,
            expected_result_size: hints.expected_result_size,
            use_fast_path: hints.use_fast_path,
            cache_results: hints.cache_result,
        })
    }

    /// Extract basic metadata for non-cached queries
    fn extract_basic_metadata(&self, stmt: &Statement, query: &str) -> Result<StatementMetadata, rusqlite::Error> {