Method load_table_schema_direct

src/cache/schema.rs:164–246

Load a single table schema directly from database (bypassing cache)

(&self, conn: &Connection, table_name: &str)

    /// Load a single table schema directly from database (bypassing cache)
    fn load_table_schema_direct(&self, conn: &Connection, table_name: &str) -> Result<TableSchema, rusqlite::Error> {
        let mut column_data = Vec::new();
        
        // First get all columns from SQLite schema
        let pragma_query = format!("PRAGMA table_info({table_name})");
        let mut stmt = conn.prepare(&pragma_query)?;
        let rows = stmt.query_map([], |row| {
            let name: String = row.get(1)?;
            let sqlite_type: String = row.get(2)?;
            Ok((name, sqlite_type))
        })?;
        
        let mut sqlite_columns = Vec::new();
        for row in rows {
            sqlite_columns.push(row?);
        }

        // Bulk query for all PostgreSQL types for this table
        let mut pg_metadata = HashMap::new();
        if let Ok(mut stmt) = conn.prepare("SELECT column_name, pg_type FROM __pgsqlite_schema WHERE table_name = ?1")
            && let Ok(rows) = stmt.query_map([table_name], |row| {
                let col_name: String = row.get(0)?;
                let pg_type: String = row.get(1)?;
                Ok((col_name, pg_type))
            }) {
                for row in rows.flatten() {
                    pg_metadata.insert(row.0, row.1);
                }
            }

        // Build column data
        for (col_name, sqlite_type) in sqlite_columns {
            let (pg_type, pg_oid) = if let Some(pg_type_str) = pg_metadata.get(&col_name) {
                let oid = crate::types::SchemaTypeMapper::pg_type_string_to_oid(pg_type_str);
                (pg_type_str.clone(), oid)
            } else {
                // Fallback to type mapping
                let type_mapper = crate::types::TypeMapper::new();
                let pg_type = type_mapper.sqlite_to_pg(&sqlite_type);
                let oid = pg_type.to_oid();
                let pg_type_str = match pg_type {
                    crate::types::PgType::Text => "text",
                    crate::types::PgType::Int8 => "int8",
                    crate::types::PgType::Int4 => "int4", 
                    crate::types::PgType::Int2 => "int2",
                    crate::types::PgType::Float8 => "float8",
                    crate::types::PgType::Float4 => "float4",
                    crate::types::PgType::Bool => "boolean",
                    crate::types::PgType::Bytea => "bytea",
                    crate::types::PgType::Date => "date",
                    crate::types::PgType::Timestamp => "timestamp",
                    crate::types::PgType::Timestamptz => "timestamptz",
                    crate::types::PgType::Uuid => "uuid",
                    crate::types::PgType::Numeric => "numeric",
                    crate::types::PgType::Json => "json",
                    crate::types::PgType::Jsonb => "jsonb",
                    crate::types::PgType::Money => "money",
                    crate::types::PgType::Int4range => "int4range",