From 366f662df9c443f4c922741c7c0998791d722bb0 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Wed, 28 Oct 2026 10:22:59 +0530 Subject: [PATCH 1/3] perf(query): skip sorts with proven committed input order (#641) --- CHANGELOG.md | 4 + CLAUDE.md | 9 +- README.md | 2 + ROADMAP.md | 2 +- benches/minigraf_bench.rs | 46 + docs/BENCHMARKS.md | 121 +++ docs/TEST_COVERAGE.md | 18 +- docs/benchmarks/641-input-order-build.json | 33 + docs/benchmarks/641-input-order-history.jsonl | 144 +++ docs/benchmarks/641-input-order.jsonl | 360 ++++++++ .../plans/2026-10-28-641-input-order.md | 137 +++ .../specs/2026-10-24-limit-order-by-design.md | 1 + .../2026-10-28-641-input-order-design.md | 389 ++++++++ examples/perf_envelope.rs | 7 + scripts/input_order_history_fixture.rs | 36 + scripts/input_order_probe.rs | 50 + src/graph/storage.rs | 28 + src/lib.rs | 12 + src/query/datalog/aggregate.rs | 22 +- src/query/engine/mod.rs | 10 +- src/query/engine/order.rs | 330 +++++++ src/query/engine/order/tests.rs | 280 ++++++ src/query/engine/order_tests.rs | 856 ++++++++++++++++++ src/query/engine/plan.rs | 5 + src/query/engine/project.rs | 3 + src/query/engine/recursive.rs | 1 + src/query/engine/scan.rs | 5 +- src/query/engine/sort.rs | 5 +- src/storage/keys.rs | 87 +- src/storage/mod.rs | 3 + src/storage/persistent_facts.rs | 2 +- src/storage/reader.rs | 62 ++ tests/distinct_test.rs | 6 + tests/input_order_test.rs | 97 ++ 34 files changed, 3143 insertions(+), 30 deletions(-) create mode 100644 docs/benchmarks/641-input-order-build.json create mode 100644 docs/benchmarks/641-input-order-history.jsonl create mode 100644 docs/benchmarks/641-input-order.jsonl create mode 100644 docs/superpowers/plans/2026-10-28-641-input-order.md create mode 100644 docs/superpowers/specs/2026-10-28-641-input-order-design.md create mode 100644 scripts/input_order_history_fixture.rs create mode 100644 scripts/input_order_probe.rs create mode 100644 src/query/engine/order.rs create mode 100644 src/query/engine/order/tests.rs create mode 100644 src/query/engine/order_tests.rs create mode 100644 tests/input_order_test.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 6d7cd3fd0d..9117079e3b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Performance + +- **Skip sorting proven ordered input** (#641, first slice). Plain queries can omit `Sort` when a committed integer, float, or Boolean range already provides the complete ascending result order. Attribute scans use AVET; entity-and-attribute scans retain their selective EAVT range. `:offset` and `:limit` then stop reading early, so memory-limit (`QRY-012`) or I/O errors in unread later input may be avoided. The proof uses the query's pinned reader, including a large write transaction's working trees, and rejects pending or staged records in the source range, mixed kinds, unsupported comparators, tie suffixes, order-changing operators, user callbacks and `collect-set`. Unproven queries retain their original plan. Aggregates and windows still buffer their full input in this slice. + ### Breaking changes - **`Value` is `#[non_exhaustive]` and has a `Set` variant** (#316). A `match` on `Value` outside the crate needs a wildcard arm, so later value kinds are not breaking changes. diff --git a/CLAUDE.md b/CLAUDE.md index 1ed0eb962d..4992873c03 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -108,7 +108,7 @@ cargo run < demos/demo_negation.txt 1. **`src/graph/`** — EAV fact store with bi-temporal support - `types.rs`: `Fact`, `Value`, `EntityId`, `TxId`, `VALID_TIME_FOREVER` - - `storage.rs`: `FactStorage` — in-memory store, `snapshot()` → `Snapshot` (committed reader + pin + pending prefix, and a `WriteTransaction`'s staged facts read with the pending ones as one store, #550; every query/cursor/log read goes through one), `transact_batch`, `retract`, `get_facts_as_of`, `get_facts_valid_at`, `net_asserted_facts`, `get_facts_by_entity_attribute_indexed` + - `storage.rs`: `FactStorage` — in-memory store, `snapshot()` → `Snapshot` (committed reader + pin + pending prefix, and a `WriteTransaction`'s staged facts read with the pending ones as one store, #550; every query/cursor/log read goes through one), `transact_batch`, `retract`, `get_facts_as_of`, `get_facts_valid_at`, `net_asserted_facts`, `get_facts_by_entity_attribute_indexed`; `Snapshot::has_pending` probes only its captured pending/staged source range for input-order proofs (#641) 2. **`src/storage/`** — Persistence layer - `mod.rs`: `StorageBackend` trait, `LegacyHeaderV7` (v7 migration only), `CommittedReader` trait @@ -122,7 +122,7 @@ cargo run < demos/demo_negation.txt - `btree.rs`: On-disk B+tree over byte keys (`build_btree`, `cow_update` (copy-on-write inserts and deletes; an emptied leaf or node leaves its parent, an emptied tree is root 0; #550) and `cow_insert`, `LeafCursor` (with `seek`), `prefix_scan`, `get`, `MutexStorageBackend`) - `dict.rs`: `DictReader` (id ↔ UUID/ident, tx timestamps, long values; `uuids_of` walks dense id batches with `LeafCursor` and uses exact scalar reads for sparse/small batches, #530) and `Encoder` (checkpoint-time id assignment and key building) - `value_pages.rs`: append-only value pages for strings over 64 bytes and sets whose element encoding is over 64 bytes (#316; DICT dedup compares bytes, `long_bytes`/`find_long_bytes`) - - `reader.rs`: `OnDiskReader` — covering reads of committed facts (`CommittedReader`, `KeySource`); query scans use the resumable `live_keys` to decide net-assert on index keys (#379) among the versions a `TxBound` keeps; `live_facts` is test-only, and production fact-level net-assert handles pending records (#532, superseded by #551); `tx_order` (cached per reader), `last_tx_at`, `tx_runs` over the DICT's transactions (#551) + - `reader.rs`: `OnDiskReader` — covering reads of committed facts (`CommittedReader`, `KeySource`); query scans use the resumable `live_keys` to decide net-assert on index keys (#379) among the versions a `TxBound` keeps; `live_facts` is test-only, and production fact-level net-assert handles pending records (#532, superseded by #551); `KeySource::any_key` proves raw kind-prefix presence with one leaf seek, including historical/retracted keys (#641); `tx_order` (cached per reader), `last_tx_at`, `tx_runs` over the DICT's transactions (#551) - `verify.rs`: integrity walk for `Minigraf::verify` (tree order, index digests, DICT, page accounting) and the source choice for `rebuild_indexes` (#373) - `meta.rs` / `page.rs` / `freelist.rs`: meta pages A/B, the common page header and allocator (skips quarantined ids), free-list chain - `pins.rs`: `Pins` / `GenerationPin` — generations held by open snapshots and the quarantine of pages checkpoints freed after them (#543) @@ -148,7 +148,7 @@ cargo run < demos/demo_negation.txt - `prepared.rs`: `BindValue`, `PreparedQuery` — parse-once/execute-many with named `$slot` bind slots; `prepare_query`, `substitute`; `Entity` and `Val(Ref)` fit each other's slots, bind mistakes are `API-022`/`023`/`024` (#181); a `:limit $n` or `:offset $o` slot takes `Val(Integer(n >= 0))` (`resolve_count_slot`, #306) - `magic_sets.rs`: Magic-sets rewriting for demand-driven recursive rule evaluation (not applied to rules with `not`/`not-join`) -3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. +3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`), `order.rs` (#641: snapshot-bound proofs of the complete result order; safe committed integer/float/Boolean ranges can set the private `ScanSpec.index` hint to AVET and omit Sort, with `plan.find` restored from Sort.cols; entity-and-attribute scans retain EAVT; pending/staged records in that range, mixed kinds, DICT comparators, callbacks and CollectSet keep the original plan; `minigraf::__input_order` forces fallback under `test-hooks`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. 4. **`src/temporal.rs`** — UTC-only timestamp parsing (avoids chrono CVE GHSA-wcg3-cvx6-7396) @@ -216,7 +216,7 @@ Auto-migrates v7 → v8 on open (spec §9, with a backup meta page). v1–v6 are ## Test Coverage -**1911 tests** (1896 passing, 15 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). +**1941 tests** (1926 passing, 15 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). See `docs/TEST_COVERAGE.md` for the full per-file breakdown. **Testing conventions** — see the Testing Conventions section below before writing any tests. @@ -228,6 +228,7 @@ See `docs/TEST_COVERAGE.md` for the full per-file breakdown. Current plan (see `ROADMAP.md` and the milestones): - **v2.x** (`main`, format v7) now gets only data-integrity and security fixes as patch releases (v2.0.3 is the first); v2.0.2 was the last planned v2.x release. - **v3.0.0** (format v8 and data integrity, plus `:limit` #306, optional `:distinct` output #493, `lag`/`lead` #182, sliding row frames #183, query profiler #185, set membership predicates #316 and prepared queries in every binding #181, UDF registration in every binding #180; tracker #383) is developed on the long-lived `v3` branch. All v3 PRs target `v3`; `main` stays untouched. CI runs on PRs to `v3` the same as on PRs to `main`. Do not merge `main` into `v3` routinely: `main` only gets backports of fixes already on `v3`. Shared CI and workflow changes land on both branches as separate PRs. Just before the v3.0.0 cut, merge `main` into `v3` once (merge commit; source conflicts resolved to `v3`, `main`'s v2.0.x CHANGELOG sections brought over) so the cut is a fast-forward. At the first v3 release, the current `main` is copied to `v2` and `v3` becomes the new `main`. +- **Input order (#641)** targets v3.0.0 in three slices: committed scalar Sort omission is implemented on `v3`; one-group count/count-distinct and partition-at-a-time windows remain pending. The reviewed design, fallback scope and acceptance gates are in `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - **v3.next** (the release after v3.0.0) holds new features (rule persistence #241; OPFS `BrowserDb` #441). - Known v2.x data issue: same-transaction multi-valued facts (#371). Fix ships in v3.0.0. All v2.x known issues are listed in pinned issue #421 (`known-issue` label); `data-integrity`/`corruption`/`durability` issues fixed in a v2.x patch stay open until that patch is published; issues fixed on the unreleased `v3` branch close on merge (closing keywords do not fire on `v3`, so close them with `gh issue close`) and stay listed in #421 (CONTRIBUTING.md). - Support policy and tiers: PHILOSOPHY.md §7 and §10. v2.x gets data-integrity and security fixes for 12 months after v3.0.0. Tier 1 = Rust + Python + browser WASM (from v3.0.0); other bindings are Tier 2. diff --git a/README.md b/README.md index e3ce418f15..1230cf9a13 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,8 @@ For example, `(lag ?salary :over (:partition-by ?dept :order-by ?hire-date))` re The unreleased v3.0.0 branch adds bounded sliding windows such as `(avg ?salary :over (:partition-by ?dept :order-by ?hire-date :rows 2 preceding))` (#183). +On v3.0.0, an ascending value-only query such as `[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]` can read directly in index order and stop early when all committed `:score` history has one value kind (integer, float, or Boolean) and its source range has no pending writes. A query whose full order cannot be proved uses the existing sort (#641). + **Status**: See [ROADMAP.md](ROADMAP.md) for planned work and current direction. ## Why Datalog? diff --git a/ROADMAP.md b/ROADMAP.md index fdf2ea59e5..60190c6224 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -98,7 +98,7 @@ Scope — query API: - Bounded sliding row frames, `:rows N preceding`, for window aggregates (#183; v3.0.0, implemented on `v3`; builds on #182) - Cursor API: `Minigraf::query` and `PreparedQuery::query` return an owned `Cursor` that delivers rows in batches, with the answer fixed at open (#432; Rust API done on `v3`). The binding cursor objects follow. Behind the cursor, the streaming engine (#473) runs every query and produces rows as they are pulled: patterns, expressions and pseudo-attributes (#544), joins and `:db/valid-at` (#545), `not` and `or` (#546), aggregates and windows (#547), rules (#548), and transaction reads (#550); the executor's query path is gone (#551; done on `v3`). Operators do not spill: memory follows operator state, with an opt-in per-query limit (`QRY-012`, #549). - Projected UUID lookup batches walk dense DICT ranges (#530; implemented on `v3`), keeping temporary memory bounded to a batch and query-cache charges in projection order. -- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). Skipping the sort when an index already returns the rows in order is #641 (v3.next). +- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). #641 targets v3.0.0 in three slices: snapshot-bound order proofs and Sort omission for committed scalar ranges, then one-group count/count-distinct and partition-at-a-time windows. The first slice is implemented on `v3`; aggregates and windows still buffer their full input pending the remaining slices. See `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - Fact-log iterator: `Minigraf::fact_log(&FactFilter)` streams every fact version (assertions and retractions, with `tx_count`, `tx_id` and valid-time bounds) in transaction order or storage order, filtered by attribute, attribute prefix, entity and tx range, with memory bounded by a window rather than the database (#430; Rust API done on `v3`). An open log pins its generation: checkpoints run but do not reuse its pages (#543; `API-013` deprecated). A raw log writer (#431) completes the extract-transform-load path; the binding objects follow with #462. - Read-only open: `OpenOptions::read_only` takes a shared lock, so several readers can hold a file at once, writes nothing to the file or its WAL (a WAL is applied in memory, a v7 file is read without migrating), and refuses writes with `API-014` (#429; Rust API done on `v3`). The bindings' `open_with_options` follows. - Raw log writer: `LogWriter` builds a new database from `FactRecord`s with their `tx_count`, `tx_id`, valid-time windows and assertion flags kept, gaps allowed (a purged transaction stays a hole for `:as-of`), at `.partial` renamed into place by `finish` (#431; Rust API done on `v3`). Completes extract (#429, #430), transform, load. The binding objects follow. diff --git a/benches/minigraf_bench.rs b/benches/minigraf_bench.rs index 35ac5a1021..411fa5b68f 100644 --- a/benches/minigraf_bench.rs +++ b/benches/minigraf_bench.rs @@ -234,6 +234,51 @@ fn bench_query(c: &mut Criterion) { // ── Task 6: time_travel/ ────────────────────────────────────────────────────── +// The existing nightly ^query/ filter selects both the proven value order and +// its UUID-tie fallback control. All facts are committed, not in-memory pending. +fn bench_input_order(c: &mut Criterion) { + let mut group = c.benchmark_group("query/ordered_values"); + group.sample_size(10); + for (label, n) in [ + ("1k", 1_000), + ("10k", 10_000), + ("100k", 100_000), + ("1m", 1_000_000), + ] { + for (mode, query) in [ + ( + "index", + "(query [:find ?v :where [?e :val ?v] :order-by [?v] :limit 10])", + ), + ( + "uuid_ties", + "(query [:find ?e ?v :where [?e :val ?v] :order-by [?v] :limit 10])", + ), + ] { + group.bench_with_input(BenchmarkId::new(mode, label), &n, |b, &n| { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("ordered.graph"); + helpers::populate_file(n, path.to_str().unwrap()); + let db = OpenOptions::new() + .read_only(true) + .path(&path) + .open() + .unwrap(); + b.iter(|| { + let minigraf::QueryResult::QueryResults { results, .. } = + db.execute(query).unwrap() + else { + panic!("expected rows"); + }; + assert_eq!(results.len(), 10.min(n)); + black_box(results) + }); + }); + } + } + group.finish(); +} + fn bench_time_travel(c: &mut Criterion) { const SCALES: &[(&str, usize)] = &[ ("1k", 1_000), @@ -1976,6 +2021,7 @@ criterion_group!( bench_insert, bench_insert_file, bench_query, + bench_input_order, bench_time_travel, bench_recursion, bench_negation, diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index c615ec9f16..313581d150 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -2,6 +2,127 @@ This document records reproducible local benchmark snapshots. Completed release-performance history belongs in the [CHANGELOG](../CHANGELOG.md); continuous CI history is available on [Bencher](https://bencher.dev/perf/minigraf/plots). +## Proven input order and Sort omission (#641, slice 1, unreleased) + +**Date**: 2026-10-28 · **Base**: `v3` at `2abf53df` · **Change**: #641, +first slice. The [build manifest](benchmarks/641-input-order-build.json) records +source, dependency-lock, library and probe fingerprints. Both libraries used +`--profile envelope` (opt-level 3) and `-C force-frame-pointers=yes`, with Rust +1.99.1 and the same dependency lock. + +Six rounds ran on an idle benchmark machine, binding CPU and memory to the same +NUMA node and swapping nodes and execution order between base and change each +round. Every query ran in a fresh process on a prebuilt, checkpointed file opened +read-only, on a 256 KiB worker stack. Three warmups preceded 5–20,000 measured +cursor drains within a one-second budget (at least five even for slower queries). +Open, fixture construction and profiling are outside timing. Tables give the +median of six process p50s; raw records retain each p50, its per-process range, +run count and query-only process peak RSS. No samples were discarded. + +The common envelope fixtures use `floor(N / 6)` ordinary entities and +approximately `N` currently visible facts, plus expired valid-time records and +hot-entity history. The +scale labels are nominal current-fact counts. The age queries read 16,666, +166,666 and 1,666,666 rows respectively. Every measured result checks its row +count; the ordered limit/offset probes also check that all returned ages are zero. + +| Nominal current facts | Ordered limit: base | Change | Ordered offset: base | Change | Change limit max peak RSS | +|---|---:|---:|---:|---:|---:| +| 100K | 5.996 ms | 0.458 ms | 6.022 ms | 0.457 ms | 3,784 KiB | +| 1M | 62.260 ms | 0.455 ms | 62.739 ms | 0.457 ms | 3,776 KiB | +| 10M | 643.947 ms | 0.463 ms | 644.929 ms | 0.452 ms | 3,796 KiB | + +The RSS column is the maximum of the six process peaks. + +The limit query is `[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]`; +the offset query adds `:offset 13`. At 10M, the changed p50 ranges were +0.459–0.476 ms and 0.448–0.459 ms. The 10M/100K ratios are **1.012** and **0.989**, +within the 2x gate. Peak RSS increases by **12 KiB** and **40 KiB**, within the +16 MiB allowance. Internal tests separately verify Sort omission, restored +projection slots, input read at most `offset + limit + 1,024` rows on the positive +fixture, at most eight raw kind-prefix seeks, and zero proof reads for zero limit +including a nonzero offset. + +### Startup cost on a selective ordered entity range + +The entity-and-attribute range remains EAVT. Its order proof still makes eight +whole-attribute kind-prefix seeks, whose startup cost dominates a one-row query: + +| Nominal current facts | Base | Change | +|---|---:|---:| +| 100K | 21.13 µs | 129.89 µs | +| 1M | 20.72 µs | 112.29 µs | +| 10M | 20.99 µs | 117.39 µs | + +Query: `[:find ?a :where [:pM :age ?a] :order-by [?a] :limit 1]`, where +`M = floor(entity_count / 2)`. This cost is reported separately from the ordinary +point-query guards. There is no cost-based selection or cross-query proof cache +in this slice. + +### Existing point and buffering controls + +The envelope's ordinary entity point, exact attribute/value point and current +hot-history point changed by **−0.65% to +1.03%** across the three scales. The +attribute scan, plain limit, ascending UUID-tie Sort and descending top-k control +changed by **−3.28% to +2.00%**. All measurements are in the +[360 envelope records](benchmarks/641-input-order.jsonl). + +The exact #323/#379 history fixture and four query shapes were also measured +through the same cursor probe: 2,000 filler facts, a never-changed sibling +attribute, and one live string value after `depth - 1` retract/reassert pairs. +The `:as-of 2002` query selects the first assertion with `:any-valid-time`. + +| Guard | Depth | Base p50 | Change p50 | Delta | +|---|---:|---:|---:|---:| +| Churned attribute | 1 | 16.83 µs | 16.70 µs | −0.80% | +| | 500 | 151.83 µs | 153.69 µs | +1.23% | +| | 2,000 | 602.70 µs | 599.46 µs | −0.54% | +| Sibling attribute | 1 | 17.12 µs | 17.10 µs | −0.15% | +| | 500 | 22.53 µs | 22.58 µs | +0.24% | +| | 2,000 | 22.85 µs | 22.81 µs | −0.17% | +| Attribute scan | 1 | 17.26 µs | 17.35 µs | +0.50% | +| | 500 | 152.62 µs | 152.65 µs | +0.02% | +| | 2,000 | 595.38 µs | 603.65 µs | +1.39% | +| Churned attribute, as-of | 1 | 17.85 µs | 17.76 µs | −0.48% | +| | 500 | 141.32 µs | 141.59 µs | +0.19% | +| | 2,000 | 554.11 µs | 560.41 µs | +1.14% | + +The worst guard delta is **+1.39%**, within the 5% gate. All +[144 history records](benchmarks/641-input-order-history.jsonl) are retained. + +### Reproduction and nightly routing + +Build the immutable base and the change once, then compile the same +[query probe](../scripts/input_order_probe.rs) against each library: + +```sh +RUSTFLAGS='-C force-frame-pointers=yes' cargo build --profile envelope --example perf_envelope +rustc --edition=2024 -C opt-level=3 -C panic=abort -C force-frame-pointers=yes \ + -L dependency="$target_dir/envelope/deps" \ + --extern minigraf="$target_dir/envelope/deps/libminigraf.rlib" \ + scripts/input_order_probe.rs -o "$probe_out" +``` + +Build envelope fixtures separately with `perf_envelope __build N`. +Run `probe '(query [...])' [zeros]` with alternating +CPU/memory binding as described above. Build the +[history fixture helper](../scripts/input_order_history_fixture.rs) against the +base library with the same rustc command; run it with ` `. +Raw records contain each complete query. + +All eight Criterion cases were executed on the bench with +`cargo bench --bench minigraf_bench -- '^query/ordered_values/' --test`: +`query/ordered_values/{index,uuid_ties}/{1k,10k,100k,1m}`. The existing `query` +nightly matrix uses `^query/`, which selects every new ID (#776); no workflow +change is needed. Scheduled Bencher history becomes available after merge. +`perf_envelope` also includes `ordered_values` beside its existing `top_k` control. + +The ordinary release binary is **1,254,928 bytes**, below the unchanged +**1,259,520-byte** cap (base: 1,258,784). Sharing the existing set/window sort +comparators removes duplicate generated code while preserving their order. +This slice changes Sort selection only; grouped Aggregate and Window remain +full-input operators until the following #641 slices. + ## Projected UUID lookup batching (#530, unreleased) **Date**: 2026-10-27 · **Baseline**: `v3` at `80120758` · **Change**: #530. diff --git a/docs/TEST_COVERAGE.md b/docs/TEST_COVERAGE.md index 7474084a85..ca8efca31f 100644 --- a/docs/TEST_COVERAGE.md +++ b/docs/TEST_COVERAGE.md @@ -4,11 +4,13 @@ | | Default features | With `--features test-hooks` | |---|---|---| -| **Passing** | 1,896 | 1,928 | +| **Passing** | 1,926 | 1,959 | | **Ignored** | 15 | 16 | -| **Total** | 1,911 | 1,944 | +| **Total** | 1,941 | 1,975 | -**Verified**: 2026-10-27 on the designated bench machine: the full default suite under branch coverage plus `cargo test --doc`, and `cargo test --features test-hooks`. The final review test enhancement also passed a focused dictionary rerun. All coverage gates retain their existing floors. +**Verified**: 2026-10-28 on the designated bench machine: the full default suite under branch coverage plus `cargo test --doc`, and `cargo test --features test-hooks`. The final proof-read failure enhancement also passed a focused rerun. All unchanged coverage floors pass; measured overall coverage is 95.39% lines and 86.14% branches. + +#641 adds 30 tests with default features and one more with `test-hooks`. #183 adds bounded row-frame parser, evaluator, and integration tests; one additional plan-independence case runs with `test-hooks`, including duplicate tie keys and NaN. A sliding-sum test checks recovery after integer saturation. Grammar corpus cases cover frame spellings and rejection. A meter test checks that a zero-width min frame reserves one deque slot. An ignored bench-machine diagnostic reproduces the Criterion datasets and prints the engine meter's peak for every measured case. @@ -24,6 +26,8 @@ Not counted above: the browser tests and the WASI run (see [Browser and WASI](#b ## Covered Areas +- **Proven input order** (#641, first slice; `src/query/engine/order_tests.rs`, `order/tests.rs`, `tests/input_order_test.rs`): full result keys and projection slots, constants and repeated slots, integer/Boolean/float edge cases including NaNs and signed zeros, replacements, join fallback orientation and distinct canonicalization. Snapshot tests cover unrelated versus in-range pending/staged records, captured prefixes, temporal filters, prepared queries, checkpoints and large-transaction working readers including rejected statements and rollback. Counters establish early stopping, bounded raw proof reads and no reads without demand; optional proof-read errors leave the original plan. Late callback and `collect-set` errors retain their evaluation. A forced-fallback differential matrix checks identical ordered lists across plan switches. A committed `MemoryBackend` fixture runs on native, WASI and the browser. Storage tests cover every key kind/tag and raw seeks over retracted history. + - **Bounded row frames** (`tests/window_functions_test.rs`, `src/query/datalog/aggregate/tests.rs`, #183): `:rows N preceding` parsing and errors, physical rows with tied order keys, partition reset, descending order, width zero and maximum, all five built-in aggregates against a replay oracle with numeric edge cases, UDFs through prepared queries and cursors, grouping with `:with`, distinct output, memory-limit refusal for long min/max strings, and final `:order-by` matching. A `test-hooks` case checks answer bags with clause reordering on and off. - **Optional distinct output** (`tests/distinct_test.rs`, #493): bag defaults, whole tuples, section syntax, cross-batch and committed/pending values, chunked write transactions, prepared execute/cursors, joins/rules/disjunction, aggregates and hidden `:with` groups, window peers and partitioned row numbers, temporal filters, typed equality and canonical float/set output, memory limits (including retained set payloads) and cursor cleanup. A meter unit test verifies each cell/key/value estimate includes set elements and their strings. With `test-hooks`, checks both reorder settings and hashed/correlated subplans. An engine unit test checks counters and state release. @@ -484,7 +488,8 @@ These tests compare the database against an independent answer rather than a sin None of these are counted in the summary. The wasm32 targets run in CI (`.github/workflows/wasm.yml`). -- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 58 `wasm_bindgen_test` tests. +- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 59 `wasm_bindgen_test` tests. The final #641 snapshot passed in headless Firefox on the bench; Chrome remains a CI run. + - One committed-memory-backend input-order fixture, including scalar edge cases and verification that Sort is omitted (#641). - Twenty-five for `BrowserDb`, including IndexedDB persistence, the cursor, and the flush returning every dirty page and failing on one it cannot read (#470). - Eleven for `BrowserBufferBackend` (which used `#[test]` and never ran before). - Two checking that IndexedDB page keys accept only whole numbers from 0 to 2^53. @@ -500,11 +505,11 @@ None of these are counted in the summary. The wasm32 targets run in CI (`.github - `importGraph()` deletes the replaced database's IndexedDB keys. - Two buffer tests check that releasing a page drops its bytes and any unflushed write, and that export writes a released page as zeros. - A native storage test checks that a file whose free pages are all zeros (as the browser exports them), both just migrated from v7 and after 20 saves, opens, verifies clean and keeps committing. The free-list test checks that a checkpoint reports exactly the ids it newly lists. -- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,121 passing (`wasm.yml`, #746); ten that spawn threads or a child process are ignored on WASI. +- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,177 passing and seven ignored in the 2026-10-28 bench run with Wasmtime v49.0.2 (`wasm.yml`). The committed input-order fixture runs here too, and the WASI REPL builds in release mode. ## Ignored Tests -The fourteen ignored tests (fifteen with `test-hooks`) are intentionally excluded from a normal local run: +The fifteen ignored tests (sixteen with `test-hooks`) are intentionally excluded from a normal local run: - Four rustdoc examples that reference internal types and cannot compile as standalone examples. - One high-contention concurrency stress test intended for scheduled runs. @@ -519,6 +524,7 @@ The fourteen ignored tests (fifteen with `test-hooks`) are intentionally exclude - One `:limit` and top-k acceptance test (`tests/limit_acceptance_test.rs`, #306, the #473 `:limit` item), run by the nightly smoke workflow over one 10M-fact fixture written with `LogWriter`: `:limit 10` returns 10 rows in under 250 ms under a 64 KiB `query_memory_limit`, adding under 32 MiB of peak RSS; `:order-by [?v :desc] :limit 10` returns the ten largest values under a 1 MiB limit, adding under 32 MiB. - One large-transaction acceptance test (`tests/large_transaction_acceptance_test.rs`, #550; `test-hooks` only), run by the nightly smoke workflow (see [Large transactions](#large-transactions-550)). - One measurement test (`meter_peak_against_rss`, `src/query/engine/tests.rs`, #549): prints the meter's peak against the peak RSS for the same two shapes, opening the engine directly. +- One row-frame measurement test (`window_rows_benchmark_meter_peaks`, `src/query/engine/tests.rs`, #183): prints metered peaks for the window benchmark fixtures. ## Reproducing diff --git a/docs/benchmarks/641-input-order-build.json b/docs/benchmarks/641-input-order-build.json new file mode 100644 index 0000000000..8b7b7510b6 --- /dev/null +++ b/docs/benchmarks/641-input-order-build.json @@ -0,0 +1,33 @@ +{ + "base": "2abf53df05447755490d017bc2daf89f4d59cdf5", + "pr_production_source_sha256": "a59a39766f2db679f231e22bd2a0290d687b7939470bcca0abbfa0d06c59bd15", + "probe_source_sha256": "103ea1adc656505c2c3c086c5747bbaf75e0a77bc283e60320030944bccf10f1", + "lock_sha256": "b03965119fd8ce5b5cf3ad3d37fb194ffeae24b6a862a0c85ae8fbcb6833ee77", + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "release_bytes": 1254928, + "nightly_filter": "^query/", + "executed_benchmark_ids": [ + "query/ordered_values/index/1k", + "query/ordered_values/index/10k", + "query/ordered_values/index/100k", + "query/ordered_values/index/1m", + "query/ordered_values/uuid_ties/1k", + "query/ordered_values/uuid_ties/10k", + "query/ordered_values/uuid_ties/100k", + "query/ordered_values/uuid_ties/1m" + ], + "libraries": { + "base": "dacde9faf1ede6e52c3bb6fc65bb7ba8e69b0ee907f0e6899ddf4fc3233a5b50", + "pr": "1ee5ddc54f1a08611a4f8e782eca79844f589c782114d11bcc1fa957abb5ee4d" + }, + "binaries": { + "base": "93bb52bbb3a058eed295710ea64b0c2a1496b031e714240777bf9e2420661780", + "pr": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98" + }, + "history_fixture_source_sha256": "faa6be9e273eedb9a12120cc1367369d2e662d71c8d92e333c15d0f1b3bcb92b", + "measurement_records": { + "envelope": 360, + "history_depth": 144, + "rounds": 6 + } +} diff --git a/docs/benchmarks/641-input-order-history.jsonl b/docs/benchmarks/641-input-order-history.jsonl new file mode 100644 index 0000000000..352435dfa5 --- /dev/null +++ b/docs/benchmarks/641-input-order-history.jsonl @@ -0,0 +1,144 @@ +{"round": 1, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.906, "min_us": 16.468, "max_us": 82.443, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.857, "min_us": 16.457, "max_us": 94.982, "rows": 1, "peak_rss_kb": 3800} +{"round": 1, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.096, "min_us": 16.683, "max_us": 803.423, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 16.835, "min_us": 16.412, "max_us": 90.514, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.46, "min_us": 16.94, "max_us": 79.938, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.447, "min_us": 16.936, "max_us": 80.756, "rows": 1, "peak_rss_kb": 3852} +{"round": 1, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.002, "min_us": 17.571, "max_us": 83.098, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.739, "min_us": 17.27, "max_us": 75.076, "rows": 1, "peak_rss_kb": 3816} +{"round": 1, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6340, "median_us": 152.142, "min_us": 149.835, "max_us": 2227.327, "rows": 1, "peak_rss_kb": 3720} +{"round": 1, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6321, "median_us": 153.786, "min_us": 150.602, "max_us": 499.42, "rows": 1, "peak_rss_kb": 3664} +{"round": 1, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.544, "min_us": 22.151, "max_us": 78.273, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.539, "min_us": 22.103, "max_us": 86.727, "rows": 1, "peak_rss_kb": 3776} +{"round": 1, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6377, "median_us": 152.269, "min_us": 149.157, "max_us": 2210.9, "rows": 1, "peak_rss_kb": 3724} +{"round": 1, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6418, "median_us": 152.539, "min_us": 150.023, "max_us": 500.466, "rows": 1, "peak_rss_kb": 3688} +{"round": 1, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6866, "median_us": 141.298, "min_us": 140.254, "max_us": 454.138, "rows": 1, "peak_rss_kb": 3688} +{"round": 1, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6838, "median_us": 142.273, "min_us": 140.08, "max_us": 1554.663, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1646, "median_us": 597.744, "min_us": 586.3, "max_us": 1860.558, "rows": 1, "peak_rss_kb": 3728} +{"round": 1, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1639, "median_us": 600.134, "min_us": 588.556, "max_us": 1880.08, "rows": 1, "peak_rss_kb": 3696} +{"round": 1, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.568, "min_us": 22.947, "max_us": 145.107, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.716, "min_us": 22.059, "max_us": 736.566, "rows": 1, "peak_rss_kb": 3824} +{"round": 1, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1651, "median_us": 595.375, "min_us": 584.172, "max_us": 1877.677, "rows": 1, "peak_rss_kb": 3664} +{"round": 1, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1633, "median_us": 604.51, "min_us": 595.657, "max_us": 1888.71, "rows": 1, "peak_rss_kb": 3592} +{"round": 1, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1748, "median_us": 553.95, "min_us": 543.607, "max_us": 11366.746, "rows": 1, "peak_rss_kb": 3684} +{"round": 1, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1766, "median_us": 556.9, "min_us": 546.422, "max_us": 1734.899, "rows": 1, "peak_rss_kb": 3696} +{"round": 2, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.675, "min_us": 16.305, "max_us": 76.262, "rows": 1, "peak_rss_kb": 3760} +{"round": 2, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.891, "min_us": 16.449, "max_us": 71.06, "rows": 1, "peak_rss_kb": 3716} +{"round": 2, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.109, "min_us": 16.629, "max_us": 89.737, "rows": 1, "peak_rss_kb": 3788} +{"round": 2, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.08, "min_us": 16.613, "max_us": 85.158, "rows": 1, "peak_rss_kb": 3824} +{"round": 2, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.788, "min_us": 17.177, "max_us": 748.357, "rows": 1, "peak_rss_kb": 3784} +{"round": 2, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 16.905, "min_us": 16.556, "max_us": 87.255, "rows": 1, "peak_rss_kb": 3736} +{"round": 2, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 19.084, "min_us": 18.672, "max_us": 85.724, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.764, "min_us": 17.359, "max_us": 83.609, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6366, "median_us": 153.598, "min_us": 152.181, "max_us": 491.288, "rows": 1, "peak_rss_kb": 3724} +{"round": 2, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6357, "median_us": 153.085, "min_us": 150.472, "max_us": 2196.376, "rows": 1, "peak_rss_kb": 3720} +{"round": 2, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.386, "min_us": 21.828, "max_us": 112.221, "rows": 1, "peak_rss_kb": 3740} +{"round": 2, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.596, "min_us": 22.154, "max_us": 93.266, "rows": 1, "peak_rss_kb": 3824} +{"round": 2, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6450, "median_us": 151.279, "min_us": 149.371, "max_us": 502.608, "rows": 1, "peak_rss_kb": 3676} +{"round": 2, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6300, "median_us": 154.965, "min_us": 150.329, "max_us": 2195.723, "rows": 1, "peak_rss_kb": 3716} +{"round": 2, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6891, "median_us": 141.48, "min_us": 139.929, "max_us": 461.349, "rows": 1, "peak_rss_kb": 3676} +{"round": 2, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6928, "median_us": 141.302, "min_us": 140.238, "max_us": 455.611, "rows": 1, "peak_rss_kb": 3700} +{"round": 2, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1631, "median_us": 598.787, "min_us": 588.113, "max_us": 5609.805, "rows": 1, "peak_rss_kb": 3640} +{"round": 2, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1639, "median_us": 597.491, "min_us": 585.913, "max_us": 1867.888, "rows": 1, "peak_rss_kb": 3716} +{"round": 2, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.082, "min_us": 22.52, "max_us": 95.217, "rows": 1, "peak_rss_kb": 3804} +{"round": 2, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.885, "min_us": 22.331, "max_us": 92.149, "rows": 1, "peak_rss_kb": 3784} +{"round": 2, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1624, "median_us": 603.779, "min_us": 586.896, "max_us": 5550.759, "rows": 1, "peak_rss_kb": 3700} +{"round": 2, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1652, "median_us": 595.145, "min_us": 582.785, "max_us": 1880.313, "rows": 1, "peak_rss_kb": 3712} +{"round": 2, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1774, "median_us": 560.957, "min_us": 551.77, "max_us": 743.736, "rows": 1, "peak_rss_kb": 3772} +{"round": 2, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1728, "median_us": 562.679, "min_us": 545.296, "max_us": 4702.014, "rows": 1, "peak_rss_kb": 3704} +{"round": 3, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.734, "min_us": 16.298, "max_us": 74.254, "rows": 1, "peak_rss_kb": 3720} +{"round": 3, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.722, "min_us": 16.381, "max_us": 68.361, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.162, "min_us": 16.705, "max_us": 69.66, "rows": 1, "peak_rss_kb": 3784} +{"round": 3, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.218, "min_us": 16.79, "max_us": 79.269, "rows": 1, "peak_rss_kb": 3760} +{"round": 3, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 18.048, "min_us": 17.562, "max_us": 94.161, "rows": 1, "peak_rss_kb": 3808} +{"round": 3, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.289, "min_us": 16.772, "max_us": 75.611, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.68, "min_us": 18.272, "max_us": 81.33, "rows": 1, "peak_rss_kb": 3712} +{"round": 3, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.783, "min_us": 17.22, "max_us": 707.082, "rows": 1, "peak_rss_kb": 3784} +{"round": 3, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6430, "median_us": 151.518, "min_us": 149.956, "max_us": 497.927, "rows": 1, "peak_rss_kb": 3624} +{"round": 3, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6389, "median_us": 153.512, "min_us": 150.715, "max_us": 492.043, "rows": 1, "peak_rss_kb": 3712} +{"round": 3, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.508, "min_us": 22.008, "max_us": 96.071, "rows": 1, "peak_rss_kb": 3800} +{"round": 3, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.587, "min_us": 22.008, "max_us": 726.64, "rows": 1, "peak_rss_kb": 3796} +{"round": 3, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6381, "median_us": 152.566, "min_us": 149.858, "max_us": 496.243, "rows": 1, "peak_rss_kb": 3684} +{"round": 3, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6401, "median_us": 153.118, "min_us": 149.871, "max_us": 509.491, "rows": 1, "peak_rss_kb": 3680} +{"round": 3, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6753, "median_us": 141.804, "min_us": 139.436, "max_us": 8926.202, "rows": 1, "peak_rss_kb": 3620} +{"round": 3, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6901, "median_us": 141.333, "min_us": 140.16, "max_us": 457.275, "rows": 1, "peak_rss_kb": 3692} +{"round": 3, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1641, "median_us": 602.906, "min_us": 593.64, "max_us": 1863.624, "rows": 1, "peak_rss_kb": 3724} +{"round": 3, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1614, "median_us": 604.969, "min_us": 589.561, "max_us": 4688.369, "rows": 1, "peak_rss_kb": 3728} +{"round": 3, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.768, "min_us": 22.146, "max_us": 114.388, "rows": 1, "peak_rss_kb": 3836} +{"round": 3, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.818, "min_us": 22.23, "max_us": 101.942, "rows": 1, "peak_rss_kb": 3796} +{"round": 3, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1666, "median_us": 595.394, "min_us": 583.836, "max_us": 787.021, "rows": 1, "peak_rss_kb": 3668} +{"round": 3, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1624, "median_us": 603.515, "min_us": 586.108, "max_us": 4651.353, "rows": 1, "peak_rss_kb": 3680} +{"round": 3, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1753, "median_us": 553.817, "min_us": 544.568, "max_us": 1730.679, "rows": 1, "peak_rss_kb": 3716} +{"round": 3, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1751, "median_us": 561.46, "min_us": 552.549, "max_us": 1754.141, "rows": 1, "peak_rss_kb": 3680} +{"round": 4, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.629, "min_us": 16.17, "max_us": 95.032, "rows": 1, "peak_rss_kb": 3756} +{"round": 4, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.76, "min_us": 16.323, "max_us": 74.642, "rows": 1, "peak_rss_kb": 3772} +{"round": 4, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 16.77, "min_us": 16.403, "max_us": 864.789, "rows": 1, "peak_rss_kb": 3820} +{"round": 4, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 16.747, "min_us": 16.369, "max_us": 74.181, "rows": 1, "peak_rss_kb": 3800} +{"round": 4, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.408, "min_us": 16.983, "max_us": 75.156, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.253, "min_us": 16.825, "max_us": 78.374, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.464, "min_us": 17.1, "max_us": 83.229, "rows": 1, "peak_rss_kb": 3800} +{"round": 4, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.726, "min_us": 17.334, "max_us": 73.666, "rows": 1, "peak_rss_kb": 3760} +{"round": 4, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6317, "median_us": 153.855, "min_us": 151.147, "max_us": 1604.284, "rows": 1, "peak_rss_kb": 3676} +{"round": 4, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6442, "median_us": 151.501, "min_us": 149.554, "max_us": 495.611, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.741, "min_us": 22.357, "max_us": 105.216, "rows": 1, "peak_rss_kb": 3780} +{"round": 4, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.33, "min_us": 21.96, "max_us": 98.274, "rows": 1, "peak_rss_kb": 3788} +{"round": 4, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6317, "median_us": 153.921, "min_us": 150.851, "max_us": 2857.311, "rows": 1, "peak_rss_kb": 3736} +{"round": 4, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6434, "median_us": 151.994, "min_us": 149.69, "max_us": 500.312, "rows": 1, "peak_rss_kb": 3660} +{"round": 4, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6910, "median_us": 141.128, "min_us": 139.965, "max_us": 492.855, "rows": 1, "peak_rss_kb": 3684} +{"round": 4, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6863, "median_us": 141.344, "min_us": 139.443, "max_us": 2249.052, "rows": 1, "peak_rss_kb": 3728} +{"round": 4, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1637, "median_us": 600.294, "min_us": 589.931, "max_us": 1881.724, "rows": 1, "peak_rss_kb": 3692} +{"round": 4, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1624, "median_us": 603.857, "min_us": 593.953, "max_us": 1881.193, "rows": 1, "peak_rss_kb": 3720} +{"round": 4, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.747, "min_us": 22.116, "max_us": 104.102, "rows": 1, "peak_rss_kb": 3780} +{"round": 4, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.154, "min_us": 22.47, "max_us": 875.121, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1650, "median_us": 594.634, "min_us": 585.981, "max_us": 1899.084, "rows": 1, "peak_rss_kb": 3680} +{"round": 4, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1637, "median_us": 601.359, "min_us": 591.949, "max_us": 1871.951, "rows": 1, "peak_rss_kb": 3668} +{"round": 4, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1745, "median_us": 561.747, "min_us": 550.313, "max_us": 5195.283, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1772, "median_us": 553.247, "min_us": 543.55, "max_us": 1734.786, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.998, "min_us": 16.612, "max_us": 75.232, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.85, "min_us": 16.377, "max_us": 69.997, "rows": 1, "peak_rss_kb": 3816} +{"round": 5, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.309, "min_us": 16.912, "max_us": 78.548, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.244, "min_us": 16.696, "max_us": 74.401, "rows": 1, "peak_rss_kb": 3860} +{"round": 5, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.13, "min_us": 16.615, "max_us": 144.4, "rows": 1, "peak_rss_kb": 3736} +{"round": 5, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.16, "min_us": 16.706, "max_us": 14797.176, "rows": 1, "peak_rss_kb": 3700} +{"round": 5, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.936, "min_us": 17.463, "max_us": 59.231, "rows": 1, "peak_rss_kb": 3804} +{"round": 5, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.746, "min_us": 17.233, "max_us": 95.154, "rows": 1, "peak_rss_kb": 3804} +{"round": 5, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6441, "median_us": 151.521, "min_us": 150.145, "max_us": 492.034, "rows": 1, "peak_rss_kb": 3692} +{"round": 5, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6273, "median_us": 156.063, "min_us": 154.656, "max_us": 515.124, "rows": 1, "peak_rss_kb": 3692} +{"round": 5, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.641, "min_us": 22.229, "max_us": 781.177, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.573, "min_us": 22.199, "max_us": 54.21, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6258, "median_us": 154.637, "min_us": 151.822, "max_us": 498.037, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6448, "median_us": 151.387, "min_us": 149.652, "max_us": 525.652, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6867, "median_us": 140.57, "min_us": 139.584, "max_us": 1533.466, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6860, "median_us": 142.649, "min_us": 141.554, "max_us": 463.5, "rows": 1, "peak_rss_kb": 3664} +{"round": 5, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1639, "median_us": 603.206, "min_us": 594.668, "max_us": 1861.797, "rows": 1, "peak_rss_kb": 3724} +{"round": 5, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1646, "median_us": 597.229, "min_us": 588.674, "max_us": 4242.573, "rows": 1, "peak_rss_kb": 3652} +{"round": 5, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.668, "min_us": 22.101, "max_us": 91.371, "rows": 1, "peak_rss_kb": 3836} +{"round": 5, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.03, "min_us": 22.46, "max_us": 100.766, "rows": 1, "peak_rss_kb": 3800} +{"round": 5, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1642, "median_us": 601.674, "min_us": 592.758, "max_us": 1873.812, "rows": 1, "peak_rss_kb": 3720} +{"round": 5, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1632, "median_us": 596.197, "min_us": 585.945, "max_us": 5471.409, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1772, "median_us": 554.277, "min_us": 544.99, "max_us": 1735.434, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1753, "median_us": 559.87, "min_us": 547.699, "max_us": 1737.856, "rows": 1, "peak_rss_kb": 3676} +{"round": 6, "variant": "pr", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.443, "min_us": 16.116, "max_us": 741.735, "rows": 1, "peak_rss_kb": 3772} +{"round": 6, "variant": "base", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.774, "min_us": 16.313, "max_us": 72.202, "rows": 1, "peak_rss_kb": 3760} +{"round": 6, "variant": "pr", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.081, "min_us": 16.704, "max_us": 79.151, "rows": 1, "peak_rss_kb": 3812} +{"round": 6, "variant": "base", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.146, "min_us": 16.771, "max_us": 91.307, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "pr", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.273, "min_us": 16.798, "max_us": 97.071, "rows": 1, "peak_rss_kb": 3856} +{"round": 6, "variant": "base", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.271, "min_us": 16.704, "max_us": 74.07, "rows": 1, "peak_rss_kb": 3772} +{"round": 6, "variant": "pr", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.364, "min_us": 17.893, "max_us": 80.395, "rows": 1, "peak_rss_kb": 3808} +{"round": 6, "variant": "base", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.715, "min_us": 17.224, "max_us": 89.931, "rows": 1, "peak_rss_kb": 3708} +{"round": 6, "variant": "pr", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6401, "median_us": 151.754, "min_us": 150.403, "max_us": 1616.608, "rows": 1, "peak_rss_kb": 3692} +{"round": 6, "variant": "base", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6394, "median_us": 153.143, "min_us": 151.561, "max_us": 510.87, "rows": 1, "peak_rss_kb": 3700} +{"round": 6, "variant": "pr", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.688, "min_us": 22.29, "max_us": 93.783, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "base", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.348, "min_us": 21.955, "max_us": 94.307, "rows": 1, "peak_rss_kb": 3836} +{"round": 6, "variant": "pr", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6342, "median_us": 152.764, "min_us": 150.451, "max_us": 1661.674, "rows": 1, "peak_rss_kb": 3668} +{"round": 6, "variant": "base", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6422, "median_us": 152.679, "min_us": 149.214, "max_us": 514.372, "rows": 1, "peak_rss_kb": 3664} +{"round": 6, "variant": "pr", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6986, "median_us": 141.704, "min_us": 140.62, "max_us": 209.368, "rows": 1, "peak_rss_kb": 3684} +{"round": 6, "variant": "base", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6710, "median_us": 145.295, "min_us": 139.236, "max_us": 1545.012, "rows": 1, "peak_rss_kb": 3708} +{"round": 6, "variant": "pr", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1641, "median_us": 597.678, "min_us": 587.99, "max_us": 1878.505, "rows": 1, "peak_rss_kb": 3676} +{"round": 6, "variant": "base", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1635, "median_us": 602.497, "min_us": 593.95, "max_us": 1866.401, "rows": 1, "peak_rss_kb": 3700} +{"round": 6, "variant": "pr", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.806, "min_us": 22.249, "max_us": 20032.575, "rows": 1, "peak_rss_kb": 3788} +{"round": 6, "variant": "base", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.816, "min_us": 22.25, "max_us": 96.466, "rows": 1, "peak_rss_kb": 3780} +{"round": 6, "variant": "pr", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1633, "median_us": 604.199, "min_us": 595.755, "max_us": 1900.908, "rows": 1, "peak_rss_kb": 3680} +{"round": 6, "variant": "base", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1661, "median_us": 592.368, "min_us": 582.486, "max_us": 1890.818, "rows": 1, "peak_rss_kb": 3720} +{"round": 6, "variant": "pr", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1747, "median_us": 557.233, "min_us": 547.646, "max_us": 5907.174, "rows": 1, "peak_rss_kb": 3716} +{"round": 6, "variant": "base", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1760, "median_us": 558.291, "min_us": 549.587, "max_us": 1726.513, "rows": 1, "peak_rss_kb": 3716} diff --git a/docs/benchmarks/641-input-order.jsonl b/docs/benchmarks/641-input-order.jsonl new file mode 100644 index 0000000000..baa1fe86a6 --- /dev/null +++ b/docs/benchmarks/641-input-order.jsonl @@ -0,0 +1,360 @@ +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 166, "median_us": 5999.528, "min_us": 5911.703, "max_us": 13178.963, "rows": 10, "peak_rss_kb": 4176} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2143, "median_us": 460.741, "min_us": 444.309, "max_us": 1450.36, "rows": 10, "peak_rss_kb": 3784} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 166, "median_us": 6019.166, "min_us": 5967.508, "max_us": 6656.385, "rows": 10, "peak_rss_kb": 4180} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2176, "median_us": 454.606, "min_us": 439.851, "max_us": 3984.18, "rows": 10, "peak_rss_kb": 3748} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.812, "min_us": 20.224, "max_us": 88.481, "rows": 1, "peak_rss_kb": 3808} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7554, "median_us": 129.307, "min_us": 127.898, "max_us": 424.464, "rows": 1, "peak_rss_kb": 3736} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.573, "min_us": 18.044, "max_us": 85.216, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.327, "min_us": 18.531, "max_us": 106.444, "rows": 1, "peak_rss_kb": 3812} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.135, "min_us": 18.619, "max_us": 779.875, "rows": 1, "peak_rss_kb": 3816} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.374, "min_us": 18.901, "max_us": 95.784, "rows": 1, "peak_rss_kb": 3828} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3044, "median_us": 322.928, "min_us": 319.465, "max_us": 1037.887, "rows": 1, "peak_rss_kb": 3672} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3038, "median_us": 323.932, "min_us": 316.45, "max_us": 1023.898, "rows": 1, "peak_rss_kb": 3656} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13412.638, "min_us": 13276.464, "max_us": 20846.811, "rows": 16666, "peak_rss_kb": 4944} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13453.5, "min_us": 13415.17, "max_us": 13715.365, "rows": 16666, "peak_rss_kb": 4936} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2716, "median_us": 364.816, "min_us": 348.679, "max_us": 1157.841, "rows": 10, "peak_rss_kb": 3740} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2654, "median_us": 365.592, "min_us": 350.656, "max_us": 3883.688, "rows": 10, "peak_rss_kb": 3780} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25524.469, "min_us": 25301.531, "max_us": 25765.421, "rows": 10, "peak_rss_kb": 4832} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25472.541, "min_us": 25309.818, "max_us": 25704.93, "rows": 10, "peak_rss_kb": 4736} +{"round": 1, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25499.927, "min_us": 25391.607, "max_us": 33072.375, "rows": 10, "peak_rss_kb": 4832} +{"round": 1, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25548.462, "min_us": 25385.514, "max_us": 25938.541, "rows": 10, "peak_rss_kb": 4792} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 16, "median_us": 62281.778, "min_us": 61935.259, "max_us": 71065.572, "rows": 10, "peak_rss_kb": 4880} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2161, "median_us": 455.524, "min_us": 445.803, "max_us": 1459.113, "rows": 10, "peak_rss_kb": 3736} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62969.124, "min_us": 62224.344, "max_us": 70317.947, "rows": 10, "peak_rss_kb": 4856} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2110, "median_us": 453.91, "min_us": 444.449, "max_us": 11753.514, "rows": 10, "peak_rss_kb": 3732} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.572, "min_us": 20.1, "max_us": 127.318, "rows": 1, "peak_rss_kb": 3820} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8701, "median_us": 112.338, "min_us": 111.524, "max_us": 396.602, "rows": 1, "peak_rss_kb": 3756} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.668, "min_us": 18.216, "max_us": 87.411, "rows": 1, "peak_rss_kb": 3780} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.801, "min_us": 18.257, "max_us": 100.848, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.073, "min_us": 16.817, "max_us": 715.39, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.199, "min_us": 17.231, "max_us": 83.215, "rows": 1, "peak_rss_kb": 3828} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3060, "median_us": 322.086, "min_us": 317.623, "max_us": 1011.017, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3026, "median_us": 325.133, "min_us": 320.272, "max_us": 1034.703, "rows": 1, "peak_rss_kb": 3704} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139741.241, "min_us": 138656.25, "max_us": 140523.233, "rows": 166666, "peak_rss_kb": 5248} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141550.061, "min_us": 140984.143, "max_us": 141976.96, "rows": 166666, "peak_rss_kb": 5288} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2581, "median_us": 376.194, "min_us": 369.579, "max_us": 3833.53, "rows": 10, "peak_rss_kb": 3792} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2743, "median_us": 354.296, "min_us": 342.685, "max_us": 1253.85, "rows": 10, "peak_rss_kb": 3712} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 267968.931, "min_us": 264570.967, "max_us": 282735.78, "rows": 10, "peak_rss_kb": 5032} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 267744.457, "min_us": 266299.304, "max_us": 279455.065, "rows": 10, "peak_rss_kb": 4952} +{"round": 1, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268195.422, "min_us": 265135.622, "max_us": 280573.941, "rows": 10, "peak_rss_kb": 5012} +{"round": 1, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270443.137, "min_us": 269416.964, "max_us": 273004.923, "rows": 10, "peak_rss_kb": 5000} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 637108.3, "min_us": 632771.696, "max_us": 646132.306, "rows": 10, "peak_rss_kb": 4836} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2135, "median_us": 461.927, "min_us": 453.211, "max_us": 1484.828, "rows": 10, "peak_rss_kb": 3748} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 635174.048, "min_us": 632851.087, "max_us": 643959.311, "rows": 10, "peak_rss_kb": 4916} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2207, "median_us": 450.251, "min_us": 426.854, "max_us": 1433.093, "rows": 10, "peak_rss_kb": 3808} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 21.162, "min_us": 20.568, "max_us": 108.788, "rows": 1, "peak_rss_kb": 3816} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8208, "median_us": 117.65, "min_us": 113.878, "max_us": 2155.73, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.924, "min_us": 18.397, "max_us": 110.716, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.947, "min_us": 18.382, "max_us": 90.96, "rows": 1, "peak_rss_kb": 3840} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.015, "min_us": 17.188, "max_us": 74.388, "rows": 1, "peak_rss_kb": 3804} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.845, "min_us": 17.057, "max_us": 77.678, "rows": 1, "peak_rss_kb": 3880} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3050, "median_us": 321.506, "min_us": 316.367, "max_us": 1019.674, "rows": 1, "peak_rss_kb": 3700} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3027, "median_us": 321.409, "min_us": 316.463, "max_us": 3721.594, "rows": 1, "peak_rss_kb": 3680} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1410535.452, "min_us": 1391930.733, "max_us": 1435272.787, "rows": 1666666, "peak_rss_kb": 5376} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1458299.471, "min_us": 1450210.999, "max_us": 1492299.323, "rows": 1666666, "peak_rss_kb": 5372} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2667, "median_us": 364.733, "min_us": 347.843, "max_us": 4598.292, "rows": 10, "peak_rss_kb": 3760} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2651, "median_us": 370.362, "min_us": 355.885, "max_us": 1170.554, "rows": 10, "peak_rss_kb": 3728} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2793647.54, "min_us": 2773543.313, "max_us": 2816038.345, "rows": 10, "peak_rss_kb": 4996} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2825120.322, "min_us": 2815575.789, "max_us": 2839506.802, "rows": 10, "peak_rss_kb": 4928} +{"round": 1, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2803596.412, "min_us": 2741740.527, "max_us": 2822248.952, "rows": 10, "peak_rss_kb": 5016} +{"round": 1, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2831466.154, "min_us": 2815023.238, "max_us": 2835387.533, "rows": 10, "peak_rss_kb": 5076} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2150, "median_us": 457.646, "min_us": 445.785, "max_us": 1440.895, "rows": 10, "peak_rss_kb": 3752} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 165, "median_us": 6011.734, "min_us": 5937.178, "max_us": 13423.5, "rows": 10, "peak_rss_kb": 4188} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2137, "median_us": 459.538, "min_us": 446.25, "max_us": 1442.254, "rows": 10, "peak_rss_kb": 3700} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 166, "median_us": 6020.646, "min_us": 5920.936, "max_us": 7494.722, "rows": 10, "peak_rss_kb": 4168} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7487, "median_us": 130.159, "min_us": 128.581, "max_us": 1643.117, "rows": 1, "peak_rss_kb": 3692} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 23.709, "min_us": 22.738, "max_us": 113.772, "rows": 1, "peak_rss_kb": 3776} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.258, "min_us": 18.654, "max_us": 79.98, "rows": 1, "peak_rss_kb": 3800} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.801, "min_us": 19.151, "max_us": 85.3, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.972, "min_us": 18.489, "max_us": 87.318, "rows": 1, "peak_rss_kb": 3728} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.046, "min_us": 18.588, "max_us": 88.15, "rows": 1, "peak_rss_kb": 3800} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3009, "median_us": 324.773, "min_us": 317.32, "max_us": 3060.825, "rows": 1, "peak_rss_kb": 3708} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3089, "median_us": 318.473, "min_us": 314.95, "max_us": 1063.898, "rows": 1, "peak_rss_kb": 3688} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13598.123, "min_us": 13396.361, "max_us": 15698.865, "rows": 16666, "peak_rss_kb": 4940} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 71, "median_us": 13328.041, "min_us": 13283.66, "max_us": 65722.236, "rows": 16666, "peak_rss_kb": 4908} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2658, "median_us": 369.959, "min_us": 358.074, "max_us": 1197.642, "rows": 10, "peak_rss_kb": 3864} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2744, "median_us": 360.229, "min_us": 345.243, "max_us": 1172.814, "rows": 10, "peak_rss_kb": 3784} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25472.288, "min_us": 25261.457, "max_us": 33253.776, "rows": 10, "peak_rss_kb": 4832} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25602.618, "min_us": 25424.693, "max_us": 27090.33, "rows": 10, "peak_rss_kb": 4824} +{"round": 2, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25383.677, "min_us": 25264.427, "max_us": 29115.778, "rows": 10, "peak_rss_kb": 4808} +{"round": 2, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25362.803, "min_us": 25253.247, "max_us": 33726.947, "rows": 10, "peak_rss_kb": 4808} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2155, "median_us": 456.641, "min_us": 448.256, "max_us": 1444.153, "rows": 10, "peak_rss_kb": 3700} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 16, "median_us": 64563.716, "min_us": 64343.98, "max_us": 73281.349, "rows": 10, "peak_rss_kb": 4860} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2141, "median_us": 458.162, "min_us": 451.952, "max_us": 1454.791, "rows": 10, "peak_rss_kb": 3716} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62813.637, "min_us": 62262.455, "max_us": 65004.883, "rows": 10, "peak_rss_kb": 4876} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8634, "median_us": 112.042, "min_us": 111.079, "max_us": 1497.188, "rows": 1, "peak_rss_kb": 3708} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.93, "min_us": 20.51, "max_us": 93.378, "rows": 1, "peak_rss_kb": 3812} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.007, "min_us": 18.565, "max_us": 94.512, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.993, "min_us": 18.469, "max_us": 104.859, "rows": 1, "peak_rss_kb": 3772} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.869, "min_us": 16.819, "max_us": 83.409, "rows": 1, "peak_rss_kb": 3732} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.763, "min_us": 17.814, "max_us": 81.775, "rows": 1, "peak_rss_kb": 3792} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3009, "median_us": 323.358, "min_us": 315.108, "max_us": 3752.876, "rows": 1, "peak_rss_kb": 3704} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3066, "median_us": 320.323, "min_us": 312.961, "max_us": 1014.121, "rows": 1, "peak_rss_kb": 3656} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139268.148, "min_us": 138356.708, "max_us": 139742.486, "rows": 166666, "peak_rss_kb": 5312} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139354.681, "min_us": 139052.022, "max_us": 139927.452, "rows": 166666, "peak_rss_kb": 5300} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2698, "median_us": 361.642, "min_us": 347.237, "max_us": 1194.932, "rows": 10, "peak_rss_kb": 3820} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2587, "median_us": 376.483, "min_us": 367.925, "max_us": 4501.921, "rows": 10, "peak_rss_kb": 3788} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270440.524, "min_us": 267778.725, "max_us": 271862.69, "rows": 10, "peak_rss_kb": 5032} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270863.746, "min_us": 269732.35, "max_us": 272756.709, "rows": 10, "peak_rss_kb": 4988} +{"round": 2, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268604.568, "min_us": 268322.147, "max_us": 319852.46, "rows": 10, "peak_rss_kb": 5060} +{"round": 2, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 267559.016, "min_us": 266048.641, "max_us": 278298.904, "rows": 10, "peak_rss_kb": 5004} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2118, "median_us": 463.954, "min_us": 452.226, "max_us": 1499.976, "rows": 10, "peak_rss_kb": 3700} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 650786.529, "min_us": 648681.037, "max_us": 658560.777, "rows": 10, "peak_rss_kb": 4900} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2176, "median_us": 458.669, "min_us": 431.312, "max_us": 1409.959, "rows": 10, "peak_rss_kb": 3752} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 656929.758, "min_us": 655165.105, "max_us": 663975.921, "rows": 10, "peak_rss_kb": 4952} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8306, "median_us": 117.169, "min_us": 113.863, "max_us": 380.752, "rows": 1, "peak_rss_kb": 3752} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.836, "min_us": 20.224, "max_us": 86.349, "rows": 1, "peak_rss_kb": 3768} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.114, "min_us": 18.468, "max_us": 86.636, "rows": 1, "peak_rss_kb": 3736} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.78, "min_us": 18.205, "max_us": 84.338, "rows": 1, "peak_rss_kb": 3796} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.527, "min_us": 16.798, "max_us": 742.505, "rows": 1, "peak_rss_kb": 3728} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.035, "min_us": 17.266, "max_us": 78.46, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3005, "median_us": 327.174, "min_us": 317.702, "max_us": 1049.976, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3011, "median_us": 326.191, "min_us": 317.493, "max_us": 1026.023, "rows": 1, "peak_rss_kb": 3660} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1413415.286, "min_us": 1404827.263, "max_us": 1421410.786, "rows": 1666666, "peak_rss_kb": 5300} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1459722.131, "min_us": 1433407.014, "max_us": 1472920.163, "rows": 1666666, "peak_rss_kb": 5424} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2655, "median_us": 370.185, "min_us": 353.074, "max_us": 1167.725, "rows": 10, "peak_rss_kb": 3800} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2681, "median_us": 362.744, "min_us": 351.987, "max_us": 3781.714, "rows": 10, "peak_rss_kb": 3804} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2804241.349, "min_us": 2798955.462, "max_us": 2832465.12, "rows": 10, "peak_rss_kb": 5020} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2826470.031, "min_us": 2802901.107, "max_us": 2828550.877, "rows": 10, "peak_rss_kb": 5076} +{"round": 2, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2783627.92, "min_us": 2770489.973, "max_us": 2835989.676, "rows": 10, "peak_rss_kb": 5060} +{"round": 2, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2840713.301, "min_us": 2819433.684, "max_us": 2869516.773, "rows": 10, "peak_rss_kb": 4976} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 167, "median_us": 5992.129, "min_us": 5907.214, "max_us": 7420.173, "rows": 10, "peak_rss_kb": 4188} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2139, "median_us": 461.205, "min_us": 445.814, "max_us": 1449.381, "rows": 10, "peak_rss_kb": 3708} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 165, "median_us": 6010.045, "min_us": 5918.006, "max_us": 13073.267, "rows": 10, "peak_rss_kb": 4148} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2141, "median_us": 459.982, "min_us": 442.234, "max_us": 1455.078, "rows": 10, "peak_rss_kb": 3716} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 21.02, "min_us": 20.405, "max_us": 90.846, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7534, "median_us": 129.666, "min_us": 128.572, "max_us": 424.127, "rows": 1, "peak_rss_kb": 3728} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.115, "min_us": 18.488, "max_us": 833.142, "rows": 1, "peak_rss_kb": 3836} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.722, "min_us": 18.353, "max_us": 84.294, "rows": 1, "peak_rss_kb": 3872} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.956, "min_us": 18.544, "max_us": 106.506, "rows": 1, "peak_rss_kb": 3788} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.188, "min_us": 18.674, "max_us": 82.323, "rows": 1, "peak_rss_kb": 3804} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3040, "median_us": 323.117, "min_us": 319.783, "max_us": 1014.786, "rows": 1, "peak_rss_kb": 3688} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3024, "median_us": 323.699, "min_us": 316.761, "max_us": 3143.238, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13316.291, "min_us": 13260.185, "max_us": 14963.648, "rows": 16666, "peak_rss_kb": 4856} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13616.487, "min_us": 13580.999, "max_us": 13930.872, "rows": 16666, "peak_rss_kb": 4868} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2669, "median_us": 367.407, "min_us": 349.628, "max_us": 3101.505, "rows": 10, "peak_rss_kb": 3792} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2672, "median_us": 368.129, "min_us": 353.44, "max_us": 1180.806, "rows": 10, "peak_rss_kb": 3728} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25539.126, "min_us": 25343.362, "max_us": 25952.281, "rows": 10, "peak_rss_kb": 4808} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25524.767, "min_us": 25352.26, "max_us": 34469.155, "rows": 10, "peak_rss_kb": 4732} +{"round": 3, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25410.494, "min_us": 25190.912, "max_us": 25784.034, "rows": 10, "peak_rss_kb": 4820} +{"round": 3, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25475.373, "min_us": 25291.405, "max_us": 25634.825, "rows": 10, "peak_rss_kb": 4788} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 16, "median_us": 62151.739, "min_us": 61771.457, "max_us": 71512.823, "rows": 10, "peak_rss_kb": 4872} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2170, "median_us": 455.727, "min_us": 436.987, "max_us": 1426.886, "rows": 10, "peak_rss_kb": 3776} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62692.349, "min_us": 62058.182, "max_us": 70391.296, "rows": 10, "peak_rss_kb": 4864} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2160, "median_us": 455.012, "min_us": 446.969, "max_us": 1448.312, "rows": 10, "peak_rss_kb": 3700} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.658, "min_us": 20.078, "max_us": 87.886, "rows": 1, "peak_rss_kb": 3800} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8672, "median_us": 112.401, "min_us": 111.482, "max_us": 378.848, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.758, "min_us": 18.261, "max_us": 762.198, "rows": 1, "peak_rss_kb": 3784} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.408, "min_us": 18.908, "max_us": 53.519, "rows": 1, "peak_rss_kb": 3836} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.708, "min_us": 16.666, "max_us": 97.138, "rows": 1, "peak_rss_kb": 3740} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.045, "min_us": 16.979, "max_us": 78.812, "rows": 1, "peak_rss_kb": 3876} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3060, "median_us": 322.605, "min_us": 318.227, "max_us": 1020.867, "rows": 1, "peak_rss_kb": 3712} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3039, "median_us": 322.721, "min_us": 315.132, "max_us": 3086.509, "rows": 1, "peak_rss_kb": 3628} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140345.58, "min_us": 139107.113, "max_us": 144205.097, "rows": 166666, "peak_rss_kb": 5240} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 142462.574, "min_us": 139147.702, "max_us": 151669.866, "rows": 166666, "peak_rss_kb": 5392} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2590, "median_us": 378.184, "min_us": 371.129, "max_us": 1232.146, "rows": 10, "peak_rss_kb": 3788} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2590, "median_us": 378.752, "min_us": 374.932, "max_us": 1195.303, "rows": 10, "peak_rss_kb": 3776} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269811.717, "min_us": 268560.762, "max_us": 273601.316, "rows": 10, "peak_rss_kb": 4936} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269928.907, "min_us": 268640.576, "max_us": 280199.756, "rows": 10, "peak_rss_kb": 5016} +{"round": 3, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 264003.317, "min_us": 263305.06, "max_us": 269180.683, "rows": 10, "peak_rss_kb": 4972} +{"round": 3, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 271249.082, "min_us": 268798.379, "max_us": 272026.983, "rows": 10, "peak_rss_kb": 4988} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 631578.933, "min_us": 630150.198, "max_us": 645590.34, "rows": 10, "peak_rss_kb": 4940} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2123, "median_us": 464.016, "min_us": 456.556, "max_us": 1471.263, "rows": 10, "peak_rss_kb": 3796} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 633363.859, "min_us": 630092.466, "max_us": 637886.099, "rows": 10, "peak_rss_kb": 4940} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2197, "median_us": 447.716, "min_us": 428.346, "max_us": 1420.34, "rows": 10, "peak_rss_kb": 3760} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.743, "min_us": 20.16, "max_us": 80.272, "rows": 1, "peak_rss_kb": 3792} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8209, "median_us": 117.413, "min_us": 112.958, "max_us": 1596.69, "rows": 1, "peak_rss_kb": 3752} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.003, "min_us": 18.456, "max_us": 75.737, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.721, "min_us": 18.144, "max_us": 99.593, "rows": 1, "peak_rss_kb": 3736} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.021, "min_us": 17.197, "max_us": 79.7, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.958, "min_us": 17.261, "max_us": 77.188, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3023, "median_us": 321.929, "min_us": 316.297, "max_us": 4268.482, "rows": 1, "peak_rss_kb": 3708} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3056, "median_us": 321.053, "min_us": 316.292, "max_us": 1029.261, "rows": 1, "peak_rss_kb": 3672} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1458306.83, "min_us": 1415763.675, "max_us": 1544801.943, "rows": 1666666, "peak_rss_kb": 5324} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1468171.017, "min_us": 1455057.28, "max_us": 1484504.613, "rows": 1666666, "peak_rss_kb": 5380} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2674, "median_us": 367.552, "min_us": 348.627, "max_us": 1150.778, "rows": 10, "peak_rss_kb": 3800} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2711, "median_us": 362.713, "min_us": 350.321, "max_us": 1154.281, "rows": 10, "peak_rss_kb": 3856} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2782133.505, "min_us": 2777786.476, "max_us": 2826370.259, "rows": 10, "peak_rss_kb": 4988} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2829604.637, "min_us": 2824145.703, "max_us": 2877554.562, "rows": 10, "peak_rss_kb": 5180} +{"round": 3, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2790627.058, "min_us": 2777566.206, "max_us": 2859175.51, "rows": 10, "peak_rss_kb": 5080} +{"round": 3, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2849620.061, "min_us": 2834464.183, "max_us": 2872590.182, "rows": 10, "peak_rss_kb": 5104} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2125, "median_us": 457.675, "min_us": 442.189, "max_us": 3893.195, "rows": 10, "peak_rss_kb": 3760} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 166, "median_us": 6046.133, "min_us": 6017.683, "max_us": 6127.19, "rows": 10, "peak_rss_kb": 4196} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2147, "median_us": 456.76, "min_us": 442.329, "max_us": 1447.457, "rows": 10, "peak_rss_kb": 3740} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 152, "median_us": 6205.975, "min_us": 6141.856, "max_us": 55593.991, "rows": 10, "peak_rss_kb": 4196} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7513, "median_us": 130.114, "min_us": 129.01, "max_us": 420.986, "rows": 1, "peak_rss_kb": 3736} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.883, "min_us": 20.327, "max_us": 92.962, "rows": 1, "peak_rss_kb": 3812} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.687, "min_us": 18.132, "max_us": 68.964, "rows": 1, "peak_rss_kb": 3772} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.691, "min_us": 18.157, "max_us": 104.451, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.187, "min_us": 18.541, "max_us": 91.35, "rows": 1, "peak_rss_kb": 3780} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 20.339, "min_us": 19.823, "max_us": 882.814, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3039, "median_us": 325.605, "min_us": 321.91, "max_us": 515.58, "rows": 1, "peak_rss_kb": 3752} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3039, "median_us": 324.659, "min_us": 320.732, "max_us": 1024.67, "rows": 1, "peak_rss_kb": 3668} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 73, "median_us": 13510.332, "min_us": 13451.291, "max_us": 21438.851, "rows": 16666, "peak_rss_kb": 4912} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13320.631, "min_us": 13278.934, "max_us": 14391.089, "rows": 16666, "peak_rss_kb": 4924} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2691, "median_us": 364.746, "min_us": 354.872, "max_us": 1179.088, "rows": 10, "peak_rss_kb": 3760} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2729, "median_us": 355.784, "min_us": 343.443, "max_us": 3072.965, "rows": 10, "peak_rss_kb": 3848} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25466.605, "min_us": 25284.151, "max_us": 25693.397, "rows": 10, "peak_rss_kb": 4784} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25410.917, "min_us": 25248.053, "max_us": 26951.89, "rows": 10, "peak_rss_kb": 4824} +{"round": 4, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25525.559, "min_us": 25363.884, "max_us": 33677.51, "rows": 10, "peak_rss_kb": 4736} +{"round": 4, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25357.592, "min_us": 25255.153, "max_us": 25674.034, "rows": 10, "peak_rss_kb": 4744} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2157, "median_us": 454.513, "min_us": 445.028, "max_us": 1446.067, "rows": 10, "peak_rss_kb": 3736} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 17, "median_us": 62224.422, "min_us": 62118.336, "max_us": 62671.293, "rows": 10, "peak_rss_kb": 4864} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2122, "median_us": 458.485, "min_us": 451.069, "max_us": 1468.055, "rows": 10, "peak_rss_kb": 3760} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62786.439, "min_us": 62341.531, "max_us": 69924.452, "rows": 10, "peak_rss_kb": 4876} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8696, "median_us": 111.982, "min_us": 110.869, "max_us": 374.828, "rows": 1, "peak_rss_kb": 3652} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.992, "min_us": 20.45, "max_us": 120.98, "rows": 1, "peak_rss_kb": 3764} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.897, "min_us": 18.306, "max_us": 96.854, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.704, "min_us": 18.135, "max_us": 82.092, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.957, "min_us": 16.878, "max_us": 730.23, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.761, "min_us": 16.78, "max_us": 89.316, "rows": 1, "peak_rss_kb": 3772} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3026, "median_us": 324.006, "min_us": 319.588, "max_us": 1016.641, "rows": 1, "peak_rss_kb": 3596} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3097, "median_us": 317.182, "min_us": 313.156, "max_us": 1014.38, "rows": 1, "peak_rss_kb": 3716} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140614.463, "min_us": 139890.671, "max_us": 151900.196, "rows": 166666, "peak_rss_kb": 5232} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141954.845, "min_us": 140265.582, "max_us": 142687.104, "rows": 166666, "peak_rss_kb": 5308} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2560, "median_us": 359.217, "min_us": 345.007, "max_us": 43007.652, "rows": 10, "peak_rss_kb": 3768} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2667, "median_us": 365.688, "min_us": 346.404, "max_us": 1208.721, "rows": 10, "peak_rss_kb": 3728} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269981.315, "min_us": 267355.21, "max_us": 279352.781, "rows": 10, "peak_rss_kb": 4968} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 266472.531, "min_us": 265781.403, "max_us": 272149.809, "rows": 10, "peak_rss_kb": 5044} +{"round": 4, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 269351.827, "min_us": 267736.932, "max_us": 272557.143, "rows": 10, "peak_rss_kb": 4976} +{"round": 4, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 266627.634, "min_us": 265361.055, "max_us": 273226.176, "rows": 10, "peak_rss_kb": 5056} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2131, "median_us": 462.172, "min_us": 454.803, "max_us": 1460.247, "rows": 10, "peak_rss_kb": 3724} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 655217.898, "min_us": 652033.238, "max_us": 664513.1, "rows": 10, "peak_rss_kb": 4844} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2170, "median_us": 454.699, "min_us": 447.214, "max_us": 1491.166, "rows": 10, "peak_rss_kb": 3712} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 655544.346, "min_us": 654890.675, "max_us": 663812.733, "rows": 10, "peak_rss_kb": 4884} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8335, "median_us": 117.358, "min_us": 113.467, "max_us": 443.108, "rows": 1, "peak_rss_kb": 3728} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.978, "min_us": 20.313, "max_us": 803.005, "rows": 1, "peak_rss_kb": 3808} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.79, "min_us": 18.307, "max_us": 100.77, "rows": 1, "peak_rss_kb": 3888} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.23, "min_us": 18.639, "max_us": 104.854, "rows": 1, "peak_rss_kb": 3740} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.544, "min_us": 17.562, "max_us": 103.305, "rows": 1, "peak_rss_kb": 3832} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.027, "min_us": 17.228, "max_us": 80.408, "rows": 1, "peak_rss_kb": 3796} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3027, "median_us": 324.824, "min_us": 316.632, "max_us": 1024.851, "rows": 1, "peak_rss_kb": 3760} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2904, "median_us": 320.52, "min_us": 315.554, "max_us": 46020.541, "rows": 1, "peak_rss_kb": 3648} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1433884.677, "min_us": 1417249.656, "max_us": 1439564.502, "rows": 1666666, "peak_rss_kb": 5312} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1444895.082, "min_us": 1435585.716, "max_us": 1463531.389, "rows": 1666666, "peak_rss_kb": 5332} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2635, "median_us": 368.19, "min_us": 351.516, "max_us": 3801.569, "rows": 10, "peak_rss_kb": 3720} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2658, "median_us": 369.493, "min_us": 356.178, "max_us": 1164.922, "rows": 10, "peak_rss_kb": 3804} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2790671.454, "min_us": 2773009.669, "max_us": 2805710.933, "rows": 10, "peak_rss_kb": 5100} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2817039.274, "min_us": 2809935.538, "max_us": 2858113.487, "rows": 10, "peak_rss_kb": 5132} +{"round": 4, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2770028.937, "min_us": 2760826.163, "max_us": 2816613.33, "rows": 10, "peak_rss_kb": 4996} +{"round": 4, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2831752.835, "min_us": 2814714.104, "max_us": 2843993.936, "rows": 10, "peak_rss_kb": 5080} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 167, "median_us": 5940.144, "min_us": 5902.1, "max_us": 7533.984, "rows": 10, "peak_rss_kb": 4144} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2136, "median_us": 457.412, "min_us": 444.509, "max_us": 3904.184, "rows": 10, "peak_rss_kb": 3724} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 147, "median_us": 6719.9, "min_us": 6680.681, "max_us": 7426.924, "rows": 10, "peak_rss_kb": 4160} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2150, "median_us": 457.548, "min_us": 438.404, "max_us": 1450.648, "rows": 10, "peak_rss_kb": 3768} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 22.528, "min_us": 21.86, "max_us": 95.825, "rows": 1, "peak_rss_kb": 3836} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7502, "median_us": 129.105, "min_us": 128.007, "max_us": 1654.713, "rows": 1, "peak_rss_kb": 3704} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.85, "min_us": 18.416, "max_us": 98.233, "rows": 1, "peak_rss_kb": 3788} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.836, "min_us": 18.362, "max_us": 114.89, "rows": 1, "peak_rss_kb": 3800} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.065, "min_us": 18.578, "max_us": 113.401, "rows": 1, "peak_rss_kb": 3824} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.233, "min_us": 18.764, "max_us": 97.688, "rows": 1, "peak_rss_kb": 3832} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3020, "median_us": 321.996, "min_us": 315.363, "max_us": 3757.335, "rows": 1, "peak_rss_kb": 3660} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3053, "median_us": 320.297, "min_us": 317.55, "max_us": 1038.069, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13309.306, "min_us": 13270.652, "max_us": 15037.819, "rows": 16666, "peak_rss_kb": 4916} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13447.968, "min_us": 13244.994, "max_us": 21792.858, "rows": 16666, "peak_rss_kb": 4964} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2804, "median_us": 349.757, "min_us": 338.03, "max_us": 1167.227, "rows": 10, "peak_rss_kb": 3768} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2739, "median_us": 358.712, "min_us": 347.008, "max_us": 1166.135, "rows": 10, "peak_rss_kb": 3788} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 38, "median_us": 25420.645, "min_us": 25281.817, "max_us": 78729.953, "rows": 10, "peak_rss_kb": 4816} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25521.427, "min_us": 25332.376, "max_us": 27144.593, "rows": 10, "peak_rss_kb": 4788} +{"round": 5, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25314.077, "min_us": 25222.843, "max_us": 25938.461, "rows": 10, "peak_rss_kb": 4792} +{"round": 5, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25791.413, "min_us": 25605.929, "max_us": 34646.837, "rows": 10, "peak_rss_kb": 4832} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 16, "median_us": 62340.02, "min_us": 62076.545, "max_us": 65314.216, "rows": 10, "peak_rss_kb": 4840} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2162, "median_us": 453.213, "min_us": 433.548, "max_us": 4369.987, "rows": 10, "peak_rss_kb": 3724} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62611.942, "min_us": 62326.632, "max_us": 65096.269, "rows": 10, "peak_rss_kb": 4844} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2137, "median_us": 460.96, "min_us": 454.143, "max_us": 1446.706, "rows": 10, "peak_rss_kb": 3792} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.656, "min_us": 20.166, "max_us": 106.557, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8606, "median_us": 112.244, "min_us": 111.368, "max_us": 1630.003, "rows": 1, "peak_rss_kb": 3704} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.039, "min_us": 18.477, "max_us": 81.735, "rows": 1, "peak_rss_kb": 3788} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.484, "min_us": 18.051, "max_us": 83.495, "rows": 1, "peak_rss_kb": 3800} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.919, "min_us": 16.964, "max_us": 82.981, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.816, "min_us": 16.751, "max_us": 80.222, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3045, "median_us": 320.416, "min_us": 312.736, "max_us": 3632.054, "rows": 1, "peak_rss_kb": 3692} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2993, "median_us": 328.48, "min_us": 316.418, "max_us": 1043.398, "rows": 1, "peak_rss_kb": 3600} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141426.393, "min_us": 139669.851, "max_us": 142368.962, "rows": 166666, "peak_rss_kb": 5272} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141614.204, "min_us": 140116.418, "max_us": 141980.243, "rows": 166666, "peak_rss_kb": 5236} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2536, "median_us": 386.696, "min_us": 381.829, "max_us": 1227.672, "rows": 10, "peak_rss_kb": 3776} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2589, "median_us": 375.033, "min_us": 367.862, "max_us": 3901.606, "rows": 10, "peak_rss_kb": 3748} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270131.036, "min_us": 266085.499, "max_us": 276004.337, "rows": 10, "peak_rss_kb": 5020} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269936.996, "min_us": 266148.559, "max_us": 274451.616, "rows": 10, "peak_rss_kb": 4972} +{"round": 5, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 265589.121, "min_us": 263711.785, "max_us": 271796.047, "rows": 10, "peak_rss_kb": 5104} +{"round": 5, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 269582.785, "min_us": 268294.791, "max_us": 319527.977, "rows": 10, "peak_rss_kb": 4964} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 634253.357, "min_us": 629656.282, "max_us": 640058.486, "rows": 10, "peak_rss_kb": 4916} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2123, "median_us": 459.371, "min_us": 448.981, "max_us": 5757.382, "rows": 10, "peak_rss_kb": 3708} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 632806.611, "min_us": 631847.557, "max_us": 639441.286, "rows": 10, "peak_rss_kb": 4908} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2182, "median_us": 449.749, "min_us": 423.926, "max_us": 4586.758, "rows": 10, "peak_rss_kb": 3788} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.994, "min_us": 20.351, "max_us": 89.951, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8352, "median_us": 116.621, "min_us": 113.364, "max_us": 375.69, "rows": 1, "peak_rss_kb": 3820} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.724, "min_us": 18.18, "max_us": 115.29, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.787, "min_us": 18.278, "max_us": 90.777, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.99, "min_us": 17.298, "max_us": 821.725, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.468, "min_us": 16.861, "max_us": 83.218, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3042, "median_us": 322.319, "min_us": 316.741, "max_us": 1031.162, "rows": 1, "peak_rss_kb": 3696} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3053, "median_us": 321.851, "min_us": 316.93, "max_us": 1030.831, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1415529.756, "min_us": 1396228.037, "max_us": 1438827.33, "rows": 1666666, "peak_rss_kb": 5280} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1466317.473, "min_us": 1452121.592, "max_us": 1477550.298, "rows": 1666666, "peak_rss_kb": 5348} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2672, "median_us": 367.935, "min_us": 355.391, "max_us": 1151.57, "rows": 10, "peak_rss_kb": 3768} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2619, "median_us": 375.695, "min_us": 355.409, "max_us": 3787.142, "rows": 10, "peak_rss_kb": 3808} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2825886.763, "min_us": 2789056.321, "max_us": 2831072.01, "rows": 10, "peak_rss_kb": 4996} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2894368.385, "min_us": 2873784.098, "max_us": 2947529.973, "rows": 10, "peak_rss_kb": 4984} +{"round": 5, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2806003.586, "min_us": 2805078.305, "max_us": 2866379.403, "rows": 10, "peak_rss_kb": 5020} +{"round": 5, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2833082.311, "min_us": 2805646.459, "max_us": 2864104.49, "rows": 10, "peak_rss_kb": 4972} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2152, "median_us": 449.747, "min_us": 439.822, "max_us": 1452.048, "rows": 10, "peak_rss_kb": 3688} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 168, "median_us": 5954.685, "min_us": 5900.64, "max_us": 6329.47, "rows": 10, "peak_rss_kb": 4104} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2036, "median_us": 457.269, "min_us": 443.036, "max_us": 46135.642, "rows": 10, "peak_rss_kb": 3684} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 165, "median_us": 6023.443, "min_us": 5985.14, "max_us": 6751.657, "rows": 10, "peak_rss_kb": 4148} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7495, "median_us": 130.358, "min_us": 129.207, "max_us": 424.705, "rows": 1, "peak_rss_kb": 3720} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 21.239, "min_us": 20.483, "max_us": 801.792, "rows": 1, "peak_rss_kb": 3804} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.945, "min_us": 18.425, "max_us": 78.484, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.846, "min_us": 18.085, "max_us": 81.785, "rows": 1, "peak_rss_kb": 3816} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.749, "min_us": 18.385, "max_us": 80.371, "rows": 1, "peak_rss_kb": 3792} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.272, "min_us": 18.729, "max_us": 88.204, "rows": 1, "peak_rss_kb": 3784} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3015, "median_us": 325.137, "min_us": 321.612, "max_us": 1023.708, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3042, "median_us": 318.987, "min_us": 315.13, "max_us": 3190.883, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13644.784, "min_us": 13441.086, "max_us": 14953.032, "rows": 16666, "peak_rss_kb": 5016} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13332.163, "min_us": 13295.852, "max_us": 13637.668, "rows": 16666, "peak_rss_kb": 4904} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2699, "median_us": 362.467, "min_us": 348.94, "max_us": 4637.761, "rows": 10, "peak_rss_kb": 3792} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2785, "median_us": 349.651, "min_us": 337.946, "max_us": 1194.415, "rows": 10, "peak_rss_kb": 3824} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25477.454, "min_us": 25296.035, "max_us": 32545.04, "rows": 10, "peak_rss_kb": 4888} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25408.296, "min_us": 25257.617, "max_us": 27488.853, "rows": 10, "peak_rss_kb": 4836} +{"round": 6, "variant": "pr", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25452.11, "min_us": 25229.554, "max_us": 25938.933, "rows": 10, "peak_rss_kb": 4840} +{"round": 6, "variant": "base", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25427.593, "min_us": 25285.603, "max_us": 34807.336, "rows": 10, "peak_rss_kb": 4784} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2182, "median_us": 454.092, "min_us": 432.554, "max_us": 1426.114, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 17, "median_us": 62238.019, "min_us": 62014.423, "max_us": 62734.557, "rows": 10, "peak_rss_kb": 4888} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2156, "median_us": 453.242, "min_us": 445.124, "max_us": 4557.277, "rows": 10, "peak_rss_kb": 3740} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 16, "median_us": 62591.193, "min_us": 62067.688, "max_us": 63364.919, "rows": 10, "peak_rss_kb": 4896} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8664, "median_us": 113.074, "min_us": 112.091, "max_us": 396.071, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 20.789, "min_us": 20.166, "max_us": 826.547, "rows": 1, "peak_rss_kb": 3820} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.794, "min_us": 18.089, "max_us": 81.508, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.693, "min_us": 18.096, "max_us": 81.38, "rows": 1, "peak_rss_kb": 3764} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.179, "min_us": 17.129, "max_us": 88.605, "rows": 1, "peak_rss_kb": 3840} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.806, "min_us": 16.912, "max_us": 82.694, "rows": 1, "peak_rss_kb": 3736} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3042, "median_us": 319.166, "min_us": 313.584, "max_us": 1017.056, "rows": 1, "peak_rss_kb": 3708} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3052, "median_us": 317.914, "min_us": 313.145, "max_us": 3779.308, "rows": 1, "peak_rss_kb": 3700} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 143500.959, "min_us": 142932.708, "max_us": 144050.45, "rows": 166666, "peak_rss_kb": 5196} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 140802.695, "min_us": 140308.563, "max_us": 196677.75, "rows": 166666, "peak_rss_kb": 5340} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2654, "median_us": 367.841, "min_us": 347.205, "max_us": 1200.188, "rows": 10, "peak_rss_kb": 3780} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2603, "median_us": 377.727, "min_us": 371.678, "max_us": 1198.651, "rows": 10, "peak_rss_kb": 3744} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269201.464, "min_us": 264429.313, "max_us": 269947.052, "rows": 10, "peak_rss_kb": 5092} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269910.76, "min_us": 266262.095, "max_us": 280000.156, "rows": 10, "peak_rss_kb": 4996} +{"round": 6, "variant": "pr", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270771.373, "min_us": 267257.138, "max_us": 277226.004, "rows": 10, "peak_rss_kb": 5008} +{"round": 6, "variant": "base", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 266122.96, "min_us": 265990.576, "max_us": 267802.657, "rows": 10, "peak_rss_kb": 5000} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2046, "median_us": 476.242, "min_us": 464.735, "max_us": 4238.672, "rows": 10, "peak_rss_kb": 3680} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 656110.882, "min_us": 652421.477, "max_us": 668495.79, "rows": 10, "peak_rss_kb": 4868} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2115, "median_us": 459.391, "min_us": 451.266, "max_us": 4649.977, "rows": 10, "peak_rss_kb": 3652} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 5, "median_us": 654683.528, "min_us": 650668.694, "max_us": 665503.244, "rows": 10, "peak_rss_kb": 4920} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8279, "median_us": 117.728, "min_us": 114.385, "max_us": 3702.814, "rows": 1, "peak_rss_kb": 3732} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 20000, "median_us": 21.393, "min_us": 20.72, "max_us": 97.104, "rows": 1, "peak_rss_kb": 3776} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.087, "min_us": 18.554, "max_us": 51.002, "rows": 1, "peak_rss_kb": 3820} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 18.709, "min_us": 18.151, "max_us": 82.658, "rows": 1, "peak_rss_kb": 3820} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.112, "min_us": 17.312, "max_us": 78.814, "rows": 1, "peak_rss_kb": 3836} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.649, "min_us": 16.836, "max_us": 20292.809, "rows": 1, "peak_rss_kb": 3780} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2726, "median_us": 360.232, "min_us": 354.597, "max_us": 1149.5, "rows": 1, "peak_rss_kb": 3684} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3021, "median_us": 325.581, "min_us": 321.048, "max_us": 1021.079, "rows": 1, "peak_rss_kb": 3664} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1402743.92, "min_us": 1393367.024, "max_us": 1414092.757, "rows": 1666666, "peak_rss_kb": 5384} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1463174.214, "min_us": 1452727.936, "max_us": 1469611.304, "rows": 1666666, "peak_rss_kb": 5336} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2621, "median_us": 379.463, "min_us": 356.207, "max_us": 1159.957, "rows": 10, "peak_rss_kb": 3800} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2700, "median_us": 363.288, "min_us": 349.863, "max_us": 1153.558, "rows": 10, "peak_rss_kb": 3784} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2835412.893, "min_us": 2779304.23, "max_us": 2852042.708, "rows": 10, "peak_rss_kb": 5032} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2827626.795, "min_us": 2793018.172, "max_us": 2856214.553, "rows": 10, "peak_rss_kb": 5048} +{"round": 6, "variant": "pr", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2778247.097, "min_us": 2760697.497, "max_us": 2819228.37, "rows": 10, "peak_rss_kb": 5028} +{"round": 6, "variant": "base", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2820626.457, "min_us": 2805712.451, "max_us": 2874229.979, "rows": 10, "peak_rss_kb": 4984} diff --git a/docs/superpowers/plans/2026-10-28-641-input-order.md b/docs/superpowers/plans/2026-10-28-641-input-order.md new file mode 100644 index 0000000000..268d494947 --- /dev/null +++ b/docs/superpowers/plans/2026-10-28-641-input-order.md @@ -0,0 +1,137 @@ +# #641 implementation plan + +Base: origin/v3 `2abf53df05447755490d017bc2daf89f4d59cdf5`. +Status: Claude-reviewed; final conditional-approval corrections applied. +Maintainer approved implementation on 2026-10-28. +Spec: `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. + +1. Obtain Claude's independent spec and implementation-plan review. Verify its + findings in the code, revise and re-review any changed contracts. Present the + reviewed design and bounded scope for maintainer approval before implementation. +2. Use the worktree skill after approval: verify `.worktrees/` is ignored, create + `.worktrees/641-input-order` on `feat/641-input-order` from refreshed origin/v3. + Check for nested instructions and revalidate the design against base changes. + Copy approved spec/plan into docs/superpowers. Main remains untouched. +3. Check bench reachability, idleness and available disk; create a task-specific + scratch checkout/copy and record the exact source revision. Reuse existing + target caches deliberately; create no tests/builds on the laptop. Run the + repository-required baseline checks there before production code changes. +4. TDD order properties first. Add the private unit-test and test-hooks + forced-optimization/fallback switch (like `__reorder`) before relying on it + as a differential oracle. Add tests for comparator-specific prefix matching, + constants/repeated slots, replacements, all Step kinds, hash/probe fallbacks, + projected Distinct canonicalization and group-equality adjacency. Confirm + red on the bench, implement the smallest private metadata module, then green. + Callback detection must walk nested expressions, bindings, not/or bodies, + aggregate descriptors and WindowFunc::Udf; existing plan::udfs alone misses + nested calls. Test those exclusions before enabling any strategy. +5. TDD snapshot/scan resolution. Implement a top-level resolver between + engine::open/resolve(TxBound) and stream/build, receiving the actual snapshot, + keys and function-registry snapshot. The logical Plan carries candidates; + after all proofs succeed the pass chooses source index and holder strategies, + removes Sort with `plan.find = Sort.cols`, and computes hold_ids from the + resolved Window mode. Failed optional reads leave all original fields/choices + intact. Do not push demand into not/or/correlated body plans, and leave + open_rules unchanged. Test pending+staged guards, pinned snapshot + stability, whole-range kind disqualification and bounded read counts with + an instrumented key source. Use existing pending_len (already includes staged) + as a zero-cost fast check; otherwise add a short-circuit range-existence probe + over the captured pending/staged index view, with no full clone or net-assert. + Test unrelated vs in-range pending records, retractions and post-snapshot + writes. Verify large_reader/with_committed sees complete AVET working roots + after finished statements and after rejected-statement rollback. Add a direct + regression: published data holds only integers for an attribute; a completed + large-transaction statement adds a float; a later query in that transaction + must use the working reader for proof and keep Sort. After rollback/new + queries, do not reuse the old proof. Include many + tombstoned historical keys: raw + prefix existence must not scan them to decide there is no live value. Add + the private KeySource raw-prefix predicate via one LeafCursor seek. Test + proof-read failure returning ordinary + fallback, not a new error. Implement demand-specific AVET alternatives and + safe proof reads. Keep existing entity/exact ranges and zero demand unchanged. + Initial properties require the outermost source's unbound value position, + distinct source variables and a single physical range. Test keyword/ref + literal alternates and float-zero/set literal encodings remain uncertified. + Reuse existing selective EAVT e/a value order when proved, rather than + broadening it to AVET. + Resolve choices once per Stream open; nested bodies keep their original + construction and receive no optimization demand. +6. TDD Sort omission end to end: compare forced fallback vs optimized lists on + the same snapshot, assert no Sort and early scan stop for the positive scalar + case, Sort retention for full tie suffixes/type/direction failures. Preserve + projection slot mapping and Limit offset semantics, including a nonidentity + Sort.cols regression. Add callback-count and later CollectSet-error tests + proving those pipelines retain Sort. Add prepared/cursor/ + rule/pending/temporal and invalidation regressions. Run focused suites and + required portability checks on the bench; measure startup proof overhead and + the ordered limit workload against immutable base. Synchronize PR 1 docs, + get Claude code review and verify findings before preparing PR 1 against v3. +7. TDD streaming Aggregate as PR 2. Verify the implementation descriptors of + count/count-distinct cannot raise aggregate data errors. Restrict to one + group column in semantic Value::Ord order, no :with/window/callback/CollectSet. + Extract/reuse a one-group finish helper after representative/empty tests fail. + Test cross-batch groups, signed zeros, mixed numeric grouping and early Limit. + Fallible aggregates/:with/multiple grouping keys remain materialized; add + later-group data-error, dropped-group precedence, UDF callback and CollectSet + failure regressions to verify those fallbacks. Implement one active group plus + bounded input/output batches, no finished-results list. Assert active-group + high-water=1, memory independent of completed groups and early input stopping. + Evict transient DICT caches between safe internal child-batch pulls, not only + when returning to Stream. Test unique scalar group-key Sort omission with a + single kind and retention for mixed numeric kinds; benchmark count/count-distinct at + scaling sizes. Run aggregate/memory/cursor checks, update docs and obtain + Claude's code review before preparing PR 2. +8. TDD partition Window as PR 3. Add compatible/incompatible multiple-window + queries, callback/CollectSet/aggregate-query fallbacks, physical input order and boundary-crossing cases + for peers/rank/row-number/lag/lead/all row frames. Implement one partition with + lookahead and reuse shared windows evaluator. Select DICT cache lifetime from + actual Window strategy; evict transient caches at internal child-batch + boundaries. Verify Window and IdSpace peak stay bounded for fixed + committed partitions while total size increases, including close/rewind/error + and checkpoint pinning. Run window/memory/cursor/prepared/limit suites and + benchmark one growing partition plus many fixed-size partitions. +9. Finish each slice with fresh required verification on the bench: full cargo + tests including test-hooks, documented all-feature clippy and WASM/WASI checks, + applicable coverage floors and binary-size gate; fmt may run locally. Run + meaningful A/B envelope/point guards once per final relevant revision. Record + optimized committed-memory-backend fixtures on WASI/browser where supported, + and record unavailable runner limitations precisely. Follow the numeric + acceptance gates in spec §8.1; frozen bag digests remain unchanged and are + never re-blessed. If keys.rs changes, run existing Kani encoder harnesses on + the bench; add no decoder/string harnesses. Do not rerun broad checks without + a code change/failure/unresolved risk. Clean task-created remote scratch; + document retained reusable state and remove it when the task ends. +10. Cross-check all repository status/test-count/reference/perf docs and the + docs-site version-scoped architecture update. Record benchmark IDs and actual + nightly filter routing for #776. Obtain Claude's final code/evidence review + before opening each PR. Re-review material fixes, open PRs against v3, and + monitor CI/fix failures. Do not merge or close the issue without the + maintainer's authorization and complete acceptance evidence. + +Update stale module/field comments in engine/sort.rs, aggregate.rs, window.rs, +ids.rs and mod.rs; CLAUDE.md's operator descriptions; ROADMAP.md's prior v3.next +entry (current issue milestone is v3.0.0); docs/BENCHMARKS.md; and the coverage +inventory. Strategy counter names are private (the profiler is not yet public): +an omitted Sort has no counter, and chosen Aggregate/Window modes have explicit +private markers for tests and the future #185 profiler. + +Representative required commands, all heavy commands on the bench: + +```sh +cargo test --quiet +cargo test --features test-hooks +cargo clippy --all-features -- -D warnings +cargo clippy --target wasm32-unknown-unknown --features browser -- -D warnings +cargo clippy --target wasm32-wasip1 -- -D warnings +cargo test --target wasm32-wasip1 --lib --tests +cargo build --release +cargo kani --lib -j --output-format terse -Z unstable-options --harness-timeout 10m +``` + +Use the pinned coverage workflow toolchain and scripts for the coverage gate; +validate the release binary against 1,259,520 bytes. Run wasm-pack browser tests +with the project's CI recipe if runners are installed. Fmt may run locally. + +No version bump, release tag, public config/type hints, new dependency, index +format change, disk spill, source-run merge or generalized optimizer is planned. diff --git a/docs/superpowers/specs/2026-10-24-limit-order-by-design.md b/docs/superpowers/specs/2026-10-24-limit-order-by-design.md index ae87308e05..008fbd70d7 100644 --- a/docs/superpowers/specs/2026-10-24-limit-order-by-design.md +++ b/docs/superpowers/specs/2026-10-24-limit-order-by-design.md @@ -3,6 +3,7 @@ **Milestone:** v3.0.0, branch `v3`. No change to the `.graph` format, the WAL format or the public Rust API. **Follows:** #473 (streaming engine; its `Limit`/`Offset` operators, §6.1 there, and `Sort`, §6.2 there, are built here), #547 (`value_order`). **Leaves to #641 (v3.next):** skipping `Sort` when an index already returns the rows in order, and sort-grouped `Aggregate`. +**Follow-up, 2026-10-28:** #641 now targets v3.0.0; its approved three-slice scope is recorded in [the input-order design](2026-10-28-641-input-order-design.md). This document retains the original #306 decisions below. **Status:** approved 2026-10-24; not implemented. ## 1. Decisions diff --git a/docs/superpowers/specs/2026-10-28-641-input-order-design.md b/docs/superpowers/specs/2026-10-28-641-input-order-design.md new file mode 100644 index 0000000000..4e93d0f37e --- /dev/null +++ b/docs/superpowers/specs/2026-10-28-641-input-order-design.md @@ -0,0 +1,389 @@ +# #641: use proven input order in the streaming engine + +Date: 2026-10-28. Base: `origin/v3` at `2abf53df05447755490d017bc2daf89f4d59cdf5`. +Status: Claude-reviewed; final conditional-approval corrections applied. +Maintainer approved implementation on 2026-10-28. Delivery is split into three slices (§9). +Issue: https://github.com/project-minigraf/minigraf/issues/641 +Target: `v3`, following the issue's current v3.0.0 milestone. The older #306 +spec called this v3.next; the current issue milestone takes precedence. + +## Purpose and philosophy + +Avoid a Sort when a scan/operator already produces the required full order; +reduce eligible grouped Aggregate state to one contiguous group; and buffer +only one Window partition when its input makes that possible. Preserve query +answers, grouping/peer rules, deterministic built-in aggregate errors, snapshot +isolation, and memory accounting. Existing top-k Sort already implements the +bounded `offset + limit` fallback and is retained. + +This follows PHILOSOPHY.md §§4–8: reuse existing indexes and operators, add no +dependencies or configuration, and change no public API, syntax, database or WAL +format. Reliability takes priority over covering every possible index order. +Only proved cases use streaming strategies; other queries retain the existing +operators. This does not promise bounded memory for all grouped queries. + +## Existing contracts that constrain the change + +- A Scan emits committed ranges, pending facts, and derived rows in succession. + Those runs are not one sorted stream. Pending keys use UUID/text order; + committed entity/ident positions use DICT ids. +- `:order-by` sorts by explicit keys and every remaining `:find` column ascending. + Matching only the explicit keys is insufficient for pagination. +- Index tag order, `Value::Ord` (group/partition equality and aggregate output), + and `value_order` (Sort/window ranking/peers) are different comparators. +- Committed float keys canonicalize NaNs and distinguish signed zeros. Group + equality equates all NaNs and equates the zeros. Composite grouping can split + an equal group across different zero encodings. +- Long strings use prefix/hash/reference keys. Sets can have different encoded + keys despite equal elements. Neither is presumed lexically ordered. +- Aggregate drains its input, finishes groups in `Value::Ord` grouping-key order, + and returns no row until every group is validated. A first aggregate error can + hide later errors or drop a group (`INT-042`). The new one-group mode admits + only infallible built-ins over callback-free/data-error-free pipelines; fallible + aggregates retain today's full-drain behavior, including under Limit. +- Window returns rows in input order. Its shared evaluator supports peers, + deterministic row-number ties, lag/lead, row frames, and registered functions. +- ProbeValue can switch to either hash orientation while running. Joins and + binding expressions can replace already-bound cells. Projected Distinct + canonicalizes floats and set elements. + +## 1. Two order properties, tied to a particular comparator + +Add private engine metadata for: + +1. **Lexicographic order**: a sequence of slot/comparator/direction entries and + slots proved constant. Comparators distinguish encoded-id order, supported + scalar value order, and `Value::Ord` group order. Consumers explicitly require + the comparator they use; an id order is never presented as value order. +2. **Contiguous grouping/partition keys**: tuples whose equal values cannot + reappear after a different tuple, tagged explicitly with the consumer's + `Value::Ord` equality. This does + not imply semantic ascending order. Constants and repeated slots can be + removed when matching a requested key. A tuple prefix proves adjacency for + that prefix, not for an arbitrary suffix or subset. + +An Aggregate's complete grouping tuple additionally proves output uniqueness, +which can discharge later Sort tie columns once that entire tuple is matched. +Start conservatively: no general functional-dependency inference, index reversal, +statistics cache, schema/type annotation, or automatic merging of source runs. +Internal test fixtures may construct explicit proofs but production never trusts +a sample of rows. Unknown means use the existing operator. +For certified committed scalar/id slots, prove and test that `JoinKey::group` +classes coincide with `Value::Ord` classes before using the cell key as the +boundary test. Excluded string/set representations supply no such proof. Never +infer coarse-equality adjacency merely from a finer raw-key adjacency. + +## 2. Bind physical choices to the pinned snapshot + +The logical planner records order demand and legal physical alternatives. +Resolve these once for each Stream open, against its own snapshot/TxBound and +function registry. Prepared execution repeats that resolution; it does not reuse +an order claim from an earlier execution or checkpoint. Only the top-level plain +query pipeline is resolved; correlated/not/or bodies receive no order demand, +and `open_rules` keeps its current construction and strategies in this delivery. + +An index-derived guarantee requires a committed key source, no pending or staged +record in the affected scan range, and no derived run. Use existing +`Snapshot::pending_len()` (which includes staged facts) for the zero-record fast +check. Otherwise add a private existence probe over Snapshot's captured pending +index view, short-circuiting at the first in-range record; no full pending clone, +net-assert or TxBound filtering. Assertions/retractions from any time force +fallback for that range; unrelated pending attributes do not disable it. Cover +staged facts through the same view and never use the live store's current length. +Later writes/checkpoints cannot change the choice for that pinned snapshot. +Pending-only/in-memory and derived scans keep the current plan. + +The large-transaction `with_committed` path is eligible: `large_reader` exposes +the working MetaPage's complete four index roots and dictionary after finished +statements (`persistent_facts/large_tx.rs:218`, `:424`); it already incorporates +the prior pending store. Test read-own-writes, rejected statement rollback, +all index alternatives, and no stale proof across successive queries there. + +Reuse existing selective index choices. Add an AVET alternative for a source scan +with constant attribute and unbound value when downstream demand needs value +order/adjacency; its cost must be justified by removing a buffering operator. +Do not replace a more selective entity/exact-value range by a whole attribute +scan. No whole-database scan is introduced to prove an order. +Only the outermost source scan supplies initial properties; optimizer join +order is unchanged. Initially require an unbound value position, no repeated +variable across source positions, and exactly one committed key range. Literal +keyword/ref/float/set matches can read several ranges or encodings, so supply +no order certificate here. `[:E :a ?v]` can retain its existing selective EAVT +range and use an AVET attribute kind proof as a conservative superset; no switch +to a broader range is needed. + +For a single AVET attribute range, use at most a fixed number of raw +tag-prefix existence seeks through the Stream snapshot's own committed-reader +KeySource (the large transaction's working reader where applicable) to prove its values are +all one supported kind. Add an internal KeySource prefix-existence method backed +by a LeafCursor seek and at most one matching raw entry. Do not implement this +with `live_keys(max=1)`: finding no live key could walk arbitrarily many retracted +or excluded historical entries. Extend the internal kind-prefix helper as +necessary; do not hardcode byte tags in the planner. Only integers, booleans and canonical +committed floats initially prove scalar `value_order`. Empty input is trivially +ordered. Any other/multiple kind retains Sort. Over-approximating visibility is +safe: retracted/history keys and keys outside the transaction/valid-time filter +may cause fallback, never false proof. This trades optimization coverage for a +bounded number of tree seeks independently of historical data size. +I/O failure during optional proof reads abandons the optimization; the ordinary +query path remains authoritative for errors it would actually encounter. + +For Window partition adjacency, EAVT/AEVT id prefixes and AVET integer/boolean/keyword/ref +value prefixes can be useful without matching semantic value order. Exclude +float/set/long-string grouping components unless the precise equality-adjacency +claim is proved. A *single* committed float grouping/partition column is safe: +the two zero encodings are consecutive and all committed NaNs are canonical. +Do not certify multi-column float grouping. A mixture of integer and float tags +also matches `Value::Ord` grouping order (integers before floats), while it does +not match `value_order` for Sort. No long-string/set order is inferred. + +## 3. Propagation rules + +These rules refer to the actual implementation, not to an operator's name: + +| Operator | Initial rule | +|---|---| +| Filter, filtering Pseudo, Limit/Offset | Preserve properties on unchanged cells. | +| Bind New/Check, Pseudo Bind, CollectSet New/Check | Preserve properties on old unchanged slots; infer no order for new slots. | +| Bind Replace, CollectSet Replace, Join replacement | Truncate the guaranteed key prefix at the first changed component; clear affected adjacency claims. | +| Entity nested-loop probe | Outer rows are processed in sequence; preserve outer properties on unchanged outer slots. Infer no global order for new inner slots. | +| ProbeValue | Preserve an outer guarantee only if every possible fallback streams the outer in sequence (`build_inner=true`); otherwise clear it. | +| Hash join | Initially clear all guarantees, even if one orientation could preserve a prefix. | +| AntiJoin | Preserve unchanged outer properties; initially do not push a new index demand through a callback-containing body. | +| Union | Initially clear properties, despite its current outer-major implementation. | +| Distinct | Preserve properties on untouched slots; canonicalization in DistinctFind invalidates affected prefixes unless a specific monotonic/equality proof exists. | +| Hash Aggregate | Clear optimization proofs in this delivery; its output uses `Value::Ord`, which alone cannot satisfy Sort's different comparator. | +| Streaming Aggregate | Remap its certified scalar group domain/order to the output group slot, and mark that complete key unique. Convert to `value_order` only for one supported scalar kind, never mixed integers/floats. | +| Window | Preserve properties only on unchanged kept input slots; no inferred order for window results. | +| Sort | Establish its actual full `value_order` key on remapped output slots. | + +Any query subtree containing user callbacks retains its existing physical access +order, Sort, and materialized aggregate/window behavior in this delivery. Disable +every #641 strategy for such a pipeline, even if no source index would change. +Resolve this +by registry implementation descriptors and recursive expression/body traversal, +not by guessed names or text matching. Rule-derived input remains a fallback. +Do not reuse plan::udfs as a complete detector: it sees only top-level unary +UDF clauses. Traverse nested expressions, bind clauses, nested not/or bodies, +aggregate descriptors and WindowFunc::Udf explicitly. +CollectSet also disables access reordering and early-stopping strategies in its +containing pipeline: its `QRY-015` data error must not disappear behind Limit. +Apply this restriction recursively through not/or bodies and rule plans. + +## 4. Sort omission + +No user callback or CollectSet may occur anywhere in the optimized top-level +pipeline or its nested bodies. If either occurs, keep Sort and the original +access path, even under Limit. + +At the final Sort decision, translate every full-order column through `plan.find` +to its producing slot. Remove only proved constants and repeated slots. Omit +Sort only when the remaining complete lexicographic order follows from the input +proof with matching comparator and directions. A stronger input key can satisfy +a prefix of itself; an unrequested leading key cannot be ignored. +Once a complete unique grouping tuple is matched, later columns cannot change +the relative order of any groups and require no further ordering proof. + +At open-time removal of `Step::Sort`, restore `plan.find = Sort.cols`: the logical +planner has already moved the original slots there and remapped `find` to +`0..find.len()`. Simply deleting the step would project the wrong slots. The +resolver must restore that mapping even with a following Limit. Limit/Offset remains above the chosen child. No descending +index scan is added. A missing proof keeps today's full Sort or top-k heap. + +Positive example: a committed integer attribute, `[:find ?v :where [?e :score ?v] +:order-by [?v] :limit 10]`, can read AVET and stop after the required batches. +Counterexample: adding `?e` to `:find` requires UUID tie order and keeps Sort; +DICT entity ids do not satisfy that suffix. Mixed integer/float values also +keep Sort despite looking numeric. + +Omitting Sort allows a cursor to return batches before a later IO/allocation +error, and Limit can avoid errors in unread input. This is ordinary cursor +laziness, not a promise to validate unread storage. User callbacks and CollectSet +disable omission; fallible materialized Aggregate still drains/validates before +returning any row. Test both callback counts and later data-error propagation. + +## 5. One-group Aggregate without hiding data errors + +Use streaming only when there is exactly one grouping column, `:with` is empty, +the query has no window, input is proved increasing by that column under +`Value::Ord`, and every aggregate's descriptor is built-in `count` or +`count-distinct`. These finish without an `INT-041/043/044` data error for arbitrary +argument values (`Agg::finish`); count-distinct retains its existing set growth +and allocation errors. Exclude callbacks and CollectSet throughout the input +pipeline, with or without a Limit. + +Initially certify integer, boolean or canonical committed-float group columns, +and mixed integer/float columns (the tag order matches `Value::Ord`). Do not +stream DICT-ordered entity/keyword groups merely because they are adjacent: +their output would violate the existing semantic group order. Multi-column +grouping, `:with`, sum/sum-distinct/min/max, registered aggregates, and unknown +order keep the existing hash-grouped strategy. Ungrouped behavior is unchanged. +Grouped `avg` is not supported by the current parser/Agg implementation; this +optimization adds no aggregate function. Window `avg` remains supported. + +Retain one group's representative cells and existing `Acc`s, an input batch and +position, and a bounded output batch. Compare boundaries by group equality, +so both zero signs stay in one group. Finish a group, append its result to the +output batch, and release its state before starting the next. Output follows +the same `Value::Ord` key order and float representative choice as today's hash +path. Reuse a one-group finish helper and preserve empty/zero-row rules. Do not +retain all finished results. Limit can stop after its final group, with the +usual batch/lookahead overread. + +Memory is one group's accumulators/distinct members and bounded input/output +batches, independent of completed group count. A single huge count-distinct +group can still grow. IO/allocation errors may follow batches already returned +to a cursor, as its contract allows; execute returns an error on full drain. +No aggregate data error can be hidden: fallible aggregates retain full drain. + +## 6. Partition-at-a-time Window + +Use a partition strategy when all windows have the same nonconstant +`:partition-by` input slot, that slot has group-equality adjacency, and the +affected subtree contains no user callbacks. Windows without a partition, mixed +partition keys or unknown adjacency keep today's full-input strategy. CollectSet +also forces fallback. Initially exclude aggregate queries from this strategy, +keeping the combination of strategy changes bounded in scope. + +Hold the current partition's kept cells and named values, plus a bounded +lookahead batch and row position. On a boundary, invoke the existing `windows` +evaluator for that partition, including each window's own sort/peers/frame, +then return its rows in original input order. Emit/release its result columns +before retaining the next complete partition. Reset rank, row-number, running +aggregates, neighbor reads and row frames at every boundary. An empty partition +is never emitted; partition boundaries crossing batches work the same way. + +No retained full-query position vector, result list or partition index. The +partition operator's memory is O(largest partition), output batches and existing +window state; a surrounding Sort/Distinct/Aggregate can still dominate query +memory. A Limit may stop before later partitions; this is an expected benefit +for built-in window pipelines. UDF windows/predicates/aggregates and unproved +paths retain their current behavior. I/O/allocation errors occur when the cursor +pulls the corresponding input, as for other streaming operators. + +Without a final query `:order-by`, row order is unspecified across physical +plans, as with current optimizer reordering. An AVET alternative can change that +encounter order; Window preserves its chosen input's order, with the same answer +bag and window values. Compare lists for a fixed chosen input order and bags +across index alternatives unless an explicit final order is requested. + +Retain DICT caches for a whole query only for the existing full-input Window +strategy. Partition windows allow normal `IdSpace::end_pull` eviction; ids and +value-page references remain valid under the pinned snapshot. Test per-query +IdSpace peak as well as Window's own meter: a bounded operator with an unbounded +cache is not accepted as bounded query memory. +Streaming Aggregate and partition Window also evict transient DICT lookup caches +at safe internal child-batch boundaries; waiting for Stream::next_rows alone is +insufficient when a single operator pull consumes many input batches. This never +evicts provisional ids or invalidates retained Cell ids/value references. + +## 7. Accounting and lifecycle + +Charge retained batches/lookahead, keys, accumulator/distinct members, result +rows, partition values and window columns through existing Held/Meter paths. +Charge before growth; failed `try_reserve` reports `QRY-012`. Transfers between +buffers are charged once for the actual live ownership. Accounting continues +through errors, partial pulls, rewind, close and drop. The profiler is not yet +public; private test strategy markers/counters distinguish choices for tests and #185. +No production feature/config switch is added. + +## 8. Required correctness tests + +- Forced optimized/fallback strategies over the exact same snapshot: compare + ordered lists (including float bits), unordered bags and error codes. Use a + private/test-hooks switch, not a public API. No removed executor oracle. + Frozen answer digests compare bags and are an additional regression guard, + never the ordered oracle; do not re-bless tests/answers for this optimization. +- Sort positive and fallback examples, repeated projected columns/constants, + complete tie suffixes, descending keys, mixed numeric kinds, NaNs/zeros, + scrambled DICT allocation, long strings sharing prefixes, sets and nil. +- Proofs operate on full ranges, not first-row samples. Put a disqualifying kind + late in an attribute, in historical data, or outside current valid time. +- Reopen prepared queries before/after pending writes and checkpoint; in-range + mixed/pending/staged and rule-derived paths use fallback; unrelated pending + attributes and large-transaction working snapshots exercise eligible paths. Open cursor + keeps its result while another writer checkpoints/reuses pages. +- Join preservation and invalidation, particularly replacements and a mid-run + ProbeValue fallback that builds the outer. Canonicalizing Distinct and nested + not/or bodies cannot accidentally resurrect a discarded proof. +- Streaming groups spanning batches, nil/empty groups and zero row, counts over + arbitrary argument kinds, signed-zero representatives and distinct release. + Fallible aggregates, `:with` and multi-key grouping retain materialized behavior: + a semantic earlier error encountered last, dropped-group aggregate precedence, + upstream failures and invalid groups after a limited prefix retain their errors. + UDF callback sequences and CollectSet failures remain unchanged. +- Window partition boundaries at and across batches, one huge/many small + partitions, all built-ins including lag/lead and bounded row frames, peers, + multiple compatible windows, incompatible/unpartitioned fallbacks, input-order + preservation and Limit/Offset. Include id-heavy retained rows. +- Every holder and IdSpace releases memory on success/error/close/drop/rewind. + Enforce small-worker-stack, binary-size and portable-target gates. + +At group/partition boundaries validate monotonicity with the physical/semantic +comparator carried by the certificate; a violation fails with existing INT-032, +never falls back after emitting rows. This is a defensive check, not permission +to weaken planner proofs. Include injected out-of-order operator fixtures. + +## 8.1 Acceptance gates + +- On the positive ordered scalar fixture, scan rows read are at most + `offset + limit + BATCH_ROWS`; zero limit reads no facts. Streaming aggregate + group-limit reads at most all rows of the requested groups plus one input + batch, with maximum fixture group size stated. No proof reads occur with no + applicable consumer demand, measured by counters rather than timings. +- On fixed-size partitions/groups at 100K/1M/10M committed facts, streaming + Window/Aggregate and transient IdSpace peak must stay within the 100K peak plus + two maximally-sized charged input batches. Compute that allowance using the + test fixture's cell/row byte helpers. No finished-results list is allowed. + Distinct members within a growing single group and a growing single Window + partition are explicitly linear controls, not bounded-memory claims. +- In query-only subprocess measurements on prebuilt fixtures, peak RSS at 10M + must be within the 100K baseline plus max(16 MiB, 15%). Investigate any failure + using engine holder/IdSpace peaks; do not count fixture-building memory as + query memory. Existing buffering paths need no claim of flat memory. +- For the bounded positive limit fixtures, 10M median query time is at most + twice 100K after warmup, with at least five idle-machine A/B samples. Existing + #379 point-query medians must not regress by more than 5%; investigate noise + before trusting either result. Include proof-startup cost as a separate case. +- Required tests/coverage/portability checks pass, the 1,230 KiB release binary + cap remains unchanged, and frozen answers are unchanged. Run an optimized + committed-memory-backend fixture on WASI and a corresponding browser fixture + where its runner is available, rather than exercising only in-memory fallback. + +## 9. Measurement and delivery + +Three dependent PRs to `v3`: (1) order metadata, conservative scan choices and +Sort omission; (2) streaming Aggregate; (3) partition Window and cache lifetime. +Keep #641 open until all three land; do not close #473. No release/tag bump. +Specs/plans and the exact fallback scope accompany PR 1. +Unique-group Sort omission lands with streaming Aggregate in PR 2; PR 1 does +not infer a Sort-compatible order from the existing hash Aggregate. + +Run all Cargo tests, clippy, coverage and measurements on the designated idle +bench machine first. Non-timing checks use the whole machine; timing runs use +the established NUMA A/B protocol with immutable base/PR revisions and at least +five samples after warmup. Keep private machine details out of committed docs. +Record command, revision, workload, engine peak, RSS, median and range. + +At 100K, 1M and 10M committed facts: ordered value-only limit/offset versus Sort +fallback (scan counters establish early stopping); high-cardinality grouped +count/count-distinct (one active group, bounded output batches, and +materialized sum-distinct as a fallback control); fixed-size Window partitions with total rows growing +(Window/IdSpace peak bounded by partition size); one growing partition (document +linear bound). Include mixed/pending, tie-suffix and type fallbacks as controls. +Run the relevant existing envelope and #379 point-query guards, avoiding timing +claims from the laptop. Review proof-seek overhead on small/selective queries; +ordinary queries without an applicable demand should perform no proof reads. + +Record benchmark IDs/filter coverage for #776; adding a benchmark is not evidence +that the nightly filter runs it. Reuse existing CI routes where sufficient; +coordinate shared workflow changes on both release branches if needed. + +Synchronize affected architecture/status/perf documentation across CLAUDE.md, +ROADMAP.md, README.md, CHANGELOG.md and docs/TEST_COVERAGE.md. Update the docs site +architecture description in its own PR with `@since v3.0.0` if release targeting +remains as currently assigned; cross-check the reference/comparison/use-cases +pages and change only claims affected by this work. No new syntax/error entries. +Claude reviews each code slice and the combined evidence before PR creation. +Delete task-created remote scratch after runs unless explicitly reused, report +anything retained and why; do not remove preexisting shared caches or fixtures. diff --git a/examples/perf_envelope.rs b/examples/perf_envelope.rs index ff4c4427a2..3b168722a0 100644 --- a/examples/perf_envelope.rs +++ b/examples/perf_envelope.rs @@ -672,6 +672,13 @@ fn shapes(e: usize, tx_half: u64, tx_half_time: &str, hot_tx_half: u64) -> Vec + +use minigraf::Minigraf; +use std::path::Path; + +fn main() { + let args: Vec<_> = std::env::args().collect(); + let path = Path::new(&args[1]); + let depth: usize = args[2].parse().unwrap(); + assert!(depth > 0 && !path.exists(), "use a fresh fixture path"); + let db = Minigraf::open(path).unwrap(); + for i in 0..2000 { + db.execute(&format!("(transact [[:f/{i} :x {i}]])")) + .unwrap(); + } + db.execute("(transact [[:e/hot :other \"o\"]])").unwrap(); + db.execute("(transact {:valid-from \"2020-01-01T00:00:00Z\"} [[:e/hot :hash \"h0\"]])") + .unwrap(); + assert_eq!(db.current_tx_count(), 2002, "the as-of fixture boundary"); + for i in 1..depth { + db.execute(&format!("(retract [[:e/hot :hash \"h{}\"]])", i - 1)) + .unwrap(); + db.execute(&format!( + "(transact {{:valid-from \"2020-01-01T00:00:00Z\"}} [[:e/hot :hash \"h{i}\"]])" + )) + .unwrap(); + } + db.checkpoint().unwrap(); + drop(db); + println!( + "{{\"depth\":{depth},\"file_bytes\":{}}}", + std::fs::metadata(path).unwrap().len() + ); +} diff --git a/scripts/input_order_probe.rs b/scripts/input_order_probe.rs new file mode 100644 index 0000000000..f2990a56f1 --- /dev/null +++ b/scripts/input_order_probe.rs @@ -0,0 +1,50 @@ +//! Common query probe compiled against both comparison libraries for #641. +//! Usage: probe '' [zeros] +//! Build fixtures separately with perf_envelope __build. Open/thread creation +//! are excluded from timings; process RSS is query-only. Worker stack: 256 KiB. + +use minigraf::{OpenOptions, Value}; +use std::time::{Duration, Instant}; + +fn rss_kb() -> u64 { + std::fs::read_to_string("/proc/self/status") + .ok() + .and_then(|text| { + text.lines() + .find(|l| l.starts_with("VmHWM:")) + .and_then(|l| l.split_whitespace().nth(1)) + .and_then(|n| n.parse().ok()) + }) + .unwrap_or(0) +} + +fn main() { + let args: Vec<_> = std::env::args().collect(); + std::thread::Builder::new().stack_size(256 * 1024).spawn(move || { + let db = OpenOptions::new().read_only(true).path(&args[1]).open().unwrap(); + let expected: usize = args[3].parse().unwrap(); + let check_zeros = args.get(4).is_some_and(|s| s == "zeros"); + let drain = || { + let mut cursor = db.query(&args[2]).unwrap(); + let mut rows = 0; + while let Some(batch) = cursor.next_batch(1000).unwrap() { + rows += batch.len(); + if check_zeros { + assert!(batch.rows().iter().all(|r| r == &[Value::Integer(0)]), "expected ordered age zeros"); + } + } + assert_eq!(rows, expected, "expected row count"); + }; + for _ in 0..3 { drain(); } + let start = Instant::now(); + let mut times = Vec::new(); + while times.len() < 20_000 && (times.len() < 5 || start.elapsed() < Duration::from_secs(1)) { + let t = Instant::now(); + drain(); + times.push(t.elapsed().as_secs_f64() * 1_000_000.0); + } + times.sort_by(f64::total_cmp); + println!("{{\"runs\":{},\"median_us\":{:.3},\"min_us\":{:.3},\"max_us\":{:.3},\"rows\":{},\"peak_rss_kb\":{}}}", + times.len(), times[times.len() / 2], times[0], times[times.len()-1], expected, rss_kb()); + }).unwrap().join().unwrap(); +} diff --git a/src/graph/storage.rs b/src/graph/storage.rs index 87790470b7..2ca3407cc1 100644 --- a/src/graph/storage.rs +++ b/src/graph/storage.rs @@ -302,6 +302,34 @@ impl Snapshot { .saturating_add(self.staged.as_ref().map_or(0, |s| s.facts.len())) } + /// Any pending/staged record of this attribute (and optional entity) in + /// the captured snapshot, even a retraction or excluded version (#641). + pub(crate) fn has_pending(&self, attribute: &str, entity: Option<&EntityId>) -> Result { + use crate::storage::index::AevtKey; + if self.pending_len() == 0 { + return Ok(false); + } + let pending = self.read_pending()?; + let mut start = AevtKey::attribute_start(attribute); + if let Some(e) = entity { + start.entity = *e; + } + // Existence needs no merge: stop each index at the source boundary + // before filtering records appended after the captured prefix. + let has = |store: &PendingStore, len: usize| { + store + .indexes + .aevt + .range(&start..) + .take_while(|(k, _)| { + k.attribute == attribute && entity.is_none_or(|e| k.entity == *e) + }) + .any(|(_, &pos)| pos < len) + }; + Ok(has(&pending, self.pending_len) + || self.staged.as_ref().is_some_and(|s| has(s, s.facts.len()))) + } + /// This snapshot with `facts` staged after its pending ones (#550 spec /// §7), its `now` raised to the newest of their `tx_id`s. pub(crate) fn with_staged(mut self, facts: Vec) -> Self { diff --git a/src/lib.rs b/src/lib.rs index 59f1e45fa0..ae678daa68 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -140,6 +140,18 @@ pub fn __reorder(on: bool) -> ReorderGuard { query::datalog::optimizer::set_reorder(on) } +#[cfg(feature = "test-hooks")] +#[doc(hidden)] +pub use query::engine::InputOrderGuard; + +/// Enables input-order optimizations on this thread for differential tests. +/// The previous setting is restored on drop; test-hooks builds only. +#[cfg(feature = "test-hooks")] +#[doc(hidden)] +pub fn __input_order(on: bool) -> InputOrderGuard { + query::engine::set_input_order(on) +} + // Large-transaction tests (#550): statements read and written in small chunks. #[cfg(feature = "test-hooks")] #[doc(hidden)] diff --git a/src/query/datalog/aggregate.rs b/src/query/datalog/aggregate.rs index 8e5c6619fb..367776178a 100644 --- a/src/query/datalog/aggregate.rs +++ b/src/query/datalog/aggregate.rs @@ -55,8 +55,10 @@ pub(crate) fn value_order(a: &Value, b: &Value) -> Ordering { (Value::Set(x), Value::Set(y)) => { let mut xs: Vec<&Value> = x.iter().collect(); let mut ys: Vec<&Value> = y.iter().collect(); - xs.sort_by(|p, q| value_order(p, q)); - ys.sort_by(|p, q| value_order(p, q)); + // Share one comparator type, so both sides share the sort code. + let cmp = |p: &&Value, q: &&Value| value_order(p, q); + xs.sort_by(cmp); + ys.sort_by(cmp); xs.iter() .zip(&ys) .map(|(p, q)| value_order(p, q)) @@ -845,15 +847,13 @@ pub(crate) fn windows( }) .then(a.cmp(&b)) }; - if let Some(partition_col) = part { - keyed.sort_unstable_by(|&a, &b| { - read(a, Some(partition_col)) - .cmp(read(b, Some(partition_col))) - .then_with(|| row_cmp(a, b)) - }); - } else { - keyed.sort_unstable_by(|&a, &b| row_cmp(a, b)); - } + // One sort implementation for partitioned and unpartitioned windows. + keyed.sort_unstable_by(|&a, &b| { + part.map_or(Ordering::Equal, |col| { + read(a, Some(col)).cmp(read(b, Some(col))) + }) + .then_with(|| row_cmp(a, b)) + }); // Charge slots before allocating, then payloads as each slot is // filled. The outer vector's entry stays charged until it is dropped. diff --git a/src/query/engine/mod.rs b/src/query/engine/mod.rs index 4d895d862e..c85080d7c6 100644 --- a/src/query/engine/mod.rs +++ b/src/query/engine/mod.rs @@ -14,6 +14,9 @@ mod ids; mod join; mod limit; mod meter; +mod order; +#[cfg(all(test, not(target_arch = "wasm32")))] +mod order_tests; mod plan; mod project; mod recursive; @@ -36,6 +39,10 @@ use anyhow::Result; use batch::Batch; use ids::IdSpace; pub(crate) use meter::Meter; +#[cfg(feature = "test-hooks")] +pub use order::InputOrderGuard; +#[cfg(feature = "test-hooks")] +pub(crate) use order::set_enabled as set_input_order; pub(crate) use plan::{Plan, plan, plan_rules, udfs}; pub(crate) use recursive::Limits; use std::sync::Arc; @@ -162,13 +169,14 @@ fn keys(snapshot: &Snapshot) -> Result> { /// Open `plan` over `snapshot`, holding at most `memory_limit` bytes. pub(crate) fn open( snapshot: Snapshot, - plan: Plan, + mut plan: Plan, functions: Arc, memory_limit: usize, ) -> Result { let keys = keys(&snapshot)?; let meter = Meter::new(memory_limit); let bound = resolve(&snapshot, plan.as_of, &meter)?; + order::resolve(&snapshot, keys, &functions, &mut plan); let ids = IdSpace::new(keys, &meter); Ok(stream(snapshot, ids, plan, functions, None, meter, bound)) } diff --git a/src/query/engine/order.rs b/src/query/engine/order.rs new file mode 100644 index 0000000000..b0d0faa053 --- /dev/null +++ b/src/query/engine/order.rs @@ -0,0 +1,330 @@ +//! Snapshot-bound input-order proofs (#641). DICT order is never UUID/text +//! order. Unknown order retains the original index choice and buffering. + +use super::plan::{Body, JoinKind, Meta, Out, Plan, ScanSpec, Source, Step, Term, Vars}; +use crate::graph::storage::Snapshot; +use crate::query::datalog::functions::{AggImpl, FunctionRegistry}; +use crate::query::datalog::types::{Expr, FindSpec, UnaryOp, WindowFunc}; +use crate::storage::KeySource; +use crate::storage::keys::{self, Index, ValueKind}; +use anyhow::Result; + +#[cfg(any(test, feature = "test-hooks"))] +thread_local! { + static ENABLED: std::cell::Cell = const { std::cell::Cell::new(true) }; +} + +#[cfg(test)] +thread_local! { + /// Public write-transaction reads return rows rather than a cursor; tests + /// use this marker to verify which root strategy they actually opened. + pub(super) static OPTIMIZATIONS: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + +fn enabled() -> bool { + #[cfg(any(test, feature = "test-hooks"))] + return ENABLED.with(std::cell::Cell::get); + #[cfg(not(any(test, feature = "test-hooks")))] + true +} + +/// Force the original strategy for differential tests only. +#[cfg(any(test, feature = "test-hooks"))] +pub(crate) fn set_enabled(on: bool) -> InputOrderGuard { + InputOrderGuard(ENABLED.with(|v| v.replace(on))) +} + +#[cfg(any(test, feature = "test-hooks"))] +#[must_use = "input-order optimization is restored when the guard drops"] +/// Restores this thread's previous input-order test setting on drop. +pub struct InputOrderGuard(bool); + +#[cfg(any(test, feature = "test-hooks"))] +impl Drop for InputOrderGuard { + fn drop(&mut self) { + ENABLED.with(|v| v.set(self.0)); + } +} + +/// Only the leading scalar slot has a semantic comparator. The following +/// entity key is DICT order and cannot prove any Sort column in this slice. +struct Ordering { + slot: Option, + kind: ValueKind, + constants: Vec, +} + +impl Ordering { + fn source(spec: &ScanSpec, kind: ValueKind) -> Self { + Ordering { + slot: match spec.v { + Term::Bind(s) => Some(s), + _ => None, + }, + kind, + constants: spec + .meta + .iter() + .filter_map(|&(m, s)| (m == Meta::ValidAt).then_some(s)) + .collect(), + } + } + + fn invalidate(&mut self, slot: usize) { + if self.slot == Some(slot) { + self.slot = None; + } + self.constants.retain(|&s| s != slot); + } + + fn constant(&self, expr: &Expr, vars: &Vars) -> bool { + match expr { + Expr::Lit(_) => true, + Expr::Var(v) => vars + .iter() + .any(|(name, s)| name == v && self.constants.contains(s)), + Expr::BinOp(_, a, b) => self.constant(a, vars) && self.constant(b, vars), + Expr::UnaryOp(_, a) => self.constant(a, vars), + Expr::Slot(_) | Expr::CollectSet { .. } => false, + } + } + + fn through(mut self, steps: &[Step]) -> Option { + for step in steps { + match step { + Step::Filter(..) | Step::Anti(_) | Step::Distinct(_) | Step::Limit { .. } => {} + Step::Bind(expr, vars, slot, mode) => { + let constant = self.constant(expr, vars); + if *mode == Out::Replace { + self.invalidate(*slot); + } + if *mode != Out::Check && constant { + self.constants.push(*slot); + } + } + Step::Pseudo { col, value } => { + if let Term::Bind(slot) = value + && self.constants.contains(col) + { + self.constants.push(*slot); + } + } + Step::Join(join) => { + if !matches!( + join.kind, + JoinKind::Probe(_) + | JoinKind::ProbeValue { + build_inner: true, + .. + } + ) { + return None; + } + for &(_, slot) in &join.replace { + self.invalidate(slot); + } + } + Step::DistinctFind(slots) => { + if self.kind == ValueKind::Float + && let Some(slot) = self.slot.filter(|s| slots.contains(s)) + { + self.invalidate(slot); + } + } + Step::Union(_) + | Step::CollectSet(_) + | Step::Aggregate { .. } + | Step::Window { .. } + | Step::Sort { .. } => return None, + } + } + Some(self) + } + + fn satisfies(&self, cols: &[usize], order: &[(usize, bool)]) -> bool { + let mut matched = false; + for &(column, desc) in order { + let Some(&slot) = cols.get(column) else { + return false; + }; + if self.constants.contains(&slot) || (matched && self.slot == Some(slot)) { + continue; + } + if matched + || desc + || self.slot != Some(slot) + || !matches!( + self.kind, + ValueKind::Integer | ValueKind::Float | ValueKind::Boolean + ) + { + return false; + } + matched = true; + } + matched + } +} + +fn safe_expr(expr: &Expr) -> bool { + match expr { + Expr::UnaryOp(UnaryOp::Udf(_), _) | Expr::CollectSet { .. } => false, + Expr::UnaryOp(_, a) => safe_expr(a), + Expr::BinOp(_, a, b) => safe_expr(a) && safe_expr(b), + Expr::Lit(_) | Expr::Var(_) | Expr::Slot(_) => true, + } +} + +fn safe_find(find: &[FindSpec], functions: &FunctionRegistry) -> bool { + find.iter().all(|f| match f { + FindSpec::Variable(_) => true, + FindSpec::Aggregate { func, .. } => functions + .get(func) + .is_some_and(|d| matches!(d.impl_, AggImpl::Builtin(_))), + FindSpec::Window(w) => !matches!(w.func, WindowFunc::Udf(_)), + }) +} + +fn safe_body(body: &Body, functions: &FunctionRegistry) -> bool { + match body { + Body::Correlated { plan, .. } | Body::Hashed { plan, .. } => { + safe_steps(&plan.steps, functions) + } + } +} + +fn safe_steps(steps: &[Step], functions: &FunctionRegistry) -> bool { + steps.iter().all(|s| match s { + Step::Filter(expr, _) | Step::Bind(expr, ..) => safe_expr(expr), + Step::CollectSet(_) => false, + Step::Anti(body) => safe_body(body, functions), + Step::Union(branches) => branches.iter().all(|b| safe_body(&b.body, functions)), + Step::Aggregate { aggs, .. } => aggs.iter().all(|(func, _)| { + functions + .get(func) + .is_some_and(|d| matches!(d.impl_, AggImpl::Builtin(_))) + }), + Step::Window { find, .. } => safe_find(find, functions), + Step::Pseudo { .. } + | Step::Join(_) + | Step::Distinct(_) + | Step::DistinctFind(_) + | Step::Sort { .. } + | Step::Limit { .. } => true, + }) +} + +/// At most eight raw seeks through the exact reader the Stream will scan. +fn scalar_kind(keys: &dyn KeySource, attribute: u32) -> Result> { + let mut found = None; + for kind in ValueKind::ALL { + if keys.any_key(Index::Avet, &keys::attribute_kind_prefix(attribute, kind))? { + if found.is_some() { + return Ok(None); + } + found = Some(kind); + } + } + Ok(found.filter(|k| { + matches!( + k, + ValueKind::Integer | ValueKind::Float | ValueKind::Boolean + ) + })) +} + +fn candidate( + snapshot: &Snapshot, + keys: &dyn KeySource, + plan: &Plan, +) -> Result> { + let Source::Scan(spec) = &plan.source else { + return Ok(None); + }; + let (Term::Const(attribute), Term::Bind(_)) = (&spec.a, &spec.v) else { + return Ok(None); + }; + if spec.derived.is_some() || spec.never() || matches!(spec.e, Term::Eq(_)) { + return Ok(None); + } + let Some(at) = plan + .steps + .iter() + .position(|s| matches!(s, Step::Sort { .. })) + else { + return Ok(None); + }; + let Some(Step::Sort { cols, order, keep }) = plan.steps.get(at) else { + return Ok(None); + }; + if *keep == Some(0) { + return Ok(None); + } + let Some(before) = plan.steps.get(..at) else { + return Ok(None); + }; + // Reject impossible full orders before any speculative storage reads. + if !Ordering::source(spec, ValueKind::Integer) + .through(before) + .is_some_and(|p| p.satisfies(cols, order)) + { + return Ok(None); + } + let entity = match &spec.e { + Term::Const(e) => Some(e), + _ => None, + }; + if snapshot.has_pending(attribute, entity)? { + return Ok(None); + } + let Some(a) = keys.iid_of(attribute)? else { + return Ok(None); + }; + let Some(kind) = scalar_kind(keys, a)? else { + return Ok(None); + }; + if !Ordering::source(spec, kind) + .through(before) + .is_some_and(|p| p.satisfies(cols, order)) + { + return Ok(None); + } + Ok(Some((at, !matches!(spec.e, Term::Const(_))))) +} + +/// Only a plain query's root pipeline is resolved; bodies and rules keep their +/// original strategies. Failed optional proof reads retain the original plan. +pub(super) fn resolve( + snapshot: &Snapshot, + keys: Option<&dyn KeySource>, + functions: &FunctionRegistry, + plan: &mut Plan, +) { + // With an offset, Sort.keep can be nonzero even though Limit pulls no row. + if !enabled() + || matches!(plan.steps.last(), Some(Step::Limit { limit: Some(0), .. })) + || !safe_steps(&plan.steps, functions) + { + return; + } + let Some(keys) = keys else { + return; + }; + let Ok(Some((at, avet))) = candidate(snapshot, keys, plan) else { + return; + }; + if !matches!(plan.steps.get(at), Some(Step::Sort { .. })) { + return; + } + if let Step::Sort { cols, .. } = plan.steps.remove(at) { + plan.find = cols; + } + if avet && let Source::Scan(spec) = &mut plan.source { + spec.index = Some(Index::Avet); + } + #[cfg(test)] + OPTIMIZATIONS.with(|n| n.set(n.get() + 1)); +} + +#[cfg(test)] +mod tests; diff --git a/src/query/engine/order/tests.rs b/src/query/engine/order/tests.rs new file mode 100644 index 0000000000..fbc0220f8b --- /dev/null +++ b/src/query/engine/order/tests.rs @@ -0,0 +1,280 @@ +use super::*; +use crate::Value; +use crate::query::engine::plan::{CollectSpec, JoinSpec, Valid}; + +fn spec(wildcard: bool) -> ScanSpec { + ScanSpec { + index: None, + e: if wildcard { Term::Any } else { Term::Bind(0) }, + a: Term::Const(":score".into()), + v: Term::Bind(1), + meta: vec![(Meta::ValidAt, 2)], + valid: Valid::Any, + width: 3, + derived: None, + } +} + +fn proof(kind: ValueKind) -> Ordering { + Ordering::source(&spec(false), kind) +} +fn sorted(proof: &Ordering) -> bool { + proof.satisfies(&[1], &[(0, false)]) +} +fn join(kind: JoinKind, replace: Vec<(usize, usize)>) -> Step { + Step::Join(JoinSpec { + inner: spec(false), + kind, + keys: vec![], + new: vec![], + replace, + outer_width: 3, + }) +} + +#[test] +fn full_order_requires_matching_prefix_direction_and_semantic_comparator() { + let order = proof(ValueKind::Integer); + assert!(sorted(&order)); + assert!( + order.satisfies(&[1, 1], &[(0, false), (1, false)]), + "same slot twice" + ); + assert!( + order.satisfies(&[2, 1], &[(0, true), (1, false)]), + "a leading constant can descend" + ); + assert!(!order.satisfies(&[1], &[(0, true)]), "no descending range"); + assert!( + !order.satisfies(&[1, 0], &[(0, false), (1, false)]), + "DICT order is not UUID order" + ); + let wildcard = Ordering::source(&spec(true), ValueKind::Integer); + assert!(sorted(&wildcard)); + assert!(!wildcard.satisfies(&[1, 0], &[(0, false), (1, false)])); + assert!( + !order.satisfies(&[], &[(0, false)]), + "malformed mapping is no proof" + ); +} + +#[test] +fn only_probe_fallbacks_that_stream_the_outer_keep_order() { + for kind in [ + JoinKind::Probe(0), + JoinKind::ProbeValue { + key: 0, + build_inner: true, + }, + ] { + assert!(sorted( + &proof(ValueKind::Integer) + .through(&[join(kind, vec![])]) + .unwrap() + )); + } + for kind in [ + JoinKind::Hash { build_inner: true }, + JoinKind::Hash { build_inner: false }, + JoinKind::ProbeValue { + key: 0, + build_inner: false, + }, + ] { + assert!( + proof(ValueKind::Integer) + .through(&[join(kind, vec![])]) + .is_none() + ); + } + let suffix = proof(ValueKind::Integer) + .through(&[join(JoinKind::Probe(0), vec![(1, 0)])]) + .unwrap(); + assert!( + sorted(&suffix), + "replacing the later entity cuts only that suffix" + ); + assert_eq!(suffix.slot, Some(1)); + let first = proof(ValueKind::Integer) + .through(&[join(JoinKind::Probe(0), vec![(0, 1)])]) + .unwrap(); + assert!(!sorted(&first), "replacing the value removes its proof"); +} + +#[test] +fn expression_modes_and_pseudo_bindings_handle_constants_and_replacements() { + let lit = Expr::Lit(Value::Integer(42)); + let new = proof(ValueKind::Integer) + .through(&[Step::Bind(lit.clone(), vec![], 3, Out::New)]) + .unwrap(); + assert!(new.satisfies(&[3, 1], &[(0, true), (1, false)])); + let checked = proof(ValueKind::Integer) + .through(&[Step::Bind(lit.clone(), vec![], 1, Out::Check)]) + .unwrap(); + assert!(sorted(&checked)); + assert!( + !checked.constants.contains(&1), + "join-equal checks do not prove an identical constant" + ); + let replaced = proof(ValueKind::Integer) + .through(&[Step::Bind(lit, vec![], 1, Out::Replace)]) + .unwrap(); + assert!(replaced.constants.contains(&1)); + assert!(replaced.slot.is_none()); + let replaced = proof(ValueKind::Integer) + .through(&[Step::Bind( + Expr::Var("?e".into()), + vec![("?e".into(), 0)], + 1, + Out::Replace, + )]) + .unwrap(); + assert!(!sorted(&replaced)); + assert!(!replaced.constants.contains(&1)); + let pseudo = proof(ValueKind::Integer) + .through(&[Step::Pseudo { + col: 2, + value: Term::Bind(3), + }]) + .unwrap(); + assert!( + pseudo.satisfies(&[3, 1], &[(0, true), (1, false)]), + "valid-at is constant, including nil" + ); +} + +#[test] +fn canonicalization_and_buffering_operators_cannot_supply_false_certificates() { + let int = proof(ValueKind::Integer) + .through(&[Step::DistinctFind(vec![1])]) + .unwrap(); + assert!(sorted(&int)); + let float = proof(ValueKind::Float) + .through(&[Step::DistinctFind(vec![1])]) + .unwrap(); + assert!(!sorted(&float)); + for step in [ + Step::Union(vec![]), + Step::CollectSet(CollectSpec { + entity: 0, + attribute: ":a".into(), + inner: spec(false), + out: 3, + mode: Out::New, + }), + Step::Aggregate { + groups: vec![1], + aggs: vec![("count".into(), 0)], + zero_row: false, + }, + Step::Window { + find: vec![], + named: vec![], + keep: vec![1], + }, + Step::Sort { + cols: vec![1], + order: vec![(0, false)], + keep: None, + }, + ] { + assert!( + proof(ValueKind::Integer).through(&[step]).is_none(), + "unsupported step clears proof" + ); + } +} + +/// No file or native-only API: WASI/browser tests exercise a real committed +/// reader and the optimized projection, not just the pending-store fallback. +#[cfg_attr( + all(target_arch = "wasm32", not(target_os = "wasi")), + wasm_bindgen_test::wasm_bindgen_test +)] +#[cfg_attr(not(all(target_arch = "wasm32", not(target_os = "wasi"))), test)] +fn committed_memory_backend_orders_all_supported_scalar_edge_cases() { + use crate::query::datalog::{ + aggregate::value_order, parser::parse_datalog_command, types::DatalogCommand, + }; + use crate::storage::{backend::memory::MemoryBackend, persistent_facts::PersistentFactStorage}; + for values in [ + vec![ + Value::Integer(i64::MAX), + Value::Integer(0), + Value::Integer(i64::MIN), + Value::Integer(-1), + ], + vec![ + Value::Boolean(true), + Value::Boolean(false), + Value::Boolean(true), + ], + vec![ + Value::Float(f64::NAN), + Value::Float(-f64::NAN), + Value::Float(f64::INFINITY), + Value::Float(f64::NEG_INFINITY), + Value::Float(-0.0), + Value::Float(0.0), + Value::Float(1.5), + ], + ] { + let mut pfs = PersistentFactStorage::new(MemoryBackend::new(), 32).unwrap(); + let facts = values + .iter() + .enumerate() + .map(|(i, v)| { + ( + uuid::Uuid::from_u128(i as u128 + 1), + ":score".into(), + v.clone(), + ) + }) + .collect(); + pfs.storage().transact(facts, None).unwrap(); + pfs.mark_dirty(); + pfs.save().unwrap(); + assert_eq!( + pfs.storage().snapshot().unwrap().pending_len(), + 0, + "committed fixture" + ); + let DatalogCommand::Query(q) = + parse_datalog_command("(query [:find ?v :where [?e :score ?v] :order-by [?v]])") + .unwrap() + else { + panic!("query"); + }; + let mut stream = crate::query::engine::open( + pfs.storage().snapshot().unwrap(), + crate::query::engine::plan(&q).unwrap(), + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert!( + stream.counters().iter().all(|c| c.op != "Sort"), + "the portable path is optimized" + ); + let mut actual = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + actual.extend(batch); + } + let mut expected = values + .iter() + .map(|v| match v { + Value::Float(f) if f.is_nan() => Value::Float(f64::NAN), + v => v.clone(), + }) + .collect::>(); + expected.sort_by(value_order); + assert_eq!(actual.len(), expected.len()); + for (row, expected) in actual.iter().zip(&expected) { + match (row.first(), expected) { + (Some(Value::Float(a)), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits()), + (Some(a), b) => assert!(a == b, "identical scalar value"), + _ => panic!("one scalar column"), + } + } + } +} diff --git a/src/query/engine/order_tests.rs b/src/query/engine/order_tests.rs new file mode 100644 index 0000000000..0c65135bb2 --- /dev/null +++ b/src/query/engine/order_tests.rs @@ -0,0 +1,856 @@ +//! Ordered input optimizations compared with the original materialized path. + +use super::{BATCH_ROWS, Counters}; +use crate::{Minigraf, Value}; + +fn fixture(n: usize) -> (tempfile::TempDir, Minigraf) { + let dir = tempfile::tempdir().unwrap(); + let db = Minigraf::open(dir.path().join("ordered.graph")).unwrap(); + let facts: String = (0..n) + .map(|i| format!("[:e{i} :score {}]", (i * 337) % n)) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + (dir, db) +} + +fn collect(db: &Minigraf, query: &str) -> (Vec>, Vec) { + let mut cursor = db.query(&format!("(query {query})")).unwrap(); + // Cursor discards its stream at EOF; retain the stream itself so its + // closed-operator counters can still establish how much input was read. + let stream = cursor.stream_mut().unwrap(); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + (rows, stream.counters()) +} + +#[test] +fn scalar_order_omits_sort_and_restores_projection_slots() { + let (_dir, db) = fixture(4096); + let (rows, counters) = collect( + &db, + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]", + ); + let expected: Vec<_> = (0..10).map(|n| vec![Value::Integer(n)]).collect(); + assert!(rows == expected, "the original value slot is projected"); + assert!( + counters.iter().all(|c| c.op != "Sort"), + "a proved complete order omits Sort" + ); +} + +#[test] +fn ordered_scan_limit_offset_reads_only_a_prefix() { + let (_dir, db) = fixture(4096); + let (rows, counters) = collect( + &db, + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10 :offset 7]", + ); + let expected: Vec<_> = (7..17).map(|n| vec![Value::Integer(n)]).collect(); + assert!(rows == expected, "offset applies in semantic value order"); + let scan = counters.iter().find(|c| c.op == "Scan").unwrap(); + assert!( + scan.rows_in <= (17 + BATCH_ROWS) as u64, + "ordered Limit stops before reading all input" + ); +} + +#[test] +fn uuid_tie_suffix_and_descending_order_keep_sort() { + let (_dir, db) = fixture(32); + for query in [ + "[:find ?e ?v :where [?e :score ?v] :order-by [?v] :limit 10]", + "[:find ?v :where [?e :score ?v] :order-by [?v :desc] :limit 10]", + ] { + let (_, counters) = collect(&db, query); + assert!(counters.iter().any(|c| c.op == "Sort"), "Sort is retained"); + } +} + +fn has_sort(counters: &[Counters]) -> bool { + counters.iter().any(|c| c.op == "Sort") +} + +fn same_rows(a: &[Vec], b: &[Vec]) -> bool { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| match (a, b) { + (Value::Float(a), Value::Float(b)) => a.to_bits() == b.to_bits(), + _ => a == b, + }) + }) +} + +#[test] +fn forced_fallback_restores_sort_and_gives_the_same_ordered_list() { + let (_dir, db) = fixture(128); + let q = "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10 :offset 7]"; + let (expected, fallback) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, optimized) = collect(&db, q); + assert!(has_sort(&fallback), "the switch forces the original Sort"); + assert!( + !has_sort(&optimized), + "dropping the guard restores optimization" + ); + assert!(same_rows(&actual, &expected), "identical ordered rows"); +} + +#[test] +fn distinct_preserves_integer_order_but_float_canonicalization_keeps_sort() { + let (_dir, db) = fixture(16); + let q = "[:find ?v :where [?e :score ?v] :distinct :order-by [?v] :limit 3]"; + assert!( + !has_sort(&collect(&db, q).1), + "integer distinct keeps an ordered subsequence" + ); + db.execute("(transact [[:a :f -0.0] [:b :f 0.0] [:c :f 1.0]])") + .unwrap(); + db.checkpoint().unwrap(); + let q = "[:find ?v :where [?e :f ?v] :distinct :order-by [?v]]"; + let (actual, counters) = collect(&db, q); + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + assert!( + has_sort(&counters), + "canonicalization invalidates the float certificate" + ); + assert!( + same_rows(&actual, &expected), + "canonical float bits are unchanged" + ); +} + +#[test] +fn an_open_ordered_cursor_keeps_its_reader_across_checkpoint_and_reuse() { + let (_dir, db) = fixture(32); + let mut cursor = db + .query("(query [:find ?v :where [?e :score ?v] :order-by [?v] :limit 10])") + .unwrap(); + assert!( + !has_sort(&cursor.counters()), + "the original snapshot was certified" + ); + for i in 1..=4 { + db.execute(&format!("(transact [[:new{i} :score -{i}]])")) + .unwrap(); + db.checkpoint().unwrap(); + } + let mut rows = Vec::new(); + while let Some(batch) = cursor.next_batch(3).unwrap() { + rows.extend(batch); + } + let expected: Vec<_> = (0..10).map(|n| vec![Value::Integer(n)]).collect(); + assert!( + same_rows(&rows, &expected), + "no rows from later generations leak in" + ); + let (new, _) = collect( + &db, + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 1]", + ); + assert!( + new == vec![vec![Value::Integer(-4)]], + "new opens see the new generation" + ); +} + +#[test] +fn prepared_queries_recheck_each_snapshot_and_rules_keep_original_strategy() { + let (_dir, db) = fixture(32); + let prepared = db + .prepare("(query [:find ?v :where [?e :score ?v] :order-by [?v] :limit $n])") + .unwrap(); + let bindings = [("n", crate::BindValue::Val(Value::Integer(1)))]; + let before = prepared.query(&bindings).unwrap(); + assert!( + !has_sort(&before.counters()), + "prepared execution is eligible" + ); + drop(before); + db.execute("(transact [[:new :score -1]])").unwrap(); + let mut pending = prepared.query(&bindings).unwrap(); + assert!(has_sort(&pending.counters()), "no stale prepared proof"); + assert!(pending.next_batch(1).unwrap().unwrap().rows() == [vec![Value::Integer(-1)]]); + drop(pending); + db.checkpoint().unwrap(); + assert!( + !has_sort(&prepared.query(&bindings).unwrap().counters()), + "checkpoint re-enables proof" + ); + db.execute("(rule [(scored ?e ?v) [?e :score ?v]])") + .unwrap(); + let (_, counters) = collect( + &db, + "[:find ?v :where (scored ?e ?v) :order-by [?v] :limit 3]", + ); + assert!(has_sort(&counters), "rule construction is unchanged"); +} + +#[test] +fn snapshot_pending_existence_uses_the_captured_prefix_and_staged_view() { + use crate::graph::storage::FactStorage; + use crate::graph::types::Fact; + let storage = FactStorage::new(); + let e = uuid::Uuid::from_u128(2); + let other = uuid::Uuid::from_u128(1); + let empty = storage.snapshot().unwrap(); + storage + .transact(vec![(e, ":a".into(), Value::Integer(1))], None) + .unwrap(); + assert!( + !empty.has_pending(":a", None).unwrap(), + "an old empty view stays empty" + ); + let snapshot = storage.snapshot().unwrap(); + storage + .transact( + vec![ + (other, ":new".into(), Value::Integer(2)), + (other, ":a".into(), Value::Integer(3)), + ], + None, + ) + .unwrap(); + assert!(snapshot.has_pending(":a", None).unwrap()); + assert!(snapshot.has_pending(":a", Some(&e)).unwrap()); + assert!(snapshot.has_pending(":a", None).unwrap()); + assert!(snapshot.has_pending(":a", Some(&e)).unwrap()); + assert!(!snapshot.has_pending(":a", Some(&other)).unwrap()); + assert!(!snapshot.has_pending(":new", None).unwrap()); + assert!(!snapshot.has_pending(":new", Some(&e)).unwrap()); + let mut retract = + Fact::with_valid_time(other, ":new".into(), Value::Integer(2), 20, 2, 0, i64::MAX); + retract.asserted = false; + let staged = snapshot.with_staged(vec![retract]); + assert!( + staged.has_pending(":new", None).unwrap(), + "staged retractions also disqualify" + ); + assert!(staged.has_pending(":new", Some(&other)).unwrap()); +} + +#[test] +fn unrelated_pending_facts_do_not_disable_order_but_in_range_records_do() { + let (_dir, db) = fixture(32); + let q = "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]"; + db.execute("(transact [[:unrelated :name \"pending\"]])") + .unwrap(); + assert!(!has_sort(&collect(&db, q).1), "unrelated pending range"); + db.execute("(transact [[:new :score -1]])").unwrap(); + let (rows, counters) = collect(&db, q); + assert!(has_sort(&counters), "a second input run needs Sort"); + assert!( + rows == vec![ + vec![Value::Integer(-1)], + vec![Value::Integer(0)], + vec![Value::Integer(1)] + ] + ); + db.checkpoint().unwrap(); + assert!( + !has_sort(&collect(&db, q).1), + "each open proves its own snapshot" + ); + db.execute("(retract [[:new :score -1]])").unwrap(); + assert!( + has_sort(&collect(&db, q).1), + "pending retractions also disqualify" + ); +} + +#[test] +fn committed_history_of_another_kind_disqualifies_the_entire_range() { + let (_dir, db) = fixture(32); + db.execute("(transact [[:history :score \"old\"]])") + .unwrap(); + db.execute("(retract [[:history :score \"old\"]])").unwrap(); + db.checkpoint().unwrap(); + let (_, counters) = collect( + &db, + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]", + ); + assert!( + has_sort(&counters), + "dead historical keys still prevent a kind proof" + ); +} + +#[test] +fn bool_float_and_single_entity_value_ranges_match_the_original_sort() { + let (_dir, db) = fixture(16); + db.execute( + "(transact [[:a :f -0.0] [:b :f 0.0] [:c :f -1.5] [:d :f 2.0] \ + [:a :b true] [:b :b false] [:one :s 8] [:one :s -2] [:one :s 3]])", + ) + .unwrap(); + db.checkpoint().unwrap(); + for q in [ + "[:find ?v :where [?e :f ?v] :order-by [?v]]", + "[:find ?v :where [?e :b ?v] :order-by [?v]]", + "[:find ?v :where [:one :s ?v] :order-by [?v]]", + ] { + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, counters) = collect(&db, q); + assert!(!has_sort(&counters), "supported scalar range"); + assert!(same_rows(&actual, &expected), "same values and float bits"); + } +} + +#[test] +fn mixed_numeric_kinds_strings_keywords_refs_sets_and_nil_keep_sort() { + let (_dir, db) = fixture(8); + db.execute( + "(transact [[:a :mixed 2] [:b :mixed 1.5] [:a :str \"b\"] [:b :str \"a\"] \ + [:a :kw :z] [:b :kw :a] [:a :ref #uuid \"00000000-0000-0000-0000-000000000002\"] \ + [:b :ref #uuid \"00000000-0000-0000-0000-000000000001\"] \ + [:a :set #{1 2}] [:b :set #{1}] [:a :nil nil]])", + ) + .unwrap(); + db.checkpoint().unwrap(); + for a in ["mixed", "str", "kw", "ref", "set", "nil"] { + let q = format!("[:find ?v :where [?e :{a} ?v] :order-by [?v]]"); + let (actual, counters) = collect(&db, &q); + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + assert!(has_sort(&counters), "uncertified value kind"); + assert!( + same_rows(&actual, &expected), + "fallback preserves full order" + ); + } +} + +#[test] +fn constant_and_repeated_projection_columns_preserve_the_complete_order() { + let (_dir, db) = fixture(32); + for q in [ + "[:find ?v ?v :where [?e :score ?v] :order-by [?v] :limit 3]", + "[:find ?c ?v :where [?e :score ?v] [(+ 20 22) ?c] :order-by [?v] :limit 3]", + "[:find ?c ?v :where [?e :score ?v] [(+ 20 22) ?c] :order-by [?c :desc ?v] :limit 3]", + ] { + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, counters) = collect(&db, q); + assert!( + !has_sort(&counters), + "constants/repetitions add no tie requirement" + ); + assert!( + same_rows(&actual, &expected), + "nonidentity projection is restored" + ); + } +} + +#[test] +fn nested_and_binding_callbacks_keep_sort_and_late_errors_under_limit() { + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let (_dir, db) = fixture(4096); + let calls = Arc::new(AtomicUsize::new(0)); + let seen = calls.clone(); + db.try_register_predicate("boom?", move |_| { + if seen.fetch_add(1, Ordering::SeqCst) == 1499 { + Err(crate::UdfError::new("late failure")) + } else { + Ok(true) + } + }) + .unwrap(); + for body in [ + "[(boom? ?v)]", + "[(= (boom? ?v) true)]", + "[(boom? ?v) ?ok]", + "(not [(= (boom? ?v) false)])", + ] { + calls.store(0, Ordering::SeqCst); + let q = format!("(query [:find ?v :where [?e :score ?v] {body} :order-by [?v] :limit 10])"); + let err = db + .execute(&q) + .expect_err("Sort must reach the late callback error"); + assert_eq!(err.code(), "QRY-014"); + assert_eq!( + calls.load(Ordering::SeqCst), + 1500, + "no call after the failure" + ); + } +} + +#[test] +fn collect_set_data_errors_are_not_hidden_by_ordered_limit() { + let (_dir, db) = fixture(4096); + let bad = (0..4096).find(|i| i * 337 % 4096 == 4095).unwrap(); + db.execute(&format!("(transact [[:e{bad} :items #{{1}}]])")) + .unwrap(); + db.checkpoint().unwrap(); + let err = db + .execute( + "(query [:find ?v :where [?e :score ?v] \ + [(collect-set ?e :items) ?s] :order-by [?v] :limit 10])", + ) + .expect_err("a late nested set remains an error"); + assert_eq!(err.code(), "QRY-015"); +} + +#[test] +fn staged_negative_values_and_working_reader_type_changes_keep_correct_order() { + let dir = tempfile::tempdir().unwrap(); + let db = crate::OpenOptions::new() + .transaction_chunk_facts(2) + .path(dir.path().join("large.graph")) + .open() + .unwrap(); + db.execute("(transact [[:a :score 0] [:b :score 2]])") + .unwrap(); + db.checkpoint().unwrap(); + let q = "(query [:find ?v :where [?e :score ?v] :order-by [?v] :limit 1])"; + { + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:staged :score -1]])").unwrap(); + let crate::QueryResult::QueryResults { results, .. } = tx.execute(q).unwrap() else { + panic!("rows"); + }; + assert!( + results == vec![vec![Value::Integer(-1)]], + "staged run is sorted with committed rows" + ); + } + { + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:new :score -0.5] [:x :other 1] [:y :other 2]])") + .unwrap(); + let crate::QueryResult::QueryResults { results, .. } = tx.execute(q).unwrap() else { + panic!("rows"); + }; + assert!( + results == vec![vec![Value::Float(-0.5)]], + "kind proof reads working roots, not published roots" + ); + } + assert!( + !has_sort(&collect(&db, "[:find ?v :where [?e :score ?v] :order-by [?v]]").1), + "rollback does not leave a stale type proof" + ); +} + +#[test] +fn temporal_queries_match_fallback_with_duplicate_values_and_metadata() { + let (_dir, db) = fixture(32); + db.execute( + "(transact {:valid-from \"2020-01-01\" :valid-to \"2021-01-01\"} \ + [[:hist1 :score -2]])", + ) + .unwrap(); + db.execute("(transact {:valid-from \"2022-01-01\"} [[:hist2 :score -2]])") + .unwrap(); + db.checkpoint().unwrap(); + for temporal in [ + ":as-of 1 :valid-at :any-valid-time", + ":as-of 2 :valid-at :any-valid-time", + ":valid-at \"2020-06-01\"", + ":valid-at \"2022-06-01\"", + ":valid-at :any-valid-time", + ] { + let q = format!("[:find ?v {temporal} :where [?e :score ?v] :order-by [?v] :limit 10]"); + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters) = collect(&db, &q); + assert!( + !has_sort(&counters), + "time filtering preserves raw key order" + ); + assert!( + same_rows(&actual, &expected), + "same temporal rows and multiplicities" + ); + } + for q in [ + "[:find ?v ?f :valid-at :any-valid-time :where [?e :score ?v] [?e :db/valid-from ?f] :order-by [?v ?f]]", + "[:find ?t ?v :valid-at :any-valid-time :where [?e :score ?v] [?e :db/valid-at ?t] :order-by [?t ?v]]", + ] { + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, _) = collect(&db, q); + assert!( + same_rows(&actual, &expected), + "metadata columns and nil valid-at are preserved" + ); + } +} + +#[test] +fn successful_working_tree_proofs_are_fresh_after_each_statement_and_rollback() { + fn values(result: crate::QueryResult) -> Vec> { + let crate::QueryResult::QueryResults { results, .. } = result else { + panic!("rows"); + }; + results + } + let proofs = || super::order::OPTIMIZATIONS.with(std::cell::Cell::get); + let dir = tempfile::tempdir().unwrap(); + let db = crate::OpenOptions::new() + .transaction_chunk_facts(2) + .path(dir.path().join("working.graph")) + .open() + .unwrap(); + db.execute("(transact [[:a :score 0] [:b :score 2]])") + .unwrap(); + db.checkpoint().unwrap(); + let q = "(query [:find ?v :where [?e :score ?v] :order-by [?v] :limit 1])"; + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:new :score -1] [:x :other 1] [:y :other 2]])") + .unwrap(); + let before = proofs(); + assert!(values(tx.execute(q).unwrap()) == vec![vec![Value::Integer(-1)]]); + assert_eq!(proofs(), before + 1, "working-tree input really omits Sort"); + tx.execute("(transact [[:newer :score -2]])").unwrap(); + assert!(values(tx.execute(q).unwrap()) == vec![vec![Value::Integer(-2)]]); + assert_eq!( + proofs(), + before + 2, + "a new query reads the new working roots" + ); + let err = tx + .execute( + "(transact [[:bad :score \"rolled back\"] \ + [:dup :other 1 {:valid-from \"2020-01-01\"}] [:filler :other 2] \ + [:dup :other 1 {:valid-from \"2021-01-01\"}]])", + ) + .expect_err("one triple, two windows"); + assert_eq!(err.code(), "API-011"); + assert!(values(tx.execute(q).unwrap()) == vec![vec![Value::Integer(-2)]]); + assert_eq!( + proofs(), + before + 3, + "rejected statement restores the proof's actual reader" + ); + tx.execute("(transact [[:mixed :score -3.5]])").unwrap(); + assert!(values(tx.execute(q).unwrap()) == vec![vec![Value::Float(-3.5)]]); + assert_eq!( + proofs(), + before + 3, + "a changed type invalidates subsequent proofs" + ); + drop(tx); + assert!(values(db.execute(q).unwrap()) == vec![vec![Value::Integer(0)]]); + assert_eq!( + proofs(), + before + 4, + "rollback leaves the published integer generation eligible" + ); +} + +#[test] +fn filters_entity_probes_and_anti_joins_preserve_unchanged_order_columns() { + let (_dir, db) = fixture(32); + let facts: String = (0..32) + .map(|i| format!("[:e{i} :flag true] [:m{i} :match {i}]")) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + for body in [ + "[(>= ?v 7)]", + "[?e :flag true]", + "[?other :match ?v]", + "(not [?e :missing true])", + ] { + let q = format!("[:find ?v :where [?e :score ?v] {body} :order-by [?v] :limit 10]"); + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters) = collect(&db, &q); + assert!( + !has_sort(&counters), + "a preserving operator keeps the outer order" + ); + assert!( + same_rows(&actual, &expected), + "same complete ordered result" + ); + } +} + +#[test] +fn expression_priority_replacement_invalidates_the_ordered_slot() { + let (_dir, db) = fixture(32); + let _on = crate::query::datalog::optimizer::set_reorder(true); + // The selective score pattern runs first. The earlier expression then + // replaces its ?v after the broad entity probe binds ?x. + let q = "[:find ?v :where [?e ?a ?x] [(+ ?x 0) ?v] [?e :score ?v] :order-by [?v] :limit 3]"; + assert!( + query_plan(q).steps.iter().any(|s| matches!( + s, + super::plan::Step::Bind(_, _, _, super::plan::Out::Replace) + )), + "replacement path" + ); + let (actual, counters) = collect(&db, q); + let (expected, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + assert!( + has_sort(&counters), + "replacement is not certified as order-preserving" + ); + assert!(same_rows(&actual, &expected)); +} + +#[test] +fn value_probe_runtime_fallback_preserves_order_only_when_it_streams_the_outer() { + use super::plan::{JoinKind, Step}; + use crate::query::datalog::{ + functions::FunctionRegistry, parser::parse_datalog_command, types::DatalogCommand, + }; + let (_dir, db) = fixture(32); + let named = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b":named"); + let mut facts = String::new(); + for i in 0..32 { + if i < 16 { + facts.push_str(&format!("[:e{i} :friend {i}] [:m{i} :alias {i}]")); + } else { + facts.push_str(&format!("[:e{i} :friend #uuid \"{named}\"]")); + } + } + facts.push_str("[:named-alias :alias :named]"); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let DatalogCommand::Query(q) = parse_datalog_command( + "(query [:find ?v :where [?e :score ?v] [?e :friend ?target] \ + [?other :alias ?target] :order-by [?v]])", + ) + .unwrap() else { + panic!("query"); + }; + for build_inner in [true, false] { + let mut plan = super::plan(&q).unwrap(); + let join = plan + .steps + .iter_mut() + .rev() + .find_map(|s| match s { + Step::Join(j) if matches!(j.kind, JoinKind::ProbeValue { .. }) => Some(j), + _ => None, + }) + .expect("value probe"); + join.kind = JoinKind::ProbeValue { + key: match join.kind { + JoinKind::ProbeValue { key, .. } => key, + _ => panic!("probe"), + }, + build_inner, + }; + let mut stream = super::open( + db.snapshot().unwrap(), + plan, + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert_eq!( + has_sort(&stream.counters()), + !build_inner, + "fallback orientation controls the proof" + ); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + let expected: Vec<_> = (0..32).map(|v| vec![Value::Integer(v)]).collect(); + assert!( + same_rows(&rows, &expected), + "ambiguous ref/keyword probes still give the full ordered result" + ); + } +} + +/// Real reader with instrumentation only around optional proof reads. +struct ProofKeys<'a> { + base: &'a dyn crate::storage::KeySource, + calls: std::sync::atomic::AtomicUsize, + fail_at: Option, +} + +macro_rules! forward_keys { + ($($name:ident($($arg:ident: $ty:ty),*) -> $ret:ty;)*) => { + $(fn $name(&self, $($arg: $ty),*) -> $ret { self.base.$name($($arg),*) })* + }; +} + +impl crate::storage::KeySource for ProofKeys<'_> { + fn any_key(&self, index: crate::storage::keys::Index, prefix: &[u8]) -> anyhow::Result { + let call = self.calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1; + if self.fail_at == Some(call) { + anyhow::bail!("optional proof read failed"); + } + self.base.any_key(index, prefix) + } + + forward_keys! { + next_ids() -> (u64, u32); + eid_of(e: &uuid::Uuid) -> anyhow::Result>; + iid_of(a: &str) -> anyhow::Result>; + uuid_of(e: u64) -> anyhow::Result; + uuids_of(e: &[u64], visit: &mut dyn FnMut(u64, uuid::Uuid) -> anyhow::Result<()>) -> anyhow::Result<()>; + ident_of(i: u32) -> anyhow::Result; + long_value(r: crate::storage::keys::ValueRef) -> anyhow::Result; + long_value_ref(s: &str) -> anyhow::Result>; + long_bytes(r: crate::storage::keys::ValueRef) -> anyhow::Result>; + long_bytes_ref(s: &[u8]) -> anyhow::Result>; + tx_id_of(n: u64) -> anyhow::Result; + tx_order() -> anyhow::Result; + last_tx_at(t: u64) -> anyhow::Result; + tx_runs(t: u64, out: &mut Vec<(u64, u64)>) -> anyhow::Result<()>; + live_keys(index: crate::storage::keys::Index, prefix: &[u8], resume: Option<&[u8]>, + bound: &crate::storage::TxBound, max: usize, out: &mut Vec) + -> anyhow::Result>>; + } +} + +fn query_plan(query: &str) -> super::Plan { + use crate::query::datalog::{parser::parse_datalog_command, types::DatalogCommand}; + let DatalogCommand::Query(q) = parse_datalog_command(&format!("(query {query})")).unwrap() + else { + panic!("query"); + }; + super::plan(&q).unwrap() +} + +#[test] +fn optional_proofs_are_bounded_and_queries_without_a_usable_demand_do_no_probes() { + use crate::query::datalog::functions::FunctionRegistry; + let (_dir, db) = fixture(32); + let snapshot = db.snapshot().unwrap(); + let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); + for (q, expected) in [ + ( + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]", + 8, + ), + ("[:find ?v :where [?e :score ?v] :limit 3]", 0), + ( + "[:find ?v :where [?e :score ?v] :order-by [?v :desc] :limit 3]", + 0, + ), + ( + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 0]", + 0, + ), + ( + "[:find ?v :where [?e :score ?v] :order-by [?v] :offset 7 :limit 0]", + 0, + ), + ( + "[:find ?e ?v :where [?e :score ?v] :order-by [?v] :limit 3]", + 0, + ), + ( + "[:find ?v :where [?e :missing ?v] :order-by [?v] :limit 3]", + 0, + ), + ( + "[:find ?e :where [?e :score ?e] :order-by [?e] :limit 3]", + 0, + ), + ] { + let keys = ProofKeys { + base, + calls: 0.into(), + fail_at: None, + }; + let mut plan = query_plan(q); + super::order::resolve( + &snapshot, + Some(&keys), + &FunctionRegistry::with_builtins(), + &mut plan, + ); + assert_eq!( + keys.calls.load(std::sync::atomic::Ordering::SeqCst), + expected, + "bounded optional proof reads" + ); + } +} + +#[test] +fn every_failed_optional_read_retains_the_original_sort_projection_and_index() { + use super::plan::{Source, Step}; + use crate::query::datalog::functions::FunctionRegistry; + let (_dir, db) = fixture(32); + let snapshot = db.snapshot().unwrap(); + let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); + for fail_at in 1..=8 { + let keys = ProofKeys { + base, + calls: 0.into(), + fail_at: Some(fail_at), + }; + let mut plan = query_plan("[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]"); + let original_find = plan.find.clone(); + super::order::resolve( + &snapshot, + Some(&keys), + &FunctionRegistry::with_builtins(), + &mut plan, + ); + assert!( + plan.steps.iter().any(|s| matches!(s, Step::Sort { .. })), + "Sort remains" + ); + assert_eq!( + plan.find, original_find, + "projection is not partially restored" + ); + assert!( + matches!(&plan.source, Source::Scan(s) if s.index.is_none()), + "index choice is unchanged" + ); + let _off = super::order::set_enabled(false); + let mut fallback = super::open( + snapshot.clone(), + plan, + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert!(has_sort(&fallback.counters())); + let mut rows = Vec::new(); + while let Some(batch) = fallback.next_rows().unwrap() { + rows.extend(batch); + } + assert!( + rows == vec![ + vec![Value::Integer(0)], + vec![Value::Integer(1)], + vec![Value::Integer(2)] + ], + "a failed optional proof still executes the original query" + ); + } +} diff --git a/src/query/engine/plan.rs b/src/query/engine/plan.rs index 494cc98e35..207c6fd05d 100644 --- a/src/query/engine/plan.rs +++ b/src/query/engine/plan.rs @@ -115,6 +115,8 @@ pub(crate) enum Meta { /// What a `Scan` reads. #[derive(Debug, Clone)] pub(crate) struct ScanSpec { + /// Snapshot-resolved source index (#641); otherwise normal index choice. + pub(crate) index: Option, pub(crate) e: Term, pub(crate) a: Term, pub(crate) v: Term, @@ -1068,6 +1070,7 @@ impl Builder { metas.push((m, slot)); } self.source = Some(Source::Scan(ScanSpec { + index: None, e, a, v, @@ -1165,6 +1168,7 @@ impl Builder { Some((entity, attribute)) => Step::CollectSet(CollectSpec { entity, inner: ScanSpec { + index: None, e: Term::Bind(0), a: Term::Const(attribute.clone()), v: Term::Bind(1), @@ -1502,6 +1506,7 @@ fn join( } Ok(JoinSpec { inner: ScanSpec { + index: None, e, a, v, diff --git a/src/query/engine/project.rs b/src/query/engine/project.rs index 3106d11855..3bfd69ce4d 100644 --- a/src/query/engine/project.rs +++ b/src/query/engine/project.rs @@ -177,6 +177,9 @@ mod tests { // The unused storage operations cannot affect a projection-only test. impl KeySource for Keys { + fn any_key(&self, _: Index, _: &[u8]) -> Result { + panic!("unused") + } fn next_ids(&self) -> (u64, u32) { (self.limit, 1) } diff --git a/src/query/engine/recursive.rs b/src/query/engine/recursive.rs index f842fe9732..43ad81a572 100644 --- a/src/query/engine/recursive.rs +++ b/src/query/engine/recursive.rs @@ -112,6 +112,7 @@ fn know_stored( return Ok(()); }; let mut scan = Scan::new(ScanSpec { + index: None, e: Term::Bind(0), a: Term::Const(attr.clone()), v: Term::Bind(1), diff --git a/src/query/engine/scan.rs b/src/query/engine/scan.rs index c4dadd9443..f8093f261f 100644 --- a/src/query/engine/scan.rs +++ b/src/query/engine/scan.rs @@ -752,7 +752,10 @@ fn open( (Some(e), Some(a), t) => (vec![(Index::Eavt, keys::entity_attribute_prefix(e, a))], t), (Some(e), None, t) => (vec![(Index::Eavt, keys::entity_prefix(e))], t), (None, Some(a), Some(t)) => avet(a, t), - (None, Some(a), None) => (vec![(Index::Aevt, keys::attribute_prefix(a))], None), + (None, Some(a), None) => ( + vec![(spec.index.unwrap_or(Index::Aevt), keys::attribute_prefix(a))], + None, + ), (None, None, t) => (vec![(Index::Eavt, Vec::new())], t), }; let mut shadow = HashSet::new(); diff --git a/src/query/engine/sort.rs b/src/query/engine/sort.rs index 7c663147ac..e4f0f57939 100644 --- a/src/query/engine/sort.rs +++ b/src/query/engine/sort.rs @@ -5,8 +5,9 @@ //! compares, and turns them back into cells only for the rows it returns. //! Under a `:limit` (`keep = k`) it holds at most `k` rows, in a binary heap //! whose top is the worst row held, so its memory follows `k`, not the -//! answer. Either way it reads its whole input; skipping that when an index -//! returns the rows in order is #641. +//! answer. Either way it reads its whole input. The snapshot-bound order +//! resolver omits this operator when a committed scalar range proves the full +//! result order (#641). use super::batch::Batch; use super::cell::{Cell, Scalar}; diff --git a/src/storage/keys.rs b/src/storage/keys.rs index 483adbe076..c0e83639c5 100644 --- a/src/storage/keys.rs +++ b/src/storage/keys.rs @@ -787,21 +787,45 @@ pub fn attribute_value_prefix(a: u32, v: &KeyValue) -> Vec { k } -/// A kind of value whose matches a constant cannot name by one key: a float -/// matches `0.0` and `-0.0` alike (#706), keywords match a UUID constant by -/// the entity they name (#544). +/// A key value's kind. Constants read floats and keywords by kind (#706, +/// #544); order proofs check every kind, including historical keys (#641). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ValueKind { + Null, + Boolean, + Integer, Float, + String, Keyword, + Ref, + Set, +} + +impl ValueKind { + pub const ALL: [Self; 8] = [ + Self::Null, + Self::Boolean, + Self::Integer, + Self::Float, + Self::String, + Self::Keyword, + Self::Ref, + Self::Set, + ]; } /// Key prefix of every AVET entry of attribute `a` with a value of `kind`. pub fn attribute_kind_prefix(a: u32, kind: ValueKind) -> Vec { let mut k = attribute_prefix(a); k.push(match kind { + ValueKind::Null => TAG_NULL, + ValueKind::Boolean => TAG_BOOL, + ValueKind::Integer => TAG_INT, ValueKind::Float => TAG_FLOAT, + ValueKind::String => TAG_STRING, ValueKind::Keyword => TAG_KEYWORD, + ValueKind::Ref => TAG_REF, + ValueKind::Set => TAG_SET, }); k } @@ -1497,4 +1521,61 @@ mod tests { assert_eq!(MAX_VALUE_BYTES, 4068); assert_eq!(MAX_IDENT_BYTES, 1024); } + + #[test] + fn kind_prefixes_cover_every_encoded_value_variant_exactly_once() { + fn kind(v: &KeyValue) -> ValueKind { + // Intentionally exhaustive: new variants must update this proof. + match v { + KeyValue::Null => ValueKind::Null, + KeyValue::Bool(_) => ValueKind::Boolean, + KeyValue::Int(_) => ValueKind::Integer, + KeyValue::Float(_) => ValueKind::Float, + KeyValue::Str(_) | KeyValue::LongStr { .. } => ValueKind::String, + KeyValue::Keyword(_) => ValueKind::Keyword, + KeyValue::Ref(_) => ValueKind::Ref, + KeyValue::Set(_) | KeyValue::LongSet { .. } => ValueKind::Set, + } + } + let r = ValueRef { page: 2, slot: 0 }; + let values = [ + KeyValue::Null, + KeyValue::Bool(false), + KeyValue::Int(-1), + KeyValue::Float(-0.0), + KeyValue::Str("a".into()), + long_str(&"x".repeat(65), r), + KeyValue::Keyword(3), + KeyValue::Ref(4), + KeyValue::Set(vec![]), + KeyValue::LongSet { + prefix: vec![1], + hash: 1, + vref: r, + }, + ]; + for (i, k) in ValueKind::ALL.iter().enumerate() { + assert!( + !ValueKind::ALL.iter().take(i).any(|other| other == k), + "unique kinds" + ); + assert!( + values.iter().any(|v| kind(v) == *k), + "every kind has a value witness" + ); + } + for v in &values { + let mut bytes = attribute_prefix(7); + put_value(&mut bytes, v); + let matched: Vec<_> = ValueKind::ALL + .iter() + .copied() + .filter(|k| bytes.starts_with(&attribute_kind_prefix(7, *k))) + .collect(); + assert!( + matched == [kind(v)], + "exactly one kind prefix matches the actual encoding" + ); + } + } } diff --git a/src/storage/mod.rs b/src/storage/mod.rs index 88e3cb3278..20753c1ca5 100644 --- a/src/storage/mod.rs +++ b/src/storage/mod.rs @@ -549,6 +549,9 @@ pub trait KeySource: Send + Sync { /// Append to `out` the transactions with `tx_id <= t` as sorted, /// disjoint, inclusive `tx_count` ranges. fn tx_runs(&self, t: u64, out: &mut Vec<(u64, u64)>) -> Result<()>; + /// Whether an index has any raw key with this prefix, including historical + /// and retracted records. One seek; no search for a live version (#641). + fn any_key(&self, index: keys::Index, prefix: &[u8]) -> Result; /// The keys of `index` that start with `prefix` and survive net-assert /// among the versions `bound` keeps, decoded, appended to `out` in key /// order. diff --git a/src/storage/persistent_facts.rs b/src/storage/persistent_facts.rs index 3207dc4244..e3987663ea 100644 --- a/src/storage/persistent_facts.rs +++ b/src/storage/persistent_facts.rs @@ -751,7 +751,7 @@ impl PersistentFactStorage { self.meta } - #[cfg(any(not(target_arch = "wasm32"), feature = "browser"))] + #[cfg(any(not(target_arch = "wasm32"), feature = "browser", test))] /// Mark storage as dirty (needs saving) pub fn mark_dirty(&mut self) { self.dirty = true; diff --git a/src/storage/reader.rs b/src/storage/reader.rs index 5abbaf9d8c..09ba6f1ab2 100644 --- a/src/storage/reader.rs +++ b/src/storage/reader.rs @@ -405,6 +405,17 @@ impl KeySource for OnDiskReader { Ok(()) } + fn any_key(&self, index: Index, prefix: &[u8]) -> Result { + let root = self.root(index); + if root == 0 { + return Ok(false); + } + let mut cursor = LeafCursor::new(root, Some(prefix), &self.backend, &self.cache)?; + Ok(cursor + .next_ref()? + .is_some_and(|(k, _)| k.starts_with(prefix))) + } + fn live_keys( &self, index: Index, @@ -588,6 +599,57 @@ pub fn all_entries_as_facts( .collect() } +#[cfg(test)] +mod order_probe_tests { + use super::*; + use crate::storage::btree::{build_btree, tests::CountingBackend}; + use crate::storage::keys::{KeyValue, ValueKind}; + use crate::storage::page::PageAllocator; + + #[test] + fn raw_kind_probe_sees_retractions_without_walking_them() { + let mut backend = CountingBackend::new(); + let cache = Arc::new(PageCache::new(0)); + let entries = (1..=8192u64) + .map(|e| { + let fact = KeyFact { + e, + a: 7, + v: KeyValue::Float(e as f64), + tx_count: 1, + vf: 0, + vt: i64::MAX, + asserted: false, + }; + (fact.key(Index::Avet).unwrap(), Vec::new()) + }) + .collect(); + let mut alloc = PageAllocator::new(Vec::new(), 2, 1); + let mut meta = MetaPage::empty(1); + meta.avet_root = build_btree(entries, &mut backend, &cache, &mut alloc).unwrap(); + let backend = Arc::new(Mutex::new(backend)); + let reader = OnDiskReader::new(backend.clone(), cache, &meta); + for (kind, expected) in [(ValueKind::Float, true), (ValueKind::Integer, false)] { + backend.lock().unwrap().reset(); + let actual = reader + .any_key(Index::Avet, &keys::attribute_kind_prefix(7, kind)) + .unwrap(); + assert_eq!(actual, expected, "raw history, not live rows"); + assert!( + backend.lock().unwrap().reads() <= 8, + "one tree descent, no history walk" + ); + } + backend.lock().unwrap().reset(); + assert!(!reader.any_key(Index::Eavt, &[]).unwrap()); + assert_eq!( + backend.lock().unwrap().reads(), + 0, + "an absent tree reads no pages" + ); + } +} + #[cfg(test)] mod uuid_batch_tests { use super::*; diff --git a/tests/distinct_test.rs b/tests/distinct_test.rs index d2ebfad590..ee72434dff 100644 --- a/tests/distinct_test.rs +++ b/tests/distinct_test.rs @@ -439,6 +439,12 @@ fn distinct_memory_limit_and_cursor_cleanup() { 1 ); let q = "(query [:find ?v :where [?e :c ?v] :distinct :order-by [?v] :limit 1])"; + assert_eq!( + rows(&db, q).len(), + 1, + "ordered input stops before the bound" + ); + let q = "(query [:find ?v :where [?e :c ?v] :distinct :order-by [?v :desc] :limit 1])"; assert_eq!( db.execute(q) .expect_err("distinct retains keys even under top-k") diff --git a/tests/input_order_test.rs b/tests/input_order_test.rs new file mode 100644 index 0000000000..7df90a413d --- /dev/null +++ b/tests/input_order_test.rs @@ -0,0 +1,97 @@ +//! Differential oracle: identical ordered lists with input-order strategies +//! enabled and disabled, across the existing plan switches and snapshots. +#![cfg(all(feature = "test-hooks", not(target_arch = "wasm32")))] + +use minigraf::{Minigraf, QueryResult, Value}; + +fn rows(db: &Minigraf, q: &str) -> Vec> { + let QueryResult::QueryResults { results, .. } = db.execute(q).unwrap() else { + panic!("query rows"); + }; + results +} + +fn same(a: &[Vec], b: &[Vec]) -> bool { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| match (a, b) { + (Value::Float(a), Value::Float(b)) => a.to_bits() == b.to_bits(), + _ => a == b, + }) + }) +} + +#[test] +fn ordered_results_are_independent_of_order_modes_and_physical_plans() { + let dir = tempfile::tempdir().unwrap(); + let db = Minigraf::open(dir.path().join("plans.graph")).unwrap(); + let facts: String = (0..128) + .map(|i| { + format!( + "[:e{i} :score {}] [:e{i} :flag {}] [:e{i} :group {}]", + (i * 37) % 128, + i % 2 == 0, + i % 4 + ) + }) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.execute( + "(transact [[:a :float -0.0] [:b :float 0.0] [:c :float -1.5] \ + [:one :multi 3] [:one :multi 1] [:one :multi 2]])", + ) + .unwrap(); + db.execute("(rule [(scored ?e ?v) [?e :score ?v]])") + .unwrap(); + let queries = [ + "(query [:find ?v :where [?e :score ?v] :order-by [?v] :limit 5 :offset 2])", + "(query [:find ?b :where [?e :flag ?b] :order-by [?b] :limit 5])", + "(query [:find ?v :where [:one :multi ?v] :order-by [?v]])", + "(query [:find ?v :where [?e :score ?v] [(>= ?v 20)] :order-by [?v] :limit 5])", + "(query [:find ?v :where [?e :score ?v] [?e :flag true] :order-by [?v] :limit 5])", + "(query [:find ?v :where [?e :score ?v] (not [?e :hidden true]) :order-by [?v] :limit 5])", + "(query [:find ?v :where [?e :score ?v] (or [?e :flag true] [?e :flag false]) :order-by [?v] :limit 5])", + "(query [:find ?v :where [?e :float ?v] :distinct :order-by [?v]])", + "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g]])", + "(query [:find ?v (rank :over (:partition-by ?e :order-by ?v)) :where [?e :score ?v] :order-by [?v]])", + "(query [:find ?v :where (scored ?e ?v) :order-by [?v] :limit 5])", + ]; + for state in 0..4 { + match state { + 1 => db.checkpoint().unwrap(), + 2 => { + db.execute("(transact [[:unrelated :name \"pending\"]])") + .unwrap(); + } + 3 => { + db.execute("(transact [[:early :score -1]])").unwrap(); + } + _ => {} + } + for reorder in [false, true] { + let _reorder = minigraf::__reorder(reorder); + for mode in [ + minigraf::Subplans::Choose, + minigraf::Subplans::Hash, + minigraf::Subplans::Correlated, + ] { + let _mode = minigraf::__subplans(mode); + for query in queries { + let expected = { + let _off = minigraf::__input_order(false); + rows(&db, query) + }; + let actual = { + let _on = minigraf::__input_order(true); + rows(&db, query) + }; + assert!( + same(&actual, &expected), + "identical ordered lists across physical strategies" + ); + } + } + } + } +} From e6670c82d24ac8e1f7ef0a75ca88c67b74c07f67 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Wed, 28 Oct 2026 12:48:46 +0530 Subject: [PATCH 2/3] perf(query): stream certified count groups (#641) --- CHANGELOG.md | 4 +- CLAUDE.md | 6 +- README.md | 2 +- ROADMAP.md | 2 +- benches/minigraf_bench.rs | 46 ++ docs/BENCHMARKS.md | 148 ++++- docs/TEST_COVERAGE.md | 23 +- docs/benchmarks/641-ordered-groups-build.json | 87 +++ .../641-ordered-groups-guards.jsonl | 360 +++++++++++ .../641-ordered-groups-history.jsonl | 144 +++++ .../benchmarks/641-ordered-groups-meter.jsonl | 24 + .../641-ordered-groups-startup.jsonl | 72 +++ docs/benchmarks/641-ordered-groups.jsonl | 252 ++++++++ scripts/input_order_group_fixture.rs | 25 + scripts/input_order_group_probe.rs | 50 ++ src/query/datalog/aggregate.rs | 24 +- src/query/engine/aggregate.rs | 263 ++++++-- src/query/engine/aggregate_order_tests.rs | 561 ++++++++++++++++++ src/query/engine/mod.rs | 10 +- src/query/engine/order.rs | 164 +++-- src/query/engine/order/tests.rs | 101 +++- src/query/engine/order_tests.rs | 119 ++-- src/query/engine/plan.rs | 15 + src/query/engine/tests.rs | 145 +++++ tests/memory_limit_acceptance_test.rs | 10 +- 25 files changed, 2468 insertions(+), 189 deletions(-) create mode 100644 docs/benchmarks/641-ordered-groups-build.json create mode 100644 docs/benchmarks/641-ordered-groups-guards.jsonl create mode 100644 docs/benchmarks/641-ordered-groups-history.jsonl create mode 100644 docs/benchmarks/641-ordered-groups-meter.jsonl create mode 100644 docs/benchmarks/641-ordered-groups-startup.jsonl create mode 100644 docs/benchmarks/641-ordered-groups.jsonl create mode 100644 scripts/input_order_group_fixture.rs create mode 100644 scripts/input_order_group_probe.rs create mode 100644 src/query/engine/aggregate_order_tests.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 9117079e3b..d62f93a5ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,7 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Performance -- **Skip sorting proven ordered input** (#641, first slice). Plain queries can omit `Sort` when a committed integer, float, or Boolean range already provides the complete ascending result order. Attribute scans use AVET; entity-and-attribute scans retain their selective EAVT range. `:offset` and `:limit` then stop reading early, so memory-limit (`QRY-012`) or I/O errors in unread later input may be avoided. The proof uses the query's pinned reader, including a large write transaction's working trees, and rejects pending or staged records in the source range, mixed kinds, unsupported comparators, tie suffixes, order-changing operators, user callbacks and `collect-set`. Unproven queries retain their original plan. Aggregates and windows still buffer their full input in this slice. +- **Skip sorting proven ordered input** (#641, first slice). Plain queries can omit `Sort` when a committed integer, float, or Boolean range already provides the complete ascending result order. Attribute scans use AVET; entity-and-attribute scans retain their selective EAVT range. `:offset` and `:limit` then stop reading early, so memory-limit (`QRY-012`) or I/O errors in unread later input may be avoided. The proof uses the query's pinned reader, including a large write transaction's working trees, and rejects pending or staged records in the source range, mixed kinds, unsupported comparators, tie suffixes, order-changing operators, user callbacks and `collect-set`. Unproven queries retain their original plan. Windows still buffer their full input pending the third slice. + +- **Release completed count groups** (#641, second slice). A plain query with exactly one proved scalar grouping key, no `:with` or windows, and only built-in `count`/`count-distinct` holds one active group plus bounded batches. Completed groups are released, and a limit can stop before later groups; one large distinct group still grows with its members. Integer, Boolean and committed-float keys qualify, including mixed integer/float grouping in `Value::Ord` order. A unique single-kind group key can also remove the final ascending Sort; mixed numeric keys retain numeric Sort. Fallible aggregates, callbacks and `collect-set` retain full-input validation and later errors. Small selective grouped queries pay proof startup cost, and a single growing group is slower (see `docs/BENCHMARKS.md`). No new aggregate syntax or function is added. ### Breaking changes diff --git a/CLAUDE.md b/CLAUDE.md index 4992873c03..85333a3d2d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -148,7 +148,7 @@ cargo run < demos/demo_negation.txt - `prepared.rs`: `BindValue`, `PreparedQuery` — parse-once/execute-many with named `$slot` bind slots; `prepare_query`, `substitute`; `Entity` and `Val(Ref)` fit each other's slots, bind mistakes are `API-022`/`023`/`024` (#181); a `:limit $n` or `:offset $o` slot takes `Val(Integer(n >= 0))` (`resolve_count_slot`, #306) - `magic_sets.rs`: Magic-sets rewriting for demand-driven recursive rule evaluation (not applied to rules with `not`/`not-join`) -3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`), `order.rs` (#641: snapshot-bound proofs of the complete result order; safe committed integer/float/Boolean ranges can set the private `ScanSpec.index` hint to AVET and omit Sort, with `plan.find` restored from Sort.cols; entity-and-attribute scans retain EAVT; pending/staged records in that range, mixed kinds, DICT comparators, callbacks and CollectSet keep the original plan; `minigraf::__input_order` forces fallback under `test-hooks`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. +3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`; #641 certifies one committed scalar group key with only built-in count/count-distinct, no :with/window/callback/CollectSet, as `Grouping::Ordered`: one active group, bounded output batches, shared finish_group, internal DICT-cache eviction; fallible aggregates keep full-drain validation), `order.rs` (#641: snapshot-bound proofs of the complete result order; safe committed integer/float/Boolean ranges can set the private `ScanSpec.index` hint to AVET and omit Sort, with `plan.find` restored from Sort.cols; entity-and-attribute scans retain EAVT; pending/staged records in that range, DICT comparators, callbacks and CollectSet keep the original strategies; mixed integer/float keys can prove grouping order but keep Sort, and unique group keys discharge tie suffixes; `minigraf::__input_order` forces fallback under `test-hooks`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. 4. **`src/temporal.rs`** — UTC-only timestamp parsing (avoids chrono CVE GHSA-wcg3-cvx6-7396) @@ -216,7 +216,7 @@ Auto-migrates v7 → v8 on open (spec §9, with a backup meta page). v1–v6 are ## Test Coverage -**1941 tests** (1926 passing, 15 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). +**1963 tests** (1947 passing, 16 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). See `docs/TEST_COVERAGE.md` for the full per-file breakdown. **Testing conventions** — see the Testing Conventions section below before writing any tests. @@ -228,7 +228,7 @@ See `docs/TEST_COVERAGE.md` for the full per-file breakdown. Current plan (see `ROADMAP.md` and the milestones): - **v2.x** (`main`, format v7) now gets only data-integrity and security fixes as patch releases (v2.0.3 is the first); v2.0.2 was the last planned v2.x release. - **v3.0.0** (format v8 and data integrity, plus `:limit` #306, optional `:distinct` output #493, `lag`/`lead` #182, sliding row frames #183, query profiler #185, set membership predicates #316 and prepared queries in every binding #181, UDF registration in every binding #180; tracker #383) is developed on the long-lived `v3` branch. All v3 PRs target `v3`; `main` stays untouched. CI runs on PRs to `v3` the same as on PRs to `main`. Do not merge `main` into `v3` routinely: `main` only gets backports of fixes already on `v3`. Shared CI and workflow changes land on both branches as separate PRs. Just before the v3.0.0 cut, merge `main` into `v3` once (merge commit; source conflicts resolved to `v3`, `main`'s v2.0.x CHANGELOG sections brought over) so the cut is a fast-forward. At the first v3 release, the current `main` is copied to `v2` and `v3` becomes the new `main`. -- **Input order (#641)** targets v3.0.0 in three slices: committed scalar Sort omission is implemented on `v3`; one-group count/count-distinct and partition-at-a-time windows remain pending. The reviewed design, fallback scope and acceptance gates are in `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. +- **Input order (#641)** targets v3.0.0 in three slices: committed scalar Sort omission is implemented on `v3`; one-group count/count-distinct is implemented on `v3`; partition-at-a-time windows remain pending. The reviewed design, fallback scope and acceptance gates are in `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - **v3.next** (the release after v3.0.0) holds new features (rule persistence #241; OPFS `BrowserDb` #441). - Known v2.x data issue: same-transaction multi-valued facts (#371). Fix ships in v3.0.0. All v2.x known issues are listed in pinned issue #421 (`known-issue` label); `data-integrity`/`corruption`/`durability` issues fixed in a v2.x patch stay open until that patch is published; issues fixed on the unreleased `v3` branch close on merge (closing keywords do not fire on `v3`, so close them with `gh issue close`) and stay listed in #421 (CONTRIBUTING.md). - Support policy and tiers: PHILOSOPHY.md §7 and §10. v2.x gets data-integrity and security fixes for 12 months after v3.0.0. Tier 1 = Rust + Python + browser WASM (from v3.0.0); other bindings are Tier 2. diff --git a/README.md b/README.md index 1230cf9a13..18005ee190 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ For example, `(lag ?salary :over (:partition-by ?dept :order-by ?hire-date))` re The unreleased v3.0.0 branch adds bounded sliding windows such as `(avg ?salary :over (:partition-by ?dept :order-by ?hire-date :rows 2 preceding))` (#183). -On v3.0.0, an ascending value-only query such as `[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]` can read directly in index order and stop early when all committed `:score` history has one value kind (integer, float, or Boolean) and its source range has no pending writes. A query whose full order cannot be proved uses the existing sort (#641). +On v3.0.0, an ascending value-only query such as `[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]` can read directly in index order and stop early when all committed `:score` history has one value kind (integer, float, or Boolean) and its source range has no pending writes. A query whose full order cannot be proved uses the existing sort (#641). Built-in `count` and `count-distinct` can also release completed groups when one committed integer/Boolean/float key is proved ordered (including mixed integer/float groups), with no `:with`, windows, callbacks or `collect-set`. Memory then follows the active group and batches; distinct members within one group still grow. Other aggregates keep full-input validation. **Status**: See [ROADMAP.md](ROADMAP.md) for planned work and current direction. diff --git a/ROADMAP.md b/ROADMAP.md index 60190c6224..41ea1a3cbd 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -98,7 +98,7 @@ Scope — query API: - Bounded sliding row frames, `:rows N preceding`, for window aggregates (#183; v3.0.0, implemented on `v3`; builds on #182) - Cursor API: `Minigraf::query` and `PreparedQuery::query` return an owned `Cursor` that delivers rows in batches, with the answer fixed at open (#432; Rust API done on `v3`). The binding cursor objects follow. Behind the cursor, the streaming engine (#473) runs every query and produces rows as they are pulled: patterns, expressions and pseudo-attributes (#544), joins and `:db/valid-at` (#545), `not` and `or` (#546), aggregates and windows (#547), rules (#548), and transaction reads (#550); the executor's query path is gone (#551; done on `v3`). Operators do not spill: memory follows operator state, with an opt-in per-query limit (`QRY-012`, #549). - Projected UUID lookup batches walk dense DICT ranges (#530; implemented on `v3`), keeping temporary memory bounded to a batch and query-cache charges in projection order. -- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). #641 targets v3.0.0 in three slices: snapshot-bound order proofs and Sort omission for committed scalar ranges, then one-group count/count-distinct and partition-at-a-time windows. The first slice is implemented on `v3`; aggregates and windows still buffer their full input pending the remaining slices. See `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. +- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). #641 targets v3.0.0 in three slices: snapshot-bound order proofs and Sort omission for committed scalar ranges, then one-group count/count-distinct and partition-at-a-time windows. Sort omission and one-group count/count-distinct are implemented on `v3`; partition-at-a-time windows remain pending. Streaming groups require a proved scalar grouping key and no `:with`, windows, callbacks or `collect-set`; other aggregates retain full-input validation. See `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - Fact-log iterator: `Minigraf::fact_log(&FactFilter)` streams every fact version (assertions and retractions, with `tx_count`, `tx_id` and valid-time bounds) in transaction order or storage order, filtered by attribute, attribute prefix, entity and tx range, with memory bounded by a window rather than the database (#430; Rust API done on `v3`). An open log pins its generation: checkpoints run but do not reuse its pages (#543; `API-013` deprecated). A raw log writer (#431) completes the extract-transform-load path; the binding objects follow with #462. - Read-only open: `OpenOptions::read_only` takes a shared lock, so several readers can hold a file at once, writes nothing to the file or its WAL (a WAL is applied in memory, a v7 file is read without migrating), and refuses writes with `API-014` (#429; Rust API done on `v3`). The bindings' `open_with_options` follows. - Raw log writer: `LogWriter` builds a new database from `FactRecord`s with their `tx_count`, `tx_id`, valid-time windows and assertion flags kept, gaps allowed (a purged transaction stays a hole for `:as-of`), at `.partial` renamed into place by `finish` (#431; Rust API done on `v3`). Completes extract (#429, #430), transform, load. The binding objects follow. diff --git a/benches/minigraf_bench.rs b/benches/minigraf_bench.rs index 411fa5b68f..fd63040e0e 100644 --- a/benches/minigraf_bench.rs +++ b/benches/minigraf_bench.rs @@ -232,6 +232,51 @@ fn bench_query(c: &mut Criterion) { } } +// Committed unique groups exercise both streaming count descriptors. The +// ordinary ^query/ nightly route includes full drains and bounded limits. +fn bench_ordered_groups(c: &mut Criterion) { + let mut group = c.benchmark_group("query/ordered_groups"); + group.sample_size(10); + for (label, n) in [ + ("1k", 1_000), + ("10k", 10_000), + ("100k", 100_000), + ("1m", 1_000_000), + ] { + for (mode, func, limited) in [ + ("count", "count", false), + ("distinct", "count-distinct", false), + ("count_limit", "count", true), + ("distinct_limit", "count-distinct", true), + ] { + group.bench_with_input(BenchmarkId::new(mode, label), &n, |b, &n| { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("groups.graph"); + helpers::populate_file(n, path.to_str().unwrap()); + let db = OpenOptions::new() + .read_only(true) + .path(&path) + .open() + .unwrap(); + let query = format!( + "(query [:find ?v ({func} ?e) :where [?e :val ?v] :order-by [?v] {}])", + if limited { ":limit 10" } else { "" } + ); + b.iter(|| { + let mut cursor = db.query(&query).unwrap(); + let mut rows = 0; + while let Some(batch) = cursor.next_batch(1000).unwrap() { + rows += batch.len(); + } + assert_eq!(rows, if limited { 10.min(n) } else { n }); + black_box(rows) + }); + }); + } + } + group.finish(); +} + // ── Task 6: time_travel/ ────────────────────────────────────────────────────── // The existing nightly ^query/ filter selects both the proven value order and @@ -2022,6 +2067,7 @@ criterion_group!( bench_insert_file, bench_query, bench_input_order, + bench_ordered_groups, bench_time_travel, bench_recursion, bench_negation, diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index 313581d150..7b982f25d1 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -2,6 +2,150 @@ This document records reproducible local benchmark snapshots. Completed release-performance history belongs in the [CHANGELOG](../CHANGELOG.md); continuous CI history is available on [Bencher](https://bencher.dev/perf/minigraf/plots). +## One-group count and distinct count (#641, slice 2, unreleased) + +**Date**: 2026-10-28 · **Parent**: slice 1 at `366f662df` · **Change**: #641, +second slice. The [build manifest](benchmarks/641-ordered-groups-build.json) +records the matched library, source, dependency-lock and probe fingerprints. +Both libraries use opt-level 3 (`--profile envelope`), frame pointers and Rust +1.99.1. The final appended native cache regression leaves the production library +byte-identical to the measured build. + +Six balanced rounds run on an idle bench, with CPU and memory bound together +and the nodes and execution order swapped each round. Each query has its own +process and a 256 KiB worker stack. One warmup precedes 3–20,000 timed drains +within a one-second budget (at least three for slow queries). Tables report the +median of six process medians and the maximum of six process RSS peaks. Open and +fixture construction are outside timing; fixtures are prebuilt and read-only. +The existing envelope/history guards use their unchanged probe (three warmups, +at least five timed drains per process). All six process samples per case are retained, including each median, range +and run count. + +The group fixture has exactly N committed facts: one integer `:group` per UUID +entity, `floor(i / 16)` for fixed groups. There are 6,250 / 62,500 / 625,000 groups +at 100K / 1M / 10M rows, each of size 16. Counts read `?e`; distinct counts read +its distinct entity ids. Each group-fixture probe checks the ordered group key and aggregate +value, as well as row count. The materialized `sum-distinct` control binds the +constant 1 and sums its distinct value per group, checking a result of 1. + +| Committed rows | Count full drain, ms (parent → change) | Distinct full drain, ms | Count limit 10, ms | Distinct limit 10, ms | +|---:|---:|---:|---:|---:| +| 100K | 50.395 → 48.880 | 63.671 → 60.007 | 48.157 → 0.652 | 60.922 → 0.762 | +| 1M | 555.213 → 484.644 | 753.668 → 597.925 | 520.168 → 0.645 | 713.856 → 0.755 | +| 10M | 7,397.820 → 4,925.882 | 10,111.836 → 6,042.124 | 6,951.004 → 0.644 | 9,522.604 → 0.758 | + +| Committed rows | Count full RSS, KiB (parent → change) | Distinct full RSS, KiB | Count limit RSS, KiB | Distinct limit RSS, KiB | +|---:|---:|---:|---:|---:| +| 100K | 10,080 → 5,072 | 13,416 → 5,052 | 9,912 → 3,840 | 13,460 → 3,816 | +| 1M | 59,664 → 5,040 | 87,888 → 5,008 | 56,648 → 3,848 | 87,972 → 3,812 | +| 10M | 500,376 → 5,188 | 904,552 → 5,204 | 506,456 → 3,816 | 894,320 → 3,860 | + +The bounded limit 10M/100K time ratios are **0.988** and **0.994**, below the 2x gate. Across the four fixed-group shapes, the largest 10M RSS increase over 100K is **152 KiB**, within the 16 MiB allowance. At 10M, full-drain count is **33.41%** faster and distinct count **40.25%** faster. All [252 grouped records](benchmarks/641-ordered-groups.jsonl) are retained. + +### Holder and early-stop gates + +| Committed rows | Count peak | Distinct-count peak | Active groups | Scan rows, limit 10 | +|---:|---:|---:|---:|---:| +| 100K | 480 B | 1,120 B | 1 | 1,024 | +| 1M | 480 B | 1,120 B | 1 | 1,024 | +| 10M | 480 B | 1,120 B | 1 | 1,024 | + +These are query-meter peaks, including IdSpace, from the +[24 diagnostic records](benchmarks/641-ordered-groups-meter.jsonl). Both count +modes release every completed group and retain no finished-results list. Zero +peak growth fits the 100K baseline plus two charged batches; the test computes +that allowance from `Batch`, `Vec` and `cell_bytes` for the fixture's two +columns, rather than a guessed byte count. The requested groups contain 160 rows; +1,024 reads fit 160 + `BATCH_ROWS`. A probe-join regression checks the same bound +at Aggregate's input (the join may also hold an outer batch). + +Input and output batches that pass within one operator pull follow the engine's +existing uncharged-batch convention. No batch is retained between calls by the +ordered Aggregate. The active group, distinct members, finish scratch and a +result row until it moves into the passing output batch remain charged. Internal +child-batch boundaries evict DICT lookup caches even when one group spans many +pulls; a targeted regression fails when that eviction is disabled. + +### A single growing group + +| Committed rows | Count peak | Distinct-count peak | +|---:|---:|---:| +| 100K | 480 B | 4,000,480 B | +| 1M | 480 B | 40,000,480 B | +| 10M | 480 B | 400,000,480 B | + +The linear distinct-member control is expected. A limit cannot finish this one +group before it has read every member. Other holders, provisional ids and final +sorting can still dominate query memory; mixed integer/float grouping keeps its +numeric Sort, and fallible aggregates retain full-input validation. + +| Committed rows | One-group count, ms (parent → change) | One-group distinct count, ms | Materialized sum-distinct control, ms | +|---:|---:|---:|---:| +| 100K | 39.487 → 44.752 | 53.622 → 58.114 | 61.088 → 62.489 | +| 1M | 401.147 → 447.729 | 639.518 → 674.656 | 679.843 → 690.527 | +| 10M | 4,066.914 → 4,519.806 | 6,921.283 → 7,348.321 | 7,344.431 → 7,553.146 | + +For one growing group, count is **11.14–13.33%** slower and distinct count **5.49–8.38%** slower. The ordered path checks its active key on every input row, and this control releases no completed groups until EOF. No cost-based strategy selection is added. The materialized sum-distinct control changes by **+1.57–2.84%**; its memory still grows with the number of groups. These costs are separate from the bounded-limit and ordinary-point gates. + +### Existing query guards and verification + +The ordinary envelope entity/exact-value/hot-point deltas are **−1.16% to +1.60%**. The exact #379 history guards have a worst delta of **+0.68%**, below 5%; all 12 workload/depth combinations pass. Full scan, plain limit, UUID-tie and descending top-k controls span **−2.40% to +2.41%**. The earlier ordered value limit/offset controls span **-3.24% to +0.32%**. The existing ordered selective-point startup cost remains visible separately: + +| Nominal envelope facts | Ordered point parent | Change | +|---:|---:|---:| +| 100K | 130.22 µs | 130.22 µs | +| 1M | 112.67 µs | 112.57 µs | +| 10M | 117.34 µs | 119.28 µs | + +The eight optional whole-attribute proof seeks are unchanged from slice 1. All [360 envelope/control records](benchmarks/641-ordered-groups-guards.jsonl) and [144 history records](benchmarks/641-ordered-groups-history.jsonl) are retained. No ordinary query without an applicable demand makes proof reads. + +The newly eligible grouped queries also pay that proof cost when there was no previous `:order-by`. On a one-row entity range: + +| Nominal envelope facts | Grouped count parent → change | Grouped distinct count parent → change | +|---:|---:|---:| +| 100K | 23.19 → 133.54 µs | 24.03 → 134.88 µs | +| 1M | 22.94 → 118.55 µs | 24.80 → 121.45 µs | +| 10M | 22.99 → 120.19 µs | 24.49 → 121.67 µs | + +These use `[:find ?a (count ?a) :where [:pM :age ?a]]` and its `count-distinct` variant, where M is the midpoint entity. EAVT remains selective, but the eight whole-attribute seeks add roughly **96–111 µs**. The [72 startup records](benchmarks/641-ordered-groups-startup.jsonl) use the unchanged guard probe (three warmups, at least five timed drains per process, six balanced process samples). A tiny group gets little benefit from releasing completed groups; there is no cost-based selection. This is reported separately from ordinary points with no applicable consumer demand. + +The final default test set is 1,947 passing / 16 ignored (the full instrumented +suite plus rustdoc and the appended filtered cache regression); with test-hooks, +1,980 pass / 17 are ignored. The full default and hooks runs preceded the final +native-only cache test, which passed separately in both configurations and was +added to the preserved coverage report. All unchanged floors pass: **95.40%** +lines / **86.38%** branches. Native, browser and WASI clippy pass; WASI has 1,179 +passing / 7 ignored tests, Firefox has 60 passing tests, and the WASI REPL builds +in release mode. Frozen answers are unchanged. The updated ignored million-group +acceptance test passes: ordered count fits its 32 MiB budget, while grouped `sum` +remains a materialized `QRY-012` control. + +The default release binary is **1,259,368 bytes**, below the unchanged +**1,259,520-byte** cap. This slice changes no storage/key encoding, dependency, +public API or file format. Window buffering is addressed by the third slice. + +### Reproduction and nightly routing + +Compile the [fixture builder](../scripts/input_order_group_fixture.rs) against +the parent library and the same [group probe](../scripts/input_order_group_probe.rs) +against both libraries, using the rustc/envelope flags in the slice-1 recipe. +Run `group_fixture N 16`, then, for example: + +```sh +group_probe groups.graph '(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])' 10 16 +``` + +Use group size N instead of 16 for the single-growing-group control. Build +fixtures in separate processes and alternate CPU/memory binding and library +execution order over six rounds. Raw records contain every complete query. + +All sixteen Criterion cases execute with +`cargo bench --bench minigraf_bench -- '^query/ordered_groups/' --test`: +`query/ordered_groups/{count,distinct,count_limit,distinct_limit}/{1k,10k,100k,1m}`. +The existing nightly `query` matrix's `^query/` route selects every new ID (#776). +Scheduled Bencher history is available after merge; none is claimed here. + + ## Proven input order and Sort omission (#641, slice 1, unreleased) **Date**: 2026-10-28 · **Base**: `v3` at `2abf53df` · **Change**: #641, @@ -120,8 +264,8 @@ change is needed. Scheduled Bencher history becomes available after merge. The ordinary release binary is **1,254,928 bytes**, below the unchanged **1,259,520-byte** cap (base: 1,258,784). Sharing the existing set/window sort comparators removes duplicate generated code while preserving their order. -This slice changes Sort selection only; grouped Aggregate and Window remain -full-input operators until the following #641 slices. +At this snapshot, only Sort selection changed; Aggregate and Window still +buffered their full input. The later #641 sections describe the other slices. ## Projected UUID lookup batching (#530, unreleased) diff --git a/docs/TEST_COVERAGE.md b/docs/TEST_COVERAGE.md index ca8efca31f..6f02d5fc5c 100644 --- a/docs/TEST_COVERAGE.md +++ b/docs/TEST_COVERAGE.md @@ -4,13 +4,13 @@ | | Default features | With `--features test-hooks` | |---|---|---| -| **Passing** | 1,926 | 1,959 | -| **Ignored** | 15 | 16 | -| **Total** | 1,941 | 1,975 | +| **Passing** | 1,947 | 1,980 | +| **Ignored** | 16 | 17 | +| **Total** | 1,963 | 1,997 | -**Verified**: 2026-10-28 on the designated bench machine: the full default suite under branch coverage plus `cargo test --doc`, and `cargo test --features test-hooks`. The final proof-read failure enhancement also passed a focused rerun. All unchanged coverage floors pass; measured overall coverage is 95.39% lines and 86.14% branches. +**Verified**: 2026-10-28 on the designated bench machine: the full default suite under branch coverage plus `cargo test --doc`, and `cargo test --features test-hooks`. Final test-only strengthening of group-demand and early-cursor assertions passed a focused rerun. An appended internal DICT-cache regression passed default/test-hooks checks and an incremental coverage run; disabling internal eviction made that regression fail. The matched production library remained byte-identical. All unchanged coverage floors pass; measured overall coverage is 95.40% lines and 86.38% branches. -#641 adds 30 tests with default features and one more with `test-hooks`. +#641 slice 1 adds 30 tests with default features and one more with `test-hooks`. Slice 2 adds 22 default-feature tests (21 active and one ignored committed-fixture memory diagnostic). #183 adds bounded row-frame parser, evaluator, and integration tests; one additional plan-independence case runs with `test-hooks`, including duplicate tie keys and NaN. A sliding-sum test checks recovery after integer saturation. Grammar corpus cases cover frame spellings and rejection. A meter test checks that a zero-width min frame reserves one deque slot. An ignored bench-machine diagnostic reproduces the Criterion datasets and prints the engine meter's peak for every measured case. @@ -28,6 +28,8 @@ Not counted above: the browser tests and the WASI run (see [Browser and WASI](#b - **Proven input order** (#641, first slice; `src/query/engine/order_tests.rs`, `order/tests.rs`, `tests/input_order_test.rs`): full result keys and projection slots, constants and repeated slots, integer/Boolean/float edge cases including NaNs and signed zeros, replacements, join fallback orientation and distinct canonicalization. Snapshot tests cover unrelated versus in-range pending/staged records, captured prefixes, temporal filters, prepared queries, checkpoints and large-transaction working readers including rejected statements and rollback. Counters establish early stopping, bounded raw proof reads and no reads without demand; optional proof-read errors leave the original plan. Late callback and `collect-set` errors retain their evaluation. A forced-fallback differential matrix checks identical ordered lists across plan switches. A committed `MemoryBackend` fixture runs on native, WASI and the browser. Storage tests cover every key kind/tag and raw seeks over retracted history. +- **One-group count aggregation** (#641, second slice; `src/query/engine/aggregate_order_tests.rs`, `order/tests.rs`, `engine/tests.rs`): count/count-distinct over one certified scalar group, cross-batch boundaries, unique-key Sort omission and retained descending/aggregate-first/mixed-numeric Sort, Boolean/float representatives and mixed numeric group order. Arbitrary argument kinds, nil, `:distinct`, offset/limit and probe joins match forced fallback. Tests cover no `:with`/window/multiple-key eligibility, later fallible-aggregate/callback/collect-set errors and dropped-group precedence, pending/staged/prepared/working-reader changes and rejected statements, atomic fallback on every optional proof-read failure, bounded group state with one active group, internal DICT-cache eviction within one group spanning many probe batches, a growing distinct-group control, low budgets, allocator refusal, close/drop/rewind, and defensive `INT-032` for injected decreasing input before and after an answer batch. A committed `MemoryBackend` fixture also runs under WASI and in the browser. + - **Bounded row frames** (`tests/window_functions_test.rs`, `src/query/datalog/aggregate/tests.rs`, #183): `:rows N preceding` parsing and errors, physical rows with tied order keys, partition reset, descending order, width zero and maximum, all five built-in aggregates against a replay oracle with numeric edge cases, UDFs through prepared queries and cursors, grouping with `:with`, distinct output, memory-limit refusal for long min/max strings, and final `:order-by` matching. A `test-hooks` case checks answer bags with clause reordering on and off. - **Optional distinct output** (`tests/distinct_test.rs`, #493): bag defaults, whole tuples, section syntax, cross-batch and committed/pending values, chunked write transactions, prepared execute/cursors, joins/rules/disjunction, aggregates and hidden `:with` groups, window peers and partitioned row numbers, temporal filters, typed equality and canonical float/set output, memory limits (including retained set payloads) and cursor cleanup. A meter unit test verifies each cell/key/value estimate includes set elements and their strings. With `test-hooks`, checks both reorder settings and hashed/correlated subplans. An engine unit test checks counters and state release. @@ -488,8 +490,8 @@ These tests compare the database against an independent answer rather than a sin None of these are counted in the summary. The wasm32 targets run in CI (`.github/workflows/wasm.yml`). -- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 59 `wasm_bindgen_test` tests. The final #641 snapshot passed in headless Firefox on the bench; Chrome remains a CI run. - - One committed-memory-backend input-order fixture, including scalar edge cases and verification that Sort is omitted (#641). +- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 60 `wasm_bindgen_test` tests. The final #641 snapshot passed in headless Firefox on the bench; Chrome remains a CI run. + - Two committed-memory-backend input-order fixtures: scalar Sort omission, and streaming counts with Boolean/float representatives and mixed numeric group order (#641). - Twenty-five for `BrowserDb`, including IndexedDB persistence, the cursor, and the flush returning every dirty page and failing on one it cannot read (#470). - Eleven for `BrowserBufferBackend` (which used `#[test]` and never ran before). - Two checking that IndexedDB page keys accept only whole numbers from 0 to 2^53. @@ -505,11 +507,11 @@ None of these are counted in the summary. The wasm32 targets run in CI (`.github - `importGraph()` deletes the replaced database's IndexedDB keys. - Two buffer tests check that releasing a page drops its bytes and any unflushed write, and that export writes a released page as zeros. - A native storage test checks that a file whose free pages are all zeros (as the browser exports them), both just migrated from v7 and after 20 saves, opens, verifies clean and keeps committing. The free-list test checks that a checkpoint reports exactly the ids it newly lists. -- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,177 passing and seven ignored in the 2026-10-28 bench run with Wasmtime v49.0.2 (`wasm.yml`). The committed input-order fixture runs here too, and the WASI REPL builds in release mode. +- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,179 passing and seven ignored in the 2026-10-28 bench run with Wasmtime v49.0.2 (`wasm.yml`). Both committed input-order fixtures run here too, and the WASI REPL builds in release mode. ## Ignored Tests -The fifteen ignored tests (sixteen with `test-hooks`) are intentionally excluded from a normal local run: +The sixteen ignored tests (seventeen with `test-hooks`) are intentionally excluded from a normal local run: - Four rustdoc examples that reference internal types and cannot compile as standalone examples. - One high-contention concurrency stress test intended for scheduled runs. @@ -518,12 +520,13 @@ The fifteen ignored tests (sixteen with `test-hooks`) are intentionally excluded - One size test at 1.15M facts (`size_per_fact_in_433_shape_1m`), run by the nightly smoke workflow. - One recursive-rule acceptance test (`reach_5m`, #548), run by the nightly smoke workflow: a layered graph whose `reach` rule derives 4,882,500 facts in 62 rounds must return them all with peak RSS under 256 bytes per derived fact, and the default `max_derived_facts` must stop the same rule with `INT-020`. - Three query-memory acceptance tests (`tests/memory_limit_acceptance_test.rs`, #549, #575, #551), run one at a time by the nightly smoke workflow: - - 1M aggregate groups return 1M rows, and with `query_memory_limit` at 32 MiB stop with `QRY-012` naming `Aggregate`, after which the database answers; + - 1M ordered count groups return 1M rows under a 32 MiB `query_memory_limit`; the fallible grouped `sum` control still stops with `QRY-012` naming `Aggregate`, after which the database answers; - 13 patterns sharing no variable over the fuzz harness's 3 facts stream 3^13 rows with peak RSS under 64 MiB, and with a 64-byte limit stop with `QRY-012` naming `HashJoin`; - `count` over every one of 1M facts counts them under a 4 KiB `query_memory_limit` (`count_holds_no_rows`, the #473 constant-memory `count` item). - One `:limit` and top-k acceptance test (`tests/limit_acceptance_test.rs`, #306, the #473 `:limit` item), run by the nightly smoke workflow over one 10M-fact fixture written with `LogWriter`: `:limit 10` returns 10 rows in under 250 ms under a 64 KiB `query_memory_limit`, adding under 32 MiB of peak RSS; `:order-by [?v :desc] :limit 10` returns the ten largest values under a 1 MiB limit, adding under 32 MiB. - One large-transaction acceptance test (`tests/large_transaction_acceptance_test.rs`, #550; `test-hooks` only), run by the nightly smoke workflow (see [Large transactions](#large-transactions-550)). - One measurement test (`meter_peak_against_rss`, `src/query/engine/tests.rs`, #549): prints the meter's peak against the peak RSS for the same two shapes, opening the engine directly. +- One committed-group measurement test (`committed_group_memory_probe`, `src/query/engine/aggregate_order_tests.rs`, #641): opens prebuilt fixed-size and growing-group fixtures, drains count/count-distinct with and without a limit, and prints meter peaks, active-group high-water and input counts. - One row-frame measurement test (`window_rows_benchmark_meter_peaks`, `src/query/engine/tests.rs`, #183): prints metered peaks for the window benchmark fixtures. ## Reproducing diff --git a/docs/benchmarks/641-ordered-groups-build.json b/docs/benchmarks/641-ordered-groups-build.json new file mode 100644 index 0000000000..41a5dc53c0 --- /dev/null +++ b/docs/benchmarks/641-ordered-groups-build.json @@ -0,0 +1,87 @@ +{ + "executed_benchmark_ids": [ + "query/ordered_groups/count/1k", + "query/ordered_groups/count/10k", + "query/ordered_groups/count/100k", + "query/ordered_groups/count/1m", + "query/ordered_groups/distinct/1k", + "query/ordered_groups/distinct/10k", + "query/ordered_groups/distinct/100k", + "query/ordered_groups/distinct/1m", + "query/ordered_groups/count_limit/1k", + "query/ordered_groups/count_limit/10k", + "query/ordered_groups/count_limit/100k", + "query/ordered_groups/count_limit/1m", + "query/ordered_groups/distinct_limit/1k", + "query/ordered_groups/distinct_limit/10k", + "query/ordered_groups/distinct_limit/100k", + "query/ordered_groups/distinct_limit/1m" + ], + "nightly_filter": "^query/", + "parent_commit": "366f662df9c443f4c922741c7c0998791d722bb0", + "parent_library_sha256": "1ee5ddc54f1a08611a4f8e782eca79844f589c782114d11bcc1fa957abb5ee4d", + "grouped_library_sha256": "419def4308e7cfc61cb4fa7f0572d0751713a50dab6a89c1cf8939ee91f78faf", + "lock_sha256": "b03965119fd8ce5b5cf3ad3d37fb194ffeae24b6a862a0c85ae8fbcb6833ee77", + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "source_sha256": "92a7034ad99ac3895e455a20be5321bfdc1540a3df8d8cf40fd6a375a58a3216", + "probe_sha256": "1556da034f89fb908719238a53011464d775df5b943b3d80426b0f68562d812f", + "fixture_builder_sha256": "2498b51719a8db20cba0c110b66ba3fdf71a82c08508b3183bb1b5b1892e26a2", + "release_bytes": 1259368, + "source_sha256_before_appended_cache_test": "6facfdee30aa6625c943ff0fc8851d8ba8d342e9149f72b58ed3234e50b45b87", + "library_identical_after_appended_native_cache_test": true, + "binaries": { + "parent-input_order_probe": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", + "grouped-input_order_probe": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", + "parent-input_order_group_probe": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", + "grouped-input_order_group_probe": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb" + }, + "fixtures": { + "groups-fixed-100k": { + "facts": 100000, + "rows_per_group": 16, + "groups": 6250, + "file_bytes": 9183232 + }, + "groups-fixed-10m": { + "facts": 10000000, + "rows_per_group": 16, + "groups": 625000, + "file_bytes": 989159424 + }, + "groups-fixed-1m": { + "facts": 1000000, + "rows_per_group": 16, + "groups": 62500, + "file_bytes": 95412224 + }, + "groups-growing-100k": { + "facts": 100000, + "rows_per_group": 100000, + "groups": 1, + "file_bytes": 8622080 + }, + "groups-growing-10m": { + "facts": 10000000, + "rows_per_group": 10000000, + "groups": 1, + "file_bytes": 905240576 + }, + "groups-growing-1m": { + "facts": 1000000, + "rows_per_group": 1000000, + "groups": 1, + "file_bytes": 89563136 + } + }, + "release_sha256": "b20a8cb4eb5bb0cc7fd44960d154138a5e256eab3df8cf9d8d359e4127381e8b", + "parent_source_sha256": "a59a39766f2db679f231e22bd2a0290d687b7939470bcca0abbfa0d06c59bd15", + "guard_probe_source_sha256": "103ea1adc656505c2c3c086c5747bbaf75e0a77bc283e60320030944bccf10f1", + "history_fixture_builder_sha256": "faa6be9e273eedb9a12120cc1367369d2e662d71c8d92e333c15d0f1b3bcb92b", + "process_samples_per_case": 6, + "group_warmups_per_process": 1, + "group_min_timed_drains_per_process": 3, + "guard_warmups_per_process": 3, + "guard_min_timed_drains_per_process": 5, + "selective_group_startup_records": 72, + "selective_group_startup_probe": "guard" +} diff --git a/docs/benchmarks/641-ordered-groups-guards.jsonl b/docs/benchmarks/641-ordered-groups-guards.jsonl new file mode 100644 index 0000000000..96e13cf233 --- /dev/null +++ b/docs/benchmarks/641-ordered-groups-guards.jsonl @@ -0,0 +1,360 @@ +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2174, "median_us": 451.105, "min_us": 438.904, "max_us": 1441.016, "rows": 10, "peak_rss_kb": 3756} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2132, "median_us": 462.73, "min_us": 446.955, "max_us": 1453.086, "rows": 10, "peak_rss_kb": 3704} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2120, "median_us": 460.359, "min_us": 444.303, "max_us": 4534.18, "rows": 10, "peak_rss_kb": 3676} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2202, "median_us": 447.628, "min_us": 437.936, "max_us": 1418.224, "rows": 10, "peak_rss_kb": 3744} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7508, "median_us": 130.142, "min_us": 129.065, "max_us": 420.035, "rows": 1, "peak_rss_kb": 3684} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7453, "median_us": 129.709, "min_us": 128.282, "max_us": 2205.911, "rows": 1, "peak_rss_kb": 3736} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.246, "min_us": 18.823, "max_us": 87.174, "rows": 1, "peak_rss_kb": 3880} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.193, "min_us": 18.45, "max_us": 97.739, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.896, "min_us": 18.469, "max_us": 83.512, "rows": 1, "peak_rss_kb": 3820} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.244, "min_us": 18.701, "max_us": 83.552, "rows": 1, "peak_rss_kb": 3828} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3067, "median_us": 319.755, "min_us": 316.322, "max_us": 1020.588, "rows": 1, "peak_rss_kb": 3704} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3044, "median_us": 318.72, "min_us": 315.569, "max_us": 3834.861, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13468.59, "min_us": 13412.986, "max_us": 14033.883, "rows": 16666, "peak_rss_kb": 4864} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13504.811, "min_us": 13464.254, "max_us": 13812.005, "rows": 16666, "peak_rss_kb": 4984} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2805, "median_us": 343.859, "min_us": 333.382, "max_us": 3855.206, "rows": 10, "peak_rss_kb": 3768} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2718, "median_us": 361.275, "min_us": 351.026, "max_us": 1178.472, "rows": 10, "peak_rss_kb": 3812} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25527.374, "min_us": 25245.911, "max_us": 32607.654, "rows": 10, "peak_rss_kb": 4808} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25703.118, "min_us": 25517.871, "max_us": 27109.745, "rows": 10, "peak_rss_kb": 4804} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25594.886, "min_us": 25329.208, "max_us": 29662.724, "rows": 10, "peak_rss_kb": 4784} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25668.722, "min_us": 25484.647, "max_us": 35171.486, "rows": 10, "peak_rss_kb": 4796} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2159, "median_us": 456.291, "min_us": 450.048, "max_us": 1471.937, "rows": 10, "peak_rss_kb": 3732} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2196, "median_us": 448.711, "min_us": 428.473, "max_us": 1408.355, "rows": 10, "peak_rss_kb": 3788} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2090, "median_us": 446.839, "min_us": 423.999, "max_us": 34469.471, "rows": 10, "peak_rss_kb": 3724} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2193, "median_us": 448.301, "min_us": 431.152, "max_us": 1430.282, "rows": 10, "peak_rss_kb": 3828} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8661, "median_us": 112.548, "min_us": 111.511, "max_us": 375.988, "rows": 1, "peak_rss_kb": 3752} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8566, "median_us": 112.55, "min_us": 111.734, "max_us": 1517.047, "rows": 1, "peak_rss_kb": 3740} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.405, "min_us": 18.84, "max_us": 85.921, "rows": 1, "peak_rss_kb": 3816} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.93, "min_us": 19.41, "max_us": 93.088, "rows": 1, "peak_rss_kb": 3880} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.966, "min_us": 17.025, "max_us": 79.727, "rows": 1, "peak_rss_kb": 3800} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.234, "min_us": 17.001, "max_us": 106.603, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3013, "median_us": 324.736, "min_us": 320.512, "max_us": 1018.594, "rows": 1, "peak_rss_kb": 3676} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3079, "median_us": 316.989, "min_us": 313.187, "max_us": 4923.97, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 142196.523, "min_us": 140999.147, "max_us": 143153.972, "rows": 166666, "peak_rss_kb": 5360} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 138856.312, "min_us": 137112.87, "max_us": 139590.747, "rows": 166666, "peak_rss_kb": 5304} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2627, "median_us": 372.79, "min_us": 352.988, "max_us": 1205.699, "rows": 10, "peak_rss_kb": 3776} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2665, "median_us": 364.551, "min_us": 346.436, "max_us": 4277.343, "rows": 10, "peak_rss_kb": 3828} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269405.648, "min_us": 266442.069, "max_us": 271029.537, "rows": 10, "peak_rss_kb": 5044} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270684.604, "min_us": 268578.651, "max_us": 274299.27, "rows": 10, "peak_rss_kb": 5048} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 269150.652, "min_us": 268586.294, "max_us": 276349.801, "rows": 10, "peak_rss_kb": 5044} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 271146.549, "min_us": 267839.226, "max_us": 272737.154, "rows": 10, "peak_rss_kb": 4976} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2135, "median_us": 456.293, "min_us": 449.001, "max_us": 4543.375, "rows": 10, "peak_rss_kb": 3728} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2144, "median_us": 459.325, "min_us": 450.639, "max_us": 1454.529, "rows": 10, "peak_rss_kb": 3712} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2159, "median_us": 458.302, "min_us": 452.146, "max_us": 1440.088, "rows": 10, "peak_rss_kb": 3744} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2214, "median_us": 439.72, "min_us": 422.271, "max_us": 4740.126, "rows": 10, "peak_rss_kb": 3824} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8301, "median_us": 117.418, "min_us": 114.223, "max_us": 378.56, "rows": 1, "peak_rss_kb": 3820} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8214, "median_us": 118.658, "min_us": 114.818, "max_us": 380.916, "rows": 1, "peak_rss_kb": 3828} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.759, "min_us": 19.159, "max_us": 19614.106, "rows": 1, "peak_rss_kb": 3780} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.57, "min_us": 18.979, "max_us": 77.408, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.004, "min_us": 17.265, "max_us": 78.27, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.82, "min_us": 18.075, "max_us": 85.507, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3050, "median_us": 321.569, "min_us": 316.599, "max_us": 1028.441, "rows": 1, "peak_rss_kb": 3704} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3010, "median_us": 323.812, "min_us": 315.899, "max_us": 3519.53, "rows": 1, "peak_rss_kb": 3768} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1405773.647, "min_us": 1399838.36, "max_us": 1411707.532, "rows": 1666666, "peak_rss_kb": 5296} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1462966.698, "min_us": 1457896.034, "max_us": 1472902.75, "rows": 1666666, "peak_rss_kb": 5268} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2513, "median_us": 372.564, "min_us": 355.457, "max_us": 42571.016, "rows": 10, "peak_rss_kb": 3780} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2639, "median_us": 374.505, "min_us": 357.665, "max_us": 1167.065, "rows": 10, "peak_rss_kb": 3764} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2783745.448, "min_us": 2771914.203, "max_us": 2836956.995, "rows": 10, "peak_rss_kb": 5008} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2858493.771, "min_us": 2828440.525, "max_us": 2871310.619, "rows": 10, "peak_rss_kb": 5028} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2795518.225, "min_us": 2770519.819, "max_us": 2819177.615, "rows": 10, "peak_rss_kb": 5060} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2869263.799, "min_us": 2834880.358, "max_us": 2903450.009, "rows": 10, "peak_rss_kb": 5072} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2140, "median_us": 452.359, "min_us": 441.475, "max_us": 1440.55, "rows": 10, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2141, "median_us": 455.321, "min_us": 446.282, "max_us": 3881.792, "rows": 10, "peak_rss_kb": 3720} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2166, "median_us": 453.705, "min_us": 444.702, "max_us": 1476.581, "rows": 10, "peak_rss_kb": 3748} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2125, "median_us": 464.982, "min_us": 457.028, "max_us": 1448.455, "rows": 10, "peak_rss_kb": 3744} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7438, "median_us": 130.35, "min_us": 128.824, "max_us": 1515.128, "rows": 1, "peak_rss_kb": 3700} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7537, "median_us": 129.79, "min_us": 128.832, "max_us": 420.295, "rows": 1, "peak_rss_kb": 3784} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.839, "min_us": 19.09, "max_us": 108.575, "rows": 1, "peak_rss_kb": 3884} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.861, "min_us": 18.296, "max_us": 88.774, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.505, "min_us": 19.094, "max_us": 95.03, "rows": 1, "peak_rss_kb": 3828} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.211, "min_us": 18.647, "max_us": 711.782, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3030, "median_us": 323.626, "min_us": 319.878, "max_us": 1020.786, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2996, "median_us": 326.744, "min_us": 322.084, "max_us": 1023.57, "rows": 1, "peak_rss_kb": 3708} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13333.257, "min_us": 13266.997, "max_us": 20988.076, "rows": 16666, "peak_rss_kb": 4924} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13592.879, "min_us": 13563.091, "max_us": 13883.064, "rows": 16666, "peak_rss_kb": 5020} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2730, "median_us": 361.222, "min_us": 343.297, "max_us": 1179.003, "rows": 10, "peak_rss_kb": 3840} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2669, "median_us": 366.054, "min_us": 351.182, "max_us": 3300.121, "rows": 10, "peak_rss_kb": 3796} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25713.662, "min_us": 25509.625, "max_us": 26544.673, "rows": 10, "peak_rss_kb": 4896} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25495.07, "min_us": 25255.536, "max_us": 26797.221, "rows": 10, "peak_rss_kb": 4796} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25683.632, "min_us": 25521.732, "max_us": 32882.804, "rows": 10, "peak_rss_kb": 4856} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25689.903, "min_us": 25459.336, "max_us": 25938.567, "rows": 10, "peak_rss_kb": 4796} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2160, "median_us": 452.699, "min_us": 443.425, "max_us": 1441.261, "rows": 10, "peak_rss_kb": 3696} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2145, "median_us": 454.304, "min_us": 446.749, "max_us": 3896.043, "rows": 10, "peak_rss_kb": 3732} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2274, "median_us": 427.962, "min_us": 418.137, "max_us": 1444.963, "rows": 10, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2162, "median_us": 454.091, "min_us": 445.095, "max_us": 1452.505, "rows": 10, "peak_rss_kb": 3732} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8618, "median_us": 112.318, "min_us": 111.298, "max_us": 2085.818, "rows": 1, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8674, "median_us": 112.555, "min_us": 111.502, "max_us": 381.3, "rows": 1, "peak_rss_kb": 3656} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.138, "min_us": 18.644, "max_us": 91.448, "rows": 1, "peak_rss_kb": 3788} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.243, "min_us": 18.709, "max_us": 123.99, "rows": 1, "peak_rss_kb": 3872} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.609, "min_us": 16.649, "max_us": 78.884, "rows": 1, "peak_rss_kb": 3832} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.8, "min_us": 16.69, "max_us": 711.724, "rows": 1, "peak_rss_kb": 3812} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3061, "median_us": 322.063, "min_us": 315.092, "max_us": 1060.95, "rows": 1, "peak_rss_kb": 3604} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3043, "median_us": 323.022, "min_us": 314.927, "max_us": 1031.869, "rows": 1, "peak_rss_kb": 3696} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140590.239, "min_us": 138475.77, "max_us": 148778.736, "rows": 166666, "peak_rss_kb": 5260} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141449.881, "min_us": 139513.608, "max_us": 143710.876, "rows": 166666, "peak_rss_kb": 5356} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2521, "median_us": 374.349, "min_us": 367.142, "max_us": 29234.96, "rows": 10, "peak_rss_kb": 3800} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2589, "median_us": 380.939, "min_us": 374.256, "max_us": 1202.756, "rows": 10, "peak_rss_kb": 3748} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269501.582, "min_us": 268337.601, "max_us": 278194.241, "rows": 10, "peak_rss_kb": 5004} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 268125.5, "min_us": 265882.759, "max_us": 270491.681, "rows": 10, "peak_rss_kb": 5072} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 271578.62, "min_us": 268650.607, "max_us": 273088.518, "rows": 10, "peak_rss_kb": 5020} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268366.8, "min_us": 267779.288, "max_us": 277741.338, "rows": 10, "peak_rss_kb": 4932} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2159, "median_us": 455.688, "min_us": 446.464, "max_us": 1447.683, "rows": 10, "peak_rss_kb": 3752} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2154, "median_us": 455.654, "min_us": 429.065, "max_us": 3854.904, "rows": 10, "peak_rss_kb": 3712} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2230, "median_us": 447.409, "min_us": 424.758, "max_us": 625.202, "rows": 10, "peak_rss_kb": 3756} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2184, "median_us": 455.052, "min_us": 428.212, "max_us": 1411.278, "rows": 10, "peak_rss_kb": 3784} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8185, "median_us": 119.401, "min_us": 113.815, "max_us": 1473.384, "rows": 1, "peak_rss_kb": 3744} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8218, "median_us": 118.539, "min_us": 114.672, "max_us": 380.693, "rows": 1, "peak_rss_kb": 3720} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.105, "min_us": 18.538, "max_us": 83.739, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.348, "min_us": 18.746, "max_us": 83.685, "rows": 1, "peak_rss_kb": 3812} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.362, "min_us": 17.49, "max_us": 78.239, "rows": 1, "peak_rss_kb": 3828} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.441, "min_us": 17.364, "max_us": 99.347, "rows": 1, "peak_rss_kb": 3728} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3035, "median_us": 320.454, "min_us": 315.148, "max_us": 3064.915, "rows": 1, "peak_rss_kb": 3728} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3041, "median_us": 323.416, "min_us": 316.796, "max_us": 1022.103, "rows": 1, "peak_rss_kb": 3676} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1404401.054, "min_us": 1402389.904, "max_us": 1446777.654, "rows": 1666666, "peak_rss_kb": 5356} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1474150.017, "min_us": 1464244.827, "max_us": 1476202.632, "rows": 1666666, "peak_rss_kb": 5392} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2670, "median_us": 367.844, "min_us": 351.905, "max_us": 1157.346, "rows": 10, "peak_rss_kb": 3720} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2691, "median_us": 366.437, "min_us": 343.202, "max_us": 1158.847, "rows": 10, "peak_rss_kb": 3776} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2798006.202, "min_us": 2784339.094, "max_us": 2830529.07, "rows": 10, "peak_rss_kb": 5192} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2821762.753, "min_us": 2802976.978, "max_us": 2851934.056, "rows": 10, "peak_rss_kb": 5024} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2830075.453, "min_us": 2820325.349, "max_us": 2872770.361, "rows": 10, "peak_rss_kb": 5080} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2819252.45, "min_us": 2810922.212, "max_us": 2853056.569, "rows": 10, "peak_rss_kb": 5008} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2136, "median_us": 458.431, "min_us": 437.053, "max_us": 3906.909, "rows": 10, "peak_rss_kb": 3744} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2166, "median_us": 454.561, "min_us": 438.998, "max_us": 1441.939, "rows": 10, "peak_rss_kb": 3732} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2150, "median_us": 459.008, "min_us": 445.287, "max_us": 1483.487, "rows": 10, "peak_rss_kb": 3756} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2147, "median_us": 452.78, "min_us": 445.05, "max_us": 4576.649, "rows": 10, "peak_rss_kb": 3824} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7538, "median_us": 129.681, "min_us": 128.078, "max_us": 421.709, "rows": 1, "peak_rss_kb": 3732} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7522, "median_us": 130.117, "min_us": 129.02, "max_us": 450.85, "rows": 1, "peak_rss_kb": 3788} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.072, "min_us": 18.463, "max_us": 753.94, "rows": 1, "peak_rss_kb": 3772} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.459, "min_us": 18.855, "max_us": 86.113, "rows": 1, "peak_rss_kb": 3736} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.833, "min_us": 18.429, "max_us": 84.063, "rows": 1, "peak_rss_kb": 3804} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.093, "min_us": 18.57, "max_us": 98.939, "rows": 1, "peak_rss_kb": 3880} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3010, "median_us": 326.406, "min_us": 321.847, "max_us": 1034.505, "rows": 1, "peak_rss_kb": 3752} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3017, "median_us": 323.406, "min_us": 316.001, "max_us": 3178.03, "rows": 1, "peak_rss_kb": 3668} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 73, "median_us": 13468.692, "min_us": 13415.13, "max_us": 15874.194, "rows": 16666, "peak_rss_kb": 4864} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13302.136, "min_us": 13248.937, "max_us": 13774.829, "rows": 16666, "peak_rss_kb": 4884} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2669, "median_us": 367.193, "min_us": 348.438, "max_us": 3891.11, "rows": 10, "peak_rss_kb": 3784} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2758, "median_us": 355.1, "min_us": 339.568, "max_us": 1169.066, "rows": 10, "peak_rss_kb": 3840} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25555.368, "min_us": 25439.301, "max_us": 25738.146, "rows": 10, "peak_rss_kb": 4820} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25728.438, "min_us": 25582.502, "max_us": 34200.879, "rows": 10, "peak_rss_kb": 4752} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25494.801, "min_us": 25313.616, "max_us": 27274.247, "rows": 10, "peak_rss_kb": 4836} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25718.1, "min_us": 25477.115, "max_us": 26058.802, "rows": 10, "peak_rss_kb": 4804} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2159, "median_us": 450.3, "min_us": 443.12, "max_us": 4629.945, "rows": 10, "peak_rss_kb": 3704} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2213, "median_us": 445.423, "min_us": 429.489, "max_us": 1403.52, "rows": 10, "peak_rss_kb": 3704} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2137, "median_us": 460.548, "min_us": 453.706, "max_us": 1499.211, "rows": 10, "peak_rss_kb": 3716} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2198, "median_us": 422.892, "min_us": 415.975, "max_us": 39840.054, "rows": 10, "peak_rss_kb": 3764} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8652, "median_us": 112.364, "min_us": 111.343, "max_us": 383.405, "rows": 1, "peak_rss_kb": 3696} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8683, "median_us": 112.391, "min_us": 111.474, "max_us": 375.717, "rows": 1, "peak_rss_kb": 3772} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.779, "min_us": 19.348, "max_us": 761.474, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.03, "min_us": 18.499, "max_us": 83.439, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.084, "min_us": 16.969, "max_us": 95.905, "rows": 1, "peak_rss_kb": 3800} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.046, "min_us": 17.089, "max_us": 94.853, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3038, "median_us": 323.275, "min_us": 319.17, "max_us": 1064.525, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3055, "median_us": 318.067, "min_us": 312.706, "max_us": 3233.245, "rows": 1, "peak_rss_kb": 3760} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140836.922, "min_us": 140676.84, "max_us": 141920.715, "rows": 166666, "peak_rss_kb": 5252} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139806.414, "min_us": 138882.478, "max_us": 149309.664, "rows": 166666, "peak_rss_kb": 5248} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2603, "median_us": 375.602, "min_us": 370.26, "max_us": 1194.747, "rows": 10, "peak_rss_kb": 3804} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2680, "median_us": 363.22, "min_us": 345.987, "max_us": 1195.99, "rows": 10, "peak_rss_kb": 3816} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269055.524, "min_us": 267129.598, "max_us": 282594.692, "rows": 10, "peak_rss_kb": 5068} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270165.411, "min_us": 269254.329, "max_us": 280876.189, "rows": 10, "peak_rss_kb": 5004} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268617.954, "min_us": 265374.484, "max_us": 276925.021, "rows": 10, "peak_rss_kb": 5028} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 279232.172, "min_us": 277023.745, "max_us": 279891.554, "rows": 10, "peak_rss_kb": 4956} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2125, "median_us": 459.351, "min_us": 449.959, "max_us": 4910.341, "rows": 10, "peak_rss_kb": 3748} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2178, "median_us": 450.239, "min_us": 442.163, "max_us": 1450.771, "rows": 10, "peak_rss_kb": 3752} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2135, "median_us": 461.245, "min_us": 454.329, "max_us": 1544.737, "rows": 10, "peak_rss_kb": 3716} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2148, "median_us": 454.022, "min_us": 444.564, "max_us": 4554.935, "rows": 10, "peak_rss_kb": 3700} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8163, "median_us": 117.179, "min_us": 113.371, "max_us": 387.395, "rows": 1, "peak_rss_kb": 3696} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8178, "median_us": 120.9, "min_us": 114.135, "max_us": 388.48, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 21.763, "min_us": 21.029, "max_us": 99.136, "rows": 1, "peak_rss_kb": 3840} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.378, "min_us": 18.748, "max_us": 20452.021, "rows": 1, "peak_rss_kb": 3892} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.942, "min_us": 17.295, "max_us": 77.294, "rows": 1, "peak_rss_kb": 3876} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.631, "min_us": 17.814, "max_us": 80.802, "rows": 1, "peak_rss_kb": 3740} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2984, "median_us": 329.65, "min_us": 323.191, "max_us": 1061.244, "rows": 1, "peak_rss_kb": 3704} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3018, "median_us": 323.16, "min_us": 315.789, "max_us": 3784.763, "rows": 1, "peak_rss_kb": 3764} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1410169.576, "min_us": 1392613.564, "max_us": 1422164.796, "rows": 1666666, "peak_rss_kb": 5492} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1440660.325, "min_us": 1433670.773, "max_us": 1449924.078, "rows": 1666666, "peak_rss_kb": 5400} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2683, "median_us": 365.575, "min_us": 355.453, "max_us": 1187.005, "rows": 10, "peak_rss_kb": 3856} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2568, "median_us": 363.15, "min_us": 340.259, "max_us": 41025.722, "rows": 10, "peak_rss_kb": 3792} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2799305.52, "min_us": 2768396.697, "max_us": 2822934.635, "rows": 10, "peak_rss_kb": 5076} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2873355.865, "min_us": 2816430.339, "max_us": 2882629.669, "rows": 10, "peak_rss_kb": 5132} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2969044.276, "min_us": 2903730.337, "max_us": 3026961.672, "rows": 10, "peak_rss_kb": 5028} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2830258.599, "min_us": 2815619.209, "max_us": 2863495.052, "rows": 10, "peak_rss_kb": 5048} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2018, "median_us": 465.965, "min_us": 446.1, "max_us": 1446.397, "rows": 10, "peak_rss_kb": 3692} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2123, "median_us": 458.598, "min_us": 448.338, "max_us": 4558.268, "rows": 10, "peak_rss_kb": 3764} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2006, "median_us": 463.058, "min_us": 448.933, "max_us": 1435.017, "rows": 10, "peak_rss_kb": 3692} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2146, "median_us": 459.103, "min_us": 446.734, "max_us": 1450.827, "rows": 10, "peak_rss_kb": 3716} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 6967, "median_us": 130.435, "min_us": 128.757, "max_us": 1488.999, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 6970, "median_us": 140.362, "min_us": 137.886, "max_us": 459.655, "rows": 1, "peak_rss_kb": 3668} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.672, "min_us": 18.879, "max_us": 98.233, "rows": 1, "peak_rss_kb": 3828} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 20.496, "min_us": 19.664, "max_us": 98.731, "rows": 1, "peak_rss_kb": 3772} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.02, "min_us": 18.468, "max_us": 120.587, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.928, "min_us": 18.491, "max_us": 742.329, "rows": 1, "peak_rss_kb": 3796} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2828, "median_us": 325.005, "min_us": 319.139, "max_us": 1012.24, "rows": 1, "peak_rss_kb": 3764} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3021, "median_us": 324.76, "min_us": 321.387, "max_us": 1052.715, "rows": 1, "peak_rss_kb": 3756} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 69, "median_us": 14470.537, "min_us": 13783.995, "max_us": 19432.104, "rows": 16666, "peak_rss_kb": 4980} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13495.002, "min_us": 13439.071, "max_us": 14399.952, "rows": 16666, "peak_rss_kb": 4940} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2518, "median_us": 365.682, "min_us": 357.303, "max_us": 1176.602, "rows": 10, "peak_rss_kb": 3764} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2671, "median_us": 363.987, "min_us": 354.953, "max_us": 3102.809, "rows": 10, "peak_rss_kb": 3824} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 37, "median_us": 27660.672, "min_us": 25756.576, "max_us": 28567.19, "rows": 10, "peak_rss_kb": 4792} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25470.232, "min_us": 25276.031, "max_us": 25687.687, "rows": 10, "peak_rss_kb": 4832} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 35, "median_us": 27706.324, "min_us": 25513.657, "max_us": 76591.383, "rows": 10, "peak_rss_kb": 4760} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25556.321, "min_us": 25379.1, "max_us": 25819.978, "rows": 10, "peak_rss_kb": 4800} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 1990, "median_us": 460.758, "min_us": 449.679, "max_us": 1451.285, "rows": 10, "peak_rss_kb": 3736} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2191, "median_us": 448.371, "min_us": 417.019, "max_us": 4608.544, "rows": 10, "peak_rss_kb": 3768} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2118, "median_us": 444.546, "min_us": 421.507, "max_us": 1479.07, "rows": 10, "peak_rss_kb": 3780} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2265, "median_us": 431.336, "min_us": 418.414, "max_us": 1468.773, "rows": 10, "peak_rss_kb": 3724} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8059, "median_us": 112.588, "min_us": 111.498, "max_us": 1780.597, "rows": 1, "peak_rss_kb": 3800} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8643, "median_us": 113.034, "min_us": 112.076, "max_us": 408.912, "rows": 1, "peak_rss_kb": 3708} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.649, "min_us": 18.92, "max_us": 95.968, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.453, "min_us": 19.029, "max_us": 123.042, "rows": 1, "peak_rss_kb": 3728} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 19.039, "min_us": 18.031, "max_us": 712.425, "rows": 1, "peak_rss_kb": 3892} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.782, "min_us": 16.691, "max_us": 109.757, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2846, "median_us": 324.493, "min_us": 313.183, "max_us": 1013.195, "rows": 1, "peak_rss_kb": 3672} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3029, "median_us": 324.09, "min_us": 319.461, "max_us": 1019.677, "rows": 1, "peak_rss_kb": 3692} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 150645.695, "min_us": 147335.711, "max_us": 152058.346, "rows": 166666, "peak_rss_kb": 5216} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 142540.488, "min_us": 141435.847, "max_us": 144331.504, "rows": 166666, "peak_rss_kb": 5260} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2506, "median_us": 372.501, "min_us": 342.919, "max_us": 3111.43, "rows": 10, "peak_rss_kb": 3824} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2704, "median_us": 362.519, "min_us": 347.676, "max_us": 1221.954, "rows": 10, "peak_rss_kb": 3756} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 294000.63, "min_us": 292471.591, "max_us": 300822.744, "rows": 10, "peak_rss_kb": 5044} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 272700.628, "min_us": 267648.067, "max_us": 279432.927, "rows": 10, "peak_rss_kb": 4984} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 289270.957, "min_us": 281706.599, "max_us": 294056.758, "rows": 10, "peak_rss_kb": 4960} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270600.782, "min_us": 268537.245, "max_us": 271460.371, "rows": 10, "peak_rss_kb": 5000} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2005, "median_us": 462.362, "min_us": 446.336, "max_us": 1441.729, "rows": 10, "peak_rss_kb": 3800} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2037, "median_us": 455.793, "min_us": 448.604, "max_us": 40309.811, "rows": 10, "peak_rss_kb": 3704} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2012, "median_us": 457.462, "min_us": 447.533, "max_us": 1425.481, "rows": 10, "peak_rss_kb": 3680} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2139, "median_us": 458.883, "min_us": 448.028, "max_us": 1462.452, "rows": 10, "peak_rss_kb": 3708} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 7799, "median_us": 119.159, "min_us": 115.844, "max_us": 1571.473, "rows": 1, "peak_rss_kb": 3736} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8265, "median_us": 117.859, "min_us": 114.393, "max_us": 409.329, "rows": 1, "peak_rss_kb": 3744} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.161, "min_us": 18.362, "max_us": 118.25, "rows": 1, "peak_rss_kb": 3744} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.342, "min_us": 18.728, "max_us": 114.843, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.137, "min_us": 17.369, "max_us": 727.18, "rows": 1, "peak_rss_kb": 3788} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.313, "min_us": 17.64, "max_us": 81.203, "rows": 1, "peak_rss_kb": 3832} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2826, "median_us": 327.48, "min_us": 316.358, "max_us": 1021.906, "rows": 1, "peak_rss_kb": 3624} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3025, "median_us": 324.765, "min_us": 316.311, "max_us": 1052.193, "rows": 1, "peak_rss_kb": 3660} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1490621.454, "min_us": 1477193.627, "max_us": 1507247.999, "rows": 1666666, "peak_rss_kb": 5328} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1466755.425, "min_us": 1460722.096, "max_us": 1525432.886, "rows": 1666666, "peak_rss_kb": 5264} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2507, "median_us": 369.163, "min_us": 341.055, "max_us": 3918.295, "rows": 10, "peak_rss_kb": 3776} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2632, "median_us": 378.978, "min_us": 348.178, "max_us": 1157.848, "rows": 10, "peak_rss_kb": 3796} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2855747.226, "min_us": 2821375.663, "max_us": 3032278.05, "rows": 10, "peak_rss_kb": 5044} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2862945.773, "min_us": 2804389.298, "max_us": 2872132.72, "rows": 10, "peak_rss_kb": 5052} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2799189.886, "min_us": 2780627.727, "max_us": 2819653.055, "rows": 10, "peak_rss_kb": 5056} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2809341.226, "min_us": 2798933.919, "max_us": 2856937.938, "rows": 10, "peak_rss_kb": 5044} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2118, "median_us": 457.353, "min_us": 442.361, "max_us": 4580.277, "rows": 10, "peak_rss_kb": 3760} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2163, "median_us": 453.687, "min_us": 444.073, "max_us": 1421.916, "rows": 10, "peak_rss_kb": 3764} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2146, "median_us": 460.404, "min_us": 447.679, "max_us": 1440.741, "rows": 10, "peak_rss_kb": 3712} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2142, "median_us": 455.834, "min_us": 437.276, "max_us": 3953.643, "rows": 10, "peak_rss_kb": 3760} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7502, "median_us": 130.294, "min_us": 129.24, "max_us": 461.568, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7516, "median_us": 129.449, "min_us": 128.188, "max_us": 421.432, "rows": 1, "peak_rss_kb": 3736} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.203, "min_us": 18.662, "max_us": 90.952, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.479, "min_us": 18.71, "max_us": 91.471, "rows": 1, "peak_rss_kb": 3736} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.222, "min_us": 18.78, "max_us": 751.034, "rows": 1, "peak_rss_kb": 3824} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 20.125, "min_us": 19.576, "max_us": 84.154, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2987, "median_us": 328.614, "min_us": 322.965, "max_us": 1050.883, "rows": 1, "peak_rss_kb": 3664} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3077, "median_us": 318.356, "min_us": 315.286, "max_us": 1016.76, "rows": 1, "peak_rss_kb": 3676} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13471.106, "min_us": 13407.262, "max_us": 20675.891, "rows": 16666, "peak_rss_kb": 4912} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13558.447, "min_us": 13374.392, "max_us": 14736.722, "rows": 16666, "peak_rss_kb": 5020} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2691, "median_us": 366.823, "min_us": 351.142, "max_us": 1160.36, "rows": 10, "peak_rss_kb": 3804} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2705, "median_us": 360.565, "min_us": 349.806, "max_us": 4508.844, "rows": 10, "peak_rss_kb": 3836} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25464.189, "min_us": 25247.812, "max_us": 26865.53, "rows": 10, "peak_rss_kb": 4788} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25656.478, "min_us": 25458.353, "max_us": 33771.459, "rows": 10, "peak_rss_kb": 4796} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25493.176, "min_us": 25346.406, "max_us": 25747.236, "rows": 10, "peak_rss_kb": 4808} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25749.758, "min_us": 25473.493, "max_us": 27104.041, "rows": 10, "peak_rss_kb": 4808} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2135, "median_us": 456.734, "min_us": 448.25, "max_us": 4163.359, "rows": 10, "peak_rss_kb": 3708} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2241, "median_us": 439.62, "min_us": 421.818, "max_us": 1424.206, "rows": 10, "peak_rss_kb": 3772} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2172, "median_us": 451.768, "min_us": 442.983, "max_us": 1441.569, "rows": 10, "peak_rss_kb": 3728} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2184, "median_us": 445.995, "min_us": 439.207, "max_us": 5142.378, "rows": 10, "peak_rss_kb": 3772} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8642, "median_us": 112.922, "min_us": 111.856, "max_us": 426.63, "rows": 1, "peak_rss_kb": 3756} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8635, "median_us": 112.855, "min_us": 111.755, "max_us": 381.07, "rows": 1, "peak_rss_kb": 3736} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 20.321, "min_us": 19.717, "max_us": 85.708, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.595, "min_us": 19.016, "max_us": 759.627, "rows": 1, "peak_rss_kb": 3832} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.422, "min_us": 17.188, "max_us": 90.179, "rows": 1, "peak_rss_kb": 3836} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.565, "min_us": 17.355, "max_us": 84.902, "rows": 1, "peak_rss_kb": 3748} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3043, "median_us": 322.779, "min_us": 314.936, "max_us": 1019.895, "rows": 1, "peak_rss_kb": 3668} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3027, "median_us": 322.381, "min_us": 313.984, "max_us": 3721.498, "rows": 1, "peak_rss_kb": 3660} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 142783.389, "min_us": 142622.413, "max_us": 143617.078, "rows": 166666, "peak_rss_kb": 5204} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139743.455, "min_us": 139541.103, "max_us": 185800.55, "rows": 166666, "peak_rss_kb": 5296} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2579, "median_us": 380.782, "min_us": 375.001, "max_us": 1231.106, "rows": 10, "peak_rss_kb": 3804} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2684, "median_us": 362.651, "min_us": 345.215, "max_us": 1192.957, "rows": 10, "peak_rss_kb": 3728} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 268764.7, "min_us": 267610.241, "max_us": 276944.24, "rows": 10, "peak_rss_kb": 5012} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 273341.058, "min_us": 269341.86, "max_us": 279120.771, "rows": 10, "peak_rss_kb": 5028} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268714.833, "min_us": 268208.612, "max_us": 270443.134, "rows": 10, "peak_rss_kb": 4980} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 378963.379, "min_us": 376943.205, "max_us": 384649.472, "rows": 10, "peak_rss_kb": 4944} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2148, "median_us": 455.487, "min_us": 448.163, "max_us": 3892.109, "rows": 10, "peak_rss_kb": 3716} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2133, "median_us": 460.835, "min_us": 450.627, "max_us": 1450.754, "rows": 10, "peak_rss_kb": 3700} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2216, "median_us": 445.308, "min_us": 423.189, "max_us": 1434.937, "rows": 10, "peak_rss_kb": 3760} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2149, "median_us": 454.692, "min_us": 446.34, "max_us": 3884.537, "rows": 10, "peak_rss_kb": 3744} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8289, "median_us": 117.264, "min_us": 113.457, "max_us": 407.205, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8177, "median_us": 121.015, "min_us": 113.553, "max_us": 387.655, "rows": 1, "peak_rss_kb": 3732} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.292, "min_us": 18.706, "max_us": 814.966, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.632, "min_us": 19.056, "max_us": 85.855, "rows": 1, "peak_rss_kb": 3812} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.82, "min_us": 17.108, "max_us": 70.576, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.348, "min_us": 17.526, "max_us": 81.882, "rows": 1, "peak_rss_kb": 3884} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2990, "median_us": 323.966, "min_us": 318.061, "max_us": 1028.98, "rows": 1, "peak_rss_kb": 3688} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2989, "median_us": 327.052, "min_us": 317.304, "max_us": 4286.159, "rows": 1, "peak_rss_kb": 3716} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1406820.155, "min_us": 1400787.871, "max_us": 1446537.914, "rows": 1666666, "peak_rss_kb": 5464} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1443181.452, "min_us": 1435190.905, "max_us": 1452921.591, "rows": 1666666, "peak_rss_kb": 5264} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2558, "median_us": 380.08, "min_us": 356.83, "max_us": 3915.483, "rows": 10, "peak_rss_kb": 3780} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2678, "median_us": 366.742, "min_us": 350.905, "max_us": 1158.235, "rows": 10, "peak_rss_kb": 3764} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2795921.943, "min_us": 2751436.353, "max_us": 2806891.709, "rows": 10, "peak_rss_kb": 5120} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2862872.74, "min_us": 2819379.024, "max_us": 2909748.912, "rows": 10, "peak_rss_kb": 5140} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2812767.883, "min_us": 2766132.136, "max_us": 2824205.672, "rows": 10, "peak_rss_kb": 5000} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2878246.78, "min_us": 2836957.144, "max_us": 2933247.646, "rows": 10, "peak_rss_kb": 5080} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2157, "median_us": 455.492, "min_us": 446.59, "max_us": 1488.079, "rows": 10, "peak_rss_kb": 3816} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2138, "median_us": 457.932, "min_us": 439.324, "max_us": 4100.241, "rows": 10, "peak_rss_kb": 3808} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2156, "median_us": 455.129, "min_us": 442.925, "max_us": 1448.402, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2160, "median_us": 456.794, "min_us": 442.213, "max_us": 1432.445, "rows": 10, "peak_rss_kb": 3788} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7413, "median_us": 130.316, "min_us": 128.745, "max_us": 1545.165, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7513, "median_us": 131.232, "min_us": 129.832, "max_us": 319.525, "rows": 1, "peak_rss_kb": 3708} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.079, "min_us": 18.319, "max_us": 92.77, "rows": 1, "peak_rss_kb": 3780} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.166, "min_us": 18.758, "max_us": 78.42, "rows": 1, "peak_rss_kb": 3872} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.782, "min_us": 19.32, "max_us": 107.916, "rows": 1, "peak_rss_kb": 3780} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.246, "min_us": 18.728, "max_us": 82.804, "rows": 1, "peak_rss_kb": 3816} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3026, "median_us": 320.227, "min_us": 316.107, "max_us": 3868.878, "rows": 1, "peak_rss_kb": 3692} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3050, "median_us": 322.273, "min_us": 316.548, "max_us": 1023.903, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13282.21, "min_us": 13230.038, "max_us": 13802.909, "rows": 16666, "peak_rss_kb": 4972} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13452.217, "min_us": 13412.74, "max_us": 20830.185, "rows": 16666, "peak_rss_kb": 4912} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2719, "median_us": 361.928, "min_us": 350.874, "max_us": 1208.386, "rows": 10, "peak_rss_kb": 3796} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2685, "median_us": 368.271, "min_us": 350.56, "max_us": 1184.531, "rows": 10, "peak_rss_kb": 3884} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25770.102, "min_us": 25584.022, "max_us": 34418.248, "rows": 10, "peak_rss_kb": 4748} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25459.407, "min_us": 25337.419, "max_us": 25741.88, "rows": 10, "peak_rss_kb": 4844} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25756.092, "min_us": 25527.389, "max_us": 34577.635, "rows": 10, "peak_rss_kb": 4844} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25363.303, "min_us": 25218.828, "max_us": 26741.69, "rows": 10, "peak_rss_kb": 4728} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2180, "median_us": 454.418, "min_us": 425.846, "max_us": 1411.442, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2176, "median_us": 454.332, "min_us": 443.626, "max_us": 3911.906, "rows": 10, "peak_rss_kb": 3792} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2262, "median_us": 431.969, "min_us": 420.011, "max_us": 1476.555, "rows": 10, "peak_rss_kb": 3772} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2158, "median_us": 456.362, "min_us": 449.399, "max_us": 1466.618, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8570, "median_us": 112.842, "min_us": 111.79, "max_us": 1505.949, "rows": 1, "peak_rss_kb": 3756} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8637, "median_us": 112.785, "min_us": 111.714, "max_us": 374.375, "rows": 1, "peak_rss_kb": 3760} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.277, "min_us": 18.799, "max_us": 111.923, "rows": 1, "peak_rss_kb": 3836} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.014, "min_us": 18.512, "max_us": 97.496, "rows": 1, "peak_rss_kb": 3828} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.114, "min_us": 17.034, "max_us": 99.988, "rows": 1, "peak_rss_kb": 3836} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.045, "min_us": 16.834, "max_us": 118.424, "rows": 1, "peak_rss_kb": 3804} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2906, "median_us": 317.586, "min_us": 313.696, "max_us": 44911.517, "rows": 1, "peak_rss_kb": 3668} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3051, "median_us": 324.176, "min_us": 319.968, "max_us": 1028.471, "rows": 1, "peak_rss_kb": 3672} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 142150.354, "min_us": 139862.869, "max_us": 152332.983, "rows": 166666, "peak_rss_kb": 5288} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139745.178, "min_us": 139532.483, "max_us": 140833.406, "rows": 166666, "peak_rss_kb": 5260} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2671, "median_us": 365.91, "min_us": 346.039, "max_us": 1307.401, "rows": 10, "peak_rss_kb": 3776} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2615, "median_us": 372.062, "min_us": 367.705, "max_us": 3959.21, "rows": 10, "peak_rss_kb": 3700} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269142.041, "min_us": 267234.728, "max_us": 282428.287, "rows": 10, "peak_rss_kb": 5020} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269322.212, "min_us": 268126.651, "max_us": 275129.76, "rows": 10, "peak_rss_kb": 4996} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270501.109, "min_us": 269231.572, "max_us": 271371.231, "rows": 10, "peak_rss_kb": 5128} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270285.224, "min_us": 265021.34, "max_us": 273600.457, "rows": 10, "peak_rss_kb": 4984} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2174, "median_us": 452.579, "min_us": 444.963, "max_us": 1467.77, "rows": 10, "peak_rss_kb": 3736} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2135, "median_us": 461.366, "min_us": 454.169, "max_us": 1470.875, "rows": 10, "peak_rss_kb": 3800} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2234, "median_us": 433.211, "min_us": 416.156, "max_us": 3927.921, "rows": 10, "peak_rss_kb": 3780} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2210, "median_us": 448.659, "min_us": 431.125, "max_us": 1422.134, "rows": 10, "peak_rss_kb": 3752} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8245, "median_us": 118.32, "min_us": 114.534, "max_us": 396.971, "rows": 1, "peak_rss_kb": 3736} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8254, "median_us": 117.268, "min_us": 113.692, "max_us": 1487.525, "rows": 1, "peak_rss_kb": 3724} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.145, "min_us": 18.518, "max_us": 109.717, "rows": 1, "peak_rss_kb": 3836} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.547, "min_us": 19.01, "max_us": 107.065, "rows": 1, "peak_rss_kb": 3832} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.309, "min_us": 17.459, "max_us": 54.299, "rows": 1, "peak_rss_kb": 3840} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.806, "min_us": 18.034, "max_us": 82.997, "rows": 1, "peak_rss_kb": 3728} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2991, "median_us": 325.376, "min_us": 315.748, "max_us": 3836.726, "rows": 1, "peak_rss_kb": 3764} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3032, "median_us": 323.76, "min_us": 316.984, "max_us": 1034.004, "rows": 1, "peak_rss_kb": 3700} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1410584.061, "min_us": 1397700.412, "max_us": 1426297.521, "rows": 1666666, "peak_rss_kb": 5436} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1468745.726, "min_us": 1453806.925, "max_us": 1487151.505, "rows": 1666666, "peak_rss_kb": 5420} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2685, "median_us": 368.309, "min_us": 345.032, "max_us": 1140.967, "rows": 10, "peak_rss_kb": 3760} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2680, "median_us": 365.858, "min_us": 346.915, "max_us": 1169.592, "rows": 10, "peak_rss_kb": 3784} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2812657.174, "min_us": 2800195.832, "max_us": 2818301.239, "rows": 10, "peak_rss_kb": 4972} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2846905.503, "min_us": 2802109.926, "max_us": 2864626.689, "rows": 10, "peak_rss_kb": 5052} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2831303.618, "min_us": 2778091.143, "max_us": 2879439.88, "rows": 10, "peak_rss_kb": 5056} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2856097.179, "min_us": 2788404.089, "max_us": 2896565.613, "rows": 10, "peak_rss_kb": 5056} diff --git a/docs/benchmarks/641-ordered-groups-history.jsonl b/docs/benchmarks/641-ordered-groups-history.jsonl new file mode 100644 index 0000000000..e3625e684e --- /dev/null +++ b/docs/benchmarks/641-ordered-groups-history.jsonl @@ -0,0 +1,144 @@ +{"round": 1, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.194, "min_us": 16.828, "max_us": 94.98, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.74, "min_us": 16.258, "max_us": 750.465, "rows": 1, "peak_rss_kb": 3780} +{"round": 1, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.327, "min_us": 16.958, "max_us": 106.856, "rows": 1, "peak_rss_kb": 3776} +{"round": 1, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 18.289, "min_us": 17.641, "max_us": 123.721, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.856, "min_us": 17.276, "max_us": 87.896, "rows": 1, "peak_rss_kb": 3804} +{"round": 1, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.448, "min_us": 16.885, "max_us": 80.105, "rows": 1, "peak_rss_kb": 3788} +{"round": 1, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.052, "min_us": 17.569, "max_us": 76.306, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.092, "min_us": 17.624, "max_us": 74.751, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6312, "median_us": 152.265, "min_us": 150.841, "max_us": 1571.479, "rows": 1, "peak_rss_kb": 3668} +{"round": 1, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6425, "median_us": 152.814, "min_us": 150.512, "max_us": 496.156, "rows": 1, "peak_rss_kb": 3728} +{"round": 1, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.769, "min_us": 22.363, "max_us": 104.695, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.743, "min_us": 22.175, "max_us": 100.539, "rows": 1, "peak_rss_kb": 3808} +{"round": 1, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6388, "median_us": 150.815, "min_us": 149.407, "max_us": 2216.831, "rows": 1, "peak_rss_kb": 3680} +{"round": 1, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6339, "median_us": 154.52, "min_us": 152.217, "max_us": 498.007, "rows": 1, "peak_rss_kb": 3688} +{"round": 1, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6881, "median_us": 142.007, "min_us": 141.116, "max_us": 499.137, "rows": 1, "peak_rss_kb": 3664} +{"round": 1, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6957, "median_us": 140.603, "min_us": 139.751, "max_us": 1640.51, "rows": 1, "peak_rss_kb": 3696} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1622, "median_us": 605.645, "min_us": 596.858, "max_us": 1876.859, "rows": 1, "peak_rss_kb": 3696} +{"round": 1, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1616, "median_us": 606.012, "min_us": 595.348, "max_us": 1878.133, "rows": 1, "peak_rss_kb": 3676} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.161, "min_us": 22.556, "max_us": 114.338, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.922, "min_us": 22.301, "max_us": 718.566, "rows": 1, "peak_rss_kb": 3800} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1639, "median_us": 602.715, "min_us": 586.162, "max_us": 1860.291, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1639, "median_us": 601.176, "min_us": 592.911, "max_us": 1891.668, "rows": 1, "peak_rss_kb": 3616} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1748, "median_us": 556.38, "min_us": 548.273, "max_us": 6309.28, "rows": 1, "peak_rss_kb": 3684} +{"round": 1, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1750, "median_us": 559.324, "min_us": 549.457, "max_us": 1727.991, "rows": 1, "peak_rss_kb": 3736} +{"round": 2, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.512, "min_us": 17.074, "max_us": 92.657, "rows": 1, "peak_rss_kb": 3772} +{"round": 2, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.956, "min_us": 16.459, "max_us": 76.432, "rows": 1, "peak_rss_kb": 3800} +{"round": 2, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.381, "min_us": 16.851, "max_us": 82.798, "rows": 1, "peak_rss_kb": 3792} +{"round": 2, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.487, "min_us": 17.017, "max_us": 80.254, "rows": 1, "peak_rss_kb": 3860} +{"round": 2, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.115, "min_us": 16.709, "max_us": 743.754, "rows": 1, "peak_rss_kb": 3808} +{"round": 2, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.482, "min_us": 16.865, "max_us": 75.564, "rows": 1, "peak_rss_kb": 3808} +{"round": 2, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.162, "min_us": 17.66, "max_us": 97.966, "rows": 1, "peak_rss_kb": 3808} +{"round": 2, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.143, "min_us": 17.684, "max_us": 85.307, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6351, "median_us": 153.351, "min_us": 150.597, "max_us": 512.942, "rows": 1, "peak_rss_kb": 3720} +{"round": 2, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6041, "median_us": 152.522, "min_us": 150.813, "max_us": 45770.464, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.885, "min_us": 22.41, "max_us": 118.695, "rows": 1, "peak_rss_kb": 3784} +{"round": 2, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.771, "min_us": 22.373, "max_us": 97.606, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6286, "median_us": 155.442, "min_us": 152.468, "max_us": 498.949, "rows": 1, "peak_rss_kb": 3608} +{"round": 2, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6361, "median_us": 153.273, "min_us": 149.843, "max_us": 1537.509, "rows": 1, "peak_rss_kb": 3604} +{"round": 2, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6930, "median_us": 141.629, "min_us": 139.472, "max_us": 476.073, "rows": 1, "peak_rss_kb": 3700} +{"round": 2, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6892, "median_us": 142.496, "min_us": 140.438, "max_us": 478.595, "rows": 1, "peak_rss_kb": 3640} +{"round": 2, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1619, "median_us": 602.566, "min_us": 587.855, "max_us": 5549.664, "rows": 1, "peak_rss_kb": 3684} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1625, "median_us": 605.155, "min_us": 595.703, "max_us": 1886.896, "rows": 1, "peak_rss_kb": 3668} +{"round": 2, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.19, "min_us": 22.523, "max_us": 98.288, "rows": 1, "peak_rss_kb": 3888} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.869, "min_us": 22.242, "max_us": 92.69, "rows": 1, "peak_rss_kb": 3828} +{"round": 2, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1639, "median_us": 594.782, "min_us": 583.696, "max_us": 5958.96, "rows": 1, "peak_rss_kb": 3720} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1657, "median_us": 596.888, "min_us": 588.333, "max_us": 1889.63, "rows": 1, "peak_rss_kb": 3704} +{"round": 2, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1768, "median_us": 558.263, "min_us": 547.68, "max_us": 1723.474, "rows": 1, "peak_rss_kb": 3704} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1734, "median_us": 561.458, "min_us": 548.477, "max_us": 5404.644, "rows": 1, "peak_rss_kb": 3676} +{"round": 3, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.083, "min_us": 16.636, "max_us": 96.63, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.358, "min_us": 16.936, "max_us": 48.078, "rows": 1, "peak_rss_kb": 3808} +{"round": 3, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.615, "min_us": 17.192, "max_us": 80.111, "rows": 1, "peak_rss_kb": 3812} +{"round": 3, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.404, "min_us": 17.095, "max_us": 92.116, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.87, "min_us": 17.354, "max_us": 96.059, "rows": 1, "peak_rss_kb": 3772} +{"round": 3, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.223, "min_us": 16.77, "max_us": 97.783, "rows": 1, "peak_rss_kb": 3868} +{"round": 3, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 20.446, "min_us": 19.94, "max_us": 738.306, "rows": 1, "peak_rss_kb": 3808} +{"round": 3, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.659, "min_us": 18.054, "max_us": 87.328, "rows": 1, "peak_rss_kb": 3772} +{"round": 3, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6398, "median_us": 153.573, "min_us": 151.038, "max_us": 542.432, "rows": 1, "peak_rss_kb": 3664} +{"round": 3, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6380, "median_us": 153.359, "min_us": 150.389, "max_us": 491.312, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.524, "min_us": 22.209, "max_us": 125.22, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.397, "min_us": 21.96, "max_us": 845.405, "rows": 1, "peak_rss_kb": 3784} +{"round": 3, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6324, "median_us": 154.896, "min_us": 152.295, "max_us": 539.04, "rows": 1, "peak_rss_kb": 3712} +{"round": 3, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6438, "median_us": 152.117, "min_us": 149.285, "max_us": 496.527, "rows": 1, "peak_rss_kb": 3692} +{"round": 3, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6832, "median_us": 142.297, "min_us": 140.552, "max_us": 2762.886, "rows": 1, "peak_rss_kb": 3708} +{"round": 3, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6874, "median_us": 142.196, "min_us": 141.114, "max_us": 457.669, "rows": 1, "peak_rss_kb": 3696} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1639, "median_us": 599.113, "min_us": 589.191, "max_us": 1883.255, "rows": 1, "peak_rss_kb": 3668} +{"round": 3, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1633, "median_us": 598.543, "min_us": 585.857, "max_us": 4844.549, "rows": 1, "peak_rss_kb": 3728} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.19, "min_us": 22.52, "max_us": 94.878, "rows": 1, "peak_rss_kb": 3796} +{"round": 3, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.413, "min_us": 22.768, "max_us": 94.337, "rows": 1, "peak_rss_kb": 3840} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1629, "median_us": 604.14, "min_us": 587.28, "max_us": 1896.933, "rows": 1, "peak_rss_kb": 3604} +{"round": 3, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1568, "median_us": 597.63, "min_us": 583.346, "max_us": 28113.653, "rows": 1, "peak_rss_kb": 3604} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1763, "median_us": 558.974, "min_us": 548.569, "max_us": 1806.298, "rows": 1, "peak_rss_kb": 3696} +{"round": 3, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1752, "median_us": 557.999, "min_us": 546.043, "max_us": 1738.916, "rows": 1, "peak_rss_kb": 3676} +{"round": 4, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.235, "min_us": 16.825, "max_us": 81.786, "rows": 1, "peak_rss_kb": 3820} +{"round": 4, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.099, "min_us": 16.647, "max_us": 1053.53, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.266, "min_us": 16.752, "max_us": 93.298, "rows": 1, "peak_rss_kb": 3812} +{"round": 4, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.369, "min_us": 16.845, "max_us": 91.22, "rows": 1, "peak_rss_kb": 3808} +{"round": 4, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.679, "min_us": 17.197, "max_us": 88.481, "rows": 1, "peak_rss_kb": 3796} +{"round": 4, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.499, "min_us": 17.178, "max_us": 91.582, "rows": 1, "peak_rss_kb": 3776} +{"round": 4, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.923, "min_us": 17.446, "max_us": 100.382, "rows": 1, "peak_rss_kb": 3868} +{"round": 4, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.349, "min_us": 17.81, "max_us": 81.962, "rows": 1, "peak_rss_kb": 3780} +{"round": 4, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6354, "median_us": 153.092, "min_us": 150.365, "max_us": 2333.791, "rows": 1, "peak_rss_kb": 3688} +{"round": 4, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6360, "median_us": 154.026, "min_us": 152.663, "max_us": 496.043, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.865, "min_us": 22.383, "max_us": 91.685, "rows": 1, "peak_rss_kb": 3808} +{"round": 4, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.798, "min_us": 22.32, "max_us": 93.189, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6364, "median_us": 152.728, "min_us": 149.372, "max_us": 2241.843, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6311, "median_us": 153.994, "min_us": 151.856, "max_us": 502.35, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6066, "median_us": 149.552, "min_us": 139.989, "max_us": 459.387, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6823, "median_us": 141.77, "min_us": 140.043, "max_us": 1510.736, "rows": 1, "peak_rss_kb": 3680} +{"round": 4, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1642, "median_us": 599.427, "min_us": 586.772, "max_us": 1870.525, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1649, "median_us": 597.208, "min_us": 589.198, "max_us": 1921.208, "rows": 1, "peak_rss_kb": 3712} +{"round": 4, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.995, "min_us": 22.362, "max_us": 108.288, "rows": 1, "peak_rss_kb": 3884} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.41, "min_us": 22.8, "max_us": 763.59, "rows": 1, "peak_rss_kb": 3764} +{"round": 4, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1641, "median_us": 600.336, "min_us": 592.43, "max_us": 1878.122, "rows": 1, "peak_rss_kb": 3716} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1646, "median_us": 596.89, "min_us": 586.012, "max_us": 1901.952, "rows": 1, "peak_rss_kb": 3756} +{"round": 4, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1744, "median_us": 556.797, "min_us": 545.677, "max_us": 4797.518, "rows": 1, "peak_rss_kb": 3676} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1730, "median_us": 565.026, "min_us": 554.017, "max_us": 1744.877, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.424, "min_us": 16.879, "max_us": 97.261, "rows": 1, "peak_rss_kb": 3856} +{"round": 5, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.832, "min_us": 16.411, "max_us": 74.848, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.589, "min_us": 17.106, "max_us": 84.522, "rows": 1, "peak_rss_kb": 3776} +{"round": 5, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.578, "min_us": 17.161, "max_us": 100.573, "rows": 1, "peak_rss_kb": 3812} +{"round": 5, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 18.018, "min_us": 17.464, "max_us": 750.802, "rows": 1, "peak_rss_kb": 3860} +{"round": 5, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.503, "min_us": 17.063, "max_us": 52.233, "rows": 1, "peak_rss_kb": 3824} +{"round": 5, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.935, "min_us": 17.529, "max_us": 74.307, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.281, "min_us": 17.868, "max_us": 96.196, "rows": 1, "peak_rss_kb": 3768} +{"round": 5, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6415, "median_us": 153.213, "min_us": 150.604, "max_us": 518.285, "rows": 1, "peak_rss_kb": 3772} +{"round": 5, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6392, "median_us": 152.834, "min_us": 150.327, "max_us": 1538.661, "rows": 1, "peak_rss_kb": 3720} +{"round": 5, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.808, "min_us": 22.237, "max_us": 93.6, "rows": 1, "peak_rss_kb": 3800} +{"round": 5, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.01, "min_us": 22.535, "max_us": 92.757, "rows": 1, "peak_rss_kb": 3844} +{"round": 5, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6409, "median_us": 152.83, "min_us": 149.592, "max_us": 501.188, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6080, "median_us": 152.965, "min_us": 149.834, "max_us": 40337.266, "rows": 1, "peak_rss_kb": 3616} +{"round": 5, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6851, "median_us": 142.723, "min_us": 141.66, "max_us": 456.073, "rows": 1, "peak_rss_kb": 3680} +{"round": 5, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6933, "median_us": 140.571, "min_us": 139.411, "max_us": 459.29, "rows": 1, "peak_rss_kb": 3728} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1605, "median_us": 605.568, "min_us": 589.122, "max_us": 4188.463, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1632, "median_us": 602.842, "min_us": 594.202, "max_us": 1874.808, "rows": 1, "peak_rss_kb": 3680} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.255, "min_us": 22.696, "max_us": 88.056, "rows": 1, "peak_rss_kb": 3876} +{"round": 5, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.877, "min_us": 22.285, "max_us": 127.262, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1631, "median_us": 596.983, "min_us": 587.772, "max_us": 6817.311, "rows": 1, "peak_rss_kb": 3680} +{"round": 5, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1638, "median_us": 600.516, "min_us": 592.109, "max_us": 1889.794, "rows": 1, "peak_rss_kb": 3660} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1748, "median_us": 560.675, "min_us": 549.993, "max_us": 1749.427, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1735, "median_us": 563.758, "min_us": 547.24, "max_us": 4876.044, "rows": 1, "peak_rss_kb": 3776} +{"round": 6, "variant": "grouped", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.123, "min_us": 16.696, "max_us": 77.231, "rows": 1, "peak_rss_kb": 3860} +{"round": 6, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.619, "min_us": 17.177, "max_us": 83.057, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "grouped", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 18.164, "min_us": 17.55, "max_us": 52.989, "rows": 1, "peak_rss_kb": 3816} +{"round": 6, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.22, "min_us": 16.896, "max_us": 79.971, "rows": 1, "peak_rss_kb": 3860} +{"round": 6, "variant": "grouped", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.26, "min_us": 16.833, "max_us": 74.919, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.612, "min_us": 17.119, "max_us": 80.95, "rows": 1, "peak_rss_kb": 3692} +{"round": 6, "variant": "grouped", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.377, "min_us": 17.831, "max_us": 781.746, "rows": 1, "peak_rss_kb": 3788} +{"round": 6, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.055, "min_us": 17.505, "max_us": 87.335, "rows": 1, "peak_rss_kb": 3788} +{"round": 6, "variant": "grouped", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6419, "median_us": 153.136, "min_us": 151.676, "max_us": 512.779, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6399, "median_us": 152.183, "min_us": 150.77, "max_us": 495.602, "rows": 1, "peak_rss_kb": 3696} +{"round": 6, "variant": "grouped", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.915, "min_us": 23.385, "max_us": 98.254, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.881, "min_us": 22.472, "max_us": 716.437, "rows": 1, "peak_rss_kb": 3800} +{"round": 6, "variant": "grouped", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6413, "median_us": 152.857, "min_us": 149.623, "max_us": 518.018, "rows": 1, "peak_rss_kb": 3696} +{"round": 6, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6406, "median_us": 152.964, "min_us": 149.841, "max_us": 495.906, "rows": 1, "peak_rss_kb": 3672} +{"round": 6, "variant": "grouped", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6798, "median_us": 140.682, "min_us": 139.447, "max_us": 2195.262, "rows": 1, "peak_rss_kb": 3720} +{"round": 6, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6830, "median_us": 143.226, "min_us": 142.287, "max_us": 465.294, "rows": 1, "peak_rss_kb": 3680} +{"round": 6, "variant": "grouped", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1627, "median_us": 602.736, "min_us": 589.3, "max_us": 1891.24, "rows": 1, "peak_rss_kb": 3716} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1620, "median_us": 604.839, "min_us": 590.602, "max_us": 4696.918, "rows": 1, "peak_rss_kb": 3668} +{"round": 6, "variant": "grouped", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.112, "min_us": 22.515, "max_us": 98.972, "rows": 1, "peak_rss_kb": 3828} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.368, "min_us": 22.775, "max_us": 92.684, "rows": 1, "peak_rss_kb": 3788} +{"round": 6, "variant": "grouped", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1643, "median_us": 597.369, "min_us": 585.153, "max_us": 1879.031, "rows": 1, "peak_rss_kb": 3696} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1638, "median_us": 601.437, "min_us": 585.811, "max_us": 4084.269, "rows": 1, "peak_rss_kb": 3596} +{"round": 6, "variant": "grouped", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1764, "median_us": 558.084, "min_us": 549.656, "max_us": 1729.083, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1753, "median_us": 557.26, "min_us": 547.835, "max_us": 1739.982, "rows": 1, "peak_rss_kb": 3724} diff --git a/docs/benchmarks/641-ordered-groups-meter.jsonl b/docs/benchmarks/641-ordered-groups-meter.jsonl new file mode 100644 index 0000000000..d398bc9411 --- /dev/null +++ b/docs/benchmarks/641-ordered-groups-meter.jsonl @@ -0,0 +1,24 @@ +{"active_groups": 1, "facts": 100000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count", "rows": 6250, "scan_rows": 100000} +{"active_groups": 1, "facts": 100000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct", "rows": 6250, "scan_rows": 100000} +{"active_groups": 1, "facts": 100000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 100000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 100000, "group_size": 100000, "meter_peak_bytes": 480, "mode": "count", "rows": 1, "scan_rows": 100000} +{"active_groups": 1, "facts": 100000, "group_size": 100000, "meter_peak_bytes": 4000480, "mode": "distinct", "rows": 1, "scan_rows": 100000} +{"active_groups": 1, "facts": 100000, "group_size": 100000, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 1, "scan_rows": 100000} +{"active_groups": 1, "facts": 100000, "group_size": 100000, "meter_peak_bytes": 4000480, "mode": "distinct_limit", "rows": 1, "scan_rows": 100000} +{"active_groups": 1, "facts": 1000000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count", "rows": 62500, "scan_rows": 1000000} +{"active_groups": 1, "facts": 1000000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct", "rows": 62500, "scan_rows": 1000000} +{"active_groups": 1, "facts": 1000000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 1000000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 1000000, "group_size": 1000000, "meter_peak_bytes": 480, "mode": "count", "rows": 1, "scan_rows": 1000000} +{"active_groups": 1, "facts": 1000000, "group_size": 1000000, "meter_peak_bytes": 40000480, "mode": "distinct", "rows": 1, "scan_rows": 1000000} +{"active_groups": 1, "facts": 1000000, "group_size": 1000000, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 1, "scan_rows": 1000000} +{"active_groups": 1, "facts": 1000000, "group_size": 1000000, "meter_peak_bytes": 40000480, "mode": "distinct_limit", "rows": 1, "scan_rows": 1000000} +{"active_groups": 1, "facts": 10000000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count", "rows": 625000, "scan_rows": 10000000} +{"active_groups": 1, "facts": 10000000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct", "rows": 625000, "scan_rows": 10000000} +{"active_groups": 1, "facts": 10000000, "group_size": 16, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 10000000, "group_size": 16, "meter_peak_bytes": 1120, "mode": "distinct_limit", "rows": 10, "scan_rows": 1024} +{"active_groups": 1, "facts": 10000000, "group_size": 10000000, "meter_peak_bytes": 480, "mode": "count", "rows": 1, "scan_rows": 10000000} +{"active_groups": 1, "facts": 10000000, "group_size": 10000000, "meter_peak_bytes": 400000480, "mode": "distinct", "rows": 1, "scan_rows": 10000000} +{"active_groups": 1, "facts": 10000000, "group_size": 10000000, "meter_peak_bytes": 480, "mode": "count_limit", "rows": 1, "scan_rows": 10000000} +{"active_groups": 1, "facts": 10000000, "group_size": 10000000, "meter_peak_bytes": 400000480, "mode": "distinct_limit", "rows": 1, "scan_rows": 10000000} diff --git a/docs/benchmarks/641-ordered-groups-startup.jsonl b/docs/benchmarks/641-ordered-groups-startup.jsonl new file mode 100644 index 0000000000..85142e49f0 --- /dev/null +++ b/docs/benchmarks/641-ordered-groups-startup.jsonl @@ -0,0 +1,72 @@ +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.674, "min_us": 22.026, "max_us": 104.849, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7276, "median_us": 133.655, "min_us": 130.988, "max_us": 431.839, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.995, "min_us": 23.117, "max_us": 113.416, "rows": 1, "peak_rss_kb": 3856} +{"round": 1, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7226, "median_us": 134.233, "min_us": 132.528, "max_us": 1518.818, "rows": 1, "peak_rss_kb": 3748} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.818, "min_us": 22.264, "max_us": 93.065, "rows": 1, "peak_rss_kb": 3876} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8244, "median_us": 118.322, "min_us": 116.251, "max_us": 381.241, "rows": 1, "peak_rss_kb": 3720} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.739, "min_us": 23.815, "max_us": 764.941, "rows": 1, "peak_rss_kb": 3840} +{"round": 1, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8067, "median_us": 121.436, "min_us": 118.72, "max_us": 390.368, "rows": 1, "peak_rss_kb": 3848} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.855, "min_us": 22.158, "max_us": 90.645, "rows": 1, "peak_rss_kb": 3812} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8079, "median_us": 119.914, "min_us": 117.553, "max_us": 391.067, "rows": 1, "peak_rss_kb": 3816} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.242, "min_us": 23.039, "max_us": 844.507, "rows": 1, "peak_rss_kb": 3852} +{"round": 1, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8005, "median_us": 121.969, "min_us": 119.723, "max_us": 394.257, "rows": 1, "peak_rss_kb": 3744} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7332, "median_us": 133.443, "min_us": 130.632, "max_us": 458.265, "rows": 1, "peak_rss_kb": 3744} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.276, "min_us": 22.42, "max_us": 100.122, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7188, "median_us": 134.563, "min_us": 132.583, "max_us": 2179.429, "rows": 1, "peak_rss_kb": 3656} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.072, "min_us": 23.089, "max_us": 98.641, "rows": 1, "peak_rss_kb": 3852} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8168, "median_us": 118.916, "min_us": 117.028, "max_us": 393.092, "rows": 1, "peak_rss_kb": 3704} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.538, "min_us": 21.899, "max_us": 734.686, "rows": 1, "peak_rss_kb": 3796} +{"round": 2, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8003, "median_us": 121.86, "min_us": 119.281, "max_us": 390.616, "rows": 1, "peak_rss_kb": 3764} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.871, "min_us": 24.133, "max_us": 98.908, "rows": 1, "peak_rss_kb": 3840} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8099, "median_us": 120.305, "min_us": 118.234, "max_us": 394.384, "rows": 1, "peak_rss_kb": 3808} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.511, "min_us": 22.696, "max_us": 737.639, "rows": 1, "peak_rss_kb": 3884} +{"round": 2, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7985, "median_us": 121.456, "min_us": 118.785, "max_us": 395.256, "rows": 1, "peak_rss_kb": 3776} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.606, "min_us": 23.839, "max_us": 96.842, "rows": 1, "peak_rss_kb": 3876} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.586, "min_us": 21.912, "max_us": 91.485, "rows": 1, "peak_rss_kb": 3828} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7254, "median_us": 133.625, "min_us": 131.188, "max_us": 2077.549, "rows": 1, "peak_rss_kb": 3644} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.985, "min_us": 22.973, "max_us": 94.061, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7239, "median_us": 135.559, "min_us": 133.409, "max_us": 451.335, "rows": 1, "peak_rss_kb": 3804} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.473, "min_us": 22.962, "max_us": 89.155, "rows": 1, "peak_rss_kb": 3800} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8135, "median_us": 118.442, "min_us": 116.41, "max_us": 4425.765, "rows": 1, "peak_rss_kb": 3756} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 25.257, "min_us": 24.48, "max_us": 115.982, "rows": 1, "peak_rss_kb": 3732} +{"round": 3, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8067, "median_us": 121.122, "min_us": 118.388, "max_us": 388.2, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.68, "min_us": 21.913, "max_us": 122.594, "rows": 1, "peak_rss_kb": 3884} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8042, "median_us": 120.147, "min_us": 118.0, "max_us": 1610.944, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.274, "min_us": 23.486, "max_us": 102.189, "rows": 1, "peak_rss_kb": 3824} +{"round": 3, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8024, "median_us": 121.68, "min_us": 119.57, "max_us": 388.575, "rows": 1, "peak_rss_kb": 3680} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7244, "median_us": 133.772, "min_us": 131.041, "max_us": 2171.136, "rows": 1, "peak_rss_kb": 3652} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.098, "min_us": 22.377, "max_us": 93.573, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7230, "median_us": 135.206, "min_us": 132.993, "max_us": 446.433, "rows": 1, "peak_rss_kb": 3656} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.143, "min_us": 23.177, "max_us": 106.92, "rows": 1, "peak_rss_kb": 3896} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8135, "median_us": 118.666, "min_us": 116.399, "max_us": 2227.442, "rows": 1, "peak_rss_kb": 3704} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.059, "min_us": 22.55, "max_us": 141.335, "rows": 1, "peak_rss_kb": 3716} +{"round": 4, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7937, "median_us": 121.32, "min_us": 118.428, "max_us": 409.106, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.539, "min_us": 23.615, "max_us": 97.879, "rows": 1, "peak_rss_kb": 3820} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8071, "median_us": 119.792, "min_us": 117.877, "max_us": 1634.025, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.73, "min_us": 22.07, "max_us": 87.809, "rows": 1, "peak_rss_kb": 3728} +{"round": 4, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8030, "median_us": 121.464, "min_us": 119.129, "max_us": 397.852, "rows": 1, "peak_rss_kb": 3680} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.54, "min_us": 23.702, "max_us": 101.217, "rows": 1, "peak_rss_kb": 3868} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.334, "min_us": 23.553, "max_us": 852.869, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7297, "median_us": 133.451, "min_us": 131.001, "max_us": 430.53, "rows": 1, "peak_rss_kb": 3644} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.821, "min_us": 22.855, "max_us": 110.028, "rows": 1, "peak_rss_kb": 3844} +{"round": 5, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7269, "median_us": 134.554, "min_us": 132.346, "max_us": 2125.632, "rows": 1, "peak_rss_kb": 3732} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 22.354, "min_us": 21.887, "max_us": 104.49, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8266, "median_us": 118.147, "min_us": 115.925, "max_us": 384.926, "rows": 1, "peak_rss_kb": 3720} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 26.161, "min_us": 25.321, "max_us": 113.82, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8005, "median_us": 121.465, "min_us": 118.769, "max_us": 1523.022, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.144, "min_us": 22.403, "max_us": 98.634, "rows": 1, "peak_rss_kb": 3880} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8091, "median_us": 120.756, "min_us": 118.705, "max_us": 397.431, "rows": 1, "peak_rss_kb": 3704} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.446, "min_us": 23.681, "max_us": 100.121, "rows": 1, "peak_rss_kb": 3920} +{"round": 5, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7971, "median_us": 121.656, "min_us": 119.115, "max_us": 1520.966, "rows": 1, "peak_rss_kb": 3740} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7314, "median_us": 133.126, "min_us": 130.537, "max_us": 434.248, "rows": 1, "peak_rss_kb": 3640} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.642, "min_us": 22.77, "max_us": 126.346, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "grouped", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 6902, "median_us": 136.484, "min_us": 134.558, "max_us": 19877.518, "rows": 1, "peak_rss_kb": 3752} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p8333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.079, "min_us": 23.032, "max_us": 96.566, "rows": 1, "peak_rss_kb": 3740} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8191, "median_us": 118.885, "min_us": 116.782, "max_us": 391.842, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.238, "min_us": 22.699, "max_us": 94.205, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "grouped", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7863, "median_us": 123.074, "min_us": 120.651, "max_us": 1606.044, "rows": 1, "peak_rss_kb": 3756} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p83333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.154, "min_us": 23.203, "max_us": 121.458, "rows": 1, "peak_rss_kb": 3844} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 8066, "median_us": 120.24, "min_us": 117.706, "max_us": 393.463, "rows": 1, "peak_rss_kb": 3672} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_count", "query": "(query [:find ?a (count ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 23.118, "min_us": 22.331, "max_us": 110.726, "rows": 1, "peak_rss_kb": 3776} +{"round": 6, "variant": "grouped", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 7722, "median_us": 125.159, "min_us": 123.031, "max_us": 1512.338, "rows": 1, "peak_rss_kb": 3724} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "grouped_point_distinct", "query": "(query [:find ?a (count-distinct ?a) :where [:p833333 :age ?a]])", "probe_binary_sha256": "29282193b4f9d9cc1066425dbcac3f16452b38de5a97c10b68dfa862fa0a9d98", "runs": 20000, "median_us": 24.803, "min_us": 23.933, "max_us": 104.078, "rows": 1, "peak_rss_kb": 3876} diff --git a/docs/benchmarks/641-ordered-groups.jsonl b/docs/benchmarks/641-ordered-groups.jsonl new file mode 100644 index 0000000000..7bf9107f98 --- /dev/null +++ b/docs/benchmarks/641-ordered-groups.jsonl @@ -0,0 +1,252 @@ +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 52399.234, "median_us": 50383.331, "min_us": 50121.251, "peak_rss_kb": 10072, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 49769.067, "median_us": 48269.798, "min_us": 48085.729, "peak_rss_kb": 5072, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 65319.141, "median_us": 64010.901, "min_us": 63737.96, "peak_rss_kb": 13108, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 68755.226, "median_us": 60075.009, "min_us": 59395.483, "peak_rss_kb": 4956, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 49594.872, "median_us": 47697.787, "min_us": 47393.721, "peak_rss_kb": 9840, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2145.129, "median_us": 643.044, "min_us": 636.287, "peak_rss_kb": 3752, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1530, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 68205.159, "median_us": 61140.429, "min_us": 60297.207, "peak_rss_kb": 13264, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2484.947, "median_us": 764.138, "min_us": 748.865, "peak_rss_kb": 3768, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1288, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 42464.829, "median_us": 41722.47, "min_us": 41446.225, "peak_rss_kb": 4844, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 24, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 93246.531, "median_us": 44525.994, "min_us": 44150.69, "peak_rss_kb": 4900, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 22, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 54847.669, "median_us": 53563.465, "min_us": 53387.448, "peak_rss_kb": 9932, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 19, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 60262.389, "median_us": 58192.687, "min_us": 57772.852, "peak_rss_kb": 10376, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 68634.274, "median_us": 60912.488, "min_us": 60413.928, "peak_rss_kb": 12236, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 64104.181, "median_us": 62454.616, "min_us": 62293.605, "peak_rss_kb": 12260, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 6250, "runs": 16, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 554787.764, "median_us": 545030.306, "min_us": 544501.534, "peak_rss_kb": 59608, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 496301.611, "median_us": 486871.647, "min_us": 484945.807, "peak_rss_kb": 5024, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 747528.418, "median_us": 740149.148, "min_us": 739460.27, "peak_rss_kb": 87736, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 597698.1, "median_us": 597089.603, "min_us": 596733.584, "peak_rss_kb": 5000, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 515481.019, "median_us": 511025.434, "min_us": 509607.041, "peak_rss_kb": 53812, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2056.523, "median_us": 661.81, "min_us": 633.271, "peak_rss_kb": 3756, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1506, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 705796.886, "median_us": 704074.6, "min_us": 703961.769, "peak_rss_kb": 87492, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 4365.909, "median_us": 759.131, "min_us": 749.706, "peak_rss_kb": 3812, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1281, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 400814.432, "median_us": 400598.398, "min_us": 400397.665, "peak_rss_kb": 4804, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 456951.999, "median_us": 448164.261, "min_us": 445215.838, "peak_rss_kb": 4888, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 682912.667, "median_us": 632705.966, "min_us": 628349.873, "peak_rss_kb": 105700, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 685981.425, "median_us": 671164.258, "min_us": 656618.245, "peak_rss_kb": 106396, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 687060.791, "median_us": 683660.274, "min_us": 679596.601, "peak_rss_kb": 80004, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 690485.551, "median_us": 688682.651, "min_us": 687235.542, "peak_rss_kb": 80020, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7390956.753, "median_us": 7360489.381, "min_us": 7247625.894, "peak_rss_kb": 499888, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4990474.376, "median_us": 4959859.348, "min_us": 4949137.061, "peak_rss_kb": 5088, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10079856.337, "median_us": 10078450.615, "min_us": 10021221.456, "peak_rss_kb": 893184, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6106689.598, "median_us": 6066822.259, "min_us": 6066808.353, "peak_rss_kb": 5080, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7133329.254, "median_us": 7018738.173, "min_us": 7001940.361, "peak_rss_kb": 483292, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 5408.497, "median_us": 662.336, "min_us": 647.565, "peak_rss_kb": 3712, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1470, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9555214.739, "median_us": 9449043.072, "min_us": 9428363.155, "peak_rss_kb": 892608, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2480.613, "median_us": 760.462, "min_us": 747.155, "peak_rss_kb": 3756, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 0, "rows": 10, "runs": 1293, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4058861.606, "median_us": 4005100.276, "min_us": 4001489.793, "peak_rss_kb": 4876, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4572231.182, "median_us": 4553985.575, "min_us": 4543359.186, "peak_rss_kb": 4876, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6904067.838, "median_us": 6891085.237, "min_us": 6872080.85, "peak_rss_kb": 669348, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7381744.073, "median_us": 7369945.777, "min_us": 7360847.505, "peak_rss_kb": 669332, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 0, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7302018.365, "median_us": 7296066.459, "min_us": 7252314.932, "peak_rss_kb": 766568, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7521829.816, "median_us": 7502562.862, "min_us": 7472853.298, "peak_rss_kb": 763488, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 0, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 49499.855, "median_us": 48864.542, "min_us": 48750.431, "peak_rss_kb": 4992, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 60532.262, "median_us": 50406.19, "min_us": 49973.417, "peak_rss_kb": 10080, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 68178.161, "median_us": 59405.527, "min_us": 59249.406, "peak_rss_kb": 4956, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 73263.386, "median_us": 64173.505, "min_us": 63952.02, "peak_rss_kb": 13216, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2147.112, "median_us": 660.495, "min_us": 636.805, "peak_rss_kb": 3840, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1494, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 49332.034, "median_us": 47792.902, "min_us": 47340.884, "peak_rss_kb": 9912, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 5673.709, "median_us": 772.013, "min_us": 757.694, "peak_rss_kb": 3788, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1266, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 63209.736, "median_us": 60982.308, "min_us": 60534.179, "peak_rss_kb": 12900, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 45166.041, "median_us": 44704.216, "min_us": 44489.276, "peak_rss_kb": 4884, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 23, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 46851.121, "median_us": 39338.441, "min_us": 39150.273, "peak_rss_kb": 4836, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 26, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 59457.661, "median_us": 55819.331, "min_us": 55454.462, "peak_rss_kb": 11248, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 55721.707, "median_us": 51533.091, "min_us": 51195.612, "peak_rss_kb": 11196, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 20, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 71500.365, "median_us": 64010.539, "min_us": 63540.715, "peak_rss_kb": 12528, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 6250, "runs": 16, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 62090.921, "median_us": 60641.531, "min_us": 60329.688, "peak_rss_kb": 12216, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 490787.324, "median_us": 489480.83, "min_us": 483007.782, "peak_rss_kb": 5008, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 562414.31, "median_us": 556891.477, "min_us": 551435.053, "peak_rss_kb": 59568, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 616752.084, "median_us": 616338.326, "min_us": 615265.804, "peak_rss_kb": 4984, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 757176.131, "median_us": 756162.875, "min_us": 755787.591, "peak_rss_kb": 87888, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 4941.256, "median_us": 646.652, "min_us": 622.737, "peak_rss_kb": 3796, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1510, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 524080.911, "median_us": 524064.389, "min_us": 521743.92, "peak_rss_kb": 56548, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 4836.307, "median_us": 752.404, "min_us": 742.939, "peak_rss_kb": 3792, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1293, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 767607.024, "median_us": 719943.779, "min_us": 712040.5, "peak_rss_kb": 87936, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 450878.5, "median_us": 450319.3, "min_us": 447379.955, "peak_rss_kb": 4920, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 402288.783, "median_us": 401695.379, "min_us": 398600.611, "peak_rss_kb": 4868, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 685949.808, "median_us": 678147.074, "min_us": 662022.328, "peak_rss_kb": 106448, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 648994.54, "median_us": 648575.612, "min_us": 647053.708, "peak_rss_kb": 106404, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 688021.367, "median_us": 684040.292, "min_us": 683006.713, "peak_rss_kb": 80160, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 686924.655, "median_us": 679276.34, "min_us": 678086.337, "peak_rss_kb": 80068, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4922713.478, "median_us": 4896264.209, "min_us": 4892932.673, "peak_rss_kb": 5128, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7564748.858, "median_us": 7524750.339, "min_us": 7473353.767, "peak_rss_kb": 493576, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6029012.81, "median_us": 6001698.176, "min_us": 5991635.855, "peak_rss_kb": 5160, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10149712.999, "median_us": 10144485.964, "min_us": 10112050.639, "peak_rss_kb": 904552, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6001.406, "median_us": 631.948, "min_us": 623.119, "peak_rss_kb": 3816, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1536, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7028234.495, "median_us": 7019891.214, "min_us": 6970827.867, "peak_rss_kb": 505160, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2481.641, "median_us": 762.962, "min_us": 743.001, "peak_rss_kb": 3812, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 1292, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9686291.568, "median_us": 9626185.934, "min_us": 9590822.075, "peak_rss_kb": 894320, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4554094.048, "median_us": 4480246.847, "min_us": 4477720.745, "peak_rss_kb": 4896, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4118278.838, "median_us": 4102975.894, "min_us": 4094346.607, "peak_rss_kb": 4852, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7352249.105, "median_us": 7343017.862, "min_us": 7324542.729, "peak_rss_kb": 668580, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6980130.887, "median_us": 6963847.412, "min_us": 6952079.166, "peak_rss_kb": 669348, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 1, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7647694.14, "median_us": 7622934.772, "min_us": 7572980.825, "peak_rss_kb": 766936, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7486161.649, "median_us": 7338633.986, "min_us": 7332766.227, "peak_rss_kb": 797084, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 1, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 52954.076, "median_us": 50713.692, "min_us": 50131.486, "peak_rss_kb": 9152, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 58581.282, "median_us": 48846.349, "min_us": 48110.185, "peak_rss_kb": 4964, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 65749.229, "median_us": 63938.265, "min_us": 63616.591, "peak_rss_kb": 13052, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 60778.402, "median_us": 60317.135, "min_us": 60130.485, "peak_rss_kb": 4972, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 56193.774, "median_us": 48065.797, "min_us": 47878.985, "peak_rss_kb": 8780, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2157.942, "median_us": 644.271, "min_us": 636.809, "peak_rss_kb": 3736, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1525, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 62221.02, "median_us": 61007.334, "min_us": 60717.862, "peak_rss_kb": 13252, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 6234.078, "median_us": 760.341, "min_us": 750.742, "peak_rss_kb": 3800, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1288, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 41339.221, "median_us": 39682.942, "min_us": 39156.08, "peak_rss_kb": 4808, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 26, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 53208.199, "median_us": 44883.008, "min_us": 44640.278, "peak_rss_kb": 4904, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 23, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 55888.562, "median_us": 53924.598, "min_us": 53690.686, "peak_rss_kb": 9852, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 19, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 60060.639, "median_us": 58035.085, "min_us": 57806.01, "peak_rss_kb": 10636, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 68783.479, "median_us": 61264.394, "min_us": 60381.196, "peak_rss_kb": 12380, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 64041.568, "median_us": 62523.137, "min_us": 61760.366, "peak_rss_kb": 12492, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 6250, "runs": 16, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 560526.803, "median_us": 560072.09, "min_us": 544959.815, "peak_rss_kb": 58488, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 488422.355, "median_us": 485027.873, "min_us": 484421.053, "peak_rss_kb": 4996, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 747991.475, "median_us": 745729.303, "min_us": 745662.019, "peak_rss_kb": 87808, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 602706.406, "median_us": 598148.514, "min_us": 597360.662, "peak_rss_kb": 4980, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 523747.341, "median_us": 510810.58, "min_us": 510612.021, "peak_rss_kb": 56540, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2071.218, "median_us": 640.779, "min_us": 630.661, "peak_rss_kb": 3796, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1535, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 717172.842, "median_us": 712289.995, "min_us": 701698.435, "peak_rss_kb": 87944, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 4925.48, "median_us": 761.609, "min_us": 745.343, "peak_rss_kb": 3752, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1282, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 403242.773, "median_us": 401757.464, "min_us": 398285.263, "peak_rss_kb": 4840, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 457216.378, "median_us": 452443.299, "min_us": 445066.965, "peak_rss_kb": 4952, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 637893.58, "median_us": 629526.262, "min_us": 628903.056, "peak_rss_kb": 106404, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 680083.294, "median_us": 657122.375, "min_us": 656684.504, "peak_rss_kb": 106396, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 672914.828, "median_us": 671562.717, "min_us": 670063.746, "peak_rss_kb": 80872, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 715647.115, "median_us": 712347.765, "min_us": 711245.365, "peak_rss_kb": 80112, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7411089.553, "median_us": 7336914.832, "min_us": 7286581.948, "peak_rss_kb": 499292, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4965376.826, "median_us": 4965215.965, "min_us": 4959015.286, "peak_rss_kb": 5148, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10211283.37, "median_us": 10177704.899, "min_us": 10177353.648, "peak_rss_kb": 893152, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6092906.895, "median_us": 6073151.407, "min_us": 6071219.156, "peak_rss_kb": 5152, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6870441.205, "median_us": 6844936.815, "min_us": 6840277.184, "peak_rss_kb": 505228, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2004.211, "median_us": 652.139, "min_us": 631.47, "peak_rss_kb": 3736, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1513, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9499746.467, "median_us": 9485887.581, "min_us": 9420591.23, "peak_rss_kb": 893312, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 5543.574, "median_us": 759.399, "min_us": 743.782, "peak_rss_kb": 3788, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 2, "rows": 10, "runs": 1280, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4047792.029, "median_us": 4038046.731, "min_us": 4026425.623, "peak_rss_kb": 4860, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4556408.036, "median_us": 4556200.854, "min_us": 4542233.33, "peak_rss_kb": 4916, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6872071.701, "median_us": 6853775.762, "min_us": 6843603.807, "peak_rss_kb": 668648, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7352206.54, "median_us": 7337074.985, "min_us": 7322809.953, "peak_rss_kb": 669284, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 2, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7325359.971, "median_us": 7311188.951, "min_us": 7286486.196, "peak_rss_kb": 763260, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7563151.356, "median_us": 7544068.94, "min_us": 7509063.47, "peak_rss_kb": 763248, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 2, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 50545.518, "median_us": 48894.685, "min_us": 48147.956, "peak_rss_kb": 4972, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 59662.116, "median_us": 51653.48, "min_us": 50991.269, "peak_rss_kb": 8448, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 61525.01, "median_us": 59274.35, "min_us": 59087.312, "peak_rss_kb": 4940, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 65032.438, "median_us": 63255.054, "min_us": 62896.556, "peak_rss_kb": 13272, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 5387.925, "median_us": 643.967, "min_us": 634.117, "peak_rss_kb": 3756, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1515, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 49478.462, "median_us": 48247.636, "min_us": 47300.979, "peak_rss_kb": 9836, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2524.677, "median_us": 768.333, "min_us": 759.025, "peak_rss_kb": 3816, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1276, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 70247.421, "median_us": 60123.973, "min_us": 59900.782, "peak_rss_kb": 13248, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 47018.257, "median_us": 44823.652, "min_us": 44624.464, "peak_rss_kb": 4880, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 23, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 48801.879, "median_us": 39383.937, "min_us": 39101.583, "peak_rss_kb": 4912, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 26, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 60249.335, "median_us": 58677.114, "min_us": 58502.112, "peak_rss_kb": 10636, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 55425.968, "median_us": 53680.259, "min_us": 52846.137, "peak_rss_kb": 10556, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 19, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 69991.361, "median_us": 62533.097, "min_us": 61515.266, "peak_rss_kb": 12208, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 6250, "runs": 16, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 64156.041, "median_us": 60634.418, "min_us": 60502.903, "peak_rss_kb": 12356, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 491784.543, "median_us": 484260.963, "min_us": 481825.286, "peak_rss_kb": 5040, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 563623.103, "median_us": 553063.408, "min_us": 552274.471, "peak_rss_kb": 56512, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 598105.258, "median_us": 593336.661, "min_us": 592016.832, "peak_rss_kb": 4952, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 809144.394, "median_us": 760701.088, "min_us": 755881.621, "peak_rss_kb": 87884, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 6413.755, "median_us": 644.11, "min_us": 626.498, "peak_rss_kb": 3808, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1519, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 524440.3, "median_us": 524049.724, "min_us": 521855.715, "peak_rss_kb": 53928, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 4969.951, "median_us": 755.109, "min_us": 743.198, "peak_rss_kb": 3748, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1293, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 724533.452, "median_us": 721718.976, "min_us": 715332.255, "peak_rss_kb": 87888, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 457956.948, "median_us": 447294.407, "min_us": 446507.092, "peak_rss_kb": 4908, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 409456.395, "median_us": 402600.098, "min_us": 402096.675, "peak_rss_kb": 4924, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 676408.554, "median_us": 667416.472, "min_us": 655953.319, "peak_rss_kb": 105768, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 648066.417, "median_us": 646329.266, "min_us": 639189.415, "peak_rss_kb": 106404, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 705792.257, "median_us": 704524.189, "min_us": 701547.646, "peak_rss_kb": 80124, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 685476.171, "median_us": 680409.098, "min_us": 677113.751, "peak_rss_kb": 84104, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4910060.071, "median_us": 4891532.234, "min_us": 4882647.274, "peak_rss_kb": 5136, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7517229.238, "median_us": 7435150.392, "min_us": 7386864.739, "peak_rss_kb": 500376, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6028743.775, "median_us": 6017425.19, "min_us": 5998684.462, "peak_rss_kb": 5204, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10172649.042, "median_us": 10161217.033, "min_us": 10145392.188, "peak_rss_kb": 893340, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 5161.37, "median_us": 630.652, "min_us": 622.392, "peak_rss_kb": 3748, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1544, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7035286.558, "median_us": 6991801.965, "min_us": 6915366.777, "peak_rss_kb": 505060, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2481.224, "median_us": 749.813, "min_us": 741.032, "peak_rss_kb": 3772, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 1306, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9641347.028, "median_us": 9498801.811, "min_us": 9497790.226, "peak_rss_kb": 893312, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4510972.932, "median_us": 4488678.751, "min_us": 4464944.764, "peak_rss_kb": 4924, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4112849.731, "median_us": 4110888.595, "min_us": 4109857.353, "peak_rss_kb": 4872, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7378488.755, "median_us": 7353623.68, "min_us": 7320490.909, "peak_rss_kb": 669308, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6948749.195, "median_us": 6932084.278, "min_us": 6912878.993, "peak_rss_kb": 669324, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 3, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7671281.475, "median_us": 7653239.993, "min_us": 7563053.293, "peak_rss_kb": 767468, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7414812.104, "median_us": 7411127.914, "min_us": 7377929.165, "peak_rss_kb": 796148, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 3, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 52153.925, "median_us": 50132.101, "min_us": 49877.151, "peak_rss_kb": 9964, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 50593.803, "median_us": 48966.595, "min_us": 48248.963, "peak_rss_kb": 5020, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 70705.373, "median_us": 62988.793, "min_us": 62812.886, "peak_rss_kb": 13416, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 60565.991, "median_us": 59939.007, "min_us": 59837.445, "peak_rss_kb": 5052, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 50587.86, "median_us": 49152.093, "min_us": 48249.615, "peak_rss_kb": 8524, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 4956.181, "median_us": 667.0, "min_us": 648.237, "peak_rss_kb": 3804, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1459, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 61851.067, "median_us": 60861.506, "min_us": 60631.688, "peak_rss_kb": 13456, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2497.088, "median_us": 759.841, "min_us": 747.705, "peak_rss_kb": 3780, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1295, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 47055.297, "median_us": 39545.452, "min_us": 39296.433, "peak_rss_kb": 4796, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 26, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 46170.009, "median_us": 44128.61, "min_us": 43997.272, "peak_rss_kb": 4876, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 23, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 61671.157, "median_us": 51435.091, "min_us": 50668.531, "peak_rss_kb": 11188, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 19, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 59540.839, "median_us": 57578.792, "min_us": 55522.41, "peak_rss_kb": 9932, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 62901.504, "median_us": 61565.572, "min_us": 60630.974, "peak_rss_kb": 12144, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 116814.059, "median_us": 61648.604, "min_us": 61436.435, "peak_rss_kb": 12300, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 6250, "runs": 16, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 560687.725, "median_us": 560460.051, "min_us": 549597.284, "peak_rss_kb": 59436, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 488150.242, "median_us": 484117.733, "min_us": 484062.228, "peak_rss_kb": 4968, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 756569.329, "median_us": 751174.105, "min_us": 747807.833, "peak_rss_kb": 87852, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 602501.217, "median_us": 597700.749, "min_us": 594861.882, "peak_rss_kb": 5008, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 524501.167, "median_us": 516285.291, "min_us": 513629.257, "peak_rss_kb": 56556, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2038.529, "median_us": 644.265, "min_us": 634.463, "peak_rss_kb": 3848, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1528, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 711912.53, "median_us": 706795.06, "min_us": 703498.111, "peak_rss_kb": 87560, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2478.07, "median_us": 751.035, "min_us": 740.719, "peak_rss_kb": 3748, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1305, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 405804.215, "median_us": 397677.995, "min_us": 395279.454, "peak_rss_kb": 4820, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 447590.112, "median_us": 446741.349, "min_us": 445560.751, "peak_rss_kb": 4900, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 633019.621, "median_us": 630500.556, "min_us": 626842.96, "peak_rss_kb": 106404, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 687405.064, "median_us": 686451.75, "min_us": 660464.601, "peak_rss_kb": 106448, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 724773.798, "median_us": 667128.687, "min_us": 666296.849, "peak_rss_kb": 80068, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 695792.172, "median_us": 692372.104, "min_us": 690142.851, "peak_rss_kb": 80004, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7326427.864, "median_us": 7307251.412, "min_us": 7230427.291, "peak_rss_kb": 499912, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4956105.62, "median_us": 4954632.932, "min_us": 4947376.107, "peak_rss_kb": 5176, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10087313.993, "median_us": 10024921.365, "min_us": 10005984.684, "peak_rss_kb": 894584, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6113350.917, "median_us": 6078108.863, "min_us": 6072223.597, "peak_rss_kb": 5124, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7039844.181, "median_us": 6910206.511, "min_us": 6886330.546, "peak_rss_kb": 506456, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 1999.12, "median_us": 653.02, "min_us": 631.223, "peak_rss_kb": 3772, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1508, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9625375.078, "median_us": 9546405.763, "min_us": 9544434.233, "peak_rss_kb": 893312, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2478.775, "median_us": 747.945, "min_us": 737.434, "peak_rss_kb": 3760, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 4, "rows": 10, "runs": 1312, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4027898.86, "median_us": 4026320.465, "min_us": 4012415.28, "peak_rss_kb": 4856, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4574981.33, "median_us": 4550933.884, "min_us": 4516641.855, "peak_rss_kb": 4876, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6937126.743, "median_us": 6910480.747, "min_us": 6889911.741, "peak_rss_kb": 669312, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7429741.79, "median_us": 7379547.521, "min_us": 7368111.34, "peak_rss_kb": 669008, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 4, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7838225.182, "median_us": 7818178.165, "min_us": 7795315.382, "peak_rss_kb": 762988, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7567364.957, "median_us": 7562222.153, "min_us": 7526526.802, "peak_rss_kb": 762548, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 4, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 56100.541, "median_us": 48986.569, "min_us": 48237.38, "peak_rss_kb": 5012, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 6250, "runs": 21, "scale": "100k", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 52790.137, "median_us": 50250.252, "min_us": 50077.137, "peak_rss_kb": 9896, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 6250, "runs": 20, "scale": "100k", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 60546.347, "median_us": 60097.544, "min_us": 59824.824, "peak_rss_kb": 4984, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 6250, "runs": 17, "scale": "100k", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 72151.083, "median_us": 63403.454, "min_us": 63005.633, "peak_rss_kb": 13224, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 6250, "runs": 16, "scale": "100k", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 2112.085, "median_us": 666.818, "min_us": 645.806, "peak_rss_kb": 3716, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1473, "scale": "100k", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 50782.777, "median_us": 49516.712, "min_us": 49241.423, "peak_rss_kb": 9492, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 21, "scale": "100k", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 7257.339, "median_us": 757.4, "min_us": 749.076, "peak_rss_kb": 3784, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1283, "scale": "100k", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 100000, "group_size": 16, "max_us": 61954.33, "median_us": 60699.905, "min_us": 60513.637, "peak_rss_kb": 13460, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 17, "scale": "100k", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 46008.881, "median_us": 44800.115, "min_us": 44311.711, "peak_rss_kb": 4880, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 23, "scale": "100k", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 49010.459, "median_us": 39429.146, "min_us": 39259.19, "peak_rss_kb": 4908, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 26, "scale": "100k", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 59976.505, "median_us": 58491.118, "min_us": 58236.868, "peak_rss_kb": 10636, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 100000, "facts": 100000, "group_size": 100000, "max_us": 99934.868, "median_us": 54051.113, "min_us": 52993.046, "peak_rss_kb": 9932, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 18, "scale": "100k", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 63442.128, "median_us": 61596.341, "min_us": 61381.364, "peak_rss_kb": 12352, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 100000, "group_size": 16, "max_us": 63019.714, "median_us": 61377.094, "min_us": 61292.16, "peak_rss_kb": 12200, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 6250, "runs": 17, "scale": "100k", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 488639.646, "median_us": 481954.96, "min_us": 481276.524, "peak_rss_kb": 5020, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 564211.641, "median_us": 553534.962, "min_us": 552727.131, "peak_rss_kb": 59664, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 604956.767, "median_us": 600835.906, "min_us": 599661.093, "peak_rss_kb": 4988, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 764432.508, "median_us": 757016.692, "min_us": 753066.596, "peak_rss_kb": 87864, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2068.978, "median_us": 651.516, "min_us": 641.904, "peak_rss_kb": 3716, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1506, "scale": "1m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 536947.166, "median_us": 529832.604, "min_us": 529087.031, "peak_rss_kb": 56648, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 2487.252, "median_us": 754.094, "min_us": 746.842, "peak_rss_kb": 3756, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1308, "scale": "1m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 1000000, "group_size": 16, "max_us": 725244.734, "median_us": 715422.122, "min_us": 714736.6, "peak_rss_kb": 87972, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 448056.56, "median_us": 445863.071, "min_us": 443790.399, "peak_rss_kb": 4884, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 402916.099, "median_us": 400325.898, "min_us": 399017.259, "peak_rss_kb": 4836, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 690287.175, "median_us": 685305.045, "min_us": 681887.488, "peak_rss_kb": 106448, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 1000000, "facts": 1000000, "group_size": 1000000, "max_us": 693112.292, "median_us": 648648.26, "min_us": 638163.836, "peak_rss_kb": 106404, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "1m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 689260.91, "median_us": 683721.22, "min_us": 678738.345, "peak_rss_kb": 80672, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 1000000, "group_size": 16, "max_us": 700296.703, "median_us": 687244.639, "min_us": 679956.587, "peak_rss_kb": 79996, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 62500, "runs": 3, "scale": "1m", "shape": "sum_distinct_control", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 4916826.758, "median_us": 4897130.178, "min_us": 4889773.814, "peak_rss_kb": 5188, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 7509912.508, "median_us": 7475955.018, "min_us": 7427168.246, "peak_rss_kb": 492676, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "count", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6068738.814, "median_us": 6001405.2, "min_us": 5992124.763, "peak_rss_kb": 5096, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 10100155.84, "median_us": 10079185.274, "min_us": 10076115.191, "peak_rss_kb": 888224, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "distinct", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2012.326, "median_us": 636.557, "min_us": 628.795, "peak_rss_kb": 3780, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1546, "scale": "10m", "shape": "count_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 6971700.672, "median_us": 6885260.209, "min_us": 6870492.162, "peak_rss_kb": 505940, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "count_limit", "variant": "parent"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 2469.34, "median_us": 756.634, "min_us": 742.388, "peak_rss_kb": 3860, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 1297, "scale": "10m", "shape": "distinct_limit", "variant": "grouped"} +{"expected_aggregate_value": 16, "facts": 10000000, "group_size": 16, "max_us": 9665168.56, "median_us": 9594324.762, "min_us": 9572281.496, "peak_rss_kb": 894116, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "distinct_limit", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4510932.402, "median_us": 4471287.113, "min_us": 4454561.527, "peak_rss_kb": 4892, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 4101930.471, "median_us": 4095780.747, "min_us": 4094120.745, "peak_rss_kb": 4960, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_count", "variant": "parent"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 7378386.833, "median_us": 7305723.146, "min_us": 7294834.191, "peak_rss_kb": 668580, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "grouped"} +{"expected_aggregate_value": 10000000, "facts": 10000000, "group_size": 10000000, "max_us": 6956945.627, "median_us": 6940287.899, "min_us": 6932183.04, "peak_rss_kb": 668620, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (count-distinct ?e) :where [?e :group ?g] :order-by [?g] ])", "round": 5, "rows": 1, "runs": 3, "scale": "10m", "shape": "growing_distinct", "variant": "parent"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7472852.489, "median_us": 7412131.483, "min_us": 7378902.101, "peak_rss_kb": 762640, "probe_binary_sha256": "004b10ad6d7d91b1036dc32f436c4355cd60992bb2e06f17fafd57cd4e1b2feb", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "grouped"} +{"expected_aggregate_value": 1, "facts": 10000000, "group_size": 16, "max_us": 7382952.26, "median_us": 7350227.918, "min_us": 7319411.089, "peak_rss_kb": 796728, "probe_binary_sha256": "34ef561d99075296a74a0f10ddcb0383baba12e131830239457698370fa27720", "query": "(query [:find ?g (sum-distinct ?one) :where [?e :group ?g] [(+ 0 1) ?one] :order-by [?g]])", "round": 5, "rows": 625000, "runs": 3, "scale": "10m", "shape": "sum_distinct_control", "variant": "parent"} diff --git a/scripts/input_order_group_fixture.rs b/scripts/input_order_group_fixture.rs new file mode 100644 index 0000000000..ab7b5ea9e9 --- /dev/null +++ b/scripts/input_order_group_fixture.rs @@ -0,0 +1,25 @@ +//! Committed fixed-size groups for #641 query-only measurements. +//! Usage: group_fixture +//! Build separately from timing/RSS. One integer :group fact per entity. +use minigraf::{EntityId, FactRecord, LogWriter, OpenOptions, Value}; + +fn main() { + let args: Vec<_> = std::env::args().collect(); + let n: usize = args[2].parse().unwrap(); + let size: usize = args[3].parse().unwrap(); + assert!(n > 0 && size > 0); + let mut writer = LogWriter::create(&args[1], OpenOptions::new()).unwrap(); + for i in 0..n { + let tx = (i / 1000 + 1) as u64; + writer.append(&FactRecord { + entity: EntityId::from_u128(i as u128 + 1), + attribute: ":group".into(), + value: Value::Integer((i / size) as i64), + tx_count: tx, tx_id: tx, + valid_from: 0, valid_to: i64::MAX, asserted: true, + }).unwrap(); + } + writer.finish().unwrap(); + println!("{{\"facts\":{n},\"rows_per_group\":{size},\"groups\":{},\"file_bytes\":{}}}", + n.div_ceil(size), std::fs::metadata(&args[1]).unwrap().len()); +} diff --git a/scripts/input_order_group_probe.rs b/scripts/input_order_group_probe.rs new file mode 100644 index 0000000000..37e68b7755 --- /dev/null +++ b/scripts/input_order_group_probe.rs @@ -0,0 +1,50 @@ +//! Group-count probe compiled against both slice-1 and slice-2 libraries (#641). +//! Usage: probe '' +//! Build fixtures separately with input_order_group_fixture.rs. Open/thread creation +//! are excluded from timings; one warmup, at least three timed drains per process; process RSS is query-only. Worker stack: 256 KiB. + +use minigraf::{OpenOptions, Value}; +use std::time::{Duration, Instant}; + +fn rss_kb() -> u64 { + std::fs::read_to_string("/proc/self/status") + .ok() + .and_then(|text| { + text.lines() + .find(|l| l.starts_with("VmHWM:")) + .and_then(|l| l.split_whitespace().nth(1)) + .and_then(|n| n.parse().ok()) + }) + .unwrap_or(0) +} + +fn main() { + let args: Vec<_> = std::env::args().collect(); + std::thread::Builder::new().stack_size(256 * 1024).spawn(move || { + let db = OpenOptions::new().read_only(true).path(&args[1]).open().unwrap(); + let expected: usize = args[3].parse().unwrap(); + let members: i64 = args[4].parse().unwrap(); + let drain = || { + let mut cursor = db.query(&args[2]).unwrap(); + let mut rows = 0; + while let Some(batch) = cursor.next_batch(1000).unwrap() { + for row in batch.rows() { + assert!(row == &[Value::Integer(rows as i64), Value::Integer(members)], "ordered group and count"); + rows += 1; + } + } + assert_eq!(rows, expected, "expected row count"); + }; + for _ in 0..1 { drain(); } + let start = Instant::now(); + let mut times = Vec::new(); + while times.len() < 20_000 && (times.len() < 3 || start.elapsed() < Duration::from_secs(1)) { + let t = Instant::now(); + drain(); + times.push(t.elapsed().as_secs_f64() * 1_000_000.0); + } + times.sort_by(f64::total_cmp); + println!("{{\"runs\":{},\"median_us\":{:.3},\"min_us\":{:.3},\"max_us\":{:.3},\"rows\":{},\"peak_rss_kb\":{}}}", + times.len(), times[times.len() / 2], times[0], times[times.len()-1], expected, rss_kb()); + }).unwrap().join().unwrap(); +} diff --git a/src/query/datalog/aggregate.rs b/src/query/datalog/aggregate.rs index 367776178a..b578a7caf3 100644 --- a/src/query/datalog/aggregate.rs +++ b/src/query/datalog/aggregate.rs @@ -660,19 +660,27 @@ pub(crate) fn finish_groups( funcs: &[&str], ) -> Result, Vec)>> { let mut out = Vec::with_capacity(groups.len()); - 'group: for (shown, accs) in groups.into_values() { - let mut results = Vec::with_capacity(accs.len()); - for (acc, func) in accs.into_iter().zip(funcs) { - match acc.finish(func)? { - Some(v) => results.push(v), - None => continue 'group, - } + for (shown, accs) in groups.into_values() { + if let Some(results) = finish_group(accs, funcs)? { + out.push((shown, results)); } - out.push((shown, results)); } Ok(out) } +/// Finish one group's accumulators in find order, including dropped-group +/// precedence over later finish errors. Shared by both aggregate strategies. +pub(crate) fn finish_group(accs: Vec, funcs: &[&str]) -> Result>> { + let mut results = Vec::with_capacity(accs.len()); + for (acc, func) in accs.into_iter().zip(funcs) { + match acc.finish(func)? { + Some(v) => results.push(v), + None => return Ok(None), + } + } + Ok(Some(results)) +} + /// A window function's running value over a sorted partition (spec §4.2). pub(crate) enum Running { Count(i64), diff --git a/src/query/engine/aggregate.rs b/src/query/engine/aggregate.rs index 79ef007f55..13b95c4f22 100644 --- a/src/query/engine/aggregate.rs +++ b/src/query/engine/aggregate.rs @@ -7,7 +7,11 @@ //! accumulator needs one: `count` reads only whether a cell is `nil`, and //! `count-distinct` keeps the keys of its cells. When the input ends, the //! groups are sorted by their values, as the executor's `BTreeMap` orders -//! them, and finished in that order (spec §3.3). A group returns, of the +//! them, and finished in that order (spec §3.3). A snapshot-proved scalar +//! group key with only built-in count/count-distinct instead holds one group, +//! finishing it at the next key and returning a bounded batch (#641). +//! Other aggregates keep full-drain validation, including under Limit. +//! A group returns, of the //! floats its key finds equal (`-0.0` and `0.0`, NaNs), the least by //! `value_order`, as the executor does. @@ -19,13 +23,19 @@ use super::meter::{ }; use super::project::value; use super::{BATCH_ROWS, Counters, Ctx, Operator}; +use crate::error::{ErrorCode, err_coded}; use crate::graph::types::Value; -use crate::query::datalog::aggregate::{Agg, Groups, finish_groups, value_order}; +use crate::query::datalog::aggregate::{Agg, Groups, finish_group, finish_groups, value_order}; use anyhow::Result; use std::collections::{HashMap, HashSet}; use std::mem::size_of; use std::sync::Arc; +#[cfg(test)] +thread_local! { + pub(super) static ORDERED_MAX_GROUPS: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + /// One aggregate of one group. enum Acc { /// The number of cells that are not `nil`. @@ -108,6 +118,8 @@ pub(crate) struct Aggregate { /// Each aggregate's function and argument slot. aggs: Vec<(String, usize)>, zero_row: bool, + ordered: bool, + ended: bool, /// Each group's index in `rows`, by its key. table: HashMap, usize>, rows: Vec, @@ -126,90 +138,216 @@ impl Aggregate { groups: Vec, aggs: Vec<(String, usize)>, zero_row: bool, + ordered: bool, meter: &Arc, ) -> Self { + #[cfg(test)] + if ordered { + ORDERED_MAX_GROUPS.with(|n| n.set(0)); + } Aggregate { child, groups, aggs, zero_row, + ordered, + ended: false, table: HashMap::new(), rows: Vec::new(), out: None, held: Held::new(meter, "Aggregate"), finished: Held::new(meter, "Aggregate"), - counters: Counters::new("Aggregate"), + counters: Counters::new(if ordered { + "AggregateOrdered" + } else { + "Aggregate" + }), } } + fn key(&self, batch: &Batch, i: usize) -> Vec { + let null = Cell::Val(Scalar::Null); + self.groups + .iter() + .map(|&s| JoinKey::group(batch.cols.get(s).and_then(|c| c.get(i)).unwrap_or(&null))) + .collect() + } + /// Step the group of each row of `batch`. fn take(&mut self, batch: &Batch, ctx: &mut Ctx<'_>) -> Result<()> { + for i in 0..batch.len { + self.step(self.key(batch, i), batch, i, ctx)?; + } + Ok(()) + } + + fn step( + &mut self, + key: Vec, + batch: &Batch, + i: usize, + ctx: &mut Ctx<'_>, + ) -> Result<()> { let null = Cell::Val(Scalar::Null); - // A slot a row lacks reads `nil`, as a missing binding does on the - // executor. let cell = |slot: usize, i: usize| batch.cols.get(slot).and_then(|c| c.get(i)); - for i in 0..batch.len { - let key: Vec = self - .groups - .iter() - .map(|&s| JoinKey::group(cell(s, i).unwrap_or(&null))) - .collect(); - let at = match self.table.get(&key) { - Some(&at) => at, - None => { - let accs = self - .aggs - .iter() - .map(|(func, _)| Acc::new(func, ctx)) - .collect::>>()?; - let cells: Vec = self - .groups - .iter() - .map(|&s| cell(s, i).unwrap_or(&null).clone()) - .collect(); - // The key, its index, the group: its cells and - // accumulators. - let entry = keys_bytes(&key) + size_of::() + HASH_ENTRY_OVERHEAD; - let group = size_of::() - + cells.iter().map(cell_bytes).sum::() - + accs.len() * size_of::(); - let n = entry + group; - self.held.charge(n)?; - let refused = growth(self.table.capacity(), entry) - .saturating_add(growth(self.rows.capacity(), size_of::())); - let reserved = self - .table - .try_reserve(1) - .and_then(|()| self.rows.try_reserve(1)); - self.held.reserve(reserved, n, refused)?; - self.rows.push(Group { cells, accs }); - self.table.insert(key, self.rows.len() - 1); - self.rows.len() - 1 - } - }; - let Some(group) = self.rows.get_mut(at) else { - continue; - }; - // Of the floats a key finds equal, the group returns the least - // by `value_order`, as the executor does: the only cells that - // are key-equal and not the same value. - for (shown, &s) in group.cells.iter_mut().zip(&self.groups) { - if let (Cell::Val(Scalar::Float(old)), Some(Cell::Val(Scalar::Float(new)))) = - (&*shown, cell(s, i)) - && value_order(&Value::Float(*new), &Value::Float(*old)).is_lt() - { - *shown = Cell::Val(Scalar::Float(*new)); + let at = match self.table.get(&key) { + Some(&at) => at, + None => { + let accs = self + .aggs + .iter() + .map(|(func, _)| Acc::new(func, ctx)) + .collect::>>()?; + let cells: Vec = self + .groups + .iter() + .map(|&s| cell(s, i).unwrap_or(&null).clone()) + .collect(); + // The key, its index, the group: its cells and + // accumulators. + let entry = keys_bytes(&key) + size_of::() + HASH_ENTRY_OVERHEAD; + let group = size_of::() + + cells.iter().map(cell_bytes).sum::() + + accs.len() * size_of::(); + let n = entry + group; + self.held.charge(n)?; + let refused = growth(self.table.capacity(), entry) + .saturating_add(growth(self.rows.capacity(), size_of::())); + let reserved = self + .table + .try_reserve(1) + .and_then(|()| self.rows.try_reserve(1)); + self.held.reserve(reserved, n, refused)?; + self.rows.push(Group { cells, accs }); + #[cfg(test)] + if self.ordered { + ORDERED_MAX_GROUPS.with(|n| n.set(n.get().max(self.rows.len()))); } + self.table.insert(key, self.rows.len() - 1); + self.rows.len() - 1 } - for (acc, (_, slot)) in group.accs.iter_mut().zip(&self.aggs) { - if let Some(c) = cell(*slot, i) { - acc.step(c, &mut self.held, ctx)?; - } + }; + let Some(group) = self.rows.get_mut(at) else { + return Ok(()); + }; + // Of the floats a key finds equal, the group returns the least + // by `value_order`, as the executor does: the only cells that + // are key-equal and not the same value. + for (shown, &s) in group.cells.iter_mut().zip(&self.groups) { + if let (Cell::Val(Scalar::Float(old)), Some(Cell::Val(Scalar::Float(new)))) = + (&*shown, cell(s, i)) + && value_order(&Value::Float(*new), &Value::Float(*old)).is_lt() + { + *shown = Cell::Val(Scalar::Float(*new)); } } + for (acc, (_, slot)) in group.accs.iter_mut().zip(&self.aggs) { + if let Some(c) = cell(*slot, i) { + acc.step(c, &mut self.held, ctx)?; + } + } + Ok(()) + } + + /// Only scalar keys and infallible count accumulators reach this path. + /// Result rows stay charged until moved into a passing output batch. + fn finish_one(&mut self, ctx: &mut Ctx<'_>) -> Result>> { + self.table.clear(); + let Some(group) = self.rows.pop() else { + return Ok(None); + }; + let scratch = 4 * size_of::>() + + group.cells.len() * size_of::() + + group.accs.len() * (size_of::() + size_of::() + size_of::<&str>()); + self.finished.charge(scratch)?; + let shown = group + .cells + .iter() + .map(|c| value(c, ctx)) + .collect::>>()?; + let accs = group.accs.into_iter().map(Acc::into_agg).collect(); + let funcs: Vec<&str> = self.aggs.iter().map(|(f, _)| f.as_str()).collect(); + let results = finish_group(accs, &funcs)?; + self.held.release(); + let Some(results) = results else { + self.finished.uncharge(scratch); + return Ok(None); + }; + let width = shown.len() + results.len(); + let bytes = size_of::>() + width * size_of::(); + self.finished.charge(bytes)?; + let mut row = Vec::new(); + self.finished.reserve( + row.try_reserve_exact(width), + bytes, + width * size_of::(), + )?; + for v in shown.iter().chain(&results) { + row.push(Cell::of_value(ctx.ids, ctx.keys, v)?); + } + self.finished.uncharge(scratch); + Ok(Some(row)) + } + + fn emit_one(&mut self, out: &mut Batch, ctx: &mut Ctx<'_>) -> Result<()> { + if let Some(row) = self.finish_one(ctx)? { + self.finished.uncharge(row_bytes(&row)); + out.push(&mut row.into_iter().map(Some).collect::>()); + } Ok(()) } + fn next_ordered(&mut self, ctx: &mut Ctx<'_>) -> Result> { + if self.ended { + return Ok(None); + } + loop { + let mut out = Batch::new(self.groups.len() + self.aggs.len()); + if let Some(batch) = self.child.next_batch(ctx)? { + debug_assert!(batch.len <= BATCH_ROWS); + self.counters.rows_in += batch.len as u64; + for i in 0..batch.len { + let key = self.key(&batch, i); + if !self.table.is_empty() && !self.table.contains_key(&key) { + let previous = self.rows.last().and_then(|g| g.cells.first()); + let next = self + .groups + .first() + .and_then(|s| batch.cols.get(*s)) + .and_then(|c| c.get(i)); + let (Some(previous), Some(next)) = (previous, next) else { + return Err(err_coded!( + ErrorCode::Int032, + "ordered aggregate without its group key" + )); + }; + if !value(next, ctx)?.cmp(&value(previous, ctx)?).is_gt() { + return Err(err_coded!( + ErrorCode::Int032, + "ordered aggregate input is not increasing" + )); + } + self.emit_one(&mut out, ctx)?; + } + self.step(key, &batch, i, ctx)?; + } + // Every child caps batches at BATCH_ROWS. At most one group + // completes per input row, so this needs no retained lookahead. + ctx.ids.end_pull(); + } else { + self.ended = true; + self.emit_one(&mut out, ctx)?; + } + if out.len > 0 { + self.counters.out(&out); + return Ok(Some(out)); + } + if self.ended { + return Ok(None); + } + } + } + /// The rows of every group, in the order of their values, finished. fn finish(&mut self, ctx: &mut Ctx<'_>) -> Result>> { if self.table.is_empty() && self.zero_row { @@ -268,6 +406,9 @@ impl Aggregate { impl Operator for Aggregate { fn next_batch(&mut self, ctx: &mut Ctx<'_>) -> Result> { + if self.ordered { + return self.next_ordered(ctx); + } if self.out.is_none() { while let Some(batch) = self.child.next_batch(ctx)? { self.counters.rows_in += batch.len as u64; @@ -291,6 +432,7 @@ impl Operator for Aggregate { } fn rewind(&mut self, seed: &[Cell]) { + self.ended = false; self.table.clear(); self.rows.clear(); self.out = None; @@ -300,6 +442,7 @@ impl Operator for Aggregate { } fn close(&mut self) { + self.ended = true; self.table = HashMap::new(); self.rows = Vec::new(); self.out = Some(Vec::new()); diff --git a/src/query/engine/aggregate_order_tests.rs b/src/query/engine/aggregate_order_tests.rs new file mode 100644 index 0000000000..8a6076d45e --- /dev/null +++ b/src/query/engine/aggregate_order_tests.rs @@ -0,0 +1,561 @@ +//! Snapshot-certified one-group aggregation (#641). +use super::{BATCH_ROWS, Counters}; +use crate::{Minigraf, Value}; + +fn fixture(n: usize, size: usize) -> (tempfile::TempDir, Minigraf) { + let dir = tempfile::tempdir().unwrap(); + let db = Minigraf::open(dir.path().join("groups.graph")).unwrap(); + let facts: String = (0..n) + .map(|i| format!("[:e{i} :bucket {}] [:e{i} :item {}]", i / size, i % 3)) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + (dir, db) +} + +fn collect(db: &Minigraf, query: &str) -> (Vec>, Vec, usize) { + let mut cursor = db.query(&format!("(query {query})")).unwrap(); + let stream = cursor.stream_mut().unwrap(); + let meter = stream.meter().clone(); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + assert_eq!(meter.used(), 0, "drain releases operator state"); + (rows, stream.counters(), meter.peak()) +} + +fn ordered(counters: &[Counters]) -> bool { + counters.iter().any(|c| c.op == "AggregateOrdered") +} + +#[test] +fn counts_stream_across_batch_boundaries_and_skip_the_unique_group_sort() { + let (_dir, db) = fixture(4099, 17); + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let query = "[:find (count ?e) ?g (count-distinct ?v) :where [?e :bucket ?g] \ + [?e :item ?v] :order-by [?g]]"; + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, query) + }; + let (rows, counters, _) = collect(&db, query); + assert!( + rows == expected, + "identical ordered group results and projection" + ); + assert!(ordered(&counters), "one-group aggregation selected"); + super::aggregate::ORDERED_MAX_GROUPS.with(|n| assert_eq!(n.get(), 1)); + assert!( + counters.iter().all(|c| c.op != "Sort"), + "the group key is unique" + ); + assert_eq!(rows.len(), 4099usize.div_ceil(17)); + for (g, row) in rows.iter().enumerate() { + let count = 17.min(4099 - g * 17) as i64; + assert!( + row == &vec![ + Value::Integer(count), + Value::Integer(g as i64), + Value::Integer(count.min(3)) + ], + "count and distinct membership reset at each group" + ); + } +} + +#[test] +fn a_group_limit_stops_after_the_requested_group_and_one_input_batch() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let (_dir, db) = fixture(4099, 17); + let (rows, counters, _) = collect(&db, "[:find ?g (count ?e) :where [?e :bucket ?g] :limit 1]"); + assert!(rows == vec![vec![Value::Integer(0), Value::Integer(17)]]); + assert!( + ordered(&counters), + "group adjacency is enough without a query Sort" + ); + let scan = counters.iter().find(|c| c.op == "Scan").unwrap(); + assert!( + scan.rows_in <= (17 + BATCH_ROWS) as u64, + "do not drain all groups" + ); + let (rows, counters, _) = collect( + &db, + "[:find ?g (count-distinct ?v) :where [?e :bucket ?g] [?e :item ?v] :order-by [?g] :offset 2 :limit 3]", + ); + assert!(ordered(&counters)); + assert!( + rows == (2..5) + .map(|g| vec![Value::Integer(g), Value::Integer(3)]) + .collect::>() + ); + let aggregate = counters + .iter() + .find(|c| c.op == "AggregateOrdered") + .unwrap(); + assert!( + aggregate.rows_in <= (5 * 17 + BATCH_ROWS) as u64, + "a probe join still stops at group demand plus one child batch" + ); +} + +#[test] +fn hidden_with_groups_multiple_keys_and_fallible_aggregates_keep_the_hash_path() { + let (_dir, db) = fixture(64, 4); + for query in [ + "[:find ?g (count ?e) :with ?v :where [?e :bucket ?g] [?e :item ?v]]", + "[:find (count ?e) :with ?g :where [?e :bucket ?g]]", + "[:find ?g ?v (count ?e) :where [?e :bucket ?g] [?e :item ?v]]", + "[:find ?g (sum ?v) :where [?e :bucket ?g] [?e :item ?v] :limit 1]", + "[:find ?g (min ?v) :where [?e :bucket ?g] [?e :item ?v] :limit 1]", + "[:find ?g (sum-distinct ?v) :where [?e :bucket ?g] [?e :item ?v] :limit 1]", + ] { + let (_, counters, _) = collect(&db, query); + assert!( + !ordered(&counters), + "unproved aggregate scope retains its original strategy" + ); + } +} + +#[test] +fn descending_or_aggregate_first_orders_keep_sort_after_streaming_groups() { + let (_dir, db) = fixture(67, 4); + for query in [ + "[:find ?g (count ?e) :where [?e :bucket ?g] :order-by [?g :desc] :limit 3]", + "[:find ?g (count ?e) :where [?e :bucket ?g] :order-by [(count ?e)] :limit 3]", + ] { + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, query) + }; + let (actual, counters, _) = collect(&db, query); + assert!(ordered(&counters)); + assert!(counters.iter().any(|c| c.op == "Sort")); + assert!(actual == expected); + } +} + +fn two_input_batches() -> usize { + use super::cell::{Cell, Scalar}; + use super::meter::cell_bytes; + 2 * (std::mem::size_of::() + + 2 * std::mem::size_of::>() + + BATCH_ROWS * (cell_bytes(&Cell::Eid(1)) + cell_bytes(&Cell::Val(Scalar::Int(0))))) +} + +#[test] +fn group_state_does_not_grow_with_the_number_of_finished_groups() { + let mut peaks = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, 1); + let (rows, counters, peak) = + collect(&db, "[:find ?g (count-distinct ?e) :where [?e :bucket ?g]]"); + assert_eq!(rows.len(), n); + assert!(ordered(&counters)); + peaks.push(peak); + } + assert!( + peaks[1] <= peaks[0] + two_input_batches(), + "finished groups are not retained" + ); +} + +#[test] +fn a_single_distinct_group_remains_an_explicit_linear_memory_control() { + let mut peaks = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, n); + let (rows, counters, peak) = + collect(&db, "[:find ?g (count-distinct ?e) :where [?e :bucket ?g]]"); + assert!(rows == vec![vec![Value::Integer(0), Value::Integer(n as i64)]]); + assert!(ordered(&counters)); + peaks.push(peak); + } + assert!( + peaks[1] > 4 * peaks[0], + "members within one group still occupy memory" + ); +} + +#[test] +fn a_proved_range_with_no_live_rows_emits_no_group() { + let (_dir, db) = fixture(1, 1); + db.execute("(retract [[:e0 :bucket 0]])").unwrap(); + db.checkpoint().unwrap(); + let (rows, counters, _) = collect(&db, "[:find ?g (count ?e) :where [?e :bucket ?g]]"); + assert!(rows.is_empty()); + assert!( + ordered(&counters), + "raw integer history proves a range even when its rows were retracted" + ); +} + +#[test] +fn fallible_finishes_keep_later_group_errors_and_dropped_group_precedence() { + let (_dir, db) = fixture(4096, 16); + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + db.execute("(transact [[:e4095 :item \"bad\"]])").unwrap(); + db.checkpoint().unwrap(); + for func in ["sum", "sum-distinct", "min"] { + let q = + format!("(query [:find ?g ({func} ?v) :where [?e :bucket ?g] [?e :item ?v] :limit 1])"); + let mut cursor = db.query(&q).unwrap(); + assert!(!ordered(&cursor.stream_mut().unwrap().counters())); + let err = cursor + .next_batch(1) + .expect_err("late group must fail before any answer"); + assert_eq!( + err.code(), + if func == "min" { "INT-043" } else { "INT-041" } + ); + } + db.execute("(transact [[:drop :bucket 999] [:drop :empty nil] [:drop :bad \"bad\"]])") + .unwrap(); + db.checkpoint().unwrap(); + let (rows, counters, _) = collect( + &db, + "[:find ?g (min ?n) (sum ?v) :where [?e :bucket ?g] [?e :empty ?n] [?e :bad ?v] :limit 1]", + ); + assert!( + rows.is_empty(), + "an earlier empty min drops the group before its bad sum" + ); + assert!(!ordered(&counters)); + let err = db.execute("(query [:find ?g (sum ?v) (min ?n) :where [?e :bucket ?g] [?e :empty ?n] [?e :bad ?v] :limit 1])").expect_err("find order chooses the first aggregate error"); + assert_eq!(err.code(), "INT-041"); +} + +#[test] +fn late_callbacks_and_collect_set_failures_cannot_be_hidden_by_group_limit() { + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let (_dir, db) = fixture(4096, 16); + let calls = Arc::new(AtomicUsize::new(0)); + let seen = calls.clone(); + db.try_register_predicate("late?", move |_| { + if seen.fetch_add(1, Ordering::SeqCst) == 1499 { + Err(crate::UdfError::new("late callback")) + } else { + Ok(true) + } + }) + .unwrap(); + let err = db + .execute( + "(query [:find ?g (count ?e) :where [?e :bucket ?g] [(= (late? ?g) true)] :limit 1])", + ) + .expect_err("callback must be reached"); + assert_eq!(err.code(), "QRY-014"); + assert_eq!(calls.load(Ordering::SeqCst), 1500); + db.execute("(transact [[:e4095 :nested #{1}]])").unwrap(); + db.checkpoint().unwrap(); + let err = db.execute("(query [:find ?g (count ?e) :where [?e :bucket ?g] [(collect-set ?e :nested) ?s] :limit 1])").expect_err("late nested set must be reached"); + assert_eq!(err.code(), "QRY-015"); +} + +#[test] +fn small_budget_succeeds_for_many_finished_groups_and_fallback_still_refuses() { + let (dir, db) = fixture(8192, 1); + drop(db); + let db = crate::OpenOptions::new() + .query_memory_limit(128 << 10) + .path(dir.path().join("groups.graph")) + .open() + .unwrap(); + let query = "[:find ?g (count ?e) :where [?e :bucket ?g]]"; + let (rows, counters, _) = collect(&db, query); + assert_eq!(rows.len(), 8192); + assert!(ordered(&counters)); + let _off = super::order::set_enabled(false); + let err = db + .execute(&format!("(query {query})")) + .expect_err("all groups exceed this budget"); + assert_eq!(err.code(), "QRY-012"); +} + +#[test] +fn pending_scope_and_prepared_queries_recompute_each_snapshot_proof() { + let (_dir, db) = fixture(64, 4); + let query = "[:find ?g (count ?e) :where [?e :bucket ?g]]"; + let prepared = db.prepare(&format!("(query {query})")).unwrap(); + assert!(ordered(&collect(&db, query).1)); + db.execute("(transact [[:outside :other 1]])").unwrap(); + assert!( + ordered(&collect(&db, query).1), + "unrelated pending facts allow the proof" + ); + db.execute("(transact [[:new :bucket -1]])").unwrap(); + let (expected, counters, _) = collect(&db, query); + assert!( + !ordered(&counters), + "in-range pending facts keep full grouping" + ); + let crate::QueryResult::QueryResults { results, .. } = prepared.execute(&[]).unwrap() else { + panic!("rows"); + }; + assert!(results == expected); + db.checkpoint().unwrap(); + let (actual, counters, _) = collect(&db, query); + assert!(ordered(&counters)); + assert!(actual == expected); + let crate::QueryResult::QueryResults { results, .. } = prepared.execute(&[]).unwrap() else { + panic!("rows"); + }; + assert!(results == expected); +} + +/// Query-only meter diagnostic over separately built committed fixtures. +/// The bench driver supplies the path/row count; never builds a fixture here. +#[test] +#[ignore] +fn committed_group_memory_probe() { + let path = std::env::var("MINIGRAF_GROUP_FIXTURE").expect("fixture path"); + let n: usize = std::env::var("MINIGRAF_GROUP_ROWS") + .unwrap() + .parse() + .unwrap(); + let group_size: usize = std::env::var("MINIGRAF_GROUP_SIZE") + .unwrap() + .parse() + .unwrap(); + let db = crate::OpenOptions::new() + .read_only(true) + .path(path) + .open() + .unwrap(); + for (mode, func, limited) in [ + ("count", "count", false), + ("distinct", "count-distinct", false), + ("count_limit", "count", true), + ("distinct_limit", "count-distinct", true), + ] { + let query = format!( + "(query [:find ?g ({func} ?e) :where [?e :group ?g] :order-by [?g] {}])", + if limited { ":limit 10" } else { "" } + ); + let mut cursor = db.query(&query).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(ordered(&stream.counters())); + let meter = stream.meter().clone(); + let mut rows = 0; + while let Some(batch) = stream.next_rows().unwrap() { + rows += batch.len(); + } + let expected = n.div_ceil(group_size); + assert_eq!(rows, if limited { 10.min(expected) } else { expected }); + assert_eq!(meter.used(), 0); + let highwater = super::aggregate::ORDERED_MAX_GROUPS.with(|n| n.get()); + assert_eq!(highwater, 1); + let scan = stream + .counters() + .into_iter() + .find(|c| c.op == "Scan") + .unwrap(); + if limited { + assert!(scan.rows_in <= (10 * group_size + BATCH_ROWS) as u64); + } + println!( + "{{\"mode\":\"{mode}\",\"facts\":{n},\"group_size\":{group_size},\"rows\":{rows},\"meter_peak_bytes\":{},\"active_groups\":{highwater},\"scan_rows\":{}}}", + meter.peak(), + scan.rows_in + ); + } +} + +#[test] +fn registered_aggregate_keeps_full_drain_under_group_limit() { + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let (_dir, db) = fixture(4096, 16); + let calls = Arc::new(AtomicUsize::new(0)); + let seen = calls.clone(); + db.try_register_aggregate( + "late-count", + || Ok(0i64), + move |acc: &mut i64, _| { + *acc += 1; + if seen.fetch_add(1, Ordering::SeqCst) == 1499 { + Err(crate::UdfError::new("late aggregate callback")) + } else { + Ok(()) + } + }, + |acc: &i64, _| Ok(Value::Integer(*acc)), + ) + .unwrap(); + let err = db + .execute("(query [:find ?g (late-count ?e) :where [?e :bucket ?g] :limit 1])") + .expect_err("must reach the aggregate callback"); + assert_eq!(err.code(), "QRY-014"); + assert_eq!(calls.load(Ordering::SeqCst), 1500); +} + +#[test] +fn a_large_transaction_uses_its_working_types_for_group_sort_proofs() { + let dir = tempfile::tempdir().unwrap(); + let db = crate::OpenOptions::new() + .transaction_chunk_facts(2) + .path(dir.path().join("working.graph")) + .open() + .unwrap(); + db.execute("(transact [[:a :bucket 0] [:b :bucket 2]])") + .unwrap(); + db.checkpoint().unwrap(); + let query = "(query [:find ?g (count ?e) :where [?e :bucket ?g] :order-by [?g]])"; + let mut staged = db.begin_write().unwrap(); + staged.execute("(transact [[:staged :bucket -1]])").unwrap(); + let before = super::order::OPTIMIZATIONS.with(std::cell::Cell::get); + staged.execute(query).unwrap(); + assert_eq!( + super::order::OPTIMIZATIONS.with(std::cell::Cell::get), + before, + "staged source stays materialized" + ); + drop(staged); + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:f :bucket -3.5] [:x :other 1] [:y :other 2]])") + .unwrap(); + let before = super::order::OPTIMIZATIONS.with(std::cell::Cell::get); + let crate::QueryResult::QueryResults { results, .. } = tx.execute(query).unwrap() else { + panic!("rows"); + }; + assert!( + results + == vec![ + vec![Value::Float(-3.5), Value::Integer(1)], + vec![Value::Integer(0), Value::Integer(1)], + vec![Value::Integer(2), Value::Integer(1)] + ], + "mixed working roots require numeric Sort after streaming groups" + ); + assert_eq!( + super::order::OPTIMIZATIONS.with(std::cell::Cell::get), + before + 1, + "working grouping is actually streamed" + ); + let err = tx.execute("(transact [[:bad :bucket \"rolled back\"] [:dup :other 1 {:valid-from \"2020-01-01\"}] [:fill :other 2] [:dup :other 1 {:valid-from \"2021-01-01\"}]])").expect_err("one triple with two windows"); + assert_eq!(err.code(), "API-011"); + let crate::QueryResult::QueryResults { results: again, .. } = tx.execute(query).unwrap() else { + panic!("rows"); + }; + assert!(results == again); + assert_eq!( + super::order::OPTIMIZATIONS.with(std::cell::Cell::get), + before + 2, + "rejected statement restores actual proof roots" + ); + drop(tx); + assert!(ordered( + &collect( + &db, + "[:find ?g (count ?e) :where [?e :bucket ?g] :order-by [?g]]" + ) + .1 + )); +} + +#[test] +fn early_cursor_close_drop_and_distinct_budget_errors_release_all_state() { + let (dir, db) = fixture(4096, 16); + for close in [false, true] { + let mut cursor = db + .query("(query [:find ?g (count-distinct ?e) :where [?e :bucket ?g]])") + .unwrap(); + assert!(ordered(&cursor.stream_mut().unwrap().counters())); + let meter = cursor.stream_mut().unwrap().meter().clone(); + assert!(cursor.next_batch(1).unwrap().is_some()); + assert!(meter.used() > 0); + if close { + cursor.close(); + } else { + drop(cursor); + } + assert_eq!(meter.used(), 0); + } + drop(db); + let db = crate::OpenOptions::new() + .query_memory_limit(1024) + .path(dir.path().join("groups.graph")) + .open() + .unwrap(); + let mut cursor = db + .query("(query [:find ?g (count-distinct ?e) :where [?e :bucket ?g]])") + .unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(ordered(&stream.counters())); + let meter = stream.meter().clone(); + let err = stream + .next_rows() + .expect_err("one distinct group exceeds this budget"); + assert_eq!(crate::MinigrafError::from(err).code(), "QRY-012"); + assert_eq!(meter.used(), 0); +} + +#[test] +fn distinct_arguments_keep_all_value_kinds_and_group_pagination() { + let (_dir, db) = fixture(64, 4); + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let long = "x".repeat(100); + db.execute(&format!("(transact [[:e0 :arg :k] [:e1 :arg :k] [:e2 :arg #uuid \"00000000-0000-0000-0000-000000000001\"] [:e3 :arg nil] [:e4 :arg \"short\"] [:e5 :arg \"{long}\"] [:e6 :arg \"{long}\"] [:e7 :arg #{{1 :k}}] [:e8 :arg #{{:k 1}}] [:e9 :arg false] [:e10 :arg -0.0] [:e11 :arg 0.0]])")).unwrap(); + db.checkpoint().unwrap(); + for tail in [ + "", + ":order-by [?g] :offset 1 :limit 2", + ":distinct :order-by [?g] :offset 1 :limit 2", + ] { + let q = format!( + "[:find ?g (count ?v) (count-distinct ?v) :where [?e :bucket ?g] [?e :arg ?v] {tail}]" + ); + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters, _) = collect(&db, &q); + assert!(ordered(&counters)); + assert!( + actual == expected, + "count null handling and distinct values match fallback" + ); + if !tail.is_empty() { + let aggregate = counters + .iter() + .find(|c| c.op == "AggregateOrdered") + .unwrap(); + assert!( + aggregate.rows_in <= (3 * 4 + BATCH_ROWS) as u64, + "group demand plus one child batch" + ); + } + } +} + +#[test] +fn a_group_spanning_many_probe_batches_does_not_retain_all_dict_lookups() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let mut peaks = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, n); + let (rows, counters, peak) = collect( + &db, + "[:find ?g (count ?e) (count-distinct ?v) :where [?e :bucket ?g] [?e :item ?v]]", + ); + assert!(ordered(&counters)); + assert!( + rows == vec![vec![ + Value::Integer(0), + Value::Integer(n as i64), + Value::Integer(3) + ]] + ); + peaks.push(peak); + } + assert!( + peaks[1] <= peaks[0] + two_input_batches(), + "internal child pulls must evict committed entity lookups within one unfinished group" + ); +} diff --git a/src/query/engine/mod.rs b/src/query/engine/mod.rs index c85080d7c6..53a335cca1 100644 --- a/src/query/engine/mod.rs +++ b/src/query/engine/mod.rs @@ -4,6 +4,8 @@ //! Every query runs here (#551). mod aggregate; +#[cfg(all(test, not(target_arch = "wasm32")))] +mod aggregate_order_tests; mod anti; mod batch; mod cell; @@ -325,8 +327,14 @@ pub(crate) fn build( groups, aggs, zero_row, + grouping, } => Box::new(aggregate::Aggregate::new( - root, groups, aggs, zero_row, meter, + root, + groups, + aggs, + zero_row, + grouping == plan::Grouping::Ordered, + meter, )), plan::Step::Window { find, named, keep } => { Box::new(window::Window::new(root, find, named, keep, meter)) diff --git a/src/query/engine/order.rs b/src/query/engine/order.rs index b0d0faa053..b5d232ae2b 100644 --- a/src/query/engine/order.rs +++ b/src/query/engine/order.rs @@ -1,9 +1,9 @@ //! Snapshot-bound input-order proofs (#641). DICT order is never UUID/text //! order. Unknown order retains the original index choice and buffering. -use super::plan::{Body, JoinKind, Meta, Out, Plan, ScanSpec, Source, Step, Term, Vars}; +use super::plan::{Body, Grouping, JoinKind, Meta, Out, Plan, ScanSpec, Source, Step, Term, Vars}; use crate::graph::storage::Snapshot; -use crate::query::datalog::functions::{AggImpl, FunctionRegistry}; +use crate::query::datalog::functions::{AggImpl, Builtin, FunctionRegistry}; use crate::query::datalog::types::{Expr, FindSpec, UnaryOp, WindowFunc}; use crate::storage::KeySource; use crate::storage::keys::{self, Index, ValueKind}; @@ -46,22 +46,32 @@ impl Drop for InputOrderGuard { } } -/// Only the leading scalar slot has a semantic comparator. The following -/// entity key is DICT order and cannot prove any Sort column in this slice. +/// Numeric tag ranges group in Value::Ord; only one scalar kind also +/// supplies the semantic Sort comparator. +#[derive(Clone, Copy, PartialEq, Eq)] +enum Domain { + Single(ValueKind), + Numbers, +} + +/// Leading scalar key and constants. A complete aggregate key is unique; +/// DICT entity suffixes never supply semantic UUID order. struct Ordering { slot: Option, - kind: ValueKind, + kind: Domain, constants: Vec, + unique: bool, } impl Ordering { - fn source(spec: &ScanSpec, kind: ValueKind) -> Self { + fn source(spec: &ScanSpec, kind: Domain) -> Self { Ordering { slot: match spec.v { Term::Bind(s) => Some(s), _ => None, }, kind, + unique: false, constants: spec .meta .iter() @@ -73,6 +83,7 @@ impl Ordering { fn invalidate(&mut self, slot: usize) { if self.slot == Some(slot) { self.slot = None; + self.unique = false; } self.constants.retain(|&s| s != slot); } @@ -110,6 +121,7 @@ impl Ordering { } } Step::Join(join) => { + self.unique = false; if !matches!( join.kind, JoinKind::Probe(_) @@ -125,8 +137,10 @@ impl Ordering { } } Step::DistinctFind(slots) => { - if self.kind == ValueKind::Float - && let Some(slot) = self.slot.filter(|s| slots.contains(s)) + if matches!( + self.kind, + Domain::Single(ValueKind::Float) | Domain::Numbers + ) && let Some(slot) = self.slot.filter(|s| slots.contains(s)) { self.invalidate(slot); } @@ -147,6 +161,9 @@ impl Ordering { let Some(&slot) = cols.get(column) else { return false; }; + if matched && self.unique { + continue; + } if self.constants.contains(&slot) || (matched && self.slot == Some(slot)) { continue; } @@ -155,7 +172,7 @@ impl Ordering { || self.slot != Some(slot) || !matches!( self.kind, - ValueKind::Integer | ValueKind::Float | ValueKind::Boolean + Domain::Single(ValueKind::Integer | ValueKind::Float | ValueKind::Boolean) ) { return false; @@ -215,29 +232,89 @@ fn safe_steps(steps: &[Step], functions: &FunctionRegistry) -> bool { } /// At most eight raw seeks through the exact reader the Stream will scan. -fn scalar_kind(keys: &dyn KeySource, attribute: u32) -> Result> { +fn scalar_kind(keys: &dyn KeySource, attribute: u32) -> Result> { let mut found = None; for kind in ValueKind::ALL { if keys.any_key(Index::Avet, &keys::attribute_kind_prefix(attribute, kind))? { - if found.is_some() { - return Ok(None); + found = match (found, kind) { + (None, ValueKind::Integer | ValueKind::Float | ValueKind::Boolean) => { + Some(Domain::Single(kind)) + } + (Some(Domain::Single(ValueKind::Integer)), ValueKind::Float) => { + Some(Domain::Numbers) + } + _ => return Ok(None), + }; + } + } + Ok(found) +} + +/// The choices are applied together only after the snapshot proof succeeds. +struct Choice { + aggregate: Option, + sort: Option, + avet: bool, +} + +fn choices( + spec: &ScanSpec, + plan: &Plan, + kind: Domain, + functions: &FunctionRegistry, +) -> Option { + let mut proof = Ordering::source(spec, kind); + let mut choice = Choice { + aggregate: None, + sort: None, + avet: !matches!(spec.e, Term::Const(_)), + }; + for (at, step) in plan.steps.iter().enumerate() { + match step { + Step::Aggregate { + groups, + aggs, + grouping: Grouping::Candidate, + .. + } if groups.len() == 1 + && proof.slot == groups.first().copied() + && aggs.iter().all(|(func, _)| { + functions.get(func).is_some_and(|d| { + matches!( + d.impl_, + AggImpl::Builtin(Builtin::Count | Builtin::CountDistinct) + ) + }) + }) => + { + choice.aggregate = Some(at); + proof.slot = Some(0); + proof.constants.clear(); + proof.unique = true; + } + Step::Sort { cols, order, keep } => { + if *keep != Some(0) && proof.satisfies(cols, order) { + choice.sort = Some(at); + } + break; + } + _ => { + let Some(next) = proof.through(std::slice::from_ref(step)) else { + break; + }; + proof = next; } - found = Some(kind); } } - Ok(found.filter(|k| { - matches!( - k, - ValueKind::Integer | ValueKind::Float | ValueKind::Boolean - ) - })) + (choice.aggregate.is_some() || choice.sort.is_some()).then_some(choice) } fn candidate( snapshot: &Snapshot, keys: &dyn KeySource, plan: &Plan, -) -> Result> { + functions: &FunctionRegistry, +) -> Result> { let Source::Scan(spec) = &plan.source else { return Ok(None); }; @@ -247,27 +324,8 @@ fn candidate( if spec.derived.is_some() || spec.never() || matches!(spec.e, Term::Eq(_)) { return Ok(None); } - let Some(at) = plan - .steps - .iter() - .position(|s| matches!(s, Step::Sort { .. })) - else { - return Ok(None); - }; - let Some(Step::Sort { cols, order, keep }) = plan.steps.get(at) else { - return Ok(None); - }; - if *keep == Some(0) { - return Ok(None); - } - let Some(before) = plan.steps.get(..at) else { - return Ok(None); - }; - // Reject impossible full orders before any speculative storage reads. - if !Ordering::source(spec, ValueKind::Integer) - .through(before) - .is_some_and(|p| p.satisfies(cols, order)) - { + // Reject impossible strategies before any speculative storage reads. + if choices(spec, plan, Domain::Single(ValueKind::Integer), functions).is_none() { return Ok(None); } let entity = match &spec.e { @@ -283,13 +341,7 @@ fn candidate( let Some(kind) = scalar_kind(keys, a)? else { return Ok(None); }; - if !Ordering::source(spec, kind) - .through(before) - .is_some_and(|p| p.satisfies(cols, order)) - { - return Ok(None); - } - Ok(Some((at, !matches!(spec.e, Term::Const(_))))) + Ok(choices(spec, plan, kind, functions)) } /// Only a plain query's root pipeline is resolved; bodies and rules keep their @@ -310,16 +362,22 @@ pub(super) fn resolve( let Some(keys) = keys else { return; }; - let Ok(Some((at, avet))) = candidate(snapshot, keys, plan) else { + let Ok(Some(choice)) = candidate(snapshot, keys, plan, functions) else { return; }; - if !matches!(plan.steps.get(at), Some(Step::Sort { .. })) { - return; + if let Some(at) = choice.aggregate + && let Some(Step::Aggregate { grouping, .. }) = plan.steps.get_mut(at) + { + *grouping = Grouping::Ordered; } - if let Step::Sort { cols, .. } = plan.steps.remove(at) { + if let Some(at) = choice.sort + && let Step::Sort { cols, .. } = plan.steps.remove(at) + { plan.find = cols; } - if avet && let Source::Scan(spec) = &mut plan.source { + if choice.avet + && let Source::Scan(spec) = &mut plan.source + { spec.index = Some(Index::Avet); } #[cfg(test)] diff --git a/src/query/engine/order/tests.rs b/src/query/engine/order/tests.rs index fbc0220f8b..f6901085ec 100644 --- a/src/query/engine/order/tests.rs +++ b/src/query/engine/order/tests.rs @@ -16,7 +16,7 @@ fn spec(wildcard: bool) -> ScanSpec { } fn proof(kind: ValueKind) -> Ordering { - Ordering::source(&spec(false), kind) + Ordering::source(&spec(false), Domain::Single(kind)) } fn sorted(proof: &Ordering) -> bool { proof.satisfies(&[1], &[(0, false)]) @@ -49,7 +49,7 @@ fn full_order_requires_matching_prefix_direction_and_semantic_comparator() { !order.satisfies(&[1, 0], &[(0, false), (1, false)]), "DICT order is not UUID order" ); - let wildcard = Ordering::source(&spec(true), ValueKind::Integer); + let wildcard = Ordering::source(&spec(true), Domain::Single(ValueKind::Integer)); assert!(sorted(&wildcard)); assert!(!wildcard.satisfies(&[1, 0], &[(0, false), (1, false)])); assert!( @@ -166,6 +166,7 @@ fn canonicalization_and_buffering_operators_cannot_supply_false_certificates() { groups: vec![1], aggs: vec![("count".into(), 0)], zero_row: false, + grouping: Grouping::Hash, }, Step::Window { find: vec![], @@ -278,3 +279,99 @@ fn committed_memory_backend_orders_all_supported_scalar_edge_cases() { } } } + +/// Group equality uses Value::Ord: integer and float ranges stay separate, +/// signed zeros share a group and the shared finisher chooses its representative. +#[cfg_attr( + all(target_arch = "wasm32", not(target_os = "wasi")), + wasm_bindgen_test::wasm_bindgen_test +)] +#[cfg_attr(not(all(target_arch = "wasm32", not(target_os = "wasi"))), test)] +fn committed_group_counts_preserve_float_representatives_and_mixed_numeric_order() { + use crate::query::datalog::{parser::parse_datalog_command, types::DatalogCommand}; + use crate::storage::{backend::memory::MemoryBackend, persistent_facts::PersistentFactStorage}; + for case in 0..3 { + let mixed = case == 1; + let mut values = vec![ + Value::Float(-0.0), + Value::Float(0.0), + Value::Float(f64::NAN), + Value::Float(-f64::NAN), + Value::Float(-100.0), + Value::Float(f64::INFINITY), + ]; + if mixed { + values.extend([Value::Integer(10), Value::Integer(-10)]); + } else if case == 2 { + values = vec![ + Value::Boolean(true), + Value::Boolean(false), + Value::Boolean(true), + ]; + } + let mut pfs = PersistentFactStorage::new(MemoryBackend::new(), 32).unwrap(); + pfs.storage() + .transact( + values + .into_iter() + .enumerate() + .map(|(i, v)| (uuid::Uuid::from_u128(i as u128 + 1), ":group".into(), v)) + .collect(), + None, + ) + .unwrap(); + pfs.mark_dirty(); + pfs.save().unwrap(); + for sorted in [false, true] { + let query = format!( + "(query [:find (count-distinct ?e) ?g (count ?e) :where [?e :group ?g] {}])", + if sorted { ":order-by [?g]" } else { "" } + ); + let DatalogCommand::Query(q) = parse_datalog_command(&query).unwrap() else { + panic!("query"); + }; + let mut results = Vec::new(); + for optimized in [false, true] { + let _mode = set_enabled(optimized); + let mut stream = crate::query::engine::open( + pfs.storage().snapshot().unwrap(), + crate::query::engine::plan(&q).unwrap(), + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + let counters = stream.counters(); + if optimized { + assert!(counters.iter().any(|c| c.op == "AggregateOrdered")); + assert_eq!( + counters.iter().any(|c| c.op == "Sort"), + mixed && sorted, + "mixed numbers group in Value::Ord but sort numerically" + ); + } + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + results.push(rows); + } + assert_eq!(results[0].len(), results[1].len()); + for (a, b) in results[0].iter().flatten().zip(results[1].iter().flatten()) { + match (a, b) { + (Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits()), + _ => assert!(a == b, "same group result"), + } + } + } + } +} + +#[test] +fn a_unique_group_key_proves_tie_columns_until_a_join_can_multiply_it() { + let mut order = proof(ValueKind::Integer); + order.unique = true; + assert!(order.satisfies(&[1, 0], &[(0, false), (1, true)])); + let joined = order.through(&[join(JoinKind::Probe(0), vec![])]).unwrap(); + assert!(!joined.satisfies(&[1, 0], &[(0, false), (1, true)])); + assert!(sorted(&joined)); +} diff --git a/src/query/engine/order_tests.rs b/src/query/engine/order_tests.rs index 0c65135bb2..55a302eeea 100644 --- a/src/query/engine/order_tests.rs +++ b/src/query/engine/order_tests.rs @@ -748,6 +748,12 @@ fn optional_proofs_are_bounded_and_queries_without_a_usable_demand_do_no_probes( let snapshot = db.snapshot().unwrap(); let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); for (q, expected) in [ + ("[:find ?v (count ?e) :where [?e :score ?v] :limit 3]", 8), + ( + "[:find ?v (count ?e) :where [?e :score ?v] :order-by [?v] :offset 7 :limit 0]", + 0, + ), + ("[:find ?v (sum ?v) :where [?e :score ?v] :limit 3]", 0), ( "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]", 8, @@ -805,52 +811,73 @@ fn every_failed_optional_read_retains_the_original_sort_projection_and_index() { let (_dir, db) = fixture(32); let snapshot = db.snapshot().unwrap(); let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); - for fail_at in 1..=8 { - let keys = ProofKeys { - base, - calls: 0.into(), - fail_at: Some(fail_at), - }; - let mut plan = query_plan("[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]"); - let original_find = plan.find.clone(); - super::order::resolve( - &snapshot, - Some(&keys), - &FunctionRegistry::with_builtins(), - &mut plan, - ); - assert!( - plan.steps.iter().any(|s| matches!(s, Step::Sort { .. })), - "Sort remains" - ); - assert_eq!( - plan.find, original_find, - "projection is not partially restored" - ); - assert!( - matches!(&plan.source, Source::Scan(s) if s.index.is_none()), - "index choice is unchanged" - ); - let _off = super::order::set_enabled(false); - let mut fallback = super::open( - snapshot.clone(), - plan, - std::sync::Arc::new(FunctionRegistry::with_builtins()), - usize::MAX, - ) - .unwrap(); - assert!(has_sort(&fallback.counters())); - let mut rows = Vec::new(); - while let Some(batch) = fallback.next_rows().unwrap() { - rows.extend(batch); + for grouped in [false, true] { + for fail_at in 1..=8 { + let keys = ProofKeys { + base, + calls: 0.into(), + fail_at: Some(fail_at), + }; + let mut plan = query_plan(if grouped { + "[:find ?v (count ?e) :where [?e :score ?v] :order-by [?v] :limit 3]" + } else { + "[:find ?v :where [?e :score ?v] :order-by [?v] :limit 3]" + }); + let original_find = plan.find.clone(); + super::order::resolve( + &snapshot, + Some(&keys), + &FunctionRegistry::with_builtins(), + &mut plan, + ); + assert!( + plan.steps.iter().any(|s| matches!(s, Step::Sort { .. })), + "Sort remains" + ); + assert_eq!( + plan.find, original_find, + "projection is not partially restored" + ); + assert!( + matches!(&plan.source, Source::Scan(s) if s.index.is_none()), + "index choice is unchanged" + ); + assert!( + plan.steps.iter().all(|s| !matches!( + s, + Step::Aggregate { + grouping: super::plan::Grouping::Ordered, + .. + } + )), + "no partial strategy change" + ); + let _off = super::order::set_enabled(false); + let mut fallback = super::open( + snapshot.clone(), + plan, + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert!(has_sort(&fallback.counters())); + let mut rows = Vec::new(); + while let Some(batch) = fallback.next_rows().unwrap() { + rows.extend(batch); + } + let expected: Vec<_> = (0..3) + .map(|i| { + let mut row = vec![Value::Integer(i)]; + if grouped { + row.push(Value::Integer(1)); + } + row + }) + .collect(); + assert!( + rows == expected, + "a failed optional proof still executes the original query" + ); } - assert!( - rows == vec![ - vec![Value::Integer(0)], - vec![Value::Integer(1)], - vec![Value::Integer(2)] - ], - "a failed optional proof still executes the original query" - ); } } diff --git a/src/query/engine/plan.rs b/src/query/engine/plan.rs index 207c6fd05d..da5305c9c9 100644 --- a/src/query/engine/plan.rs +++ b/src/query/engine/plan.rs @@ -140,6 +140,15 @@ impl ScanSpec { } } +/// The logical candidate stays on the hash path until snapshot resolution +/// certifies a single contiguous grouping key (#641). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum Grouping { + Hash, + Candidate, + Ordered, +} + /// A clause after the scan, in the executor's order. #[derive(Debug, Clone)] pub(crate) enum Step { @@ -179,6 +188,7 @@ pub(crate) enum Step { /// Whether no input row gives one row of zeros: a query of `count`s /// and `count-distinct`s and no plain `:find` variable. zero_row: bool, + grouping: Grouping, }, /// The last step of a query with windows (#547 spec §4): each row once, /// in input order, holding its cells at `keep` and then the value of @@ -514,6 +524,11 @@ fn plan_with(query: &DatalogQuery, evaluated: Option>) -> Result< groups, aggs, zero_row, + grouping: if !window && query.with_vars.is_empty() { + Grouping::Candidate + } else { + Grouping::Hash + }, }); } else { for spec in &query.find { diff --git a/src/query/engine/tests.rs b/src/query/engine/tests.rs index 7c0f35dbcd..a145dd85ca 100644 --- a/src/query/engine/tests.rs +++ b/src/query/engine/tests.rs @@ -3085,6 +3085,7 @@ fn rewind_and_close_release() { vec![0], vec![("count".to_string(), 0)], false, + false, &meter, ); let ops: [&mut dyn super::Operator; 2] = [&mut distinct, &mut aggregate]; @@ -3117,6 +3118,7 @@ fn small_limit_in_each_holder() { vec![0], vec![("count".to_string(), 0)], false, + false, &meter, ); let err = pull_once(&mut aggregate, &meter).unwrap_err(); @@ -3404,6 +3406,7 @@ fn aggregate_finish_charges_its_sorted_groups() { vec![0], vec![("count".to_string(), 0)], false, + false, &meter, ); let batch = pull_once(&mut aggregate, &meter).unwrap().expect("a batch"); @@ -3439,6 +3442,7 @@ fn aggregate_finish_keeps_sum_distinct_members_charged_once() { vec![], vec![("sum-distinct".to_string(), 0)], false, + false, &meter, ); pull_once(&mut aggregate, &meter).unwrap().expect("a batch"); @@ -3494,3 +3498,144 @@ fn top_k_memory_follows_k_not_the_input() { .expect_err("a full sort over the limit"); assert_eq!(crate::MinigrafError::from(e).code(), "QRY-012"); } + +#[test] +fn ordered_aggregate_rewind_close_and_errors_release_the_active_group() { + use super::Operator; + let meter = super::Meter::unlimited(); + let mut op = super::aggregate::Aggregate::new( + Box::new(Ints { n: 3000, at: 0 }), + vec![0], + vec![("count".into(), 0)], + false, + true, + &meter, + ); + let first = pull_once(&mut op, &meter).unwrap().unwrap(); + assert!(meter.used() > 0, "one unfinished group survives the batch"); + op.rewind(&[]); + assert_eq!(meter.used(), 0); + let again = pull_once(&mut op, &meter).unwrap().unwrap(); + assert_eq!(first.len, again.len); + op.close(); + op.close(); + assert_eq!(meter.used(), 0); + let meter = super::Meter::new(1); + let mut op = super::aggregate::Aggregate::new( + Box::new(Ints { n: 3, at: 0 }), + vec![0], + vec![("count".into(), 0)], + false, + true, + &meter, + ); + assert!(pull_once(&mut op, &meter).is_err()); + op.close(); + assert_eq!(meter.used(), 0); +} + +/// A deliberately untrusted child for defensive input-order checks (#641). +struct Sequence { + cells: Vec, + at: usize, +} + +impl super::Operator for Sequence { + fn next_batch(&mut self, _: &mut super::Ctx<'_>) -> anyhow::Result> { + if self.at == self.cells.len() { + return Ok(None); + } + let mut out = super::Batch::new(1); + while self.at < self.cells.len() && out.len < super::BATCH_ROWS { + out.push(&mut [Some(self.cells[self.at].clone())]); + self.at += 1; + } + Ok(Some(out)) + } + fn rewind(&mut self, _: &[super::cell::Cell]) { + self.at = 0; + } + fn close(&mut self) { + self.at = self.cells.len(); + } + fn counters(&self, _: &mut Vec) {} +} + +#[test] +fn ordered_aggregate_rejects_decreasing_groups_before_and_after_an_answer_batch() { + use super::Operator; + use super::cell::{Cell, Scalar}; + let int = |n| Cell::Val(Scalar::Int(n)); + for cells in [ + vec![int(1), int(2), int(1)], + vec![Cell::Val(Scalar::Float(1.5)), int(1)], + (0..2 * super::BATCH_ROWS as i64) + .map(int) + .chain([int(0)]) + .collect(), + ] { + let late = cells.len() > super::BATCH_ROWS; + let meter = super::Meter::unlimited(); + let mut op = super::aggregate::Aggregate::new( + Box::new(Sequence { cells, at: 0 }), + vec![0], + vec![("count".into(), 0)], + false, + true, + &meter, + ); + let mut batches = 0; + let err = loop { + match pull_once(&mut op, &meter) { + Ok(Some(_)) => batches += 1, + Ok(None) => panic!("broken group order must fail"), + Err(e) => break e, + } + }; + assert_eq!(crate::MinigrafError::from(err).code(), "INT-032"); + assert_eq!(batches > 0, late); + op.close(); + assert_eq!(meter.used(), 0); + } +} + +#[test] +fn ordered_distinct_member_reservation_failure_releases_an_unfinished_group() { + use super::cell::{Cell, Scalar}; + use super::{Ctx, Operator}; + struct Members(Ints); + impl Operator for Members { + fn next_batch(&mut self, ctx: &mut Ctx<'_>) -> anyhow::Result> { + if self.0.at > 0 { + super::meter::FAIL_RESERVE.with(|f| f.set(Some("Aggregate"))); + } + let Some(mut batch) = self.0.next_batch(ctx)? else { + return Ok(None); + }; + batch.cols.push(vec![Cell::Val(Scalar::Int(0)); batch.len]); + Ok(Some(batch)) + } + fn rewind(&mut self, seed: &[Cell]) { + self.0.rewind(seed); + } + fn close(&mut self) { + self.0.close(); + } + fn counters(&self, _: &mut Vec) {} + } + let meter = super::Meter::unlimited(); + let mut op = super::aggregate::Aggregate::new( + Box::new(Members(Ints { n: 3000, at: 0 })), + vec![1], + vec![("count-distinct".into(), 0)], + false, + true, + &meter, + ); + let result = pull_once(&mut op, &meter); + super::meter::FAIL_RESERVE.with(|f| f.set(None)); + let err = result.expect_err("second batch cannot reserve a new distinct member"); + assert_eq!(crate::MinigrafError::from(err).code(), "QRY-012"); + op.close(); + assert_eq!(meter.used(), 0); +} diff --git a/tests/memory_limit_acceptance_test.rs b/tests/memory_limit_acceptance_test.rs index 17c3a615f8..4daa87a107 100644 --- a/tests/memory_limit_acceptance_test.rs +++ b/tests/memory_limit_acceptance_test.rs @@ -110,7 +110,15 @@ fn grouped_count_1m_groups() { .path(dir.path().join("groups.graph")) .open() .unwrap(); - let err = drain(&db, query).err().expect("over the limit"); + assert_eq!( + drain(&db, query).unwrap(), + GROUPS, + "ordered counts release completed groups" + ); + // Fallible sum retains the materialized holder, preserving later errors. + let err = drain(&db, "(query [:find ?g (sum ?g) :where [?e :g ?g]])") + .err() + .expect("over the limit"); assert_eq!(err.code(), "QRY-012", "stopped by the limit"); assert!(err.to_string().contains("Aggregate"), "names Aggregate"); // The database answers other queries. From 91feb60f82a971170db1181d78f5b50fad7929e5 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Wed, 28 Oct 2026 17:39:29 +0530 Subject: [PATCH 3/3] feat(query): release proved window partitions incrementally (#641) --- CHANGELOG.md | 4 +- CLAUDE.md | 6 +- README.md | 2 +- ROADMAP.md | 2 +- benches/minigraf_bench.rs | 46 ++ docs/BENCHMARKS.md | 152 ++++ docs/TEST_COVERAGE.md | 20 +- .../641-partition-windows-build.json | 30 + .../641-partition-windows-guards.jsonl | 360 +++++++++ .../641-partition-windows-history.jsonl | 144 ++++ .../641-partition-windows-meter.jsonl | 18 + .../641-partition-windows-startup.jsonl | 72 ++ docs/benchmarks/641-partition-windows.jsonl | 252 ++++++ scripts/input_order_window_probe.rs | 53 ++ src/query/datalog/optimizer.rs | 12 +- src/query/engine/ids.rs | 6 +- src/query/engine/meter.rs | 89 +++ src/query/engine/mod.rs | 27 +- src/query/engine/order.rs | 117 ++- src/query/engine/order/tests.rs | 102 +++ src/query/engine/order_tests.rs | 52 ++ src/query/engine/plan.rs | 43 +- src/query/engine/tests.rs | 51 ++ src/query/engine/window.rs | 266 ++++++- src/query/engine/window_order_tests.rs | 752 ++++++++++++++++++ src/storage/persistent_facts.rs | 11 +- 26 files changed, 2598 insertions(+), 91 deletions(-) create mode 100644 docs/benchmarks/641-partition-windows-build.json create mode 100644 docs/benchmarks/641-partition-windows-guards.jsonl create mode 100644 docs/benchmarks/641-partition-windows-history.jsonl create mode 100644 docs/benchmarks/641-partition-windows-meter.jsonl create mode 100644 docs/benchmarks/641-partition-windows-startup.jsonl create mode 100644 docs/benchmarks/641-partition-windows.jsonl create mode 100644 scripts/input_order_window_probe.rs create mode 100644 src/query/engine/window_order_tests.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index d62f93a5ad..79b41a2465 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,10 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Performance -- **Skip sorting proven ordered input** (#641, first slice). Plain queries can omit `Sort` when a committed integer, float, or Boolean range already provides the complete ascending result order. Attribute scans use AVET; entity-and-attribute scans retain their selective EAVT range. `:offset` and `:limit` then stop reading early, so memory-limit (`QRY-012`) or I/O errors in unread later input may be avoided. The proof uses the query's pinned reader, including a large write transaction's working trees, and rejects pending or staged records in the source range, mixed kinds, unsupported comparators, tie suffixes, order-changing operators, user callbacks and `collect-set`. Unproven queries retain their original plan. Windows still buffer their full input pending the third slice. +- **Skip sorting proven ordered input** (#641, first slice). Plain queries can omit `Sort` when a committed integer, float, or Boolean range already provides the complete ascending result order. Attribute scans use AVET; entity-and-attribute scans retain their selective EAVT range. `:offset` and `:limit` then stop reading early, so memory-limit (`QRY-012`) or I/O errors in unread later input may be avoided. The proof uses the query's pinned reader, including a large write transaction's working trees, and rejects pending or staged records in the source range, mixed kinds, unsupported comparators, tie suffixes, order-changing operators, user callbacks and `collect-set`. Unproven queries retain their original plan. - **Release completed count groups** (#641, second slice). A plain query with exactly one proved scalar grouping key, no `:with` or windows, and only built-in `count`/`count-distinct` holds one active group plus bounded batches. Completed groups are released, and a limit can stop before later groups; one large distinct group still grows with its members. Integer, Boolean and committed-float keys qualify, including mixed integer/float grouping in `Value::Ord` order. A unique single-kind group key can also remove the final ascending Sort; mixed numeric keys retain numeric Sort. Fallible aggregates, callbacks and `collect-set` retain full-input validation and later errors. Small selective grouped queries pay proof startup cost, and a single growing group is slower (see `docs/BENCHMARKS.md`). No new aggregate syntax or function is added. +- **Release completed window partitions** (#641, third slice). A plain query whose built-in windows share one proved nonconstant partition key can hold one partition plus bounded input/output batches, using the existing evaluator for peers, frames and neighbors. The pinned committed source must prove adjacency, with no pending/staged records in its range; scalar value order or dictionary entity/ident order can qualify. Window results preserve their chosen input order; query row order still requires final `:order-by`. Unpartitioned or incompatible windows, aggregate queries, callbacks and `collect-set` retain full-input evaluation. Transient DICT caches are evicted within long internal pulls and result conversions. One growing partition remains linear, and a surrounding sort/distinct can dominate memory. A limit can avoid later input and its I/O/allocation errors; coalescing can still encounter an error while gathering one output batch. Small selective windows pay proof startup cost (see `docs/BENCHMARKS.md`). + ### Breaking changes - **`Value` is `#[non_exhaustive]` and has a `Set` variant** (#316). A `match` on `Value` outside the crate needs a wildcard arm, so later value kinds are not breaking changes. diff --git a/CLAUDE.md b/CLAUDE.md index 85333a3d2d..4fc73b8e4d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -148,7 +148,7 @@ cargo run < demos/demo_negation.txt - `prepared.rs`: `BindValue`, `PreparedQuery` — parse-once/execute-many with named `$slot` bind slots; `prepare_query`, `substitute`; `Entity` and `Val(Ref)` fit each other's slots, bind mistakes are `API-022`/`023`/`024` (#181); a `:limit $n` or `:offset $o` slot takes `Val(Integer(n >= 0))` (`resolve_count_slot`, #306) - `magic_sets.rs`: Magic-sets rewriting for demand-driven recursive rule evaluation (not applied to rules with `not`/`not-join`) -3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`; #641 certifies one committed scalar group key with only built-in count/count-distinct, no :with/window/callback/CollectSet, as `Grouping::Ordered`: one active group, bounded output batches, shared finish_group, internal DICT-cache eviction; fallible aggregates keep full-drain validation), `order.rs` (#641: snapshot-bound proofs of the complete result order; safe committed integer/float/Boolean ranges can set the private `ScanSpec.index` hint to AVET and omit Sort, with `plan.find` restored from Sort.cols; entity-and-attribute scans retain EAVT; pending/staged records in that range, DICT comparators, callbacks and CollectSet keep the original strategies; mixed integer/float keys can prove grouping order but keep Sort, and unique group keys discharge tie suffixes; `minigraf::__input_order` forces fallback under `test-hooks`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. +3a. **`src/query/engine/`** — Streaming query engine (#473), runs every query (#551): `plan.rs` (the operator tree of every query, or the executor's error code for it: patterns, expression clauses, `not`/`not-join` and `or`/`or-join`, and rule invocations, read as patterns of their relations (`plan_rules`, #548; a magic-set head constant is `HeadArg::Const`), in `optimizer::plan` order, then the `or`s in text order, then the deferred `not`s; an `or` branch or a `not` body is planned as a `:where` is; a clause list with no pattern first starts from `Seed`; a constant no cell equals is `Term::Never`, a scan that reads nothing; `:as-of` resolved when the query opens (`Snapshot::tx_bound`: a counter bound when `tx_id` rises with `tx_count`, else `TxBound::Timestamp`: committed `tx_count` ranges and pending `tx_id <= t`); a per-fact pseudo-attribute pattern reads the metadata column its source's scan fills (the hidden variable the parser named, #594), and `:db/valid-at` joins as `[e _ _]`; plain `:find` variables, aggregates with `:with`, and window functions, over an aggregate's groups too), `scan.rs` (one pattern over committed key ranges via `CommittedReader::key_source`/`live_keys`, AVET ranges for cross-kind constants, then the pending range by whole runs; one entity per probe for a join), `join.rs` (`IndexNestedLoopJoin` when the pattern's entity is bound, or, under a constant attribute and entity not constant, its value (#721: per outer row the AVET ranges of the values that join-equal it and the attribute's pending facts with its key, read once per query in `IdSpace::probes`; an entity cell needs the keyword naming it, known only where the query made the entity from a keyword (rule heads, magic seeds), else the join becomes the planner's `HashJoin`); `HashJoin` otherwise, and on a relation; `JoinKey`: floats by IEEE `==`, a keyword equals a ref to the entity it names), `filter.rs` (`Filter`/`Bind` and pseudo-attribute steps over batches; a `Bind` on a bound slot keeps the rows where the result is join-equal, #596), `collect.rs` (`CollectSet`, #316: `[(collect-set ?e :a) ?s]` per row probes `[e :a ?v]` as an `IndexNestedLoopJoin` does and binds the values as one set, `#{}` when none, metered; `Expr::CollectSet`, parsed only as a whole binding clause), `anti.rs` (`AntiJoin`, #546: a body with the same rows for every outer row runs once into a hash set of its imported-variable keys; any other body, or one whose first pattern's entity is imported, runs per outer row from `seed.rs`'s one-row `Seed`, via `Operator::rewind`; never deduplicates), `aggregate.rs` (`Aggregate`, #547: a hash table of groups keyed on cells as `Value`'s `Ord` compares values, one entry when ungrouped; `count`/`count-distinct` on cells, other aggregates on values via `datalog::aggregate::Agg`; groups sorted by value and finished in that order; a float group shows its least value by `value_order`; #641 certifies one committed scalar group key with only built-in count/count-distinct, no :with/window/callback/CollectSet, as `Grouping::Ordered`: one active group, bounded output batches, shared finish_group, internal DICT-cache eviction; fallible aggregates keep full-drain validation), `order.rs` (#641: snapshot-bound proofs of the complete result order; safe committed integer/float/Boolean ranges can set the private `ScanSpec.index` hint to AVET and omit Sort, with `plan.find` restored from Sort.cols; entity-and-attribute scans retain EAVT; pending/staged records in that range, callbacks and CollectSet keep the original strategies; DICT comparators prove only window partition adjacency, never final Sort or aggregate group order; mixed integer/float keys can prove grouping order but keep Sort, and unique group keys discharge tie suffixes; `minigraf::__input_order` forces fallback under `test-hooks`), `sort.rs` (`Sort`, #306: the `:find` columns as values, in the full order of `:order-by` — its keys, then every other `:find` column ascending, by `datalog::aggregate::row_order`/`value_order`; under a `:limit` a heap of the best `offset + limit` rows; reads its whole input, dropping the DICT lookups after each batch, metered; its rows turned back into cells only as returned), `limit.rs` (`Limit`, #306: skips `offset` rows, passes on at most `limit`, then closes its child so nothing below reads more; planned after the last step, after `Builder::finish`, and after `Sort`), `window.rs` (`Window`, #547: holds each input row's passed-on cells and its named variables' values, then computes every window with `datalog::aggregate::windows`, the executor's code, and returns the rows in input order; #641 resolves compatible built-in windows to `WindowPartitioned`, retaining one partition and charged lookahead, coalescing completed partitions into bounded output batches, evicting DICT caches at internal input/result boundaries; full-input mode keeps query-lifetime caches), `union.rs`/`distinct.rs` (`Union` and `Distinct`, #546: each `or` branch planned as a `not` body is, hashed into a table or run per outer row; then one row per distinct binding, as the executor's `Value`s compare; `:distinct` adds `DistinctFind` after aggregates/windows and before sorting/pagination, keyed on final `:find` columns by aggregate-group equality, with canonical float zero/NaN output including set elements, #493), `cell.rs`/`batch.rs` (id cells in columnar batches of 1,024), `ids.rs` (DICT and provisional ids, `keyword_eid`), `project.rs` (ids → values for returned rows only; bounded stack UUID hints share DICT paths, with cache insertion and charges in projection order, #530), `relation.rs`/`recursive.rs` (#548: rule queries; a relation per evaluated predicate holds its derived rows, a set by `encode_value` identity, appended per round so `Old`/`Delta`/`Full` are ranges; `Recursive` runs each stratum's semi-naive rounds, one run per same-stratum top-level invocation, a rule reading its stratum otherwise run in full every round; scans read derived rows after committed and pending ones, with `nil` metadata), `meter.rs` (#549: one `Meter` per query, shared by every holder of state through a `Held` — hash join build sides, `not`/`or` tables, distinct sets, aggregate groups, window rows, rule relations and their temporaries, `IdSpace`, the set a `CollectSet` builds; each entry charged by a per-entry estimate including retained set elements and strings before it is inserted, containers grown with `try_reserve`, released on `rewind`/`close`/drop; over `OpenOptions::query_memory_limit`, or a refused allocation, is `QRY-012`; `Stream::close` drops the operator tree, keeping its counters). `mod.rs`: `Operator` (`next_batch`/`rewind`/`close`/`counters`), `Stream` (the operator tree over an owned `Snapshot`, pulled one batch at a time). `DatalogExecutor::open` / `execute_query` run every query on it: a cursor gets the `Stream` (`Answer::Stream`), `execute` drains it. 4. **`src/temporal.rs`** — UTC-only timestamp parsing (avoids chrono CVE GHSA-wcg3-cvx6-7396) @@ -216,7 +216,7 @@ Auto-migrates v7 → v8 on open (spec §9, with a backup meta page). v1–v6 are ## Test Coverage -**1963 tests** (1947 passing, 16 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). +**1989 tests** (1972 passing, 17 ignored; unit + integration + doc). Engine answers once checked by the executor are frozen in `tests/answers/` (#551). See `docs/TEST_COVERAGE.md` for the full per-file breakdown. **Testing conventions** — see the Testing Conventions section below before writing any tests. @@ -228,7 +228,7 @@ See `docs/TEST_COVERAGE.md` for the full per-file breakdown. Current plan (see `ROADMAP.md` and the milestones): - **v2.x** (`main`, format v7) now gets only data-integrity and security fixes as patch releases (v2.0.3 is the first); v2.0.2 was the last planned v2.x release. - **v3.0.0** (format v8 and data integrity, plus `:limit` #306, optional `:distinct` output #493, `lag`/`lead` #182, sliding row frames #183, query profiler #185, set membership predicates #316 and prepared queries in every binding #181, UDF registration in every binding #180; tracker #383) is developed on the long-lived `v3` branch. All v3 PRs target `v3`; `main` stays untouched. CI runs on PRs to `v3` the same as on PRs to `main`. Do not merge `main` into `v3` routinely: `main` only gets backports of fixes already on `v3`. Shared CI and workflow changes land on both branches as separate PRs. Just before the v3.0.0 cut, merge `main` into `v3` once (merge commit; source conflicts resolved to `v3`, `main`'s v2.0.x CHANGELOG sections brought over) so the cut is a fast-forward. At the first v3 release, the current `main` is copied to `v2` and `v3` becomes the new `main`. -- **Input order (#641)** targets v3.0.0 in three slices: committed scalar Sort omission is implemented on `v3`; one-group count/count-distinct is implemented on `v3`; partition-at-a-time windows remain pending. The reviewed design, fallback scope and acceptance gates are in `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. +- **Input order (#641)** targets v3.0.0 in three slices: committed scalar Sort omission, one-group count/count-distinct and partition-at-a-time windows are implemented in the dependent PRs for `v3`. The reviewed design, fallback scope and acceptance gates are in `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - **v3.next** (the release after v3.0.0) holds new features (rule persistence #241; OPFS `BrowserDb` #441). - Known v2.x data issue: same-transaction multi-valued facts (#371). Fix ships in v3.0.0. All v2.x known issues are listed in pinned issue #421 (`known-issue` label); `data-integrity`/`corruption`/`durability` issues fixed in a v2.x patch stay open until that patch is published; issues fixed on the unreleased `v3` branch close on merge (closing keywords do not fire on `v3`, so close them with `gh issue close`) and stay listed in #421 (CONTRIBUTING.md). - Support policy and tiers: PHILOSOPHY.md §7 and §10. v2.x gets data-integrity and security fixes for 12 months after v3.0.0. Tier 1 = Rust + Python + browser WASM (from v3.0.0); other bindings are Tier 2. diff --git a/README.md b/README.md index 18005ee190..a182ae2bee 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ For example, `(lag ?salary :over (:partition-by ?dept :order-by ?hire-date))` re The unreleased v3.0.0 branch adds bounded sliding windows such as `(avg ?salary :over (:partition-by ?dept :order-by ?hire-date :rows 2 preceding))` (#183). -On v3.0.0, an ascending value-only query such as `[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]` can read directly in index order and stop early when all committed `:score` history has one value kind (integer, float, or Boolean) and its source range has no pending writes. A query whose full order cannot be proved uses the existing sort (#641). Built-in `count` and `count-distinct` can also release completed groups when one committed integer/Boolean/float key is proved ordered (including mixed integer/float groups), with no `:with`, windows, callbacks or `collect-set`. Memory then follows the active group and batches; distinct members within one group still grow. Other aggregates keep full-input validation. +On v3.0.0, an ascending value-only query such as `[:find ?v :where [?e :score ?v] :order-by [?v] :limit 10]` can read directly in index order and stop early when all committed `:score` history has one value kind (integer, float, or Boolean) and its source range has no pending writes. A query whose full order cannot be proved uses the existing sort (#641). Built-in `count` and `count-distinct` can also release completed groups when one committed integer/Boolean/float key is proved ordered (including mixed integer/float groups), with no `:with`, windows, callbacks or `collect-set`. Memory then follows the active group and batches; distinct members within one group still grow. Other aggregates keep full-input validation. When every built-in window uses the same proved nonconstant partition key, the engine can also finish and release one partition at a time. Its memory follows the largest partition plus bounded batches; one growing partition still grows. Unpartitioned windows, incompatible keys, aggregate queries, callbacks and `collect-set` keep full-input evaluation. A surrounding sort or distinct operation can still require more memory. **Status**: See [ROADMAP.md](ROADMAP.md) for planned work and current direction. diff --git a/ROADMAP.md b/ROADMAP.md index 41ea1a3cbd..d9924a9186 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -98,7 +98,7 @@ Scope — query API: - Bounded sliding row frames, `:rows N preceding`, for window aggregates (#183; v3.0.0, implemented on `v3`; builds on #182) - Cursor API: `Minigraf::query` and `PreparedQuery::query` return an owned `Cursor` that delivers rows in batches, with the answer fixed at open (#432; Rust API done on `v3`). The binding cursor objects follow. Behind the cursor, the streaming engine (#473) runs every query and produces rows as they are pulled: patterns, expressions and pseudo-attributes (#544), joins and `:db/valid-at` (#545), `not` and `or` (#546), aggregates and windows (#547), rules (#548), and transaction reads (#550); the executor's query path is gone (#551; done on `v3`). Operators do not spill: memory follows operator state, with an opt-in per-query limit (`QRY-012`, #549). - Projected UUID lookup batches walk dense DICT ranges (#530; implemented on `v3`), keeping temporary memory bounded to a batch and query-cache charges in projection order. -- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). #641 targets v3.0.0 in three slices: snapshot-bound order proofs and Sort omission for committed scalar ranges, then one-group count/count-distinct and partition-at-a-time windows. Sort omission and one-group count/count-distinct are implemented on `v3`; partition-at-a-time windows remain pending. Streaming groups require a proved scalar grouping key and no `:with`, windows, callbacks or `collect-set`; other aggregates retain full-input validation. See `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. +- Native `:limit N`, `:order-by` and `:offset`, with a top-k `Sort` whose memory follows `N` (#306; done on `v3`, with the 10M-fact acceptance tests moved from #473; spec `docs/superpowers/specs/2026-10-24-limit-order-by-design.md`). #641 targets v3.0.0 in three slices: snapshot-bound order proofs and Sort omission for committed scalar ranges, then one-group count/count-distinct and partition-at-a-time windows. All three slices are implemented in the dependent #641 PRs for `v3`. Streaming groups require a proved scalar grouping key and no `:with`, windows, callbacks or `collect-set`; other aggregates retain full-input validation. Compatible built-in windows with one proved nonconstant partition key hold one partition and bounded batches; unpartitioned/incompatible windows, aggregate queries, callbacks and `collect-set` retain full-input evaluation. See `docs/superpowers/specs/2026-10-28-641-input-order-design.md`. - Fact-log iterator: `Minigraf::fact_log(&FactFilter)` streams every fact version (assertions and retractions, with `tx_count`, `tx_id` and valid-time bounds) in transaction order or storage order, filtered by attribute, attribute prefix, entity and tx range, with memory bounded by a window rather than the database (#430; Rust API done on `v3`). An open log pins its generation: checkpoints run but do not reuse its pages (#543; `API-013` deprecated). A raw log writer (#431) completes the extract-transform-load path; the binding objects follow with #462. - Read-only open: `OpenOptions::read_only` takes a shared lock, so several readers can hold a file at once, writes nothing to the file or its WAL (a WAL is applied in memory, a v7 file is read without migrating), and refuses writes with `API-014` (#429; Rust API done on `v3`). The bindings' `open_with_options` follows. - Raw log writer: `LogWriter` builds a new database from `FactRecord`s with their `tx_count`, `tx_id`, valid-time windows and assertion flags kept, gaps allowed (a purged transaction stays a hole for `:as-of`), at `.partial` renamed into place by `finish` (#431; Rust API done on `v3`). Completes extract (#429, #430), transform, load. The binding objects follow. diff --git a/benches/minigraf_bench.rs b/benches/minigraf_bench.rs index fd63040e0e..acdc1b175d 100644 --- a/benches/minigraf_bench.rs +++ b/benches/minigraf_bench.rs @@ -277,6 +277,51 @@ fn bench_ordered_groups(c: &mut Criterion) { group.finish(); } +// Committed one-row partitions exercise value and entity certificates. The +// ordinary ^query/ nightly route includes full drains and bounded limits. +fn bench_partition_windows(c: &mut Criterion) { + let mut group = c.benchmark_group("query/partition_windows"); + group.sample_size(10); + for (label, n) in [ + ("1k", 1_000), + ("10k", 10_000), + ("100k", 100_000), + ("1m", 1_000_000), + ] { + for (mode, partition, limited) in [ + ("value", "?v", false), + ("entity", "?e", false), + ("value_limit", "?v", true), + ("entity_limit", "?e", true), + ] { + group.bench_with_input(BenchmarkId::new(mode, label), &n, |b, &n| { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("windows.graph"); + helpers::populate_file(n, path.to_str().unwrap()); + let db = OpenOptions::new() + .read_only(true) + .path(&path) + .open() + .unwrap(); + let query = format!( + "(query [:find ?e ?v (row-number :over (:partition-by {partition} :order-by ?e)) :where [?e :val ?v] {}])", + if limited { ":limit 10" } else { "" } + ); + b.iter(|| { + let mut cursor = db.query(&query).unwrap(); + let mut rows = 0; + while let Some(batch) = cursor.next_batch(1000).unwrap() { + rows += batch.len(); + } + assert_eq!(rows, if limited { 10.min(n) } else { n }); + black_box(rows) + }); + }); + } + } + group.finish(); +} + // ── Task 6: time_travel/ ────────────────────────────────────────────────────── // The existing nightly ^query/ filter selects both the proven value order and @@ -2068,6 +2113,7 @@ criterion_group!( bench_query, bench_input_order, bench_ordered_groups, + bench_partition_windows, bench_time_travel, bench_recursion, bench_negation, diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index 7b982f25d1..f5462a0d24 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -2,6 +2,158 @@ This document records reproducible local benchmark snapshots. Completed release-performance history belongs in the [CHANGELOG](../CHANGELOG.md); continuous CI history is available on [Bencher](https://bencher.dev/perf/minigraf/plots). +## Partition-at-a-time windows (#641, slice 3, unreleased) + +**Date**: 2026-10-28 · **Parent**: slice 2 at `e6670c82d` · **Change**: #641, +third slice. The [build manifest](benchmarks/641-partition-windows-build.json) +records the exact source fingerprint, matched parent/new library hashes, +compiler, lockfile, probe and fixture-builder hashes, and release size. + +The snapshot resolver can prove adjacency for one nonconstant partition key +shared by all built-in windows of a plain query. It prefers an existing entity +prefix; otherwise a numeric/Boolean or uniform Ref/Keyword value prefix can +qualify. DICT order proves adjacency only, never semantic Sort or Aggregate +order. Pending/staged records in the captured source range, aggregate queries, +unpartitioned or incompatible windows, callbacks and `collect-set` keep the +full-input strategy. No public syntax or setting changes. + +Each certified partition uses the existing evaluator for its own ordering, +peers, frames and neighbors. The operator retains one partition and a charged +lookahead batch, and coalesces completed partitions into bounded passing output +batches. It stops at an already-read child-batch boundary when output is ready, +so a small limit does not pull more input merely to complete an unneeded later +partition. A surrounding Sort/Distinct can still dominate memory. Row order +across physical plans requires final query `:order-by`. + +### Protocol and fixed partitions + +All builds, tests and measurements ran on the designated bench machine. The +immutable group fixtures from slice 2 contain exactly N committed facts: entity +UUID i+1 has integer `:group floor(i/16)` for fixed groups, or group zero for one +growing partition. Fixture construction runs separately from query timing/RSS. +The [window probe](../scripts/input_order_window_probe.rs) is linked unchanged +against both frozen libraries with the envelope opt-level-3/frame-pointer flags, +a 256 KiB worker stack, one warmup and at least three timed cursor drains per +process. Open/thread creation are outside query timing. Each drain checks every +entity, group value and partition row number, not just row count. + +Six idle-machine A/B process rounds alternate execution order and CPU/memory +NUMA binding. Results below are medians of six process medians; all raw records +retain each process's minimum/median/maximum, repeat count and peak RSS. +`value` partitions by `?g` (16 rows), `entity` by `?e` (one row). Both use +`(row-number :over (... :order-by ?e))`, project `?e ?g` before the window +column, and read `[?e :group ?g]`. Limited shapes add `:limit 10` without a final +Sort; the full query strings are in the records. + +| Shape | Facts | Parent ms | Partitioned ms | Time change | New peak RSS KiB | +|---|---:|---:|---:|---:|---:| +| `value` | 100k | 244.509 | 243.214 | -0.53% | 5,484 | +| `value` | 1m | 2989.030 | 2497.180 | -16.46% | 5,604 | +| `value` | 10m | 33536.737 | 25958.366 | -22.60% | 5,588 | +| `entity` | 100k | 247.649 | 255.748 | +3.27% | 5,408 | +| `entity` | 1m | 2971.102 | 2641.718 | -11.09% | 5,520 | +| `entity` | 10m | 33461.808 | 27378.896 | -18.18% | 5,680 | +| `value_limit` | 100k | 218.354 | 2.066 | -99.05% | 3,996 | +| `value_limit` | 1m | 2563.673 | 2.131 | -99.92% | 3,992 | +| `value_limit` | 10m | 28386.299 | 2.212 | -99.99% | 4,044 | +| `entity_limit` | 100k | 217.361 | 2.073 | -99.05% | 3,944 | +| `entity_limit` | 1m | 2559.089 | 2.146 | -99.92% | 3,900 | +| `entity_limit` | 10m | 28347.589 | 2.235 | -99.99% | 3,952 | + +The bounded limit 10M/100K time ratios are **1.071** (value) and **1.078** (entity), both within the 2x gate. The largest new 10M RSS increase over 100K across all four shapes is **272 KiB**, within the 16 MiB allowance. All [252 window records](benchmarks/641-partition-windows.jsonl) are retained. + +### Retained state and growing controls + +| Shape | Window peak bytes (all scales) | IdSpace peak bytes (all scales) | Max partition rows | Limited input rows | +|---|---:|---:|---:|---:| +| `value` | 52,464 | 81,920 | 16 | full drain | +| `value_limit` | 52,464 | 1,280 | 16 | 1,024 | +| `entity` | 49,464 | 81,920 | 1 | full drain | +| `entity_limit` | 49,464 | 800 | 1 | 1,024 | + +All [18 memory records](benchmarks/641-partition-windows-meter.jsonl) are retained. Both fixed-partition peaks are exactly flat from 100K to 10M, within the 100K peak plus two charged input batches (**98,464 bytes**, computed with the fixture’s cell/row helpers). A single growing partition instead reaches **200 × N + 32 Window bytes**, including with a limit, while IdSpace remains **81,920 bytes**. Finishing the first partition still requires all N rows; that is a linear control, not a bounded-limit claim. + +Input lookahead, keys, kept-cell entries, named values and result columns are +charged while retained. Shared payload estimates follow the existing +conservative per-entry accounting when both lookahead and kept copies exist; +passing output batches follow existing uncharged accounting. DICT ids remain +valid under the pin while transient lookup maps are evicted at internal input +batch and result-conversion boundaries. Provisional ids survive eviction. +A separate reference-heavy `?e`/`lag ?e`/`lead ?e` regression bounds lookups by +three output reference columns per 1,024-row batch; disabling result-conversion +eviction makes that regression fail. Window and IdSpace peaks are traced +separately in test builds, with no production instrumentation. + +| Shape | Facts | Parent ms | Partitioned ms | Time change | New peak RSS KiB | +|---|---:|---:|---:|---:|---:| +| `growing_value` | 100k | 247.919 | 266.611 | +7.54% | 34,896 | +| `growing_value` | 1m | 3006.784 | 2935.370 | -2.38% | 313,072 | +| `growing_value` | 10m | 33637.928 | 33139.746 | -1.48% | 2,897,984 | +| `growing_value_limit` | 100k | 216.650 | 203.653 | -6.00% | 35,064 | +| `growing_value_limit` | 1m | 2580.660 | 2190.145 | -15.13% | 319,284 | +| `growing_value_limit` | 10m | 28506.157 | 23415.299 | -17.86% | 2,897,296 | +| `unpartitioned_control` | 100k | 244.699 | 245.854 | +0.47% | 43,572 | +| `unpartitioned_control` | 1m | 2983.375 | 2976.743 | -0.22% | 444,780 | +| `unpartitioned_control` | 10m | 33287.533 | 33508.387 | +0.66% | 3,715,432 | + +A limit can avoid unread later input and its I/O/allocation errors. Coalescing +can still encounter an error while gathering one output batch after completing +some partitions. Built-in window pipelines contain no user callbacks or +fallible aggregate validation whose later data error would be hidden. + +### Existing guards and selective startup + +All 12 exact #379 history guards pass: time deltas **-2.17% to +0.49%**, within the +5% gate. Ordinary envelope points range from **-2.31% to +0.61%**. Existing ordered limit/offset cases range from **-1.66% to +1.99%**, and other controls from **-1.49% to +3.37%**. All [360 envelope/control records](benchmarks/641-partition-windows-guards.jsonl) and [144 history records](benchmarks/641-partition-windows-history.jsonl) are retained. + +| Startup workload | Facts | Parent µs | Partitioned µs | Added µs | +|---|---:|---:|---:|---:| +| `value_window_point` | 100k | 24.139 | 136.399 | +112.261 | +| `value_window_point` | 1m | 23.355 | 121.472 | +98.117 | +| `value_window_point` | 10m | 23.604 | 124.117 | +100.514 | +| `unpartitioned_window_point` | 100k | 23.471 | 23.123 | -0.347 | +| `unpartitioned_window_point` | 1m | 23.610 | 23.769 | +0.159 | +| `unpartitioned_window_point` | 10m | 23.683 | 23.733 | +0.050 | + +The [72 startup records](benchmarks/641-partition-windows-startup.jsonl) use the unchanged guard probe (three warmups, at least five timed drains, six balanced process rounds). Both queries read `[:pM :age ?a]` and project `?a` plus row-number ordered by `?a`; only the value-partition case adds `:partition-by ?a`. M is the midpoint entity. The source remains selective EAVT. + +No ordinary query without an applicable demand performs proof reads. Entity +partition certification needs no optional value-kind seeks. A newly eligible +selective value-partition window still pays eight whole-attribute proof seeks; +there is no cost-based strategy selection. The startup records report that +cost separately from existing point guards and unpartitioned-window controls. + +### Validation and reproduction + +The full default suite passes **1,972 tests** (17 ignored), test-hooks **2,005** (18 ignored), WASI **1,182** (seven ignored), and Firefox **61**. The committed-reader window fixture runs on both portable targets. Strict native/browser/WASI clippy, the WASI release build and unchanged branch-coverage floors pass (**95.44%** lines / **86.50%** branches). Golden-file/migration/fault-injection checks and frozen answer comparisons pass. The final focused window and doc-test reruns also pass. + +The initial native release binary exceeded the unchanged 1,259,520-byte cap. +Sharing the identical stable transaction-order sort across legacy-open paths, +and stable clause-cost sorting across ascending/descending call sites, brings +the final binary to **1,258,040 bytes**. Equal-key order, flags, dependencies, +public API, file/WAL formats and frozen answers remain unchanged. + +Build the [group fixture](../scripts/input_order_group_fixture.rs) with the +parent library, and link the same window probe against both matched libraries +using the slice-1 rustc/envelope recipe. For example: + +```sh +group_fixture fixed.graph 100000 16 +window_probe fixed.graph '(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])' 10 16 16 +``` + +Use `:partition-by ?e` and final probe argument 1 for one-row entity +partitions. Use fixture group size N and final probe argument N for the growing +partition, or omit `:partition-by` with final probe argument N for its +unpartitioned control. Alternate bindings/order over six rounds. + +All sixteen Criterion IDs execute with +`cargo bench --bench minigraf_bench -- '^query/partition_windows/' --test`: +`query/partition_windows/{value,entity,value_limit,entity_limit}/{1k,10k,100k,1m}`. +They use committed one-row partitions, with value/entity certificates and +full/limited drains. The existing nightly `^query/` route selects every new ID +(#776). Scheduled Bencher history becomes available after merge; none is +claimed here. + ## One-group count and distinct count (#641, slice 2, unreleased) **Date**: 2026-10-28 · **Parent**: slice 1 at `366f662df` · **Change**: #641, diff --git a/docs/TEST_COVERAGE.md b/docs/TEST_COVERAGE.md index 6f02d5fc5c..1f275798d5 100644 --- a/docs/TEST_COVERAGE.md +++ b/docs/TEST_COVERAGE.md @@ -4,13 +4,13 @@ | | Default features | With `--features test-hooks` | |---|---|---| -| **Passing** | 1,947 | 1,980 | -| **Ignored** | 16 | 17 | -| **Total** | 1,963 | 1,997 | +| **Passing** | 1,972 | 2,005 | +| **Ignored** | 17 | 18 | +| **Total** | 1,989 | 2,023 | -**Verified**: 2026-10-28 on the designated bench machine: the full default suite under branch coverage plus `cargo test --doc`, and `cargo test --features test-hooks`. Final test-only strengthening of group-demand and early-cursor assertions passed a focused rerun. An appended internal DICT-cache regression passed default/test-hooks checks and an incremental coverage run; disabling internal eviction made that regression fail. The matched production library remained byte-identical. All unchanged coverage floors pass; measured overall coverage is 95.40% lines and 86.38% branches. +**Verified**: 2026-10-28 on the designated bench machine: full default/test-hooks tests and the full branch-coverage suite pass, including golden files and migration/fault injection after sharing stable-sort code. Disabling internal reference-result cache eviction makes the targeted window regression fail. All unchanged coverage floors pass; measured overall coverage is 95.44% lines and 86.50% branches. Strict native/browser/WASI lint, WASI tests (1,182 passing, seven ignored), the WASI release build and Firefox tests (61 passing) also pass; the new committed-reader window fixture executes on both portable runners. -#641 slice 1 adds 30 tests with default features and one more with `test-hooks`. Slice 2 adds 22 default-feature tests (21 active and one ignored committed-fixture memory diagnostic). +#641 slice 1 adds 30 tests with default features and one more with `test-hooks`. Slice 2 adds 22 default-feature tests (21 active and one ignored committed-fixture memory diagnostic). Slice 3 adds 26 default-feature tests (25 active and one ignored committed-fixture memory diagnostic). #183 adds bounded row-frame parser, evaluator, and integration tests; one additional plan-independence case runs with `test-hooks`, including duplicate tie keys and NaN. A sliding-sum test checks recovery after integer saturation. Grammar corpus cases cover frame spellings and rejection. A meter test checks that a zero-width min frame reserves one deque slot. An ignored bench-machine diagnostic reproduces the Criterion datasets and prints the engine meter's peak for every measured case. @@ -30,6 +30,8 @@ Not counted above: the browser tests and the WASI run (see [Browser and WASI](#b - **One-group count aggregation** (#641, second slice; `src/query/engine/aggregate_order_tests.rs`, `order/tests.rs`, `engine/tests.rs`): count/count-distinct over one certified scalar group, cross-batch boundaries, unique-key Sort omission and retained descending/aggregate-first/mixed-numeric Sort, Boolean/float representatives and mixed numeric group order. Arbitrary argument kinds, nil, `:distinct`, offset/limit and probe joins match forced fallback. Tests cover no `:with`/window/multiple-key eligibility, later fallible-aggregate/callback/collect-set errors and dropped-group precedence, pending/staged/prepared/working-reader changes and rejected statements, atomic fallback on every optional proof-read failure, bounded group state with one active group, internal DICT-cache eviction within one group spanning many probe batches, a growing distinct-group control, low budgets, allocator refusal, close/drop/rewind, and defensive `INT-032` for injected decreasing input before and after an answer batch. A committed `MemoryBackend` fixture also runs under WASI and in the browser. +- **Partition windows** (#641, third slice; `window_order_tests.rs`, `order/tests.rs`, `order_tests.rs`, `engine/tests.rs`): compatible multiple windows with independent orders, peers, frames and neighbors; scalar/mixed-number, entity, Ref and Keyword adjacency with comparator-specific fallbacks; boundaries on and across batch edges; empty/selective ranges; callback/CollectSet/aggregate-query exclusions; bounded early-limit reads and output coalescing; pending/staged/working-reader/prepared/cursor pinning; fixed versus growing partitions; separately tracked Window/IdSpace peaks; internal input and reference-result cache eviction, including a failing retention mutation; lookahead ownership, low budgets, allocator refusal, close/drop/rewind and defensive `INT-032` before and after returned batches. The committed `MemoryBackend` fixture runs on native, WASI and browser targets. + - **Bounded row frames** (`tests/window_functions_test.rs`, `src/query/datalog/aggregate/tests.rs`, #183): `:rows N preceding` parsing and errors, physical rows with tied order keys, partition reset, descending order, width zero and maximum, all five built-in aggregates against a replay oracle with numeric edge cases, UDFs through prepared queries and cursors, grouping with `:with`, distinct output, memory-limit refusal for long min/max strings, and final `:order-by` matching. A `test-hooks` case checks answer bags with clause reordering on and off. - **Optional distinct output** (`tests/distinct_test.rs`, #493): bag defaults, whole tuples, section syntax, cross-batch and committed/pending values, chunked write transactions, prepared execute/cursors, joins/rules/disjunction, aggregates and hidden `:with` groups, window peers and partitioned row numbers, temporal filters, typed equality and canonical float/set output, memory limits (including retained set payloads) and cursor cleanup. A meter unit test verifies each cell/key/value estimate includes set elements and their strings. With `test-hooks`, checks both reorder settings and hashed/correlated subplans. An engine unit test checks counters and state release. @@ -490,8 +492,8 @@ These tests compare the database against an independent answer rather than a sin None of these are counted in the summary. The wasm32 targets run in CI (`.github/workflows/wasm.yml`). -- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 60 `wasm_bindgen_test` tests. The final #641 snapshot passed in headless Firefox on the bench; Chrome remains a CI run. - - Two committed-memory-backend input-order fixtures: scalar Sort omission, and streaming counts with Boolean/float representatives and mixed numeric group order (#641). +- **In a browser** (`wasm-pack test --headless`, Firefox and Chrome): 61 `wasm_bindgen_test` tests. The final #641 snapshot passed in headless Firefox on the bench; Chrome remains a CI run. + - Three committed-memory-backend input-order fixtures: scalar Sort omission, streaming counts with Boolean/float representatives and mixed numeric group order, and partition windows preserving float edges and numeric group classes (#641). - Twenty-five for `BrowserDb`, including IndexedDB persistence, the cursor, and the flush returning every dirty page and failing on one it cannot read (#470). - Eleven for `BrowserBufferBackend` (which used `#[test]` and never ran before). - Two checking that IndexedDB page keys accept only whole numbers from 0 to 2^53. @@ -507,11 +509,11 @@ None of these are counted in the summary. The wasm32 targets run in CI (`.github - `importGraph()` deletes the replaced database's IndexedDB keys. - Two buffer tests check that releasing a page drops its bytes and any unflushed write, and that export writes a released page as zeros. - A native storage test checks that a file whose free pages are all zeros (as the browser exports them), both just migrated from v7 and after 20 saves, opens, verifies clean and keeps committing. The free-list test checks that a checkpoint reports exactly the ids it newly lists. -- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,179 passing and seven ignored in the 2026-10-28 bench run with Wasmtime v49.0.2 (`wasm.yml`). Both committed input-order fixtures run here too, and the WASI REPL builds in release mode. +- **On `wasm32-wasip1` under Wasmtime**: the unit and integration tests that do not use a file run, 1,182 passing and seven ignored in the 2026-10-28 bench run with Wasmtime v49.0.2 (`wasm.yml`). All three committed input-order fixtures run here too, and the WASI REPL builds in release mode. ## Ignored Tests -The sixteen ignored tests (seventeen with `test-hooks`) are intentionally excluded from a normal local run: +The seventeen ignored tests (eighteen with `test-hooks`) are intentionally excluded from a normal local run: - Four rustdoc examples that reference internal types and cannot compile as standalone examples. - One high-contention concurrency stress test intended for scheduled runs. diff --git a/docs/benchmarks/641-partition-windows-build.json b/docs/benchmarks/641-partition-windows-build.json new file mode 100644 index 0000000000..98210f8ae5 --- /dev/null +++ b/docs/benchmarks/641-partition-windows-build.json @@ -0,0 +1,30 @@ +{ + "executed_benchmark_ids": [ + "query/partition_windows/value/1k", + "query/partition_windows/value/10k", + "query/partition_windows/value/100k", + "query/partition_windows/value/1m", + "query/partition_windows/entity/1k", + "query/partition_windows/entity/10k", + "query/partition_windows/entity/100k", + "query/partition_windows/entity/1m", + "query/partition_windows/value_limit/1k", + "query/partition_windows/value_limit/10k", + "query/partition_windows/value_limit/100k", + "query/partition_windows/value_limit/1m", + "query/partition_windows/entity_limit/1k", + "query/partition_windows/entity_limit/10k", + "query/partition_windows/entity_limit/100k", + "query/partition_windows/entity_limit/1m" + ], + "nightly_filter": "^query/", + "parent_commit": "e6670c82d24ac8e1f7ef0a75ca88c67b74c07f67", + "parent_library_sha256": "419def4308e7cfc61cb4fa7f0572d0751713a50dab6a89c1cf8939ee91f78faf", + "partitioned_library_sha256": "f308364c49fd59adac456299220db7bd5be74641dbbf0b9988bc93b209f339c2", + "lock_sha256": "b03965119fd8ce5b5cf3ad3d37fb194ffeae24b6a862a0c85ae8fbcb6833ee77", + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "source_sha256": "f5410bb1ac6f00b02e2f459bd81ab6bf76fe7dd460b4219727a445812e51d009", + "probe_sha256": "06894b129f2022b18bfb0fd9f98ab6cae0d03b1eb48697299542558a7cc339ba", + "fixture_builder_sha256": "2498b51719a8db20cba0c110b66ba3fdf71a82c08508b3183bb1b5b1892e26a2", + "release_bytes": 1258040 +} diff --git a/docs/benchmarks/641-partition-windows-guards.jsonl b/docs/benchmarks/641-partition-windows-guards.jsonl new file mode 100644 index 0000000000..32b66e0437 --- /dev/null +++ b/docs/benchmarks/641-partition-windows-guards.jsonl @@ -0,0 +1,360 @@ +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2165, "median_us": 455.208, "min_us": 442.883, "max_us": 1436.258, "rows": 10, "peak_rss_kb": 3792} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2152, "median_us": 456.468, "min_us": 443.765, "max_us": 3287.268, "rows": 10, "peak_rss_kb": 3736} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2093, "median_us": 468.54, "min_us": 455.704, "max_us": 1450.176, "rows": 10, "peak_rss_kb": 3776} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2157, "median_us": 455.936, "min_us": 442.391, "max_us": 1445.944, "rows": 10, "peak_rss_kb": 3780} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7432, "median_us": 129.736, "min_us": 128.147, "max_us": 2157.232, "rows": 1, "peak_rss_kb": 3688} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7512, "median_us": 130.164, "min_us": 129.1, "max_us": 449.263, "rows": 1, "peak_rss_kb": 3776} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.286, "min_us": 18.758, "max_us": 83.483, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.043, "min_us": 18.414, "max_us": 95.517, "rows": 1, "peak_rss_kb": 3844} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.9, "min_us": 18.45, "max_us": 77.12, "rows": 1, "peak_rss_kb": 3876} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.857, "min_us": 18.417, "max_us": 101.107, "rows": 1, "peak_rss_kb": 3808} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3044, "median_us": 318.851, "min_us": 314.772, "max_us": 3205.452, "rows": 1, "peak_rss_kb": 3688} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3013, "median_us": 325.276, "min_us": 319.988, "max_us": 1026.788, "rows": 1, "peak_rss_kb": 3744} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13352.786, "min_us": 13224.177, "max_us": 14655.866, "rows": 16666, "peak_rss_kb": 4956} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13298.595, "min_us": 13255.589, "max_us": 20797.709, "rows": 16666, "peak_rss_kb": 4904} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2710, "median_us": 365.223, "min_us": 349.147, "max_us": 1156.254, "rows": 10, "peak_rss_kb": 3836} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2765, "median_us": 355.476, "min_us": 347.742, "max_us": 1162.907, "rows": 10, "peak_rss_kb": 3872} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25646.862, "min_us": 25410.91, "max_us": 35817.197, "rows": 10, "peak_rss_kb": 4800} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25494.846, "min_us": 25340.112, "max_us": 29374.105, "rows": 10, "peak_rss_kb": 4716} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25931.399, "min_us": 25711.166, "max_us": 34853.038, "rows": 10, "peak_rss_kb": 4808} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25506.946, "min_us": 25331.283, "max_us": 26656.812, "rows": 10, "peak_rss_kb": 4716} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2217, "median_us": 446.133, "min_us": 414.059, "max_us": 1419.465, "rows": 10, "peak_rss_kb": 3744} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2162, "median_us": 452.222, "min_us": 444.384, "max_us": 4726.926, "rows": 10, "peak_rss_kb": 3776} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2161, "median_us": 455.466, "min_us": 446.872, "max_us": 1440.173, "rows": 10, "peak_rss_kb": 3816} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2186, "median_us": 449.634, "min_us": 442.161, "max_us": 1448.831, "rows": 10, "peak_rss_kb": 3776} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8528, "median_us": 112.829, "min_us": 111.623, "max_us": 1474.719, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8638, "median_us": 113.128, "min_us": 112.052, "max_us": 374.388, "rows": 1, "peak_rss_kb": 3800} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.966, "min_us": 19.47, "max_us": 83.366, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.102, "min_us": 18.455, "max_us": 105.798, "rows": 1, "peak_rss_kb": 3812} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.094, "min_us": 17.048, "max_us": 117.69, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.02, "min_us": 17.053, "max_us": 80.486, "rows": 1, "peak_rss_kb": 3716} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2954, "median_us": 316.5, "min_us": 313.041, "max_us": 36726.392, "rows": 1, "peak_rss_kb": 3704} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3089, "median_us": 317.195, "min_us": 313.071, "max_us": 1013.955, "rows": 1, "peak_rss_kb": 3724} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 139815.231, "min_us": 138912.935, "max_us": 149920.204, "rows": 166666, "peak_rss_kb": 5160} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 141837.657, "min_us": 140412.639, "max_us": 143110.6, "rows": 166666, "peak_rss_kb": 5308} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2709, "median_us": 354.959, "min_us": 341.861, "max_us": 4553.692, "rows": 10, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2609, "median_us": 376.243, "min_us": 371.763, "max_us": 1192.794, "rows": 10, "peak_rss_kb": 3800} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 275076.331, "min_us": 270105.98, "max_us": 281777.987, "rows": 10, "peak_rss_kb": 5004} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 268868.232, "min_us": 266775.201, "max_us": 269673.713, "rows": 10, "peak_rss_kb": 5068} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 274354.115, "min_us": 270383.123, "max_us": 276195.696, "rows": 10, "peak_rss_kb": 5004} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268608.319, "min_us": 268417.32, "max_us": 275503.433, "rows": 10, "peak_rss_kb": 4972} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2106, "median_us": 460.738, "min_us": 451.058, "max_us": 1449.733, "rows": 10, "peak_rss_kb": 3708} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2215, "median_us": 445.289, "min_us": 425.594, "max_us": 1446.499, "rows": 10, "peak_rss_kb": 3804} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2196, "median_us": 446.763, "min_us": 424.094, "max_us": 3233.368, "rows": 10, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2154, "median_us": 457.479, "min_us": 449.665, "max_us": 1459.866, "rows": 10, "peak_rss_kb": 3776} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8220, "median_us": 118.249, "min_us": 114.154, "max_us": 385.614, "rows": 1, "peak_rss_kb": 3684} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8279, "median_us": 117.223, "min_us": 113.866, "max_us": 1610.394, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.238, "min_us": 18.643, "max_us": 84.244, "rows": 1, "peak_rss_kb": 3800} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.282, "min_us": 18.712, "max_us": 92.543, "rows": 1, "peak_rss_kb": 3848} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.575, "min_us": 17.776, "max_us": 89.343, "rows": 1, "peak_rss_kb": 3788} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.634, "min_us": 17.935, "max_us": 78.785, "rows": 1, "peak_rss_kb": 3820} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3028, "median_us": 323.935, "min_us": 315.68, "max_us": 2750.046, "rows": 1, "peak_rss_kb": 3696} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3076, "median_us": 323.322, "min_us": 316.179, "max_us": 467.57, "rows": 1, "peak_rss_kb": 3704} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1399635.466, "min_us": 1390621.592, "max_us": 1405031.575, "rows": 1666666, "peak_rss_kb": 5392} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1444321.629, "min_us": 1431024.109, "max_us": 1474896.894, "rows": 1666666, "peak_rss_kb": 5412} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2638, "median_us": 372.983, "min_us": 361.322, "max_us": 1170.574, "rows": 10, "peak_rss_kb": 3896} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2707, "median_us": 364.15, "min_us": 341.837, "max_us": 1149.201, "rows": 10, "peak_rss_kb": 3832} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2807766.63, "min_us": 2768927.223, "max_us": 2811366.326, "rows": 10, "peak_rss_kb": 5140} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2851769.445, "min_us": 2797048.591, "max_us": 2855504.88, "rows": 10, "peak_rss_kb": 5064} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2798236.014, "min_us": 2794894.991, "max_us": 2829547.318, "rows": 10, "peak_rss_kb": 5004} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2812689.128, "min_us": 2796963.433, "max_us": 2845881.991, "rows": 10, "peak_rss_kb": 5036} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2155, "median_us": 455.699, "min_us": 445.066, "max_us": 1460.828, "rows": 10, "peak_rss_kb": 3776} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2164, "median_us": 454.144, "min_us": 441.241, "max_us": 6813.863, "rows": 10, "peak_rss_kb": 3756} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2125, "median_us": 455.181, "min_us": 443.761, "max_us": 1439.987, "rows": 10, "peak_rss_kb": 3736} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2170, "median_us": 456.031, "min_us": 443.553, "max_us": 3304.901, "rows": 10, "peak_rss_kb": 3756} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7516, "median_us": 129.863, "min_us": 128.611, "max_us": 423.035, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7535, "median_us": 129.471, "min_us": 128.336, "max_us": 581.875, "rows": 1, "peak_rss_kb": 3732} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.091, "min_us": 18.246, "max_us": 83.553, "rows": 1, "peak_rss_kb": 3844} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.033, "min_us": 18.435, "max_us": 79.099, "rows": 1, "peak_rss_kb": 3792} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.835, "min_us": 18.367, "max_us": 784.317, "rows": 1, "peak_rss_kb": 3864} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.196, "min_us": 18.75, "max_us": 60.949, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3051, "median_us": 321.488, "min_us": 315.311, "max_us": 1020.984, "rows": 1, "peak_rss_kb": 3724} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3035, "median_us": 323.86, "min_us": 320.244, "max_us": 1012.114, "rows": 1, "peak_rss_kb": 3692} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13374.527, "min_us": 13317.798, "max_us": 20570.854, "rows": 16666, "peak_rss_kb": 4984} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13341.73, "min_us": 13276.746, "max_us": 14877.105, "rows": 16666, "peak_rss_kb": 4952} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2732, "median_us": 357.146, "min_us": 351.424, "max_us": 1206.602, "rows": 10, "peak_rss_kb": 3800} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2746, "median_us": 355.382, "min_us": 347.244, "max_us": 3127.212, "rows": 10, "peak_rss_kb": 3740} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25568.36, "min_us": 25247.376, "max_us": 27733.271, "rows": 10, "peak_rss_kb": 4872} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25743.786, "min_us": 25510.152, "max_us": 25895.0, "rows": 10, "peak_rss_kb": 4760} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25425.648, "min_us": 25200.127, "max_us": 27220.375, "rows": 10, "peak_rss_kb": 4872} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25629.234, "min_us": 25369.084, "max_us": 25935.819, "rows": 10, "peak_rss_kb": 4804} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2172, "median_us": 450.223, "min_us": 439.43, "max_us": 4014.563, "rows": 10, "peak_rss_kb": 3796} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2133, "median_us": 460.581, "min_us": 448.562, "max_us": 1446.241, "rows": 10, "peak_rss_kb": 3740} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2265, "median_us": 433.503, "min_us": 418.103, "max_us": 1436.819, "rows": 10, "peak_rss_kb": 3772} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2167, "median_us": 449.489, "min_us": 442.228, "max_us": 4492.141, "rows": 10, "peak_rss_kb": 3708} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8679, "median_us": 112.72, "min_us": 111.675, "max_us": 440.697, "rows": 1, "peak_rss_kb": 3772} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8669, "median_us": 112.616, "min_us": 111.537, "max_us": 390.488, "rows": 1, "peak_rss_kb": 3764} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.976, "min_us": 18.497, "max_us": 80.576, "rows": 1, "peak_rss_kb": 3824} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.429, "min_us": 18.801, "max_us": 727.585, "rows": 1, "peak_rss_kb": 3792} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.976, "min_us": 16.989, "max_us": 50.147, "rows": 1, "peak_rss_kb": 3852} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.528, "min_us": 17.546, "max_us": 86.777, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3077, "median_us": 318.071, "min_us": 312.633, "max_us": 1042.46, "rows": 1, "peak_rss_kb": 3732} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3050, "median_us": 322.317, "min_us": 318.398, "max_us": 1015.007, "rows": 1, "peak_rss_kb": 3668} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 138157.822, "min_us": 137023.962, "max_us": 139933.536, "rows": 166666, "peak_rss_kb": 5292} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 142532.683, "min_us": 141718.475, "max_us": 142881.946, "rows": 166666, "peak_rss_kb": 5252} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2647, "median_us": 371.67, "min_us": 365.217, "max_us": 1190.798, "rows": 10, "peak_rss_kb": 3692} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2607, "median_us": 377.242, "min_us": 371.834, "max_us": 1200.221, "rows": 10, "peak_rss_kb": 3708} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 266225.935, "min_us": 265610.981, "max_us": 273697.912, "rows": 10, "peak_rss_kb": 5140} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 273224.809, "min_us": 266611.651, "max_us": 278486.03, "rows": 10, "peak_rss_kb": 5036} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 268813.869, "min_us": 267303.415, "max_us": 269659.641, "rows": 10, "peak_rss_kb": 5096} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 272604.104, "min_us": 266640.677, "max_us": 274473.889, "rows": 10, "peak_rss_kb": 4952} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2153, "median_us": 456.782, "min_us": 449.589, "max_us": 1449.382, "rows": 10, "peak_rss_kb": 3792} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2127, "median_us": 458.479, "min_us": 449.41, "max_us": 4575.979, "rows": 10, "peak_rss_kb": 3736} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2154, "median_us": 453.945, "min_us": 446.576, "max_us": 1444.807, "rows": 10, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2164, "median_us": 454.589, "min_us": 444.622, "max_us": 1433.691, "rows": 10, "peak_rss_kb": 3752} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8314, "median_us": 117.31, "min_us": 113.913, "max_us": 1478.613, "rows": 1, "peak_rss_kb": 3796} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8212, "median_us": 120.165, "min_us": 113.341, "max_us": 385.012, "rows": 1, "peak_rss_kb": 3776} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.345, "min_us": 18.702, "max_us": 82.633, "rows": 1, "peak_rss_kb": 3852} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.718, "min_us": 19.122, "max_us": 99.931, "rows": 1, "peak_rss_kb": 3840} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.795, "min_us": 17.101, "max_us": 98.411, "rows": 1, "peak_rss_kb": 3824} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.262, "min_us": 17.457, "max_us": 769.639, "rows": 1, "peak_rss_kb": 3844} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3035, "median_us": 323.295, "min_us": 315.362, "max_us": 1025.515, "rows": 1, "peak_rss_kb": 3752} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3023, "median_us": 325.572, "min_us": 316.376, "max_us": 1019.403, "rows": 1, "peak_rss_kb": 3700} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1402263.339, "min_us": 1393107.607, "max_us": 1448604.497, "rows": 1666666, "peak_rss_kb": 5280} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1461808.486, "min_us": 1455126.591, "max_us": 1471244.587, "rows": 1666666, "peak_rss_kb": 5388} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2755, "median_us": 360.807, "min_us": 343.452, "max_us": 1165.215, "rows": 10, "peak_rss_kb": 3880} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2639, "median_us": 369.408, "min_us": 350.796, "max_us": 3198.914, "rows": 10, "peak_rss_kb": 3796} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2809101.589, "min_us": 2764433.903, "max_us": 2834417.33, "rows": 10, "peak_rss_kb": 5064} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2859102.796, "min_us": 2827146.335, "max_us": 2879521.228, "rows": 10, "peak_rss_kb": 5016} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2785424.667, "min_us": 2777947.019, "max_us": 2788045.879, "rows": 10, "peak_rss_kb": 5036} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2847055.093, "min_us": 2831602.475, "max_us": 2876036.218, "rows": 10, "peak_rss_kb": 5012} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2162, "median_us": 455.941, "min_us": 437.092, "max_us": 1408.302, "rows": 10, "peak_rss_kb": 3732} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2166, "median_us": 457.366, "min_us": 448.11, "max_us": 1441.83, "rows": 10, "peak_rss_kb": 3728} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2140, "median_us": 456.391, "min_us": 439.96, "max_us": 3828.185, "rows": 10, "peak_rss_kb": 3768} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2138, "median_us": 460.662, "min_us": 444.833, "max_us": 1447.898, "rows": 10, "peak_rss_kb": 3808} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7522, "median_us": 129.926, "min_us": 128.208, "max_us": 440.229, "rows": 1, "peak_rss_kb": 3736} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7399, "median_us": 130.686, "min_us": 129.328, "max_us": 1526.512, "rows": 1, "peak_rss_kb": 3724} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.171, "min_us": 18.642, "max_us": 79.554, "rows": 1, "peak_rss_kb": 3880} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.352, "min_us": 18.7, "max_us": 85.554, "rows": 1, "peak_rss_kb": 3856} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.888, "min_us": 18.383, "max_us": 95.463, "rows": 1, "peak_rss_kb": 3888} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.726, "min_us": 18.353, "max_us": 85.259, "rows": 1, "peak_rss_kb": 3808} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3017, "median_us": 324.527, "min_us": 320.417, "max_us": 1049.678, "rows": 1, "peak_rss_kb": 3708} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3048, "median_us": 317.971, "min_us": 314.925, "max_us": 3089.886, "rows": 1, "peak_rss_kb": 3648} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13473.404, "min_us": 13431.685, "max_us": 13792.684, "rows": 16666, "peak_rss_kb": 4968} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13498.161, "min_us": 13459.684, "max_us": 21348.117, "rows": 16666, "peak_rss_kb": 4904} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2853, "median_us": 342.502, "min_us": 332.295, "max_us": 1185.469, "rows": 10, "peak_rss_kb": 3788} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2715, "median_us": 362.458, "min_us": 348.971, "max_us": 1160.026, "rows": 10, "peak_rss_kb": 3824} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25695.997, "min_us": 25509.031, "max_us": 37288.079, "rows": 10, "peak_rss_kb": 4840} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25577.277, "min_us": 25365.338, "max_us": 25755.27, "rows": 10, "peak_rss_kb": 4860} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25528.328, "min_us": 25307.977, "max_us": 27000.296, "rows": 10, "peak_rss_kb": 4796} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25583.602, "min_us": 25405.707, "max_us": 34142.455, "rows": 10, "peak_rss_kb": 4776} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2145, "median_us": 461.436, "min_us": 445.916, "max_us": 1461.216, "rows": 10, "peak_rss_kb": 3764} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2168, "median_us": 454.635, "min_us": 447.417, "max_us": 1439.983, "rows": 10, "peak_rss_kb": 3752} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2270, "median_us": 429.011, "min_us": 415.048, "max_us": 3239.468, "rows": 10, "peak_rss_kb": 3728} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2280, "median_us": 427.604, "min_us": 420.183, "max_us": 1434.707, "rows": 10, "peak_rss_kb": 3752} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8675, "median_us": 112.425, "min_us": 111.323, "max_us": 428.057, "rows": 1, "peak_rss_kb": 3720} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8582, "median_us": 112.624, "min_us": 111.439, "max_us": 1457.074, "rows": 1, "peak_rss_kb": 3784} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.243, "min_us": 18.752, "max_us": 133.456, "rows": 1, "peak_rss_kb": 3808} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.738, "min_us": 18.3, "max_us": 83.67, "rows": 1, "peak_rss_kb": 3820} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.345, "min_us": 17.39, "max_us": 98.371, "rows": 1, "peak_rss_kb": 3800} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.068, "min_us": 17.057, "max_us": 87.138, "rows": 1, "peak_rss_kb": 3828} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3030, "median_us": 321.307, "min_us": 313.328, "max_us": 3068.514, "rows": 1, "peak_rss_kb": 3608} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3059, "median_us": 321.518, "min_us": 317.632, "max_us": 1021.953, "rows": 1, "peak_rss_kb": 3584} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140493.534, "min_us": 138240.555, "max_us": 142025.017, "rows": 166666, "peak_rss_kb": 5256} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140422.148, "min_us": 139501.097, "max_us": 141108.655, "rows": 166666, "peak_rss_kb": 5192} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2745, "median_us": 360.27, "min_us": 344.892, "max_us": 1190.067, "rows": 10, "peak_rss_kb": 3836} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2686, "median_us": 360.218, "min_us": 344.093, "max_us": 4675.817, "rows": 10, "peak_rss_kb": 3696} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 271021.711, "min_us": 270776.537, "max_us": 272466.348, "rows": 10, "peak_rss_kb": 4932} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 268441.762, "min_us": 268303.872, "max_us": 271845.24, "rows": 10, "peak_rss_kb": 4904} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 276460.154, "min_us": 273587.06, "max_us": 290455.077, "rows": 10, "peak_rss_kb": 4920} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 272396.007, "min_us": 271302.391, "max_us": 280337.673, "rows": 10, "peak_rss_kb": 4984} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2137, "median_us": 460.163, "min_us": 453.251, "max_us": 1446.053, "rows": 10, "peak_rss_kb": 3716} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2164, "median_us": 460.152, "min_us": 453.361, "max_us": 644.658, "rows": 10, "peak_rss_kb": 3736} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2146, "median_us": 453.934, "min_us": 442.438, "max_us": 3474.638, "rows": 10, "peak_rss_kb": 3704} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2166, "median_us": 454.666, "min_us": 448.142, "max_us": 1444.607, "rows": 10, "peak_rss_kb": 3764} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8192, "median_us": 118.568, "min_us": 113.596, "max_us": 406.162, "rows": 1, "peak_rss_kb": 3712} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8163, "median_us": 118.214, "min_us": 114.358, "max_us": 1225.292, "rows": 1, "peak_rss_kb": 3780} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.249, "min_us": 18.654, "max_us": 82.507, "rows": 1, "peak_rss_kb": 3792} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.364, "min_us": 18.765, "max_us": 86.432, "rows": 1, "peak_rss_kb": 3864} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.851, "min_us": 17.985, "max_us": 79.363, "rows": 1, "peak_rss_kb": 3884} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.869, "min_us": 17.041, "max_us": 79.93, "rows": 1, "peak_rss_kb": 3848} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3019, "median_us": 325.963, "min_us": 320.836, "max_us": 1019.764, "rows": 1, "peak_rss_kb": 3676} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3035, "median_us": 320.785, "min_us": 316.015, "max_us": 3035.025, "rows": 1, "peak_rss_kb": 3708} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1418442.909, "min_us": 1405664.627, "max_us": 1429031.612, "rows": 1666666, "peak_rss_kb": 5424} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1465842.722, "min_us": 1459706.048, "max_us": 1472922.882, "rows": 1666666, "peak_rss_kb": 5312} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2660, "median_us": 366.215, "min_us": 344.539, "max_us": 2563.234, "rows": 10, "peak_rss_kb": 3844} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2693, "median_us": 366.537, "min_us": 354.604, "max_us": 1156.982, "rows": 10, "peak_rss_kb": 3836} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2809699.502, "min_us": 2783269.958, "max_us": 2822496.662, "rows": 10, "peak_rss_kb": 4996} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2824944.37, "min_us": 2819461.371, "max_us": 2919911.088, "rows": 10, "peak_rss_kb": 5060} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2804000.327, "min_us": 2801212.198, "max_us": 2822366.232, "rows": 10, "peak_rss_kb": 5020} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2824812.389, "min_us": 2815977.561, "max_us": 2850027.223, "rows": 10, "peak_rss_kb": 5044} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2165, "median_us": 453.898, "min_us": 437.66, "max_us": 1435.928, "rows": 10, "peak_rss_kb": 3780} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2146, "median_us": 454.423, "min_us": 436.38, "max_us": 3877.623, "rows": 10, "peak_rss_kb": 3776} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2167, "median_us": 455.41, "min_us": 447.302, "max_us": 1436.639, "rows": 10, "peak_rss_kb": 3772} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2161, "median_us": 455.497, "min_us": 445.42, "max_us": 1434.468, "rows": 10, "peak_rss_kb": 3764} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7471, "median_us": 129.883, "min_us": 128.768, "max_us": 2325.136, "rows": 1, "peak_rss_kb": 3760} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7561, "median_us": 129.47, "min_us": 127.789, "max_us": 420.681, "rows": 1, "peak_rss_kb": 3716} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.098, "min_us": 18.456, "max_us": 79.292, "rows": 1, "peak_rss_kb": 3712} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 18.856, "min_us": 18.42, "max_us": 93.705, "rows": 1, "peak_rss_kb": 3812} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.783, "min_us": 18.383, "max_us": 95.198, "rows": 1, "peak_rss_kb": 3808} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.133, "min_us": 18.533, "max_us": 855.239, "rows": 1, "peak_rss_kb": 3792} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3035, "median_us": 323.728, "min_us": 320.092, "max_us": 1017.723, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3070, "median_us": 323.197, "min_us": 315.574, "max_us": 803.313, "rows": 1, "peak_rss_kb": 3692} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13311.514, "min_us": 13257.121, "max_us": 19262.126, "rows": 16666, "peak_rss_kb": 5004} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13471.114, "min_us": 13247.268, "max_us": 13808.885, "rows": 16666, "peak_rss_kb": 4928} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2721, "median_us": 359.907, "min_us": 351.216, "max_us": 1149.206, "rows": 10, "peak_rss_kb": 3836} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2628, "median_us": 372.353, "min_us": 355.626, "max_us": 3158.418, "rows": 10, "peak_rss_kb": 3744} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 40, "median_us": 25444.47, "min_us": 25279.912, "max_us": 25709.267, "rows": 10, "peak_rss_kb": 4820} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25676.219, "min_us": 25505.435, "max_us": 26368.064, "rows": 10, "peak_rss_kb": 4852} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25529.106, "min_us": 25252.411, "max_us": 31649.772, "rows": 10, "peak_rss_kb": 4872} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25673.835, "min_us": 25454.593, "max_us": 26642.581, "rows": 10, "peak_rss_kb": 4800} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2164, "median_us": 455.226, "min_us": 447.077, "max_us": 1444.208, "rows": 10, "peak_rss_kb": 3780} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2167, "median_us": 449.688, "min_us": 442.283, "max_us": 3923.21, "rows": 10, "peak_rss_kb": 3712} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2251, "median_us": 430.163, "min_us": 421.75, "max_us": 1442.009, "rows": 10, "peak_rss_kb": 3756} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2262, "median_us": 429.924, "min_us": 416.377, "max_us": 1452.45, "rows": 10, "peak_rss_kb": 3768} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8588, "median_us": 112.803, "min_us": 111.754, "max_us": 1487.976, "rows": 1, "peak_rss_kb": 3740} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8738, "median_us": 112.264, "min_us": 111.064, "max_us": 389.709, "rows": 1, "peak_rss_kb": 3768} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.931, "min_us": 18.247, "max_us": 96.258, "rows": 1, "peak_rss_kb": 3856} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.119, "min_us": 18.416, "max_us": 81.323, "rows": 1, "peak_rss_kb": 3784} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.896, "min_us": 16.928, "max_us": 80.18, "rows": 1, "peak_rss_kb": 3864} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.747, "min_us": 16.679, "max_us": 714.93, "rows": 1, "peak_rss_kb": 3840} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3039, "median_us": 322.061, "min_us": 318.322, "max_us": 1016.049, "rows": 1, "peak_rss_kb": 3584} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3050, "median_us": 321.32, "min_us": 312.934, "max_us": 1016.096, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140226.454, "min_us": 139649.314, "max_us": 148761.684, "rows": 166666, "peak_rss_kb": 5212} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140285.307, "min_us": 139672.604, "max_us": 141760.312, "rows": 166666, "peak_rss_kb": 5224} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2566, "median_us": 378.873, "min_us": 371.13, "max_us": 3861.368, "rows": 10, "peak_rss_kb": 3824} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2590, "median_us": 379.548, "min_us": 374.597, "max_us": 1196.741, "rows": 10, "peak_rss_kb": 3816} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 268390.293, "min_us": 267574.314, "max_us": 274145.129, "rows": 10, "peak_rss_kb": 5048} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270990.244, "min_us": 269875.117, "max_us": 271632.132, "rows": 10, "peak_rss_kb": 4960} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270800.031, "min_us": 269050.277, "max_us": 273494.62, "rows": 10, "peak_rss_kb": 4876} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 272131.942, "min_us": 271536.918, "max_us": 321013.234, "rows": 10, "peak_rss_kb": 5008} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2090, "median_us": 470.453, "min_us": 455.543, "max_us": 1508.618, "rows": 10, "peak_rss_kb": 3768} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2144, "median_us": 455.904, "min_us": 444.364, "max_us": 3792.0, "rows": 10, "peak_rss_kb": 3724} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2157, "median_us": 456.232, "min_us": 449.032, "max_us": 1478.141, "rows": 10, "peak_rss_kb": 3696} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2239, "median_us": 438.855, "min_us": 421.052, "max_us": 1435.929, "rows": 10, "peak_rss_kb": 3720} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8073, "median_us": 118.415, "min_us": 114.54, "max_us": 1487.69, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8253, "median_us": 118.039, "min_us": 114.392, "max_us": 400.042, "rows": 1, "peak_rss_kb": 3744} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.01, "min_us": 18.433, "max_us": 88.541, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.218, "min_us": 18.643, "max_us": 87.006, "rows": 1, "peak_rss_kb": 3748} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.046, "min_us": 17.269, "max_us": 105.824, "rows": 1, "peak_rss_kb": 3816} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.856, "min_us": 17.2, "max_us": 92.934, "rows": 1, "peak_rss_kb": 3800} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3032, "median_us": 320.783, "min_us": 315.461, "max_us": 3693.305, "rows": 1, "peak_rss_kb": 3736} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3007, "median_us": 327.194, "min_us": 321.804, "max_us": 1024.934, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1410867.418, "min_us": 1406756.731, "max_us": 1420776.287, "rows": 1666666, "peak_rss_kb": 5468} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1448103.761, "min_us": 1434579.827, "max_us": 1464827.24, "rows": 1666666, "peak_rss_kb": 5460} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2685, "median_us": 367.263, "min_us": 348.539, "max_us": 1163.37, "rows": 10, "peak_rss_kb": 3796} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2678, "median_us": 367.897, "min_us": 342.831, "max_us": 1174.908, "rows": 10, "peak_rss_kb": 3812} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2786332.978, "min_us": 2775469.923, "max_us": 2838578.449, "rows": 10, "peak_rss_kb": 5128} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2848623.403, "min_us": 2837540.395, "max_us": 2895117.21, "rows": 10, "peak_rss_kb": 5092} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2809008.795, "min_us": 2779523.13, "max_us": 2839506.212, "rows": 10, "peak_rss_kb": 4984} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2853040.363, "min_us": 2812697.312, "max_us": 2862654.299, "rows": 10, "peak_rss_kb": 5088} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2153, "median_us": 454.798, "min_us": 437.644, "max_us": 3293.866, "rows": 10, "peak_rss_kb": 3760} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2147, "median_us": 459.136, "min_us": 445.061, "max_us": 1425.14, "rows": 10, "peak_rss_kb": 3812} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2175, "median_us": 451.902, "min_us": 443.86, "max_us": 1430.179, "rows": 10, "peak_rss_kb": 3704} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2162, "median_us": 453.427, "min_us": 438.89, "max_us": 3793.047, "rows": 10, "peak_rss_kb": 3772} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7491, "median_us": 130.182, "min_us": 128.493, "max_us": 424.278, "rows": 1, "peak_rss_kb": 3704} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7480, "median_us": 130.226, "min_us": 128.824, "max_us": 423.562, "rows": 1, "peak_rss_kb": 3720} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.041, "min_us": 18.571, "max_us": 94.016, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.263, "min_us": 18.699, "max_us": 659.766, "rows": 1, "peak_rss_kb": 3704} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.012, "min_us": 18.58, "max_us": 80.288, "rows": 1, "peak_rss_kb": 3880} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.002, "min_us": 18.571, "max_us": 102.383, "rows": 1, "peak_rss_kb": 3860} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3030, "median_us": 323.655, "min_us": 319.978, "max_us": 1031.315, "rows": 1, "peak_rss_kb": 3720} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3015, "median_us": 323.689, "min_us": 315.644, "max_us": 2801.798, "rows": 1, "peak_rss_kb": 3692} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13466.541, "min_us": 13257.574, "max_us": 15123.691, "rows": 16666, "peak_rss_kb": 4916} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13495.217, "min_us": 13445.452, "max_us": 13802.163, "rows": 16666, "peak_rss_kb": 4852} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2831, "median_us": 345.324, "min_us": 335.194, "max_us": 2588.36, "rows": 10, "peak_rss_kb": 3872} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2789, "median_us": 347.264, "min_us": 334.842, "max_us": 1186.814, "rows": 10, "peak_rss_kb": 3856} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25736.973, "min_us": 25495.764, "max_us": 26084.387, "rows": 10, "peak_rss_kb": 4792} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25520.725, "min_us": 25290.987, "max_us": 34419.741, "rows": 10, "peak_rss_kb": 4820} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25724.157, "min_us": 25502.326, "max_us": 27267.553, "rows": 10, "peak_rss_kb": 4836} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 40, "median_us": 25540.023, "min_us": 25324.833, "max_us": 25767.776, "rows": 10, "peak_rss_kb": 4836} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2225, "median_us": 438.581, "min_us": 424.561, "max_us": 3387.056, "rows": 10, "peak_rss_kb": 3688} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2246, "median_us": 437.944, "min_us": 424.177, "max_us": 1420.918, "rows": 10, "peak_rss_kb": 3760} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2191, "median_us": 448.593, "min_us": 441.226, "max_us": 1485.345, "rows": 10, "peak_rss_kb": 3752} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2151, "median_us": 453.267, "min_us": 445.465, "max_us": 3310.517, "rows": 10, "peak_rss_kb": 3676} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8603, "median_us": 112.535, "min_us": 111.43, "max_us": 376.914, "rows": 1, "peak_rss_kb": 3760} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8399, "median_us": 112.401, "min_us": 111.209, "max_us": 383.626, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 20.007, "min_us": 18.36, "max_us": 742.992, "rows": 1, "peak_rss_kb": 3812} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.777, "min_us": 18.321, "max_us": 89.501, "rows": 1, "peak_rss_kb": 3852} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.315, "min_us": 17.335, "max_us": 118.954, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.205, "min_us": 17.165, "max_us": 90.438, "rows": 1, "peak_rss_kb": 3816} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2880, "median_us": 322.642, "min_us": 313.996, "max_us": 1081.101, "rows": 1, "peak_rss_kb": 3700} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3031, "median_us": 321.692, "min_us": 314.287, "max_us": 2410.446, "rows": 1, "peak_rss_kb": 3684} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 7, "median_us": 149137.897, "min_us": 147131.708, "max_us": 151017.098, "rows": 166666, "peak_rss_kb": 5316} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140102.224, "min_us": 138714.286, "max_us": 150563.911, "rows": 166666, "peak_rss_kb": 5352} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2550, "median_us": 361.944, "min_us": 344.667, "max_us": 1227.27, "rows": 10, "peak_rss_kb": 3860} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2613, "median_us": 374.861, "min_us": 371.113, "max_us": 1208.151, "rows": 10, "peak_rss_kb": 3828} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 283912.217, "min_us": 282055.154, "max_us": 287220.787, "rows": 10, "peak_rss_kb": 5108} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 269614.901, "min_us": 267474.521, "max_us": 275233.704, "rows": 10, "peak_rss_kb": 4988} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 289755.162, "min_us": 285151.179, "max_us": 295583.704, "rows": 10, "peak_rss_kb": 4972} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 271070.916, "min_us": 267553.883, "max_us": 272157.463, "rows": 10, "peak_rss_kb": 5012} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2076, "median_us": 455.135, "min_us": 446.502, "max_us": 3831.989, "rows": 10, "peak_rss_kb": 3724} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2156, "median_us": 455.596, "min_us": 446.656, "max_us": 1455.79, "rows": 10, "peak_rss_kb": 3788} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2107, "median_us": 440.254, "min_us": 421.353, "max_us": 1444.303, "rows": 10, "peak_rss_kb": 3744} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2045, "median_us": 457.467, "min_us": 448.202, "max_us": 25350.181, "rows": 10, "peak_rss_kb": 3688} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 7807, "median_us": 117.713, "min_us": 114.277, "max_us": 385.908, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8319, "median_us": 117.724, "min_us": 113.921, "max_us": 436.964, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.34, "min_us": 18.578, "max_us": 98.264, "rows": 1, "peak_rss_kb": 3888} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.094, "min_us": 18.43, "max_us": 752.757, "rows": 1, "peak_rss_kb": 3716} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 18.025, "min_us": 17.319, "max_us": 106.419, "rows": 1, "peak_rss_kb": 3888} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.835, "min_us": 16.928, "max_us": 101.069, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2870, "median_us": 323.721, "min_us": 315.858, "max_us": 1051.449, "rows": 1, "peak_rss_kb": 3620} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 2992, "median_us": 325.235, "min_us": 316.399, "max_us": 3059.691, "rows": 1, "peak_rss_kb": 3728} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1501085.631, "min_us": 1490174.312, "max_us": 1505719.323, "rows": 1666666, "peak_rss_kb": 5352} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1456090.849, "min_us": 1447828.721, "max_us": 1507512.054, "rows": 1666666, "peak_rss_kb": 5392} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2522, "median_us": 365.62, "min_us": 349.076, "max_us": 3128.769, "rows": 10, "peak_rss_kb": 3868} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2677, "median_us": 368.777, "min_us": 349.087, "max_us": 1174.894, "rows": 10, "peak_rss_kb": 3776} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 3021701.584, "min_us": 2975586.943, "max_us": 3039849.857, "rows": 10, "peak_rss_kb": 5028} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2808192.015, "min_us": 2782963.541, "max_us": 2866080.534, "rows": 10, "peak_rss_kb": 4940} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 3050132.423, "min_us": 3003858.343, "max_us": 3075873.62, "rows": 10, "peak_rss_kb": 5000} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2847363.1, "min_us": 2796898.889, "max_us": 2857195.412, "rows": 10, "peak_rss_kb": 5084} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2137, "median_us": 461.155, "min_us": 448.74, "max_us": 1455.003, "rows": 10, "peak_rss_kb": 3760} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2144, "median_us": 454.667, "min_us": 443.025, "max_us": 4036.592, "rows": 10, "peak_rss_kb": 3756} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2148, "median_us": 458.461, "min_us": 447.519, "max_us": 1455.642, "rows": 10, "peak_rss_kb": 3696} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2178, "median_us": 452.093, "min_us": 444.726, "max_us": 1435.732, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7426, "median_us": 129.831, "min_us": 128.33, "max_us": 3302.212, "rows": 1, "peak_rss_kb": 3768} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "ordered_point", "query": "[:find ?a :where [:p8333 :age ?a] :order-by [?a] :limit 1]", "runs": 7567, "median_us": 130.129, "min_us": 128.945, "max_us": 273.244, "rows": 1, "peak_rss_kb": 3716} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.418, "min_us": 18.858, "max_us": 109.81, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "point_entity", "query": "[:find ?a :where [:p8333 :age ?a]]", "runs": 20000, "median_us": 19.087, "min_us": 18.407, "max_us": 79.159, "rows": 1, "peak_rss_kb": 3840} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 18.933, "min_us": 18.522, "max_us": 97.167, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p8333\"]]", "runs": 20000, "median_us": 19.449, "min_us": 18.831, "max_us": 842.193, "rows": 1, "peak_rss_kb": 3796} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3038, "median_us": 323.321, "min_us": 319.727, "max_us": 1016.115, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3061, "median_us": 322.992, "min_us": 315.56, "max_us": 1010.011, "rows": 1, "peak_rss_kb": 3664} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 74, "median_us": 13476.341, "min_us": 13278.473, "max_us": 20440.349, "rows": 16666, "peak_rss_kb": 4964} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 75, "median_us": 13280.595, "min_us": 13225.098, "max_us": 13850.633, "rows": 16666, "peak_rss_kb": 4976} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2717, "median_us": 363.107, "min_us": 347.469, "max_us": 1167.511, "rows": 10, "peak_rss_kb": 3872} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2693, "median_us": 360.945, "min_us": 352.516, "max_us": 2562.716, "rows": 10, "peak_rss_kb": 3772} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25611.442, "min_us": 25373.373, "max_us": 26071.278, "rows": 10, "peak_rss_kb": 4852} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 39, "median_us": 25607.207, "min_us": 25385.004, "max_us": 26705.266, "rows": 10, "peak_rss_kb": 4804} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25489.651, "min_us": 25261.911, "max_us": 32258.437, "rows": 10, "peak_rss_kb": 4776} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 39, "median_us": 25774.03, "min_us": 25607.676, "max_us": 26005.65, "rows": 10, "peak_rss_kb": 4748} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2211, "median_us": 450.575, "min_us": 427.715, "max_us": 1445.271, "rows": 10, "peak_rss_kb": 3716} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2199, "median_us": 447.54, "min_us": 425.312, "max_us": 3746.65, "rows": 10, "peak_rss_kb": 3832} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2132, "median_us": 449.915, "min_us": 442.712, "max_us": 1442.14, "rows": 10, "peak_rss_kb": 3760} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2178, "median_us": 452.019, "min_us": 443.636, "max_us": 1435.813, "rows": 10, "peak_rss_kb": 3760} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8600, "median_us": 112.354, "min_us": 111.117, "max_us": 1275.859, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "ordered_point", "query": "[:find ?a :where [:p83333 :age ?a] :order-by [?a] :limit 1]", "runs": 8678, "median_us": 112.313, "min_us": 111.327, "max_us": 401.0, "rows": 1, "peak_rss_kb": 3816} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 18.846, "min_us": 18.399, "max_us": 77.331, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "point_entity", "query": "[:find ?a :where [:p83333 :age ?a]]", "runs": 20000, "median_us": 19.183, "min_us": 18.645, "max_us": 84.371, "rows": 1, "peak_rss_kb": 3832} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 18.017, "min_us": 16.822, "max_us": 75.841, "rows": 1, "peak_rss_kb": 3812} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p83333\"]]", "runs": 20000, "median_us": 17.781, "min_us": 16.77, "max_us": 19809.952, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3049, "median_us": 322.375, "min_us": 318.263, "max_us": 1024.601, "rows": 1, "peak_rss_kb": 3744} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3081, "median_us": 320.396, "min_us": 312.988, "max_us": 1015.874, "rows": 1, "peak_rss_kb": 3708} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 140170.845, "min_us": 139743.742, "max_us": 147611.319, "rows": 166666, "peak_rss_kb": 5284} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 8, "median_us": 138865.187, "min_us": 138649.052, "max_us": 139852.681, "rows": 166666, "peak_rss_kb": 5348} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2686, "median_us": 359.288, "min_us": 344.568, "max_us": 3048.644, "rows": 10, "peak_rss_kb": 3852} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2711, "median_us": 359.42, "min_us": 343.967, "max_us": 1223.58, "rows": 10, "peak_rss_kb": 3684} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 270617.017, "min_us": 268403.101, "max_us": 278233.839, "rows": 10, "peak_rss_kb": 5016} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 272230.758, "min_us": 269371.394, "max_us": 273327.234, "rows": 10, "peak_rss_kb": 5072} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 269495.564, "min_us": 264219.921, "max_us": 272200.505, "rows": 10, "peak_rss_kb": 5056} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 270732.614, "min_us": 268246.659, "max_us": 280493.894, "rows": 10, "peak_rss_kb": 5108} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2147, "median_us": 458.153, "min_us": 450.542, "max_us": 1446.471, "rows": 10, "peak_rss_kb": 3736} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_limit", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 2143, "median_us": 453.42, "min_us": 444.209, "max_us": 3957.468, "rows": 10, "peak_rss_kb": 3808} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2240, "median_us": 444.622, "min_us": 416.912, "max_us": 1413.41, "rows": 10, "peak_rss_kb": 3728} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_offset", "query": "[:find ?a :where [?e :age ?a] :order-by [?a] :offset 13 :limit 10]", "runs": 2235, "median_us": 446.321, "min_us": 420.598, "max_us": 1404.753, "rows": 10, "peak_rss_kb": 3772} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8145, "median_us": 117.89, "min_us": 114.274, "max_us": 1551.498, "rows": 1, "peak_rss_kb": 3744} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "ordered_point", "query": "[:find ?a :where [:p833333 :age ?a] :order-by [?a] :limit 1]", "runs": 8283, "median_us": 117.496, "min_us": 113.839, "max_us": 384.124, "rows": 1, "peak_rss_kb": 3728} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.235, "min_us": 18.652, "max_us": 80.481, "rows": 1, "peak_rss_kb": 3860} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "point_entity", "query": "[:find ?a :where [:p833333 :age ?a]]", "runs": 20000, "median_us": 19.199, "min_us": 18.562, "max_us": 83.869, "rows": 1, "peak_rss_kb": 3820} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.973, "min_us": 17.151, "max_us": 80.09, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_value", "query": "[:find ?e :where [?e :name \"p833333\"]]", "runs": 20000, "median_us": 17.97, "min_us": 17.136, "max_us": 73.217, "rows": 1, "peak_rss_kb": 3744} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3037, "median_us": 320.714, "min_us": 316.055, "max_us": 3069.994, "rows": 1, "peak_rss_kb": 3704} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "hot_current", "query": "[:find ?v :where [:hot :counter ?v]]", "runs": 3046, "median_us": 323.613, "min_us": 315.522, "max_us": 1018.875, "rows": 1, "peak_rss_kb": 3680} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1425728.258, "min_us": 1403612.716, "max_us": 1433911.364, "rows": 1666666, "peak_rss_kb": 5288} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "attribute_scan", "query": "[:find ?e ?a :where [?e :age ?a]]", "runs": 5, "median_us": 1461410.034, "min_us": 1449266.519, "max_us": 1462777.932, "rows": 1666666, "peak_rss_kb": 5352} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2683, "median_us": 366.904, "min_us": 354.319, "max_us": 1155.377, "rows": 10, "peak_rss_kb": 3832} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "limit", "query": "[:find ?e ?a :where [?e :age ?a] :limit 10]", "runs": 2679, "median_us": 367.767, "min_us": 350.335, "max_us": 1159.336, "rows": 10, "peak_rss_kb": 3712} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2797534.117, "min_us": 2780345.632, "max_us": 2803571.563, "rows": 10, "peak_rss_kb": 4964} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "uuid_ties", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a] :limit 10]", "runs": 5, "median_us": 2853048.929, "min_us": 2835351.305, "max_us": 2880810.654, "rows": 10, "peak_rss_kb": 5012} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2802850.814, "min_us": 2791209.26, "max_us": 2814390.355, "rows": 10, "peak_rss_kb": 5008} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "top_k", "query": "[:find ?e ?a :where [?e :age ?a] :order-by [?a :desc] :limit 10]", "runs": 5, "median_us": 2851066.164, "min_us": 2843808.032, "max_us": 2882807.378, "rows": 10, "peak_rss_kb": 5044} diff --git a/docs/benchmarks/641-partition-windows-history.jsonl b/docs/benchmarks/641-partition-windows-history.jsonl new file mode 100644 index 0000000000..e58b2bea63 --- /dev/null +++ b/docs/benchmarks/641-partition-windows-history.jsonl @@ -0,0 +1,144 @@ +{"round": 1, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.772, "min_us": 16.424, "max_us": 757.13, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.976, "min_us": 16.61, "max_us": 70.407, "rows": 1, "peak_rss_kb": 3852} +{"round": 1, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.175, "min_us": 16.782, "max_us": 73.174, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.542, "min_us": 17.144, "max_us": 91.681, "rows": 1, "peak_rss_kb": 3840} +{"round": 1, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.459, "min_us": 16.922, "max_us": 51.997, "rows": 1, "peak_rss_kb": 3872} +{"round": 1, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.303, "min_us": 16.804, "max_us": 73.455, "rows": 1, "peak_rss_kb": 3744} +{"round": 1, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.186, "min_us": 17.653, "max_us": 77.504, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.03, "min_us": 17.559, "max_us": 75.857, "rows": 1, "peak_rss_kb": 3804} +{"round": 1, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6388, "median_us": 151.53, "min_us": 150.093, "max_us": 1757.311, "rows": 1, "peak_rss_kb": 3680} +{"round": 1, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6399, "median_us": 152.883, "min_us": 150.02, "max_us": 491.98, "rows": 1, "peak_rss_kb": 3708} +{"round": 1, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.95, "min_us": 22.538, "max_us": 106.773, "rows": 1, "peak_rss_kb": 3840} +{"round": 1, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.467, "min_us": 22.042, "max_us": 89.148, "rows": 1, "peak_rss_kb": 3828} +{"round": 1, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6362, "median_us": 152.359, "min_us": 150.091, "max_us": 1801.757, "rows": 1, "peak_rss_kb": 3772} +{"round": 1, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6377, "median_us": 153.357, "min_us": 149.86, "max_us": 497.013, "rows": 1, "peak_rss_kb": 3744} +{"round": 1, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6846, "median_us": 142.806, "min_us": 141.794, "max_us": 478.145, "rows": 1, "peak_rss_kb": 3732} +{"round": 1, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6936, "median_us": 140.007, "min_us": 139.084, "max_us": 2978.056, "rows": 1, "peak_rss_kb": 3708} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1629, "median_us": 603.381, "min_us": 588.718, "max_us": 1877.688, "rows": 1, "peak_rss_kb": 3684} +{"round": 1, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1632, "median_us": 604.732, "min_us": 589.909, "max_us": 1885.81, "rows": 1, "peak_rss_kb": 3748} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.858, "min_us": 22.267, "max_us": 725.653, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.032, "min_us": 22.447, "max_us": 94.026, "rows": 1, "peak_rss_kb": 3864} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1628, "median_us": 602.132, "min_us": 583.335, "max_us": 1870.154, "rows": 1, "peak_rss_kb": 3764} +{"round": 1, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1643, "median_us": 600.755, "min_us": 593.286, "max_us": 1872.81, "rows": 1, "peak_rss_kb": 3748} +{"round": 1, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1729, "median_us": 553.188, "min_us": 544.415, "max_us": 5351.554, "rows": 1, "peak_rss_kb": 3776} +{"round": 1, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1767, "median_us": 558.145, "min_us": 547.11, "max_us": 1735.696, "rows": 1, "peak_rss_kb": 3708} +{"round": 2, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.679, "min_us": 16.321, "max_us": 75.473, "rows": 1, "peak_rss_kb": 3828} +{"round": 2, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.061, "min_us": 16.636, "max_us": 78.197, "rows": 1, "peak_rss_kb": 3816} +{"round": 2, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.275, "min_us": 16.725, "max_us": 774.676, "rows": 1, "peak_rss_kb": 3756} +{"round": 2, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.193, "min_us": 16.845, "max_us": 76.62, "rows": 1, "peak_rss_kb": 3780} +{"round": 2, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.348, "min_us": 16.834, "max_us": 87.565, "rows": 1, "peak_rss_kb": 3760} +{"round": 2, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.642, "min_us": 17.184, "max_us": 94.033, "rows": 1, "peak_rss_kb": 3796} +{"round": 2, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.107, "min_us": 17.602, "max_us": 84.495, "rows": 1, "peak_rss_kb": 3752} +{"round": 2, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.251, "min_us": 17.764, "max_us": 91.615, "rows": 1, "peak_rss_kb": 3824} +{"round": 2, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6315, "median_us": 152.873, "min_us": 151.286, "max_us": 492.956, "rows": 1, "peak_rss_kb": 3660} +{"round": 2, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6340, "median_us": 152.229, "min_us": 149.868, "max_us": 1868.803, "rows": 1, "peak_rss_kb": 3716} +{"round": 2, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.473, "min_us": 22.088, "max_us": 112.741, "rows": 1, "peak_rss_kb": 3812} +{"round": 2, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.154, "min_us": 22.501, "max_us": 105.436, "rows": 1, "peak_rss_kb": 3832} +{"round": 2, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6415, "median_us": 152.694, "min_us": 149.515, "max_us": 499.675, "rows": 1, "peak_rss_kb": 3752} +{"round": 2, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6429, "median_us": 151.116, "min_us": 149.619, "max_us": 1581.442, "rows": 1, "peak_rss_kb": 3720} +{"round": 2, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6857, "median_us": 141.601, "min_us": 139.448, "max_us": 451.386, "rows": 1, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6913, "median_us": 141.444, "min_us": 140.592, "max_us": 456.41, "rows": 1, "peak_rss_kb": 3672} +{"round": 2, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1639, "median_us": 594.98, "min_us": 586.389, "max_us": 4484.684, "rows": 1, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1617, "median_us": 604.607, "min_us": 588.31, "max_us": 1876.031, "rows": 1, "peak_rss_kb": 3736} +{"round": 2, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.842, "min_us": 22.263, "max_us": 121.768, "rows": 1, "peak_rss_kb": 3844} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.198, "min_us": 22.625, "max_us": 54.24, "rows": 1, "peak_rss_kb": 3792} +{"round": 2, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1642, "median_us": 591.619, "min_us": 584.004, "max_us": 4959.463, "rows": 1, "peak_rss_kb": 3636} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1644, "median_us": 601.207, "min_us": 584.69, "max_us": 1888.521, "rows": 1, "peak_rss_kb": 3724} +{"round": 2, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1755, "median_us": 559.398, "min_us": 549.67, "max_us": 1752.475, "rows": 1, "peak_rss_kb": 3740} +{"round": 2, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1773, "median_us": 552.866, "min_us": 544.315, "max_us": 3438.877, "rows": 1, "peak_rss_kb": 3720} +{"round": 3, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.04, "min_us": 16.627, "max_us": 89.739, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.198, "min_us": 16.685, "max_us": 80.766, "rows": 1, "peak_rss_kb": 3796} +{"round": 3, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.7, "min_us": 17.261, "max_us": 85.741, "rows": 1, "peak_rss_kb": 3764} +{"round": 3, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.173, "min_us": 16.837, "max_us": 72.867, "rows": 1, "peak_rss_kb": 3804} +{"round": 3, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.725, "min_us": 17.057, "max_us": 68.753, "rows": 1, "peak_rss_kb": 3812} +{"round": 3, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.448, "min_us": 16.878, "max_us": 40072.015, "rows": 1, "peak_rss_kb": 3820} +{"round": 3, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.559, "min_us": 18.102, "max_us": 88.805, "rows": 1, "peak_rss_kb": 3792} +{"round": 3, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.071, "min_us": 17.537, "max_us": 81.882, "rows": 1, "peak_rss_kb": 3776} +{"round": 3, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6403, "median_us": 152.84, "min_us": 150.149, "max_us": 496.003, "rows": 1, "peak_rss_kb": 3716} +{"round": 3, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6439, "median_us": 152.879, "min_us": 151.485, "max_us": 507.907, "rows": 1, "peak_rss_kb": 3660} +{"round": 3, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.001, "min_us": 22.635, "max_us": 742.606, "rows": 1, "peak_rss_kb": 3840} +{"round": 3, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.536, "min_us": 22.091, "max_us": 96.686, "rows": 1, "peak_rss_kb": 3864} +{"round": 3, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6416, "median_us": 152.652, "min_us": 149.342, "max_us": 518.613, "rows": 1, "peak_rss_kb": 3732} +{"round": 3, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6368, "median_us": 153.937, "min_us": 152.171, "max_us": 517.14, "rows": 1, "peak_rss_kb": 3588} +{"round": 3, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6944, "median_us": 140.347, "min_us": 139.446, "max_us": 1308.63, "rows": 1, "peak_rss_kb": 3700} +{"round": 3, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6902, "median_us": 141.52, "min_us": 139.53, "max_us": 454.934, "rows": 1, "peak_rss_kb": 3756} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1629, "median_us": 603.103, "min_us": 594.85, "max_us": 1913.101, "rows": 1, "peak_rss_kb": 3672} +{"round": 3, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1634, "median_us": 598.105, "min_us": 586.776, "max_us": 4623.369, "rows": 1, "peak_rss_kb": 3736} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.094, "min_us": 22.537, "max_us": 111.495, "rows": 1, "peak_rss_kb": 3840} +{"round": 3, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.613, "min_us": 21.987, "max_us": 93.367, "rows": 1, "peak_rss_kb": 3864} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1652, "median_us": 597.331, "min_us": 582.717, "max_us": 1907.539, "rows": 1, "peak_rss_kb": 3608} +{"round": 3, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1624, "median_us": 600.866, "min_us": 583.602, "max_us": 5630.946, "rows": 1, "peak_rss_kb": 3740} +{"round": 3, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1768, "median_us": 556.914, "min_us": 546.104, "max_us": 1730.768, "rows": 1, "peak_rss_kb": 3736} +{"round": 3, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1736, "median_us": 566.431, "min_us": 550.277, "max_us": 1738.366, "rows": 1, "peak_rss_kb": 3748} +{"round": 4, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.32, "min_us": 16.893, "max_us": 645.423, "rows": 1, "peak_rss_kb": 3808} +{"round": 4, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.611, "min_us": 17.128, "max_us": 95.744, "rows": 1, "peak_rss_kb": 3872} +{"round": 4, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.11, "min_us": 16.717, "max_us": 76.459, "rows": 1, "peak_rss_kb": 3756} +{"round": 4, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.375, "min_us": 16.862, "max_us": 76.105, "rows": 1, "peak_rss_kb": 3772} +{"round": 4, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.767, "min_us": 17.162, "max_us": 77.017, "rows": 1, "peak_rss_kb": 3824} +{"round": 4, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 18.108, "min_us": 17.616, "max_us": 87.227, "rows": 1, "peak_rss_kb": 3824} +{"round": 4, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.077, "min_us": 17.634, "max_us": 130.599, "rows": 1, "peak_rss_kb": 3800} +{"round": 4, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.397, "min_us": 17.829, "max_us": 639.025, "rows": 1, "peak_rss_kb": 3804} +{"round": 4, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6320, "median_us": 154.709, "min_us": 153.09, "max_us": 530.654, "rows": 1, "peak_rss_kb": 3756} +{"round": 4, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6405, "median_us": 152.427, "min_us": 150.123, "max_us": 494.487, "rows": 1, "peak_rss_kb": 3700} +{"round": 4, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.03, "min_us": 22.612, "max_us": 98.013, "rows": 1, "peak_rss_kb": 3868} +{"round": 4, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.94, "min_us": 22.499, "max_us": 92.219, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6516, "median_us": 150.0, "min_us": 148.786, "max_us": 509.475, "rows": 1, "peak_rss_kb": 3584} +{"round": 4, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6352, "median_us": 154.239, "min_us": 150.781, "max_us": 503.649, "rows": 1, "peak_rss_kb": 3716} +{"round": 4, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6915, "median_us": 141.09, "min_us": 139.161, "max_us": 2372.509, "rows": 1, "peak_rss_kb": 3668} +{"round": 4, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6849, "median_us": 142.067, "min_us": 140.471, "max_us": 457.366, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1643, "median_us": 599.672, "min_us": 586.182, "max_us": 1888.905, "rows": 1, "peak_rss_kb": 3764} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1618, "median_us": 603.927, "min_us": 588.232, "max_us": 4646.159, "rows": 1, "peak_rss_kb": 3696} +{"round": 4, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.938, "min_us": 22.273, "max_us": 109.787, "rows": 1, "peak_rss_kb": 3820} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.82, "min_us": 22.216, "max_us": 96.77, "rows": 1, "peak_rss_kb": 3836} +{"round": 4, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1656, "median_us": 592.832, "min_us": 584.177, "max_us": 1873.008, "rows": 1, "peak_rss_kb": 3644} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1605, "median_us": 615.657, "min_us": 592.007, "max_us": 3949.668, "rows": 1, "peak_rss_kb": 3724} +{"round": 4, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1767, "median_us": 557.628, "min_us": 549.066, "max_us": 1800.01, "rows": 1, "peak_rss_kb": 3656} +{"round": 4, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1735, "median_us": 563.248, "min_us": 546.439, "max_us": 1735.977, "rows": 1, "peak_rss_kb": 3732} +{"round": 5, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.879, "min_us": 16.449, "max_us": 89.984, "rows": 1, "peak_rss_kb": 3792} +{"round": 5, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.023, "min_us": 16.668, "max_us": 60.836, "rows": 1, "peak_rss_kb": 3756} +{"round": 5, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.218, "min_us": 16.707, "max_us": 777.215, "rows": 1, "peak_rss_kb": 3868} +{"round": 5, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.308, "min_us": 16.875, "max_us": 42.397, "rows": 1, "peak_rss_kb": 3808} +{"round": 5, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.985, "min_us": 17.532, "max_us": 88.778, "rows": 1, "peak_rss_kb": 3784} +{"round": 5, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.841, "min_us": 17.288, "max_us": 86.866, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.025, "min_us": 17.446, "max_us": 107.684, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 18.049, "min_us": 17.485, "max_us": 76.035, "rows": 1, "peak_rss_kb": 3828} +{"round": 5, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6359, "median_us": 152.647, "min_us": 150.454, "max_us": 2325.614, "rows": 1, "peak_rss_kb": 3696} +{"round": 5, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6396, "median_us": 152.949, "min_us": 151.586, "max_us": 523.043, "rows": 1, "peak_rss_kb": 3656} +{"round": 5, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.266, "min_us": 22.832, "max_us": 112.423, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.551, "min_us": 22.155, "max_us": 77.825, "rows": 1, "peak_rss_kb": 3856} +{"round": 5, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6408, "median_us": 152.598, "min_us": 150.387, "max_us": 500.524, "rows": 1, "peak_rss_kb": 3708} +{"round": 5, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6389, "median_us": 152.564, "min_us": 150.158, "max_us": 4588.373, "rows": 1, "peak_rss_kb": 3752} +{"round": 5, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6830, "median_us": 143.03, "min_us": 140.788, "max_us": 463.317, "rows": 1, "peak_rss_kb": 3724} +{"round": 5, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6734, "median_us": 145.436, "min_us": 144.023, "max_us": 466.039, "rows": 1, "peak_rss_kb": 3688} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1640, "median_us": 598.159, "min_us": 587.332, "max_us": 1836.78, "rows": 1, "peak_rss_kb": 3672} +{"round": 5, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1634, "median_us": 600.193, "min_us": 585.932, "max_us": 1864.986, "rows": 1, "peak_rss_kb": 3756} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.217, "min_us": 22.644, "max_us": 98.614, "rows": 1, "peak_rss_kb": 3800} +{"round": 5, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.874, "min_us": 22.161, "max_us": 92.466, "rows": 1, "peak_rss_kb": 3768} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1667, "median_us": 592.248, "min_us": 583.906, "max_us": 1882.834, "rows": 1, "peak_rss_kb": 3764} +{"round": 5, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1654, "median_us": 595.829, "min_us": 583.734, "max_us": 1871.451, "rows": 1, "peak_rss_kb": 3728} +{"round": 5, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1738, "median_us": 555.159, "min_us": 545.237, "max_us": 45919.607, "rows": 1, "peak_rss_kb": 3732} +{"round": 5, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1747, "median_us": 561.741, "min_us": 550.03, "max_us": 1737.377, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "partitioned", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 16.893, "min_us": 16.518, "max_us": 77.728, "rows": 1, "peak_rss_kb": 3828} +{"round": 6, "variant": "parent", "depth": 1, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.195, "min_us": 16.827, "max_us": 77.018, "rows": 1, "peak_rss_kb": 3792} +{"round": 6, "variant": "partitioned", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.187, "min_us": 16.787, "max_us": 83.368, "rows": 1, "peak_rss_kb": 3848} +{"round": 6, "variant": "parent", "depth": 1, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 17.569, "min_us": 17.06, "max_us": 87.384, "rows": 1, "peak_rss_kb": 3792} +{"round": 6, "variant": "partitioned", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.45, "min_us": 17.001, "max_us": 87.241, "rows": 1, "peak_rss_kb": 3796} +{"round": 6, "variant": "parent", "depth": 1, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 20000, "median_us": 17.866, "min_us": 17.369, "max_us": 748.98, "rows": 1, "peak_rss_kb": 3824} +{"round": 6, "variant": "partitioned", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 17.726, "min_us": 17.242, "max_us": 81.597, "rows": 1, "peak_rss_kb": 3748} +{"round": 6, "variant": "parent", "depth": 1, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 20000, "median_us": 19.15, "min_us": 18.676, "max_us": 88.778, "rows": 1, "peak_rss_kb": 3828} +{"round": 6, "variant": "partitioned", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6448, "median_us": 151.717, "min_us": 149.683, "max_us": 491.543, "rows": 1, "peak_rss_kb": 3700} +{"round": 6, "variant": "parent", "depth": 500, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 6323, "median_us": 153.275, "min_us": 150.343, "max_us": 1318.702, "rows": 1, "peak_rss_kb": 3732} +{"round": 6, "variant": "partitioned", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 22.506, "min_us": 22.082, "max_us": 81.641, "rows": 1, "peak_rss_kb": 3812} +{"round": 6, "variant": "parent", "depth": 500, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.042, "min_us": 22.628, "max_us": 97.518, "rows": 1, "peak_rss_kb": 3832} +{"round": 6, "variant": "partitioned", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6381, "median_us": 153.138, "min_us": 150.151, "max_us": 506.084, "rows": 1, "peak_rss_kb": 3648} +{"round": 6, "variant": "parent", "depth": 500, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 6321, "median_us": 154.366, "min_us": 150.431, "max_us": 1862.816, "rows": 1, "peak_rss_kb": 3616} +{"round": 6, "variant": "partitioned", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6919, "median_us": 141.346, "min_us": 140.371, "max_us": 490.468, "rows": 1, "peak_rss_kb": 3740} +{"round": 6, "variant": "parent", "depth": 500, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 6927, "median_us": 141.228, "min_us": 139.471, "max_us": 466.0, "rows": 1, "peak_rss_kb": 3728} +{"round": 6, "variant": "partitioned", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1605, "median_us": 600.356, "min_us": 587.549, "max_us": 5533.342, "rows": 1, "peak_rss_kb": 3664} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "churned_attr", "query": "(query [:find ?v :where [:e/hot :hash ?v]])", "runs": 1599, "median_us": 612.124, "min_us": 595.624, "max_us": 1871.862, "rows": 1, "peak_rss_kb": 3732} +{"round": 6, "variant": "partitioned", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.034, "min_us": 22.33, "max_us": 98.119, "rows": 1, "peak_rss_kb": 3864} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "sibling_attr", "query": "(query [:find ?v :where [:e/hot :other ?v]])", "runs": 20000, "median_us": 23.254, "min_us": 22.658, "max_us": 96.348, "rows": 1, "peak_rss_kb": 3812} +{"round": 6, "variant": "partitioned", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1633, "median_us": 599.434, "min_us": 592.219, "max_us": 4193.94, "rows": 1, "peak_rss_kb": 3584} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "attr_scan", "query": "(query [:find ?v :where [?e :hash ?v]])", "runs": 1656, "median_us": 592.528, "min_us": 582.988, "max_us": 1863.532, "rows": 1, "peak_rss_kb": 3768} +{"round": 6, "variant": "partitioned", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1780, "median_us": 556.029, "min_us": 545.377, "max_us": 1154.545, "rows": 1, "peak_rss_kb": 3732} +{"round": 6, "variant": "parent", "depth": 2000, "workload": "churned_attr_as_of", "query": "(query [:find ?v :as-of 2002 :valid-at :any-valid-time :where [:e/hot :hash ?v]])", "runs": 1738, "median_us": 560.805, "min_us": 549.77, "max_us": 3518.997, "rows": 1, "peak_rss_kb": 3720} diff --git a/docs/benchmarks/641-partition-windows-meter.jsonl b/docs/benchmarks/641-partition-windows-meter.jsonl new file mode 100644 index 0000000000..572fc7e4c0 --- /dev/null +++ b/docs/benchmarks/641-partition-windows-meter.jsonl @@ -0,0 +1,18 @@ +{"facts": 100000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 100000, "max_partition_rows": 16, "mode": "value", "rows": 100000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 100000, "fixture_group_size": 16, "id_peak_bytes": 1280, "input_rows": 1024, "max_partition_rows": 16, "mode": "value_limit", "rows": 10, "total_peak_bytes": 53744, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 100000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 100000, "max_partition_rows": 1, "mode": "entity", "rows": 100000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 100000, "fixture_group_size": 16, "id_peak_bytes": 800, "input_rows": 1024, "max_partition_rows": 1, "mode": "entity_limit", "rows": 10, "total_peak_bytes": 49544, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 100000, "fixture_group_size": 100000, "id_peak_bytes": 81920, "input_rows": 100000, "max_partition_rows": 100000, "mode": "value", "rows": 100000, "total_peak_bytes": 20000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 20000032} +{"facts": 100000, "fixture_group_size": 100000, "id_peak_bytes": 81920, "input_rows": 100000, "max_partition_rows": 100000, "mode": "value_limit", "rows": 10, "total_peak_bytes": 20000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 20000032} +{"facts": 1000000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 1000000, "max_partition_rows": 16, "mode": "value", "rows": 1000000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 1000000, "fixture_group_size": 16, "id_peak_bytes": 1280, "input_rows": 1024, "max_partition_rows": 16, "mode": "value_limit", "rows": 10, "total_peak_bytes": 53744, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 1000000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 1000000, "max_partition_rows": 1, "mode": "entity", "rows": 1000000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 1000000, "fixture_group_size": 16, "id_peak_bytes": 800, "input_rows": 1024, "max_partition_rows": 1, "mode": "entity_limit", "rows": 10, "total_peak_bytes": 49544, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 1000000, "fixture_group_size": 1000000, "id_peak_bytes": 81920, "input_rows": 1000000, "max_partition_rows": 1000000, "mode": "value", "rows": 1000000, "total_peak_bytes": 200000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 200000032} +{"facts": 1000000, "fixture_group_size": 1000000, "id_peak_bytes": 81920, "input_rows": 1000000, "max_partition_rows": 1000000, "mode": "value_limit", "rows": 10, "total_peak_bytes": 200000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 200000032} +{"facts": 10000000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 10000000, "max_partition_rows": 16, "mode": "value", "rows": 10000000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 10000000, "fixture_group_size": 16, "id_peak_bytes": 1280, "input_rows": 1024, "max_partition_rows": 16, "mode": "value_limit", "rows": 10, "total_peak_bytes": 53744, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 52464} +{"facts": 10000000, "fixture_group_size": 16, "id_peak_bytes": 81920, "input_rows": 10000000, "max_partition_rows": 1, "mode": "entity", "rows": 10000000, "total_peak_bytes": 131152, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 10000000, "fixture_group_size": 16, "id_peak_bytes": 800, "input_rows": 1024, "max_partition_rows": 1, "mode": "entity_limit", "rows": 10, "total_peak_bytes": 49544, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 49464} +{"facts": 10000000, "fixture_group_size": 10000000, "id_peak_bytes": 81920, "input_rows": 10000000, "max_partition_rows": 10000000, "mode": "value", "rows": 10000000, "total_peak_bytes": 2000000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 2000000032} +{"facts": 10000000, "fixture_group_size": 10000000, "id_peak_bytes": 81920, "input_rows": 10000000, "max_partition_rows": 10000000, "mode": "value_limit", "rows": 10, "total_peak_bytes": 2000000032, "two_batch_allowance_bytes": 98464, "window_peak_bytes": 2000000032} diff --git a/docs/benchmarks/641-partition-windows-startup.jsonl b/docs/benchmarks/641-partition-windows-startup.jsonl new file mode 100644 index 0000000000..df47bc996f --- /dev/null +++ b/docs/benchmarks/641-partition-windows-startup.jsonl @@ -0,0 +1,72 @@ +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.726, "min_us": 22.86, "max_us": 94.679, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7185, "median_us": 137.156, "min_us": 133.039, "max_us": 344.311, "rows": 1, "peak_rss_kb": 3768} +{"round": 1, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.431, "min_us": 21.378, "max_us": 121.437, "rows": 1, "peak_rss_kb": 3792} +{"round": 1, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.476, "min_us": 22.729, "max_us": 127.377, "rows": 1, "peak_rss_kb": 3776} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.469, "min_us": 22.609, "max_us": 776.403, "rows": 1, "peak_rss_kb": 3796} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7984, "median_us": 121.783, "min_us": 118.882, "max_us": 392.696, "rows": 1, "peak_rss_kb": 3784} +{"round": 1, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.507, "min_us": 21.744, "max_us": 103.953, "rows": 1, "peak_rss_kb": 3848} +{"round": 1, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.865, "min_us": 22.011, "max_us": 74.55, "rows": 1, "peak_rss_kb": 3872} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.465, "min_us": 21.545, "max_us": 112.918, "rows": 1, "peak_rss_kb": 3832} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7828, "median_us": 124.193, "min_us": 121.748, "max_us": 1772.391, "rows": 1, "peak_rss_kb": 3636} +{"round": 1, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.638, "min_us": 21.532, "max_us": 129.708, "rows": 1, "peak_rss_kb": 3740} +{"round": 1, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.604, "min_us": 21.531, "max_us": 88.711, "rows": 1, "peak_rss_kb": 3716} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7136, "median_us": 136.418, "min_us": 132.553, "max_us": 1318.658, "rows": 1, "peak_rss_kb": 3760} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.14, "min_us": 22.075, "max_us": 105.417, "rows": 1, "peak_rss_kb": 3832} +{"round": 2, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.26, "min_us": 22.57, "max_us": 92.243, "rows": 1, "peak_rss_kb": 3868} +{"round": 2, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.421, "min_us": 21.322, "max_us": 111.144, "rows": 1, "peak_rss_kb": 3784} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 8000, "median_us": 122.057, "min_us": 119.508, "max_us": 422.719, "rows": 1, "peak_rss_kb": 3732} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.242, "min_us": 22.495, "max_us": 645.924, "rows": 1, "peak_rss_kb": 3828} +{"round": 2, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 24.683, "min_us": 22.801, "max_us": 103.87, "rows": 1, "peak_rss_kb": 3712} +{"round": 2, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.733, "min_us": 21.85, "max_us": 95.864, "rows": 1, "peak_rss_kb": 3820} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7661, "median_us": 129.5, "min_us": 122.318, "max_us": 414.717, "rows": 1, "peak_rss_kb": 3748} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.268, "min_us": 22.28, "max_us": 573.865, "rows": 1, "peak_rss_kb": 3744} +{"round": 2, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 24.902, "min_us": 22.915, "max_us": 97.267, "rows": 1, "peak_rss_kb": 3832} +{"round": 2, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.214, "min_us": 21.313, "max_us": 97.073, "rows": 1, "peak_rss_kb": 3828} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.642, "min_us": 21.727, "max_us": 95.988, "rows": 1, "peak_rss_kb": 3816} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7223, "median_us": 135.925, "min_us": 132.587, "max_us": 434.767, "rows": 1, "peak_rss_kb": 3760} +{"round": 3, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.51, "min_us": 21.419, "max_us": 862.52, "rows": 1, "peak_rss_kb": 3832} +{"round": 3, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 22.987, "min_us": 22.308, "max_us": 91.691, "rows": 1, "peak_rss_kb": 3764} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 22.824, "min_us": 22.068, "max_us": 91.301, "rows": 1, "peak_rss_kb": 3748} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 8038, "median_us": 121.621, "min_us": 118.522, "max_us": 403.901, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.636, "min_us": 21.671, "max_us": 94.558, "rows": 1, "peak_rss_kb": 3816} +{"round": 3, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.439, "min_us": 21.621, "max_us": 106.803, "rows": 1, "peak_rss_kb": 3720} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.535, "min_us": 21.57, "max_us": 92.594, "rows": 1, "peak_rss_kb": 3740} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7878, "median_us": 123.943, "min_us": 121.45, "max_us": 401.372, "rows": 1, "peak_rss_kb": 3768} +{"round": 3, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.309, "min_us": 21.253, "max_us": 107.04, "rows": 1, "peak_rss_kb": 3788} +{"round": 3, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.63, "min_us": 21.64, "max_us": 710.569, "rows": 1, "peak_rss_kb": 3872} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7058, "median_us": 136.879, "min_us": 133.082, "max_us": 447.487, "rows": 1, "peak_rss_kb": 3676} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.137, "min_us": 22.187, "max_us": 109.677, "rows": 1, "peak_rss_kb": 3844} +{"round": 4, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.661, "min_us": 22.937, "max_us": 112.463, "rows": 1, "peak_rss_kb": 3856} +{"round": 4, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.736, "min_us": 21.745, "max_us": 155.303, "rows": 1, "peak_rss_kb": 3816} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7981, "median_us": 120.969, "min_us": 118.279, "max_us": 1573.162, "rows": 1, "peak_rss_kb": 3752} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.798, "min_us": 23.088, "max_us": 97.542, "rows": 1, "peak_rss_kb": 3820} +{"round": 4, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.719, "min_us": 21.922, "max_us": 91.073, "rows": 1, "peak_rss_kb": 3852} +{"round": 4, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.995, "min_us": 22.074, "max_us": 94.187, "rows": 1, "peak_rss_kb": 3796} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7419, "median_us": 124.144, "min_us": 121.776, "max_us": 19947.375, "rows": 1, "peak_rss_kb": 3732} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.613, "min_us": 21.741, "max_us": 95.286, "rows": 1, "peak_rss_kb": 3828} +{"round": 4, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.836, "min_us": 21.975, "max_us": 128.58, "rows": 1, "peak_rss_kb": 3860} +{"round": 4, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.93, "min_us": 22.084, "max_us": 89.432, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.834, "min_us": 21.911, "max_us": 112.396, "rows": 1, "peak_rss_kb": 3884} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7180, "median_us": 136.298, "min_us": 132.801, "max_us": 1783.769, "rows": 1, "peak_rss_kb": 3724} +{"round": 5, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.333, "min_us": 22.183, "max_us": 113.6, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 22.873, "min_us": 22.115, "max_us": 90.024, "rows": 1, "peak_rss_kb": 3856} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.042, "min_us": 22.257, "max_us": 94.374, "rows": 1, "peak_rss_kb": 3788} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 8017, "median_us": 121.324, "min_us": 118.288, "max_us": 1336.304, "rows": 1, "peak_rss_kb": 3780} +{"round": 5, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.584, "min_us": 21.745, "max_us": 92.834, "rows": 1, "peak_rss_kb": 3788} +{"round": 5, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.358, "min_us": 21.386, "max_us": 93.83, "rows": 1, "peak_rss_kb": 3796} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.594, "min_us": 21.749, "max_us": 97.522, "rows": 1, "peak_rss_kb": 3836} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7826, "median_us": 124.09, "min_us": 121.329, "max_us": 1247.249, "rows": 1, "peak_rss_kb": 3768} +{"round": 5, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.727, "min_us": 21.916, "max_us": 94.467, "rows": 1, "peak_rss_kb": 3812} +{"round": 5, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 24.078, "min_us": 22.09, "max_us": 97.291, "rows": 1, "peak_rss_kb": 3832} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7176, "median_us": 136.381, "min_us": 132.637, "max_us": 451.636, "rows": 1, "peak_rss_kb": 3612} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 25.179, "min_us": 23.009, "max_us": 96.141, "rows": 1, "peak_rss_kb": 3744} +{"round": 6, "variant": "partitioned", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 22.827, "min_us": 22.068, "max_us": 738.28, "rows": 1, "peak_rss_kb": 3816} +{"round": 6, "variant": "parent", "scale": "100k", "facts": 100000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p8333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.323, "min_us": 21.232, "max_us": 93.288, "rows": 1, "peak_rss_kb": 3788} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 8083, "median_us": 120.842, "min_us": 118.315, "max_us": 309.913, "rows": 1, "peak_rss_kb": 3784} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.523, "min_us": 22.689, "max_us": 92.463, "rows": 1, "peak_rss_kb": 3784} +{"round": 6, "variant": "partitioned", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.819, "min_us": 21.93, "max_us": 797.308, "rows": 1, "peak_rss_kb": 3856} +{"round": 6, "variant": "parent", "scale": "1m", "facts": 1000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p83333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.442, "min_us": 21.655, "max_us": 98.858, "rows": 1, "peak_rss_kb": 3796} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 7856, "median_us": 124.026, "min_us": 121.588, "max_us": 419.04, "rows": 1, "peak_rss_kb": 3776} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "value_window_point", "query": "(query [:find ?a (row-number :over (:partition-by ?a :order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 24.671, "min_us": 22.828, "max_us": 106.766, "rows": 1, "peak_rss_kb": 3844} +{"round": 6, "variant": "partitioned", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "e006d76bc66ad53e9af9029051e20425105b21b213949cab036cb2e27d27452a", "runs": 20000, "median_us": 23.578, "min_us": 21.502, "max_us": 66.623, "rows": 1, "peak_rss_kb": 3868} +{"round": 6, "variant": "parent", "scale": "10m", "facts": 10000000, "workload": "unpartitioned_window_point", "query": "(query [:find ?a (row-number :over (:order-by ?a)) :where [:p833333 :age ?a]])", "probe_binary_sha256": "0dd9f4452ecdceb41e5bc7591b2695a39c03f34edf96c1ad8f1fd22b592b8aa0", "runs": 20000, "median_us": 23.927, "min_us": 22.077, "max_us": 681.912, "rows": 1, "peak_rss_kb": 3792} diff --git a/docs/benchmarks/641-partition-windows.jsonl b/docs/benchmarks/641-partition-windows.jsonl new file mode 100644 index 0000000000..9ec2bd18f2 --- /dev/null +++ b/docs/benchmarks/641-partition-windows.jsonl @@ -0,0 +1,252 @@ +{"facts": 100000, "group_size": 16, "max_us": 250625.351, "median_us": 242126.828, "min_us": 241137.469, "partition_size": 16, "peak_rss_kb": 41892, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 244728.278, "median_us": 243500.958, "min_us": 243460.378, "partition_size": 16, "peak_rss_kb": 5424, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 225731.16, "median_us": 214159.385, "min_us": 210863.003, "partition_size": 16, "peak_rss_kb": 42328, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 5959.672, "median_us": 2053.713, "min_us": 2028.001, "partition_size": 16, "peak_rss_kb": 3964, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 483, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 251019.298, "median_us": 247278.249, "min_us": 242149.295, "partition_size": 1, "peak_rss_kb": 42596, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 5, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 255770.538, "median_us": 255507.808, "min_us": 254461.946, "partition_size": 1, "peak_rss_kb": 5312, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 218744.417, "median_us": 217453.323, "min_us": 215853.795, "partition_size": 1, "peak_rss_kb": 44244, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 12303.364, "median_us": 2233.86, "min_us": 2208.431, "partition_size": 1, "peak_rss_kb": 3944, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 439, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 244227.171, "median_us": 243561.063, "min_us": 241331.72, "partition_size": 100000, "peak_rss_kb": 43232, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 5, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 279066.508, "median_us": 267216.491, "min_us": 265080.801, "partition_size": 100000, "peak_rss_kb": 34832, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 217378.005, "median_us": 216090.79, "min_us": 215546.507, "partition_size": 100000, "peak_rss_kb": 43136, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 214503.845, "median_us": 203443.571, "min_us": 203120.341, "partition_size": 100000, "peak_rss_kb": 34908, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 246139.401, "median_us": 244621.449, "min_us": 243621.118, "partition_size": 100000, "peak_rss_kb": 45028, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 304911.607, "median_us": 249060.549, "min_us": 246971.13, "partition_size": 100000, "peak_rss_kb": 42340, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 100000, "runs": 4, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2966500.052, "median_us": 2958774.21, "min_us": 2924603.807, "partition_size": 16, "peak_rss_kb": 449200, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2508114.525, "median_us": 2507141.124, "min_us": 2500400.044, "partition_size": 16, "peak_rss_kb": 5604, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2572070.734, "median_us": 2555130.626, "min_us": 2537259.14, "partition_size": 16, "peak_rss_kb": 437468, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 8347.947, "median_us": 2131.408, "min_us": 2100.028, "partition_size": 16, "peak_rss_kb": 3964, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 459, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2967590.83, "median_us": 2948655.587, "min_us": 2946431.298, "partition_size": 1, "peak_rss_kb": 457552, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2659901.0, "median_us": 2652541.034, "min_us": 2647644.915, "partition_size": 1, "peak_rss_kb": 5112, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2547372.801, "median_us": 2546677.561, "min_us": 2537787.519, "partition_size": 1, "peak_rss_kb": 436520, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6648.087, "median_us": 2141.926, "min_us": 2110.716, "partition_size": 1, "peak_rss_kb": 3836, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 459, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3024433.452, "median_us": 3001762.725, "min_us": 2997147.742, "partition_size": 1000000, "peak_rss_kb": 441996, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2968145.278, "median_us": 2956085.123, "min_us": 2954617.835, "partition_size": 1000000, "peak_rss_kb": 310260, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2589154.153, "median_us": 2573099.152, "min_us": 2569029.825, "partition_size": 1000000, "peak_rss_kb": 481036, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2202724.826, "median_us": 2189302.357, "min_us": 2142196.815, "partition_size": 1000000, "peak_rss_kb": 318952, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2986303.631, "median_us": 2968908.306, "min_us": 2961607.06, "partition_size": 1000000, "peak_rss_kb": 433300, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2997680.119, "median_us": 2987196.79, "min_us": 2980176.979, "partition_size": 1000000, "peak_rss_kb": 440584, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33593805.032, "median_us": 33578370.88, "min_us": 33544668.685, "partition_size": 16, "peak_rss_kb": 3715000, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 26004957.862, "median_us": 25968051.436, "min_us": 25929447.215, "partition_size": 16, "peak_rss_kb": 5460, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28474268.269, "median_us": 28428225.372, "min_us": 28394956.722, "partition_size": 16, "peak_rss_kb": 3714280, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6966.195, "median_us": 2206.493, "min_us": 2180.67, "partition_size": 16, "peak_rss_kb": 3956, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 447, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33246179.879, "median_us": 33238228.355, "min_us": 33176645.34, "partition_size": 1, "peak_rss_kb": 3715068, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27494849.952, "median_us": 27444868.12, "min_us": 27329161.1, "partition_size": 1, "peak_rss_kb": 5588, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28285724.91, "median_us": 28259382.019, "min_us": 28233663.106, "partition_size": 1, "peak_rss_kb": 3714284, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6855.765, "median_us": 2231.834, "min_us": 2190.856, "partition_size": 1, "peak_rss_kb": 3936, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 442, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33550342.812, "median_us": 33533874.958, "min_us": 33505012.759, "partition_size": 10000000, "peak_rss_kb": 3715520, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33275350.625, "median_us": 33261281.705, "min_us": 33242642.805, "partition_size": 10000000, "peak_rss_kb": 2897584, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28323941.811, "median_us": 28321995.86, "min_us": 28313268.06, "partition_size": 10000000, "peak_rss_kb": 3715664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23453244.044, "median_us": 23438404.701, "min_us": 23408278.316, "partition_size": 10000000, "peak_rss_kb": 2897296, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 0, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33253785.968, "median_us": 33228438.302, "min_us": 33200761.254, "partition_size": 10000000, "peak_rss_kb": 3714844, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 33427742.145, "median_us": 33417986.842, "min_us": 33416501.931, "partition_size": 10000000, "peak_rss_kb": 3715148, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 0, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 242970.244, "median_us": 242126.476, "min_us": 241995.342, "partition_size": 16, "peak_rss_kb": 5384, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 246702.376, "median_us": 244020.473, "min_us": 243622.782, "partition_size": 16, "peak_rss_kb": 43952, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6600.957, "median_us": 2074.559, "min_us": 2042.144, "partition_size": 16, "peak_rss_kb": 3988, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 473, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 220865.251, "median_us": 219188.972, "min_us": 218307.437, "partition_size": 16, "peak_rss_kb": 44232, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 309352.756, "median_us": 255988.93, "min_us": 255022.319, "partition_size": 1, "peak_rss_kb": 5268, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 250310.206, "median_us": 248019.841, "min_us": 247234.205, "partition_size": 1, "peak_rss_kb": 42268, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6477.958, "median_us": 2066.268, "min_us": 2031.596, "partition_size": 1, "peak_rss_kb": 3900, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 476, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 218397.952, "median_us": 214580.274, "min_us": 212505.635, "partition_size": 1, "peak_rss_kb": 42140, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 268605.569, "median_us": 266504.981, "min_us": 261851.599, "partition_size": 100000, "peak_rss_kb": 34340, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 254354.163, "median_us": 246875.743, "min_us": 243681.334, "partition_size": 100000, "peak_rss_kb": 42368, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 203422.091, "median_us": 201817.869, "min_us": 200857.296, "partition_size": 100000, "peak_rss_kb": 34912, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 224837.718, "median_us": 216618.986, "min_us": 213618.944, "partition_size": 100000, "peak_rss_kb": 43120, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 246228.583, "median_us": 245172.597, "min_us": 244636.273, "partition_size": 100000, "peak_rss_kb": 43016, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 251625.921, "median_us": 242828.235, "min_us": 242089.826, "partition_size": 100000, "peak_rss_kb": 42328, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2492790.474, "median_us": 2485513.083, "min_us": 2477078.93, "partition_size": 16, "peak_rss_kb": 5528, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3035644.702, "median_us": 2986736.07, "min_us": 2957103.29, "partition_size": 16, "peak_rss_kb": 433640, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6674.983, "median_us": 2129.09, "min_us": 2102.684, "partition_size": 16, "peak_rss_kb": 3984, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 463, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2551719.122, "median_us": 2532848.158, "min_us": 2527719.924, "partition_size": 16, "peak_rss_kb": 434312, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2679261.801, "median_us": 2621858.026, "min_us": 2621212.913, "partition_size": 1, "peak_rss_kb": 5380, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2991710.682, "median_us": 2954429.536, "min_us": 2954206.382, "partition_size": 1, "peak_rss_kb": 434236, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6768.986, "median_us": 2148.487, "min_us": 2106.218, "partition_size": 1, "peak_rss_kb": 3868, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 451, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2571168.618, "median_us": 2571109.92, "min_us": 2567350.723, "partition_size": 1, "peak_rss_kb": 430728, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2934553.943, "median_us": 2915643.889, "min_us": 2914410.002, "partition_size": 1000000, "peak_rss_kb": 310184, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3042647.659, "median_us": 3026357.32, "min_us": 2999212.45, "partition_size": 1000000, "peak_rss_kb": 432028, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2173973.247, "median_us": 2170347.406, "min_us": 2135785.296, "partition_size": 1000000, "peak_rss_kb": 319264, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2596930.748, "median_us": 2595859.473, "min_us": 2591390.879, "partition_size": 1000000, "peak_rss_kb": 481740, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2947043.111, "median_us": 2945526.803, "min_us": 2940682.067, "partition_size": 1000000, "peak_rss_kb": 432940, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3021889.621, "median_us": 2999929.381, "min_us": 2989132.652, "partition_size": 1000000, "peak_rss_kb": 439884, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 25915949.108, "median_us": 25865605.916, "min_us": 25816972.516, "partition_size": 16, "peak_rss_kb": 5564, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33693945.811, "median_us": 33620891.432, "min_us": 33619535.074, "partition_size": 16, "peak_rss_kb": 3715048, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 7803.897, "median_us": 2214.928, "min_us": 2182.753, "partition_size": 16, "peak_rss_kb": 4024, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 444, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28391845.691, "median_us": 28329611.043, "min_us": 28314238.164, "partition_size": 16, "peak_rss_kb": 3714988, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27519326.472, "median_us": 27448018.515, "min_us": 27432682.198, "partition_size": 1, "peak_rss_kb": 5516, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33521619.336, "median_us": 33487232.211, "min_us": 33479801.683, "partition_size": 1, "peak_rss_kb": 3714504, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 7385.36, "median_us": 2237.153, "min_us": 2198.601, "partition_size": 1, "peak_rss_kb": 3920, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 437, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28502436.538, "median_us": 28452129.073, "min_us": 28419229.931, "partition_size": 1, "peak_rss_kb": 3714288, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 32973440.835, "median_us": 32966947.377, "min_us": 32951185.099, "partition_size": 10000000, "peak_rss_kb": 2897984, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33939358.917, "median_us": 33914899.319, "min_us": 33852752.313, "partition_size": 10000000, "peak_rss_kb": 3715620, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23366942.639, "median_us": 23358129.61, "min_us": 23344601.476, "partition_size": 10000000, "peak_rss_kb": 2897076, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28700772.987, "median_us": 28699035.02, "min_us": 28684044.53, "partition_size": 10000000, "peak_rss_kb": 3715664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 1, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 33371952.387, "median_us": 33346660.305, "min_us": 33318660.577, "partition_size": 10000000, "peak_rss_kb": 3715180, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33412845.529, "median_us": 33367540.623, "min_us": 33339423.765, "partition_size": 10000000, "peak_rss_kb": 3714404, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 1, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 266325.817, "median_us": 264652.766, "min_us": 257044.305, "partition_size": 16, "peak_rss_kb": 41636, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 289228.782, "median_us": 243870.097, "min_us": 242634.689, "partition_size": 16, "peak_rss_kb": 5376, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 247076.935, "median_us": 234588.788, "min_us": 227302.858, "partition_size": 16, "peak_rss_kb": 42524, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6440.257, "median_us": 2063.495, "min_us": 2034.727, "partition_size": 16, "peak_rss_kb": 3996, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 478, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 262408.881, "median_us": 261213.569, "min_us": 253061.208, "partition_size": 1, "peak_rss_kb": 44272, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 255296.613, "median_us": 255048.837, "min_us": 253249.144, "partition_size": 1, "peak_rss_kb": 5320, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 239743.552, "median_us": 234679.776, "min_us": 231294.487, "partition_size": 1, "peak_rss_kb": 43228, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6456.763, "median_us": 2087.946, "min_us": 2062.584, "partition_size": 1, "peak_rss_kb": 3900, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 472, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 270546.885, "median_us": 269546.735, "min_us": 263555.701, "partition_size": 100000, "peak_rss_kb": 42868, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 265865.206, "median_us": 265648.523, "min_us": 263750.05, "partition_size": 100000, "peak_rss_kb": 34816, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 238986.442, "median_us": 235056.767, "min_us": 231313.205, "partition_size": 100000, "peak_rss_kb": 43528, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 205429.146, "median_us": 203862.016, "min_us": 202688.778, "partition_size": 100000, "peak_rss_kb": 34948, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 265887.885, "median_us": 265464.933, "min_us": 263628.179, "partition_size": 100000, "peak_rss_kb": 42252, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 4, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 253947.582, "median_us": 244236.386, "min_us": 242582.926, "partition_size": 100000, "peak_rss_kb": 43572, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3223186.083, "median_us": 3161925.917, "min_us": 3159436.132, "partition_size": 16, "peak_rss_kb": 451144, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2497778.163, "median_us": 2497308.39, "min_us": 2487275.22, "partition_size": 16, "peak_rss_kb": 5548, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2747205.881, "median_us": 2712358.35, "min_us": 2704931.89, "partition_size": 16, "peak_rss_kb": 466132, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6689.788, "median_us": 2131.22, "min_us": 2100.223, "partition_size": 16, "peak_rss_kb": 3908, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 463, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3200178.923, "median_us": 3155075.392, "min_us": 3126545.14, "partition_size": 1, "peak_rss_kb": 434320, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2650432.006, "median_us": 2642701.451, "min_us": 2630820.249, "partition_size": 1, "peak_rss_kb": 5472, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2581924.337, "median_us": 2542926.866, "min_us": 2535060.979, "partition_size": 1, "peak_rss_kb": 436532, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 9407.562, "median_us": 2142.962, "min_us": 2111.648, "partition_size": 1, "peak_rss_kb": 3792, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 456, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3029529.568, "median_us": 3001960.181, "min_us": 2995082.426, "partition_size": 1000000, "peak_rss_kb": 434252, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2977022.514, "median_us": 2950545.449, "min_us": 2938555.345, "partition_size": 1000000, "peak_rss_kb": 312364, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2567192.23, "median_us": 2567151.11, "min_us": 2555930.03, "partition_size": 1000000, "peak_rss_kb": 458508, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2224161.923, "median_us": 2190987.848, "min_us": 2172158.856, "partition_size": 1000000, "peak_rss_kb": 306120, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3000882.947, "median_us": 2962968.003, "min_us": 2954891.135, "partition_size": 1000000, "peak_rss_kb": 440448, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2982499.069, "median_us": 2981621.356, "min_us": 2979294.896, "partition_size": 1000000, "peak_rss_kb": 425196, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33355473.764, "median_us": 33237020.409, "min_us": 33224640.694, "partition_size": 16, "peak_rss_kb": 3714672, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 26101123.304, "median_us": 26029672.594, "min_us": 25977420.968, "partition_size": 16, "peak_rss_kb": 5588, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28447391.832, "median_us": 28397474.536, "min_us": 28347931.866, "partition_size": 16, "peak_rss_kb": 3714284, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6986.161, "median_us": 2209.543, "min_us": 2187.283, "partition_size": 16, "peak_rss_kb": 3980, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 446, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33713280.936, "median_us": 33590566.224, "min_us": 33557082.49, "partition_size": 1, "peak_rss_kb": 3714268, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27334069.869, "median_us": 27312924.871, "min_us": 27285135.465, "partition_size": 1, "peak_rss_kb": 5596, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28189287.271, "median_us": 28168447.936, "min_us": 28156567.557, "partition_size": 1, "peak_rss_kb": 3714280, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6909.492, "median_us": 2283.222, "min_us": 2190.73, "partition_size": 1, "peak_rss_kb": 3788, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 431, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33449842.784, "median_us": 33449630.925, "min_us": 33407112.165, "partition_size": 10000000, "peak_rss_kb": 3715620, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33234640.776, "median_us": 33233303.134, "min_us": 33197847.932, "partition_size": 10000000, "peak_rss_kb": 2897548, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28367933.762, "median_us": 28365518.23, "min_us": 28359004.34, "partition_size": 10000000, "peak_rss_kb": 3715664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23409229.373, "median_us": 23398593.229, "min_us": 23370091.557, "partition_size": 10000000, "peak_rss_kb": 2897152, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 2, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33250734.723, "median_us": 33241455.635, "min_us": 33191267.927, "partition_size": 10000000, "peak_rss_kb": 3715436, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 33601992.406, "median_us": 33598786.606, "min_us": 33505201.404, "partition_size": 10000000, "peak_rss_kb": 3715432, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 2, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 254061.73, "median_us": 242926.792, "min_us": 242555.811, "partition_size": 16, "peak_rss_kb": 5468, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 245511.473, "median_us": 244996.979, "min_us": 243777.551, "partition_size": 16, "peak_rss_kb": 41188, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 9272.991, "median_us": 2073.079, "min_us": 2041.973, "partition_size": 16, "peak_rss_kb": 3984, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 471, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 220483.19, "median_us": 217518.895, "min_us": 216524.641, "partition_size": 16, "peak_rss_kb": 42000, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 257686.172, "median_us": 256943.621, "min_us": 254521.469, "partition_size": 1, "peak_rss_kb": 5380, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 247121.199, "median_us": 246040.854, "min_us": 244376.281, "partition_size": 1, "peak_rss_kb": 42368, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6449.119, "median_us": 2079.591, "min_us": 2046.324, "partition_size": 1, "peak_rss_kb": 3932, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 470, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 267404.294, "median_us": 217268.488, "min_us": 214992.895, "partition_size": 1, "peak_rss_kb": 43008, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 267123.589, "median_us": 266603.021, "min_us": 265787.622, "partition_size": 100000, "peak_rss_kb": 34828, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 253393.99, "median_us": 248963.18, "min_us": 244866.592, "partition_size": 100000, "peak_rss_kb": 43976, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 203168.549, "median_us": 201489.933, "min_us": 201223.718, "partition_size": 100000, "peak_rss_kb": 34404, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 222560.101, "median_us": 218704.054, "min_us": 212447.273, "partition_size": 100000, "peak_rss_kb": 43968, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 248118.188, "median_us": 246731.158, "min_us": 244655.55, "partition_size": 100000, "peak_rss_kb": 41828, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 252635.492, "median_us": 244776.051, "min_us": 242479.51, "partition_size": 100000, "peak_rss_kb": 43296, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2499539.812, "median_us": 2497050.911, "min_us": 2489914.638, "partition_size": 16, "peak_rss_kb": 5408, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3047491.248, "median_us": 3009838.532, "min_us": 3007369.777, "partition_size": 16, "peak_rss_kb": 457312, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6082.457, "median_us": 2142.029, "min_us": 2101.7, "partition_size": 16, "peak_rss_kb": 3988, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 462, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2590216.475, "median_us": 2572215.126, "min_us": 2564726.71, "partition_size": 16, "peak_rss_kb": 426500, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2641969.136, "median_us": 2640735.262, "min_us": 2620587.001, "partition_size": 1, "peak_rss_kb": 5424, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3014536.829, "median_us": 3013708.993, "min_us": 2990374.747, "partition_size": 1, "peak_rss_kb": 434156, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 9193.115, "median_us": 2144.054, "min_us": 2095.721, "partition_size": 1, "peak_rss_kb": 3900, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 456, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2640809.359, "median_us": 2574606.81, "min_us": 2574286.583, "partition_size": 1, "peak_rss_kb": 427204, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2929517.578, "median_us": 2920194.366, "min_us": 2910990.341, "partition_size": 1000000, "peak_rss_kb": 311084, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3030958.046, "median_us": 2998344.874, "min_us": 2993791.976, "partition_size": 1000000, "peak_rss_kb": 428060, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2188577.477, "median_us": 2176953.818, "min_us": 2145752.154, "partition_size": 1000000, "peak_rss_kb": 319284, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2604996.604, "median_us": 2602896.197, "min_us": 2596556.544, "partition_size": 1000000, "peak_rss_kb": 433120, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 3002535.401, "median_us": 2971864.774, "min_us": 2971178.515, "partition_size": 1000000, "peak_rss_kb": 444780, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2985808.292, "median_us": 2978934.726, "min_us": 2970130.609, "partition_size": 1000000, "peak_rss_kb": 440136, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 25889367.877, "median_us": 25843329.846, "min_us": 25779651.996, "partition_size": 16, "peak_rss_kb": 5572, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33517996.321, "median_us": 33486956.435, "min_us": 33425464.397, "partition_size": 16, "peak_rss_kb": 3713848, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6961.403, "median_us": 2212.426, "min_us": 2186.063, "partition_size": 16, "peak_rss_kb": 4028, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 446, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28442643.237, "median_us": 28425915.441, "min_us": 28402790.992, "partition_size": 16, "peak_rss_kb": 3714144, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27085657.073, "median_us": 27063969.71, "min_us": 27041138.708, "partition_size": 1, "peak_rss_kb": 5612, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33441379.037, "median_us": 33368873.913, "min_us": 33338210.97, "partition_size": 1, "peak_rss_kb": 3714848, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 9382.605, "median_us": 2233.082, "min_us": 2196.446, "partition_size": 1, "peak_rss_kb": 3860, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 432, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28605697.536, "median_us": 28571665.926, "min_us": 28508108.315, "partition_size": 1, "peak_rss_kb": 3714208, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 32959208.647, "median_us": 32922280.277, "min_us": 32916823.02, "partition_size": 10000000, "peak_rss_kb": 2896992, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33866072.927, "median_us": 33833699.683, "min_us": 33821266.018, "partition_size": 10000000, "peak_rss_kb": 3714952, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23669437.374, "median_us": 23648540.854, "min_us": 23586262.914, "partition_size": 10000000, "peak_rss_kb": 2896452, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28687783.52, "median_us": 28687536.47, "min_us": 28596782.417, "partition_size": 10000000, "peak_rss_kb": 3715664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 3, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 33125773.332, "median_us": 33119141.172, "min_us": 33097008.546, "partition_size": 10000000, "peak_rss_kb": 3714852, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33519936.067, "median_us": 33515126.275, "min_us": 33480380.877, "partition_size": 10000000, "peak_rss_kb": 3714324, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 3, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 243180.264, "median_us": 240739.285, "min_us": 240274.585, "partition_size": 16, "peak_rss_kb": 42608, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 244431.159, "median_us": 242780.46, "min_us": 241795.767, "partition_size": 16, "peak_rss_kb": 5484, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 215035.714, "median_us": 212593.739, "min_us": 210358.357, "partition_size": 16, "peak_rss_kb": 44304, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 9282.47, "median_us": 2048.872, "min_us": 2023.951, "partition_size": 16, "peak_rss_kb": 3948, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 477, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 247271.558, "median_us": 244517.814, "min_us": 240048.054, "partition_size": 1, "peak_rss_kb": 41644, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 266381.309, "median_us": 255490.535, "min_us": 253990.709, "partition_size": 1, "peak_rss_kb": 5408, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 217859.927, "median_us": 215289.455, "min_us": 212839.727, "partition_size": 1, "peak_rss_kb": 42140, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6416.279, "median_us": 2067.354, "min_us": 2042.034, "partition_size": 1, "peak_rss_kb": 3940, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 477, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 244187.376, "median_us": 243248.902, "min_us": 241319.195, "partition_size": 100000, "peak_rss_kb": 42360, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 267348.721, "median_us": 266618.952, "min_us": 265603.302, "partition_size": 100000, "peak_rss_kb": 34896, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 213630.026, "median_us": 213249.994, "min_us": 212299.506, "partition_size": 100000, "peak_rss_kb": 44236, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 206305.848, "median_us": 205100.201, "min_us": 204427.838, "partition_size": 100000, "peak_rss_kb": 35064, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 249186.035, "median_us": 240222.447, "min_us": 239511.268, "partition_size": 100000, "peak_rss_kb": 42956, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 247539.296, "median_us": 246536.278, "min_us": 244419.204, "partition_size": 100000, "peak_rss_kb": 43052, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2997974.467, "median_us": 2977312.333, "min_us": 2938606.331, "partition_size": 16, "peak_rss_kb": 431432, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2581616.415, "median_us": 2527454.147, "min_us": 2526132.504, "partition_size": 16, "peak_rss_kb": 5484, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2561788.133, "median_us": 2547421.479, "min_us": 2540904.104, "partition_size": 16, "peak_rss_kb": 427204, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6680.226, "median_us": 2138.002, "min_us": 2103.462, "partition_size": 16, "peak_rss_kb": 3992, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 463, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2947609.211, "median_us": 2936916.808, "min_us": 2923989.517, "partition_size": 1, "peak_rss_kb": 457552, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2647623.258, "median_us": 2646717.196, "min_us": 2636023.998, "partition_size": 1, "peak_rss_kb": 5520, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2599672.594, "median_us": 2547068.529, "min_us": 2528670.083, "partition_size": 1, "peak_rss_kb": 427204, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 7949.543, "median_us": 2148.095, "min_us": 2117.441, "partition_size": 1, "peak_rss_kb": 3888, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 455, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3023714.819, "median_us": 3011607.851, "min_us": 3008372.768, "partition_size": 1000000, "peak_rss_kb": 446288, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3001243.344, "median_us": 2964525.255, "min_us": 2946915.39, "partition_size": 1000000, "peak_rss_kb": 313072, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2572335.208, "median_us": 2565857.78, "min_us": 2560067.391, "partition_size": 1000000, "peak_rss_kb": 481740, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2219773.784, "median_us": 2197764.184, "min_us": 2197167.671, "partition_size": 1000000, "peak_rss_kb": 310376, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3016325.086, "median_us": 2994742.407, "min_us": 2982386.044, "partition_size": 1000000, "peak_rss_kb": 439884, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2999529.181, "median_us": 2996446.8, "min_us": 2996056.801, "partition_size": 1000000, "peak_rss_kb": 428012, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33520502.353, "median_us": 33495104.06, "min_us": 33475903.984, "partition_size": 16, "peak_rss_kb": 3715032, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 26111485.157, "median_us": 26003320.395, "min_us": 25955581.007, "partition_size": 16, "peak_rss_kb": 5416, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 29137974.874, "median_us": 28375122.95, "min_us": 28374809.456, "partition_size": 16, "peak_rss_kb": 3714984, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6957.557, "median_us": 2211.576, "min_us": 2181.25, "partition_size": 16, "peak_rss_kb": 4044, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 446, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33603450.178, "median_us": 33590347.994, "min_us": 33550504.503, "partition_size": 1, "peak_rss_kb": 3715208, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27517231.929, "median_us": 27507625.212, "min_us": 27468906.639, "partition_size": 1, "peak_rss_kb": 5640, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28199435.743, "median_us": 28185307.922, "min_us": 28178847.019, "partition_size": 1, "peak_rss_kb": 3714260, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 5983.842, "median_us": 2228.74, "min_us": 2197.703, "partition_size": 1, "peak_rss_kb": 3940, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 446, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33694870.527, "median_us": 33567657.131, "min_us": 33565955.895, "partition_size": 10000000, "peak_rss_kb": 3715516, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33219314.26, "median_us": 33204920.433, "min_us": 33202379.74, "partition_size": 10000000, "peak_rss_kb": 2897892, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28393068.799, "median_us": 28363637.865, "min_us": 28361954.794, "partition_size": 10000000, "peak_rss_kb": 3714960, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23474096.699, "median_us": 23432004.49, "min_us": 23408274.048, "partition_size": 10000000, "peak_rss_kb": 2897248, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 4, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33217213.248, "median_us": 33199030.145, "min_us": 33190296.977, "partition_size": 10000000, "peak_rss_kb": 3714396, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 33702147.235, "median_us": 33673347.399, "min_us": 33614030.438, "partition_size": 10000000, "peak_rss_kb": 3714412, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 4, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 244983.907, "median_us": 244303.615, "min_us": 243744.973, "partition_size": 16, "peak_rss_kb": 5472, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 5, "scale": "100k", "shape": "value", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 257379.32, "median_us": 250358.536, "min_us": 246133.022, "partition_size": 16, "peak_rss_kb": 44664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 4, "scale": "100k", "shape": "value", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 6502.332, "median_us": 2069.002, "min_us": 2034.711, "partition_size": 16, "peak_rss_kb": 3948, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 477, "scale": "100k", "shape": "value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 224541.069, "median_us": 220638.454, "min_us": 217339.255, "partition_size": 16, "peak_rss_kb": 42636, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 5, "scale": "100k", "shape": "value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 256519.672, "median_us": 256493.492, "min_us": 253389.497, "partition_size": 1, "peak_rss_kb": 5304, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 4, "scale": "100k", "shape": "entity", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 250601.136, "median_us": 248243.594, "min_us": 244530.824, "partition_size": 1, "peak_rss_kb": 41892, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 5, "scale": "100k", "shape": "entity", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 9119.306, "median_us": 2058.0, "min_us": 2024.27, "partition_size": 1, "peak_rss_kb": 3924, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 475, "scale": "100k", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 221949.059, "median_us": 221594.062, "min_us": 220003.327, "partition_size": 1, "peak_rss_kb": 43228, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 5, "scale": "100k", "shape": "entity_limit", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 271189.534, "median_us": 267688.962, "min_us": 263317.639, "partition_size": 100000, "peak_rss_kb": 34540, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 251616.455, "median_us": 251566.666, "min_us": 249500.868, "partition_size": 100000, "peak_rss_kb": 41472, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 4, "scale": "100k", "shape": "growing_value", "variant": "parent"} +{"facts": 100000, "group_size": 100000, "max_us": 218519.057, "median_us": 204214.584, "min_us": 204205.17, "partition_size": 100000, "peak_rss_kb": 34944, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 100000, "group_size": 100000, "max_us": 218067.331, "median_us": 216681.727, "min_us": 215608.523, "partition_size": 100000, "peak_rss_kb": 44220, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 5, "scale": "100k", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 100000, "group_size": 16, "max_us": 246295.824, "median_us": 244079.006, "min_us": 243790.494, "partition_size": 100000, "peak_rss_kb": 42960, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 100000, "group_size": 16, "max_us": 247198.403, "median_us": 245825.123, "min_us": 242909.009, "partition_size": 100000, "peak_rss_kb": 43056, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 100000, "runs": 5, "scale": "100k", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2475031.518, "median_us": 2473059.192, "min_us": 2470296.616, "partition_size": 16, "peak_rss_kb": 5528, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 3000041.994, "median_us": 2991323.828, "min_us": 2976059.961, "partition_size": 16, "peak_rss_kb": 440620, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "value", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 9162.734, "median_us": 2130.749, "min_us": 2105.137, "partition_size": 16, "peak_rss_kb": 3952, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 459, "scale": "1m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2578677.384, "median_us": 2572434.213, "min_us": 2570723.763, "partition_size": 16, "peak_rss_kb": 426500, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2617729.441, "median_us": 2610842.182, "min_us": 2609687.697, "partition_size": 1, "peak_rss_kb": 5448, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2993122.164, "median_us": 2987773.796, "min_us": 2983847.223, "partition_size": 1, "peak_rss_kb": 451272, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "entity", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 6992.062, "median_us": 2219.64, "min_us": 2172.417, "partition_size": 1, "peak_rss_kb": 3888, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 444, "scale": "1m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2577303.412, "median_us": 2572668.141, "min_us": 2566259.354, "partition_size": 1, "peak_rss_kb": 427204, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "entity_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2923341.699, "median_us": 2919535.53, "min_us": 2899121.209, "partition_size": 1000000, "peak_rss_kb": 311732, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 3032753.75, "median_us": 3026397.384, "min_us": 3019877.547, "partition_size": 1000000, "peak_rss_kb": 446992, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "growing_value", "variant": "parent"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2243000.437, "median_us": 2191906.936, "min_us": 2127600.003, "partition_size": 1000000, "peak_rss_kb": 306520, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 1000000, "group_size": 1000000, "max_us": 2590832.673, "median_us": 2588221.276, "min_us": 2585084.983, "partition_size": 1000000, "peak_rss_kb": 446564, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "1m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 1000000, "group_size": 16, "max_us": 2953609.828, "median_us": 2943574.296, "min_us": 2942628.705, "partition_size": 1000000, "peak_rss_kb": 433552, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 1000000, "group_size": 16, "max_us": 2992173.512, "median_us": 2987815.138, "min_us": 2978665.729, "partition_size": 1000000, "peak_rss_kb": 439508, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 1000000, "runs": 3, "scale": "1m", "shape": "unpartitioned_control", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 26023870.938, "median_us": 25948681.504, "min_us": 25907496.916, "partition_size": 16, "peak_rss_kb": 5572, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33694898.065, "median_us": 33610019.186, "min_us": 33600777.632, "partition_size": 16, "peak_rss_kb": 3715036, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "value", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 6964.524, "median_us": 2216.091, "min_us": 2185.804, "partition_size": 16, "peak_rss_kb": 3928, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 439, "scale": "10m", "shape": "value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28345947.435, "median_us": 28317051.13, "min_us": 28267345.064, "partition_size": 16, "peak_rss_kb": 3714980, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 27392005.649, "median_us": 27263050.068, "min_us": 27124484.578, "partition_size": 1, "peak_rss_kb": 5680, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33490680.248, "median_us": 33436384.501, "min_us": 33397976.267, "partition_size": 1, "peak_rss_kb": 3715400, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "entity", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 8323.053, "median_us": 2238.258, "min_us": 2187.676, "partition_size": 1, "peak_rss_kb": 3952, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 437, "scale": "10m", "shape": "entity_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 28565183.085, "median_us": 28435796.362, "min_us": 28424660.905, "partition_size": 1, "peak_rss_kb": 3714556, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "entity_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33111478.31, "median_us": 33074570.904, "min_us": 33021472.027, "partition_size": 10000000, "peak_rss_kb": 2897256, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 33709751.743, "median_us": 33708199.02, "min_us": 33669759.475, "partition_size": 10000000, "peak_rss_kb": 3715620, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "growing_value", "variant": "parent"} +{"facts": 10000000, "group_size": 10000000, "max_us": 23321081.435, "median_us": 23305730.888, "min_us": 23249580.486, "partition_size": 10000000, "peak_rss_kb": 2897228, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "partitioned"} +{"facts": 10000000, "group_size": 10000000, "max_us": 28654660.068, "median_us": 28646795.865, "min_us": 28630391.714, "partition_size": 10000000, "peak_rss_kb": 3715664, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :group ?g] :limit 10])", "round": 5, "rows": 10, "runs": 3, "scale": "10m", "shape": "growing_value_limit", "variant": "parent"} +{"facts": 10000000, "group_size": 16, "max_us": 34858377.526, "median_us": 33605532.529, "min_us": 33463192.111, "partition_size": 10000000, "peak_rss_kb": 3715096, "probe_binary_sha256": "7b60aca5130356c3fb24ae92c49b08d5f7fab47600f642aa933087cf3c896da7", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "partitioned"} +{"facts": 10000000, "group_size": 16, "max_us": 33338818.942, "median_us": 33333611.339, "min_us": 33332276.275, "partition_size": 10000000, "peak_rss_kb": 3714804, "probe_binary_sha256": "d03a700074efa6d53a474752c5faf9e0762ff08ea6806433a13b8b5c999a39f4", "query": "(query [:find ?e ?g (row-number :over (:order-by ?e)) :where [?e :group ?g] ])", "round": 5, "rows": 10000000, "runs": 3, "scale": "10m", "shape": "unpartitioned_control", "variant": "parent"} diff --git a/scripts/input_order_window_probe.rs b/scripts/input_order_window_probe.rs new file mode 100644 index 0000000000..bab2604bb8 --- /dev/null +++ b/scripts/input_order_window_probe.rs @@ -0,0 +1,53 @@ +//! Window probe linked against both slice-2 and slice-3 libraries (#641). +//! Usage: probe '' +//! Use input_order_group_fixture.rs separately. Timings exclude open/thread +//! creation: one warmup, at least three timed drains; 256 KiB worker stack. +use minigraf::{OpenOptions, Value}; +use std::time::{Duration, Instant}; + +fn rss_kb() -> u64 { + std::fs::read_to_string("/proc/self/status") + .ok() + .and_then(|text| { + text.lines() + .find(|l| l.starts_with("VmHWM:")) + .and_then(|l| l.split_whitespace().nth(1)) + .and_then(|n| n.parse().ok()) + }) + .unwrap_or(0) +} + +fn main() { + let args: Vec<_> = std::env::args().collect(); + std::thread::Builder::new().stack_size(256 * 1024).spawn(move || { + let db = OpenOptions::new().read_only(true).path(&args[1]).open().unwrap(); + let expected: usize = args[3].parse().unwrap(); + let group_size: usize = args[4].parse().unwrap(); + let partition_size: usize = args[5].parse().unwrap(); + let drain = || { + let mut cursor = db.query(&args[2]).unwrap(); + let mut rows = 0; + while let Some(batch) = cursor.next_batch(1000).unwrap() { + for row in batch.rows() { + assert!(row.len() == 3, "three projected columns"); + assert!(row[0] == Value::Ref(minigraf::EntityId::from_u128(rows as u128 + 1)), "input entity order"); + assert!(row[1] == Value::Integer((rows / group_size) as i64), "group value"); + assert!(row[2] == Value::Integer((rows % partition_size + 1) as i64), "partition row number"); + rows += 1; + } + } + assert_eq!(rows, expected, "expected row count"); + }; + drain(); + let start = Instant::now(); + let mut times = Vec::new(); + while times.len() < 20_000 && (times.len() < 3 || start.elapsed() < Duration::from_secs(1)) { + let t = Instant::now(); + drain(); + times.push(t.elapsed().as_secs_f64() * 1_000_000.0); + } + times.sort_by(f64::total_cmp); + println!("{{\"runs\":{},\"median_us\":{:.3},\"min_us\":{:.3},\"max_us\":{:.3},\"rows\":{},\"peak_rss_kb\":{}}}", + times.len(), times[times.len() / 2], times[0], times[times.len()-1], expected, rss_kb()); + }).unwrap().join().unwrap(); +} diff --git a/src/query/datalog/optimizer.rs b/src/query/datalog/optimizer.rs index 59de58c729..0ca7b9c073 100644 --- a/src/query/datalog/optimizer.rs +++ b/src/query/datalog/optimizer.rs @@ -443,7 +443,7 @@ fn plan_ordered( // i.e. final relative order at any shared insertion point comes out ascending // (cheapest first), mirroring the executor's previous post-filter ordering. if reorder() { - not_clauses.sort_by_key(|c| std::cmp::Reverse(clause_cost(c))); + sort_by_cost(&mut not_clauses, true); } for nc in not_clauses { @@ -609,6 +609,16 @@ pub fn clause_cost(clause: &WhereClause) -> u64 { } } +/// Share a stable cost sort between deferred clauses and negation placement. +/// Equal-cost clauses retain their input order in either direction. +#[inline(never)] +pub(crate) fn sort_by_cost(clauses: &mut [WhereClause], descending: bool) { + clauses.sort_by(|a, b| { + let order = clause_cost(a).cmp(&clause_cost(b)); + if descending { order.reverse() } else { order } + }); +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/query/engine/ids.rs b/src/query/engine/ids.rs index 2a256a6bee..5ebe89c071 100644 --- a/src/query/engine/ids.rs +++ b/src/query/engine/ids.rs @@ -9,9 +9,9 @@ //! or ident keeps its id. DICT lookups are only cached until the next pull //! ([`IdSpace::end_pull`]): a DICT id never changes, and a cache that grew //! with every row a cursor returns would hold the whole answer. -//! A stream that ends in a `Window` keeps them until it ends: the window -//! already looked up every row's ids in its first pull, and holds the whole -//! answer anyway (#547). +//! A full-input `Window` keeps them until it ends (#547). A certified +//! partition Window evicts at internal input/result batch boundaries too, +//! so one operator pull cannot retain the lookups of the whole query (#641). use super::meter::{HASH_ENTRY_OVERHEAD, Held, Meter, growth}; use crate::error::{ErrorCode, err_coded}; diff --git a/src/query/engine/meter.rs b/src/query/engine/meter.rs index 967a7f138e..c279776e5b 100644 --- a/src/query/engine/meter.rs +++ b/src/query/engine/meter.rs @@ -26,6 +26,35 @@ pub(crate) struct Meter { used: AtomicUsize, /// The most `used` has been, for tests and measurement. peak: AtomicUsize, + #[cfg(test)] + window: LivePeak, + #[cfg(test)] + ids: LivePeak, +} + +/// Test-only ownership totals distinguish a window's retained rows from the +/// lookup cache. Multiple Helds with the same name contribute together. +#[cfg(test)] +#[derive(Debug, Default)] +struct LivePeak { + used: AtomicUsize, + peak: AtomicUsize, +} + +#[cfg(test)] +impl LivePeak { + fn add(&self, n: usize) { + let now = self.used.load(Ordering::Relaxed).saturating_add(n); + self.used.store(now, Ordering::Relaxed); + self.peak.fetch_max(now, Ordering::Relaxed); + } + + fn subtract(&self, n: usize) { + self.used.store( + self.used.load(Ordering::Relaxed).saturating_sub(n), + Ordering::Relaxed, + ); + } } impl Meter { @@ -34,6 +63,10 @@ impl Meter { limit, used: AtomicUsize::new(0), peak: AtomicUsize::new(0), + #[cfg(test)] + window: LivePeak::default(), + #[cfg(test)] + ids: LivePeak::default(), }) } @@ -53,6 +86,21 @@ impl Meter { pub(crate) fn peak(&self) -> usize { self.peak.load(Ordering::Relaxed) } + + #[cfg(test)] + fn tracked(&self, op: &str) -> Option<&LivePeak> { + match op { + "Window" => Some(&self.window), + "IdSpace" => Some(&self.ids), + _ => None, + } + } + + #[cfg(test)] + pub(crate) fn peak_for(&self, op: &str) -> usize { + self.tracked(op) + .map_or(0, |p| p.peak.load(Ordering::Relaxed)) + } } /// What one holder counts on its query's meter. @@ -99,6 +147,10 @@ impl Held { m.used.store(now, Ordering::Relaxed); m.peak.fetch_max(now, Ordering::Relaxed); self.bytes = self.bytes.saturating_add(n); + #[cfg(test)] + if let Some(peak) = m.tracked(self.op) { + peak.add(n); + } Ok(()) } @@ -107,6 +159,10 @@ impl Held { let n = n.min(self.bytes); self.bytes -= n; let m = &*self.meter; + #[cfg(test)] + if let Some(peak) = m.tracked(self.op) { + peak.subtract(n); + } m.used.store( m.used.load(Ordering::Relaxed).saturating_sub(n), Ordering::Relaxed, @@ -116,6 +172,15 @@ impl Held { /// Take over what `other` counts, which goes on being counted until this /// holder lets it go. pub(crate) fn absorb(&mut self, mut other: Held) { + #[cfg(test)] + if self.op != other.op { + if let Some(peak) = self.meter.tracked(other.op) { + peak.subtract(other.bytes); + } + if let Some(peak) = self.meter.tracked(self.op) { + peak.add(other.bytes); + } + } self.bytes = self.bytes.saturating_add(other.bytes); other.bytes = 0; } @@ -325,3 +390,27 @@ mod tests { assert_eq!(meter.used(), usize::MAX); } } + +#[cfg(test)] +#[test] +fn op_peaks_count_overlapping_holders_and_transferred_ownership() { + let meter = Meter::unlimited(); + let mut rows = Held::new(&meter, "Window"); + let mut columns = Held::new(&meter, "Window"); + let mut ids = Held::new(&meter, "IdSpace"); + rows.charge(100).unwrap(); + columns.charge(30).unwrap(); + ids.charge(200).unwrap(); + assert_eq!(meter.peak_for("Window"), 130); + assert_eq!(meter.peak_for("IdSpace"), 200); + rows.uncharge(80); + drop(columns); + let mut transferred = Held::new(&meter, "other"); + transferred.charge(500).unwrap(); + ids.absorb(transferred); + assert_eq!(meter.peak_for("IdSpace"), 700); + assert_eq!(meter.peak_for("Window"), 130); + drop(rows); + drop(ids); + assert_eq!(meter.used(), 0); +} diff --git a/src/query/engine/mod.rs b/src/query/engine/mod.rs index 53a335cca1..0845c78efd 100644 --- a/src/query/engine/mod.rs +++ b/src/query/engine/mod.rs @@ -30,6 +30,8 @@ mod sort; mod tests; mod union; mod window; +#[cfg(all(test, not(target_arch = "wasm32")))] +mod window_order_tests; use crate::error::{ErrorCode, err_coded}; use crate::graph::storage::Snapshot; @@ -130,9 +132,9 @@ pub(crate) struct Stream { find: Vec, vars: Vec, project: Counters, - /// Keep the DICT lookups until the stream ends: a `Window` turns every - /// row's ids into values in its first pull, and the rows it returns - /// later read the same ids again (#547). + /// Full-input windows retain DICT lookups until the stream ends (#547). + /// Certified partition windows instead evict at internal input/result + /// boundaries and outer pulls; ids stay valid under the pin (#641). hold_ids: bool, /// In a rule query, the relations its rules derived (#548). relations: Option, @@ -282,7 +284,9 @@ fn stream( vars, as_of: _, } = plan; - let hold_ids = steps.iter().any(|s| matches!(s, plan::Step::Window { .. })); + let hold_ids = steps.iter().any(|s| { + matches!(s, plan::Step::Window { mode, .. } if !matches!(mode, plan::WindowMode::Partitioned { .. })) + }); let root = build(source, steps, &meter); Stream { snapshot, @@ -336,8 +340,19 @@ pub(crate) fn build( grouping == plan::Grouping::Ordered, meter, )), - plan::Step::Window { find, named, keep } => { - Box::new(window::Window::new(root, find, named, keep, meter)) + plan::Step::Window { + find, + named, + keep, + mode, + } => { + let partition = match mode { + plan::WindowMode::Partitioned { slot, order } => Some((slot, order)), + plan::WindowMode::Full | plan::WindowMode::Candidate(_) => None, + }; + Box::new(window::Window::new( + root, find, named, keep, partition, meter, + )) } plan::Step::Sort { cols, order, keep } => { Box::new(sort::Sort::new(root, cols, order, keep, meter)) diff --git a/src/query/engine/order.rs b/src/query/engine/order.rs index b5d232ae2b..192ac4683f 100644 --- a/src/query/engine/order.rs +++ b/src/query/engine/order.rs @@ -1,7 +1,10 @@ //! Snapshot-bound input-order proofs (#641). DICT order is never UUID/text //! order. Unknown order retains the original index choice and buffering. -use super::plan::{Body, Grouping, JoinKind, Meta, Out, Plan, ScanSpec, Source, Step, Term, Vars}; +use super::plan::{ + Body, Grouping, JoinKind, Meta, Out, PartitionOrder, Plan, ScanSpec, Source, Step, Term, Vars, + WindowMode, +}; use crate::graph::storage::Snapshot; use crate::query::datalog::functions::{AggImpl, Builtin, FunctionRegistry}; use crate::query::datalog::types::{Expr, FindSpec, UnaryOp, WindowFunc}; @@ -52,6 +55,7 @@ impl Drop for InputOrderGuard { enum Domain { Single(ValueKind), Numbers, + Entity, } /// Leading scalar key and constants. A complete aggregate key is unique; @@ -80,6 +84,47 @@ impl Ordering { } } + fn entity(spec: &ScanSpec) -> Option { + let Term::Bind(slot) = spec.e else { + return None; + }; + if spec.index == Some(Index::Avet) { + return None; + } + let mut proof = Self::source(spec, Domain::Entity); + proof.slot = Some(slot); + Some(proof) + } + + fn group_ordered(&self) -> bool { + matches!( + self.kind, + Domain::Single(ValueKind::Integer | ValueKind::Float | ValueKind::Boolean) + | Domain::Numbers + ) + } + + fn partition_order(&self) -> Option { + match self.kind { + Domain::Entity | Domain::Single(ValueKind::Ref) => Some(PartitionOrder::Entity), + Domain::Single(ValueKind::Keyword) => Some(PartitionOrder::Ident), + _ if self.group_ordered() => Some(PartitionOrder::Values), + _ => None, + } + } + + fn remap(&mut self, keep: &[usize]) { + self.slot = self + .slot + .and_then(|slot| keep.iter().position(|&s| s == slot)); + self.constants = keep + .iter() + .enumerate() + .filter_map(|(at, s)| self.constants.contains(s).then_some(at)) + .collect(); + self.unique = false; + } + fn invalidate(&mut self, slot: usize) { if self.slot == Some(slot) { self.slot = None; @@ -232,14 +277,19 @@ fn safe_steps(steps: &[Step], functions: &FunctionRegistry) -> bool { } /// At most eight raw seeks through the exact reader the Stream will scan. -fn scalar_kind(keys: &dyn KeySource, attribute: u32) -> Result> { +fn value_domain(keys: &dyn KeySource, attribute: u32) -> Result> { let mut found = None; for kind in ValueKind::ALL { if keys.any_key(Index::Avet, &keys::attribute_kind_prefix(attribute, kind))? { found = match (found, kind) { - (None, ValueKind::Integer | ValueKind::Float | ValueKind::Boolean) => { - Some(Domain::Single(kind)) - } + ( + None, + ValueKind::Integer + | ValueKind::Float + | ValueKind::Boolean + | ValueKind::Ref + | ValueKind::Keyword, + ) => Some(Domain::Single(kind)), (Some(Domain::Single(ValueKind::Integer)), ValueKind::Float) => { Some(Domain::Numbers) } @@ -253,21 +303,22 @@ fn scalar_kind(keys: &dyn KeySource, attribute: u32) -> Result> { /// The choices are applied together only after the snapshot proof succeeds. struct Choice { aggregate: Option, + window: Option<(usize, usize, PartitionOrder)>, sort: Option, avet: bool, } fn choices( - spec: &ScanSpec, plan: &Plan, - kind: Domain, + mut proof: Ordering, + avet: bool, functions: &FunctionRegistry, ) -> Option { - let mut proof = Ordering::source(spec, kind); let mut choice = Choice { aggregate: None, + window: None, sort: None, - avet: !matches!(spec.e, Term::Const(_)), + avet, }; for (at, step) in plan.steps.iter().enumerate() { match step { @@ -276,7 +327,8 @@ fn choices( aggs, grouping: Grouping::Candidate, .. - } if groups.len() == 1 + } if proof.group_ordered() + && groups.len() == 1 && proof.slot == groups.first().copied() && aggs.iter().all(|(func, _)| { functions.get(func).is_some_and(|d| { @@ -292,6 +344,20 @@ fn choices( proof.constants.clear(); proof.unique = true; } + Step::Window { + keep, + mode: WindowMode::Candidate(slot), + .. + } => { + if proof.slot != Some(*slot) || proof.constants.contains(slot) { + break; + } + let Some(order) = proof.partition_order() else { + break; + }; + choice.window = Some((at, *slot, order)); + proof.remap(keep); + } Step::Sort { cols, order, keep } => { if *keep != Some(0) && proof.satisfies(cols, order) { choice.sort = Some(at); @@ -306,7 +372,8 @@ fn choices( } } } - (choice.aggregate.is_some() || choice.sort.is_some()).then_some(choice) + (choice.aggregate.is_some() || choice.window.is_some() || choice.sort.is_some()) + .then_some(choice) } fn candidate( @@ -324,8 +391,20 @@ fn candidate( if spec.derived.is_some() || spec.never() || matches!(spec.e, Term::Eq(_)) { return Ok(None); } - // Reject impossible strategies before any speculative storage reads. - if choices(spec, plan, Domain::Single(ValueKind::Integer), functions).is_none() { + // Prefer the existing entity prefix when it already partitions windows; + // no kind seeks or broader index are needed for dictionary-id adjacency. + let entity_choice = + Ordering::entity(spec).and_then(|proof| choices(plan, proof, false, functions)); + let avet = !matches!(spec.e, Term::Const(_)); + if entity_choice.is_none() + && choices( + plan, + Ordering::source(spec, Domain::Single(ValueKind::Integer)), + avet, + functions, + ) + .is_none() + { return Ok(None); } let entity = match &spec.e { @@ -335,13 +414,16 @@ fn candidate( if snapshot.has_pending(attribute, entity)? { return Ok(None); } + if entity_choice.is_some() { + return Ok(entity_choice); + } let Some(a) = keys.iid_of(attribute)? else { return Ok(None); }; - let Some(kind) = scalar_kind(keys, a)? else { + let Some(kind) = value_domain(keys, a)? else { return Ok(None); }; - Ok(choices(spec, plan, kind, functions)) + Ok(choices(plan, Ordering::source(spec, kind), avet, functions)) } /// Only a plain query's root pipeline is resolved; bodies and rules keep their @@ -370,6 +452,11 @@ pub(super) fn resolve( { *grouping = Grouping::Ordered; } + if let Some((at, slot, order)) = choice.window + && let Some(Step::Window { mode, .. }) = plan.steps.get_mut(at) + { + *mode = WindowMode::Partitioned { slot, order }; + } if let Some(at) = choice.sort && let Step::Sort { cols, .. } = plan.steps.remove(at) { diff --git a/src/query/engine/order/tests.rs b/src/query/engine/order/tests.rs index f6901085ec..2d685a9009 100644 --- a/src/query/engine/order/tests.rs +++ b/src/query/engine/order/tests.rs @@ -172,6 +172,7 @@ fn canonicalization_and_buffering_operators_cannot_supply_false_certificates() { find: vec![], named: vec![], keep: vec![1], + mode: WindowMode::Full, }, Step::Sort { cols: vec![1], @@ -375,3 +376,104 @@ fn a_unique_group_key_proves_tie_columns_until_a_join_can_multiply_it() { assert!(!joined.satisfies(&[1, 0], &[(0, false), (1, true)])); assert!(sorted(&joined)); } +/// A real committed reader on native, WASI and the browser, including canonical +/// NaNs, both zero encodings, mixed numeric groups and Boolean partitions. +#[cfg_attr( + all(target_arch = "wasm32", not(target_os = "wasi")), + wasm_bindgen_test::wasm_bindgen_test +)] +#[cfg_attr(not(all(target_arch = "wasm32", not(target_os = "wasi"))), test)] +fn committed_partition_windows_preserve_float_edges_and_numeric_group_classes() { + use crate::query::datalog::{parser::parse_datalog_command, types::DatalogCommand}; + use crate::storage::{backend::memory::MemoryBackend, persistent_facts::PersistentFactStorage}; + for case in 0..3 { + let mut values = vec![ + Value::Float(-0.0), + Value::Float(0.0), + Value::Float(f64::NAN), + Value::Float(-f64::NAN), + Value::Float(f64::NEG_INFINITY), + Value::Float(1.5), + ]; + if case == 1 { + values.extend([Value::Integer(10), Value::Integer(-10)]); + } + if case == 2 { + values = vec![ + Value::Boolean(true), + Value::Boolean(false), + Value::Boolean(true), + ]; + } + let mut pfs = PersistentFactStorage::new(MemoryBackend::new(), 32).unwrap(); + pfs.storage() + .transact( + values + .into_iter() + .enumerate() + .map(|(i, v)| (uuid::Uuid::from_u128(i as u128 + 1), ":part".into(), v)) + .collect(), + None, + ) + .unwrap(); + pfs.mark_dirty(); + pfs.save().unwrap(); + let DatalogCommand::Query(q)=parse_datalog_command("(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) (lag ?g :over (:partition-by ?g :order-by ?e)) (sum ?g :over (:partition-by ?g :order-by ?e :rows 1 preceding)) :where [?e :part ?g] :order-by [?g ?e]])").unwrap() else {panic!("query");}; + let mut results = Vec::new(); + for optimized in [false, true] { + let _mode = set_enabled(optimized); + let mut stream = crate::query::engine::open( + pfs.storage().snapshot().unwrap(), + crate::query::engine::plan(&q).unwrap(), + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert_eq!( + stream + .counters() + .iter() + .any(|c| c.op == "WindowPartitioned"), + optimized + ); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + results.push(rows); + } + assert_eq!(results[0].len(), results[1].len()); + for (a, b) in results[0].iter().flatten().zip(results[1].iter().flatten()) { + match (a, b) { + (Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits()), + _ => assert!(a == b, "same partition window result"), + } + } + } +} + +#[test] +fn id_adjacency_cannot_certify_aggregate_or_semantic_sort_order() { + for kind in [ValueKind::Keyword, ValueKind::Ref] { + let p = proof(kind); + assert!(!p.group_ordered()); + assert!(!sorted(&p)); + assert!(p.partition_order().is_some()); + } + let p = Ordering::entity(&spec(false)).unwrap(); + assert!(!p.group_ordered()); + assert!(!sorted(&p)); + assert_eq!(p.partition_order(), Some(PartitionOrder::Entity)); + let mut avet = spec(false); + avet.index = Some(Index::Avet); + assert!( + Ordering::entity(&avet).is_none(), + "an existing value-range hint cannot prove entity adjacency" + ); + let mut p = proof(ValueKind::Integer); + p.remap(&[0, 2]); + assert!( + p.slot.is_none(), + "a dropped key cannot certify an output order" + ); +} diff --git a/src/query/engine/order_tests.rs b/src/query/engine/order_tests.rs index 55a302eeea..1e7ad03fe3 100644 --- a/src/query/engine/order_tests.rs +++ b/src/query/engine/order_tests.rs @@ -748,6 +748,22 @@ fn optional_proofs_are_bounded_and_queries_without_a_usable_demand_do_no_probes( let snapshot = db.snapshot().unwrap(); let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); for (q, expected) in [ + ( + "[:find ?v (row-number :over (:partition-by ?v :order-by ?e)) :where [?e :score ?v]]", + 8, + ), + ( + "[:find ?v (row-number :over (:partition-by ?e :order-by ?v)) :where [?e :score ?v]]", + 0, + ), + ( + "[:find ?v (row-number :over (:order-by ?v)) :where [?e :score ?v]]", + 0, + ), + ( + "[:find ?v (row-number :over (:partition-by ?v :order-by ?e)) :where [?e :score ?v] :limit 0]", + 0, + ), ("[:find ?v (count ?e) :where [?e :score ?v] :limit 3]", 8), ( "[:find ?v (count ?e) :where [?e :score ?v] :order-by [?v] :offset 7 :limit 0]", @@ -881,3 +897,39 @@ fn every_failed_optional_read_retains_the_original_sort_projection_and_index() { } } } + +#[test] +fn every_failed_window_proof_leaves_mode_projection_and_index_unchanged() { + use super::plan::{Source, Step, WindowMode}; + use crate::query::datalog::functions::FunctionRegistry; + let (_dir, db) = fixture(32); + let snapshot = db.snapshot().unwrap(); + let base = snapshot.committed.as_ref().unwrap().key_source().unwrap(); + for fail_at in 1..=8 { + let keys = ProofKeys { + base, + calls: 0.into(), + fail_at: Some(fail_at), + }; + let mut plan = query_plan( + "[:find ?v (row-number :over (:partition-by ?v :order-by ?e)) :where [?e :score ?v] :order-by [?v]]", + ); + let original = plan.find.clone(); + super::order::resolve( + &snapshot, + Some(&keys), + &FunctionRegistry::with_builtins(), + &mut plan, + ); + assert!(plan.steps.iter().all(|s| !matches!( + s, + Step::Window { + mode: WindowMode::Partitioned { .. }, + .. + } + ))); + assert!(plan.steps.iter().any(|s| matches!(s, Step::Sort { .. }))); + assert!(matches!(&plan.source, Source::Scan(s) if s.index.is_none())); + assert_eq!(plan.find, original); + } +} diff --git a/src/query/engine/plan.rs b/src/query/engine/plan.rs index da5305c9c9..c8f4784758 100644 --- a/src/query/engine/plan.rs +++ b/src/query/engine/plan.rs @@ -149,6 +149,22 @@ pub(crate) enum Grouping { Ordered, } +/// The comparator of a certified partition prefix. DICT ids prove adjacency, +/// not semantic UUID or keyword order. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum PartitionOrder { + Values, + Entity, + Ident, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum WindowMode { + Full, + Candidate(usize), + Partitioned { slot: usize, order: PartitionOrder }, +} + /// A clause after the scan, in the executor's order. #[derive(Debug, Clone)] pub(crate) enum Step { @@ -197,6 +213,7 @@ pub(crate) enum Step { find: Vec, named: Vec, keep: Vec, + mode: WindowMode, }, /// After the last step: the `:find` columns at slots `cols`, sorted by /// `order`, `(column of cols, descending)` (the full order), holding at @@ -556,10 +573,25 @@ fn plan_with(query: &DatalogQuery, evaluated: Option>) -> Result< slot(var) } }; - let named = named_vars(&query.find) - .iter() - .map(column) - .collect::>>()?; + let names = named_vars(&query.find); + let named = names.iter().map(column).collect::>>()?; + let mode = if aggregate { + WindowMode::Full + } else { + let mut windows = query.find.iter().filter_map(|f| match f { + FindSpec::Window(w) => Some(w), + _ => None, + }); + windows + .next() + .and_then(|w| w.partition_by.as_ref()) + .filter(|part| windows.all(|w| w.partition_by.as_ref() == Some(*part))) + .and_then(|part| names.iter().position(|name| name == part)) + .and_then(|at| named.get(at)) + .copied() + .map(WindowMode::Candidate) + .unwrap_or(WindowMode::Full) + }; let keep: Vec = cols.iter().flatten().copied().collect(); let (mut next_kept, mut next_window) = (0, keep.len()); for c in &cols { @@ -575,6 +607,7 @@ fn plan_with(query: &DatalogQuery, evaluated: Option>) -> Result< find: query.find.clone(), named, keep, + mode, }); } else { find = cols @@ -1386,7 +1419,7 @@ impl Builder { /// Deferred `not`s, cheapest first when reordering, as on the executor. fn sorted(mut deferred: Vec) -> Vec { if optimizer::reorder() { - deferred.sort_by_key(optimizer::clause_cost); + optimizer::sort_by_cost(&mut deferred, false); } deferred } diff --git a/src/query/engine/tests.rs b/src/query/engine/tests.rs index a145dd85ca..4b707db6fd 100644 --- a/src/query/engine/tests.rs +++ b/src/query/engine/tests.rs @@ -3639,3 +3639,54 @@ fn ordered_distinct_member_reservation_failure_releases_an_unfinished_group() { op.close(); assert_eq!(meter.used(), 0); } + +#[test] +fn partition_window_rejects_decreasing_boundaries_before_and_after_output() { + use super::{ + Operator, + cell::{Cell, Scalar}, + plan::PartitionOrder, + }; + use crate::query::datalog::{parser::parse_datalog_command, types::DatalogCommand}; + let DatalogCommand::Query(q) = parse_datalog_command( + "(query [:find ?g (row-number :over (:partition-by ?g :order-by ?g)) :where [?e :key ?g]])", + ) + .unwrap() else { + panic!("query"); + }; + let int = |n| Cell::Val(Scalar::Int(n)); + for (cells, late) in [ + (vec![int(2), int(1)], false), + (vec![int(1), int(2), int(1)], false), + (vec![Cell::Val(Scalar::Float(1.5)), int(1)], false), + ( + (0..2 * super::BATCH_ROWS as i64) + .map(int) + .chain([int(0)]) + .collect(), + true, + ), + ] { + let meter = super::Meter::unlimited(); + let mut op = super::window::Window::new( + Box::new(Sequence { cells, at: 0 }), + q.find.clone(), + vec![0], + vec![0], + Some((0, PartitionOrder::Values)), + &meter, + ); + let mut batches = 0; + let err = loop { + match pull_once(&mut op, &meter) { + Ok(Some(_)) => batches += 1, + Ok(None) => panic!("invalid partition order must fail"), + Err(e) => break e, + } + }; + assert_eq!(crate::MinigrafError::from(err).code(), "INT-032"); + assert_eq!(batches > 0, late); + op.close(); + assert_eq!(meter.used(), 0); + } +} diff --git a/src/query/engine/window.rs b/src/query/engine/window.rs index 150b401ab6..9c053e3550 100644 --- a/src/query/engine/window.rs +++ b/src/query/engine/window.rs @@ -6,13 +6,18 @@ //! named variables (spec §2), which the windows sort and partition by and //! accumulate. When the input ends, the values come from //! [`windows`](crate::query::datalog::aggregate::windows), the code the -//! executor runs. +//! executor runs. Snapshot-certified input instead completes one partition +//! at a time, with a charged lookahead batch. Completed partitions share a +//! passing output batch; input-batch boundaries stop unnecessary lookahead +//! when output is already available (#641). use super::batch::Batch; -use super::cell::{Cell, Scalar}; +use super::cell::{Cell, JoinKey, Scalar}; use super::meter::{Held, Meter, cell_bytes, growth, row_bytes, value_bytes}; +use super::plan::PartitionOrder; use super::project::value; use super::{BATCH_ROWS, Counters, Ctx, Operator}; +use crate::error::{ErrorCode, err_coded}; use crate::graph::types::Value; use crate::query::datalog::aggregate::{WindowColumn, WindowColumnMeter, windows}; use crate::query::datalog::types::FindSpec; @@ -21,6 +26,11 @@ use std::collections::TryReserveError; use std::mem::size_of; use std::sync::Arc; +#[cfg(test)] +thread_local! { + pub(super) static PARTITION_MAX_ROWS: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + pub(crate) struct Window { child: Box, find: Vec, @@ -28,11 +38,19 @@ pub(crate) struct Window { named: Vec, /// The slots passed on, before the windows' columns. keep: Vec, + /// A snapshot-certified partition key and its physical comparator. + partition: Option<(usize, PartitionOrder)>, + input: Option, + at: usize, + key: Option, + ended: bool, + /// Retained lookahead and the current scalar/id key. + held_input: Held, /// Each input row's cells at `keep`, in input order. cells: Vec>, /// Each input row's values of the named variables. values: Vec>, - /// The finished rows, last first, once the input has ended. + /// Finished rows, last first, for one partition or the full input. out: Option>>, /// `cells`, then the finished rows, released as they are returned /// (#549 spec §3.2). @@ -50,52 +68,174 @@ impl Window { find: Vec, named: Vec, keep: Vec, + partition: Option<(usize, PartitionOrder)>, meter: &Arc, ) -> Self { + #[cfg(test)] + if partition.is_some() { + PARTITION_MAX_ROWS.with(|n| n.set(0)); + } Window { child, find, named, keep, + partition, + input: None, + at: 0, + key: None, + ended: false, + held_input: Held::new(meter, "Window"), cells: Vec::new(), values: Vec::new(), out: None, held: Held::new(meter, "Window"), held_values: Held::new(meter, "Window"), held_columns: Held::new(meter, "Window"), - counters: Counters::new("Window"), + counters: Counters::new(if partition.is_some() { + "WindowPartitioned" + } else { + "Window" + }), } } /// Hold each row of `batch`. fn take(&mut self, batch: &Batch, ctx: &mut Ctx<'_>) -> Result<()> { - let null = Cell::Val(Scalar::Null); - // A slot a row lacks reads `nil`, as a missing binding does on the - // executor. - let cell = - |slot: usize, i: usize| batch.cols.get(slot).and_then(|c| c.get(i)).unwrap_or(&null); for i in 0..batch.len { - let cells: Vec = self.keep.iter().map(|&s| cell(s, i).clone()).collect(); - let n = row_bytes(&cells); - self.held.charge(n)?; - let refused = growth(self.cells.capacity(), size_of::>()); - self.held.reserve(self.cells.try_reserve(1), n, refused)?; - let values = self - .named - .iter() - .map(|&s| value(cell(s, i), ctx)) - .collect::>>()?; - let v = size_of::>() + values.iter().map(value_bytes).sum::(); - self.held_values.charge(v)?; - let refused = growth(self.values.capacity(), size_of::>()); - self.held_values - .reserve(self.values.try_reserve(1), v, refused)?; - self.cells.push(cells); - self.values.push(values); + self.take_row(batch, i, ctx)?; + } + Ok(()) + } + + fn take_row(&mut self, batch: &Batch, i: usize, ctx: &mut Ctx<'_>) -> Result<()> { + let null = Cell::Val(Scalar::Null); + let cell = |slot: usize| batch.cols.get(slot).and_then(|c| c.get(i)).unwrap_or(&null); + let cells: Vec = self.keep.iter().map(|&s| cell(s).clone()).collect(); + let n = row_bytes(&cells); + self.held.charge(n)?; + let refused = growth(self.cells.capacity(), size_of::>()); + self.held.reserve(self.cells.try_reserve(1), n, refused)?; + let values = self + .named + .iter() + .map(|&s| value(cell(s), ctx)) + .collect::>>()?; + let v = size_of::>() + values.iter().map(value_bytes).sum::(); + self.held_values.charge(v)?; + let refused = growth(self.values.capacity(), size_of::>()); + self.held_values + .reserve(self.values.try_reserve(1), v, refused)?; + self.cells.push(cells); + self.values.push(values); + #[cfg(test)] + if self.partition.is_some() { + PARTITION_MAX_ROWS.with(|n| n.set(n.get().max(self.cells.len()))); } Ok(()) } + fn input_bytes(batch: &Batch) -> usize { + size_of::() + + batch.cols.len() * size_of::>() + + batch.cols.iter().flatten().map(cell_bytes).sum::() + } + + fn release_key(&mut self) { + if let Some(key) = self.key.take() { + self.held_input.uncharge(cell_bytes(&key)); + } + } + + fn increasing( + order: PartitionOrder, + previous: &Cell, + next: &Cell, + ctx: &mut Ctx<'_>, + ) -> Result { + Ok(match (order, previous, next) { + (PartitionOrder::Entity, Cell::Eid(a), Cell::Eid(b)) => b > a, + (PartitionOrder::Ident, Cell::Iid(a), Cell::Iid(b)) => b > a, + (PartitionOrder::Values, a, b) => value(b, ctx)?.cmp(&value(a, ctx)?).is_gt(), + _ => false, + }) + } + + /// Load one complete partition. A boundary row remains in the charged + /// lookahead until this partition's results have all been returned. + fn load_partition( + &mut self, + slot: usize, + order: PartitionOrder, + stop_at_batch_end: bool, + ctx: &mut Ctx<'_>, + ) -> Result { + loop { + let batch = match self.input.take() { + Some(batch) => batch, + None => match self.child.next_batch(ctx)? { + Some(batch) => { + debug_assert!(batch.len <= BATCH_ROWS); + self.held_input.charge(Self::input_bytes(&batch))?; + self.counters.rows_in += batch.len as u64; + batch + } + None => { + self.ended = true; + self.release_key(); + self.out = Some(if self.cells.is_empty() { + Vec::new() + } else { + self.finish(ctx)? + }); + return Ok(true); + } + }, + }; + while self.at < batch.len { + let key = batch + .cols + .get(slot) + .and_then(|c| c.get(self.at)) + .ok_or_else(|| { + err_coded!(ErrorCode::Int032, "window partition key is missing") + })? + .clone(); + if let Some(previous) = &self.key { + if JoinKey::group(previous) != JoinKey::group(&key) { + if !Self::increasing(order, previous, &key, ctx)? { + return Err(err_coded!( + ErrorCode::Int032, + "window partition input is not increasing" + )); + } + self.input = Some(batch); + self.release_key(); + self.out = Some(self.finish(ctx)?); + return Ok(true); + } + } else { + self.held_input.charge(cell_bytes(&key))?; + self.key = Some(key); + } + self.take_row(&batch, self.at, ctx)?; + self.at += 1; + } + let bytes = Self::input_bytes(&batch); + drop(batch); + self.held_input.uncharge(bytes); + self.at = 0; + // DICT ids and value-page references remain valid under the pin. + // Provisional ids survive this eviction. + ctx.ids.end_pull(); + // Already completed rows can be returned without reading another + // child batch just to finish an unneeded later partition. + if stop_at_batch_end { + return Ok(false); + } + } + } + /// Every row, in input order, with its windows' cells. fn finish(&mut self, ctx: &mut Ctx<'_>) -> Result>> { let result = self.finish_rows(ctx); @@ -115,13 +255,22 @@ impl Window { self.held_values.release(); let outer = columns.len() * size_of::(); for column in columns.drain(..) { - for (row, v) in rows.iter_mut().zip(&column.values) { + for (at, (row, v)) in rows.iter_mut().zip(&column.values).enumerate() { let c = Cell::of_value(ctx.ids, ctx.keys, v)?; let n = cell_bytes(&c); self.held.charge(n)?; let refused = growth(row.capacity(), size_of::()); self.held.reserve(row.try_reserve(1), n, refused)?; row.push(c); + if self.partition.is_some() && (at + 1) % BATCH_ROWS == 0 { + ctx.ids.end_pull(); + } + } + // Ref/keyword-valued results can populate the lookup maps again + // even after input ended. Bound those conversions too, and release + // a completed partition before coalescing another into the output. + if self.partition.is_some() { + ctx.ids.end_pull(); } let bytes = column.bytes; drop(column); @@ -136,16 +285,6 @@ impl Window { impl Operator for Window { fn next_batch(&mut self, ctx: &mut Ctx<'_>) -> Result> { - if self.out.is_none() { - while let Some(batch) = self.child.next_batch(ctx)? { - self.counters.rows_in += batch.len as u64; - self.take(&batch, ctx)?; - } - self.out = Some(self.finish(ctx)?); - } - let Some(rows) = self.out.as_mut().filter(|r| !r.is_empty()) else { - return Ok(None); - }; let width = self.keep.len() + self .find @@ -153,17 +292,49 @@ impl Operator for Window { .filter(|s| matches!(s, FindSpec::Window(_))) .count(); let mut batch = Batch::new(width); - while batch.len < BATCH_ROWS - && let Some(row) = rows.pop() - { - self.held.uncharge(row_bytes(&row)); - batch.push(&mut row.into_iter().map(Some).collect::>()); + loop { + if self.out.as_ref().is_none_or(Vec::is_empty) { + if let Some((slot, order)) = self.partition { + self.out = None; + if self.ended || !self.load_partition(slot, order, batch.len > 0, ctx)? { + break; + } + } else if self.out.is_none() { + while let Some(input) = self.child.next_batch(ctx)? { + self.counters.rows_in += input.len as u64; + self.take(&input, ctx)?; + } + self.out = Some(self.finish(ctx)?); + } else { + break; + } + } + let Some(rows) = self.out.as_mut().filter(|r| !r.is_empty()) else { + break; + }; + while batch.len < BATCH_ROWS + && let Some(row) = rows.pop() + { + self.held.uncharge(row_bytes(&row)); + batch.push(&mut row.into_iter().map(Some).collect::>()); + } + if batch.len == BATCH_ROWS || self.partition.is_none() { + break; + } + } + if batch.len == 0 { + return Ok(None); } self.counters.out(&batch); Ok(Some(batch)) } fn rewind(&mut self, seed: &[Cell]) { + self.input = None; + self.at = 0; + self.key = None; + self.ended = false; + self.held_input.release(); self.cells.clear(); self.values.clear(); self.out = None; @@ -174,6 +345,11 @@ impl Operator for Window { } fn close(&mut self) { + self.input = None; + self.key = None; + self.at = 0; + self.ended = true; + self.held_input.release(); self.cells = Vec::new(); self.values = Vec::new(); self.out = Some(Vec::new()); @@ -185,8 +361,10 @@ impl Operator for Window { fn counters(&self, out: &mut Vec) { out.push(Counters { - bytes_held: (self.held.bytes() + self.held_values.bytes() + self.held_columns.bytes()) - as u64, + bytes_held: (self.held.bytes() + + self.held_values.bytes() + + self.held_columns.bytes() + + self.held_input.bytes()) as u64, ..self.counters }); self.child.counters(out); diff --git a/src/query/engine/window_order_tests.rs b/src/query/engine/window_order_tests.rs new file mode 100644 index 0000000000..f8cda340e6 --- /dev/null +++ b/src/query/engine/window_order_tests.rs @@ -0,0 +1,752 @@ +//! Snapshot-certified partition windows compared with the full-input evaluator. +use super::{BATCH_ROWS, Counters}; +use crate::{Minigraf, Value}; +use std::mem::size_of; + +fn fixture(n: usize, size: usize) -> (tempfile::TempDir, Minigraf) { + let dir = tempfile::tempdir().unwrap(); + let db = Minigraf::open(dir.path().join("parts.graph")).unwrap(); + let facts: String = (0..n) + .map(|i| format!("[:e{i} :part {}] [:e{i} :value {}]", i / size, i % 7)) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + (dir, db) +} +fn collect(db: &Minigraf, q: &str) -> (Vec>, Vec, usize) { + let mut cursor = db.query(&format!("(query {q})")).unwrap(); + let stream = cursor.stream_mut().unwrap(); + let meter = stream.meter().clone(); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + assert_eq!(meter.used(), 0); + (rows, stream.counters(), meter.peak()) +} +fn partitioned(c: &[Counters]) -> bool { + c.iter().any(|c| c.op == "WindowPartitioned") +} +fn same(a: &[Vec], b: &[Vec]) -> bool { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| { + a.len() == b.len() + && a.iter().zip(b).all(|(a, b)| match (a, b) { + (Value::Float(a), Value::Float(b)) => a.to_bits() == b.to_bits(), + _ => a == b, + }) + }) +} +fn chosen_avet_oracle(db: &Minigraf, q: &str) -> Vec> { + use crate::query::datalog::{ + functions::FunctionRegistry, parser::parse_datalog_command, types::DatalogCommand, + }; + let DatalogCommand::Query(q) = parse_datalog_command(&format!("(query {q})")).unwrap() else { + panic!("query"); + }; + let mut plan = super::plan(&q).unwrap(); + let super::plan::Source::Scan(spec) = &mut plan.source else { + panic!("scan"); + }; + spec.index = Some(crate::storage::keys::Index::Avet); + let _off = super::order::set_enabled(false); + let mut stream = super::open( + db.snapshot().unwrap(), + plan, + std::sync::Arc::new(FunctionRegistry::with_builtins()), + usize::MAX, + ) + .unwrap(); + assert!(!partitioned(&stream.counters())); + let mut rows = Vec::new(); + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + rows +} + +#[test] +fn compatible_windows_keep_independent_orders_peers_frames_and_neighbors() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let (_dir, db) = fixture(4099, 17); + let q = "[:find ?e ?g ?v (row-number :over (:partition-by ?g :order-by ?v)) \ + (rank :over (:partition-by ?g :order-by ?v)) \ + (sum ?v :over (:partition-by ?g :order-by ?v)) \ + (count ?v :over (:partition-by ?g :order-by ?v)) \ + (min ?v :over (:partition-by ?g :order-by ?v :desc :rows 2 preceding)) \ + (max ?v :over (:partition-by ?g :order-by ?v :rows 0 preceding)) \ + (avg ?v :over (:partition-by ?g :order-by ?e :rows 2 preceding)) \ + (lag ?v :over (:partition-by ?g :order-by ?v)) \ + (lead ?v :over (:partition-by ?g :order-by ?v :desc)) \ + :where [?e :part ?g] [?e :value ?v] :order-by [?g ?e]]"; + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, counters, _) = collect(&db, q); + assert!(partitioned(&counters)); + assert!( + same(&actual, &expected), + "shared evaluator preserves every window column" + ); +} + +#[test] +fn a_window_limit_stops_after_first_partition_and_one_input_batch() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let (_dir, db) = fixture(8192, 17); + let q = "[:find ?e ?g ?v (row-number :over (:partition-by ?g :order-by ?v)) \ + :where [?e :part ?g] [?e :value ?v] :limit 10]"; + let expected = chosen_avet_oracle(&db, q); + let (actual, counters, _) = collect(&db, q); + assert!(partitioned(&counters)); + assert!( + same(&actual, &expected), + "preserve the chosen input's order" + ); + let window = counters + .iter() + .find(|c| c.op == "WindowPartitioned") + .unwrap(); + assert!(window.rows_in <= (17 + BATCH_ROWS) as u64); +} + +#[test] +fn a_fixed_partition_bounds_metered_state_as_total_rows_grow() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let mut peaks = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, 17); + let (rows, counters, peak) = collect( + &db, + "[:find ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]]", + ); + assert_eq!(rows.len(), n); + assert!(partitioned(&counters)); + peaks.push(peak); + } + use super::{ + batch::Batch, + cell::{Cell, Scalar}, + meter::cell_bytes, + }; + let two_batches = 2 + * (std::mem::size_of::() + + 2 * std::mem::size_of::>() + + BATCH_ROWS * (cell_bytes(&Cell::Eid(1)) + cell_bytes(&Cell::Val(Scalar::Int(0))))); + assert!( + peaks[1] <= peaks[0] + two_batches, + "completed partitions and DICT caches are released" + ); +} + +#[test] +fn one_growing_partition_is_an_explicit_linear_control() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let mut peaks = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, n); + let (rows, counters, peak) = collect( + &db, + "[:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]]", + ); + assert_eq!(rows.len(), n); + assert!(partitioned(&counters)); + peaks.push(peak); + } + assert!(peaks[1] > 4 * peaks[0]); +} + +#[test] +fn incompatible_unpartitioned_constant_and_aggregate_queries_keep_full_window() { + let (_dir, db) = fixture(64, 4); + for q in [ + "[:find ?g (row-number :over (:order-by ?v)) :where [?e :part ?g] [?e :value ?v]]", + "[:find ?g (rank :over (:partition-by ?g :order-by ?v)) (row-number :over (:partition-by ?e :order-by ?v)) :where [?e :part ?g] [?e :value ?v]]", + "[:find ?g (count ?e) (row-number :over (:partition-by ?g :order-by ?g)) :where [?e :part ?g]]", + "[:find ?g (row-number :over (:partition-by ?p :order-by ?g)) :where [?e :part ?g] [(+ 0 1) ?p]]", + ] { + assert!(!partitioned(&collect(&db, q).1)); + } +} + +#[test] +fn entity_prefix_preserves_input_order_with_arbitrary_value_arguments() { + let dir = tempfile::tempdir().unwrap(); + let db = Minigraf::open(dir.path().join("entity.graph")).unwrap(); + let facts: String = (0..4099) + .map(|i| format!("[:e{} :value {i}]", i / 17)) + .collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + let long = "x".repeat(100); + db.execute(&format!("(transact [[:e0 :value \"{long}\"] [:e0 :value :k] [:e0 :value nil] [:e0 :value false] [:e0 :value #{{1 :k}}]])")).unwrap(); + db.checkpoint().unwrap(); + let q = "[:find ?e ?v (row-number :over (:partition-by ?e :order-by ?v :desc)) (min ?v :over (:partition-by ?e :order-by ?v)) (lag ?v :over (:partition-by ?e :order-by ?v)) :where [?e :value ?v]]"; + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, counters, _) = collect(&db, q); + assert!( + partitioned(&counters), + "entity adjacency doesn't need semantic value order" + ); + assert!( + same(&actual, &expected), + "the unchanged AEVT scan's physical row order is preserved" + ); +} + +#[test] +fn late_callbacks_and_collect_set_errors_still_fail_before_answers() { + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + let (_dir, db) = fixture(4096, 17); + let calls = Arc::new(AtomicUsize::new(0)); + let seen = calls.clone(); + db.try_register_predicate("late?", move |_| { + if seen.fetch_add(1, Ordering::SeqCst) == 1499 { + Err(crate::UdfError::new("late callback")) + } else { + Ok(true) + } + }) + .unwrap(); + let q = "(query [:find ?g (row-number :over (:partition-by ?g :order-by ?v)) :where [?e :part ?g] [?e :value ?v] [(= (late? ?g) true)] :limit 1])"; + let mut cursor = db.query(q).unwrap(); + assert!(!partitioned(&cursor.stream_mut().unwrap().counters())); + assert_eq!( + cursor + .next_batch(1) + .expect_err("late callback remains visible") + .code(), + "QRY-014" + ); + assert_eq!(calls.load(Ordering::SeqCst), 1500); + db.execute("(transact [[:e4095 :nested #{1}]])").unwrap(); + db.checkpoint().unwrap(); + let q = "(query [:find ?g (row-number :over (:partition-by ?g :order-by ?v)) :where [?e :part ?g] [?e :value ?v] [(collect-set ?e :nested) ?s] :limit 1])"; + assert_eq!( + db.execute(q) + .expect_err("late nested set remains visible") + .code(), + "QRY-015" + ); +} + +#[test] +fn pending_scope_and_prepared_cursors_choose_fresh_strategies() { + let (_dir, db) = fixture(64, 4); + let q = "[:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g] :order-by [?g ?e]]"; + let prepared = db.prepare(&format!("(query {q})")).unwrap(); + let mut old = prepared.query(&[]).unwrap(); + assert!(partitioned(&old.stream_mut().unwrap().counters())); + let expected = collect(&db, q).0; + db.execute("(transact [[:outside :other 1]])").unwrap(); + assert!(partitioned(&collect(&db, q).1)); + db.execute("(transact [[:new :part -1]])").unwrap(); + let mut fresh = prepared.query(&[]).unwrap(); + assert!(!partitioned(&fresh.stream_mut().unwrap().counters())); + drop(fresh); + db.checkpoint().unwrap(); + let mut rows = Vec::new(); + while let Some(batch) = old.next_batch(3).unwrap() { + rows.extend(batch); + } + assert!( + same(&rows, &expected), + "pinned partition cursor survives checkpoint and reuse" + ); + let mut fresh = prepared.query(&[]).unwrap(); + assert!(partitioned(&fresh.stream_mut().unwrap().counters())); +} + +#[test] +fn close_drop_and_rewind_release_partition_lookahead_and_results() { + let (_dir, db) = fixture(4099, 17); + let q = "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]])"; + for close in [false, true] { + let mut cursor = db.query(q).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + let first = stream.next_rows().unwrap().unwrap(); + assert!(meter.used() > 0); + stream.root.rewind(&[]); + stream.ids.end_pull(); + assert_eq!(meter.used(), 0); + assert!(same(&first, &stream.next_rows().unwrap().unwrap())); + if close { + cursor.close(); + } else { + drop(cursor); + } + assert_eq!(meter.used(), 0); + } +} + +#[test] +fn small_budget_streams_fixed_partitions_and_full_fallback_refuses() { + let (dir, db) = fixture(4096, 17); + drop(db); + let db = crate::OpenOptions::new() + .query_memory_limit(128 << 10) + .path(dir.path().join("parts.graph")) + .open() + .unwrap(); + let q = "[:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]]"; + let (rows, counters, _) = collect(&db, q); + assert_eq!(rows.len(), 4096); + assert!(partitioned(&counters)); + let _off = super::order::set_enabled(false); + assert_eq!( + db.execute(&format!("(query {q})")) + .expect_err("full window exceeds budget") + .code(), + "QRY-012" + ); +} + +#[test] +fn id_value_prefixes_partition_without_becoming_semantic_group_orders() { + let (_dir, db) = fixture(64, 4); + let long = "x".repeat(100); + let facts:String=(0..64).map(|i|{ + let keyword=if i%2==0 {":z"}else{":a"}; + let id=if i%2==0 {2}else{1}; + format!("[:e{i} :kwpart {keyword}] [:e{i} :refpart #uuid \"00000000-0000-0000-0000-{id:012}\"] [:e{i} :boolpart {}] [:e{i} :longpart \"{long}{}\"] [:e{i} :setpart #{{{}}}]",i%2==0,i%2,i%2) + }).collect(); + db.execute(&format!("(transact [{facts}])")).unwrap(); + db.checkpoint().unwrap(); + for (attribute, expected_mode) in [ + ("kwpart", true), + ("refpart", true), + ("boolpart", true), + ("longpart", false), + ("setpart", false), + ] { + let q = format!( + "[:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :{attribute} ?g] :order-by [?g ?e]]" + ); + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters, _) = collect(&db, &q); + assert_eq!(partitioned(&counters), expected_mode); + assert!(same(&actual, &expected)); + if ["kwpart", "refpart"].contains(&attribute) { + let q = format!("[:find ?g (count ?e) :where [?e :{attribute} ?g]]"); + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters, _) = collect(&db, &q); + assert!(counters.iter().all(|c| c.op != "AggregateOrdered")); + assert!( + same(&actual, &expected), + "Hash Aggregate still emits semantic Value::Ord groups" + ); + } + } +} + +#[test] +fn registered_window_callbacks_keep_full_evaluation_under_limit() { + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let (_dir, db) = fixture(4096, 17); + let calls = Arc::new(AtomicUsize::new(0)); + let seen = calls.clone(); + db.try_register_aggregate( + "late-window", + || Ok(0i64), + move |acc: &mut i64, _| { + if seen.fetch_add(1, Ordering::SeqCst) == 1499 { + return Err(crate::UdfError::new("late window callback")); + } + *acc += 1; + Ok(()) + }, + |acc: &i64, _| Ok(Value::Integer(*acc)), + ) + .unwrap(); + let q = "(query [:find ?g (late-window ?v :over (:partition-by ?g :order-by ?v)) :where [?e :part ?g] [?e :value ?v] :limit 1])"; + let mut cursor = db.query(q).unwrap(); + assert!(!partitioned(&cursor.stream_mut().unwrap().counters())); + assert_eq!( + cursor + .next_batch(1) + .expect_err("must reach the late window callback") + .code(), + "QRY-014" + ); + assert_eq!(calls.load(Ordering::SeqCst), 1500); +} + +#[test] +fn empty_committed_history_and_literal_ranges_keep_their_contracts() { + let (_dir, db) = fixture(1, 1); + let (_, counters, _) = collect( + &db, + "[:find ?e (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :part 0]]", + ); + assert!( + !partitioned(&counters), + "literal value ranges aren't certified in this delivery" + ); + db.execute("(retract [[:e0 :part 0]])").unwrap(); + db.checkpoint().unwrap(); + let (rows, counters, _) = collect( + &db, + "[:find ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]]", + ); + assert!(rows.is_empty()); + assert!(partitioned(&counters)); +} + +#[test] +fn lookahead_is_charged_once_and_released_with_the_partition_cursor() { + use super::{ + batch::Batch, + cell::{Cell, Scalar}, + meter::{cell_bytes, row_bytes}, + }; + let (_dir, db) = fixture(4099, 1500); + let mut cursor=db.query("(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]])").unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + assert_eq!(stream.next_rows().unwrap().unwrap().len(), BATCH_ROWS); + let charged = size_of::() + + 2 * size_of::>() + + BATCH_ROWS * (cell_bytes(&Cell::Eid(1)) + cell_bytes(&Cell::Val(Scalar::Int(0)))); + let charged = charged + + (1500 - BATCH_ROWS) + * row_bytes(&[ + Cell::Eid(1), + Cell::Val(Scalar::Int(0)), + Cell::Val(Scalar::Int(1)), + ]); + let window = stream + .counters() + .into_iter() + .find(|c| c.op == "WindowPartitioned") + .unwrap(); + assert_eq!( + window.bytes_held, charged as u64, + "lookahead plus remaining results of one partition" + ); + assert_eq!( + meter.used(), + charged, + "outer pull evicts committed lookup maps" + ); + super::window::PARTITION_MAX_ROWS.with(|n| assert_eq!(n.get(), 1500)); + stream.close(); + assert_eq!(meter.used(), 0); +} + +#[test] +fn one_partition_spanning_many_batches_evicts_dict_lookups_internally() { + let mut ids = Vec::new(); + let mut windows = Vec::new(); + for n in [1024, 16384] { + let (_dir, db) = fixture(n, n); + let mut cursor=db.query("(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) (lag ?e :over (:partition-by ?g :order-by ?e)) (lead ?e :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]])").unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + let mut rows = 0; + while let Some(batch) = stream.next_rows().unwrap() { + rows += batch.len(); + } + assert_eq!(rows, n); + assert_eq!(meter.used(), 0); + assert!( + meter.peak_for("IdSpace") > 0, + "the fixture actually resolves UUIDs" + ); + ids.push(meter.peak_for("IdSpace")); + windows.push(meter.peak_for("Window")); + } + assert!( + windows[1] > 4 * windows[0], + "one growing partition remains linear" + ); + // Projection can resolve three unrelated references per output row: + // input EID order differs from the UUID order used by lag/lead. The + // 1024-row control has only 1024 distinct entities; the larger partition + // can therefore reach a higher, still one-output-batch lookup peak. + let eid_entry = 2 + * (size_of::() + + size_of::() + + super::meter::HASH_ENTRY_OVERHEAD); + for peak in ids { + assert!( + peak <= 3 * BATCH_ROWS * eid_entry, + "internal window stages must not retain all DICT lookups" + ); + } +} + +#[test] +fn partition_budget_and_allocator_errors_release_every_holder() { + let (dir, db) = fixture(4096, 4096); + drop(db); + let db = crate::OpenOptions::new() + .query_memory_limit(128 << 10) + .path(dir.path().join("parts.graph")) + .open() + .unwrap(); + let q = "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g]])"; + let mut cursor = db.query(q).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + assert_eq!( + crate::MinigrafError::from( + stream + .next_rows() + .expect_err("growing partition exceeds budget") + ) + .code(), + "QRY-012" + ); + assert_eq!(meter.used(), 0); + let (_dir, db) = fixture(64, 4); + let mut cursor = db.query(q).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + super::meter::FAIL_RESERVE.with(|f| f.set(Some("Window"))); + let result = stream.next_rows(); + super::meter::FAIL_RESERVE.with(|f| f.set(None)); + assert_eq!( + crate::MinigrafError::from(result.expect_err("allocator refusal")).code(), + "QRY-012" + ); + assert_eq!(meter.used(), 0); +} + +#[test] +fn working_reader_proofs_track_finished_and_rejected_statements() { + fn rows(result: crate::QueryResult) -> Vec> { + let crate::QueryResult::QueryResults { results, .. } = result else { + panic!("rows"); + }; + results + } + let dir = tempfile::tempdir().unwrap(); + let db = crate::OpenOptions::new() + .transaction_chunk_facts(2) + .path(dir.path().join("working.graph")) + .open() + .unwrap(); + db.execute("(transact [[:a :part 0] [:b :part 2]])") + .unwrap(); + db.checkpoint().unwrap(); + let q = "(query [:find ?e ?g (row-number :over (:partition-by ?g :order-by ?e)) :where [?e :part ?g] :order-by [?g ?e]])"; + let proofs = || super::order::OPTIMIZATIONS.with(std::cell::Cell::get); + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:staged :part -1]])").unwrap(); + let before = proofs(); + tx.execute(q).unwrap(); + assert_eq!(proofs(), before, "staged source stays full"); + drop(tx); + let mut tx = db.begin_write().unwrap(); + tx.execute("(transact [[:new :part -1] [:x :other 1] [:y :other 2]])") + .unwrap(); + let before = proofs(); + let expected = { + let _off = super::order::set_enabled(false); + rows(tx.execute(q).unwrap()) + }; + assert!(same(&rows(tx.execute(q).unwrap()), &expected)); + assert_eq!(proofs(), before + 1, "working integer roots partition"); + let err=tx.execute("(transact [[:bad :part \"rolled back\"] [:dup :other 1 {:valid-from \"2020-01-01\"}] [:fill :other 2] [:dup :other 1 {:valid-from \"2021-01-01\"}]])").expect_err("two windows for one triple"); + assert_eq!(err.code(), "API-011"); + assert!(same(&rows(tx.execute(q).unwrap()), &expected)); + assert_eq!( + proofs(), + before + 2, + "rejected statement restores proof roots" + ); + tx.execute("(transact [[:mixed :part \"string\"]])") + .unwrap(); + let expected = { + let _off = super::order::set_enabled(false); + rows(tx.execute(q).unwrap()) + }; + assert!(same(&rows(tx.execute(q).unwrap()), &expected)); + assert_eq!( + proofs(), + before + 2, + "working mixed strings disable value certificate" + ); + drop(tx); + assert!(partitioned( + &collect( + &db, + q.strip_prefix("(query ") + .unwrap() + .strip_suffix(')') + .unwrap() + ) + .1 + )); +} + +/// Query-only meter diagnostic over separately built committed fixtures. +#[test] +#[ignore] +fn committed_window_memory_probe() { + let path = std::env::var("MINIGRAF_GROUP_FIXTURE").expect("fixture path"); + let n: usize = std::env::var("MINIGRAF_GROUP_ROWS") + .unwrap() + .parse() + .unwrap(); + let size: usize = std::env::var("MINIGRAF_GROUP_SIZE") + .unwrap() + .parse() + .unwrap(); + let db = crate::OpenOptions::new() + .read_only(true) + .path(path) + .open() + .unwrap(); + for (mode, partition, limited) in [ + ("value", "?g", false), + ("value_limit", "?g", true), + ("entity", "?e", false), + ("entity_limit", "?e", true), + ] { + if size == n && partition == "?e" { + continue; + } + let q = format!( + "(query [:find ?e ?g (row-number :over (:partition-by {partition} :order-by ?e)) :where [?e :group ?g] {}])", + if limited { ":limit 10" } else { "" } + ); + let mut cursor = db.query(&q).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let meter = stream.meter().clone(); + let mut rows = 0; + while let Some(batch) = stream.next_rows().unwrap() { + rows += batch.len(); + } + assert_eq!(rows, if limited { 10.min(n) } else { n }); + assert_eq!(meter.used(), 0); + let max_rows = super::window::PARTITION_MAX_ROWS.with(|n| n.get()); + let expected = if partition == "?e" { 1 } else { size }; + assert_eq!(max_rows, expected.min(n)); + let input = stream + .counters() + .into_iter() + .find(|c| c.op == "WindowPartitioned") + .unwrap() + .rows_in; + if limited { + assert!(input <= (10usize.max(expected) + BATCH_ROWS) as u64); + } + use super::{ + batch::Batch, + cell::{Cell, Scalar}, + meter::cell_bytes, + }; + let two_batches = 2 + * (size_of::() + + 2 * size_of::>() + + BATCH_ROWS + * (cell_bytes(&Cell::Eid(1)) + cell_bytes(&Cell::Val(Scalar::Int(0))))); + println!( + "{{\"mode\":\"{mode}\",\"facts\":{n},\"fixture_group_size\":{size},\"rows\":{rows},\"total_peak_bytes\":{},\"window_peak_bytes\":{},\"id_peak_bytes\":{},\"max_partition_rows\":{max_rows},\"input_rows\":{input},\"two_batch_allowance_bytes\":{two_batches}}}", + meter.peak(), + meter.peak_for("Window"), + meter.peak_for("IdSpace") + ); + } +} + +#[test] +fn many_single_row_partitions_fill_a_bounded_output_batch() { + let (_dir, db) = fixture(4099, 1); + let q = "[:find ?e ?g (row-number :over (:partition-by ?e :order-by ?g)) :where [?e :part ?g]]"; + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let mut cursor = db.query(&format!("(query {q})")).unwrap(); + let stream = cursor.stream_mut().unwrap(); + assert!(partitioned(&stream.counters())); + let first = stream.next_rows().unwrap().unwrap(); + assert!( + first.len() >= BATCH_ROWS - 1 && first.len() <= BATCH_ROWS, + "small partitions should share a passing output batch" + ); + let mut rows = first; + while let Some(batch) = stream.next_rows().unwrap() { + rows.extend(batch); + } + assert!(same(&rows, &expected)); +} + +#[test] +fn partitions_on_and_across_input_batch_edges_match_full_evaluation() { + let _text_order = crate::query::datalog::optimizer::set_reorder(false); + for size in [16, BATCH_ROWS - 1, BATCH_ROWS, BATCH_ROWS + 1] { + let (_dir, db) = fixture(3 * BATCH_ROWS + 7, size); + let q = "[:find ?e ?g ?v (rank :over (:partition-by ?g :order-by ?v)) (lag ?v :over (:partition-by ?g :order-by ?v)) (sum ?v :over (:partition-by ?g :order-by ?v :rows 2 preceding)) :where [?e :part ?g] [?e :value ?v] :order-by [?g ?e]]"; + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, q) + }; + let (actual, counters, _) = collect(&db, q); + assert!(partitioned(&counters)); + assert!(same(&actual, &expected)); + super::window::PARTITION_MAX_ROWS.with(|n| assert_eq!(n.get(), size)); + } +} + +#[test] +fn selective_eavt_id_partitions_and_absent_attributes_keep_their_contracts() { + let (_dir, db) = fixture(1, 1); + db.execute("(transact [[:one :kw :z] [:one :kw :a] [:one :ref #uuid \"00000000-0000-0000-0000-000000000002\"] [:one :ref #uuid \"00000000-0000-0000-0000-000000000001\"] [:one :idmix :z] [:one :idmix #uuid \"00000000-0000-0000-0000-000000000002\"]])").unwrap(); + db.checkpoint().unwrap(); + for (attribute, mode) in [("kw", true), ("ref", true), ("idmix", false)] { + let q = format!( + "[:find ?g (row-number :over (:partition-by ?g :order-by ?g)) :where [:one :{attribute} ?g]]" + ); + let (expected, _, _) = { + let _off = super::order::set_enabled(false); + collect(&db, &q) + }; + let (actual, counters, _) = collect(&db, &q); + assert_eq!(partitioned(&counters), mode); + assert!(same(&actual, &expected)); + } + let (rows, counters, _) = collect( + &db, + "[:find ?e (row-number :over (:partition-by ?e :order-by ?e)) :where [?e :missing ?v]]", + ); + assert!(rows.is_empty()); + assert!( + partitioned(&counters), + "empty entity prefix needs no value-kind proof" + ); + let (rows, counters, _) = collect( + &db, + "[:find ?g (row-number :over (:partition-by ?g :order-by ?g)) :where [:one :missing ?g]]", + ); + assert!(rows.is_empty()); + assert!( + !partitioned(&counters), + "a value certificate needs the attribute id" + ); +} diff --git a/src/storage/persistent_facts.rs b/src/storage/persistent_facts.rs index e3987663ea..32d842eab1 100644 --- a/src/storage/persistent_facts.rs +++ b/src/storage/persistent_facts.rs @@ -69,6 +69,13 @@ enum Opened { Fresh, } +/// Share one stable sort across legacy-open paths and backend types. Facts +/// from the same transaction retain their original order. +#[inline(never)] +fn sort_facts_by_tx(facts: &mut [Fact]) { + facts.sort_by_key(|f| f.tx_count); +} + impl PersistentFactStorage { /// Open storage on `backend` with no WAL beside it (in-memory and browser /// databases). See [`PersistentFactStorage::open`]. @@ -169,7 +176,7 @@ impl PersistentFactStorage { let max_fact_tx = facts.iter().map(|f| f.tx_count).max().unwrap_or(0); let max_tx = max_fact_tx.max(header.last_checkpointed_tx_count); // Pending facts are kept in tx order (the fact log relies on it). - facts.sort_by_key(|f| f.tx_count); + sort_facts_by_tx(&mut facts); let _ = self.storage.load_facts(facts)?; Ok(MetaPage { last_checkpointed_tx_count: max_tx, @@ -315,7 +322,7 @@ impl PersistentFactStorage { let max_tx = max_fact_tx.max(header.last_checkpointed_tx_count); // Ids are assigned in transaction order (spec §9 step 2). - facts.sort_by_key(|f| f.tx_count); + sort_facts_by_tx(&mut facts); let old_page_count = header.page_count.max(2); let mut alloc = PageAllocator::new(Vec::new(), old_page_count, 1); let encoded = encode(