Method store_create_table_metadata

src/session/db_handler.rs:2750–2829

Store CREATE TABLE metadata including type mappings and numeric constraints

(
        &self,
        conn: &rusqlite::Connection,
        table_name: &str,
        type_mappings: &std::collections::HashMap<String, crate::metadata::TypeMapping>
    )

    /// Store CREATE TABLE metadata including type mappings and numeric constraints
    fn store_create_table_metadata(
        &self,
        conn: &rusqlite::Connection,
        table_name: &str,
        type_mappings: &std::collections::HashMap<String, crate::metadata::TypeMapping>
    ) -> Result<(), rusqlite::Error> {
        debug!("Storing CREATE TABLE metadata: {} type mappings found", type_mappings.len());

        // Initialize the metadata table if it doesn't exist
        let init_query = "CREATE TABLE IF NOT EXISTS __pgsqlite_schema (
            table_name TEXT NOT NULL,
            column_name TEXT NOT NULL,
            pg_type TEXT NOT NULL,
            sqlite_type TEXT NOT NULL,
            PRIMARY KEY (table_name, column_name)
        )";

        conn.execute(init_query, [])?;

        // Initialize numeric constraints table if it doesn't exist
        let init_numeric_query = "CREATE TABLE IF NOT EXISTS __pgsqlite_numeric_constraints (
            table_name TEXT NOT NULL,
            column_name TEXT NOT NULL,
            precision INTEGER NOT NULL,
            scale INTEGER NOT NULL,
            PRIMARY KEY (table_name, column_name)
        )";

        conn.execute(init_numeric_query, [])?;

        // Store each type mapping
        for (full_column, type_mapping) in type_mappings {
            // Split table.column format
            let parts: Vec<&str> = full_column.split('.').collect();
            if parts.len() == 2 && parts[0] == table_name {
                let insert_query = format!(
                    "INSERT OR REPLACE INTO __pgsqlite_schema (table_name, column_name, pg_type, sqlite_type) VALUES ('{}', '{}', '{}', '{}')",
                    table_name, parts[1], type_mapping.pg_type, type_mapping.sqlite_type
                );

                if let Err(e) = conn.execute(&insert_query, []) {
                    debug!("Failed to store metadata for {}.{}: {}", table_name, parts[1], e);
                } else {
                    debug!("Stored metadata: {}.{} -> {} ({})", table_name, parts[1], type_mapping.pg_type, type_mapping.sqlite_type);
                }

                // Store numeric constraints if present
                debug!("Checking for numeric constraints: pg_type={}, modifier={:?}", type_mapping.pg_type, type_mapping.type_modifier);
                if let Some(modifier) = type_mapping.type_modifier {
                    // Extract base type without parameters
                    let base_type = if let Some(paren_pos) = type_mapping.pg_type.find('(') {
                        type_mapping.pg_type[..paren_pos].trim()
                    } else {
                        &type_mapping.pg_type
                    };
                    let pg_type_lower = base_type.to_lowercase();

                    if pg_type_lower == "numeric" || pg_type_lower == "decimal" {