Function run_rtt_server_sqlx_benchmark

xtask/src/main.rs:4001–4056

(iterations: usize)

}

fn run_rtt_server_sqlx_benchmark(iterations: usize) -> Result<BenchmarkRun> {
    let open_started = Instant::now();
    let server = benchmark_pglite_server()?;
    let open_micros = open_started.elapsed().as_micros();
    let uri = server.database_url();
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .context("create benchmark Tokio runtime")?;

    let (connect_micros, setup_micros, tests) = runtime.block_on(async {
        let connect_started = Instant::now();
        let mut conn = sqlx::PgConnection::connect(&uri)
            .await
            .context("connect SQLx benchmark client")?;
        let connect_micros = connect_started.elapsed().as_micros();

        let setup_started = Instant::now();
        conn.execute(rtt_setup_sql())
            .await
            .context("execute RTT setup over SQLx")?;
        let setup_micros = setup_started.elapsed().as_micros();

        let mut tests = Vec::new();
        for case in rtt_cases() {
            let mut samples = Vec::with_capacity(iterations);
            for _ in 0..iterations {
                let started = Instant::now();
                conn.execute(case.sql.as_str())
                    .await
                    .with_context(|| format!("execute RTT benchmark {} over SQLx", case.id))?;
                samples.push(started.elapsed().as_micros());
            }
            tests.push(samples_result(
                case.id,
                format!("Test {}: {}", case.id, case.label),
                "milliseconds",
                iterations,
                samples,
            ));
        }
        conn.close().await.context("close SQLx benchmark client")?;
        Ok::<_, anyhow::Error>((connect_micros, setup_micros, tests))
    })?;
    server.shutdown()?;

    Ok(BenchmarkRun {
        suite: "rtt",
        mode: "server_sqlx",
        description: "PGliteServer over the Postgres wire protocol using one long-lived SQLx connection.",
        open_micros,
        connect_micros: Some(connect_micros),
        setup_micros,
        tests,
    })
}

fn run_rtt_server_tokio_postgres_simple_benchmark(iterations: usize) -> Result<BenchmarkRun> {