Function run_speed_server_sqlx_benchmark

xtask/src/main.rs:4156–4203

(scale: f64, sql_source: SpeedSqlSource)

}

fn run_speed_server_sqlx_benchmark(scale: f64, sql_source: SpeedSqlSource) -> 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, tests) = runtime.block_on(async {
        let connect_started = Instant::now();
        let mut conn = sqlx::PgConnection::connect(&uri)
            .await
            .context("connect SQLx speed benchmark client")?;
        let connect_micros = connect_started.elapsed().as_micros();

        let mut tests = Vec::new();
        for case in speed_cases(scale, sql_source)? {
            let started = Instant::now();
            conn.execute(case.sql.as_str())
                .await
                .with_context(|| format!("execute speed benchmark {} over SQLx", case.id))?;
            tests.push(single_sample_result(
                case.id,
                case.label,
                "seconds",
                case.operation_count,
                started.elapsed(),
            ));
        }
        conn.close()
            .await
            .context("close SQLx speed benchmark client")?;
        Ok::<_, anyhow::Error>((connect_micros, tests))
    })?;
    server.shutdown()?;

    Ok(BenchmarkRun {
        suite: "speed",
        mode: "server_sqlx",
        description: "Generated SQLite speedtest-style SQL suite through one SQLx connection to PgliteServer.",
        open_micros,
        connect_micros: Some(connect_micros),
        setup_micros: 0,
        tests,
    })
}

fn benchmark_pglite_server() -> Result<PgliteServer> {
    PgliteServer::builder()