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

cudf_polars/dsl/utils/aggregations.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import itertools
+from decimal import Decimal
 from functools import partial
 from typing import TYPE_CHECKING, Any
 
@@ -16,7 +17,7 @@ import pylibcudf as plc
 from cudf_polars.containers import DataType
 from cudf_polars.dsl import expr, ir
 from cudf_polars.dsl.expressions.base import ExecutionContext
-from cudf_polars.utils.versions import POLARS_VERSION_LT_1323
+from cudf_polars.utils.versions import POLARS_VERSION_LT_134, POLARS_VERSION_LT_1323
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator, Iterable, Sequence
@@ -45,6 +46,11 @@ def replace_nulls(col: expr.Expr, value: Any, *, is_top: bool) -> expr.Expr:
     """
     if not is_top:
         return col
+    if isinstance(value, int) and value == 0:
+        dtype = col.dtype.plc_type
+        value = (
+            Decimal(0).scaleb(dtype.scale()) if plc.traits.is_fixed_point(dtype) else 0
+        )
     return expr.UnaryFunction(
         col.dtype, "fill_null", (), col, expr.Literal(col.dtype, value)
     )
@@ -91,17 +97,25 @@ def decompose_single_agg(
     name = named_expr.name
     if isinstance(agg, expr.UnaryFunction) and agg.name in {
         "rank",
+        "fill_null_with_strategy",
+        "cum_sum",
     }:
         if context != ExecutionContext.WINDOW:
             raise NotImplementedError(
                 f"{agg.name} is not supported in groupby or rolling context"
             )
+        if agg.name == "fill_null_with_strategy" and (
+            strategy := agg.options[0]
+        ) not in {"forward", "backward"}:
+            raise NotImplementedError(
+                f"fill_null({strategy=}) not supported in a groupy or rolling context"
+            )
         # Ensure Polars semantics for dtype:
         # - average -> Float64
         # - min/max/dense/ordinal -> IDX_DTYPE (UInt32/UInt64)
         post_col: expr.Expr = expr.Col(agg.dtype, name)
         if agg.name == "rank":
-            post_col = expr.Cast(agg.dtype, post_col)
+            post_col = expr.Cast(agg.dtype, True, post_col)  # noqa: FBT003
 
         return [(named_expr, True)], named_expr.reconstruct(post_col)
     if isinstance(agg, expr.UnaryFunction) and agg.name == "null_count":
@@ -117,10 +131,10 @@ def decompose_single_agg(
         sum_name = next(name_generator)
         sum_agg = expr.NamedExpr(
             sum_name,
-            expr.Agg(u32, "sum", (), expr.Cast(u32, is_null_bool)),
+            expr.Agg(u32, "sum", (), context, expr.Cast(u32, True, is_null_bool)),  # noqa: FBT003
         )
         return [(sum_agg, True)], named_expr.reconstruct(
-            expr.Cast(u32, expr.Col(u32, sum_name))
+            expr.Cast(u32, True, expr.Col(u32, sum_name))  # noqa: FBT003
         )
     if isinstance(agg, expr.Col):
         # TODO: collect_list produces null for empty group in libcudf, empty list in polars.
@@ -146,15 +160,6 @@ def decompose_single_agg(
         return [(named_expr, True)], named_expr.reconstruct(expr.Col(agg.dtype, name))
     if isinstance(agg, (expr.Literal, expr.LiteralColumn)):
         return [], named_expr
-    if (
-        is_top
-        and isinstance(agg, expr.UnaryFunction)
-        and agg.name == "fill_null_with_strategy"
-    ):
-        strategy, _ = agg.options
-        raise NotImplementedError(
-            f"fill_null_with_strategy({strategy!r}) is not supported in groupby aggregations"
-        )
     if isinstance(agg, expr.Agg):
         if agg.name == "quantile":
             # Second child the requested quantile (which is asserted
@@ -163,7 +168,7 @@ def decompose_single_agg(
         else:
             (child,) = agg.children
         needs_masking = agg.name in {"min", "max"} and plc.traits.is_floating_point(
-            child.dtype.plc
+            child.dtype.plc_type
         )
         if needs_masking and agg.options:
             # pl.col("a").nan_max or nan_min
@@ -177,7 +182,7 @@ def decompose_single_agg(
         if any(has_agg for _, has_agg in aggs):
             raise NotImplementedError("Nested aggs in groupby not supported")
 
-        child_dtype = child.dtype.plc
+        child_dtype = child.dtype.plc_type
         req = agg.agg_request
         is_median = agg.name == "median"
         is_quantile = agg.name == "quantile"
@@ -186,18 +191,22 @@ def decompose_single_agg(
         # mean/median on decimal: Polars returns float -> pre-cast
         decimal_unsupported = False
         if plc.traits.is_fixed_point(child_dtype):
-            if is_quantile:
+            cast_for_quantile = is_quantile and not POLARS_VERSION_LT_134
+            cast_for_mean_or_median = (
+                agg.name in {"mean", "median"}
+            ) and plc.traits.is_floating_point(agg.dtype.plc_type)
+
+            if cast_for_quantile or cast_for_mean_or_median:
+                child = expr.Cast(
+                    agg.dtype
+                    if plc.traits.is_floating_point(agg.dtype.plc_type)
+                    else DataType(pl.Float64()),
+                    True,  # noqa: FBT003
+                    child,
+                )
+                child_dtype = child.dtype.plc_type
+            elif is_quantile and POLARS_VERSION_LT_134:  # pragma: no cover
                 decimal_unsupported = True
-            elif agg.name in {"mean", "median"}:
-                tid = agg.dtype.plc.id()
-                if tid in {plc.TypeId.FLOAT32, plc.TypeId.FLOAT64}:
-                    cast_to = (
-                        DataType(pl.Float64)
-                        if tid == plc.TypeId.FLOAT64
-                        else DataType(pl.Float32)
-                    )
-                    child = expr.Cast(cast_to, child)
-                    child_dtype = child.dtype.plc
 
         is_group_quantile_supported = plc.traits.is_integral(
             child_dtype
@@ -221,9 +230,13 @@ def decompose_single_agg(
 
         if agg.name == "sum":
             col = (
-                expr.Cast(agg.dtype, expr.Col(DataType(pl.datatypes.Int64()), name))
+                expr.Cast(
+                    agg.dtype,
+                    True,  # noqa: FBT003
+                    expr.Col(DataType(pl.datatypes.Int64()), name),
+                )
                 if (
-                    plc.traits.is_integral(agg.dtype.plc)
+                    plc.traits.is_integral(agg.dtype.plc_type)
                     and agg.dtype.id() != plc.TypeId.INT64
                 )
                 else expr.Col(agg.dtype, name)
@@ -272,9 +285,9 @@ def decompose_single_agg(
             post_agg_col: expr.Expr = expr.Col(
                 DataType(pl.Float64()), name
             )  # libcudf promotes to float64
-            if agg.dtype.plc.id() == plc.TypeId.FLOAT32:
+            if agg.dtype.plc_type.id() == plc.TypeId.FLOAT32:
                 # Cast back to float32 to match Polars
-                post_agg_col = expr.Cast(agg.dtype, post_agg_col)
+                post_agg_col = expr.Cast(agg.dtype, True, post_agg_col)  # noqa: FBT003
             return [(named_expr, True)], named_expr.reconstruct(post_agg_col)
         else:
             return [(named_expr, True)], named_expr.reconstruct(

cudf_polars/dsl/utils/reshape.py

@@ -4,12 +4,19 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import pylibcudf as plc
 
 from cudf_polars.containers import Column
 
+if TYPE_CHECKING:
+    from rmm.pylibrmm.stream import Stream
+
 
-def broadcast(*columns: Column, target_length: int | None = None) -> list[Column]:
+def broadcast(
+    *columns: Column, target_length: int | None = None, stream: Stream
+) -> list[Column]:
     """
     Broadcast a sequence of columns to a common length.
 
