Method extract_basic_metadata

src/cache/enhanced_statement_pool.rs:244–280

Extract basic metadata for non-cached queries

(&self, stmt: &Statement, query: &str)

    /// Extract basic metadata for non-cached queries
    fn extract_basic_metadata(&self, stmt: &Statement, query: &str) -> 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: crate::query::QueryComplexity::Medium,
            expected_result_size: crate::query::ResultSize::Unknown,
            use_fast_path: false,
            cache_results: false,
        })
    }

    /// Get cached metadata if available
    fn get_cached_metadata(&self, cache_key: &str) -> Option<StatementMetadata> {