Method handle_execute

nodedb/src/control/server/pgwire/handler/sql_prepared.rs:60–100

Handle `EXECUTE name [(value, ...)]`. Retrieves the prepared statement, substitutes parameter values into the SQL body, and executes through the standard pipeline. Uses `Box::pin` because this creates async recursion: `execute_sql` → `handle_execute` → `execute_sql` (with the substituted body). The substituted SQL is the PREPARE body (e.g., a SELECT), not another EXECUTE, so the recursion termin

(
        &'a self,
        identity: &'a AuthenticatedIdentity,
        addr: &'a std::net::SocketAddr,
        sql: &'a str,
    )

    /// The substituted SQL is the PREPARE body (e.g., a SELECT), not another EXECUTE,
    /// so the recursion terminates in one level.
    pub(super) fn handle_execute<'a>(
        &'a self,
        identity: &'a AuthenticatedIdentity,
        addr: &'a std::net::SocketAddr,
        sql: &'a str,
    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = PgWireResult<Vec<Response>>> + Send + 'a>>
    {
        Box::pin(async move {
            let (name, param_values) = parse_execute_statement(sql)?;

            let stmt = self.sessions.get_sql_prepared(addr, &name).ok_or_else(|| {
                PgWireError::UserError(Box::new(ErrorInfo::new(
                    "ERROR".to_owned(),
                    "26000".to_owned(),
                    format!("prepared statement \"{name}\" does not exist"),
                )))
            })?;

            // Validate parameter count.
            let expected_count = count_placeholders(&stmt.sql);
            if !param_values.is_empty() && param_values.len() != expected_count {
                return Err(PgWireError::UserError(Box::new(ErrorInfo::new(
                    "ERROR".to_owned(),
                    "08P01".to_owned(),
                    format!(
                        "wrong number of parameters for prepared statement \"{name}\": \
                         expected {expected_count}, got {}",
                        param_values.len()
                    ),
                ))));
            }

            // Substitute parameters into the SQL body.
            let final_sql = substitute_sql_params(&stmt.sql, &param_values);

            // Execute through the standard pipeline. The substituted SQL is the
            // PREPARE body (e.g., SELECT/INSERT), never another EXECUTE statement,
            // so this does not recurse further.
            self.execute_sql(identity, addr, &final_sql).await
        })
    }

    /// Handle `DEALLOCATE name` or `DEALLOCATE ALL`.
    pub(super) fn handle_deallocate(