Method run

benchmarks/src/dict.rs:313–359

(self)

}
impl RunOpt {
    pub async fn run(self) -> Result<()> {
        println!(
            "Running dictionary encoding benchmarks with the following options: {self:#?}\n"
        );

        let query_range = match self.query {
            Some(query_id) => {
                if query_id >= 1 && query_id <= DICTIONARY_QUERIES.len() {
                    query_id..=query_id
                } else {
                    return exec_err!(
                        "Query {query_id} not found. Available queries: 1 to {}",
                        DICTIONARY_QUERIES.len()
                    );
                }
            }
            None => 1..=DICTIONARY_QUERIES.len(),
        };

        let config = self.common.config()?;
        let rt = self.common.build_runtime()?;
        let ctx = SessionContext::new_with_config_rt(config, rt);
        let mut benchmark_run = BenchmarkRun::new();

        for query_id in query_range {
            let query = &DICTIONARY_QUERIES[query_id - 1];
            benchmark_run.start_new_case(query.name);

            let query_run = self.benchmark_query(query, &ctx).await;
            match query_run {
                Ok(query_results) => {
                    for iter in query_results {
                        benchmark_run.write_iter(iter.elapsed, iter.row_count);
                    }
                }
                Err(e) => {
                    return Err(DataFusionError::Context(
                        format!("Dictionary benchmark '{}' failed:", query.name),
                        Box::new(e),
                    ));
                }
            }
        }

        benchmark_run.maybe_write_json(self.output_path.as_ref())?;
        Ok(())
    }

    async fn benchmark_query(
        &self,