feat: custom "workspaces" for generated data (#109)

**Summary**: Instead of generating data (queries, schema, etc.) directly
inside the optd repo, we generate them inside a custom "workspace"
directory.

**Demo**:


https://github.com/cmu-db/optd/assets/20631215/56931dce-6ac0-499f-a968-dde34f103f70

**Details**:
* The current main use case of this is to run tests locally with a
"clean" workspace without needing to delete local files
* Workspaces are a CLI arg
* Relative paths are allowed and are interpreted relative to the root
directory of the optd repository using `parse_pathstr()`

Author: wangpatrick57

.gitignore

@@ -2,9 +2,4 @@
 /.vscode
 /.DS_Store
 /.idea
-.history
-optd-perftest/**/genned_tables
-optd-perftest/**/genned_queries
-optd-perftest/**/tpch-kit
-optd-perftest/**/pgdata
-optd-perftest/**/postgres_log
+.history

optd-perftest/src/main.rs

@@ -1,3 +1,5 @@
+use std::{fs, path::Path};
+
 use cardtest::{CardtestRunner, CardtestRunnerDBHelper};
 use clap::{Parser, Subcommand};
 use postgres_db::PostgresDb;
@@ -16,6 +18,12 @@ mod tpch;
 
 #[derive(Parser)]
 struct Cli {
+    #[arg(long)]
+    #[clap(default_value = "../optd_perftest_workspace")]
+    #[clap(
+        help = "The directory where artifacts required for performance testing (such as pgdata or TPC-H queries) are generated. See comment of parse_pathstr() to see what paths are allowed (TLDR: absolute and relative both ok)."
+    )]
+    workspace: String,
     #[command(subcommand)]
     command: Commands,
 }
@@ -37,20 +45,28 @@ async fn main() -> anyhow::Result<()> {
     env_logger::init();
     let cli = Cli::parse();
 
+    let workspace_dpath = shell::parse_pathstr(&cli.workspace)?;
+    if !workspace_dpath.exists() {
+        fs::create_dir(&workspace_dpath)?;
+    }
+
     match &cli.command {
         Commands::Cardtest { scale_factor, seed } => {
             let tpch_config = TpchConfig {
                 database: String::from(TPCH_KIT_POSTGRES),
                 scale_factor: *scale_factor,
                 seed: *seed,
             };
-            cardtest(tpch_config).await
+            cardtest(&workspace_dpath, tpch_config).await
         }
     }
 }
 
