Method encode_row

src/query/extended.rs:3780–4392

(
        row: &[Option<Vec<u8>>],
        result_formats: &[i16],
        field_types: &[i32],
    )

    }
    
    fn encode_row(
        row: &[Option<Vec<u8>>],
        result_formats: &[i16],
        field_types: &[i32],
    ) -> Result<Vec<Option<Vec<u8>>>, PgSqliteError> {
        info!("encode_row called with {} fields, {} result_formats, {} field_types",
              row.len(), result_formats.len(), field_types.len());
        info!("  result_formats: {:?}", result_formats);
        info!("  field_types: {:?}", field_types);

        // Log the first few values for debugging
        for (i, value) in row.iter().take(3).enumerate() {
            if let Some(bytes) = value {
                if let Ok(s) = std::str::from_utf8(bytes) {
                    debug!("  Field {}: '{}' (type OID {})", i, s, field_types.get(i).unwrap_or(&0));
                    // Extra debug for array types
                    if field_types.get(i).copied().unwrap_or(0) == 1007 {
                        info!("  DEBUG: Encoding INT4Array field {} with value '{}'", i, s);
                    }
                } else {
                    debug!("  Field {}: <binary data> (type OID {})", i, field_types.get(i).unwrap_or(&0));
                }
            } else {
                debug!("  Field {}: NULL (type OID {})", i, field_types.get(i).unwrap_or(&0));
            }
        }
        
        let mut encoded_row = Vec::new();
        
        for (i, value) in row.iter().enumerate() {
            // If result_formats has only one element, it applies to all columns
            let format = if result_formats.len() == 1 {
                result_formats[0]
            } else {
                result_formats.get(i).copied().unwrap_or(0)
            };
            let type_oid = field_types.get(i).copied().unwrap_or(PgType::Text.to_oid());
            
            
            let encoded_value = match value {
                None => None,
                Some(bytes) => {
                    if format == 1 {
                        // Binary format requested
                        match type_oid {
                            t if t == PgType::Bool.to_oid() => {
                                // bool - convert text to binary
                                if let Ok(s) = String::from_utf8(bytes.clone()) {
                                    let val = match s.trim() {
                                        "1" | "t" | "true" | "TRUE" | "T" => 1u8,
                                        "0" | "f" | "false" | "FALSE" | "F" => 0u8,
                                        _ => {
                                            // Invalid boolean, keep as text
                                            encoded_row.push(Some(bytes.clone()));
                                            continue;
                                        }
                                    };
                                    Some(vec![val])