Method execute_select

src/query/extended.rs:4394–5070

(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        portal_name: &str,
        query: &str,
        max_rows: i3

    }
    
    async fn execute_select<T>(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        portal_name: &str,
        query: &str,
        max_rows: i32,
    ) -> Result<(), PgSqliteError>
    where
        T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
    {
        // Check if this is a catalog query first
        info!("execute_select: Checking if query is catalog query: {}", query);
        if query.contains("int_array_with_nulls") {
            info!("DEBUG: execute_select called with array null query: {}", query);
        }
        let response = if let Some(catalog_result) = CatalogInterceptor::intercept_query(query, db.clone(), Some(session.clone())).await {
            info!("execute_select: Query intercepted by catalog handler");
            println!("EXTENDED: Got catalog result, about to unwrap");
            let mut catalog_response = catalog_result?;
            println!("EXTENDED: Unwrapped catalog result, columns: {}, rows: {}", catalog_response.columns.len(), catalog_response.rows.len());
            
            // For catalog queries with binary result formats, we need to ensure the data
            // is in the correct format for binary encoding
            let portals = session.portals.read().await;
            let portal = portals.get(portal_name).unwrap();
            let has_binary_format = portal.result_formats.contains(&1);
            println!("EXTENDED: result_formats = {:?}, has_binary_format = {}", portal.result_formats, has_binary_format);
            drop(portals);
            
            if has_binary_format {
                if query.contains("pg_attribute") {
                    info!("Converting catalog text data for binary encoding");
                    // pg_attribute specific handling - ensure numeric columns are properly formatted
                    for row in &mut catalog_response.rows {
                        // attnum is at index 5
                        if row.len() > 5
                            && let Some(Some(attnum_bytes)) = row.get_mut(5)
                                && let Ok(attnum_str) = String::from_utf8(attnum_bytes.clone()) {
                                    // Ensure it's just the numeric value without extra formatting
                                    *attnum_bytes = attnum_str.trim().as_bytes().to_vec();
                                }
                    }
                } else if query.contains("pg_database") {
                    info!("Converting pg_database boolean data for binary encoding");
                    // pg_database has boolean columns that need special handling
                    // They're stored as 'f'/'t' but need to be converted for binary format
                    // No conversion needed here - the binary encoder will handle 'f'/'t' for Bool type
                    println!("EXTENDED: pg_database binary format - boolean columns will be handled by encoder");
                } else if query.contains("information_schema") {
                    info!("Converting information_schema text data for binary encoding");
                    // For information_schema queries, the data is already in text format
                    // which is what binary encoding expects for text columns
                    // No additional conversion needed - the binary encoder will handle it
                    println!("EXTENDED: information_schema binary format - no conversion needed");
                }
            }