Function sql

benchmarks/benches/sql.rs:88–162

(c: &mut Criterion)

}

pub fn sql(c: &mut Criterion) {
    env_logger::init();

    let start = Instant::now();
    let args = EnvParser::parse();
    let rt = make_tokio_runtime();

    println!("Loading benchmarks...");

    let benchmarks = rt.block_on(async {
        let ctx = make_ctx(&args).expect("SessionContext creation failed");

        load_benchmarks(&args, &ctx, &SQL_BENCHMARK_DIRECTORY)
            .await
            .unwrap_or_else(|err| panic!("failed load benchmarks: {err:?}"))
    });

    println!(
        "Loaded benchmarks in {} ms ...",
        start.elapsed().as_millis()
    );

    for (group, benchmarks) in benchmarks {
        let mut group = c.benchmark_group(group);
        group.sample_size(10);
        group.sampling_mode(SamplingMode::Flat);

        for mut benchmark in benchmarks {
            // create a context
            let ctx = make_ctx(&args).expect("SessionContext creation failed");

            // initialize the benchmark. This parses the benchmark file and does any pre-execution
            // work such as loading data into tables
            rt.block_on(async {
                benchmark
                    .initialize(&ctx)
                    .await
                    .expect("initialization failed");

                // run assertions
                benchmark.assert(&ctx).await.expect("assertion failed");
            });

            let mut name = benchmark.name().to_string();
            if !benchmark.subgroup().is_empty() {
                name.push('_');
                name.push_str(benchmark.subgroup());
            }

            if args.persist_results {
                handle_persist(&rt, &ctx, &name, &mut benchmark);
            } else if args.validate {
                handle_verify(&rt, &ctx, &name, &mut benchmark);
            } else {
                info!("Running benchmark {name} ...");

                let name = name.clone();
                group.bench_function(name.clone(), |b| {