[pull] master from GaijinEntertainment:master

benchmarks/sql/groupby_average.das

@@ -0,0 +1,63 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _select((Brand=key, AvgPrice=avg of price per group)).
+// SQL: SELECT brand, AVG(price) GROUP BY brand.
+// Splice mode (PR-A2 follow-up) fuses the inner select+average per group via a
+// 2-slot per-key acc (sum : double + count : uint64) and divides at result-build.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                                  |> _group_by(_.brand)
+                                  |> _select((Brand = _._0,
+                                              AvgPrice = _._1 |> select($(c : Car) => c.price) |> average())))
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._select((Brand = _._0,
+                                                       AvgPrice = _._1 |> select($(c : Car) => c.price) |> average())))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._select((Brand = _._0,
+                                      AvgPrice = _._1 |> select($(c : Car) => c.price) |> average()))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_average_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def groupby_average_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_average_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/groupby_first.das

@@ -0,0 +1,42 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _select((Brand=key, FirstCar=first source elem per group)).
+// No direct SQL aggregator for "first source-order row per group" → m1 omitted; m3 vs m3f
+// is the headline comparison. Splice (PR-A2) emits miss-branch-only loop (no hit update).
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._select((Brand = _._0,
+                                                       FirstCar = _._1 |> first())))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._select((Brand = _._0,
+                                      FirstCar = _._1 |> first()))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_first_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_first_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/groupby_having_count.das

@@ -0,0 +1,64 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _having(_._1 |> length >= 5) |> _select((Brand=key, N=length)).
+// SQL: SELECT brand, COUNT(*) FROM cars GROUP BY brand HAVING COUNT(*) >= 5.
+// Splice mode (PR-D) recognizes that the having predicate's length(_._1) matches the
+// select's length slot — the predicate rewrites to `kv._{slot} >= 5` and wraps the
+// result-build push_clone in a per-bucket filter. Per-element loop is unchanged from
+// PR-A2's count splice; the only extra cost is the post-table filter.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                                  |> _group_by(_.brand)
+                                  |> _having(_._1 |> length >= 5)
+                                  |> _select((Brand = _._0, N = _._1 |> length)))
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._having(_._1 |> length >= 5)._select((Brand = _._0, N = _._1 |> length)))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._having(_._1 |> length >= 5)
+                            ._select((Brand = _._0, N = _._1 |> length))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_having_count_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def groupby_having_count_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_having_count_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/groupby_max.das

@@ -0,0 +1,63 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _select((Brand=key, MaxPrice=max of price per group)).
+// SQL: SELECT brand, MAX(price) GROUP BY brand.
+// Splice mode (PR-A2) fuses the inner select+max per group into the per-element
+// miss/hit branches — no bucket array, single hash op per element.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                                  |> _group_by(_.brand)
+                                  |> _select((Brand = _._0,
+                                              MaxPrice = _._1 |> select($(c : Car) => c.price) |> max())))
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._select((Brand = _._0,
+                                                       MaxPrice = _._1 |> select($(c : Car) => c.price) |> max())))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._select((Brand = _._0,
+                                      MaxPrice = _._1 |> select($(c : Car) => c.price) |> max()))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_max_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def groupby_max_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_max_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/groupby_min.das

@@ -0,0 +1,63 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _select((Brand=key, MinPrice=min of price per group)).
+// SQL: SELECT brand, MIN(price) GROUP BY brand.
+// Splice mode (PR-A2) fuses the inner select+min per group into the per-element
+// miss/hit branches — no bucket array, single hash op per element.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                                  |> _group_by(_.brand)
+                                  |> _select((Brand = _._0,
+                                              MinPrice = _._1 |> select($(c : Car) => c.price) |> min())))
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._select((Brand = _._0,
+                                                       MinPrice = _._1 |> select($(c : Car) => c.price) |> min())))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._select((Brand = _._0,
+                                      MinPrice = _._1 |> select($(c : Car) => c.price) |> min()))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_min_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def groupby_min_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_min_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/groupby_multi_reducer.das

@@ -0,0 +1,69 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+// _group_by(_.brand) |> _select 4-slot named tuple — fuses count + sum + max into one pass.
+// SQL: SELECT brand, COUNT(*), SUM(price), MAX(price) GROUP BY brand.
+// Splice (PR-A2 A.4) walks the ReducerSpec array once per source element, emitting per-slot
+// miss-init + hit-update for all 3 reducers — no per-reducer separate passes.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                                  |> _group_by(_.brand)
+                                  |> _select((Brand = _._0,
+                                              N = _._1 |> length,
+                                              TotalPrice = _._1 |> select($(c : Car) => c.price) |> sum(),
+                                              MaxPrice   = _._1 |> select($(c : Car) => c.price) |> max())))
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let groups <- (arr._group_by(_.brand)._select((Brand = _._0,
+                                                       N = _._1 |> length,
+                                                       TotalPrice = _._1 |> select($(c : Car) => c.price) |> sum(),
+                                                       MaxPrice   = _._1 |> select($(c : Car) => c.price) |> max())))
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let groups <- _fold(each(arr)
+                            ._group_by(_.brand)
+                            ._select((Brand = _._0,
+                                      N = _._1 |> length,
+                                      TotalPrice = _._1 |> select($(c : Car) => c.price) |> sum(),
+                                      MaxPrice   = _._1 |> select($(c : Car) => c.price) |> max()))
+                            .to_array())
+        if (empty(groups)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def groupby_multi_reducer_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def groupby_multi_reducer_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def groupby_multi_reducer_m3f(b : B?) {
+    run_m3f(b, 100000)
+}