dpath -> path

Author: patrickhyw

benchmark/job/load_info.py

@@ -37,7 +37,7 @@ class JobLoadInfo(LoadInfoBaseClass):
 
     def __init__(self, dbgym_workspace: DBGymWorkspace):
         # Schema (directly in the codebase).
-        job_codebase_path = dbgym_workspace.base_dbgym_repo_dpath / "benchmark" / "job"
+        job_codebase_path = dbgym_workspace.base_dbgym_repo_path / "benchmark" / "job"
         self._schema_path = job_codebase_path / JOB_SCHEMA_FNAME
         assert (
             self._schema_path.exists()

benchmark/tpch/cli.py

@@ -101,41 +101,41 @@ def _get_queries_dirname(seed: int, scale_factor: float) -> str:
 
 
 def _clone_tpch_kit(dbgym_workspace: DBGymWorkspace) -> None:
-    expected_symlink_dpath = dbgym_workspace.dbgym_cur_symlinks_path / (
+    expected_symlink_path = dbgym_workspace.dbgym_cur_symlinks_path / (
         TPCH_KIT_DIRNAME + ".link"
     )
-    if expected_symlink_dpath.exists():
+    if expected_symlink_path.exists():
         logging.getLogger(DBGYM_LOGGER_NAME).info(
-            f"Skipping clone: {expected_symlink_dpath}"
+            f"Skipping clone: {expected_symlink_path}"
         )
         return
 
-    logging.getLogger(DBGYM_LOGGER_NAME).info(f"Cloning: {expected_symlink_dpath}")
+    logging.getLogger(DBGYM_LOGGER_NAME).info(f"Cloning: {expected_symlink_path}")
     subprocess_run(
         f"./clone_tpch_kit.sh {dbgym_workspace.dbgym_this_run_path}",
-        cwd=dbgym_workspace.base_dbgym_repo_dpath / "benchmark" / "tpch",
+        cwd=dbgym_workspace.base_dbgym_repo_path / "benchmark" / "tpch",
     )
-    symlink_dpath = dbgym_workspace.link_result(
+    symlink_path = dbgym_workspace.link_result(
         dbgym_workspace.dbgym_this_run_path / TPCH_KIT_DIRNAME
     )
-    assert expected_symlink_dpath.samefile(symlink_dpath)
-    logging.getLogger(DBGYM_LOGGER_NAME).info(f"Cloned: {expected_symlink_dpath}")
+    assert expected_symlink_path.samefile(symlink_path)
+    logging.getLogger(DBGYM_LOGGER_NAME).info(f"Cloned: {expected_symlink_path}")
 
 
 def _generate_tpch_queries(
     dbgym_workspace: DBGymWorkspace, seed_start: int, seed_end: int, scale_factor: float
 ) -> None:
-    tpch_kit_dpath = dbgym_workspace.dbgym_cur_symlinks_path / (
+    tpch_kit_path = dbgym_workspace.dbgym_cur_symlinks_path / (
         TPCH_KIT_DIRNAME + ".link"
     )
     logging.getLogger(DBGYM_LOGGER_NAME).info(
         f"Generating queries: [{seed_start}, {seed_end}]"
     )
     for seed in range(seed_start, seed_end + 1):
-        expected_queries_symlink_dpath = dbgym_workspace.dbgym_cur_symlinks_path / (
+        expected_queries_symlink_path = dbgym_workspace.dbgym_cur_symlinks_path / (
             _get_queries_dirname(seed, scale_factor) + ".link"
         )
-        if expected_queries_symlink_dpath.exists():
+        if expected_queries_symlink_path.exists():
             continue
 
         queries_parent_path = (
@@ -147,43 +147,43 @@ def _generate_tpch_queries(
             target_sql = (queries_parent_path / f"{i}.sql").resolve()
             subprocess_run(
                 f"DSS_QUERY=./queries ./qgen {i} -r {seed} -s {scale_factor} > {target_sql}",
-                cwd=tpch_kit_dpath / "dbgen",
+                cwd=tpch_kit_path / "dbgen",
                 verbose=False,
             )
-        queries_symlink_dpath = dbgym_workspace.link_result(queries_parent_path)
-        assert queries_symlink_dpath.samefile(expected_queries_symlink_dpath)
+        queries_symlink_path = dbgym_workspace.link_result(queries_parent_path)
+        assert queries_symlink_path.samefile(expected_queries_symlink_path)
     logging.getLogger(DBGYM_LOGGER_NAME).info(
         f"Generated queries: [{seed_start}, {seed_end}]"
     )
 
 
 def _generate_tpch_tables(dbgym_workspace: DBGymWorkspace, scale_factor: float) -> None:
-    tpch_kit_dpath = dbgym_workspace.dbgym_cur_symlinks_path / (
+    tpch_kit_path = dbgym_workspace.dbgym_cur_symlinks_path / (
         TPCH_KIT_DIRNAME + ".link"
     )
-    expected_tables_symlink_dpath = get_tables_symlink_path(
+    expected_tables_symlink_path = get_tables_symlink_path(
         dbgym_workspace.dbgym_workspace_path, "tpch", scale_factor
     )
-    if expected_tables_symlink_dpath.exists():
+    if expected_tables_symlink_path.exists():
         logging.getLogger(DBGYM_LOGGER_NAME).info(
-            f"Skipping generation: {expected_tables_symlink_dpath}"
+            f"Skipping generation: {expected_tables_symlink_path}"
         )
         return
 
     logging.getLogger(DBGYM_LOGGER_NAME).info(
-        f"Generating: {expected_tables_symlink_dpath}"
+        f"Generating: {expected_tables_symlink_path}"
     )
-    subprocess_run(f"./dbgen -vf -s {scale_factor}", cwd=tpch_kit_dpath / "dbgen")
+    subprocess_run(f"./dbgen -vf -s {scale_factor}", cwd=tpch_kit_path / "dbgen")
     tables_parent_path = dbgym_workspace.dbgym_this_run_path / get_tables_dirname(
         "tpch", scale_factor
     )
     tables_parent_path.mkdir(parents=False, exist_ok=False)
-    subprocess_run(f"mv ./*.tbl {tables_parent_path}", cwd=tpch_kit_dpath / "dbgen")
+    subprocess_run(f"mv ./*.tbl {tables_parent_path}", cwd=tpch_kit_path / "dbgen")
 
-    tables_symlink_dpath = dbgym_workspace.link_result(tables_parent_path)
-    assert tables_symlink_dpath.samefile(expected_tables_symlink_dpath)
+    tables_symlink_path = dbgym_workspace.link_result(tables_parent_path)
+    assert tables_symlink_path.samefile(expected_tables_symlink_path)
     logging.getLogger(DBGYM_LOGGER_NAME).info(
-        f"Generated: {expected_tables_symlink_dpath}"
+        f"Generated: {expected_tables_symlink_path}"
     )
 
 

benchmark/tpch/load_info.py

@@ -25,7 +25,7 @@ class TpchLoadInfo(LoadInfoBaseClass):
     def __init__(self, dbgym_workspace: DBGymWorkspace, scale_factor: float):
         # Schema and constraints (directly in the codebase).
         tpch_codebase_path = (
-            dbgym_workspace.base_dbgym_repo_dpath / "benchmark" / "tpch"
+            dbgym_workspace.base_dbgym_repo_path / "benchmark" / "tpch"
         )
         self._schema_path = tpch_codebase_path / TPCH_SCHEMA_FNAME
         assert (

dbms/postgres/_build_repo.sh

@@ -2,40 +2,40 @@
 
 set -euxo pipefail
 
-REPO_REAL_PARENT_DPATH="$1"
+REPO_REAL_PARENT_path="$1"
 
 # Download and make postgres from the boot repository.
-mkdir -p "${REPO_REAL_PARENT_DPATH}"
-cd "${REPO_REAL_PARENT_DPATH}"
+mkdir -p "${REPO_REAL_PARENT_path}"
+cd "${REPO_REAL_PARENT_path}"
 git clone https://github.com/lmwnshn/boot.git --single-branch --branch vldb_2024 --depth 1
 cd ./boot
-./cmudb/build/configure.sh release "${REPO_REAL_PARENT_DPATH}/boot/build/postgres"
+./cmudb/build/configure.sh release "${REPO_REAL_PARENT_path}/boot/build/postgres"
 make clean
 make install-world-bin -j4
 
 # Download and make boot.
 cd ./cmudb/extension/boot_rs/
 cargo build --release
 cbindgen . -o target/boot_rs.h --lang c
-cd "${REPO_REAL_PARENT_DPATH}/boot"
+cd "${REPO_REAL_PARENT_path}/boot"
 
 cd ./cmudb/extension/boot/
 make clean
 make install -j
-cd "${REPO_REAL_PARENT_DPATH}/boot"
+cd "${REPO_REAL_PARENT_path}/boot"
 
 # Download and make hypopg.
 git clone https://github.com/HypoPG/hypopg.git
 cd ./hypopg
-PG_CONFIG="${REPO_REAL_PARENT_DPATH}/boot/build/postgres/bin/pg_config" make install
-cd "${REPO_REAL_PARENT_DPATH}/boot"
+PG_CONFIG="${REPO_REAL_PARENT_path}/boot/build/postgres/bin/pg_config" make install
+cd "${REPO_REAL_PARENT_path}/boot"
 
 # Download and make pg_hint_plan.
 # We need -L to follow links.
 curl -L https://github.com/ossc-db/pg_hint_plan/archive/refs/tags/REL15_1_5_1.tar.gz -o REL15_1_5_1.tar.gz
 tar -xzf REL15_1_5_1.tar.gz
 rm REL15_1_5_1.tar.gz
 cd ./pg_hint_plan-REL15_1_5_1
-PATH="${REPO_REAL_PARENT_DPATH}/boot/build/postgres/bin:$PATH" make
-PATH="${REPO_REAL_PARENT_DPATH}/boot/build/postgres/bin:$PATH" make install
-cp ./pg_hint_plan.so ${REPO_REAL_PARENT_DPATH}/boot/build/postgres/lib
+PATH="${REPO_REAL_PARENT_path}/boot/build/postgres/bin:$PATH" make
+PATH="${REPO_REAL_PARENT_path}/boot/build/postgres/bin:$PATH" make install
+cp ./pg_hint_plan.so ${REPO_REAL_PARENT_path}/boot/build/postgres/lib

dbms/postgres/cli.py

@@ -38,7 +38,7 @@
     WORKSPACE_PATH_PLACEHOLDER,
     DBGymWorkspace,
     fully_resolve_path,
-    get_default_dbdata_parent_dpath,
+    get_default_dbdata_parent_path,
     is_fully_resolved,
     is_ssd,
 )
@@ -68,30 +68,30 @@ def _postgres_build(dbgym_workspace: DBGymWorkspace, rebuild: bool) -> None:
     """
     This function exists as a hook for integration tests.
     """
-    expected_repo_symlink_dpath = get_repo_symlink_path(
+    expected_repo_symlink_path = get_repo_symlink_path(
         dbgym_workspace.dbgym_workspace_path
     )
-    if not rebuild and expected_repo_symlink_dpath.exists():
+    if not rebuild and expected_repo_symlink_path.exists():
         logging.getLogger(DBGYM_LOGGER_NAME).info(
-            f"Skipping _postgres_build: {expected_repo_symlink_dpath}"
+            f"Skipping _postgres_build: {expected_repo_symlink_path}"
         )
         return
 
     logging.getLogger(DBGYM_LOGGER_NAME).info(
-        f"Setting up repo in {expected_repo_symlink_dpath}"
+        f"Setting up repo in {expected_repo_symlink_path}"
     )
-    repo_real_dpath = dbgym_workspace.dbgym_this_run_path / "repo"
-    repo_real_dpath.mkdir(parents=False, exist_ok=False)
+    repo_real_path = dbgym_workspace.dbgym_this_run_path / "repo"
+    repo_real_path.mkdir(parents=False, exist_ok=False)
     subprocess_run(
-        f"./_build_repo.sh {repo_real_dpath}",
-        cwd=dbgym_workspace.base_dbgym_repo_dpath / "dbms" / "postgres",
+        f"./_build_repo.sh {repo_real_path}",
+        cwd=dbgym_workspace.base_dbgym_repo_path / "dbms" / "postgres",
     )
 
     # only link at the end so that the link only ever points to a complete repo
-    repo_symlink_dpath = dbgym_workspace.link_result(repo_real_dpath)
-    assert expected_repo_symlink_dpath.samefile(repo_symlink_dpath)
+    repo_symlink_path = dbgym_workspace.link_result(repo_real_path)
+    assert expected_repo_symlink_path.samefile(repo_symlink_path)
     logging.getLogger(DBGYM_LOGGER_NAME).info(
-        f"Set up repo in {expected_repo_symlink_dpath}"
+        f"Set up repo in {expected_repo_symlink_path}"
     )
 
 
@@ -112,29 +112,29 @@ def _postgres_build(dbgym_workspace: DBGymWorkspace, rebuild: bool) -> None:
     "--intended-dbdata-hardware",
     type=click.Choice(["hdd", "ssd"]),
     default="hdd",
-    help=f"The intended hardware dbdata should be on. Used as a sanity check for --dbdata-parent-dpath.",
+    help=f"The intended hardware dbdata should be on. Used as a sanity check for --dbdata-parent-path.",
 )
 @click.option(
-    "--dbdata-parent-dpath",
+    "--dbdata-parent-path",
     default=None,
     type=Path,
-    help=f"The path to the parent directory of the dbdata which will be actively tuned. The default is {get_default_dbdata_parent_dpath(WORKSPACE_PATH_PLACEHOLDER)}.",
+    help=f"The path to the parent directory of the dbdata which will be actively tuned. The default is {get_default_dbdata_parent_path(WORKSPACE_PATH_PLACEHOLDER)}.",
 )
 def postgres_dbdata(
     dbgym_workspace: DBGymWorkspace,
     benchmark_name: str,
     scale_factor: float,
     pgbin_path: Optional[Path],
     intended_dbdata_hardware: str,
-    dbdata_parent_dpath: Optional[Path],
+    dbdata_parent_path: Optional[Path],
 ) -> None:
     _postgres_dbdata(
         dbgym_workspace,
         benchmark_name,
         scale_factor,
         pgbin_path,
         intended_dbdata_hardware,
-        dbdata_parent_dpath,
+        dbdata_parent_path,
     )
 
 
@@ -144,38 +144,38 @@ def _postgres_dbdata(
     scale_factor: float,
     pgbin_path: Optional[Path],
     intended_dbdata_hardware: str,
-    dbdata_parent_dpath: Optional[Path],
+    dbdata_parent_path: Optional[Path],
 ) -> None:
     """
     This function exists as a hook for integration tests.
     """
     # Set args to defaults programmatically (do this before doing anything else in the function)
     if pgbin_path is None:
         pgbin_path = get_pgbin_symlink_path(dbgym_workspace.dbgym_workspace_path)
-    if dbdata_parent_dpath is None:
-        dbdata_parent_dpath = get_default_dbdata_parent_dpath(
+    if dbdata_parent_path is None:
+        dbdata_parent_path = get_default_dbdata_parent_path(
             dbgym_workspace.dbgym_workspace_path
         )
 
     # Fully resolve all input paths.
     pgbin_path = fully_resolve_path(pgbin_path)
-    dbdata_parent_dpath = fully_resolve_path(dbdata_parent_dpath)
+    dbdata_parent_path = fully_resolve_path(dbdata_parent_path)
 
     # Check assertions on args
     if intended_dbdata_hardware == "hdd":
         assert not is_ssd(
-            dbdata_parent_dpath
-        ), f"Intended hardware is HDD but dbdata_parent_dpath ({dbdata_parent_dpath}) is an SSD"
+            dbdata_parent_path
+        ), f"Intended hardware is HDD but dbdata_parent_path ({dbdata_parent_path}) is an SSD"
     elif intended_dbdata_hardware == "ssd":
         assert is_ssd(
-            dbdata_parent_dpath
-        ), f"Intended hardware is SSD but dbdata_parent_dpath ({dbdata_parent_dpath}) is an HDD"
+            dbdata_parent_path
+        ), f"Intended hardware is SSD but dbdata_parent_path ({dbdata_parent_path}) is an HDD"
     else:
         assert False
 
     # Create dbdata
     _create_dbdata(
-        dbgym_workspace, benchmark_name, scale_factor, pgbin_path, dbdata_parent_dpath
+        dbgym_workspace, benchmark_name, scale_factor, pgbin_path, dbdata_parent_path
     )
 
 
@@ -184,7 +184,7 @@ def _create_dbdata(
     benchmark_name: str,
     scale_factor: float,
     pgbin_path: Path,
-    dbdata_parent_dpath: Path,
+    dbdata_parent_path: Path,
 ) -> None:
     """
     If you change the code of _create_dbdata(), you should also delete the symlink so that the next time you run
@@ -202,13 +202,13 @@ def _create_dbdata(
         return
 
     # It's ok for the dbdata/ directory to be temporary. It just matters that the .tgz is saved in a safe place.
-    dbdata_path = dbdata_parent_dpath / "dbdata_being_created"
-    # We might be reusing the same dbdata_parent_dpath, so delete dbdata_path if it already exists
+    dbdata_path = dbdata_parent_path / "dbdata_being_created"
+    # We might be reusing the same dbdata_parent_path, so delete dbdata_path if it already exists
     if dbdata_path.exists():
         shutil.rmtree(dbdata_path)
 
     # Call initdb.
-    # Save any script we call from pgbin_symlink_dpath because they are dependencies generated from another task run.
+    # Save any script we call from pgbin_symlink_path because they are dependencies generated from another task run.
     dbgym_workspace.save_file(pgbin_path / "initdb")
     subprocess_run(f'./initdb -D "{dbdata_path}"', cwd=pgbin_path)
 
@@ -242,23 +242,23 @@ def _create_dbdata(
 
 def _generic_dbdata_setup(dbgym_workspace: DBGymWorkspace) -> None:
     # get necessary vars
-    pgbin_real_dpath = get_pgbin_symlink_path(
+    pgbin_real_path = get_pgbin_symlink_path(
         dbgym_workspace.dbgym_workspace_path
     ).resolve()
-    assert pgbin_real_dpath.exists()
+    assert pgbin_real_path.exists()
     dbgym_pguser = DBGYM_POSTGRES_USER
     dbgym_pgpass = DBGYM_POSTGRES_PASS
     pgport = DEFAULT_POSTGRES_PORT
 
     # Create user
-    dbgym_workspace.save_file(pgbin_real_dpath / "psql")
+    dbgym_workspace.save_file(pgbin_real_path / "psql")
     subprocess_run(
         f"./psql -c \"create user {dbgym_pguser} with superuser password '{dbgym_pgpass}'\" {DEFAULT_POSTGRES_DBNAME} -p {pgport} -h localhost",
-        cwd=pgbin_real_dpath,
+        cwd=pgbin_real_path,
     )
     subprocess_run(
         f'./psql -c "grant pg_monitor to {dbgym_pguser}" {DEFAULT_POSTGRES_DBNAME} -p {pgport} -h localhost',
-        cwd=pgbin_real_dpath,
+        cwd=pgbin_real_path,
     )
 
     # Load shared preload libraries
@@ -267,14 +267,14 @@ def _generic_dbdata_setup(dbgym_workspace: DBGymWorkspace) -> None:
             # You have to use TO and you can't put single quotes around the libraries (https://postgrespro.com/list/thread-id/2580120)
             # The method I wrote here works for both one library and multiple libraries
             f'./psql -c "ALTER SYSTEM SET shared_preload_libraries TO {SHARED_PRELOAD_LIBRARIES};" {DEFAULT_POSTGRES_DBNAME} -p {pgport} -h localhost',
-            cwd=pgbin_real_dpath,
+            cwd=pgbin_real_path,
         )
 
     # Create the dbgym database. Since one dbdata dir maps to one benchmark, all benchmarks will use the same database
     # as opposed to using databases named after the benchmark.
     subprocess_run(
         f"./psql -c \"create database {DBGYM_POSTGRES_DBNAME} with owner = '{dbgym_pguser}'\" {DEFAULT_POSTGRES_DBNAME} -p {pgport} -h localhost",
-        cwd=pgbin_real_dpath,
+        cwd=pgbin_real_path,
     )