Method handle_execute

src/query/extended.rs:1261–1927

(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        portal: String,
        max_rows: i32,
    )

    }
    
    pub async fn handle_execute<T>(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        portal: String,
        max_rows: i32,
    ) -> Result<(), PgSqliteError>
    where
        T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
    {
        println!("EXTENDED: handle_execute called for portal: '{}'", portal);

        // Get the portal
        let (query, translated_query, bound_values, param_formats, result_formats, statement_name, inferred_param_types) = {
            let portals = session.portals.read().await;
            let portal_obj = portals.get(&portal)
                .ok_or_else(|| PgSqliteError::Protocol(format!("Unknown portal: {portal}")))?;
            
            (portal_obj.query.clone(),
             portal_obj.translated_query.clone(),
             portal_obj.bound_values.clone(),
             portal_obj.param_formats.clone(),
             portal_obj.result_formats.clone(),
             portal_obj.statement_name.clone(),
             portal_obj.inferred_param_types.clone())
        };
        
        // Special logging for orders queries
        if query.contains("orders") && query.contains("customer_id") {
            info!("EXECUTE: Orders query detected!");
            info!("EXECUTE: Query: {}", query);
            info!("EXECUTE: Statement name: {}", statement_name);
            
            // Check what field_descriptions are stored for this statement
            let statements = session.prepared_statements.read().await;
            
            // For unnamed statements, try both empty string and the actual value
            let stmt_opt = if statement_name.is_empty() {
                statements.get("")
                    .or_else(|| statements.get(&statement_name))
            } else {
                statements.get(&statement_name)
            };
            
            if let Some(stmt) = stmt_opt {
                info!("EXECUTE: Statement has {} field_descriptions", stmt.field_descriptions.len());
                for fd in &stmt.field_descriptions {
                    info!("EXECUTE:   {} -> type OID {}", fd.name, fd.type_oid);
                    if fd.name.contains("total_amount") && fd.type_oid == 25 {
                        info!("EXECUTE:   ^^^ BUG DETECTED: total_amount has TEXT type!");
                    }
                }
            } else {
                info!("EXECUTE: Statement not found! Available keys: {:?}", 
                      statements.keys().collect::<Vec<_>>());
            }
        }