Upload 284 files

.gitignore

@@ -0,0 +1,18 @@
+.idea/
+.swp
+tables_scale_1*/
+*.tbl
+*.o
+dbgen
+.venv/
+__pycache__/
+qgen
+dask_user_space/
+dask-worker-space/
+timings*.csv
+plots/
+**/spark-warehouse
+perf.*
+target/
+**/flamegraph.svg
+Cargo.lock

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Ritchie Vink
+
+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.

Makefile

@@ -0,0 +1,70 @@
+SHELL=/bin/bash
+PYTHON=.venv/bin/python
+
+.venv:
+	@python -m venv .venv
+	@.venv/bin/pip install -U pip
+	@.venv/bin/pip install --no-cache-dir -r requirements.txt
+
+.fireducks:
+	@python -m venv .fireducks
+	@.venv/bin/pip install -U pip
+	@.venv/bin/pip install --no-cache-dir -r requirements-fireducks.txt
+
+clean-tpch-dbgen:
+	$(MAKE) -C tpch-dbgen clean
+
+clean-venv:
+	rm -r .venv
+
+clean-tables:
+	rm -r tables_scale_*
+
+clean: clean-tpch-dbgen clean-venv
+
+tables_scale_1: .venv
+	$(MAKE) -C tpch-dbgen all
+	cd tpch-dbgen && ./dbgen -vf -s 1 && cd ..
+	mkdir -p "tables_scale_1"
+	mv tpch-dbgen/*.tbl tables_scale_1/
+	.venv/bin/python prepare_files.py 1
+
+tables_scale_10: .venv
+	$(MAKE) -C tpch-dbgen all
+	cd tpch-dbgen && ./dbgen -vf -s 10 && cd ..
+	mkdir -p "tables_scale_10"
+	mv tpch-dbgen/*.tbl tables_scale_10/
+	.venv/bin/python prepare_files.py 10
+
+run_polars: .venv
+	.venv/bin/python -m polars_queries.executor
+
+run_pandas: .venv
+	.venv/bin/python -m pandas_queries.executor
+
+run_fireducks: .fireducks
+	.fireducks/bin/python -m fireducks_queries.executor
+
+run_dask: .venv
+	.venv/bin/python -m dask_queries.executor
+
+run_modin: .venv
+	.venv/bin/python -m modin_queries.executor
+
+run_vaex: .venv
+	.venv/bin/python -m vaex_queries.executor
+
+run_spark: .venv
+	.venv/bin/python -m spark_queries.executor
+
+run_duckdb: .venv
+	.venv/bin/python -m duckdb_queries.executor
+
+plot_results: .venv
+	.venv/bin/python -m scripts.plot_results
+
+run_all: run_polars run_pandas run_fireducks
+
+pre-commit:
+	.venv/bin/python -m isort .
+	.venv/bin/python -m black .

README.md

@@ -1,3 +1,48 @@
----
-license: apache-2.0
----
+polars-tpch
+===========
+
+This repo contains the code used for performance evaluation of polars. The benchmarks are TPC-standardised queries and data designed to test the performance of "real" workflows.
+
+From the [TPC website](https://www.tpc.org/tpch/):
+> TPC-H is a decision support benchmark. It consists of a suite of business-oriented ad hoc queries and concurrent data modifications. The queries and the data populating the database have been chosen to have broad industry-wide relevance. This benchmark illustrates decision support systems that examine large volumes of data, execute queries with a high degree of complexity, and give answers to critical business questions.
+
+## Generating TPC-H Data
+
+### Project setup
+
+```shell
+# clone this repository
+git clone https://github.com/pola-rs/tpch.git
+cd tpch/tpch-dbgen
+
+# build tpch-dbgen
+make
+```
+
+Notes:
+
+- For MacOS, the above `make` command will result in an error while compiling like below,
+
+   ```shell
+   bm_utils.c:71:10: fatal error: 'malloc.h' file not found
+   #include <malloc.h>
+            ^~~~~~~~~~
+   1 error generated.
+   make: *** [bm_utils.o] Error 1
+   ```
+  To fix this, change the import statement `#include <malloc.h>` to `#include <sys/malloc.h>` in the files where error
+  is reported (`bm_utils.c` and `varsub.c`) and then re-run the command `make`.
+
+### Execute
+
+```shell
+# change directory to the root of the repository
+cd ../
+./run.sh
+```
+
+This will do the following,
+
+- Create a new virtual environment with all required dependencies.
+- Generate data for benchmarks.
+- Run the benchmark suite.

common_utils.py

@@ -0,0 +1,70 @@
+import os
+import re
+import sys
+from subprocess import run
+
+from linetimer import CodeTimer
+
+INCLUDE_IO = bool(os.environ.get("INCLUDE_IO", False))
+SHOW_RESULTS = bool(os.environ.get("SHOW_RESULTS", False))
+LOG_TIMINGS = bool(os.environ.get("LOG_TIMINGS", False))
+SCALE_FACTOR = os.environ.get("SCALE_FACTOR", "1")
+WRITE_PLOT = bool(os.environ.get("WRITE_PLOT", False))
+FILE_TYPE = os.environ.get("FILE_TYPE", "parquet")
+SPARK_LOG_LEVEL = os.environ.get("SPARK_LOG_LEVEL", "ERROR")
+print("include io:", INCLUDE_IO)
+print("show results:", SHOW_RESULTS)
+print("log timings:", LOG_TIMINGS)
+print("file type:", FILE_TYPE)
+
+CWD = os.path.dirname(os.path.realpath(__file__))
+DATASET_BASE_DIR = os.path.join(CWD, f"tables_scale_{SCALE_FACTOR}")
+ANSWERS_BASE_DIR = os.path.join(CWD, "tpch-dbgen/answers")
+TIMINGS_FILE = os.path.join(CWD, os.environ.get("TIMINGS_FILE", "timings.csv"))
+DEFAULT_PLOTS_DIR = os.path.join(CWD, "plots")
+
+
+def append_row(solution: str, q: str, secs: float, version: str, success=True):
+    with open(TIMINGS_FILE, "a") as f:
+        if f.tell() == 0:
+            f.write("solution,version,query_no,duration[s],include_io,success\n")
+        f.write(f"{solution},{version},{q},{secs},{INCLUDE_IO},{success}\n")
+
+
+def on_second_call(func):
+    def helper(*args, **kwargs):
+        helper.calls += 1
+
+        # first call is outside the function
+        # this call must set the result
+        if helper.calls == 1:
+            # include IO will compute the result on the 2nd call
+            if not INCLUDE_IO:
+                helper.result = func(*args, **kwargs)
+            return helper.result
+
+        # second call is in the query, now we set the result
+        if INCLUDE_IO and helper.calls == 2:
+            helper.result = func(*args, **kwargs)
+
+        return helper.result
+
+    helper.calls = 0
+    helper.result = None
+
+    return helper
+
+
+def execute_all(solution: str):
+    package_name = f"{solution}_queries"
+
+    expr = re.compile(r"^q(\d+).py")
+    num_queries = 0
+    for file in os.listdir(package_name):
+        g = expr.search(file)
+        if g is not None:
+            num_queries = max(int(g.group(1)), num_queries)
+
+    with CodeTimer(name=f"Overall execution of ALL {solution} queries", unit="s"):
+        for i in range(1, num_queries + 1):
+            run([sys.executable, "-m", f"{package_name}.q{i}"])

dask_queries/executor.py

@@ -0,0 +1,4 @@
+from common_utils import execute_all
+
+if __name__ == "__main__":
+    execute_all("dask")

dask_queries/q1.py

@@ -0,0 +1,73 @@
+from datetime import date, datetime
+
+from dask_queries import utils
+
+Q_NUM = 1
+
+
+def q():
+    VAR1 = datetime(1998, 9, 2)
+
+    lineitem = utils.get_line_item_ds
+    # first call one time to cache in case we don't include the IO times
+    lineitem()
+
+    def query():
+        nonlocal lineitem
+        lineitem = lineitem()
+
+        lineitem_filtered = lineitem.loc[
+            :,
+            [
+                "l_quantity",
+                "l_extendedprice",
+                "l_discount",
+                "l_tax",
+                "l_returnflag",
+                "l_linestatus",
+                "l_shipdate",
+                "l_orderkey",
+            ],
+        ]
+        sel = lineitem_filtered.l_shipdate <= VAR1
+        lineitem_filtered = lineitem_filtered[sel].copy()
+        lineitem_filtered["sum_qty"] = lineitem_filtered.l_quantity
+        lineitem_filtered["sum_base_price"] = lineitem_filtered.l_extendedprice
+        lineitem_filtered["avg_qty"] = lineitem_filtered.l_quantity
+        lineitem_filtered["avg_price"] = lineitem_filtered.l_extendedprice
+        lineitem_filtered["sum_disc_price"] = lineitem_filtered.l_extendedprice * (
+            1 - lineitem_filtered.l_discount
+        )
+        lineitem_filtered["sum_charge"] = (
+            lineitem_filtered.l_extendedprice
+            * (1 - lineitem_filtered.l_discount)
+            * (1 + lineitem_filtered.l_tax)
+        )
+        lineitem_filtered["avg_disc"] = lineitem_filtered.l_discount
+        lineitem_filtered["count_order"] = lineitem_filtered.l_orderkey
+        gb = lineitem_filtered.groupby(["l_returnflag", "l_linestatus"])
+
+        total = gb.agg(
+            {
+                "sum_qty": "sum",
+                "sum_base_price": "sum",
+                "sum_disc_price": "sum",
+                "sum_charge": "sum",
+                "avg_qty": "mean",
+                "avg_price": "mean",
+                "avg_disc": "mean",
+                "count_order": "count",
+            }
+        )
+
+        result_df = (
+            total.compute().reset_index().sort_values(["l_returnflag", "l_linestatus"])
+        )
+
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q2.py

@@ -0,0 +1,157 @@
+from dask_queries import utils
+
+Q_NUM = 2
+
+
+def q():
+    var1 = 15
+    var2 = "BRASS"
+    var3 = "EUROPE"
+
+    region_ds = utils.get_region_ds
+    nation_ds = utils.get_nation_ds
+    supplier_ds = utils.get_supplier_ds
+    part_ds = utils.get_part_ds
+    part_supp_ds = utils.get_part_supp_ds
+
+    # first call one time to cache in case we don't include the IO times
+    region_ds()
+    nation_ds()
+    supplier_ds()
+    part_ds()
+    part_supp_ds()
+
+    def query():
+        nonlocal region_ds
+        nonlocal nation_ds
+        nonlocal supplier_ds
+        nonlocal part_ds
+        nonlocal part_supp_ds
+        region_ds = region_ds()
+        nation_ds = nation_ds()
+        supplier_ds = supplier_ds()
+        part_ds = part_ds()
+        part_supp_ds = part_supp_ds()
+
+        nation_filtered = nation_ds[["n_nationkey", "n_name", "n_regionkey"]]
+        region_filtered = region_ds[(region_ds["r_name"] == var3)]
+        region_filtered = region_filtered[["r_regionkey"]]
+        r_n_merged = nation_filtered.merge(
+            region_filtered, left_on="n_regionkey", right_on="r_regionkey", how="inner"
+        )
+        r_n_merged = r_n_merged.loc[:, ["n_nationkey", "n_name"]]
+        supplier_filtered = supplier_ds.loc[
+            :,
+            [
+                "s_suppkey",
+                "s_name",
+                "s_address",
+                "s_nationkey",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+            ],
+        ]
+        s_r_n_merged = r_n_merged.merge(
+            supplier_filtered,
+            left_on="n_nationkey",
+            right_on="s_nationkey",
+            how="inner",
+        )
+        s_r_n_merged = s_r_n_merged.loc[
+            :,
+            [
+                "n_name",
+                "s_suppkey",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+            ],
+        ]
+        partsupp_filtered = part_supp_ds.loc[
+            :, ["ps_partkey", "ps_suppkey", "ps_supplycost"]
+        ]
+        ps_s_r_n_merged = s_r_n_merged.merge(
+            partsupp_filtered, left_on="s_suppkey", right_on="ps_suppkey", how="inner"
+        )
+        ps_s_r_n_merged = ps_s_r_n_merged.loc[
+            :,
+            [
+                "n_name",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+                "ps_partkey",
+                "ps_supplycost",
+            ],
+        ]
+        part_filtered = part_ds.loc[:, ["p_partkey", "p_mfgr", "p_size", "p_type"]]
+        part_filtered = part_filtered[
+            (part_filtered["p_size"] == var1)
+            & (part_filtered["p_type"].astype(str).str.endswith(var2))
+        ]
+        part_filtered = part_filtered.loc[:, ["p_partkey", "p_mfgr"]]
+        merged_df = part_filtered.merge(
+            ps_s_r_n_merged, left_on="p_partkey", right_on="ps_partkey", how="inner"
+        )
+        merged_df = merged_df.loc[
+            :,
+            [
+                "n_name",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+                "ps_supplycost",
+                "p_partkey",
+                "p_mfgr",
+            ],
+        ]
+        min_values = merged_df.groupby("p_partkey")["ps_supplycost"].min().reset_index()
+        min_values.columns = ["P_PARTKEY_CPY", "MIN_SUPPLYCOST"]
+        merged_df = merged_df.merge(
+            min_values,
+            left_on=["p_partkey", "ps_supplycost"],
+            right_on=["P_PARTKEY_CPY", "MIN_SUPPLYCOST"],
+            how="inner",
+        )
+        result_df = merged_df.loc[
+            :,
+            [
+                "s_acctbal",
+                "s_name",
+                "n_name",
+                "p_partkey",
+                "p_mfgr",
+                "s_address",
+                "s_phone",
+                "s_comment",
+            ],
+        ].compute()
+        result_df = result_df.sort_values(
+            by=[
+                "s_acctbal",
+                "n_name",
+                "s_name",
+                "p_partkey",
+            ],
+            ascending=[
+                False,
+                True,
+                True,
+                True,
+            ],
+        )[:100]
+
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q3.py

@@ -0,0 +1,63 @@
+import datetime
+
+from dask_queries import utils
+
+Q_NUM = 3
+
+
+def q():
+    var1 = datetime.datetime.strptime("1995-03-15", "%Y-%m-%d")
+    var2 = "BUILDING"
+
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+    customer_ds = utils.get_customer_ds
+
+    # first call one time to cache in case we don't include the IO times
+    line_item_ds()
+    orders_ds()
+    customer_ds()
+
+    def query():
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        nonlocal customer_ds
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+        customer_ds = customer_ds()
+
+        lineitem_filtered = line_item_ds.loc[
+            :, ["l_orderkey", "l_extendedprice", "l_discount", "l_shipdate"]
+        ]
+        orders_filtered = orders_ds.loc[
+            :, ["o_orderkey", "o_custkey", "o_orderdate", "o_shippriority"]
+        ]
+        customer_filtered = customer_ds.loc[:, ["c_mktsegment", "c_custkey"]]
+        lsel = lineitem_filtered.l_shipdate > var1
+        osel = orders_filtered.o_orderdate < var1
+        csel = customer_filtered.c_mktsegment == var2
+        flineitem = lineitem_filtered[lsel]
+        forders = orders_filtered[osel]
+        fcustomer = customer_filtered[csel]
+        jn1 = fcustomer.merge(forders, left_on="c_custkey", right_on="o_custkey")
+        jn2 = jn1.merge(flineitem, left_on="o_orderkey", right_on="l_orderkey")
+        jn2["revenue"] = jn2.l_extendedprice * (1 - jn2.l_discount)
+        total = (
+            jn2.groupby(["l_orderkey", "o_orderdate", "o_shippriority"])["revenue"]
+            .sum()
+            .compute()
+            .reset_index()
+            .sort_values(["revenue"], ascending=False)
+        )
+
+        result_df = total[:10].loc[
+            :, ["l_orderkey", "revenue", "o_orderdate", "o_shippriority"]
+        ]
+
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q4.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+
+from dask_queries import utils
+
+Q_NUM = 4
+
+
+def q():
+    date1 = datetime.strptime("1993-10-01", "%Y-%m-%d")
+    date2 = datetime.strptime("1993-07-01", "%Y-%m-%d")
+
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+
+    # first call one time to cache in case we don't include the IO times
+    line_item_ds()
+    orders_ds()
+
+    def query():
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+
+        lsel = line_item_ds.l_commitdate < line_item_ds.l_receiptdate
+        osel = (orders_ds.o_orderdate < date1) & (orders_ds.o_orderdate >= date2)
+        flineitem = line_item_ds[lsel]
+        forders = orders_ds[osel]
+        forders = forders[["o_orderkey", "o_orderpriority"]]
+        # jn = forders[forders["o_orderkey"].compute().isin(flineitem["l_orderkey"])] # doesn't support isin
+        jn = forders.merge(
+            flineitem, left_on="o_orderkey", right_on="l_orderkey"
+        ).drop_duplicates(subset=["o_orderkey"])[["o_orderpriority", "o_orderkey"]]
+        result_df = (
+            jn.groupby("o_orderpriority")["o_orderkey"]
+            .count()
+            .reset_index()
+            .sort_values(["o_orderpriority"])
+        )
+        result_df = result_df.compute()
+        return result_df.rename({"o_orderkey": "order_count"}, axis=1)
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q5.py

@@ -0,0 +1,64 @@
+import datetime
+
+from dask_queries import utils
+
+Q_NUM = 5
+
+
+def q():
+    date1 = datetime.datetime.strptime("1994-01-01", "%Y-%m-%d")
+    date2 = datetime.datetime.strptime("1995-01-01", "%Y-%m-%d")
+
+    region_ds = utils.get_region_ds
+    nation_ds = utils.get_nation_ds
+    customer_ds = utils.get_customer_ds
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+    supplier_ds = utils.get_supplier_ds
+
+    # first call one time to cache in case we don't include the IO times
+    region_ds()
+    nation_ds()
+    customer_ds()
+    line_item_ds()
+    orders_ds()
+    supplier_ds()
+
+    def query():
+        nonlocal region_ds
+        nonlocal nation_ds
+        nonlocal customer_ds
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        nonlocal supplier_ds
+
+        region_ds = region_ds()
+        nation_ds = nation_ds()
+        customer_ds = customer_ds()
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+        supplier_ds = supplier_ds()
+
+        rsel = region_ds.r_name == "ASIA"
+        osel = (orders_ds.o_orderdate >= date1) & (orders_ds.o_orderdate < date2)
+        forders = orders_ds[osel]
+        fregion = region_ds[rsel]
+        jn1 = fregion.merge(nation_ds, left_on="r_regionkey", right_on="n_regionkey")
+        jn2 = jn1.merge(customer_ds, left_on="n_nationkey", right_on="c_nationkey")
+        jn3 = jn2.merge(forders, left_on="c_custkey", right_on="o_custkey")
+        jn4 = jn3.merge(line_item_ds, left_on="o_orderkey", right_on="l_orderkey")
+        jn5 = supplier_ds.merge(
+            jn4,
+            left_on=["s_suppkey", "s_nationkey"],
+            right_on=["l_suppkey", "n_nationkey"],
+        )
+        jn5["revenue"] = jn5.l_extendedprice * (1.0 - jn5.l_discount)
+        gb = jn5.groupby("n_name")["revenue"].sum()
+        result_df = gb.compute().reset_index().sort_values("revenue", ascending=False)
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q6.py

@@ -0,0 +1,46 @@
+import datetime
+
+import pandas as pd
+
+from dask_queries import utils
+
+Q_NUM = 6
+
+
+def q():
+    date1 = datetime.datetime.strptime("1994-01-01", "%Y-%m-%d")
+    date2 = datetime.datetime.strptime("1995-01-01", "%Y-%m-%d")
+    var3 = 24
+
+    line_item_ds = utils.get_line_item_ds
+
+    # first call one time to cache in case we don't include the IO times
+    line_item_ds()
+
+    def query():
+        nonlocal line_item_ds
+        line_item_ds = line_item_ds()
+
+        lineitem_filtered = line_item_ds.loc[
+            :, ["l_quantity", "l_extendedprice", "l_discount", "l_shipdate"]
+        ]
+        sel = (
+            (lineitem_filtered.l_shipdate >= date1)
+            & (lineitem_filtered.l_shipdate < date2)
+            & (lineitem_filtered.l_discount >= 0.05)
+            & (lineitem_filtered.l_discount <= 0.07)
+            & (lineitem_filtered.l_quantity < var3)
+        )
+
+        flineitem = lineitem_filtered[sel]
+        result_value = (
+            (flineitem.l_extendedprice * flineitem.l_discount).sum().compute()
+        )
+        result_df = pd.DataFrame({"revenue": [result_value]})
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/q7.py

@@ -0,0 +1,139 @@
+import datetime
+from datetime import datetime
+
+import dask.dataframe as dd
+
+from dask_queries import utils
+
+Q_NUM = 7
+
+
+def q():
+    var1 = datetime.strptime("1995-01-01", "%Y-%m-%d")
+    var2 = datetime.strptime("1997-01-01", "%Y-%m-%d")
+    nation_ds = utils.get_nation_ds
+    customer_ds = utils.get_customer_ds
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+    supplier_ds = utils.get_supplier_ds
+
+    # first call one time to cache in case we don't include the IO times
+    nation_ds()
+    customer_ds()
+    line_item_ds()
+    orders_ds()
+    supplier_ds()
+
+    def query():
+        nonlocal nation_ds
+        nonlocal customer_ds
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        nonlocal supplier_ds
+
+        nation_ds = nation_ds()
+        customer_ds = customer_ds()
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+        supplier_ds = supplier_ds()
+
+        lineitem_filtered = line_item_ds[
+            (line_item_ds["l_shipdate"] >= var1) & (line_item_ds["l_shipdate"] < var2)
+        ]
+        lineitem_filtered["l_year"] = lineitem_filtered["l_shipdate"].dt.year
+        lineitem_filtered["revenue"] = lineitem_filtered["l_extendedprice"] * (
+            1.0 - lineitem_filtered["l_discount"]
+        )
+        lineitem_filtered = lineitem_filtered.loc[
+            :, ["l_orderkey", "l_suppkey", "l_year", "revenue"]
+        ]
+        supplier_filtered = supplier_ds.loc[:, ["s_suppkey", "s_nationkey"]]
+        orders_filtered = orders_ds.loc[:, ["o_orderkey", "o_custkey"]]
+        customer_filtered = customer_ds.loc[:, ["c_custkey", "c_nationkey"]]
+        n1 = nation_ds[(nation_ds["n_name"] == "FRANCE")].loc[
+            :, ["n_nationkey", "n_name"]
+        ]
+        n2 = nation_ds[(nation_ds["n_name"] == "GERMANY")].loc[
+            :, ["n_nationkey", "n_name"]
+        ]
+
+        # ----- do nation 1 -----
+        N1_C = customer_filtered.merge(
+            n1, left_on="c_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N1_C = N1_C.drop(columns=["c_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "cust_nation"}
+        )
+        N1_C_O = N1_C.merge(
+            orders_filtered, left_on="c_custkey", right_on="o_custkey", how="inner"
+        )
+        N1_C_O = N1_C_O.drop(columns=["c_custkey", "o_custkey"])
+
+        N2_S = supplier_filtered.merge(
+            n2, left_on="s_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N2_S = N2_S.drop(columns=["s_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "supp_nation"}
+        )
+        N2_S_L = N2_S.merge(
+            lineitem_filtered, left_on="s_suppkey", right_on="l_suppkey", how="inner"
+        )
+        N2_S_L = N2_S_L.drop(columns=["s_suppkey", "l_suppkey"])
+
+        total1 = N1_C_O.merge(
+            N2_S_L, left_on="o_orderkey", right_on="l_orderkey", how="inner"
+        )
+        total1 = total1.drop(columns=["o_orderkey", "l_orderkey"])
+
+        # ----- do nation 2 ----- (same as nation 1 section but with nation 2)
+        N2_C = customer_filtered.merge(
+            n2, left_on="c_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N2_C = N2_C.drop(columns=["c_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "cust_nation"}
+        )
+        N2_C_O = N2_C.merge(
+            orders_filtered, left_on="c_custkey", right_on="o_custkey", how="inner"
+        )
+        N2_C_O = N2_C_O.drop(columns=["c_custkey", "o_custkey"])
+
+        N1_S = supplier_filtered.merge(
+            n1, left_on="s_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N1_S = N1_S.drop(columns=["s_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "supp_nation"}
+        )
+        N1_S_L = N1_S.merge(
+            lineitem_filtered, left_on="s_suppkey", right_on="l_suppkey", how="inner"
+        )
+        N1_S_L = N1_S_L.drop(columns=["s_suppkey", "l_suppkey"])
+
+        total2 = N2_C_O.merge(
+            N1_S_L, left_on="o_orderkey", right_on="l_orderkey", how="inner"
+        )
+        total2 = total2.drop(columns=["o_orderkey", "l_orderkey"])
+
+        # concat results
+        total = dd.concat([total1, total2])
+        result_df = (
+            total.groupby(["supp_nation", "cust_nation", "l_year"])
+            .revenue.agg("sum")
+            .reset_index()
+        )
+        result_df.columns = ["supp_nation", "cust_nation", "l_year", "revenue"]
+
+        result_df = result_df.compute().sort_values(
+            by=["supp_nation", "cust_nation", "l_year"],
+            ascending=[
+                True,
+                True,
+                True,
+            ],
+        )
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

dask_queries/utils.py

@@ -0,0 +1,119 @@
+import os
+import timeit
+from os.path import join
+from typing import Callable, Union
+
+import dask.dataframe as dd
+import pandas as pd
+from linetimer import CodeTimer, linetimer
+
+from common_utils import (
+    ANSWERS_BASE_DIR,
+    DATASET_BASE_DIR,
+    FILE_TYPE,
+    INCLUDE_IO,
+    LOG_TIMINGS,
+    SHOW_RESULTS,
+    append_row,
+    on_second_call,
+)
+
+
+def read_ds(path: str) -> Union:
+    if INCLUDE_IO:
+        return dd.read_parquet(path)
+    if FILE_TYPE == "feather":
+        raise ValueError("file type feather not supported for dask queries")
+
+    return dd.from_pandas(pd.read_parquet(path), npartitions=os.cpu_count())
+
+
+def get_query_answer(query: int, base_dir: str = ANSWERS_BASE_DIR) -> dd.DataFrame:
+    answer_df = pd.read_csv(
+        join(base_dir, f"q{query}.out"),
+        sep="|",
+        parse_dates=True,
+        infer_datetime_format=True,
+    )
+    return answer_df.rename(columns=lambda x: x.strip())
+
+
+def test_results(q_num: int, result_df: pd.DataFrame):
+    with CodeTimer(name=f"Testing result of dask Query {q_num}", unit="s"):
+        answer = get_query_answer(q_num)
+
+        for c, t in answer.dtypes.items():
+            s1 = result_df[c]
+            s2 = answer[c]
+
+            if t.name == "object":
+                s1 = s1.astype("string").apply(lambda x: x.strip())
+                s2 = s2.astype("string").apply(lambda x: x.strip())
+
+            pd.testing.assert_series_equal(left=s1, right=s2, check_index=False)
+
+
+@on_second_call
+def get_line_item_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "lineitem.parquet"))
+
+
+@on_second_call
+def get_orders_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "orders.parquet"))
+
+
+@on_second_call
+def get_customer_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "customer.parquet"))
+
+
+@on_second_call
+def get_region_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "region.parquet"))
+
+
+@on_second_call
+def get_nation_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "nation.parquet"))
+
+
+@on_second_call
+def get_supplier_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "supplier.parquet"))
+
+
+@on_second_call
+def get_part_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "part.parquet"))
+
+
+@on_second_call
+def get_part_supp_ds(base_dir: str = DATASET_BASE_DIR) -> dd.DataFrame:
+    return read_ds(join(base_dir, "partsupp.parquet"))
+
+
+def run_query(q_num: str, query: Callable):
+    @linetimer(name=f"Overall execution of dask Query {q_num}", unit="s")
+    def run():
+        import dask
+
+        dask.config.set(scheduler="threads")
+
+        with CodeTimer(name=f"Get result of dask Query {q_num}", unit="s"):
+            t0 = timeit.default_timer()
+
+            result = query()
+            secs = timeit.default_timer() - t0
+
+        if LOG_TIMINGS:
+            append_row(
+                solution="dask", version=dask.__version__, q=f"q{q_num}", secs=secs
+            )
+        else:
+            test_results(q_num, result)
+
+        if SHOW_RESULTS:
+            print(result)
+
+    run()

duckdb_queries/executor.py

@@ -0,0 +1,4 @@
+from common_utils import execute_all
+
+if __name__ == "__main__":
+    execute_all("duckdb")

duckdb_queries/q1.py

@@ -0,0 +1,41 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 1
+
+
+def q():
+    lineitem = utils.get_line_item_ds()
+
+    query_str = f"""
+    select
+        l_returnflag,
+        l_linestatus,
+        sum(l_quantity) as sum_qty,
+        sum(l_extendedprice) as sum_base_price,
+        sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
+        sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
+        avg(l_quantity) as avg_qty,
+        avg(l_extendedprice) as avg_price,
+        avg(l_discount) as avg_disc,
+        count(*) as count_order
+    from
+        {lineitem}
+    where
+        l_shipdate <= '1998-09-02'
+    group by
+        l_returnflag,
+        l_linestatus
+    order by
+        l_returnflag,
+        l_linestatus
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q10.py

@@ -0,0 +1,55 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 10
+
+
+def q():
+    customer_ds = utils.get_customer_ds()
+    orders_ds = utils.get_orders_ds()
+    line_item_ds = utils.get_line_item_ds()
+    nation_ds = utils.get_nation_ds()
+
+    query_str = f"""
+    select
+        c_custkey,
+        c_name,
+        round(sum(l_extendedprice * (1 - l_discount)), 2) as revenue,
+        c_acctbal,
+        n_name,
+        trim(c_address) as c_address,
+        c_phone,
+        trim(c_comment) as c_comment
+    from
+        {customer_ds},
+        {orders_ds},
+        {line_item_ds},
+        {nation_ds}
+    where
+        c_custkey = o_custkey
+        and l_orderkey = o_orderkey
+        and o_orderdate >= date '1993-10-01'
+        and o_orderdate < date '1993-10-01' + interval '3' month
+        and l_returnflag = 'R'
+        and c_nationkey = n_nationkey
+    group by
+        c_custkey,
+        c_name,
+        c_acctbal,
+        c_phone,
+        n_name,
+        c_address,
+        c_comment
+    order by
+        revenue desc
+    limit 20
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q11.py

@@ -0,0 +1,49 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 11
+
+
+def q():
+    supplier_ds = utils.get_supplier_ds()
+    part_supp_ds = utils.get_part_supp_ds()
+    nation_ds = utils.get_nation_ds()
+
+    query_str = f"""
+    select
+        ps_partkey,
+        round(sum(ps_supplycost * ps_availqty), 2) as value
+    from
+        {part_supp_ds},
+        {supplier_ds},
+        {nation_ds}
+    where
+        ps_suppkey = s_suppkey
+        and s_nationkey = n_nationkey
+        and n_name = 'GERMANY'
+    group by
+        ps_partkey having
+                sum(ps_supplycost * ps_availqty) > (
+            select
+                sum(ps_supplycost * ps_availqty) * 0.0001
+            from
+                {part_supp_ds},
+                {supplier_ds},
+                {nation_ds}
+            where
+                ps_suppkey = s_suppkey
+                and s_nationkey = n_nationkey
+                and n_name = 'GERMANY'
+            )
+        order by
+            value desc
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q12.py

@@ -0,0 +1,48 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 12
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+
+    query_str = f"""
+    select
+        l_shipmode,
+        sum(case
+            when o_orderpriority = '1-URGENT'
+                or o_orderpriority = '2-HIGH'
+                then 1
+            else 0
+        end) as high_line_count,
+        sum(case
+            when o_orderpriority <> '1-URGENT'
+                and o_orderpriority <> '2-HIGH'
+                then 1
+            else 0
+        end) as low_line_count
+    from
+        {orders_ds},
+        {line_item_ds}
+    where
+        o_orderkey = l_orderkey
+        and l_shipmode in ('MAIL', 'SHIP')
+        and l_commitdate < l_receiptdate
+        and l_shipdate < l_commitdate
+        and l_receiptdate >= date '1994-01-01'
+        and l_receiptdate < date '1994-01-01' + interval '1' year
+    group by
+        l_shipmode
+    order by
+        l_shipmode
+	"""
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q13.py

@@ -0,0 +1,42 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 13
+
+
+def q():
+    orders_ds = utils.get_orders_ds()
+    customer_ds = utils.get_customer_ds()
+
+    query_str = f"""
+    select
+        c_count, count(*) as custdist
+    from (
+        select
+            c_custkey,
+            count(o_orderkey)
+        from
+            {customer_ds} left outer join {orders_ds} on
+            c_custkey = o_custkey
+            and o_comment not like '%special%requests%'
+        group by
+            c_custkey
+        )as c_orders (c_custkey, c_count)
+    group by
+        c_count
+    order by
+        custdist desc,
+        c_count desc
+	"""
+
+    utils.get_customer_ds()
+    utils.get_orders_ds()
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q14.py

@@ -0,0 +1,34 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 14
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    line_item_ds = utils.get_line_item_ds()
+
+    query_str = f"""
+    select
+        round(100.00 * sum(case
+            when p_type like 'PROMO%'
+                then l_extendedprice * (1 - l_discount)
+            else 0
+        end) / sum(l_extendedprice * (1 - l_discount)), 2) as promo_revenue
+    from
+        {line_item_ds},
+        {part_ds}
+    where
+        l_partkey = p_partkey
+        and l_shipdate >= date '1995-09-01'
+        and l_shipdate < date '1995-09-01' + interval '1' month
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q15.py

@@ -0,0 +1,57 @@
+import duckdb
+from duckdb import DuckDBPyConnection
+
+from duckdb_queries import utils
+
+Q_NUM = 15
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    supplier_ds = utils.get_supplier_ds()
+
+    ddl = f"""
+    create or replace temporary view revenue (supplier_no, total_revenue) as
+        select
+            l_suppkey,
+            sum(l_extendedprice * (1 - l_discount))
+        from
+            {line_item_ds}
+        where
+            l_shipdate >= date '1996-01-01'
+            and l_shipdate < date '1996-01-01' + interval '3' month
+        group by
+            l_suppkey
+    """
+
+    query_str = f"""
+    select
+        s_suppkey,
+        s_name,
+        s_address,
+        s_phone,
+        total_revenue
+    from
+        {supplier_ds},
+        revenue
+    where
+        s_suppkey = supplier_no
+        and total_revenue = (
+            select
+                max(total_revenue)
+            from
+                revenue
+        )
+    order by
+        s_suppkey
+	"""
+
+    _ = duckdb.execute(ddl)
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+    duckdb.execute("DROP VIEW IF EXISTS revenue")
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q16.py

@@ -0,0 +1,52 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 16
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    supplier_ds = utils.get_supplier_ds()
+    part_supp_ds = utils.get_part_supp_ds()
+
+    query_str = f"""
+    select
+        p_brand,
+        p_type,
+        p_size,
+        count(distinct ps_suppkey) as supplier_cnt
+    from
+        {part_supp_ds},
+        {part_ds}
+    where
+        p_partkey = ps_partkey
+        and p_brand <> 'Brand#45'
+        and p_type not like 'MEDIUM POLISHED%'
+        and p_size in (49, 14, 23, 45, 19, 3, 36, 9)
+        and ps_suppkey not in (
+            select
+                s_suppkey
+            from
+                {supplier_ds}
+            where
+                s_comment like '%Customer%Complaints%'
+        )
+    group by
+        p_brand,
+        p_type,
+        p_size
+    order by
+        supplier_cnt desc,
+        p_brand,
+        p_type,
+        p_size
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q17.py

@@ -0,0 +1,38 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 17
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    line_item_ds = utils.get_line_item_ds()
+
+    query_str = f"""
+    select
+        round(sum(l_extendedprice) / 7.0, 2) as avg_yearly
+    from
+        {line_item_ds},
+        {part_ds}
+    where
+        p_partkey = l_partkey
+        and p_brand = 'Brand#23'
+        and p_container = 'MED BOX'
+        and l_quantity < (
+            select
+                0.2 * avg(l_quantity)
+            from
+                {line_item_ds}
+            where
+                l_partkey = p_partkey
+        )
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q18.py

@@ -0,0 +1,55 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 18
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+    customer_ds = utils.get_customer_ds()
+
+    query_str = f"""
+    select
+        c_name,
+        c_custkey,
+        o_orderkey,
+        o_orderdate as o_orderdat,
+        o_totalprice,
+        sum(l_quantity) as col6
+    from
+        {customer_ds},
+        {orders_ds},
+        {line_item_ds}
+    where
+        o_orderkey in (
+            select
+                l_orderkey
+            from
+                {line_item_ds}
+            group by
+                l_orderkey having
+                    sum(l_quantity) > 300
+        )
+        and c_custkey = o_custkey
+        and o_orderkey = l_orderkey
+    group by
+        c_name,
+        c_custkey,
+        o_orderkey,
+        o_orderdate,
+        o_totalprice
+    order by
+        o_totalprice desc,
+        o_orderdate
+    limit 100
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q19.py

@@ -0,0 +1,56 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 19
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    line_item_ds = utils.get_line_item_ds()
+
+    query_str = f"""
+    select
+        round(sum(l_extendedprice* (1 - l_discount)), 2) as revenue
+    from
+        {line_item_ds},
+        {part_ds}
+    where
+        (
+            p_partkey = l_partkey
+            and p_brand = 'Brand#12'
+            and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG')
+            and l_quantity >= 1 and l_quantity <= 1 + 10
+            and p_size between 1 and 5
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        )
+        or
+        (
+            p_partkey = l_partkey
+            and p_brand = 'Brand#23'
+            and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK')
+            and l_quantity >= 10 and l_quantity <= 20
+            and p_size between 1 and 10
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        )
+        or
+        (
+            p_partkey = l_partkey
+            and p_brand = 'Brand#34'
+            and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG')
+            and l_quantity >= 20 and l_quantity <= 30
+            and p_size between 1 and 15
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        )
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q2.py

@@ -0,0 +1,68 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 2
+
+
+def q():
+    region_ds = utils.get_region_ds()
+    nation_ds = utils.get_nation_ds()
+    supplier_ds = utils.get_supplier_ds()
+    part_ds = utils.get_part_ds()
+    part_supp_ds = utils.get_part_supp_ds()
+
+    query_str = f"""
+    select
+        s_acctbal,
+        s_name,
+        n_name,
+        p_partkey,
+        p_mfgr,
+        trim(s_address) as s_address,
+        s_phone,
+        trim(s_comment) as s_comment
+    from
+        {part_ds},
+        {supplier_ds},
+        {part_supp_ds},
+        {nation_ds},
+        {region_ds} 
+    where
+        p_partkey = ps_partkey
+        and s_suppkey = ps_suppkey
+        and p_size = 15
+        and p_type like '%BRASS'
+        and s_nationkey = n_nationkey
+        and n_regionkey = r_regionkey
+        and r_name = 'EUROPE'
+        and ps_supplycost = (
+            select
+                min(ps_supplycost)
+            from
+                {part_supp_ds},
+                {supplier_ds},
+                {nation_ds},
+                {region_ds}
+            where
+                p_partkey = ps_partkey
+                and s_suppkey = ps_suppkey
+                and s_nationkey = n_nationkey
+                and n_regionkey = r_regionkey
+                and r_name = 'EUROPE'
+        )
+    order by
+        s_acctbal desc,
+        n_name,
+        s_name,
+        p_partkey
+    limit 100
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q20.py

@@ -0,0 +1,61 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 20
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    nation_ds = utils.get_nation_ds()
+    supplier_ds = utils.get_supplier_ds()
+    part_ds = utils.get_part_ds()
+    part_supp_ds = utils.get_part_supp_ds()
+
+    query_str = f"""
+    select
+        s_name,
+        trim(s_address) as s_address
+    from
+        {supplier_ds},
+        {nation_ds}
+    where
+        s_suppkey in (
+            select
+                ps_suppkey
+            from
+                {part_supp_ds}
+            where
+                ps_partkey in (
+                    select
+                        p_partkey
+                    from
+                        {part_ds}
+                    where
+                        p_name like 'forest%'
+                )
+                and ps_availqty > (
+                    select
+                        0.5 * sum(l_quantity)
+                    from
+                        {line_item_ds}
+                    where
+                        l_partkey = ps_partkey
+                        and l_suppkey = ps_suppkey
+                        and l_shipdate >= date '1994-01-01'
+                        and l_shipdate < date '1994-01-01' + interval '1' year
+                )
+        )
+        and s_nationkey = n_nationkey
+        and n_name = 'CANADA'
+    order by
+        s_name
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q21.py

@@ -0,0 +1,63 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 21
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    supplier_ds = utils.get_supplier_ds()
+    nation_ds = utils.get_nation_ds()
+    orders_ds = utils.get_orders_ds()
+
+    query_str = f"""
+    select
+        s_name,
+        count(*) as numwait
+    from
+        {supplier_ds},
+        {line_item_ds} l1,
+        {orders_ds},
+        {nation_ds}
+    where
+        s_suppkey = l1.l_suppkey
+        and o_orderkey = l1.l_orderkey
+        and o_orderstatus = 'F'
+        and l1.l_receiptdate > l1.l_commitdate
+        and exists (
+            select
+                *
+            from
+                {line_item_ds} l2
+            where
+                l2.l_orderkey = l1.l_orderkey
+                and l2.l_suppkey <> l1.l_suppkey
+        )
+        and not exists (
+            select
+                *
+            from
+                {line_item_ds} l3
+            where
+                l3.l_orderkey = l1.l_orderkey
+                and l3.l_suppkey <> l1.l_suppkey
+                and l3.l_receiptdate > l3.l_commitdate
+        )
+        and s_nationkey = n_nationkey
+        and n_name = 'SAUDI ARABIA'
+    group by
+        s_name
+    order by
+        numwait desc,
+        s_name
+    limit 100
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q22.py

@@ -0,0 +1,57 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 22
+
+
+def q():
+    orders_ds = utils.get_orders_ds()
+    customer_ds = utils.get_customer_ds()
+
+    query_str = f"""
+    select
+        cntrycode,
+        count(*) as numcust,
+        sum(c_acctbal) as totacctbal
+    from (
+        select
+            substring(c_phone from 1 for 2) as cntrycode,
+            c_acctbal
+        from
+            {customer_ds}
+        where
+            substring(c_phone from 1 for 2) in
+                (13, 31, 23, 29, 30, 18, 17)
+            and c_acctbal > (
+                select
+                    avg(c_acctbal)
+                from
+                    {customer_ds}
+                where
+                    c_acctbal > 0.00
+                    and substring (c_phone from 1 for 2) in
+                        (13, 31, 23, 29, 30, 18, 17)
+            )
+            and not exists (
+                select
+                    *
+                from
+                    {orders_ds}
+                where
+                    o_custkey = c_custkey
+            )
+        ) as custsale
+    group by
+        cntrycode
+    order by
+        cntrycode
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q3.py

@@ -0,0 +1,45 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 3
+
+
+def q():
+    customer_ds = utils.get_customer_ds()
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+
+    query_str = f"""
+    select
+        l_orderkey,
+        sum(l_extendedprice * (1 - l_discount)) as revenue,
+        o_orderdate,
+        o_shippriority
+    from
+        {customer_ds},
+        {orders_ds},
+        {line_item_ds}
+    where
+        c_mktsegment = 'BUILDING'
+        and c_custkey = o_custkey
+        and l_orderkey = o_orderkey
+        and o_orderdate < '1995-03-15'
+        and l_shipdate > '1995-03-15'
+    group by
+        l_orderkey,
+        o_orderdate,
+        o_shippriority
+    order by
+        revenue desc,
+        o_orderdate
+    limit 10
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q4.py

@@ -0,0 +1,42 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 4
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+
+    query_str = f"""
+    select
+        o_orderpriority,
+        count(*) as order_count
+    from
+        {orders_ds}
+    where
+        o_orderdate >= timestamp '1993-07-01'
+        and o_orderdate < timestamp '1993-07-01' + interval '3' month
+        and exists (
+            select
+                *
+            from
+                {line_item_ds}
+            where
+                l_orderkey = o_orderkey
+                and l_commitdate < l_receiptdate
+        )
+    group by
+        o_orderpriority
+    order by
+        o_orderpriority
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q5.py

@@ -0,0 +1,49 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 5
+
+
+def q():
+    region_ds = utils.get_region_ds()
+    nation_ds = utils.get_nation_ds()
+    customer_ds = utils.get_customer_ds()
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+    supplier_ds = utils.get_supplier_ds()
+
+    query_str = f"""
+    select
+        n_name,
+        sum(l_extendedprice * (1 - l_discount)) as revenue
+    from
+        {customer_ds},
+        {orders_ds},
+        {line_item_ds},
+        {supplier_ds},
+        {nation_ds},
+        {region_ds}
+    where
+        c_custkey = o_custkey
+        and l_orderkey = o_orderkey
+        and l_suppkey = s_suppkey
+        and c_nationkey = s_nationkey
+        and s_nationkey = n_nationkey
+        and n_regionkey = r_regionkey
+        and r_name = 'ASIA'
+        and o_orderdate >= timestamp '1994-01-01'
+        and o_orderdate < timestamp '1994-01-01' + interval '1' year
+    group by
+        n_name
+    order by
+        revenue desc
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q6.py

@@ -0,0 +1,29 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 6
+
+
+def q():
+    line_item_ds = utils.get_line_item_ds()
+
+    query_str = f"""
+    select
+        sum(l_extendedprice * l_discount) as revenue
+    from
+        {line_item_ds}
+    where
+        l_shipdate >= timestamp '1994-01-01'
+        and l_shipdate < timestamp '1994-01-01' + interval '1' year
+        and l_discount between .06 - 0.01 and .06 + 0.01
+        and l_quantity < 24
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q7.py

@@ -0,0 +1,63 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 7
+
+
+def q():
+    nation_ds = utils.get_nation_ds()
+    customer_ds = utils.get_customer_ds()
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+    supplier_ds = utils.get_supplier_ds()
+
+    query_str = f"""
+    select
+        supp_nation,
+        cust_nation,
+        l_year,
+        sum(volume) as revenue
+    from
+        (
+            select
+                n1.n_name as supp_nation,
+                n2.n_name as cust_nation,
+                year(l_shipdate) as l_year,
+                l_extendedprice * (1 - l_discount) as volume
+            from
+                {supplier_ds},
+                {line_item_ds},
+                {orders_ds},
+                {customer_ds},
+                {nation_ds} n1,
+                {nation_ds} n2
+            where
+                s_suppkey = l_suppkey
+                and o_orderkey = l_orderkey
+                and c_custkey = o_custkey
+                and s_nationkey = n1.n_nationkey
+                and c_nationkey = n2.n_nationkey
+                and (
+                    (n1.n_name = 'FRANCE' and n2.n_name = 'GERMANY')
+                    or (n1.n_name = 'GERMANY' and n2.n_name = 'FRANCE')
+                )
+                and l_shipdate between timestamp '1995-01-01' and timestamp '1996-12-31'
+        ) as shipping
+    group by
+        supp_nation,
+        cust_nation,
+        l_year
+    order by
+        supp_nation,
+        cust_nation,
+        l_year
+    """
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q8.py

@@ -0,0 +1,65 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 8
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    supplier_ds = utils.get_supplier_ds()
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+    customer_ds = utils.get_customer_ds()
+    nation_ds = utils.get_nation_ds()
+    region_ds = utils.get_region_ds()
+
+    query_str = f"""
+    select
+        o_year,
+        round(
+            sum(case
+                when nation = 'BRAZIL' then volume
+                else 0
+            end) / sum(volume)
+        , 2) as mkt_share
+    from
+        (
+            select
+                extract(year from o_orderdate) as o_year,
+                l_extendedprice * (1 - l_discount) as volume,
+                n2.n_name as nation
+            from
+                {part_ds},
+                {supplier_ds},
+                {line_item_ds},
+                {orders_ds},
+                {customer_ds},
+                {nation_ds} n1,
+                {nation_ds} n2,
+                {region_ds}
+            where
+                p_partkey = l_partkey
+                and s_suppkey = l_suppkey
+                and l_orderkey = o_orderkey
+                and o_custkey = c_custkey
+                and c_nationkey = n1.n_nationkey
+                and n1.n_regionkey = r_regionkey
+                and r_name = 'AMERICA'
+                and s_nationkey = n2.n_nationkey
+                and o_orderdate between timestamp '1995-01-01' and timestamp '1996-12-31'
+                and p_type = 'ECONOMY ANODIZED STEEL'
+        ) as all_nations
+    group by
+        o_year
+    order by
+        o_year
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/q9.py

@@ -0,0 +1,57 @@
+import duckdb
+
+from duckdb_queries import utils
+
+Q_NUM = 9
+
+
+def q():
+    part_ds = utils.get_part_ds()
+    supplier_ds = utils.get_supplier_ds()
+    line_item_ds = utils.get_line_item_ds()
+    orders_ds = utils.get_orders_ds()
+    part_supp_ds = utils.get_part_supp_ds()
+    nation_ds = utils.get_nation_ds()
+
+    query_str = f"""
+    select
+        nation,
+        o_year,
+        round(sum(amount), 2) as sum_profit
+    from
+        (
+            select
+                n_name as nation,
+                year(o_orderdate) as o_year,
+                l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity as amount
+            from
+                {part_ds},
+                {supplier_ds},
+                {line_item_ds},
+                {part_supp_ds},
+                {orders_ds},
+                {nation_ds}
+            where
+                s_suppkey = l_suppkey
+                and ps_suppkey = l_suppkey
+                and ps_partkey = l_partkey
+                and p_partkey = l_partkey
+                and o_orderkey = l_orderkey
+                and s_nationkey = n_nationkey
+                and p_name like '%green%'
+        ) as profit
+    group by
+        nation,
+        o_year
+    order by
+        nation,
+        o_year desc
+	"""
+
+    q_final = duckdb.sql(query_str)
+
+    utils.run_query(Q_NUM, q_final)
+
+
+if __name__ == "__main__":
+    q()

duckdb_queries/utils.py

@@ -0,0 +1,115 @@
+import timeit
+from importlib.metadata import version
+from os.path import join
+from typing import Any
+
+import duckdb
+import polars as pl
+from duckdb import DuckDBPyRelation
+from linetimer import CodeTimer, linetimer
+from polars import testing as pl_test
+
+from common_utils import (
+    ANSWERS_BASE_DIR,
+    DATASET_BASE_DIR,
+    FILE_TYPE,
+    INCLUDE_IO,
+    LOG_TIMINGS,
+    SHOW_RESULTS,
+    append_row,
+)
+
+
+def _scan_ds(path: str):
+    path = f"{path}.{FILE_TYPE}"
+    if FILE_TYPE == "parquet":
+        if INCLUDE_IO:
+            duckdb.read_parquet(path)
+            return f"'{path}'"
+        else:
+            name = path.replace("/", "_").replace(".", "_")
+            duckdb.sql(
+                f"create temp table if not exists {name} as select * from read_parquet('{path}');"
+            )
+            return name
+    elif FILE_TYPE == "feather":
+        raise ValueError("duckdb does not support feather for now")
+    else:
+        raise ValueError(f"file type: {FILE_TYPE} not expected")
+    return path
+
+
+def get_query_answer(query: int, base_dir: str = ANSWERS_BASE_DIR) -> pl.LazyFrame:
+    answer_ldf = pl.scan_csv(
+        join(base_dir, f"q{query}.out"),
+        separator="|",
+        has_header=True,
+        try_parse_dates=True,
+    )
+    cols = answer_ldf.columns
+    answer_ldf = answer_ldf.select(
+        [pl.col(c).alias(c.strip()) for c in cols]
+    ).with_columns([pl.col(pl.datatypes.Utf8).str.strip().keep_name()])
+
+    return answer_ldf
+
+
+def test_results(q_num: int, result_df: pl.DataFrame):
+    with CodeTimer(name=f"Testing result of duckdb Query {q_num}", unit="s"):
+        answer = get_query_answer(q_num).collect()
+        pl_test.assert_frame_equal(left=result_df, right=answer, check_dtype=False)
+
+
+def get_line_item_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "lineitem"))
+
+
+def get_orders_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "orders"))
+
+
+def get_customer_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "customer"))
+
+
+def get_region_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "region"))
+
+
+def get_nation_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "nation"))
+
+
+def get_supplier_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "supplier"))
+
+
+def get_part_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "part"))
+
+
+def get_part_supp_ds(base_dir: str = DATASET_BASE_DIR) -> str:
+    return _scan_ds(join(base_dir, "partsupp"))
+
+
+def run_query(q_num: int, context: DuckDBPyRelation):
+    @linetimer(name=f"Overall execution of duckdb Query {q_num}", unit="s")
+    def query():
+        with CodeTimer(name=f"Get result of duckdb Query {q_num}", unit="s"):
+            t0 = timeit.default_timer()
+            # force duckdb to materialize
+            result = context.pl()
+
+            secs = timeit.default_timer() - t0
+
+        if LOG_TIMINGS:
+            append_row(
+                solution="duckdb", version=version("duckdb"), q=f"q{q_num}", secs=secs
+            )
+        else:
+            test_results(q_num, result)
+
+        if SHOW_RESULTS:
+            print(result)
+
+    query()

fireducks_queries/executor.py

@@ -0,0 +1,4 @@
+from common_utils import execute_all
+
+if __name__ == "__main__":
+    execute_all("fireducks")

fireducks_queries/q1.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+
+from fireducks_queries import utils
+
+Q_NUM = 1
+
+
+def q():
+    VAR1 = datetime(1998, 9, 2)
+
+    lineitem = utils.get_line_item_ds
+    # first call one time to cache in case we don't include the IO times
+    lineitem()
+
+    def query():
+        nonlocal lineitem
+        lineitem = lineitem()
+
+        lineitem_filtered = lineitem.loc[
+            :,
+            [
+                "l_quantity",
+                "l_extendedprice",
+                "l_discount",
+                "l_tax",
+                "l_returnflag",
+                "l_linestatus",
+                "l_shipdate",
+                "l_orderkey",
+            ],
+        ]
+        sel = lineitem_filtered.l_shipdate <= VAR1
+        lineitem_filtered = lineitem_filtered[sel]
+        lineitem_filtered["sum_qty"] = lineitem_filtered.l_quantity
+        lineitem_filtered["sum_base_price"] = lineitem_filtered.l_extendedprice
+        lineitem_filtered["avg_qty"] = lineitem_filtered.l_quantity
+        lineitem_filtered["avg_price"] = lineitem_filtered.l_extendedprice
+        lineitem_filtered["sum_disc_price"] = lineitem_filtered.l_extendedprice * (
+            1 - lineitem_filtered.l_discount
+        )
+        lineitem_filtered["sum_charge"] = (
+            lineitem_filtered.l_extendedprice
+            * (1 - lineitem_filtered.l_discount)
+            * (1 + lineitem_filtered.l_tax)
+        )
+        lineitem_filtered["avg_disc"] = lineitem_filtered.l_discount
+        lineitem_filtered["count_order"] = lineitem_filtered.l_orderkey
+        gb = lineitem_filtered.groupby(["l_returnflag", "l_linestatus"])
+
+        total = gb.agg(
+            {
+                "sum_qty": "sum",
+                "sum_base_price": "sum",
+                "sum_disc_price": "sum",
+                "sum_charge": "sum",
+                "avg_qty": "mean",
+                "avg_price": "mean",
+                "avg_disc": "mean",
+                "count_order": "count",
+            }
+        )
+
+        result_df = total.reset_index().sort_values(["l_returnflag", "l_linestatus"])
+
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q2.py

@@ -0,0 +1,159 @@
+from fireducks_queries import utils
+
+Q_NUM = 2
+
+
+def q():
+    var1 = 15
+    var2 = "BRASS"
+    var3 = "EUROPE"
+
+    region_ds = utils.get_region_ds
+    nation_ds = utils.get_nation_ds
+    supplier_ds = utils.get_supplier_ds
+    part_ds = utils.get_part_ds
+    part_supp_ds = utils.get_part_supp_ds
+
+    # first call one time to cache in case we don't include the IO times
+    region_ds()
+    nation_ds()
+    supplier_ds()
+    part_ds()
+    part_supp_ds()
+
+    def query():
+        nonlocal region_ds
+        nonlocal nation_ds
+        nonlocal supplier_ds
+        nonlocal part_ds
+        nonlocal part_supp_ds
+        region_ds = region_ds()
+        nation_ds = nation_ds()
+        supplier_ds = supplier_ds()
+        part_ds = part_ds()
+        part_supp_ds = part_supp_ds()
+
+        nation_filtered = nation_ds.loc[:, ["n_nationkey", "n_name", "n_regionkey"]]
+        region_filtered = region_ds[(region_ds["r_name"] == var3)]
+        region_filtered = region_filtered.loc[:, ["r_regionkey"]]
+        r_n_merged = nation_filtered.merge(
+            region_filtered, left_on="n_regionkey", right_on="r_regionkey", how="inner"
+        )
+        r_n_merged = r_n_merged.loc[:, ["n_nationkey", "n_name"]]
+        supplier_filtered = supplier_ds.loc[
+            :,
+            [
+                "s_suppkey",
+                "s_name",
+                "s_address",
+                "s_nationkey",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+            ],
+        ]
+        s_r_n_merged = r_n_merged.merge(
+            supplier_filtered,
+            left_on="n_nationkey",
+            right_on="s_nationkey",
+            how="inner",
+        )
+        s_r_n_merged = s_r_n_merged.loc[
+            :,
+            [
+                "n_name",
+                "s_suppkey",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+            ],
+        ]
+        partsupp_filtered = part_supp_ds.loc[
+            :, ["ps_partkey", "ps_suppkey", "ps_supplycost"]
+        ]
+        ps_s_r_n_merged = s_r_n_merged.merge(
+            partsupp_filtered, left_on="s_suppkey", right_on="ps_suppkey", how="inner"
+        )
+        ps_s_r_n_merged = ps_s_r_n_merged.loc[
+            :,
+            [
+                "n_name",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+                "ps_partkey",
+                "ps_supplycost",
+            ],
+        ]
+        part_filtered = part_ds.loc[:, ["p_partkey", "p_mfgr", "p_size", "p_type"]]
+        part_filtered = part_filtered[
+            (part_filtered["p_size"] == var1)
+            & (part_filtered["p_type"].str.endswith(var2))
+        ]
+        part_filtered = part_filtered.loc[:, ["p_partkey", "p_mfgr"]]
+        merged_df = part_filtered.merge(
+            ps_s_r_n_merged, left_on="p_partkey", right_on="ps_partkey", how="inner"
+        )
+        merged_df = merged_df.loc[
+            :,
+            [
+                "n_name",
+                "s_name",
+                "s_address",
+                "s_phone",
+                "s_acctbal",
+                "s_comment",
+                "ps_supplycost",
+                "p_partkey",
+                "p_mfgr",
+            ],
+        ]
+        min_values = merged_df.groupby("p_partkey", as_index=False)[
+            "ps_supplycost"
+        ].min()
+        min_values.columns = ["P_PARTKEY_CPY", "MIN_SUPPLYCOST"]
+        merged_df = merged_df.merge(
+            min_values,
+            left_on=["p_partkey", "ps_supplycost"],
+            right_on=["P_PARTKEY_CPY", "MIN_SUPPLYCOST"],
+            how="inner",
+        )
+        result_df = merged_df.loc[
+            :,
+            [
+                "s_acctbal",
+                "s_name",
+                "n_name",
+                "p_partkey",
+                "p_mfgr",
+                "s_address",
+                "s_phone",
+                "s_comment",
+            ],
+        ]
+        result_df = result_df.sort_values(
+            by=[
+                "s_acctbal",
+                "n_name",
+                "s_name",
+                "p_partkey",
+            ],
+            ascending=[
+                False,
+                True,
+                True,
+                True,
+            ],
+        )[:100]
+
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q3.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+
+from fireducks_queries import utils
+
+Q_NUM = 3
+
+
+def q():
+    var1 = var2 = datetime(1995, 3, 15)
+    var3 = "BUILDING"
+
+    customer_ds = utils.get_customer_ds
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+
+    # first call one time to cache in case we don't include the IO times
+    customer_ds()
+    line_item_ds()
+    orders_ds()
+
+    def query():
+        nonlocal customer_ds
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        customer_ds = customer_ds()
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+
+        lineitem_filtered = line_item_ds.loc[
+            :, ["l_orderkey", "l_extendedprice", "l_discount", "l_shipdate"]
+        ]
+        orders_filtered = orders_ds.loc[
+            :, ["o_orderkey", "o_custkey", "o_orderdate", "o_shippriority"]
+        ]
+        customer_filtered = customer_ds.loc[:, ["c_mktsegment", "c_custkey"]]
+        lsel = lineitem_filtered.l_shipdate > var1
+        osel = orders_filtered.o_orderdate < var2
+        csel = customer_filtered.c_mktsegment == var3
+        flineitem = lineitem_filtered[lsel]
+        forders = orders_filtered[osel]
+        fcustomer = customer_filtered[csel]
+        jn1 = fcustomer.merge(forders, left_on="c_custkey", right_on="o_custkey")
+        jn2 = jn1.merge(flineitem, left_on="o_orderkey", right_on="l_orderkey")
+        jn2["revenue"] = jn2.l_extendedprice * (1 - jn2.l_discount)
+
+        total = (
+            jn2.groupby(
+                ["l_orderkey", "o_orderdate", "o_shippriority"], as_index=False
+            )["revenue"]
+            .sum()
+            .sort_values(["revenue"], ascending=False)
+        )
+        result_df = total[:10].loc[
+            :, ["l_orderkey", "revenue", "o_orderdate", "o_shippriority"]
+        ]
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q4.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from fireducks_queries import utils
+
+Q_NUM = 4
+
+
+def q():
+    date1 = datetime(1993, 10, 1)
+    date2 = datetime(1993, 7, 1)
+
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+
+    # first call one time to cache in case we don't include the IO times
+    line_item_ds()
+    orders_ds()
+
+    def query():
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+
+        lsel = line_item_ds.l_commitdate < line_item_ds.l_receiptdate
+        osel = (orders_ds.o_orderdate < date1) & (orders_ds.o_orderdate >= date2)
+        flineitem = line_item_ds[lsel]
+        forders = orders_ds[osel]
+        jn = forders[forders["o_orderkey"].isin(flineitem["l_orderkey"])]
+        result_df = (
+            jn.groupby("o_orderpriority", as_index=False)["o_orderkey"]
+            .count()
+            .sort_values(["o_orderpriority"])
+            .rename(columns={"o_orderkey": "order_count"})
+        )
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q5.py

@@ -0,0 +1,64 @@
+import datetime
+
+from fireducks_queries import utils
+
+Q_NUM = 5
+
+
+def q():
+    date1 = datetime.datetime.strptime("1994-01-01", "%Y-%m-%d")
+    date2 = datetime.datetime.strptime("1995-01-01", "%Y-%m-%d")
+
+    region_ds = utils.get_region_ds
+    nation_ds = utils.get_nation_ds
+    customer_ds = utils.get_customer_ds
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+    supplier_ds = utils.get_supplier_ds
+
+    # first call one time to cache in case we don't include the IO times
+    region_ds()
+    nation_ds()
+    customer_ds()
+    line_item_ds()
+    orders_ds()
+    supplier_ds()
+
+    def query():
+        nonlocal region_ds
+        nonlocal nation_ds
+        nonlocal customer_ds
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        nonlocal supplier_ds
+
+        region_ds = region_ds()
+        nation_ds = nation_ds()
+        customer_ds = customer_ds()
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+        supplier_ds = supplier_ds()
+
+        rsel = region_ds.r_name == "ASIA"
+        osel = (orders_ds.o_orderdate >= date1) & (orders_ds.o_orderdate < date2)
+        forders = orders_ds[osel]
+        fregion = region_ds[rsel]
+        jn1 = fregion.merge(nation_ds, left_on="r_regionkey", right_on="n_regionkey")
+        jn2 = jn1.merge(customer_ds, left_on="n_nationkey", right_on="c_nationkey")
+        jn3 = jn2.merge(forders, left_on="c_custkey", right_on="o_custkey")
+        jn4 = jn3.merge(line_item_ds, left_on="o_orderkey", right_on="l_orderkey")
+        jn5 = supplier_ds.merge(
+            jn4,
+            left_on=["s_suppkey", "s_nationkey"],
+            right_on=["l_suppkey", "n_nationkey"],
+        )
+        jn5["revenue"] = jn5.l_extendedprice * (1.0 - jn5.l_discount)
+        gb = jn5.groupby("n_name", as_index=False)["revenue"].sum()
+        result_df = gb.sort_values("revenue", ascending=False)
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q6.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+
+import fireducks.pandas as pd
+
+from fireducks_queries import utils
+
+Q_NUM = 6
+
+
+def q():
+    date1 = datetime(1994, 1, 1)
+    date2 = datetime(1995, 1, 1)
+    var3 = 24
+
+    line_item_ds = utils.get_line_item_ds
+
+    # first call one time to cache in case we don't include the IO times
+    line_item_ds()
+
+    def query():
+        nonlocal line_item_ds
+        line_item_ds = line_item_ds()
+
+        lineitem_filtered = line_item_ds.loc[
+            :, ["l_quantity", "l_extendedprice", "l_discount", "l_shipdate"]
+        ]
+        sel = (
+            (lineitem_filtered.l_shipdate >= date1)
+            & (lineitem_filtered.l_shipdate < date2)
+            & (lineitem_filtered.l_discount >= 0.05)
+            & (lineitem_filtered.l_discount <= 0.07)
+            & (lineitem_filtered.l_quantity < var3)
+        )
+
+        flineitem = lineitem_filtered[sel]
+        result_value = (flineitem.l_extendedprice * flineitem.l_discount).sum()
+        result_df = pd.DataFrame({"revenue": [result_value]})
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()

fireducks_queries/q7.py

@@ -0,0 +1,137 @@
+from datetime import datetime
+
+import fireducks.pandas as pd
+
+from fireducks_queries import utils
+
+Q_NUM = 7
+
+
+def q():
+    nation_ds = utils.get_nation_ds
+    customer_ds = utils.get_customer_ds
+    line_item_ds = utils.get_line_item_ds
+    orders_ds = utils.get_orders_ds
+    supplier_ds = utils.get_supplier_ds
+
+    # first call one time to cache in case we don't include the IO times
+    nation_ds()
+    customer_ds()
+    line_item_ds()
+    orders_ds()
+    supplier_ds()
+
+    def query():
+        nonlocal nation_ds
+        nonlocal customer_ds
+        nonlocal line_item_ds
+        nonlocal orders_ds
+        nonlocal supplier_ds
+
+        nation_ds = nation_ds()
+        customer_ds = customer_ds()
+        line_item_ds = line_item_ds()
+        orders_ds = orders_ds()
+        supplier_ds = supplier_ds()
+
+        lineitem_filtered = line_item_ds[
+            (line_item_ds["l_shipdate"] >= datetime(1995, 1, 1))
+            & (line_item_ds["l_shipdate"] < datetime(1997, 1, 1))
+        ]
+        lineitem_filtered["l_year"] = lineitem_filtered["l_shipdate"].dt.year
+        lineitem_filtered["revenue"] = lineitem_filtered["l_extendedprice"] * (
+            1.0 - lineitem_filtered["l_discount"]
+        )
+        lineitem_filtered = lineitem_filtered.loc[
+            :, ["l_orderkey", "l_suppkey", "l_year", "revenue"]
+        ]
+        supplier_filtered = supplier_ds.loc[:, ["s_suppkey", "s_nationkey"]]
+        orders_filtered = orders_ds.loc[:, ["o_orderkey", "o_custkey"]]
+        customer_filtered = customer_ds.loc[:, ["c_custkey", "c_nationkey"]]
+        n1 = nation_ds[(nation_ds["n_name"] == "FRANCE")].loc[
+            :, ["n_nationkey", "n_name"]
+        ]
+        n2 = nation_ds[(nation_ds["n_name"] == "GERMANY")].loc[
+            :, ["n_nationkey", "n_name"]
+        ]
+
+        # ----- do nation 1 -----
+        N1_C = customer_filtered.merge(
+            n1, left_on="c_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N1_C = N1_C.drop(columns=["c_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "cust_nation"}
+        )
+        N1_C_O = N1_C.merge(
+            orders_filtered, left_on="c_custkey", right_on="o_custkey", how="inner"
+        )
+        N1_C_O = N1_C_O.drop(columns=["c_custkey", "o_custkey"])
+
+        N2_S = supplier_filtered.merge(
+            n2, left_on="s_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N2_S = N2_S.drop(columns=["s_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "supp_nation"}
+        )
+        N2_S_L = N2_S.merge(
+            lineitem_filtered, left_on="s_suppkey", right_on="l_suppkey", how="inner"
+        )
+        N2_S_L = N2_S_L.drop(columns=["s_suppkey", "l_suppkey"])
+
+        total1 = N1_C_O.merge(
+            N2_S_L, left_on="o_orderkey", right_on="l_orderkey", how="inner"
+        )
+        total1 = total1.drop(columns=["o_orderkey", "l_orderkey"])
+
+        # ----- do nation 2 ----- (same as nation 1 section but with nation 2)
+        N2_C = customer_filtered.merge(
+            n2, left_on="c_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N2_C = N2_C.drop(columns=["c_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "cust_nation"}
+        )
+        N2_C_O = N2_C.merge(
+            orders_filtered, left_on="c_custkey", right_on="o_custkey", how="inner"
+        )
+        N2_C_O = N2_C_O.drop(columns=["c_custkey", "o_custkey"])
+
+        N1_S = supplier_filtered.merge(
+            n1, left_on="s_nationkey", right_on="n_nationkey", how="inner"
+        )
+        N1_S = N1_S.drop(columns=["s_nationkey", "n_nationkey"]).rename(
+            columns={"n_name": "supp_nation"}
+        )
+        N1_S_L = N1_S.merge(
+            lineitem_filtered, left_on="s_suppkey", right_on="l_suppkey", how="inner"
+        )
+        N1_S_L = N1_S_L.drop(columns=["s_suppkey", "l_suppkey"])
+
+        total2 = N2_C_O.merge(
+            N1_S_L, left_on="o_orderkey", right_on="l_orderkey", how="inner"
+        )
+        total2 = total2.drop(columns=["o_orderkey", "l_orderkey"])
+
+        # concat results
+        total = pd.concat([total1, total2])
+        result_df = (
+            total.groupby(["supp_nation", "cust_nation", "l_year"])
+            .revenue.agg("sum")
+            .reset_index()
+        )
+        result_df.columns = ["supp_nation", "cust_nation", "l_year", "revenue"]
+
+        result_df = result_df.sort_values(
+            by=["supp_nation", "cust_nation", "l_year"],
+            ascending=[
+                True,
+                True,
+                True,
+            ],
+        )
+        return result_df
+
+    utils.run_query(Q_NUM, query)
+
+
+if __name__ == "__main__":
+    q()