Method unroll_sql_execute

src/adapter/src/client.rs:846–977

If the named portal binds a SQL `EXECUTE `, resolve the prepared statement, install a fresh portal for the inner statement (carrying the EXECUTE's actual parameter values), and return that portal's name so the caller can run `try_frontend_peek` against it. Only ever unrolls one level: the parser rejects `PREPARE foo AS EXECUTE bar` (matching Postgres), so the inner statement is guarante

(
        &mut self,
        portal_name: String,
        outer_ctx_extra: &mut Option<ExecuteContextGuard>,
    )

    /// the caller can thread it into `try_frontend_peek`, which reuses it
    /// instead of taking its own.
    async fn unroll_sql_execute(
        &mut self,
        portal_name: String,
        outer_ctx_extra: &mut Option<ExecuteContextGuard>,
    ) -> Result<(String, Option<Arc<Catalog>>), AdapterError> {
        let (stmt, params, outer_logging, outer_lifecycle_timestamps) = {
            let session = self.session.as_ref().expect("SessionClient invariant");
            let portal = match session.get_portal_unverified(&portal_name) {
                Some(p) => p,
                // No portal: let `try_frontend_peek` surface the
                // standard "missing portal" error.
                None => return Ok((portal_name, None)),
            };
            match &portal.stmt {
                Some(stmt) => (
                    Arc::clone(stmt),
                    portal.parameters.clone(),
                    Arc::clone(&portal.logging),
                    portal.lifecycle_timestamps.clone(),
                ),
                None => return Ok((portal_name, None)),
            }
        };

        // Only EXECUTE statements need unrolling. Bail out before taking a
        // catalog snapshot in the (overwhelmingly common) non-EXECUTE case.
        if !matches!(&*stmt, Statement::Execute(_)) {
            return Ok((portal_name, None));
        }

        let catalog = self.catalog_snapshot("unroll_sql_execute").await;

        // Validate the outer EXECUTE portal against the (possibly newer)
        // catalog: ensures the recorded portal description still matches
        // what describing the EXECUTE would produce now.
        {
            let session = self.session.as_mut().expect("SessionClient invariant");
            Coordinator::verify_portal(&catalog, session, &portal_name)?;
        }

        // Bump query_total for the outer EXECUTE itself. The inner
        // statement gets its own increment inside `try_frontend_peek_inner`
        // (or, on bailout, in the coordinator's `handle_execute`).
        {
            let session = self.session.as_ref().expect("SessionClient invariant");
            session
                .metrics()
                .query_total(&[
                    metrics::session_type_label_value(session.user()),
                    metrics::statement_type_label_value(&stmt),
                ])
                .inc();
        }

        // Begin EXECUTE-level statement logging up front, so that planning
        // errors below produce an `Errored` end-event in
        // `mz_statement_execution_history` rather than no entry at all.
        //