cudf-polars-cu13 25.10.0__py3-none-any.whl

cudf_polars/experimental/benchmarks/pdsds_queries/q10.py

@@ -0,0 +1,225 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Query 10."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+from cudf_polars.experimental.benchmarks.utils import get_data
+
+if TYPE_CHECKING:
+    from cudf_polars.experimental.benchmarks.utils import RunConfig
+
+
+def duckdb_impl(run_config: RunConfig) -> str:
+    """Query 10."""
+    return """
+    SELECT cd_gender,
+                   cd_marital_status,
+                   cd_education_status,
+                   Count(*) cnt1,
+                   cd_purchase_estimate,
+                   Count(*) cnt2,
+                   cd_credit_rating,
+                   Count(*) cnt3,
+                   cd_dep_count,
+                   Count(*) cnt4,
+                   cd_dep_employed_count,
+                   Count(*) cnt5,
+                   cd_dep_college_count,
+                   Count(*) cnt6
+    FROM   customer c,
+           customer_address ca,
+           customer_demographics
+    WHERE  c.c_current_addr_sk = ca.ca_address_sk
+           AND ca_county IN ( 'Lycoming County', 'Sheridan County',
+                              'Kandiyohi County',
+                              'Pike County',
+                                               'Greene County' )
+           AND cd_demo_sk = c.c_current_cdemo_sk
+           AND EXISTS (SELECT *
+                       FROM   store_sales,
+                              date_dim
+                       WHERE  c.c_customer_sk = ss_customer_sk
+                              AND ss_sold_date_sk = d_date_sk
+                              AND d_year = 2002
+                              AND d_moy BETWEEN 4 AND 4 + 3)
+           AND ( EXISTS (SELECT *
+                         FROM   web_sales,
+                                date_dim
+                         WHERE  c.c_customer_sk = ws_bill_customer_sk
+                                AND ws_sold_date_sk = d_date_sk
+                                AND d_year = 2002
+                                AND d_moy BETWEEN 4 AND 4 + 3)
+                  OR EXISTS (SELECT *
+                             FROM   catalog_sales,
+                                    date_dim
+                             WHERE  c.c_customer_sk = cs_ship_customer_sk
+                                    AND cs_sold_date_sk = d_date_sk
+                                    AND d_year = 2002
+                                    AND d_moy BETWEEN 4 AND 4 + 3) )
+    GROUP  BY cd_gender,
+              cd_marital_status,
+              cd_education_status,
+              cd_purchase_estimate,
+              cd_credit_rating,
+              cd_dep_count,
+              cd_dep_employed_count,
+              cd_dep_college_count
+    ORDER  BY cd_gender,
+              cd_marital_status,
+              cd_education_status,
+              cd_purchase_estimate,
+              cd_credit_rating,
+              cd_dep_count,
+              cd_dep_employed_count,
+              cd_dep_college_count
+    LIMIT 100;
+    """
+
+
+def polars_impl(run_config: RunConfig) -> pl.LazyFrame:
+    """Query 10."""
+    # Load required tables
+    customer = get_data(run_config.dataset_path, "customer", run_config.suffix)
+    customer_address = get_data(
+        run_config.dataset_path, "customer_address", run_config.suffix
+    )
+    customer_demographics = get_data(
+        run_config.dataset_path, "customer_demographics", run_config.suffix
+    )
+    store_sales = get_data(run_config.dataset_path, "store_sales", run_config.suffix)
+    web_sales = get_data(run_config.dataset_path, "web_sales", run_config.suffix)
+    catalog_sales = get_data(
+        run_config.dataset_path, "catalog_sales", run_config.suffix
+    )
+    date_dim = get_data(run_config.dataset_path, "date_dim", run_config.suffix)
+
+    # Target counties and date range
+    target_counties = [
+        "Lycoming County",
+        "Sheridan County",
+        "Kandiyohi County",
+        "Pike County",
+        "Greene County",
+    ]
+
+    # Get customers with store sales in the target period (EXISTS condition 1)
+    store_customers = (
+        store_sales.join(date_dim, left_on="ss_sold_date_sk", right_on="d_date_sk")
+        .filter(
+            (pl.col("d_year") == 2002)
+            & (pl.col("d_moy").is_between(4, 7, closed="both"))
+        )
+        .select("ss_customer_sk")
+        .unique()
+    )
+
+    # Get customers with web sales in the target period (EXISTS condition 2a)
+    web_customers = (
+        web_sales.join(date_dim, left_on="ws_sold_date_sk", right_on="d_date_sk")
+        .filter(
+            (pl.col("d_year") == 2002)
+            & (pl.col("d_moy").is_between(4, 7, closed="both"))
+        )
+        .select(pl.col("ws_bill_customer_sk").alias("customer_sk"))
+        .unique()
+    )
+
+    # Get customers with catalog sales in the target period (EXISTS condition 2b)
+    catalog_customers = (
+        catalog_sales.join(date_dim, left_on="cs_sold_date_sk", right_on="d_date_sk")
+        .filter(
+            (pl.col("d_year") == 2002)
+            & (pl.col("d_moy").is_between(4, 7, closed="both"))
+        )
+        .select(pl.col("cs_ship_customer_sk").alias("customer_sk"))
+        .unique()
+    )
+
+    # Combine web and catalog customers (OR condition)
+    web_or_catalog_customers = pl.concat([web_customers, catalog_customers]).unique()
+
+    # Main query: join customer tables and apply filters
+    return (
+        customer.join(
+            customer_address, left_on="c_current_addr_sk", right_on="ca_address_sk"
+        )
+        .join(
+            customer_demographics, left_on="c_current_cdemo_sk", right_on="cd_demo_sk"
+        )
+        .filter(pl.col("ca_county").is_in(target_counties))
+        # Apply EXISTS conditions through joins
+        .join(
+            store_customers,
+            left_on="c_customer_sk",
+            right_on="ss_customer_sk",
+            how="inner",
+        )
+        .join(
+            web_or_catalog_customers,
+            left_on="c_customer_sk",
+            right_on="customer_sk",
+            how="inner",
+        )
+        .group_by(
+            [
+                "cd_gender",
+                "cd_marital_status",
+                "cd_education_status",
+                "cd_purchase_estimate",
+                "cd_credit_rating",
+                "cd_dep_count",
+                "cd_dep_employed_count",
+                "cd_dep_college_count",
+            ]
+        )
+        .agg(
+            [
+                # Cast -> Int64 to match DuckDB
+                # TODO: We should plan to make these optional
+                pl.len().alias("cnt1").cast(pl.Int64),
+                pl.len().alias("cnt2").cast(pl.Int64),
+                pl.len().alias("cnt3").cast(pl.Int64),
+                pl.len().alias("cnt4").cast(pl.Int64),
+                pl.len().alias("cnt5").cast(pl.Int64),
+                pl.len().alias("cnt6").cast(pl.Int64),
+            ]
+        )
+        .sort(
+            [
+                "cd_gender",
+                "cd_marital_status",
+                "cd_education_status",
+                "cd_purchase_estimate",
+                "cd_credit_rating",
+                "cd_dep_count",
+                "cd_dep_employed_count",
+                "cd_dep_college_count",
+            ],
+            nulls_last=True,
+        )
+        .limit(100)
+        .select(
+            [
+                "cd_gender",
+                "cd_marital_status",
+                "cd_education_status",
+                "cnt1",
+                "cd_purchase_estimate",
+                "cnt2",
+                "cd_credit_rating",
+                "cnt3",
+                "cd_dep_count",
+                "cnt4",
+                "cd_dep_employed_count",
+                "cnt5",
+                "cd_dep_college_count",
+                "cnt6",
+            ]
+        )
+    )