@@ -20,6 +27,9 @@ def broadcast(*columns: Column, target_length: int | None = None) -> list[Column
     target_length
         Optional length to broadcast to. If not provided, uses the
         non-unit length of existing columns.
+    stream
+        CUDA stream used for device memory operations and kernel launches
+        on this dataframe.
 
     Returns
     -------
@@ -63,7 +73,9 @@ def broadcast(*columns: Column, target_length: int | None = None) -> list[Column
         column
         if column.size != 1
         else Column(
-            plc.Column.from_scalar(column.obj_scalar, nrows),
+            plc.Column.from_scalar(
+                column.obj_scalar(stream=stream), nrows, stream=stream
+            ),
             is_sorted=plc.types.Sorted.YES,
             order=plc.types.Order.ASCENDING,
             null_order=plc.types.NullOrder.BEFORE,

cudf_polars/dsl/utils/rolling.py

@@ -13,7 +13,7 @@ from cudf_polars.dsl import expr, ir
 from cudf_polars.dsl.expressions.base import ExecutionContext
 from cudf_polars.dsl.utils.aggregations import apply_pre_evaluation
 from cudf_polars.dsl.utils.naming import unique_names
-from cudf_polars.dsl.utils.windows import offsets_to_windows
+from cudf_polars.dsl.utils.windows import duration_to_int
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -74,10 +74,13 @@ def rewrite_rolling(
     index_name = options.rolling.index_column
     index_dtype = schema[index_name]
     index_col = expr.Col(index_dtype, index_name)
-    if plc.traits.is_integral(index_dtype.plc) and index_dtype.id() != plc.TypeId.INT64:
+    if (
+        plc.traits.is_integral(index_dtype.plc_type)
+        and index_dtype.id() != plc.TypeId.INT64
+    ):
         plc_index_dtype = plc.DataType(plc.TypeId.INT64)
     else:
-        plc_index_dtype = index_dtype.plc
+        plc_index_dtype = index_dtype.plc_type
     index = expr.NamedExpr(index_name, index_col)
     temp_prefix = "_" * max(map(len, schema))
     if len(aggs) > 0:
@@ -92,9 +95,9 @@ def rewrite_rolling(
     else:
         rolling_schema = schema
         apply_post_evaluation = lambda inp: inp  # noqa: E731
-    preceding, following = offsets_to_windows(
-        plc_index_dtype, options.rolling.offset, options.rolling.period
-    )
+    preceding_ordinal = duration_to_int(plc_index_dtype, *options.rolling.offset)
+    following_ordinal = duration_to_int(plc_index_dtype, *options.rolling.period)
+
     if (n := len(keys)) > 0:
         # Grouped rolling in polars sorts the output by the groups.
         inp = ir.Sort(
@@ -110,8 +113,9 @@ def rewrite_rolling(
         ir.Rolling(
             rolling_schema,
             index,
-            preceding,
-            following,
+            plc_index_dtype,
+            preceding_ordinal,
+            following_ordinal,
             options.rolling.closed_window,
             keys,
             aggs,

cudf_polars/dsl/utils/windows.py

@@ -12,7 +12,9 @@ import polars as pl
 import pylibcudf as plc
 
 if TYPE_CHECKING:
-    from cudf_polars.typing import ClosedInterval, Duration
+    from rmm.pylibrmm.stream import Stream
+
+    from cudf_polars.typing import ClosedInterval
 
 
 __all__ = [
@@ -75,7 +77,7 @@ def duration_to_int(
     return -value if negative else value
 
 
-def duration_to_scalar(dtype: plc.DataType, value: int) -> plc.Scalar:
+def duration_to_scalar(dtype: plc.DataType, value: int, stream: Stream) -> plc.Scalar:
     """
     Convert a raw polars duration value to a pylibcudf scalar.
 
@@ -86,6 +88,9 @@ def duration_to_scalar(dtype: plc.DataType, value: int) -> plc.Scalar:
     value
         The raw value as in integer. If `dtype` represents a timestamp
         type, this should be in nanoseconds.
+    stream
+        CUDA stream used for device memory operations and kernel launches
+        on this dataframe. The returned scalar will be valid on this stream.
 
     Returns
     -------
@@ -99,20 +104,28 @@ def duration_to_scalar(dtype: plc.DataType, value: int) -> plc.Scalar:
     """
     tid = dtype.id()
     if tid == plc.TypeId.INT64:
-        return plc.Scalar.from_py(value, dtype)
+        return plc.Scalar.from_py(value, dtype, stream=stream)
     elif tid == plc.TypeId.TIMESTAMP_NANOSECONDS:
-        return plc.Scalar.from_py(value, plc.DataType(plc.TypeId.DURATION_NANOSECONDS))
+        return plc.Scalar.from_py(
+            value, plc.DataType(plc.TypeId.DURATION_NANOSECONDS), stream=stream
+        )
     elif tid == plc.TypeId.TIMESTAMP_MICROSECONDS:
         return plc.Scalar.from_py(
-            value // 1000, plc.DataType(plc.TypeId.DURATION_MICROSECONDS)
+            value // 1000,
+            plc.DataType(plc.TypeId.DURATION_MICROSECONDS),
+            stream=stream,
         )
     elif tid == plc.TypeId.TIMESTAMP_MILLISECONDS:
         return plc.Scalar.from_py(
-            value // 1_000_000, plc.DataType(plc.TypeId.DURATION_MILLISECONDS)
+            value // 1_000_000,
+            plc.DataType(plc.TypeId.DURATION_MILLISECONDS),
+            stream=stream,
         )
     elif tid == plc.TypeId.TIMESTAMP_DAYS:
         return plc.Scalar.from_py(
-            value // 86_400_000_000_000, plc.DataType(plc.TypeId.DURATION_DAYS)
+            value // 86_400_000_000_000,
+            plc.DataType(plc.TypeId.DURATION_DAYS),
+            stream=stream,
         )
     else:
         raise NotImplementedError(
@@ -122,8 +135,9 @@ def duration_to_scalar(dtype: plc.DataType, value: int) -> plc.Scalar:
 
 def offsets_to_windows(
     dtype: plc.DataType,
-    offset: Duration,
-    period: Duration,
+    offset_i: int,
+    period_i: int,
+    stream: Stream,
 ) -> tuple[plc.Scalar, plc.Scalar]:
     """
     Convert polars offset/period pair to preceding/following windows.
@@ -132,21 +146,22 @@ def offsets_to_windows(
     ----------
     dtype
         Datatype of column defining windows
-    offset
-        Offset duration
-    period
-        Period of window
+    offset_i
+        Integer ordinal representing the offset of the window.
+        See :func:`duration_to_int` for more details.
+    period_i
+        Integer ordinal representing the period of the window.
+        See :func:`duration_to_int` for more details.
+    stream
+        CUDA stream used for device memory operations and kernel launches
 
     Returns
     -------
-    tuple of preceding and following windows as pylibcudf scalars.
+    tuple of preceding and following windows as host integers.
     """
-    offset_i = duration_to_int(dtype, *offset)
-    period_i = duration_to_int(dtype, *period)
-    # Polars uses current_row + offset, ..., current_row + offset + period
-    # Libcudf uses current_row - preceding, ..., current_row + following
-    return duration_to_scalar(dtype, -offset_i), duration_to_scalar(
-        dtype, offset_i + period_i
+    return (
+        duration_to_scalar(dtype, -offset_i, stream=stream),
+        duration_to_scalar(dtype, offset_i + period_i, stream=stream),
     )
 
 

cudf_polars/experimental/base.py

@@ -5,7 +5,9 @@
 from __future__ import annotations
 
 import dataclasses
+import enum
 from collections import defaultdict
+from enum import IntEnum
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, Generic, NamedTuple, TypeVar
 
@@ -20,19 +22,24 @@ if TYPE_CHECKING:
 class PartitionInfo:
     """Partitioning information."""
 
-    __slots__ = ("count", "partitioned_on")
+    __slots__ = ("count", "io_plan", "partitioned_on")
     count: int
     """Partition count."""
     partitioned_on: tuple[NamedExpr, ...]
     """Columns the data is hash-partitioned on."""
+    io_plan: IOPartitionPlan | None
+    """IO partitioning plan (Scan nodes only)."""
 
     def __init__(
         self,
         count: int,
+        *,
         partitioned_on: tuple[NamedExpr, ...] = (),
+        io_plan: IOPartitionPlan | None = None,
     ):
         self.count = count
         self.partitioned_on = partitioned_on
+        self.io_plan = io_plan
 
     def keys(self, node: Node) -> Iterator[tuple[str, int]]:
         """Return the partitioned keys for a given node."""
@@ -108,13 +115,17 @@ class DataSourceInfo:
     """
 
     _unique_stats_columns: set[str]
+    _read_columns: set[str]
 
     @property
     def row_count(self) -> ColumnStat[int]:  # pragma: no cover
         """Data source row-count estimate."""
         raise NotImplementedError("Sub-class must implement row_count.")
 
-    def unique_stats(self, column: str) -> UniqueStats:  # pragma: no cover
+    def unique_stats(
+        self,
+        column: str,
+    ) -> UniqueStats:  # pragma: no cover
         """Return unique-value statistics for a column."""
         raise NotImplementedError("Sub-class must implement unique_stats.")
 
@@ -131,6 +142,10 @@ class DataSourceInfo:
         """Add a column needing unique-value information."""
         self._unique_stats_columns.add(column)
 
+    def add_read_column(self, column: str) -> None:
+        """Add a column needing to be read."""
+        self._read_columns.add(column)
+
 
 class DataSourcePair(NamedTuple):
     """Pair of table-source and column-name information."""
@@ -230,6 +245,11 @@ class ColumnSourceInfo:
         for table_source, column_name in self.table_source_pairs:
             table_source.add_unique_stats_column(column or column_name)
 
+    def add_read_column(self, column: str | None = None) -> None:
+        """Add a column needing to be read."""
+        for table_source, column_name in self.table_source_pairs:
+            table_source.add_read_column(column or column_name)
+
 
 class ColumnStats:
     """
@@ -384,3 +404,36 @@ class StatsCollector:
         self.row_count: dict[IR, ColumnStat[int]] = {}
         self.column_stats: dict[IR, dict[str, ColumnStats]] = {}
         self.join_info = JoinInfo()
+
+
+class IOPartitionFlavor(IntEnum):
+    """Flavor of IO partitioning."""
+
+    SINGLE_FILE = enum.auto()  # 1:1 mapping between files and partitions
+    SPLIT_FILES = enum.auto()  # Split each file into >1 partition
+    FUSED_FILES = enum.auto()  # Fuse multiple files into each partition
+    SINGLE_READ = enum.auto()  # One worker/task reads everything
+
+
+class IOPartitionPlan:
+    """
+    IO partitioning plan.
+
+    Notes
+    -----
+    The meaning of `factor` depends on the value of `flavor`:
+      - SINGLE_FILE: `factor` must be `1`.
+      - SPLIT_FILES: `factor` is the number of partitions per file.
+      - FUSED_FILES: `factor` is the number of files per partition.
+      - SINGLE_READ: `factor` is the total number of files.
+    """
+
+    __slots__ = ("factor", "flavor")
+    factor: int
+    flavor: IOPartitionFlavor
+
+    def __init__(self, factor: int, flavor: IOPartitionFlavor) -> None:
+        if flavor == IOPartitionFlavor.SINGLE_FILE and factor != 1:  # pragma: no cover
+            raise ValueError(f"Expected factor == 1 for {flavor}, got: {factor}")
+        self.factor = factor
+        self.flavor = flavor

cudf_polars/experimental/benchmarks/pdsds.py

@@ -16,26 +16,17 @@ from __future__ import annotations
 import contextlib
 import importlib
 import os
-import time
-from collections import defaultdict
-from pathlib import Path
 from typing import TYPE_CHECKING
 
-import polars as pl
-
 with contextlib.suppress(ImportError):
     from cudf_polars.experimental.benchmarks.utils import (
-        Record,
-        RunConfig,
-        get_executor_options,
-        parse_args,
+        run_duckdb,
         run_polars,
+        run_validate,
     )
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
     from types import ModuleType
-    from typing import Any
 
 # Without this setting, the first IO task to run
 # on each worker takes ~15 sec extra
@@ -58,7 +49,7 @@ def valid_query(name: str) -> bool:
 class PDSDSQueriesMeta(type):
     """Metaclass used for query lookup."""
 
-    def __getattr__(cls, name: str):  # type: ignore
+    def __getattr__(cls, name: str):  # type: ignore[no-untyped-def]
         """Query lookup."""
         if valid_query(name):
             q_num = int(name[1:])
@@ -88,118 +79,6 @@ class PDSDSDuckDBQueries(PDSDSQueries):
     q_impl = "duckdb_impl"
 
 
-def execute_duckdb_query(query: str, dataset_path: Path) -> pl.DataFrame:
-    """Execute a query with DuckDB."""
-    import duckdb
-
-    conn = duckdb.connect()
-
-    statements = [
-        f"CREATE VIEW {table.stem} as SELECT * FROM read_parquet('{table.absolute()}');"
-        for table in Path(dataset_path).glob("*.parquet")
-    ]
-    statements.append(query)
-    return conn.execute("\n".join(statements)).pl()
-
-
-def run_duckdb(benchmark: Any, options: Sequence[str] | None = None) -> None:
-    """Run the benchmark with DuckDB."""
-    args = parse_args(options, num_queries=99)
-    vars(args).update({"query_set": benchmark.name})
-    run_config = RunConfig.from_args(args)
-    records: defaultdict[int, list[Record]] = defaultdict(list)
-
-    for q_id in run_config.queries:
-        try:
-            duckdb_query = getattr(PDSDSDuckDBQueries, f"q{q_id}")(run_config)
-        except AttributeError as err:
-            raise NotImplementedError(f"Query {q_id} not implemented.") from err
-
-        print(f"DuckDB Executing: {q_id}")
-        records[q_id] = []
-
-        for i in range(args.iterations):
-            t0 = time.time()
-
-            result = execute_duckdb_query(duckdb_query, run_config.dataset_path)
-
-            t1 = time.time()
-            record = Record(query=q_id, duration=t1 - t0)
-            if args.print_results:
-                print(result)
-
-            print(f"Query {q_id} - Iteration {i} finished in {record.duration:0.4f}s")
-            records[q_id].append(record)
-
-
-def run_validate(benchmark: Any, options: Sequence[str] | None = None) -> None:
-    """Validate Polars CPU vs DuckDB or Polars GPU."""
-    from polars.testing import assert_frame_equal
-
-    args = parse_args(options, num_queries=99)
-    vars(args).update({"query_set": benchmark.name})
-    run_config = RunConfig.from_args(args)
-
-    baseline = args.baseline
-    if baseline not in {"duckdb", "cpu"}:
-        raise ValueError("Baseline must be one of: 'duckdb', 'cpu'")
-
-    failures: list[int] = []
-
-    engine: pl.GPUEngine | None = None
-    if run_config.executor != "cpu":
-        engine = pl.GPUEngine(
-            raise_on_fail=True,
-            executor=run_config.executor,
-            executor_options=get_executor_options(run_config, PDSDSPolarsQueries),
-        )
-
-    for q_id in run_config.queries:
-        print(f"\nValidating Query {q_id}")
-        try:
-            polars_query = getattr(PDSDSPolarsQueries, f"q{q_id}")(run_config)
-            duckdb_query = getattr(PDSDSDuckDBQueries, f"q{q_id}")(run_config)
-        except AttributeError as err:
-            raise NotImplementedError(f"Query {q_id} not implemented.") from err
-
-        if baseline == "duckdb":
-            base_result = execute_duckdb_query(duckdb_query, run_config.dataset_path)
-        elif baseline == "cpu":
-            base_result = polars_query.collect(new_streaming=True)
-
-        if run_config.executor == "cpu":
-            test_result = polars_query.collect(new_streaming=True)
-        else:
-            try:
-                test_result = polars_query.collect(engine=engine)
-            except Exception as e:
-                failures.append(q_id)
-                print(f"❌ Query {q_id} failed validation: GPU execution failed.\n{e}")
-                continue
-
-        try:
-            assert_frame_equal(
-                base_result,
-                test_result,
-                check_dtypes=True,
-                check_column_order=False,
-            )
-            print(f"✅ Query {q_id} passed validation.")
-        except AssertionError as e:
-            failures.append(q_id)
-            print(f"❌ Query {q_id} failed validation:\n{e}")
-            if args.print_results:
-                print("Baseline Result:\n", base_result)
-                print("Test Result:\n", test_result)
-
-    if failures:
-        print("\nValidation Summary:")
-        print("===================")
-        print(f"{len(failures)} query(s) failed: {failures}")
-    else:
-        print("\nAll queries passed validation.")
-
-
 if __name__ == "__main__":
     import argparse
 
@@ -215,6 +94,13 @@ if __name__ == "__main__":
     if args.engine == "polars":
         run_polars(PDSDSPolarsQueries, extra_args, num_queries=99)
     elif args.engine == "duckdb":
-        run_duckdb(PDSDSDuckDBQueries, extra_args)
+        run_duckdb(PDSDSDuckDBQueries, extra_args, num_queries=99)
     elif args.engine == "validate":
-        run_validate(PDSDSQueries, extra_args)
+        run_validate(
+            PDSDSPolarsQueries,
+            PDSDSDuckDBQueries,
+            extra_args,
+            num_queries=99,
+            check_dtypes=True,
+            check_column_order=True,
+        )