Method analyze_insert_params

src/query/extended.rs:5716–5776

Analyze INSERT query to determine parameter types from schema

(query: &str, db: &Arc<DbHandler>)

    
    /// Analyze INSERT query to determine parameter types from schema
    async fn analyze_insert_params(query: &str, db: &Arc<DbHandler>) -> Result<(Vec<i32>, Vec<i32>), PgSqliteError> {
        // Use QueryContextAnalyzer to extract table and column info
        let (table_name, columns) = crate::types::QueryContextAnalyzer::get_insert_column_info(query)
            .ok_or_else(|| PgSqliteError::Protocol("Failed to parse INSERT query".to_string()))?;
        
        info!("Analyzing INSERT for table '{}' with columns: {:?}", table_name, columns);
        
        // Get cached table schema
        let table_schema = db.get_table_schema(&table_name).await
            .map_err(|e| PgSqliteError::Protocol(format!("Failed to get table schema: {e}")))?;
        
        // If no explicit columns, use all columns from the table
        let columns = if columns.is_empty() {
            table_schema.columns.iter()
                .map(|col| col.name.clone())
                .collect()
        } else {
            columns
        };
        
        // Look up types for each column using cached schema
        let mut param_types = Vec::new();
        let mut original_types = Vec::new();
        for column in &columns {
            if let Some(col_info) = table_schema.column_map.get(&column.to_lowercase()) {
                original_types.push(col_info.pg_oid);
                
                // For certain PostgreSQL types that tokio-postgres doesn't support in binary format,
                // use TEXT as the parameter type to allow string representation
                let param_oid = match col_info.pg_oid {
                    t if t == PgType::Macaddr8.to_oid() => PgType::Text.to_oid(), // MACADDR8 -> TEXT
                    t if t == PgType::Macaddr.to_oid() => PgType::Text.to_oid(), // MACADDR -> TEXT  
                    t if t == PgType::Inet.to_oid() => PgType::Text.to_oid(), // INET -> TEXT
                    t if t == PgType::Cidr.to_oid() => PgType::Text.to_oid(), // CIDR -> TEXT
                    t if t == PgType::Money.to_oid() => PgType::Text.to_oid(), // MONEY -> TEXT
                    t if t == PgType::Int4range.to_oid() => PgType::Text.to_oid(), // INT4RANGE -> TEXT
                    t if t == PgType::Int8range.to_oid() => PgType::Text.to_oid(), // INT8RANGE -> TEXT
                    t if t == PgType::Numrange.to_oid() => PgType::Text.to_oid(), // NUMRANGE -> TEXT
                    t if t == PgType::Bit.to_oid() => PgType::Text.to_oid(), // BIT -> TEXT
                    t if t == PgType::Varbit.to_oid() => PgType::Text.to_oid(), // VARBIT -> TEXT
                    _ => col_info.pg_oid, // Use original OID for supported types
                };
                
                param_types.push(param_oid);
                if param_oid != col_info.pg_oid {
                    info!("Mapped parameter type for {}.{}: {} (OID {}) -> TEXT (OID 25) for binary protocol compatibility", 
                          table_name, column, col_info.pg_type, col_info.pg_oid);
                } else {
                    info!("Found cached type for {}.{}: {} (OID {})", 
                          table_name, column, col_info.pg_type, col_info.pg_oid);
                }
            } else {
                // Default to text if column not found
                param_types.push(PgType::Text.to_oid());
                original_types.push(PgType::Text.to_oid());
                info!("Column {}.{} not found in schema, defaulting to text", table_name, column);
            }
        }