cudf_polars/experimental/benchmarks/pdsds_queries/q2.py

@@ -0,0 +1,244 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Query 2."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+from cudf_polars.experimental.benchmarks.utils import get_data
+
+if TYPE_CHECKING:
+    from cudf_polars.experimental.benchmarks.utils import RunConfig
+
+
+def duckdb_impl(run_config: RunConfig) -> str:
+    """Query 2."""
+    return """
+    WITH wscs
+         AS (SELECT sold_date_sk,
+                    sales_price
+             FROM   (SELECT ws_sold_date_sk    sold_date_sk,
+                            ws_ext_sales_price sales_price
+                     FROM   web_sales)
+             UNION ALL
+             (SELECT cs_sold_date_sk    sold_date_sk,
+                     cs_ext_sales_price sales_price
+              FROM   catalog_sales)),
+         wswscs
+         AS (SELECT d_week_seq,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Sunday' ) THEN sales_price
+                          ELSE NULL
+                        END) sun_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Monday' ) THEN sales_price
+                          ELSE NULL
+                        END) mon_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Tuesday' ) THEN sales_price
+                          ELSE NULL
+                        END) tue_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Wednesday' ) THEN sales_price
+                          ELSE NULL
+                        END) wed_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Thursday' ) THEN sales_price
+                          ELSE NULL
+                        END) thu_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Friday' ) THEN sales_price
+                          ELSE NULL
+                        END) fri_sales,
+                    Sum(CASE
+                          WHEN ( d_day_name = 'Saturday' ) THEN sales_price
+                          ELSE NULL
+                        END) sat_sales
+             FROM   wscs,
+                    date_dim
+             WHERE  d_date_sk = sold_date_sk
+             GROUP  BY d_week_seq)
+    SELECT d_week_seq1,
+           Round(sun_sales1 / sun_sales2, 2),
+           Round(mon_sales1 / mon_sales2, 2),
+           Round(tue_sales1 / tue_sales2, 2),
+           Round(wed_sales1 / wed_sales2, 2),
+           Round(thu_sales1 / thu_sales2, 2),
+           Round(fri_sales1 / fri_sales2, 2),
+           Round(sat_sales1 / sat_sales2, 2)
+    FROM   (SELECT wswscs.d_week_seq d_week_seq1,
+                   sun_sales         sun_sales1,
+                   mon_sales         mon_sales1,
+                   tue_sales         tue_sales1,
+                   wed_sales         wed_sales1,
+                   thu_sales         thu_sales1,
+                   fri_sales         fri_sales1,
+                   sat_sales         sat_sales1
+            FROM   wswscs,
+                   date_dim
+            WHERE  date_dim.d_week_seq = wswscs.d_week_seq
+                   AND d_year = 1998) y,
+           (SELECT wswscs.d_week_seq d_week_seq2,
+                   sun_sales         sun_sales2,
+                   mon_sales         mon_sales2,
+                   tue_sales         tue_sales2,
+                   wed_sales         wed_sales2,
+                   thu_sales         thu_sales2,
+                   fri_sales         fri_sales2,
+                   sat_sales         sat_sales2
+            FROM   wswscs,
+                   date_dim
+            WHERE  date_dim.d_week_seq = wswscs.d_week_seq
+                   AND d_year = 1998 + 1) z
+    WHERE  d_week_seq1 = d_week_seq2 - 53
+    ORDER  BY d_week_seq1;
+    """
+
+
+def polars_impl(run_config: RunConfig) -> pl.LazyFrame:
+    """Query 2."""
+    # Load required tables
+    web_sales = get_data(run_config.dataset_path, "web_sales", run_config.suffix)
+    catalog_sales = get_data(
+        run_config.dataset_path, "catalog_sales", run_config.suffix
+    )
+    date_dim = get_data(run_config.dataset_path, "date_dim", run_config.suffix)
+    # Step 1: Create wscs CTE equivalent (union of web and catalog sales)
+    wscs = pl.concat(
+        [
+            web_sales.select(
+                [
+                    pl.col("ws_sold_date_sk").alias("sold_date_sk"),
+                    pl.col("ws_ext_sales_price").alias("sales_price"),
+                ]
+            ),
+            catalog_sales.select(
+                [
+                    pl.col("cs_sold_date_sk").alias("sold_date_sk"),
+                    pl.col("cs_ext_sales_price").alias("sales_price"),
+                ]
+            ),
+        ]
+    )
+    # Step 2: Create wswscs CTE equivalent (aggregate by week and day of week)
+    # First join with date_dim to get day names
+    wscs_with_dates = wscs.join(date_dim, left_on="sold_date_sk", right_on="d_date_sk")
+    # Create separate aggregations for each day to better control null handling
+    days = (
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+    )
+    day_cols = (
+        "sun_sales",
+        "mon_sales",
+        "tue_sales",
+        "wed_sales",
+        "thu_sales",
+        "fri_sales",
+        "sat_sales",
+    )
+    # Start with all week sequences
+    all_weeks = wscs_with_dates.select("d_week_seq").unique()
+    wswscs = all_weeks
+
+    wswscs = (
+        wscs_with_dates.with_columns(
+            [
+                pl.when(pl.col("d_day_name") == day)
+                .then(pl.col("sales_price"))
+                .otherwise(None)
+                .alias(name)
+                for day, name in zip(days, day_cols, strict=True)
+            ]
+        )
+        .group_by("d_week_seq")
+        .agg(
+            *(pl.col(name).sum().alias(name) for name in day_cols),
+            *(pl.col(name).count().alias(f"{name}_count") for name in day_cols),
+        )
+        .with_columns(
+            [
+                pl.when(pl.col(f"{name}_count") > 0)
+                .then(pl.col(name))
+                .otherwise(None)
+                .alias(name)
+                for name in day_cols
+            ]
+        )
+        .select(["d_week_seq", *day_cols])
+    )
+
+    # Step 3: Create year 1998 data (y subquery equivalent)
+    y_1998 = (
+        wswscs.join(date_dim, left_on="d_week_seq", right_on="d_week_seq")
+        .filter(pl.col("d_year") == 1998)
+        .select(
+            [
+                pl.col("d_week_seq").alias("d_week_seq1"),
+                pl.col("sun_sales").alias("sun_sales1"),
+                pl.col("mon_sales").alias("mon_sales1"),
+                pl.col("tue_sales").alias("tue_sales1"),
+                pl.col("wed_sales").alias("wed_sales1"),
+                pl.col("thu_sales").alias("thu_sales1"),
+                pl.col("fri_sales").alias("fri_sales1"),
+                pl.col("sat_sales").alias("sat_sales1"),
+            ]
+        )
+    )
+    # Step 4: Create year 1999 data (z subquery equivalent)
+    z_1999 = (
+        wswscs.join(date_dim, left_on="d_week_seq", right_on="d_week_seq")
+        .filter(pl.col("d_year") == 1999)
+        .select(
+            [
+                pl.col("d_week_seq").alias("d_week_seq2"),
+                pl.col("sun_sales").alias("sun_sales2"),
+                pl.col("mon_sales").alias("mon_sales2"),
+                pl.col("tue_sales").alias("tue_sales2"),
+                pl.col("wed_sales").alias("wed_sales2"),
+                pl.col("thu_sales").alias("thu_sales2"),
+                pl.col("fri_sales").alias("fri_sales2"),
+                pl.col("sat_sales").alias("sat_sales2"),
+            ]
+        )
+    )
+    # Step 5: Join the two years and calculate ratios
+    return (
+        y_1998.join(z_1999, left_on="d_week_seq1", right_on=pl.col("d_week_seq2") - 53)
+        .select(
+            [
+                pl.col("d_week_seq1"),
+                (pl.col("sun_sales1") / pl.col("sun_sales2"))
+                .round(2)
+                .alias("round((sun_sales1 / sun_sales2), 2)"),
+                (pl.col("mon_sales1") / pl.col("mon_sales2"))
+                .round(2)
+                .alias("round((mon_sales1 / mon_sales2), 2)"),
+                (pl.col("tue_sales1") / pl.col("tue_sales2"))
+                .round(2)
+                .alias("round((tue_sales1 / tue_sales2), 2)"),
+                (pl.col("wed_sales1") / pl.col("wed_sales2"))
+                .round(2)
+                .alias("round((wed_sales1 / wed_sales2), 2)"),
+                (pl.col("thu_sales1") / pl.col("thu_sales2"))
+                .round(2)
+                .alias("round((thu_sales1 / thu_sales2), 2)"),
+                (pl.col("fri_sales1") / pl.col("fri_sales2"))
+                .round(2)
+                .alias("round((fri_sales1 / fri_sales2), 2)"),
+                (pl.col("sat_sales1") / pl.col("sat_sales2"))
+                .round(2)
+                .alias("round((sat_sales1 / sat_sales2), 2)"),
+            ]
+        )
+        .sort("d_week_seq1")
+    )