-async fn cardtest(tpch_config: TpchConfig) -> anyhow::Result<()> {
-    let pg_db = PostgresDb::build().await?;
+async fn cardtest<P: AsRef<Path>>(
+    workspace_dpath: P,
+    tpch_config: TpchConfig,
+) -> anyhow::Result<()> {
+    let pg_db = PostgresDb::build(workspace_dpath).await?;
     let databases: Vec<Box<dyn CardtestRunnerDBHelper>> = vec![Box::new(pg_db)];
 
     let tpch_benchmark = Benchmark::Tpch(tpch_config.clone());

optd-perftest/src/postgres_db.rs

@@ -7,7 +7,7 @@ use crate::{
 use async_trait::async_trait;
 use regex::Regex;
 use std::{
-    env::{self, consts::OS},
+    env::consts::OS,
     fs::{self, File},
     path::{Path, PathBuf},
     process::Command,
@@ -17,6 +17,7 @@ use tokio_postgres::{Client, NoTls};
 const OPTD_DBNAME: &str = "optd";
 
 pub struct PostgresDb {
+    workspace_dpath: PathBuf,
     // is an option because we need to initialize the struct before setting this
     client: Option<Client>,
 
@@ -32,17 +33,12 @@ pub struct PostgresDb {
 ///   - Stop and start functions should be separate
 ///   - Setup should be done in build() unless it requires more information (like benchmark)
 impl PostgresDb {
-    pub async fn build() -> anyhow::Result<Self> {
+    pub async fn build<P: AsRef<Path>>(workspace_dpath: P) -> anyhow::Result<Self> {
         log::debug!("[start] building PostgresDb");
 
         // build paths, sometimes creating them if they don't exist
-        let curr_dpath = env::current_dir()?;
-        let postgres_db_dpath = Path::new(file!())
-            .parent()
-            .unwrap()
-            .join("postgres_db")
-            .to_path_buf();
-        let postgres_db_dpath = curr_dpath.join(postgres_db_dpath); // make it absolute
+        let workspace_dpath = workspace_dpath.as_ref().to_path_buf();
+        let postgres_db_dpath = workspace_dpath.join("postgres_db");
         if !postgres_db_dpath.exists() {
             fs::create_dir(&postgres_db_dpath)?;
         }
@@ -51,6 +47,7 @@ impl PostgresDb {
 
         // create Self
         let mut db = PostgresDb {
+            workspace_dpath,
             client: None,
             _postgres_db_dpath: postgres_db_dpath,
             pgdata_dpath,
@@ -222,7 +219,7 @@ impl PostgresDb {
         // deleting pgdata would also delete the old connection so we have to reconnect
         self.connect_to_postgres().await?;
         // load the schema
-        let tpch_kit = TpchKit::build()?;
+        let tpch_kit = TpchKit::build(&self.workspace_dpath)?;
         shell::run_command_with_status_check(&format!(
             "psql {} -f {}",
             OPTD_DBNAME,
@@ -279,7 +276,7 @@ impl CardtestRunnerDBHelper for PostgresDb {
 /// This impl has helpers for ```impl CardtestRunnerDBHelper for PostgresDb```
 impl PostgresDb {
     async fn eval_tpch_estcards(&self, tpch_config: &TpchConfig) -> anyhow::Result<Vec<usize>> {
-        let tpch_kit = TpchKit::build()?;
+        let tpch_kit = TpchKit::build(&self.workspace_dpath)?;
         tpch_kit.gen_queries(tpch_config)?;
 
         let mut estcards = vec![];
@@ -293,7 +290,7 @@ impl PostgresDb {
     }
 
     async fn eval_tpch_truecards(&self, tpch_config: &TpchConfig) -> anyhow::Result<Vec<usize>> {
-        let tpch_kit = TpchKit::build()?;
+        let tpch_kit = TpchKit::build(&self.workspace_dpath)?;
         tpch_kit.gen_queries(tpch_config)?;
 
         let mut truecards = vec![];

optd-perftest/src/shell.rs

@@ -1,5 +1,6 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
+use std::str;
 use std::{fs, io};
 
 /// Runs a command, exiting the program immediately if the command fails
@@ -37,3 +38,22 @@ where
     }
     Ok(())
 }
+
+/// Get the path of the root "optd" repo directory
+pub fn get_optd_root() -> io::Result<PathBuf> {
+    let output = run_command_with_status_check("git rev-parse --show-toplevel")?;
+    let path = str::from_utf8(&output.stdout).unwrap().trim();
+    let path = PathBuf::from(path);
+    Ok(path)
+}
+
+/// Can be an absolute path or a relative path. Regardless of where this CLI is run, relative paths are evaluated relative to the optd repo root.
+pub fn parse_pathstr(pathstr: &str) -> io::Result<PathBuf> {
+    let path = PathBuf::from(pathstr);
+    let path = if path.is_relative() {
+        get_optd_root()?.join(path)
+    } else {
+        path
+    };
+    Ok(path)
+}

optd-perftest/src/tpch.rs

@@ -30,8 +30,9 @@ impl TpchConfig {
 /// Since it's conceptually a wrapper around the repo, I chose _not_ to make
 ///   TpchConfig an initialization parameter.
 pub struct TpchKit {
+    _workspace_dpath: PathBuf,
+
     // cache these paths so we don't have to build them multiple times
-    optd_repo_dpath: PathBuf,
     _tpch_dpath: PathBuf,
     tpch_kit_repo_dpath: PathBuf,
     queries_dpath: PathBuf,
@@ -43,20 +44,14 @@ pub struct TpchKit {
 
 /// I keep the same conventions for these methods as I do for PostgresDb
 impl TpchKit {
-    pub fn build() -> io::Result<Self> {
+    pub fn build<P: AsRef<Path>>(workspace_dpath: P) -> io::Result<Self> {
         log::debug!("[start] building TpchKit");
 
         // build paths, sometimes creating them if they don't exist
-        // we assume that this is being run in the base optd repo dir
-        let optd_repo_dpath = env::current_dir()?;
-        let tpch_dpath = Path::new(file!())
-            .parent()
-            .unwrap()
-            .join("tpch")
-            .to_path_buf();
-        let tpch_dpath = optd_repo_dpath.join(tpch_dpath); // make tpch_dpath absolute
+        let workspace_dpath = workspace_dpath.as_ref().to_path_buf();
+        let tpch_dpath = workspace_dpath.join("tpch");
         if !tpch_dpath.exists() {
-            fs::create_dir(&tpch_dpath).unwrap_or_else(|_| panic!("tpch_dpath ({:?}) doesn't exist. make sure that the current dir is the base repo dir. right now, the current dir is {:?}", tpch_dpath, optd_repo_dpath));
+            fs::create_dir(&tpch_dpath)?;
         }
         let tpch_kit_repo_dpath = tpch_dpath.join("tpch-kit");
         let dbgen_dpath = tpch_kit_repo_dpath.join("dbgen");
@@ -73,7 +68,7 @@ impl TpchKit {
 
         // create Self
         let kit = TpchKit {
-            optd_repo_dpath,
+            _workspace_dpath: workspace_dpath,
             _tpch_dpath: tpch_dpath,
             tpch_kit_repo_dpath,
             queries_dpath,
@@ -94,10 +89,6 @@ impl TpchKit {
         Ok(kit)
     }
 
-    fn cd_to_optd(&self) -> io::Result<()> {
-        env::set_current_dir(&self.optd_repo_dpath)
-    }
-
     fn clonepull_tpch_kit_repo(&self) -> io::Result<()> {
         if !self.tpch_kit_repo_dpath.exists() {
             log::debug!("[start] cloning tpch-kit repo");
@@ -114,7 +105,7 @@ impl TpchKit {
         log::debug!("[start] pulling latest tpch-kit repo");
         shell::run_command_with_status_check("git pull")?;
         log::debug!("[end] pulling latest tpch-kit repo");
-        self.cd_to_optd()
+        Ok(())
     }
 
     fn build_dbgen(&self, database: &str) -> io::Result<()> {
@@ -126,7 +117,7 @@ impl TpchKit {
             database
         ))?;
         log::debug!("[end] building dbgen");
-        self.cd_to_optd()
+        Ok(())
     }
 
     fn get_machine() -> &'static str {
@@ -155,7 +146,6 @@ impl TpchKit {
                 "./dbgen -s{}",
                 tpch_config.scale_factor
             ))?;
-            self.cd_to_optd()?;
             File::create(done_fpath)?;
             log::debug!("[end] generating tables for {}", tpch_config.get_stringid());
         } else {
@@ -189,7 +179,6 @@ impl TpchKit {
                     this_genned_queries_dpath.join(format!("{}.sql", query_i));
                 fs::write(&this_genned_queries_fpath, output.stdout)?;
             }
-            self.cd_to_optd()?;
             File::create(done_fpath)?;
             log::debug!(
                 "[end] generating queries for {}",