lakebench 0.1.0__tar.gz

lakebench-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Miles Cole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lakebench-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: lakebench
+Version: 0.1.0
+Summary: A multi-modal Python library for benchmarking Azure lakehouse engines and ELT scenarios, supporting both industry-standard and novel benchmarks.
+Author-email: Miles Cole <m.w.c.360@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Miles Cole
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/mwc360/LakeBench
+Project-URL: Issues, https://github.com/mwc360/LakeBench/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Benchmark
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyarrow>=15.0.0
+Requires-Dist: deltalake==0.18.2
+Requires-Dist: sqlglot==26.30.0
+Provides-Extra: duckdb
+Requires-Dist: duckdb==1.3.1; extra == "duckdb"
+Provides-Extra: polars
+Requires-Dist: polars==1.30.0; extra == "polars"
+Provides-Extra: daft
+Requires-Dist: getdaft==0.4.18; extra == "daft"
+Provides-Extra: all
+Requires-Dist: duckdb==1.3.1; extra == "all"
+Requires-Dist: polars==1.30.0; extra == "all"
+Requires-Dist: getdaft==0.4.18; extra == "all"
+Provides-Extra: datagen
+Requires-Dist: duckdb==1.3.1; extra == "datagen"
+Dynamic: license-file
+
+# LakeBench
+
+🌊 LakeBench is the first Python-based, multi-modal benchmarking framework designed to evaluate performance across multiple lakehouse compute engines and ELT scenarios. Supporting a variety of engines and both industry-standard and novel benchmarks, LakeBench enables comprehensive, apples-to-apples comparisons in a single, extensible Python library.
+
+Most existing benchmarks (like TPC-DS and TPC-H) are too query-heavy and miss the reality that data engineers build complex **ELT pipelines** — not just run analytic queries. While these traditional benchmarks are helpful for testing bulk loading and complex SQL execution, they do not reflect the broader data lifecycle that lakehouse systems must support.
+
+**LakeBench bridges this gap by introducing novel benchmarks that aim to capture the growing spectrum of ELT workflows.** In addition to supporting industry standards like TPC-DS and TPC-H, LakeBench includes scenarios that measure not only query performance, but also data loading, transformation, incremental processing, and maintenance operations. This holistic approach enables you to benchmark engines on the real-world tasks that matter most for modern data engineering.
+
+> LakeBench proposes that **the entire end-to-end data lifecycle managed by data engineers is relevant**: data loading, bulk and incremental transformations, maintenance jobs, and ad-hoc analytical queries. By benchmarking these stages, LakeBench delivers actionable insights into engine efficiency, performance, and operational trade-offs across the full data pipeline.
+
+---
+
+## 🧱 Key Features
+
+- **Modular engine support** (Spark, DuckDB, Polars, Daft)
+- **Benchmark scenarios** that reflect real-world ELT workflows
+- **Atomic units of work** that benchmark discrete lifecycle stages
+- **Configurable execution** to isolate engine behaviors
+- COMING SOON: **Custom result logging** and metrics capture (e.g. SparkMeasure)
+
+---
+
+## 🔍 Benchmark Scenarios
+
+LakeBench currently supports three benchmarks with more to come:
+
+- **ELTBench**: An benchmark with various modes (`light`, `full`) that simulates typicaly ELT workloads:
+  - Raw data load (Parquet → Delta)
+  - Fact table generation
+  - Incremental merge processing
+  - Table maintenance (e.g. OPTIMIZE/VACUUM)
+  - Ad-hoc analytical queries
+- **[TPC-DS](https://www.tpc.org/tpcds/)**: An industry-standard benchmark for complex analytical queries, featuring 24 source tables and 99 queries. Designed to simulate decision support systems and analytics workloads.
+- **[TPC-H](https://www.tpc.org/tpch/)**: Focuses on ad-hoc decision support with 8 tables and 22 queries, evaluating performance on business-oriented analytical workloads.
+
+_Coming Soon_
+- **AtomicELT**: A derivative of _ELTBench_ that focuses on the performance of individual ELT operations. Each operation type is executed only once, allowing for granular comparison of engine performance on specific tasks. Results should be interpreted per operation, not as a cumulative runtime.
+
+---
+
+## 🛠️ Engine Support Matrix
+
+LakeBench supports multiple lakehouse compute engines. Each benchmark scenario declares which engines it supports via `<BenchmarkClassName>.BENCHMARK_IMPL_REGISTRY`.
+
+| Engine          | ELTBench | AtomicELT | TPC-DS | TPC-H |
+|-----------------|:--------:|:---------:|:------:|:-----:|
+| Spark (Fabric)  |    ✅    |     🔜    |   ✅   |   ✅  |
+| DuckDB          |    ✅    |     🔜    |   ✅   |   ✅  |
+| Polars          |    ✅    |     🔜    |   ✅   |   ✅  |
+| Daft            |    ✅    |     🔜    |   ✅   |   ✅  |
+
+> **Legend:**  
+> ✅ = Supported  
+> 🔜 = Coming Soon  
+> (Blank) = Not currently supported 
+
+LakeBench is designed to be _extensible_—new engines can be added via subclassing an existing engine class, and benchmarks can register support for additional engines as they are implemented.
+
+---
+
+## 📦 Installation
+
+Install from PyPi:
+
+```bash
+pip install lakebench[duckdb,polars,daft]
+```
+
+_Note: in this initial beta version, all engines have only been tested inside Microsoft Fabric Python and Spark Notebooks._
+
+## Example Usage
+
+### Fabric Spark
+```python
+from lakebench.engines.fabric_spark import FabricSpark
+from lakebench.benchmarks.elt_bench import ELTBench
+
+engine = FabricSpark(
+    lakehouse_workspace_name="workspace",
+    lakehouse_name="lakehouse",
+    lakehouse_schema_name="schema"
+)
+
+benchmark = ELTBench(
+    engine=engine,
+    scenario_name="sf10",
+    mode="light",
+    tpcds_parquet_abfss_path="abfss://...",
+    save_results=True,
+    result_abfss_path="abfss://..."
+)
+
+benchmark.run()
+```
+
+### Polars
+```python
+from lakebench.engines.polars import Polars
+from lakebench.benchmarks.elt_bench import ELTBench
+
+engine = Polars( 
+    delta_abfss_schema_path = 'abfss://...'
+)
+
+benchmark = ELTBench(
+    engine=engine,
+    scenario_name="sf10",
+    mode="light",
+    tpcds_parquet_abfss_path="abfss://...",
+    save_results=True,
+    result_abfss_path="abfss://..."
+)
+
+benchmark.run()
+```
+
+## 🔌 Extensibility by Design
+
+LakeBench is built to be **plug-and-play** for both benchmark types and compute engines:
+
+- You can register **new engines** without modifying core benchmark logic.
+- You can add **new benchmarks** that reuse existing engines and shared engine methods.
+- LakeBench extension libraries can be created to extend core LakeBench capabilities with additional custom benchmarks and engines (i.e. `MyCustomSynapseSpark(Spark)`, `MyOrgsELT(BaseBenchmark)`).
+
+This architecture encourages experimentation, benchmarking innovation, and easy adaptation to your needs.
+
+_Example:_
+```python
+# Automatically maps benchmark implementation to your custom engine class
+from lakebench.engines.spark import Spark
+
+class MyCustomSynapseSpark(Spark):
+    ...
+
+benchmark = AtomicELT(engine=MyCustomSynapseSpark(...))
+```
+All you need to do is subclass the relevant base class and it will auto-register provided that the referenced benchmark supports the base class. No changes to the framework internals required.
+
+# 🔍 Philosophy
+LakeBench is designed to host a suite of benchmarks that cover E2E data engineering and consumption workloads:
+- Loading data from raw storage
+- Transforming and enriching data
+- Applying incremental module building logic
+- Maintaining and optimizing datasets
+- Running complex analytical queries
+
+The core aim is provide transparency into engine efficiency, performance, and costs across the data lifecycle..
+
+# 📬 Feedback / Contributions
+Got ideas? Found a bug? Want to contribute a benchmark or engine wrapper? PRs and issues are welcome!
+
+
+# Acknowledgement of Other _LakeBench_ Projects
+The **LakeBench** name is also used by two unrelated academic and research efforts:
+- **[RLGen/LAKEBENCH](https://github.com/RLGen/LAKEBENCH)**: A benchmark designed for evaluating vision-language models on multimodal tasks.
+- **LakeBench: Benchmarks for Data Discovery over Lakes** ([paper link](https://www.catalyzex.com/paper/lakebench-benchmarks-for-data-discovery-over)):
+    A benchmark suite focused on improving data discovery and exploration over large data lakes.
+
+While these projects target very different problem domains — such as machine learning and data discovery — they coincidentally share the same name. This project, focused on ELT benchmarking across lakehouse engines, is not affiliated with or derived from either.

lakebench-0.1.0/README.md

@@ -0,0 +1,159 @@
+# LakeBench
+
+🌊 LakeBench is the first Python-based, multi-modal benchmarking framework designed to evaluate performance across multiple lakehouse compute engines and ELT scenarios. Supporting a variety of engines and both industry-standard and novel benchmarks, LakeBench enables comprehensive, apples-to-apples comparisons in a single, extensible Python library.
+
+Most existing benchmarks (like TPC-DS and TPC-H) are too query-heavy and miss the reality that data engineers build complex **ELT pipelines** — not just run analytic queries. While these traditional benchmarks are helpful for testing bulk loading and complex SQL execution, they do not reflect the broader data lifecycle that lakehouse systems must support.
+
+**LakeBench bridges this gap by introducing novel benchmarks that aim to capture the growing spectrum of ELT workflows.** In addition to supporting industry standards like TPC-DS and TPC-H, LakeBench includes scenarios that measure not only query performance, but also data loading, transformation, incremental processing, and maintenance operations. This holistic approach enables you to benchmark engines on the real-world tasks that matter most for modern data engineering.
+
+> LakeBench proposes that **the entire end-to-end data lifecycle managed by data engineers is relevant**: data loading, bulk and incremental transformations, maintenance jobs, and ad-hoc analytical queries. By benchmarking these stages, LakeBench delivers actionable insights into engine efficiency, performance, and operational trade-offs across the full data pipeline.
+
+---
+
+## 🧱 Key Features
+
+- **Modular engine support** (Spark, DuckDB, Polars, Daft)
+- **Benchmark scenarios** that reflect real-world ELT workflows
+- **Atomic units of work** that benchmark discrete lifecycle stages
+- **Configurable execution** to isolate engine behaviors
+- COMING SOON: **Custom result logging** and metrics capture (e.g. SparkMeasure)
+
+---
+
+## 🔍 Benchmark Scenarios
+
+LakeBench currently supports three benchmarks with more to come:
+
+- **ELTBench**: An benchmark with various modes (`light`, `full`) that simulates typicaly ELT workloads:
+  - Raw data load (Parquet → Delta)
+  - Fact table generation
+  - Incremental merge processing
+  - Table maintenance (e.g. OPTIMIZE/VACUUM)
+  - Ad-hoc analytical queries
+- **[TPC-DS](https://www.tpc.org/tpcds/)**: An industry-standard benchmark for complex analytical queries, featuring 24 source tables and 99 queries. Designed to simulate decision support systems and analytics workloads.
+- **[TPC-H](https://www.tpc.org/tpch/)**: Focuses on ad-hoc decision support with 8 tables and 22 queries, evaluating performance on business-oriented analytical workloads.
+
+_Coming Soon_
+- **AtomicELT**: A derivative of _ELTBench_ that focuses on the performance of individual ELT operations. Each operation type is executed only once, allowing for granular comparison of engine performance on specific tasks. Results should be interpreted per operation, not as a cumulative runtime.
+
+---
+
+## 🛠️ Engine Support Matrix
+
+LakeBench supports multiple lakehouse compute engines. Each benchmark scenario declares which engines it supports via `<BenchmarkClassName>.BENCHMARK_IMPL_REGISTRY`.
+
+| Engine          | ELTBench | AtomicELT | TPC-DS | TPC-H |
+|-----------------|:--------:|:---------:|:------:|:-----:|
+| Spark (Fabric)  |    ✅    |     🔜    |   ✅   |   ✅  |
+| DuckDB          |    ✅    |     🔜    |   ✅   |   ✅  |
+| Polars          |    ✅    |     🔜    |   ✅   |   ✅  |
+| Daft            |    ✅    |     🔜    |   ✅   |   ✅  |
+
+> **Legend:**  
+> ✅ = Supported  
+> 🔜 = Coming Soon  
+> (Blank) = Not currently supported 
+
+LakeBench is designed to be _extensible_—new engines can be added via subclassing an existing engine class, and benchmarks can register support for additional engines as they are implemented.
+
+---
+
+## 📦 Installation
+
+Install from PyPi:
+
+```bash
+pip install lakebench[duckdb,polars,daft]
+```
+
+_Note: in this initial beta version, all engines have only been tested inside Microsoft Fabric Python and Spark Notebooks._
+
+## Example Usage
+
+### Fabric Spark
+```python
+from lakebench.engines.fabric_spark import FabricSpark
+from lakebench.benchmarks.elt_bench import ELTBench
+
+engine = FabricSpark(
+    lakehouse_workspace_name="workspace",
+    lakehouse_name="lakehouse",
+    lakehouse_schema_name="schema"
+)
+
+benchmark = ELTBench(
+    engine=engine,
+    scenario_name="sf10",
+    mode="light",
+    tpcds_parquet_abfss_path="abfss://...",
+    save_results=True,
+    result_abfss_path="abfss://..."
+)
+
+benchmark.run()
+```
+
+### Polars
+```python
+from lakebench.engines.polars import Polars
+from lakebench.benchmarks.elt_bench import ELTBench
+
+engine = Polars( 
+    delta_abfss_schema_path = 'abfss://...'
+)
+
+benchmark = ELTBench(
+    engine=engine,
+    scenario_name="sf10",
+    mode="light",
+    tpcds_parquet_abfss_path="abfss://...",
+    save_results=True,
+    result_abfss_path="abfss://..."
+)
+
+benchmark.run()
+```
+
+## 🔌 Extensibility by Design
+
+LakeBench is built to be **plug-and-play** for both benchmark types and compute engines:
+
+- You can register **new engines** without modifying core benchmark logic.
+- You can add **new benchmarks** that reuse existing engines and shared engine methods.
+- LakeBench extension libraries can be created to extend core LakeBench capabilities with additional custom benchmarks and engines (i.e. `MyCustomSynapseSpark(Spark)`, `MyOrgsELT(BaseBenchmark)`).
+
+This architecture encourages experimentation, benchmarking innovation, and easy adaptation to your needs.
+
+_Example:_
+```python
+# Automatically maps benchmark implementation to your custom engine class
+from lakebench.engines.spark import Spark
+
+class MyCustomSynapseSpark(Spark):
+    ...
+
+benchmark = AtomicELT(engine=MyCustomSynapseSpark(...))
+```
+All you need to do is subclass the relevant base class and it will auto-register provided that the referenced benchmark supports the base class. No changes to the framework internals required.
+
+# 🔍 Philosophy
+LakeBench is designed to host a suite of benchmarks that cover E2E data engineering and consumption workloads:
+- Loading data from raw storage
+- Transforming and enriching data
+- Applying incremental module building logic
+- Maintaining and optimizing datasets
+- Running complex analytical queries
+
+The core aim is provide transparency into engine efficiency, performance, and costs across the data lifecycle..
+
+# 📬 Feedback / Contributions
+Got ideas? Found a bug? Want to contribute a benchmark or engine wrapper? PRs and issues are welcome!
+
+
+# Acknowledgement of Other _LakeBench_ Projects
+The **LakeBench** name is also used by two unrelated academic and research efforts:
+- **[RLGen/LAKEBENCH](https://github.com/RLGen/LAKEBENCH)**: A benchmark designed for evaluating vision-language models on multimodal tasks.
+- **LakeBench: Benchmarks for Data Discovery over Lakes** ([paper link](https://www.catalyzex.com/paper/lakebench-benchmarks-for-data-discovery-over)):
+    A benchmark suite focused on improving data discovery and exploration over large data lakes.
+
+While these projects target very different problem domains — such as machine learning and data discovery — they coincidentally share the same name. This project, focused on ELT benchmarking across lakehouse engines, is not affiliated with or derived from either.

lakebench-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lakebench"
+version = "0.1.0"
+authors = [
+    { name="Miles Cole", email="m.w.c.360@gmail.com" },
+]
+license = {file = "LICENSE"}
+description = "A multi-modal Python library for benchmarking Azure lakehouse engines and ELT scenarios, supporting both industry-standard and novel benchmarks."
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Intended Audience :: Developers",
+    "Topic :: System :: Benchmark",
+]
+dependencies = [
+    "numpy",
+    "pyarrow>=15.0.0",
+    "deltalake==0.18.2",
+    "sqlglot==26.30.0"
+]
+
+[project.optional-dependencies]
+duckdb = ["duckdb==1.3.1"]
+polars = ["polars==1.30.0"]
+daft = ["getdaft==0.4.18"]
+all = ["duckdb==1.3.1", "polars==1.30.0", "getdaft==0.4.18"]
+datagen = ["duckdb==1.3.1"]
+
+[project.urls]
+Homepage = "https://github.com/mwc360/LakeBench"
+Issues = "https://github.com/mwc360/LakeBench/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.package-data]
+# Include SQL files src directory
+"lakebench" = ["**/*.sql"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

lakebench-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lakebench-0.1.0/src/lakebench/benchmarks/_tpc/__init__.py

@@ -0,0 +1 @@
+from ._tpc import _TPC

lakebench-0.1.0/src/lakebench/benchmarks/_tpc/_tpc.py

@@ -0,0 +1,156 @@
+from typing import Optional
+from ..base import BaseBenchmark
+from ...utils.query_utils import transpile_and_qualify_query
+
+from ...engines.base import BaseEngine
+from ...engines.spark import Spark
+from ...engines.duckdb import DuckDB
+from ...engines.daft import Daft
+from ...engines.polars import Polars
+
+import importlib.resources
+import posixpath
+
+class _TPC(BaseBenchmark):
+    """
+    """
+    BENCHMARK_IMPL_REGISTRY = {
+        Spark: None,
+        DuckDB: None,
+        Daft: None,
+        Polars: None
+    }
+    MODE_REGISTRY = ['load', 'query', 'power_test']
+    TPC_BENCHMARK_VARIANT = ''
+    TABLE_REGISTRY = [
+        'call_center', 'catalog_page', 'catalog_returns', 'catalog_sales',
+        'customer', 'customer_address', 'customer_demographics', 'date_dim',
+        'household_demographics', 'income_band', 'inventory', 'item',
+        'promotion', 'reason', 'ship_mode', 'store', 'store_returns',
+        'store_sales', 'time_dim', 'warehouse', 'web_page', 'web_returns',
+        'web_sales', 'web_site'
+    ]
+    QUERY_REGISTRY = [
+        'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8', 'q9', 'q10',
+        'q11', 'q12', 'q13', 'q14a', 'q14b', 'q15', 'q16', 'q17', 'q18', 'q19', 'q20',
+        'q21', 'q22', 'q23a', 'q23b', 'q24a', 'q24b', 'q25', 'q26', 'q27', 'q28', 'q29', 'q30',
+        'q31', 'q32', 'q33', 'q34', 'q35', 'q36', 'q37', 'q38', 'q39a', 'q39b', 'q40',
+        'q41', 'q42', 'q43', 'q44', 'q45', 'q46', 'q47', 'q48', 'q49', 'q50',
+        'q51', 'q52', 'q53', 'q54', 'q55', 'q56', 'q57', 'q58', 'q59', 'q60',
+        'q61', 'q62', 'q63', 'q64', 'q65', 'q66', 'q67', 'q68', 'q69', 'q70',
+        'q71', 'q72', 'q73', 'q74', 'q75', 'q76', 'q77', 'q78', 'q79', 'q80',
+        'q81', 'q82', 'q83', 'q84', 'q85', 'q86', 'q87', 'q88', 'q89', 'q90',
+        'q91', 'q92', 'q93', 'q94', 'q95', 'q96', 'q97', 'q98', 'q99'
+    ]
+    DDL_FILE_NAME = ''
+
+    def __init__(
+            self, 
+            engine: BaseEngine, 
+            scenario_name: str,
+            query_list: Optional[list[str]] | None = None,
+            parquet_mount_path: Optional[str] = None,
+            parquet_abfss_path: Optional[str] = None,
+            result_abfss_path: Optional[str] = None,
+            save_results: bool = False
+            ):
+        super().__init__(engine, scenario_name, result_abfss_path, save_results)
+        if query_list is not None:
+            expanded_query_list = []
+            for query in query_list:
+                if query == '*':
+                    expanded_query_list.extend(self.QUERY_REGISTRY)  # Replace '*' with all queries
+                else:
+                    expanded_query_list.append(query)
+            query_set = set(query_list)
+            if not query_set.issubset(self.QUERY_REGISTRY):
+                unsupported_queries = query_set - set(self.QUERY_REGISTRY)
+                raise ValueError(f"Query list contains unsupported queries: {unsupported_queries}. Supported queries: {self.QUERY_REGISTRY}.")
+            self.query_list = expanded_query_list
+        else:
+            self.query_list = self.QUERY_REGISTRY
+
+        for base_engine, benchmark_impl in self.BENCHMARK_IMPL_REGISTRY.items():
+            if isinstance(engine, base_engine):
+                self.benchmark_impl_class = benchmark_impl
+                break
+        else:
+            raise ValueError(
+                f"No benchmark implementation registered for engine type: {type(engine).__name__} "
+                f"in benchmark '{self.__class__.__name__}'."
+            )
+
+        self.engine = engine
+        self.scenario_name = scenario_name
+
+        match engine.REQUIRED_READ_ENDPOINT:
+            case 'mount':
+                if parquet_mount_path is None:
+                    raise ValueError(f"parquet_mount_path must be provided for {type(engine).__name__} engine.")
+                self.source_data_path = parquet_mount_path
+            case 'abfss':
+                if parquet_abfss_path is None:
+                    raise ValueError(f"parquet_abfss_path must be provided for {type(engine).__name__} engine.")
+                self.source_data_path = parquet_abfss_path
+            case _:
+                if parquet_mount_path is None and parquet_abfss_path is None:
+                    raise ValueError(
+                        f"Either parquet_mount_path or parquet_abfss_path must be provided for {type(engine).__name__} engine."
+                    )
+                self.source_data_path = parquet_abfss_path or parquet_mount_path
+
+    def run(self, mode: str = 'power_test'):
+        match mode:
+            case 'load':
+                self._run_load_test()
+            case 'query':
+                self._run_query_test()
+            case 'power_test':
+                self._run_power_test()
+            case _:
+                raise ValueError(f"Unknown mode '{mode}'. Supported modes: {self.MODE_REGISTRY}.")
+    
+    def _prepare_schema(self):
+        self.engine.create_schema_if_not_exists(drop_before_create=True)
+        with importlib.resources.path(f"lakebench.benchmarks.tpc{self.TPC_BENCHMARK_VARIANT.lower()}.resources.ddl", self.DDL_FILE_NAME) as ddl_path:
+            with open(ddl_path, 'r') as ddl_file:
+                ddl = ddl_file.read()
+            
+        statements = [s for s in ddl.split(';') if len(s) > 7]
+        for statement in statements:
+            self.engine.execute_sql_statement(statement)
+
+    def _run_load_test(self):
+        if isinstance(self.engine, Spark):
+            self._prepare_schema()
+        for table_name in self.TABLE_REGISTRY:
+            with self.timer(phase="Load", test_item=table_name, engine=self.engine):
+                self.engine.load_parquet_to_delta(
+                    parquet_folder_path=posixpath.join(self.source_data_path,table_name), 
+                    table_name=table_name
+                )
+        self.post_results()
+
+    def _run_query_test(self):
+        if isinstance(self.engine, (DuckDB, Daft, Polars)):
+            for table_name in self.TABLE_REGISTRY:
+                self.engine.register_table(table_name)
+        for query_name in self.query_list:
+            with importlib.resources.path(f"lakebench.benchmarks.tpc{self.TPC_BENCHMARK_VARIANT.lower()}.resources.queries", f'{query_name}.sql') as query_path:
+                with open(query_path, 'r') as query_file:
+                    query = query_file.read()
+
+            prepped_query = transpile_and_qualify_query(
+                query=query, 
+                from_dialect='spark', 
+                to_dialect=self.engine.SQLGLOT_DIALECT, 
+                catalog=self.engine.catalog_name,
+                schema=self.engine.schema_name
+                )
+            with self.timer(phase="Query", test_item=query_name, engine=self.engine):
+                execute_query = self.engine.execute_sql_query(prepped_query)
+        self.post_results()
+
+    def _run_power_test(self):
+        self._run_load_test()
+        self._run_query_test()

lakebench-0.1.0/src/lakebench/benchmarks/base.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Type, Optional
+import uuid
+from datetime import datetime
+from ..utils.timer import timer
+
+class BaseBenchmark(ABC):
+    BENCHMARK_IMPL_REGISTRY: Dict[Type, Type] = {}
+
+    def __init__(self, engine, scenario_name: str, result_abfss_path: Optional[str], save_results: bool = False):
+        self.engine = engine
+        self.scenario_name = scenario_name
+        self.result_abfss_path = result_abfss_path
+        self.save_results = save_results
+        self.header_detail_dict = {
+            'run_id': str(uuid.uuid1()),
+            'run_datetime': datetime.now().strftime('%Y-%m-%dT%H:%M:%S'),
+            'engine': type(engine).__name__,
+            'benchmark': self.__class__.__name__,
+            'scenario': scenario_name,
+            'total_cores': self.engine.get_total_cores(),
+            'compute_size': self.engine.get_compute_size()
+        }
+        self.timer = timer
+        self.results = []
+
+    @abstractmethod
+    def run(self):
+        pass
+
+    def post_results(self):
+        result_array = [
+            {
+                **self.header_detail_dict,
+                'phase': phase,
+                'test_item': test_item,
+                'start_datetime': start_datetime,
+                "duration_sec": duration_ms / 1000,
+                'duration_ms': duration_ms,
+                'iteration': iteration,
+                'success': success,
+                'error_message': error_message
+            }
+            for phase, test_item, start_datetime, duration_ms, iteration, success, error_message in self.timer.results
+        ]
+
+        if self.save_results:
+            if self.result_abfss_path is None:
+                raise ValueError("result_abfss_path must be provided if save_results is True.")
+            else:
+                self.engine.append_array_to_delta(self.result_abfss_path, result_array)
+
+        self.results.append(result_array)
+        self.timer.clear_results()

lakebench-0.1.0/src/lakebench/benchmarks/elt_bench/__init__.py

@@ -0,0 +1 @@
+from .elt_bench import ELTBench