cudf_polars/experimental/benchmarks/pdsds_queries/q3.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Query 3."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+from cudf_polars.experimental.benchmarks.utils import get_data
+
+if TYPE_CHECKING:
+    from cudf_polars.experimental.benchmarks.utils import RunConfig
+
+
+def duckdb_impl(run_config: RunConfig) -> str:
+    """Query 3."""
+    return """
+    SELECT dt.d_year,
+                   item.i_brand_id          brand_id,
+                   item.i_brand             brand,
+                   Sum(ss_ext_discount_amt) sum_agg
+    FROM   date_dim dt,
+           store_sales,
+           item
+    WHERE  dt.d_date_sk = store_sales.ss_sold_date_sk
+           AND store_sales.ss_item_sk = item.i_item_sk
+           AND item.i_manufact_id = 427
+           AND dt.d_moy = 11
+    GROUP  BY dt.d_year,
+              item.i_brand,
+              item.i_brand_id
+    ORDER  BY dt.d_year,
+              sum_agg DESC,
+              brand_id
+    LIMIT 100;
+    """
+
+
+def polars_impl(run_config: RunConfig) -> pl.LazyFrame:
+    """Query 3."""
+    # Load required tables
+    date_dim = get_data(run_config.dataset_path, "date_dim", run_config.suffix)
+    store_sales = get_data(run_config.dataset_path, "store_sales", run_config.suffix)
+    item = get_data(run_config.dataset_path, "item", run_config.suffix)
+    # Execute the query following the SQL logic
+    return (
+        date_dim.join(store_sales, left_on="d_date_sk", right_on="ss_sold_date_sk")
+        .join(item, left_on="ss_item_sk", right_on="i_item_sk")
+        .filter((pl.col("i_manufact_id") == 427) & (pl.col("d_moy") == 11))
+        .group_by(["d_year", "i_brand", "i_brand_id"])
+        .agg([pl.col("ss_ext_discount_amt").sum().alias("sum_agg")])
+        .select(
+            [
+                pl.col("d_year"),
+                pl.col("i_brand_id").alias("brand_id"),
+                pl.col("i_brand").alias("brand"),
+                pl.col("sum_agg"),
+            ]
+        )
+        .sort(["d_year", "sum_agg", "brand_id"], descending=[False, True, False])
+        .limit(100)
+    )