Method recover_protocol_error

src/pglite/postgres_mod.rs:1486–1522

(&mut self, payload_len: usize)

    }

    fn recover_protocol_error(&mut self, payload_len: usize) -> Result<()> {
        self.protocol
            .recover_error
            .call(&mut self.store)
            .context("PostgresMainLongJmp after protocol trap")?;

        // PostgreSQL extended-query errors skip messages until Sync. If Sync was
        // already in this host buffer, re-enter the loop to drain it and produce
        // ReadyForQuery from PostgreSQL rather than inventing one in Rust.
        let max_drain_attempts = (payload_len / 5).saturating_add(2).max(1);
        let mut drain_attempts = 0usize;
        while self.protocol_input_remaining()? > 0 {
            drain_attempts += 1;
            ensure!(
                drain_attempts <= max_drain_attempts,
                "Postgres protocol recovery did not drain buffered input after {drain_attempts} attempts"
            );
            if let Err(drain_err) = self.protocol.main_loop.call(&mut self.store) {
                if runtime_error_exit_code(&drain_err) == Some(POSTGRES_MAIN_LONGJMP)
                    || is_wasm_uncaught_exception(&drain_err)
                {
                    debug!(
                        "PostgresMainLoopOnce trapped while draining after PostgreSQL error recovery: {drain_err}"
                    );
                } else {
                    warn!(
                        "PostgresMainLoopOnce trapped while draining after recovery: {drain_err}"
                    );
                }
                self.protocol
                    .recover_error
                    .call(&mut self.store)
                    .context("PostgresMainLongJmp while draining after protocol trap")?;
            }
        }
        Ok(())
    }

    fn recover_non_trapping_protocol_error(&mut self) -> Result<()> {
        self.protocol