Method send_protocol_inner

src/pglite/postgres_mod.rs:1231–1302

(&mut self, payload: &[u8])

    }

    fn send_protocol_inner(&mut self, payload: &[u8]) -> Result<Vec<u8>> {
        self.reset_backend_c_timings()?;

        {
            let _phase = timing::phase("postgres.protocol.input_reset");
            self.io.reset(&mut self.store)?;
        }
        {
            let _phase = timing::phase("postgres.protocol.input_write");
            self.io
                .push_input(&mut self.store, &self.env, &self.guest_allocator, payload)?;
        }

        {
            let _phase = timing::phase("postgres.protocol.dispatch_buffer");
            let max_attempts = (payload.len() / 5).saturating_add(2).max(1);
            let mut attempts = 0usize;
            let mut recovered_protocol_error = false;
            while self.protocol_input_remaining()? > 0 {
                attempts += 1;
                ensure!(
                    attempts <= max_attempts,
                    "Postgres protocol dispatch did not drain buffered input after {attempts} attempts"
                );
                if let Err(err) = self.protocol.main_loop.call(&mut self.store) {
                    if runtime_error_exit_code(&err) == Some(POSTGRES_MAIN_LONGJMP) {
                        debug!(
                            "PostgresMainLoopOnce used host longjmp fallback; recovering protocol error"
                        );
                        self.recover_protocol_error(payload.len())?;
                        recovered_protocol_error = true;
                    } else if is_wasm_uncaught_exception(&err) {
                        debug!(
                            "PostgresMainLoopOnce trapped for PostgreSQL error; recovering protocol state: {err}"
                        );
                        self.recover_protocol_error(payload.len())?;
                        recovered_protocol_error = true;
                    } else {
                        warn!("PostgresMainLoopOnce trapped; attempting protocol recovery: {err}");
                        self.recover_protocol_error(payload.len())?;
                        recovered_protocol_error = true;
                    }
                }
            }

            {
                let _phase = timing::phase("postgres.protocol.send_ready");
                self.protocol
                    .send_ready
                    .call(&mut self.store)
                    .context("PostgresSendReadyForQueryIfNecessary")?;
            }
            {
                let _phase = timing::phase("postgres.protocol.pq_flush");
                self.protocol
                    .pq_flush
                    .call(&mut self.store)
                    .context("pgl_pq_flush after protocol buffer")?;