bench: final

Author: protocolstardust

bench/adapters/duckdb_adapter.py

@@ -91,6 +91,18 @@ def query():
         result, time_ns = self._time_it(query)
         return BenchmarkResult("groupby_q5", time_ns, len(result))
 
+    def run_groupby_q6(self) -> BenchmarkResult:
+        """Q6: max(v1) - min(v2) group by id3"""
+        t = self._get_table()
+
+        def query():
+            return self._conn.execute(
+                f"SELECT id3, MAX(v1) - MIN(v2) as range FROM {t} GROUP BY id3"
+            ).fetchdf()
+
+        result, time_ns = self._time_it(query)
+        return BenchmarkResult("groupby_q6", time_ns, len(result))
+
     def run_join_inner(self, right_path: Path) -> BenchmarkResult:
         """Inner join on id1."""
         left = self._get_table("left")

bench/adapters/polars_adapter.py

@@ -79,6 +79,18 @@ def query():
         result, time_ns = self._time_it(query)
         return BenchmarkResult("groupby_q5", time_ns, len(result))
 
+    def run_groupby_q6(self) -> BenchmarkResult:
+        """Q6: max(v1) - min(v2) group by id3"""
+        df = self._get_table()
+
+        def query():
+            return df.group_by("id3").agg(
+                (pl.max("v1") - pl.min("v2")).alias("range")
+            )
+
+        result, time_ns = self._time_it(query)
+        return BenchmarkResult("groupby_q6", time_ns, len(result))
+
     def run_join_inner(self, right_path: Path) -> BenchmarkResult:
         """Inner join on id1."""
         left = self._get_table("left")

bench/adapters/questdb_adapter.py

@@ -157,6 +157,18 @@ def query():
         result, time_ns = self._time_it(query)
         return BenchmarkResult("groupby_q5", time_ns, len(result))
 
+    def run_groupby_q6(self) -> BenchmarkResult:
+        """Q6: max(v1) - min(v2) group by id3"""
+        t = self._get_table()
+
+        def query():
+            with self._conn.cursor() as cur:
+                cur.execute(f"SELECT id3, MAX(v1) - MIN(v2) as range FROM {t} GROUP BY id3")
+                return cur.fetchall()
+
+        result, time_ns = self._time_it(query)
+        return BenchmarkResult("groupby_q6", time_ns, len(result))
+
     def run_join_inner(self, right_path: Path) -> BenchmarkResult:
         """Inner join on id1."""
         raise NotImplementedError("QuestDB join benchmarks not implemented")

bench/adapters/rayforce_adapter.py

@@ -111,7 +111,7 @@ def load_data(self, path: Path, table_name: str = "data") -> None:
         column_types = self._get_column_types(path)
 
         # Use rayforce native CSV loading with column types
-        rf_table = self._Table.from_csv(column_types, str(path)).select("*").execute()
+        rf_table = self._Table.from_csv(column_types, str(path))
         rf_table.save(symbol_name)
         self._table_names[table_name] = symbol_name
 
@@ -195,6 +195,12 @@ def run_groupby_q5(self) -> BenchmarkResult:
         query = f"(select {{v1: (sum v1) v2: (sum v2) v3: (sum v3) by: id3 from: {t}}})"
         return self._run_timed_query(query, "groupby_q5")
 
+    def run_groupby_q6(self) -> BenchmarkResult:
+        """Q6: max(v1) - min(v2) group by id3"""
+        t = self._get_symbol()
+        query = f"(select {{range: (- (max v1) (min v2)) by: id3 from: {t}}})"
+        return self._run_timed_query(query, "groupby_q6")
+
     def _load_table_from_csv(self, path: Path) -> object:
         """Load CSV file using rayforce native Table.from_csv."""
         column_types = self._get_column_types(path)

bench/adapters/timescale_adapter.py

@@ -158,6 +158,18 @@ def query():
         result, time_ns = self._time_it(query)
         return BenchmarkResult("groupby_q5", time_ns, len(result))
 
+    def run_groupby_q6(self) -> BenchmarkResult:
+        """Q6: max(v1) - min(v2) group by id3"""
+        t = self._get_table()
+
+        def query():
+            with self._conn.cursor() as cur:
+                cur.execute(f"SELECT id3, MAX(v1) - MIN(v2) as range FROM {t} GROUP BY id3")
+                return cur.fetchall()
+
+        result, time_ns = self._time_it(query)
+        return BenchmarkResult("groupby_q6", time_ns, len(result))
+
     def run_join_inner(self, right_path: Path) -> BenchmarkResult:
         """Inner join on id1."""
         import io

bench/runner.py

@@ -53,7 +53,7 @@ class BenchmarkRunner:
     """Run benchmarks across multiple adapters."""
 
     BENCHMARKS = {
-        "groupby": ["groupby_q1", "groupby_q2", "groupby_q3", "groupby_q4", "groupby_q5"],
+        "groupby": ["groupby_q1", "groupby_q2", "groupby_q3", "groupby_q4", "groupby_q5", "groupby_q6"],
         "join": ["join_inner", "join_left"],
         "sort": ["sort_single", "sort_multi"],
     }
@@ -222,7 +222,13 @@ def print_comparison(results: list[BenchmarkRun]) -> None:
             by_benchmark[run.benchmark] = {}
         by_benchmark[run.benchmark][run.adapter] = run
 
-    adapters = sorted(set(r.adapter for r in results))
+    # Put rayforce first, then sort the rest
+    all_adapters = set(r.adapter for r in results)
+    adapters = []
+    if "rayforce" in all_adapters:
+        adapters.append("rayforce")
+        all_adapters.remove("rayforce")
+    adapters.extend(sorted(all_adapters))
 
     print("\n" + "=" * 60)
     print("COMPARISON (median ms)")
@@ -235,27 +241,35 @@ def print_comparison(results: list[BenchmarkRun]) -> None:
     print(header)
     print("-" * 60)
 
+    # Track speedups relative to rayforce
+    speedups: dict[str, list[float]] = {a: [] for a in adapters}
+
     # Rows
     for bench_name, adapter_results in sorted(by_benchmark.items()):
         row = f"{bench_name:<15}"
-        times = []
+        rf_time = adapter_results.get("rayforce", None)
+        rf_ms = rf_time.median_ms if rf_time else None
+
         for adapter in adapters:
             if adapter in adapter_results:
                 t = adapter_results[adapter].median_ms
-                times.append((adapter, t))
                 row += f" {t:>12.2f}"
+                if rf_ms and rf_ms > 0:
+                    speedups[adapter].append(t / rf_ms)
             else:
                 row += f" {'N/A':>12}"
         print(row)
 
-        # Mark fastest
-        if times:
-            fastest = min(times, key=lambda x: x[1])
-            slowest = max(times, key=lambda x: x[1])
-            if len(times) > 1:
-                speedup = slowest[1] / fastest[1]
-                print(f"  → {fastest[0]} is {speedup:.1f}x faster than {slowest[0]}")
-
+    # Average speedup line
+    print("-" * 60)
+    row = f"{'(avg speedup)':<15}"
+    for adapter in adapters:
+        if speedups[adapter]:
+            avg = sum(speedups[adapter]) / len(speedups[adapter])
+            row += f" {avg:>11.2f}x"
+        else:
+            row += f" {'N/A':>12}"
+    print(row)
     print("=" * 60)