bench(compute): pin the ADR 0019 baseline workloads

Two benchmarks pin the facade's levers the way the current API forces
them to run: fusedFilteredAggregateTwoAggregates (one dict leaf, two
aggregate columns = two kernel calls re-scanning the filter, 137.3
ms/op) and fusedFilteredAggregateMulti (the ADR example: two-leaf AND
declining the dict lane onto the per-row RowPredicate path, times two
calls — 2269.1 ms/op, ~60x the single-leaf dict lane). Numbers recorded
in ADR 0019 as the baseline the implementation must beat.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dfa1

docs/adr/0019-columnar-transducer-facade.md

@@ -84,6 +84,21 @@ The Calcite `VortexAggregatePushDownRule` boundary tier is the first consumer: i
 aggregate columns one `filteredAggregate` call per column; a multi-aggregate pipeline folds them in
 one scan of the filter column.
 
+### Baseline (measured 2026-07-03, `ComputeKernelBenchmark`, 100M rows)
+
+The two levers, pinned as benchmarks the implementation must beat — expressed the only way the
+current API allows:
+
+| Workload | Today | ms/op |
+| --- | --- | --- |
+| 1 dict leaf × 2 aggregates (`fusedFilteredAggregateTwoAggregates`) | 2 kernel calls, filter re-scanned per aggregate | 137.3 ± 0.1 |
+| 2-leaf `AND` × 2 aggregates (`fusedFilteredAggregateMulti`, this ADR's example) | multi-leaf declines the dict lane → per-row `RowPredicate` path, × 2 calls | 2269.1 ± 19.8 |
+
+For scale: the single-leaf single-aggregate dict lane runs the same scan in 36.2 ms and the raw
+code scan in ~25 ms. The pipeline's compile step attacks both levers at once — the dict leaf drives
+the scan, the residual leaf is tested only on code matches, and every aggregate folds from that one
+pass — so the example workload's target is tens of milliseconds, not seconds.
+
 ## Consequences
 
 ### Positive

performance/src/main/java/io/github/dfa1/vortex/performance/ComputeKernelBenchmark.java

@@ -274,6 +274,55 @@ public long fusedFilteredAggregateDict() {
         return acc;
     }
 
+    /// ADR 0019 baseline, lever 1 — multi-aggregate over one filter: `SUM`/`MIN`(measure) and
+    /// `SUM`(plain) under the same single-leaf `category == 7` filter, expressed the only way the
+    /// current API allows — one [Compute#filteredAggregate(Chunk, RowFilter, String)] call PER
+    /// aggregate column, so the filter column is re-scanned once per aggregate. The transducer
+    /// façade folds every aggregate from one scan; this method is the number it must beat.
+    ///
+    /// Result (2026-07-03, 100M rows): 137.3 ± 0.1 ms/op — ≈ 2× the single-aggregate lane, the
+    /// redundant re-scan plus the second aggregate's (random-access `plain`) match reads.
+    ///
+    /// @return the two folds' selected counts and sums combined, so JMH cannot eliminate either call
+    @Benchmark
+    public long fusedFilteredAggregateTwoAggregates() {
+        long acc = 0;
+        for (Chunk chunk : chunks) {
+            RowFilter filter = RowFilter.eq("category", CATEGORY_VALUE);
+            FilteredAggregate measure = Compute.filteredAggregate(chunk, filter, "measure");
+            FilteredAggregate plain = Compute.filteredAggregate(chunk, filter, "plain");
+            acc += measure.selectedRows() + measure.sum().longValue()
+                    + ((Long) measure.min()).longValue() + plain.sum().longValue();
+        }
+        return acc;
+    }
+
+    /// ADR 0019 baseline, lever 2 — the full façade example: a two-leaf `AND`
+    /// (`category == 7 AND price > 500`, ≈ 1/32 selectivity) with two aggregate columns. A
+    /// multi-leaf filter declines the dict code-scan lane, so every row pays the per-leaf
+    /// [Compute] `RowPredicate` accessor path (dict chunk-lookup for `category`, lazy ALP decode
+    /// for `price`), twice — once per aggregate call. The façade's compile step drives the scan
+    /// with the dict leaf, tests the residual `price` leaf only on code matches, and feeds both
+    /// aggregates from that single pass.
+    ///
+    /// Result (2026-07-03, 100M rows): 2269.1 ± 19.8 ms/op — the multi-leaf decline costs ≈ 60×
+    /// the single-leaf dict lane's 36.2 ms; ADR 0019's target for this exact workload is tens of
+    /// milliseconds.
+    ///
+    /// @return the two folds' selected counts and sums combined, so JMH cannot eliminate either call
+    @Benchmark
+    public long fusedFilteredAggregateMulti() {
+        long acc = 0;
+        for (Chunk chunk : chunks) {
+            RowFilter filter = RowFilter.eq("category", CATEGORY_VALUE)
+                    .and(RowFilter.gt("price", PRICE_THRESHOLD));
+            FilteredAggregate measure = Compute.filteredAggregate(chunk, filter, "measure");
+            FilteredAggregate plain = Compute.filteredAggregate(chunk, filter, "plain");
+            acc += measure.selectedRows() + measure.sum().longValue() + plain.sum().longValue();
+        }
+        return acc;
+    }
+
     /// Hand-fused control for [#fusedFilteredSumAlp()]: the obvious developer loop a fused kernel must
     /// match — `for i: if (price.getDouble(i) > 500) acc += measure.getLong(i)` per chunk, with no
     /// off-heap bitmap. Decodes each price and (when selected) each measure through the accessor.