diff --git a/.github/workflows/binary-size.yml b/.github/workflows/binary-size.yml index a6ea934263..699f4fa705 100644 --- a/.github/workflows/binary-size.yml +++ b/.github/workflows/binary-size.yml @@ -14,16 +14,7 @@ jobs: name: Check release binary size runs-on: ubuntu-latest env: - # 1260 KiB: 1200 KiB (raised from 1 MiB for #277's structured error codes) plus a - # temporary 60 KiB while the streaming engine and the executor both ship (#473; - # 30 KiB more for rule queries on the engine, #548). Back to 1200 KiB when #551 - # removes the executor's query path. See PHILOSOPHY.md §4. - SIZE_LIMIT_BYTES: 1290240 - # Temporarily report-only on v3: #549 left the binary at 1259 of 1260 KiB with - # #549 PR 2, #550 and #551 still to land while both query paths ship. A size over - # the limit is a warning, not a failure. Set back to "fail", with a limit of - # 1228800 (1200 KiB), when #551 removes the executor's query path. - SIZE_GATE: report + SIZE_LIMIT_BYTES: 1228800 # 1200 KiB — raised from 1 MiB for #277's structured error codes; see PHILOSOPHY.md §4 steps: - name: Checkout code uses: actions/checkout@v4 @@ -42,10 +33,6 @@ jobs: LIMIT_KB=$(( SIZE_LIMIT_BYTES / 1024 )) echo "Binary size: ${SIZE_KB} KiB (limit: ${LIMIT_KB} KiB)" if [ "$SIZE" -gt "$SIZE_LIMIT_BYTES" ]; then - if [ "$SIZE_GATE" = "report" ]; then - echo "::warning::binary size ${SIZE_KB} KiB exceeds limit of ${LIMIT_KB} KiB (gate is report-only until #551)" - exit 0 - fi echo "FAIL: binary size ${SIZE_KB} KiB exceeds limit of ${LIMIT_KB} KiB" exit 1 fi diff --git a/.github/workflows/crash-kill.yml b/.github/workflows/crash-kill.yml index d7ad2069d6..4801d95122 100644 --- a/.github/workflows/crash-kill.yml +++ b/.github/workflows/crash-kill.yml @@ -67,7 +67,7 @@ jobs: # v3's large-transaction variant (#550) needs the test hooks; pass # the feature wherever the checked-out Cargo.toml defines it. features="" - if grep -q '^test-oracle = ' Cargo.toml; then features="--features test-oracle"; fi + if grep -q '^test-hooks = ' Cargo.toml; then features="--features test-hooks"; fi echo "crash-kill features: ${features:-(none)}" cargo test $features --test crash_kill_test -- --nocapture 2>&1 | tee crash-kill-output.txt @@ -84,7 +84,7 @@ jobs: echo echo "- Run: $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID" echo "- Commit: $(git rev-parse HEAD)" - echo "- Reproduce: cargo test --test crash_kill_test -- --nocapture (add --features test-oracle where Cargo.toml defines it)" + echo "- Reproduce: cargo test --test crash_kill_test -- --nocapture (add --features test-hooks where Cargo.toml defines it)" echo " (set MINIGRAF_CRASH_KILL_ROUNDS to raise the round count; MINIGRAF_CRASH_KILL_SEED to the printed base seed to replay)" echo echo "## Test output" diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 9d5c700951..a9cf765095 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -44,13 +44,12 @@ jobs: - name: Check docs.rs build run: cargo docs-rs --target ${{ matrix.target }} - # The streaming engine (#473) runs beside the existing executor until #551. - # With this feature every query the engine runs is also run by the executor, - # and a different answer fails the test, so the whole suite (model-based, - # property, golden corpus, integration) checks the engine. - oracle: + # The tests that need the test-only switches: plan independence (#596), + # forced `not`/`or` body forms (#546) and small transaction chunks (#550) + # in the model-based, property and crash tests. + test-hooks: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - name: Run tests with the executor as the engine's oracle - run: cargo test --features test-oracle + - name: Run tests with the test-only switches + run: cargo test --features test-hooks diff --git a/.github/workflows/smoke.yml b/.github/workflows/smoke.yml index 9188ec21c8..748bdc68c7 100644 --- a/.github/workflows/smoke.yml +++ b/.github/workflows/smoke.yml @@ -49,8 +49,7 @@ jobs: RUST_BACKTRACE: 1 # #549 / #575: 1M aggregate groups complete or stop with QRY-012 under a - # limit; a 13-pattern cartesian product streams in a few MiB. Without - # test-oracle: the executor would run out of memory on the product. + # limit; a 13-pattern cartesian product streams in a few MiB. memory-limit-acceptance: name: Query memory limit acceptance runs-on: ubuntu-latest @@ -68,7 +67,7 @@ jobs: RUST_BACKTRACE: 1 # #550: a 1M-fact transact holds at most one chunk of facts and commits as - # a checkpoint; peak RSS is printed. test-oracle: the statement reader's + # a checkpoint; peak RSS is printed. test-hooks: the statement reader's # high-water mark. large-transaction-acceptance: name: Large transaction acceptance @@ -82,6 +81,6 @@ jobs: uses: dtolnay/rust-toolchain@stable - name: Run the acceptance test - run: cargo test --profile bench --features test-oracle --test large_transaction_acceptance_test -- --ignored --nocapture + run: cargo test --profile bench --features test-hooks --test large_transaction_acceptance_test -- --ignored --nocapture env: RUST_BACKTRACE: 1 diff --git a/CHANGELOG.md b/CHANGELOG.md index 96fc60f9da..8cb115d236 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -97,23 +97,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Internal -- **Single-pattern queries run on a new streaming engine** (#473, part 2: #544, first PR). A query whose `:where` is one pattern and whose `:find` holds plain variables now runs on operators that read index keys in batches of 1,024 rows and turn ids into values only for the rows they return (#530, for these queries). A pattern with a constant attribute and value, `[?e :a C]`, reads the AVET range of `C` instead of every fact of the attribute (#518). Measured at 1M facts (#394 envelope, `[?e :name "…"]`): 344 ms → 20 µs and 142 → 3 MiB; an attribute scan of 166,666 rows 577 → 268 ms and 172 → 57 MiB; point and `:as-of` queries 10–30 % faster. Every other query runs on the existing executor as before. Results are unchanged: in tests, every query the engine runs is also run by the executor and the answers must agree, and CI runs the whole suite that way (`test-oracle` feature). +- **Single-pattern queries run on a new streaming engine** (#473, part 2: #544, first PR). A query whose `:where` is one pattern and whose `:find` holds plain variables now runs on operators that read index keys in batches of 1,024 rows and turn ids into values only for the rows they return (#530, for these queries). A pattern with a constant attribute and value, `[?e :a C]`, reads the AVET range of `C` instead of every fact of the attribute (#518). Measured at 1M facts (#394 envelope, `[?e :name "…"]`): 344 ms → 20 µs and 142 → 3 MiB; an attribute scan of 166,666 rows 577 → 268 ms and 172 → 57 MiB; point and `:as-of` queries 10–30 % faster. Every other query runs on the existing executor as before. Results are unchanged: in tests, every query the engine runs is also run by the executor and the answers must agree, and CI ran the whole suite that way until the executor's query path was removed (#551). - **Expressions and pseudo-attributes run on the streaming engine** (#473, part 2: #544, second PR). The engine now also runs expression clauses after its pattern (`[(> ?v 21)]`, `[(+ ?v 1) ?w]`, registered predicates), per-fact pseudo-attribute patterns on the pattern's entity (`:db/valid-from`, `:db/valid-to`, `:db/tx-count`, `:db/tx-id`), and keyword, UUID and float constants in the value position. A constant reads only the AVET ranges it can match: a keyword reads its own range and the range of refs to the entity it names, a UUID reads its ref range and the attribute's keywords, a float reads the attribute's floats. The executor's matching rules are kept (a keyword matches a ref to the entity it names, a UUID matches a keyword that names it, floats match within `f64::EPSILON`), and so are its errors (INT-026, QRY-007). `:db/valid-at`, which the executor matches against every fact of the entity, stays on the executor until joins (#545). - **Cursors stream the queries the engine runs** (#473, part 2: #544, third PR). `Minigraf::query`, `PreparedQuery::query` and `BrowserDb.query` no longer compute the whole answer at open for these queries: the cursor pulls one batch of up to 1,024 rows from the engine's operators when it runs out of rows, and `close` or dropping it stops the work. An attribute scan drained with `next_batch(1000)` holds 7 MiB at 1M and 10M facts (was 58 and 458 MiB) and runs 3–17 % faster (#394 envelope). The answer is still the database as it was when the cursor opened, whatever is written or checkpointed while it is open. A read error that happens after some rows of a `next_batch` call were gathered is returned by the next call, after those rows. No API change. -- **Joins run on the streaming engine** (#473, part 3: #545, second PR). Queries of several patterns with stored attributes, with or without expression clauses, now run on the engine. Patterns run in the planner's order: the first is a scan, and each later one is an `IndexNestedLoopJoin` when its entity is a variable already bound (one entity range per row, committed and pending), or a `HashJoin` otherwise (value and attribute positions, cross products), built on the side with the smaller estimate. Joins follow the executor's rules (#545, first PR): floats are equal by IEEE `==`, a keyword equals a ref to the entity it names, and a variable keeps the value of its first pattern in the `:where` text. Measured at 1M facts (#394 envelope, p50 and peak RSS): `[:p :follows ?f] [?f :name ?n]` 796 ms → 50 µs and 322 → 4 MiB; `[:p :manager ?b] [?s :manager ?b] [?s :name ?n]` 1.67 s → 148 ms and 392–462 → 14 MiB; `[?e :follows ?f] [?f :group 7] [?f :name ?n]` 2.6 s → 1.1 s and 468–480 → 42 MiB. `or`, `not`, rules and aggregates still run on the executor. Results are unchanged (`test-oracle`). -- **Pseudo-attributes across joins and `:db/valid-at` run on the streaming engine** (#473, part 3: #545, third PR). A per-fact pseudo-attribute pattern (`:db/valid-from`, `:db/valid-to`, `:db/tx-count`, `:db/tx-id`) reads the metadata of its source (#594, above): the source's scan or join fills a metadata column from the fact's key, and the pattern binds or checks against it. A `:db/valid-at` pattern joins with every visible fact of its entity, as `[e _ _]` would, with the query's valid time as a column. Measured at 10M facts (#394 envelope, p50 and peak RSS): `[:p :follows ?f] [?f :name ?n] [?f :db/tx-count ?t]` 34 s → 56 µs and 6.0–7.5 GiB → 4 MiB (3.2 s → 56 µs at 1M). Results are unchanged (`test-oracle`). -- **`not` and `not-join` run on the streaming engine** (#473, part 4: #546, first PR). An `AntiJoin` keeps the outer rows for which the body has no row; it never deduplicates. A body that has the same rows for every outer row (its expressions and pseudo-attributes read only variables its own patterns bind) runs once, and its rows' values of the variables it shares with the outer row form a hash set. Any other body, and one whose first pattern's entity comes from the outer row, runs once per outer row from a one-row seed of the values it imports, stopping at its first row: an entity-bound body costs one index probe per row and holds nothing. Bodies are ordered with the imported variables counted as bound. Queries whose negation holds a rule invocation stay on the executor. Measured (#394 envelope, p50 and peak RSS): an entity-bound `not` (`[?e :group 7] (not [?e :age 7])`, run per row) 760 ms → 27 ms and 222 → 6 MiB at 1M facts, 8.7 s → 0.29 s and 1.2 GiB → 6 MiB at 10M; a `not-join` keyed on a value whose body has an expression (`(not-join [?a] [?f :group 17] [?f :age ?a] [(< ?a 50)])`, hashed) 1.29 s → 5.8 ms at 100K, over 60 s → 53 ms and 171 → 7 MiB at 1M, over 60 s → 0.57 s and 1.5 GiB → 9 MiB at 10M. Other workloads unchanged. Results are unchanged (`test-oracle`). -- **Aggregates run on the streaming engine** (#473, part 5: #547, second PR). Queries with aggregates in `:find`, with or without `:with`, now run on the engine when their `:where` does. An `Aggregate` operator keeps one entry per group in a hash table, keyed on the grouping cells as groups compare values, and steps each aggregate as rows arrive: a query with no grouping variable holds one set of accumulators, whatever the input size. `count` reads only whether a cell is `nil` and `count-distinct` keeps the keys of its cells, so neither turns ids into values; other aggregates read values. When the input ends, the groups are sorted by their values, finished in that order and returned in batches. Measured (#394 envelope, p50 and peak RSS): `[:find (count ?v) :where [?e ?a ?v]]` 207 ms → 44 ms and 97 → 7 MiB at 100K facts, 3.01 s → 457 ms and 728 → 7 MiB at 1M, 29.6 s → 4.46 s and 6.6 GiB → 7 MiB at 10M; `[:find ?g (count ?e) :where [?e :group ?g]]` 31 → 5.9 ms at 100K, 397 → 61 ms and 97 → 7 MiB at 1M, 4.51 s → 614 ms and 901 → 7 MiB at 10M. Other workloads unchanged. Results are unchanged apart from the float group value above (`test-oracle`). -- **Window functions run on the streaming engine** (#473, part 5: #547, third PR). Queries with window functions in `:find`, alone or over an aggregate's groups, now run on the engine when their `:where` does. A `Window` operator holds each input row's returned cells and the values of the variables the windows read, then computes every window with the code the executor runs (partitions, the sort, peers) and returns the rows in input order. Measured (#394 envelope, p50 and peak RSS): `[:find ?e (rank :over (:order-by ?a)) :where [?e :age ?a]]` 41.5 → 32.8 ms and 19 → 16 MiB at 100K facts, 601 → 434 ms and 140 → 109 MiB at 1M, 7.89 s → 5.65 s and 1,257 → 1,030 MiB at 10M. A window holds every row by nature, so memory still grows with the input. Other workloads unchanged. Results are unchanged (`test-oracle`). -- **Rule queries run on the streaming engine** (#473, part 6: #548, second PR). A query that invokes a rule, at any depth, now runs on the engine when its body and the body of every rule it evaluates do. Each evaluated predicate has a relation: the facts its rules derive, held as rows of ids, a set (a fact derived twice, or equal to a stored fact, is kept once). `Recursive` derives the relations stratum by stratum before the body runs. Round 1 runs every rule over all facts; each later round runs a rule once per top-level invocation of its own stratum, that invocation reading only the facts the last round derived, so a fact is derived from new facts only (semi-naive). A rule that reads its own stratum otherwise (in an `or` branch, through a `[?x :p ?y]` or `[?x ?a ?v]` pattern, or `:db/valid-at`) runs over all facts every round. Scans read a relation's rows after the committed and pending facts, with `nil` metadata; entity probes use the relation's index. The query body is planned as any engine query, rule invocations read as patterns of their relations. The executor's `FactStorage` copy of the database for each rule query is gone on this path. Queries with an `:as-of` timestamp, or with a rule body the engine does not plan (an expression-only body, a nested `or`) stay on the executor. The binary-size gate on `v3` is 1,260 KiB until #551 removes the executor's query path (it was 1,230 KiB; this adds about 34 KiB). Measured (#394 envelope, executor → engine, p50 and peak RSS at 100K / 1M / 10M facts; `docs/BENCHMARKS.md`): `recursive_ancestors` (`(boss :p ?b)`, 5–7 ancestors through the magic-set rewrite) 2.71 s → 1.45 ms, 43.9 s → 2.14 ms, over 60 s → 3.04 ms, at 4 MiB instead of 253 MiB, 2.6 GiB and over 8.8 GiB; the whole transitive closure (`[:find ?x ?b :where (boss ?x ?b)]`, 72K, 889K and 10.6M derived facts) 3.04 s → 211 ms, 51.0 s → 3.21 s, over 60 s → 53.8 s, and 484 MiB → 45 MiB, 4.7 GiB → 318 MiB, over 8.8 GiB → 2.5 GiB. Other workloads unchanged. Results are unchanged (`test-oracle`). -- **`or` and `or-join` run on the streaming engine** (#473, part 4: #546, second PR). A `Union` extends each outer row by every row of every branch; a `Distinct` then keeps one of each set of equal rows, comparing values as the executor does (`0.0` equals `-0.0`, a keyword never equals a ref, a row holding NaN is never a duplicate). Each branch is planned as a `not` body is: a branch with the same rows for every outer row runs once, into a table of its rows by their values of the variables it shares with the outer row; any other branch, and one whose first pattern's entity comes from the outer row, runs per outer row from a one-row seed. When the branches bind no new variable (every `or-join`, and an `or` that only filters), an outer row is returned once, from the first branch that has a row. A query whose first clause to run is an `or` starts from the empty row. These stay on the executor: a branch with a rule invocation, a nested `or`, or a predicate the function registry may not have; an `or` whose branches bind their own patterns' metadata; and a branch whose `not` reads a variable only the branch's expression binds. Measured (#394 envelope, p50 and peak RSS): an `or-join` of two branches keyed on a value (`[?e :group 7] [?e :age ?a] (or-join [?a] (and [?f :group 17] [?f :age ?a] [(< ?a 30)]) (and [?g :group 27] [?g :age ?a] [(> ?a 60)]))`, both hashed) 111 ms → 8.3 ms at 100K facts, 1.44 s → 80 ms and 306 → 7 MiB at 1M, 17.1 s → 0.86 s and 1.9 GiB → 12 MiB at 10M. Other workloads unchanged. Results are unchanged (`test-oracle`). +- **Joins run on the streaming engine** (#473, part 3: #545, second PR). Queries of several patterns with stored attributes, with or without expression clauses, now run on the engine. Patterns run in the planner's order: the first is a scan, and each later one is an `IndexNestedLoopJoin` when its entity is a variable already bound (one entity range per row, committed and pending), or a `HashJoin` otherwise (value and attribute positions, cross products), built on the side with the smaller estimate. Joins follow the executor's rules (#545, first PR): floats are equal by IEEE `==`, a keyword equals a ref to the entity it names, and a variable keeps the value of its first pattern in the `:where` text. Measured at 1M facts (#394 envelope, p50 and peak RSS): `[:p :follows ?f] [?f :name ?n]` 796 ms → 50 µs and 322 → 4 MiB; `[:p :manager ?b] [?s :manager ?b] [?s :name ?n]` 1.67 s → 148 ms and 392–462 → 14 MiB; `[?e :follows ?f] [?f :group 7] [?f :name ?n]` 2.6 s → 1.1 s and 468–480 → 42 MiB. `or`, `not`, rules and aggregates still run on the executor. Results are unchanged (checked against the executor). +- **Pseudo-attributes across joins and `:db/valid-at` run on the streaming engine** (#473, part 3: #545, third PR). A per-fact pseudo-attribute pattern (`:db/valid-from`, `:db/valid-to`, `:db/tx-count`, `:db/tx-id`) reads the metadata of its source (#594, above): the source's scan or join fills a metadata column from the fact's key, and the pattern binds or checks against it. A `:db/valid-at` pattern joins with every visible fact of its entity, as `[e _ _]` would, with the query's valid time as a column. Measured at 10M facts (#394 envelope, p50 and peak RSS): `[:p :follows ?f] [?f :name ?n] [?f :db/tx-count ?t]` 34 s → 56 µs and 6.0–7.5 GiB → 4 MiB (3.2 s → 56 µs at 1M). Results are unchanged (checked against the executor). +- **`not` and `not-join` run on the streaming engine** (#473, part 4: #546, first PR). An `AntiJoin` keeps the outer rows for which the body has no row; it never deduplicates. A body that has the same rows for every outer row (its expressions and pseudo-attributes read only variables its own patterns bind) runs once, and its rows' values of the variables it shares with the outer row form a hash set. Any other body, and one whose first pattern's entity comes from the outer row, runs once per outer row from a one-row seed of the values it imports, stopping at its first row: an entity-bound body costs one index probe per row and holds nothing. Bodies are ordered with the imported variables counted as bound. Queries whose negation holds a rule invocation stay on the executor. Measured (#394 envelope, p50 and peak RSS): an entity-bound `not` (`[?e :group 7] (not [?e :age 7])`, run per row) 760 ms → 27 ms and 222 → 6 MiB at 1M facts, 8.7 s → 0.29 s and 1.2 GiB → 6 MiB at 10M; a `not-join` keyed on a value whose body has an expression (`(not-join [?a] [?f :group 17] [?f :age ?a] [(< ?a 50)])`, hashed) 1.29 s → 5.8 ms at 100K, over 60 s → 53 ms and 171 → 7 MiB at 1M, over 60 s → 0.57 s and 1.5 GiB → 9 MiB at 10M. Other workloads unchanged. Results are unchanged (checked against the executor). +- **Aggregates run on the streaming engine** (#473, part 5: #547, second PR). Queries with aggregates in `:find`, with or without `:with`, now run on the engine when their `:where` does. An `Aggregate` operator keeps one entry per group in a hash table, keyed on the grouping cells as groups compare values, and steps each aggregate as rows arrive: a query with no grouping variable holds one set of accumulators, whatever the input size. `count` reads only whether a cell is `nil` and `count-distinct` keeps the keys of its cells, so neither turns ids into values; other aggregates read values. When the input ends, the groups are sorted by their values, finished in that order and returned in batches. Measured (#394 envelope, p50 and peak RSS): `[:find (count ?v) :where [?e ?a ?v]]` 207 ms → 44 ms and 97 → 7 MiB at 100K facts, 3.01 s → 457 ms and 728 → 7 MiB at 1M, 29.6 s → 4.46 s and 6.6 GiB → 7 MiB at 10M; `[:find ?g (count ?e) :where [?e :group ?g]]` 31 → 5.9 ms at 100K, 397 → 61 ms and 97 → 7 MiB at 1M, 4.51 s → 614 ms and 901 → 7 MiB at 10M. Other workloads unchanged. Results are unchanged apart from the float group value above (checked against the executor). +- **Window functions run on the streaming engine** (#473, part 5: #547, third PR). Queries with window functions in `:find`, alone or over an aggregate's groups, now run on the engine when their `:where` does. A `Window` operator holds each input row's returned cells and the values of the variables the windows read, then computes every window with the code the executor runs (partitions, the sort, peers) and returns the rows in input order. Measured (#394 envelope, p50 and peak RSS): `[:find ?e (rank :over (:order-by ?a)) :where [?e :age ?a]]` 41.5 → 32.8 ms and 19 → 16 MiB at 100K facts, 601 → 434 ms and 140 → 109 MiB at 1M, 7.89 s → 5.65 s and 1,257 → 1,030 MiB at 10M. A window holds every row by nature, so memory still grows with the input. Other workloads unchanged. Results are unchanged (checked against the executor). +- **Rule queries run on the streaming engine** (#473, part 6: #548, second PR). A query that invokes a rule, at any depth, now runs on the engine when its body and the body of every rule it evaluates do. Each evaluated predicate has a relation: the facts its rules derive, held as rows of ids, a set (a fact derived twice, or equal to a stored fact, is kept once). `Recursive` derives the relations stratum by stratum before the body runs. Round 1 runs every rule over all facts; each later round runs a rule once per top-level invocation of its own stratum, that invocation reading only the facts the last round derived, so a fact is derived from new facts only (semi-naive). A rule that reads its own stratum otherwise (in an `or` branch, through a `[?x :p ?y]` or `[?x ?a ?v]` pattern, or `:db/valid-at`) runs over all facts every round. Scans read a relation's rows after the committed and pending facts, with `nil` metadata; entity probes use the relation's index. The query body is planned as any engine query, rule invocations read as patterns of their relations. The executor's `FactStorage` copy of the database for each rule query is gone on this path. Queries with an `:as-of` timestamp, or with a rule body the engine does not plan (an expression-only body, a nested `or`) stay on the executor. The binary-size gate on `v3` is 1,260 KiB until #551 removes the executor's query path (it was 1,230 KiB; this adds about 34 KiB). Measured (#394 envelope, executor → engine, p50 and peak RSS at 100K / 1M / 10M facts; `docs/BENCHMARKS.md`): `recursive_ancestors` (`(boss :p ?b)`, 5–7 ancestors through the magic-set rewrite) 2.71 s → 1.45 ms, 43.9 s → 2.14 ms, over 60 s → 3.04 ms, at 4 MiB instead of 253 MiB, 2.6 GiB and over 8.8 GiB; the whole transitive closure (`[:find ?x ?b :where (boss ?x ?b)]`, 72K, 889K and 10.6M derived facts) 3.04 s → 211 ms, 51.0 s → 3.21 s, over 60 s → 53.8 s, and 484 MiB → 45 MiB, 4.7 GiB → 318 MiB, over 8.8 GiB → 2.5 GiB. Other workloads unchanged. Results are unchanged (checked against the executor). +- **`or` and `or-join` run on the streaming engine** (#473, part 4: #546, second PR). A `Union` extends each outer row by every row of every branch; a `Distinct` then keeps one of each set of equal rows, comparing values as the executor does (`0.0` equals `-0.0`, a keyword never equals a ref, a row holding NaN is never a duplicate). Each branch is planned as a `not` body is: a branch with the same rows for every outer row runs once, into a table of its rows by their values of the variables it shares with the outer row; any other branch, and one whose first pattern's entity comes from the outer row, runs per outer row from a one-row seed. When the branches bind no new variable (every `or-join`, and an `or` that only filters), an outer row is returned once, from the first branch that has a row. A query whose first clause to run is an `or` starts from the empty row. These stay on the executor: a branch with a rule invocation, a nested `or`, or a predicate the function registry may not have; an `or` whose branches bind their own patterns' metadata; and a branch whose `not` reads a variable only the branch's expression binds. Measured (#394 envelope, p50 and peak RSS): an `or-join` of two branches keyed on a value (`[?e :group 7] [?e :age ?a] (or-join [?a] (and [?f :group 17] [?f :age ?a] [(< ?a 30)]) (and [?g :group 27] [?g :age ?a] [(> ?a 60)]))`, both hashed) 111 ms → 8.3 ms at 100K facts, 1.44 s → 80 ms and 306 → 7 MiB at 1M, 17.1 s → 0.86 s and 1.9 GiB → 12 MiB at 10M. Other workloads unchanged. Results are unchanged (checked against the executor). - **A join with no shared variable builds on the side with the smaller product estimate** (#473, part 7: #549; #575). A `HashJoin` with no join key holds one side in full, and the planner compared the inner pattern with the outer side's cheapest pattern, so a chain of patterns sharing no variable built every later join on the growing outer side (3^(k−1) rows at the k-th join of the #575 fuzz shape). It now compares the inner pattern with the product of the outer patterns' estimates, so such a chain builds on each 3-row inner pattern. Answers do not change; joins with a key are planned as before. - **Committed reads hide superseded history on index keys** (#379). A query's committed facts are now reduced to the ones that survive net-assert (each fact's assertion from its newest transaction, unless that transaction retracted it; #435) while walking the index keys, before any fact is built. Only surviving entries are decoded and translated through the dictionary. A transaction that retracted a triple hides everything older in it, and a long run of hidden entries is skipped with one `seek`. `:as-of N` point and attribute queries now take the same index path instead of reading every fact in the file. On a checkpointed file with 2,000 superseded values, a point query takes 1.03 ms instead of 4.61 ms, an attribute scan 1.24 ms instead of 5.87 ms, and an `:as-of` point query 23 µs instead of 5.6 ms (at depth 1). Results are unchanged: the executor still applies net-assert to committed and pending facts together, and a pending fact is always newer than a committed one. - **B+tree reads no longer follow leaf sibling links** (v8 storage format, PR 1 of 5; #374). Every index scan uses a cursor that walks down from the root and keeps the path, with a forward `seek` that climbs only as far as needed. This prepares for copy-on-write index pages, which cannot keep sibling links. The file format and query results are unchanged. Concurrent 100k-fact scans take 25–37 % less time and checkpointing after one fact at 10k facts 9 % less; single point lookups and attribute scans are 2–6 % slower (about 0.4 µs per lookup). A corrupted child pointer now fails with STG-013 (wrong page type) or INT-049 (cycle) instead of following a bad link. ### Tests -- **Statement bases and large write transactions (#550).** A `WriteTransaction` whose statements repeat, change, retract and re-assert each other's facts across chunks gives every statement the same outcome, and stores the same records, at chunk sizes 1 to 4 as with one chunk; queries after each statement return what a commit of the statements so far would hold; failed and rolled-back statements and transactions leave the file passing `verify`. The fault matrix covers a large `WriteTransaction` at every write and sync, and with `test-oracle` the crash-kill test runs every third transaction of its large variant as one. +- **Statement bases and large write transactions (#550).** A `WriteTransaction` whose statements repeat, change, retract and re-assert each other's facts across chunks gives every statement the same outcome, and stores the same records, at chunk sizes 1 to 4 as with one chunk; queries after each statement return what a commit of the statements so far would hold; failed and rolled-back statements and transactions leave the file passing `verify`. The fault matrix covers a large `WriteTransaction` at every write and sync, and with `test-hooks` the crash-kill test runs every third transaction of its large variant as one. - **Golden-file compatibility corpus (#391).** `tests/golden/` holds v7 files written by minigraf 2.0.3, each with a JSON manifest of its CRC32, `tx_count` and expected query results. They cover one checkpoint, several checkpoints, indexes rebuilt on open, a WAL left by a crash, a WAL whose entries were already checkpointed, and same-transaction multi-values (#371). `tests/golden_corpus_test.rs` opens a copy of each file and checks its manifest after open, after a checkpoint and reopen, and after one more write. Golden files are never regenerated, only added; a new `golden-corpus` job in `policy.yml` fails a pull request that changes one. The generator is a standalone crate pinned to `minigraf = "=2.0.3"` (`tests/golden/gen/v7/`). On `v3`, each v7 file must also carry a v8 meta page after its first open, and seven v8 files are frozen alongside them, written by the `v3` branch at `23aa57c` (`tests/golden/gen/v8/`): one checkpoint, seven copy-on-write checkpoints, a crash-left v2 WAL, an already-checkpointed v2 WAL, same-transaction multi-values, a v7 file migrated in place, and long values (a 4,068-byte string stored twice, the 64/65-byte inline boundary, a 1,000-byte attribute and keyword). All #371 queries now pass. - **Model-based storage test (#385).** `tests/model_based_test.rs` runs random sequences of `transact` (multi-valued batches, transaction- and fact-level valid-time windows, a triple repeated with another window), `retract`, write transactions (committed or rolled back, retracting their own assertions), checkpoints, reopens (default, a 4-page cache, auto-checkpoint every 2 writes) and simulated crashes (a copy of the `.graph` file and WAL taken while the handle is open, so the WAL is replayed) against a file in a temp dir. After every step, `current_tx_count`, `verify`, full rows with windows and tx counts, and entity-, entity+attribute-, attribute-, attribute+value-, value-bound and full-scan queries, under `:as-of N` and `:valid-at T`, must match a plain reference model (one valid-time window per triple, #435; API-011 for two windows of one triple in one statement and API-019 for an empty or inverted window, from `execute` and `tx.execute`, #436; the last statement that writes a triple decides it at commit, #477). Reads inside a write transaction are checked against what its commit will hold. Normal CI runs 24 cases; the nightly property-test workflow runs 30,000. - **SIGKILL crash test checks committed data (#384).** `tests/crash_kill_test.rs` used to check only that the file reopened and one attribute query ran, so it missed #370 and could not reach #371. The child now runs a seeded workload (multi-valued batches, batched retracts, re-assertions) and logs each transaction after `execute` returns; it checkpoints after every transaction, every third, never (WAL replay), automatically every 2 writes, or every third with `SyncMode::Normal`. After a `SIGKILL` at a random point, the reopened file must hold exactly the model after the last logged transaction or the one in flight, through a full scan, attribute (AEVT), attribute+value (AVET) and entity-bound (EAVT) queries and `:as-of`, with `verify` clean. The checks run again after a second reopen and after a checkpoint plus reopen. Per-PR CI runs 5 rounds (one per mode); the nightly crash-kill workflow runs 100 per OS. `MINIGRAF_CRASH_KILL_SEED` replays a failure. @@ -123,11 +123,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - **Coverage gates that gate (#396).** The per-module gate in `coverage-gates.yml` had never checked anything: the instrumented test run failed (the lock tests could not find `pid_ns_helper`), the report it grepped was empty, and every module was skipped with a warning, so the job passed. It also read `cargo llvm-cov --text`, which has no per-file percentages, and named `btree_v6`, which v3 no longer has. The job now runs the whole suite with branch coverage on a pinned nightly, fails if any test fails, and checks each file's line and branch percentage against `coverage-thresholds.toml` with `scripts/coverage_gates.py`; a file missing from the report, or without branch data, fails. The thresholds file covers the WAL, `db.rs`, the fact log and log writer, every storage file, and the evaluator, executor and stratification, with floors at the measured values less one point. It also lists the paths left uncovered on purpose (invariant checks, browser-only and Windows-only paths). New tests cover the WAL's fact-size and fact-count limits (the old fact-size test changed bytes inside the fact and never reached the limit), a WAL opened in a missing directory, a failed cut of a torn WAL tail, short v7 pages and slots past the count, backup meta pages of another generation or length, a torn first meta with data in page 1, `save` with nothing pending, `into_backend` with pending facts, `rebuild_indexes` with nothing checkpointed, unsorted or repeated B+tree input, a stored key inserted with another value, a tree pointer to a page of another type, the read-only `MutexStorageBackend`, and two threads missing the same page in the page cache (before, only a lucky race reached that path). Branch coverage of `wal.rs` went from 83% to 95%, `packed_pages.rs` from 86% to 100%, `persistent_facts.rs` from 82% to 88%, and `btree.rs` from 85% to 85.5%. A follow-up brought the storage files the issue named to 90% branch coverage or more: `btree.rs` to 95.7%, `persistent_facts.rs` to 91.7% and `index.rs` to 100%, with floors raised to match. New tests cover a leaf packing retried around one large entry, an entry larger than a page, separators over the fill target, an insert into a tree whose root points to itself, auto-save on drop, a torn first meta with a blank page 1, and an unreadable page past the meta's page count. Splitting internal nodes is now one pass: the old retry loop could not run, because the balanced cut always leaves each node within the fill target. The workflow pins cargo-llvm-cov 0.9.1, since 0.8.x missed the library's unit tests under the pinned nightly and reported much lower numbers. - **Performance envelope at 100K–10M facts (#394).** `examples/perf_envelope.rs` builds and caches fixtures of 100K, 1M and 10M facts (six attributes per entity, a ref tree, two valid-time windows, an entity with 1,000 versions). It reports open and checkpoint times, RSS, and p50/p99 latency for twelve query shapes, each shape in its own process. It builds with a new `envelope` Cargo profile (`release` at opt-level 3, as an application compiles the library; `release` itself is opt-level "z"). `docs/BENCHMARKS.md` and the README publish the results: point lookups and single-entity time travel stay flat (12–14 µs at 10M facts). Scans, aggregations and joins grow linearly with the attributes they touch. Rule queries are supported to 100K facts only. A Python FFI round trip (`bench/envelope.py` in minigraf-python) adds about 70 µs per query. `.github/workflows/envelope.yml` runs 100K and 1M on demand, and a 10K smoke pass on PRs that change the harness. The nightly Criterion `query/*` groups gain 100K and 1M scales. Profiling at 1M facts found #528, #529, #530, #531 and #532. - **Pseudo-attribute sources (#594).** `tests/pseudo_source_test.rs` covers the source rule (nearest earlier pattern in the text, two pseudo-attributes sharing one, every fact through `[?e ?a _]`, constants by entity id, `$slot`s by name), `PRS-081` for each shape with no source, reading the outer fact from `not`, `not-join` (listed and unlisted variable), `or` (never a sibling branch) and `or-join`, closed rule bodies, and `:db/valid-at`. Parser, optimizer and matcher unit tests cover the hidden variables, their placement and the join variables a crossed `not-join` gains. The plan-independence matrix gains the pseudo-attribute shapes. -- **Answers that depend on the plan fail the tests (#596).** A test-only switch (`minigraf::__reorder`, `test-oracle` feature) turns off every place the native build reorders: the pattern selectivity sort, the `not`/`not-join` and `or`/`or-join` cost sorts and the `or` short-circuits (#250), and the engine's `HashJoin` build side. `tests/plan_independence_test.rs` runs a matrix of queries (joins, expressions, rules, `or`/`or-join`, `not`/`not-join`, keyword and ref, floats, long strings, aggregates, time travel), in memory and on file, through `execute` and a cursor, with the switch on and off, and requires the same rows. Under `test-oracle` the model-based (#385) and property (#386) tests also run every generated query with the switch off. -- **Rule queries on the engine (#548).** `tests/recursive_engine_test.rs` (10 tests) runs rule queries in memory, on a file with pending facts and after a checkpoint, and under `test-oracle` against the executor: transitive closure (linear and non-linear), mutual recursion, strata whose `not` and `or` rules recurse, rules that read their stratum outside a top-level invocation, derived facts seen by every pattern, the identity of derived facts, `nil` metadata, heads, both `INT-020` limits, and rule queries with aggregates, `not-join`, `or` and windows. Every existing rule suite (`recursive_rules_test`, `negation_test`, `disjunction_test`, `magic_sets_test`, the model-based and property tests) now runs its rule queries on the engine with the oracle. Engine unit tests cover routing and derived rows read across batches. +- **Answers that depend on the plan fail the tests (#596).** A test-only switch (`minigraf::__reorder`, `test-hooks` feature) turns off every place the native build reorders: the pattern selectivity sort, the `not`/`not-join` and `or`/`or-join` cost sorts and the `or` short-circuits (#250), and the engine's `HashJoin` build side. `tests/plan_independence_test.rs` runs a matrix of queries (joins, expressions, rules, `or`/`or-join`, `not`/`not-join`, keyword and ref, floats, long strings, aggregates, time travel), in memory and on file, through `execute` and a cursor, with the switch on and off, and requires the same rows. Under `test-hooks` the model-based (#385) and property (#386) tests also run every generated query with the switch off. +- **Rule queries on the engine (#548).** `tests/recursive_engine_test.rs` (10 tests) runs rule queries in memory, on a file with pending facts and after a checkpoint, checked against the executor until #551 and against its recorded answers since: transitive closure (linear and non-linear), mutual recursion, strata whose `not` and `or` rules recurse, rules that read their stratum outside a top-level invocation, derived facts seen by every pattern, the identity of derived facts, `nil` metadata, heads, both `INT-020` limits, and rule queries with aggregates, `not-join`, `or` and windows. Every existing rule suite (`recursive_rules_test`, `negation_test`, `disjunction_test`, `magic_sets_test`, the model-based and property tests) now runs its rule queries on the engine with the oracle. Engine unit tests cover routing and derived rows read across batches. - **Recursive rules at 5M derived facts (#473 acceptance, #548).** `tests/recursive_acceptance_test.rs` (ignored; the nightly smoke workflow runs it) derives 4,882,500 `reach` facts in 62 rounds over a layered graph of 155,000 edges and checks that every one is returned and that the query's peak RSS stays under 256 bytes per derived fact (169 measured); the default `max_derived_facts` then stops the same rule with `INT-020`. The #394 envelope has a `recursive` shape: the whole transitive closure of `:manager`, with no constant, so no magic sets. -- **Query memory at 1M groups and on the #575 product (#549).** `tests/memory_limit_acceptance_test.rs` (ignored; the nightly smoke workflow runs it without `test-oracle`) returns 1M aggregate groups, or `QRY-012` naming `Aggregate` under a 32 MiB limit, and streams the 1.6M rows of 13 patterns sharing no variable over the fuzz harness's 3 facts in under 64 MiB of peak RSS (the executor held more than 5.7 GB), or `QRY-012` naming `HashJoin` under a 64-byte limit. An ignored engine test prints the meter's peak against the peak RSS: 435 MiB against about 545 MiB for the groups (`docs/BENCHMARKS.md`). Measuring it found `Aggregate`'s sorted map of groups uncharged while its hash table was still held; the map is now charged and the table freed first, which lowered the real peak from 651 MiB. -- **Negation bodies in both forms (#546).** A second test-only switch (`minigraf::__subplans`, `test-oracle` feature) forces the engine's `not` / `not-join` bodies to run hashed or correlated. `tests/plan_independence_test.rs` runs every query with the body forms chosen, forced hashed and forced correlated, each with reordering on and off; its matrix gains negations over floats near zero, `0.0` and `-0.0`, keywords and refs of one entity, long strings, bodies reading an imported variable they do not bind, variable-free bodies and `:db/valid-at`. `tests/negation_equality_test.rs` checks the changed answers on every executor path, in memory and after a checkpoint. The property test's rerun also forces hashed bodies. Engine unit tests cover the form the planner picks, routing, multiplicity, failing expressions in bodies, and that a hashed body is read once and a correlated one probes once per row. +- **Query memory at 1M groups and on the #575 product (#549).** `tests/memory_limit_acceptance_test.rs` (ignored; the nightly smoke workflow runs it) returns 1M aggregate groups, or `QRY-012` naming `Aggregate` under a 32 MiB limit, and streams the 1.6M rows of 13 patterns sharing no variable over the fuzz harness's 3 facts in under 64 MiB of peak RSS (the executor held more than 5.7 GB), or `QRY-012` naming `HashJoin` under a 64-byte limit. An ignored engine test prints the meter's peak against the peak RSS: 435 MiB against about 545 MiB for the groups (`docs/BENCHMARKS.md`). Measuring it found `Aggregate`'s sorted map of groups uncharged while its hash table was still held; the map is now charged and the table freed first, which lowered the real peak from 651 MiB. +- **Negation bodies in both forms (#546).** A second test-only switch (`minigraf::__subplans`, `test-hooks` feature) forces the engine's `not` / `not-join` bodies to run hashed or correlated. `tests/plan_independence_test.rs` runs every query with the body forms chosen, forced hashed and forced correlated, each with reordering on and off; its matrix gains negations over floats near zero, `0.0` and `-0.0`, keywords and refs of one entity, long strings, bodies reading an imported variable they do not bind, variable-free bodies and `:db/valid-at`. `tests/negation_equality_test.rs` checks the changed answers on every executor path, in memory and after a checkpoint. The property test's rerun also forces hashed bodies. Engine unit tests cover the form the planner picks, routing, multiplicity, failing expressions in bodies, and that a hashed body is read once and a correlated one probes once per row. - **Disjunctions (#546).** `tests/or_equality_test.rs` checks the changed `or` / `or-join` answers through `execute` and a cursor, in memory and after a checkpoint. `tests/plan_independence_test.rs` gains disjunctions (keywords meeting refs, floats near zero, long strings as keys, branches naming different outer variables or no join variable, a branch with `not`, an `or` with nothing before it, a cross product, `:db/valid-at` in a branch), run with branches chosen, forced hashed and forced correlated. The property test generates `or` and `or-join` over bound variables, with a reference evaluator that deduplicates the rows they keep. Engine unit tests run every disjunction shape with each branch form forced against the executor, and cover routing, the form the planner picks, `Distinct`, and that a hashed branch is read once. - **Aggregates and windows (#547).** `src/query/datalog/aggregate.rs` unit tests check every accumulator over every order of small inputs (exact float sums against hand-computed values, cancellation, subnormals, signed zeros, infinities and NaN, integer saturation, errors decided at the end) and that the value order is total. `tests/aggregate_window_rules_test.rs` checks the changed answers; `tests/plan_independence_test.rs` gains aggregate, window and mixed queries over ties, keywords and refs, and floats. - `tests/snapshot_atomicity_test.rs` races a writer against a reader: a query must see each transaction whole, whether written with `execute` or a `WriteTransaction` (#554), and must read one state for all its patterns (#555), in memory and on file. It also runs the v2.x checkpoint race from #558, which never failed on v3: copy-on-write checkpoints do not overwrite pages a published reader uses. diff --git a/CLAUDE.md b/CLAUDE.md index a1cfe7e1b9..6dde6b5983 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -134,20 +134,20 @@ cargo run < demos/demo_negation.txt 3. **`src/query/datalog/`** — Datalog engine - `parser.rs`: EDN/Datalog parser — `transact`, `retract`, `query`, `rule`, `:as-of`, `:valid-at`, `not`, `not-join`; `resolve_pseudo_sources` names each per-fact pseudo-attribute's source (nearest earlier same-entity pattern, lexical scope) and its hidden metadata variable `?#.`, else PRS-081 (#594) - - `parser/statement.rs`: `transact`/`retract` read one fact at a time (#550): `kind_of` dispatches on the first two tokens; one pass keeps today's error order (phases 1 tokens … 6 valid windows, the earliest phase's first error, phase 3 in today's check order); `read_statement` (pass 1) keeps at most `TX_CHUNK_FACTS` materialised facts and the offset after the last, and returns phase 5–6 errors from `Statement::facts`/`Statement::chunks` (one `Chunk` at a time; pass 2 from that offset for a larger statement); `set_tx_chunk_facts` for tests (`minigraf::__tx_chunk_facts` and `__statement_facts_high_water` under `test-oracle`). The `Parser` reads tokens on demand from a `Lexer` (`keep` off checks structure without holding it); `parse_transact`/`parse_retract` remain under `cfg(test)` for the differential tests + - `parser/statement.rs`: `transact`/`retract` read one fact at a time (#550): `kind_of` dispatches on the first two tokens; one pass keeps today's error order (phases 1 tokens … 6 valid windows, the earliest phase's first error, phase 3 in today's check order); `read_statement` (pass 1) keeps at most `TX_CHUNK_FACTS` materialised facts and the offset after the last, and returns phase 5–6 errors from `Statement::facts`/`Statement::chunks` (one `Chunk` at a time; pass 2 from that offset for a larger statement); `set_tx_chunk_facts` for tests (`minigraf::__tx_chunk_facts` and `__statement_facts_high_water` under `test-hooks`). The `Parser` reads tokens on demand from a `Lexer` (`keep` off checks structure without holding it); `parse_transact`/`parse_retract` remain under `cfg(test)` for the differential tests - `parser/verifier.rs`: test-only (not wasm32) bounded-exhaustive check of the parser against `tests/grammar/grammar.pest` (#643): every 1–3 character string (`parse_edn`) and every balanced token filler up to `MINIGRAF_GRAMMAR_BOUND` (default 3) in 15 command templates (`parse_datalog_command`); pest rejects ⇒ parser rejects, pest accepts ⇒ parser accepts or raises a `SEMANTIC` code; today's drift is `KNOWN_DRIFT`, one entry per cause, removed by its fix (empty: #649, #650, #651 fixed) - - `executor.rs`: `DatalogExecutor` — `transact`/`retract`/`rule` commands, and every query on the engine (`open_query`, `open_rule_query`; planner errors after the pseudo-attribute check, then every predicate the query and its rules name, `QRY-007`). The executor's own query path (temporal filter → net-assert → valid-time, not/not-join post-filter, `or` branches) compiles under `cfg(any(test, feature = "test-oracle"))` only, as the engine's oracle (#551) - - `matcher.rs`: `edn_to_value`, `edn_to_entity_id`; `PatternMatcher` (oracle builds only, #551) - - `aggregate.rs`: `Agg` (one aggregate of one group) and `Running` (a window's running value), shared by the executor and the engine; exact sums (`i128` integers saturated once, fixed-point floats rounded once), `value_order` (one total order of values for window sorts, peers, `rank` and `min`/`max`), `named_vars` (a window's tie-break variables), `windows` (each window's value per row: partitions, sort, peers) (#547) - - `evaluator.rs`: `rule_invocation_to_pattern`, the rule limits and their errors; for oracle builds only (#551), `RecursiveEvaluator` (semi-naive), `StratifiedEvaluator` (repeats a stratum whose rules recurse through a `not`/`or` rule until it derives nothing new, #633), `evaluate_not_join` + - `executor.rs`: `DatalogExecutor` — `transact`/`retract`/`rule` commands, and every query on the engine (`open_query`, `open_rule_query`; planner errors after the pseudo-attribute check, then every predicate the query and its rules name, `QRY-007`); its own query path is gone (#551) + - `matcher.rs`: `edn_to_value`, `edn_to_entity_id` + - `aggregate.rs`: `Agg` (one aggregate of one group) and `Running` (a window's running value), used by the engine; exact sums (`i128` integers saturated once, fixed-point floats rounded once), `value_order` (one total order of values for window sorts, peers, `rank` and `min`/`max`), `named_vars` (a window's tie-break variables), `windows` (each window's value per row: partitions, sort, peers) (#547) + - `evaluator.rs`: `rule_invocation_to_pattern`, the rule limits and their errors - `stratification.rs`: `DependencyGraph`, `stratify()` — negative edges + cycle detection; a positive edge to a rule with `not`/`not-join`/`or`/`or-join` also raises the caller, off a cycle (#628) - `rules.rs`: `RuleRegistry` — thread-safe rule management - `types.rs`: `EdnValue`, `Pattern`, `DatalogQuery`, `AsOf`, `ValidAt`, `WhereClause` (incl. `Not`, `NotJoin`); `PseudoAttr` enum, `AttributeSpec` wrapper - - `optimizer.rs`: Selectivity-based join reordering on every build (the `wasm` feature is a deprecated no-op). `reorder()` gates every reordering site; tests turn it off per thread (`set_reorder`, `minigraf::__reorder` under `test-oracle`, #596); `plan_seeded` orders a body with its imported variables counted as bound, `plan_after` orders a rule body's clauses after its delta, each joining on a variable bound before it where one can (#694), and `subplans()` lets tests force the engine's negation bodies and `or` branches hashed or correlated (`set_subplans`, `minigraf::__subplans`, #546) + - `optimizer.rs`: Selectivity-based join reordering on every build (the `wasm` feature is a deprecated no-op). `reorder()` gates every reordering site; tests turn it off per thread (`set_reorder`, `minigraf::__reorder` under `test-hooks`, #596); `plan_seeded` orders a body with its imported variables counted as bound, `plan_after` orders a rule body's clauses after its delta, each joining on a variable bound before it where one can (#694), and `subplans()` lets tests force the engine's negation bodies and `or` branches hashed or correlated (`set_subplans`, `minigraf::__subplans`, #546) - `prepared.rs`: `BindValue`, `PreparedQuery` — parse-once/execute-many with named `$slot` bind slots; `prepare_query`, `substitute` - `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, `HashJoin` otherwise; `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), `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`), `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), `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), `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`; each entry charged by a per-entry estimate 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), `oracle.rs` (with `cfg(test)` or the `test-oracle` feature, every query also runs on the executor's query path and must agree; an engine `QRY-012` agrees with any answer; `exempt()` skips it for the answer changes of #551 spec §4, whose tests check both answers). `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, `HashJoin` otherwise; `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), `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`), `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), `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), `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`; each entry charged by a per-entry estimate 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) @@ -212,7 +212,7 @@ Auto-migrates v7 → v8 on open (spec §9, with a backup meta page). v1–v6 are ## Test Coverage -**1779 tests** (1767 passing, 12 ignored; unit + integration + doc). +**1709 tests** (1697 passing, 12 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. diff --git a/Cargo.toml b/Cargo.toml index 810916c3a2..5fecd74145 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -86,9 +86,10 @@ default = [] # Deprecated, does nothing since v3.0.0: every build reorders query clauses # (#594, #596). Kept so that builds naming it still resolve. wasm = [] -# Build the executor's query path and run it beside the streaming engine, -# comparing every answer (#473 spec §9, #551). Tests only. -test-oracle = [] +# Test-only switches for integration tests: clause reordering, `not`/`or` +# body forms, transaction chunk size and its high-water mark (#596, #546, +# #550; `minigraf::__reorder` and the rest). Tests only. +test-hooks = [] browser = [ "dep:wasm-bindgen", "dep:wasm-bindgen-futures", diff --git a/PHILOSOPHY.md b/PHILOSOPHY.md index ab09d8df49..60de43add5 100644 --- a/PHILOSOPHY.md +++ b/PHILOSOPHY.md @@ -113,9 +113,7 @@ SQLite's success comes from a clear philosophy: be a library, not a server. Be s #277's structured error codes — 130 documented codes across 6 categories cannot fit in 1MB even with opt-level="z", LTO, codegen-units=1, and strip=symbols all already applied; see CI's `binary-size.yml` for the - enforced limit). On the v3 branch the gate allows a temporary 60 KiB more - (1,260 KiB) while the streaming engine and the old executor both ship - (#473; rule queries on the engine added 30 KiB, #548), and since #549 left the binary at 1,259 KiB that gate is report-only: CI warns above 1,260 KiB instead of failing. It returns to an enforced 1,200 KiB when #551 removes the executor's query path + enforced limit) - No runtime dependencies (no JVM, no Python, no Node.js) **Anti-pattern**: Requiring external services, libraries, or runtimes to function. diff --git a/benches/minigraf_bench.rs b/benches/minigraf_bench.rs index 0e0436bc9b..97273a6cd0 100644 --- a/benches/minigraf_bench.rs +++ b/benches/minigraf_bench.rs @@ -3,8 +3,7 @@ // Integrate `pprof` as a Criterion profiler (via the `pprof` crate's Criterion // feature or `criterion-pprof`) so that `cargo bench` can emit flamegraphs. // Run the query/negation/aggregation/disjunction groups at 10K and 100K facts -// to confirm that `filter_facts_for_query` (index rebuild) and -// `net_asserted_facts` are the dominant costs before making structural changes. +// to find the dominant costs before making structural changes. // // Example setup (Cargo.toml): // [dev-dependencies] @@ -928,7 +927,7 @@ fn bench_negation(c: &mut Criterion) { group.finish(); } - // not/rule_body: `not` inside a rule body (StratifiedEvaluator overhead). + // not/rule_body: `not` inside a rule body (stratified evaluation overhead). // Rule: `(eligible ?x) :- [?x :val ?v] (not [?x :blocked true])` // 10% of entities are blocked. { diff --git a/coverage-thresholds.toml b/coverage-thresholds.toml index eeba715809..6e51a959d4 100644 --- a/coverage-thresholds.toml +++ b/coverage-thresholds.toml @@ -123,8 +123,9 @@ branches = 70 # Query engine [files."src/query/datalog/evaluator.rs"] +# No branches since #551 removed the evaluators: only the limit errors and +# rule_invocation_to_pattern are left. lines = 88 -branches = 84 [files."src/query/datalog/executor.rs"] lines = 93 diff --git a/docs/TEST_COVERAGE.md b/docs/TEST_COVERAGE.md index 609b1c7702..284b796f83 100644 --- a/docs/TEST_COVERAGE.md +++ b/docs/TEST_COVERAGE.md @@ -2,9 +2,9 @@ ## Coverage Summary -**Verified**: 2026-10-23 with `cargo test --quiet` (with `--features test-oracle`: 1,782 passing, 16 ignored) +**Verified**: 2026-10-23 with `cargo test --quiet` (with `--features test-hooks`: 1,713 passing, 13 ignored) -**Result**: 1,767 passing tests and 12 ignored tests (1,779 total) +**Result**: 1,697 passing tests and 12 ignored tests (1,709 total). #551 PR 2 deleted the executor's query path with the 73 unit tests of its internals and the oracle; two engine tests replace shapes no other test covered, and a storage unit test the reads only the executor made This covers the unreleased file-format-v8 work (#287, #371): the index-key value-collision fix, the v7→v8 migration, and the drop of formats v1–v6. It otherwise still covers the public database API, the Datalog engine, storage and recovery paths, v2.0.0's locking and structured-error-code changes, and v2.0.1's regression test for rebuilding indexes on open after several checkpoints (#370). Merged from the v2.x line: `tests/point_query_history_test.rs` and new storage unit tests check that attribute-narrowed bound-entity lookups return exactly what a full scan returns, and that `net_asserted_facts` matches its previous implementation on randomized histories (#323). Attribute-scan tests check that the AEVT range covers exactly the queried attribute, including non-ASCII names such as `:丿` and prefix siblings such as `:ab` for `:a` (#381). Incremental B+tree rebuild tests check that checkpoints which copy untouched index leaves produce exactly the entries and file checksum a full rebuild would, including over repeated checkpoints, that single-fact checkpoints do not fragment the index, and that a damaged slot directory is rejected rather than copied (#315). B+tree cursor tests check that every scan walks the tree, not the leaf `next_leaf` chain: full scans and start positions match the input, `seek` from the current position lands where a fresh descent from the root would (randomized, plus within a leaf, to a sibling, across subtrees, past the end, into the gap after a leaf, and backwards as a no-op), a seek to the sibling leaf reads exactly one page, reads are unchanged with every `next_leaf` zeroed, a child pointer into a non-B+tree page is STG-013, and a cycle in child pointers is an error, not a hang (v8 storage format PR 1, #374). Directory-sync unit tests check that creating the `.graph` file or the WAL, and deleting the WAL, fsync the parent directory after the file operation, and that reopening an existing file does not (#389). Disjunction tests check that `or-join` returns an empty result, not INT-031, when no rows reach it: on an empty database, after a pattern that matches nothing, after a `not` that removes every row, and in a rule body (#405). A stratification unit test builds the same two-rule negative cycle 64 times and checks that the INT-054 message names the same predicate pair every time (#410). Magic-sets tests check that a recursive rule with a literal start that recurses through another rule returns the same results as without the literal (#297). API tests check that `execute()` and `WriteTransaction::execute()` reject `$slot` bind tokens in every position with API-010 (#407). The REPL `run()` test now runs in a child process with null stdin, so it no longer hangs when the test runner's stdin is an open non-TTY stream (#415). v8 page-format tests (PR 2, #374, #388) check the 24-byte page header (a flipped bit, a wrong page id and a future generation each give their own STG code, legacy page types fail before the CRC, and a failed page is never cached), meta-page encoding, the free-list chain, WAL v2's base generation, and every row of the meta-selection table: both slots valid, a torn newest slot with the WAL's base generation (opens at the older one), a WAL newer than the valid meta, pages of the next generation on the free list or past `page_count` with no WAL (all STG-033, with the file unmodified), an unknown feature bit (STG-034), and a pre-release v8 single header (STG-032). Fault-injection tests crash `save()` at every page write (cleanly and with torn pages, including the meta write) and every sync, and crash a v7 migration at every write; each reopen finds exactly the old or the new checkpoint, and every reachable page plus the free list covers the file exactly. Twenty-five consecutive saves never write a page the previous meta references. Covering-key tests (PR 3, #433) check that byte order equals logical order for every key component and value type on random tuples (negative, zero and large integers, NaN and ±0.0, strings with 0x00, 64- and 65-byte strings, FOREVER, newest-transaction-first) and that every component round-trips; that prefix-compressed leaves and shortest-separator internal nodes round-trip, agree with a linear scan, keep `max(left) < s ≤ min(right)`, and reject an overflow; that the byte-key B+tree's builds, incremental rebuilds, cursor and `seek` match their expected sets; that dictionary ids are assigned once, never reused, shared between a keyword attribute and value, and deterministic; that a re-asserted or retracted long value writes no new value page and a forced hash collision still finds the right value; that one transaction with two timestamps is STG-037 and a missing dictionary entry STG-036; that committed reads by entity, entity and attribute, attribute, and in full equal an in-memory model across eight checkpoints and a reopen; that short-valued reads touch no value page; that a v7 file with every value type, long strings, refs and retractions migrates to exactly the same facts; that a pre-covering-key v8 file is STG-032; and that string values over 4,068 bytes and attributes or keywords over 1,024 bytes are WAL-003. A WAL test checks that reopening next to a fully checkpointed WAL does not reuse transaction numbers (#447). Copy-on-write checkpoint tests (PR 4, #434) check that lazy free-list pops and pushes conserve every page across page boundaries, partial head pages and chain exhaustion, never hand out a page freed in the same generation, and share unread chain pages unchanged; that a copy-on-write insert equals a sorted merge for random batches (including keys below the first and above the last, many into one leaf, root growth to depth 3, and 1 KB separators that split internal nodes), leaves the old tree readable and unchanged, frees exactly the replaced nodes, writes only new pages, writes exactly one leaf and two internal nodes for one entry in a depth-3 tree, and does not fragment leaves under single inserts; that a checkpoint after 1 or 100 right-edge facts writes at most the tree-depth difference more pages at 100,000 facts than at 10,000, and at most one path per new entry per tree for random keys; and that four reader threads querying throughout 40 checkpoints never fail and never see the fact count go backwards. Hardening tests (PR 5) damage an index leaf, an internal node, a dictionary leaf, a value page and a free-list page in turn. Every committed read or checkpoint that reaches the damaged page fails with STG-029, never with wrong or fewer rows. A query through `Minigraf` on a file with damaged leaves fails with STG-029, and the file still opens at its last checkpoint. A size test measures at most 200 bytes per fact (142 measured) on 144k facts in #433's shape; its 1.15M-fact variant is ignored locally and runs in the nightly smoke workflow. A shared dictionary-cache test checks that cached ident and timestamp lookups return the same facts and that the cache stays bounded. Merged from the v2.x line: storage and `edge_cases_test.rs` tests check that more than 65,535 uncheckpointed facts each resolve to their own fact through entity lookups and attribute scans, in memory and file-backed (#445). Merged from the v2.x line: `tests/golden_corpus_test.rs` opens a copy of each committed golden file in `tests/golden/` (v7 files written by minigraf 2.0.3: one checkpoint, several checkpoints, indexes rebuilt on open, a crash-left WAL, an already-checkpointed WAL, same-transaction multi-values) and checks its manifest's CRC32, `tx_count` and query results after open, after a checkpoint and reopen, and after one more write; a second test checks that every golden file has a manifest (#391). On `v3` the same test checks that each v7 file has a v8 meta page after its first open and gives the same results after reopening the migrated file, and adds seven v8 golden files (one checkpoint, seven copy-on-write checkpoints, a crash-left v2 WAL, an already-checkpointed v2 WAL, same-transaction multi-values, a v7 file migrated in place, and long values at the size limits); the #371 queries, skipped on v2.x, run and pass. `tests/model_based_test.rs` runs random sequences of transacts, retracts, write transactions, checkpoints, reopens and simulated crashes against a file and, after every step, compares the transaction counter, `verify`, full rows with windows and tx counts, and six query shapes under `:as-of N` and `:valid-at T` with a reference model (#385). `tests/property_test.rs` writes random histories (batched transacts, retracts, write transactions, checkpoints) in memory and to a file, and compares random queries (one to three joined patterns, `not` or `not-join`, a comparison predicate, `:as-of`, `:valid-at` or `:any-valid-time`) with a reference evaluator, on the open file and after a reopen; a query error fails the test (#386). `tests/crash_kill_test.rs` kills a child process running a seeded workload (multi-valued batches, batched retracts, five checkpoint modes) at a random point and checks that the reopened file holds exactly the transactions the child logged as committed, or those plus the one in flight, through full-scan, AEVT, AVET, EAVT and `:as-of` queries and `verify`, again after a second reopen and after a checkpoint plus reopen (#384). Integrity tests (#373) check that intact files verify with no problems and an exact fact and page count, and that `verify` reports each kind of damage with its code: an EAVT, AEVT, AVET or VAET leaf missing an entry (STG-038), keys out of order and a page reached from two trees (STG-039), a rotted index leaf (STG-029), a free page still in use and a leaked page (STG-035), a missing transaction entry (STG-036), and an entity id whose UUID maps to another id (STG-040). After each index or free-list damage, `rebuild_indexes` leaves a file that verifies clean, reads back every fact and accounts for every page. The source is an index that agrees with another one, or the only intact one; three intact indexes that all disagree, or a damaged dictionary, give STG-041 with the file unchanged. A rebuild commits pending facts, including new ids and long values. A crash at every write (clean and torn) and every sync of a rebuild reopens either at the old generation with only its old damage or at the new one with none, never losing a fact. Through `Minigraf` (`tests/integrity_test.rs`), a rebuild commits WAL entries and deletes the WAL, and flipping a byte in each leaf of a file in turn is always reported, then either repaired (index leaves) or refused with STG-041 and the file unchanged (dictionary leaves). Page-count tests (#497) check that a CRC-valid meta whose `page_count` is past the end of the file (one page past, 2^50, `u64::MAX`; with the other slot valid or damaged; with or without a WAL) and a file cut short by one page, three pages or down to three pages are `STG-044` at open, with the file unchanged and not grown, while a `page_count` exactly at the end opens; that a checkpoint whose pages did not all reach the backend fails with `INT-049` before writing its meta, and the file reopens at the previous generation; and that `verify` at a meta counting pages past the end reports `STG-044` without scanning to that count. Through `Minigraf` (`tests/integrity_test.rs`), a file truncated by one or three pages and a file whose meta was rewritten with `page_count` 2^50 and a valid CRC are `STG-044` read-write and read-only, with no WAL created and the file length unchanged. The `file_header` fuzz input from #497 is a corpus seed. A sub-page test (#506, `tests/integrity_test.rs`) checks that a file of 1 to 4,095 bytes is `STG-045` read-write and read-only, unchanged and with no WAL, when it is a database cut below one page or foreign bytes, and opens as a new database that takes writes when it is a prefix of the first meta page or all zeros; a file-backend unit test checks that `partial_page` returns the bytes past the last whole page. The `corrupt_file` fuzzer no longer skips files under one page: they must fail to open or open empty, and the #506 input is a corpus seed. Damaged v7 fact page tests (#496) check that a page in the counted fact range whose type byte is anything but the fact-page type (zero, `0x01`, the v2.x B+tree types, `0xFF`, a zeroed page; first and last page) is `STG-014` rather than skipped, while a range derived from the first index root skips only v2.x B+tree pages; that opening such a v7 file read-write or read-only fails with `STG-014` and writes nothing; and, in `tests/migration_matrix_test.rs`, that the golden `v7_basic.graph` with page 1's type byte changed or page 1 overwritten with noise fails both opens with the file unchanged and no WAL created. Both inputs are `fact_page` corpus seeds. Merged from the v2.x line: `tests/edge_cases_test.rs` checks the same refusal and acceptance through `Minigraf::open` on a database checkpointed twice (#506). Torn-WAL-tail tests (#513) check that opening a WAL writer cuts off a partial last entry (cut in the checksum, the header or the payload) or an entry with a bad checksum and everything after it, then appends where replay reaches, and leaves an intact WAL byte for byte; that an append that fails part-way makes every later append `WAL-007` while a rejected oversize fact (`WAL-003`, nothing written) does not; through `Minigraf`, that the failed transaction is not applied, later `transact` and `commit` are `WAL-007`, and a `checkpoint()` makes writes work again; and, in `tests/wal_test.rs`, that a commit made after reopening a crash-left WAL with each kind of torn tail survives a second crash. The fault matrix (#390, `src/fault_matrix.rs`) drives a test-only fault plan through the real file backend, WAL and directory fsync: an EIO, a short or torn write (1, 40 and 4,095 bytes), a full disk that keeps failing every later write, a failed fsync, and a failed fsync that also loses the writes since the last good one ("fsyncgate"), each at every write or sync call of a transact, a transact that creates the WAL, an automatic checkpoint, `checkpoint()`, the close-time checkpoint and `rebuild_indexes()`, on a database committed over two checkpoints with multi-valued, retracted and long values and entries pending in the WAL. After each fault, the handle holds the old facts or those plus the whole transaction, never part of one; after a failed checkpoint another is `STG-046`; a later write succeeds or is `WAL-007`/`STG-046`; a kill and reopen gives exactly the handle's facts, plus the failed transaction whole or not at all, and `verify` finds nothing; and a commit after recovery survives another kill. Two more tests fill the disk halfway through a checkpoint (`STG-046`, reads unchanged, reopen intact), and fail the fsync after a checkpoint's meta write and then retry the checkpoint, crashing at each of its writes: the retry is refused and every reopen is intact (without the refusal, a reopen hits `STG-029`). Unit tests check the fault plan's counting, and that a `rebuild_indexes` refused with `STG-041` leaves the handle usable. Live-read tests (#379) check that `triple_len` ends exactly where `tx↓` begins for every value type and index; that on random histories (several valid-time windows, retractions, re-assertions, several values per attribute, long values, 12 transactions per checkpoint) the committed live read for every scan kind and `:as-of` point is exactly the net-asserted set, that it stays equivalent with pending facts on top, and after reopen; and that a point read on a triple asserted and retracted 2,000 times reads under a third of the pages a history read does, with or without `:as-of`. `tests/live_reads_test.rs` runs the same history in a checkpointed file database and in memory and checks that point, attribute, full-scan, join, valid-time, `:as-of` and rule queries return the same rows, before and after reopen. One-window tests (#435) check that `net_asserted_facts` keeps each triple's newest transaction only (a later window replaces an earlier one, closing an open window, a retraction in the newest transaction hides it, records with two windows in one transaction keep both, once each) against a per-triple model on random histories; that the on-disk key walk agrees at every `:as-of` before and after reopen; and that `API-011` rejects two windows of one fact in one transaction without taking a `tx_count`. `tests/valid_time_window_test.rs` checks replacing, closing, extending, reopening and retract-then-reassert through entity-bound and attribute queries in memory, on a checkpointed file and after reopen, `API-011` from `transact` and from `WriteTransaction::execute`, and a later statement's window committed when two statements of a `WriteTransaction` give one fact different windows. Window-validation tests (#436) check that `check_valid_windows` rejects an empty window, an inverted one, and a `:valid-to` at or before the transaction time when `:valid-from` is left out, but not retractions; that `execute` rejects each such `transact` (both bounds, equal bounds, `:valid-to` only, a per-fact bound inverting the transaction's window) with `API-019` without writing or taking a `tx_count`, in memory, checkpointed and after reopen; that `tx.execute()` rejects them and the transaction still commits its other statements; that `commit()` rejects a default `valid_from` that has passed the `:valid-to` by commit time; and that `FactStorage::transact_batch` takes no `tx_count` on rejection. Statement-order tests (#477, `tests/statement_order_test.rs`) run every mix of two statements on one fact inside a `WriteTransaction` (retract then assert, assert then retract, two retracts, two windows, after a committed assertion and on an empty database) and check that reads inside the transaction and the committed rows agree, in memory, checkpointed and after reopen; that other facts of an overridden statement survive; that the commit is one transaction without the overridden records; and that two windows in one statement are `API-011` from `tx.execute()` while the rest commits. A unit test checks the commit collapse keeps each fact's newest statement in order. A log-writer test checks that an inverted window is `API-019`, a second window of a fact in one transaction `API-011`, and an assertion and a retraction of one fact in one transaction `API-020` in either order, each leaving the writer usable and the output exact, while duplicate retractions, identical repeats and the same fact in the next transaction are accepted. Cursor tests (#432, `tests/cursor_test.rs`) check that `query()` batches partition the `execute()` answer for several batch sizes (never empty, never over `max_rows`, `max_rows == 0` still progresses, `None` stays `None`), that the iterator and aggregates, rules, `:as-of` and `:any-valid-time` match `execute()`, that a cursor opened before a `transact`, a `WriteTransaction` commit, a retract or a checkpoint returns the pre-write answer to the end (in memory and file-backed), that `transact`/`retract`/`rule` are `API-012` and bind slots `API-010`, that a `WriteTransaction` thread gets `INT-001`, that rule limits give `INT-020` as from `execute()`, that `PreparedQuery::query` matches `PreparedQuery::execute`, and that a cursor is `Send` and outlives its database handle. Fact-log tests (#430, `tests/fact_log_test.rs`) check that `fact_log()` returns exactly the records written (assertions and retractions, with `tx_count` and `tx_id`) in memory, with everything pending, half checkpointed, fully checkpointed and after reopen, in both orders, with windows of 1 to 1,000 records and batch sizes of 1 to 1,000, in non-decreasing `tx_count` in Tx order; that every layout gives identical records, including valid-time windows and long string values; that a transaction larger than the window is split with no loss or duplicate; that attribute, attribute-prefix, entity and tx-range filters and their combinations match a model, and unknown names match nothing; that writes after open are not in the log; that `checkpoint()` and `rebuild_indexes()` are `API-013` while a log is open (a checkpoint with nothing to write is allowed), that automatic checkpoints from `execute()` and `WriteTransaction::commit` wait for the log, and that closing, dropping or finishing the log releases the database; that a `WriteTransaction` thread gets `INT-001`; and that a log is `Send`, outlives its database handle, and the deferred writes replay on the next open. Read-only open tests (#429, `tests/read_only_open_test.rs`) check that a read-only handle on a file with checkpointed facts and a pending WAL returns the same query results, `tx_count` and fact log as a read-write open; that queries, a cursor, a fact log, `verify`, `prepare`, rules and a UDF leave the `.graph` and WAL bytes and the `.graph` mtime unchanged, and no WAL is created; that `transact`, `retract`, `begin_write`, `checkpoint` and `rebuild_indexes` are `API-014` without taking a `tx_count`, also on a read-only in-memory database and through the builder path; that a missing file is `STG-042` and nothing is created; that an empty file is an empty database and stays 0 bytes; that read-only handles share a file while a read-write one is refused with `STG-025`, both ways; that a file without write permission opens read-only; and that small and whole-file page caches work. File-backend unit tests check that a shared-mode backend refuses page writes and syncs with `INT-056`, that the in-process registry counts readers and admits readers or one writer (also without kernel locks), and that a reader in another process shares the file with a reader here and refuses a writer here with `STG-026`. Storage unit tests check that a read-only open of a v7 file at every point of an interrupted migration (clean and torn writes) sees every fact and writes nothing, and that an empty backend stays empty. `tests/golden_corpus_test.rs` opens a copy of every golden file read-only first and checks its `tx_count` and queries, and that neither the file nor its WAL changes. Log-writer tests (#431, `tests/log_writer_test.rs`) copy a source's fact log (assertions, retractions, an explicit valid-time window, long strings, refs, keywords, checkpointed and pending facts) through `LogWriter` and check that the new file has no `.partial` or WAL, verifies clean, and gives the source's `tx_count`, fact log and query results (current, `:valid-at`, `:any-valid-time`, every `:as-of`, and entity-, attribute- and value-bound lookups) read-write, read-only and after reopen (#370); that it takes new writes at the source's next `tx_count`; that 90,000 facts over two batch commits verify clean and count correctly at `:as-of`; that a purged middle transaction is a hole whose `:as-of` equals the one before, and trailing holes keep the counter through `advance_tx_count`; that an empty log is an empty database with the counter; that `tx_count` 0, a lower or closed transaction and a backwards advance are `API-015`, a second `tx_id` `API-016`, a second window `API-011`, a retraction of an asserted fact in one transaction `API-020`, an empty window `API-019` and oversize values or idents `WAL-003`, each leaving the writer usable and the output exact, with repeats written once; that an existing target or WAL is `STG-043`, a second writer `STG-025` and `read_only` `API-014`; that a stale `.partial` is reused; that dropping an unfinished writer leaves nothing; that `finish` refuses a target created during the build and leaves it untouched; and that `LogWriter` is `Send`. Unit tests check that a batch commits only when a transaction opens past the batch size, never splitting one, and that `FileBackend::truncate` empties a file. A unit test in `error.rs` checks that `MinigrafError::invalid_argument` and `MinigrafError::closed`, the constructors for language bindings, give API-017 and API-018 with their text. Query-validation tests (#406, #414) check that a plain `:find` variable or a window function's argument, `:partition-by` or `:order-by` variable that no `:where` clause binds (including `?_` wildcards) is `PRS-080` from both `execute()` and `prepare()`, naming the variable, while variables bound by a pattern, an attribute position, a rule call, an expression binding, an `or-join`, every branch of an `or`, a pseudo-attribute or a window spec are accepted, and bind slots are not mistaken for `:find` variables; and that an unknown aggregate is `QRY-010` and an unknown window function `QRY-011` on an empty database, when no row matches, when rows match, through a rule query and through a prepared query, while a registered UDF in either position returns an empty result on an empty database. Coverage-gate tests (#396) check that replay stops at a WAL entry whose first fact is longer than 10 MB or that claims more than 1M facts, that a WAL writer cannot be opened in a missing directory, and that a failed cut of a torn WAL tail fails the open and leaves the file as it was; that a short v7 page and a slot past the record count are `INT-024`; that a migration backup meta of another generation or file length is not used (`STG-032`, file unchanged), and a torn first meta with data in page 1 is `STG-032`, not a new file; that `save` with nothing pending writes nothing, `into_backend` saves pending facts, and `rebuild_indexes` with nothing checkpointed commits the pending facts; and that unsorted or repeated B+tree input and a stored key inserted with another value are `INT-049`, a tree pointer to a free-list page is `STG-013` from `get`, a leaf walk and a copy-on-write insert, and the read-only `MutexStorageBackend` refuses writes, syncs and close. A page-cache test holds two threads in the backend read so both miss the same page, and checks that both get the one cached copy; before it, that path ran only when the scheduler happened to race the threads, and the gate flapped. Three `BrowserDb` tests (wasm32, run with `wasm-bindgen-test` in a browser, not counted above) check that `query()` batches of 1, 7 and 1,000 give the rows of `execute()`, that a cursor keeps the answer from when it opened and returns the end after `close()`, and that a `transact` is API-012. The wasm32 targets run in CI (`.github/workflows/wasm.yml`). In a browser (`wasm-pack test --headless`, Firefox and Chrome): 32 `wasm_bindgen_test` tests: nineteen for `BrowserDb` (including IndexedDB persistence, the cursor, and the flush returning every dirty page and failing on one it cannot read, from #470), eleven for `BrowserBufferBackend` (which used `#[test]` and never ran before), and two checking that IndexedDB page keys accept only whole numbers from 0 to 2^53. Five of the `BrowserDb` tests (#411, #440) check that opening a v7 store written straight into IndexedDB stores a v8 meta page and only the live pages, with nothing written on the next open; that after each of 60 transacts memory, and at the end IndexedDB, hold exactly the pages not on the free list while the file grows by under one page per transact; that a commit applied in memory but never flushed reopens at the previous one and keeps working; that an export after churn is as long as the meta says and imports back with its free pages dropped; and that `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, and 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, 956 passing; ten that spawn threads or a child process are ignored on WASI. These are not counted above. A WAL test checks that a checkpoint with no facts to flush still removes a WAL whose entries are all already in the file, and the golden-corpus test now requires the WAL to be gone after a checkpoint for the `stale_wal` fixtures too (#457). A WAL test checks that closing a handle opened with `wal_checkpoint_threshold(usize::MAX)`, in both sync modes, leaves the `.graph` file byte for byte as it was and keeps the WAL, whose entries replay on the next open, and a unit test closes an in-memory handle under the same setting (#476). A recursive-rule test checks that a rule query on a database with more live facts than `max_results` returns its answer, with a bound and with a free first argument, and that a query deriving more facts than its `:max-results` is still `INT-020` (#528). A log-writer test runs the online backup from `docs/DURABILITY.md`: it copies a read-write handle with an uncheckpointed transaction through `fact_log` and `LogWriter` while another thread writes past the automatic checkpoint threshold, and checks that the copy verifies clean, holds exactly the records the log returned and the counter read after the log opened, and that every concurrent write reaches the source's file once the log is dropped (#398). Rule-body tests in `tests/recursive_rules_test.rs` check that a `:db/valid-at` pattern in a rule definition, in its `not` and `not-join` bodies and in its `or` branches binds the query's valid time, on the semi-naive, stratified and magic-sets paths (#617). Tests in `tests/not_join_test.rs` check that a rule calling a rule with `not-join`, `not` or `or` returns that rule's rows, with a free and a literal argument and through a forwarding rule, and that a rule with its own `not-join` calling one gets the same rows whether or not the query asks for the callee first; stratification unit tests check that such a caller, a rule forwarding to it and a caller of a recursive one sit above the callee, and that recursion through a rule with a `not` still stratifies (#628). Tests in `tests/not_join_test.rs` check that recursion through a rule with `not`, `not-join` or `or`, directly or through another rule, returns every row along a chain, and that the `not` still removes the rows it should; evaluator unit tests check that such recursion stops at its fixpoint that `max_iterations` and `max_results` end one that does not with INT-020, and that `max_results` counts the facts every pass derives, not only the mixed rule's (#633). @@ -14,28 +14,28 @@ This covers the unreleased file-format-v8 work (#287, #371): the index-key value - **Multi-value and index-key correctness** (`tests/multi_value_test.rs`, 10 tests): same-transaction multi-valued facts surviving query-time dedup, retracting several values of one attribute in one call, valid-time stints (facts differing only in valid time), maximum-value-size boundaries, and format v8 index keys (value bytes + assert/retract flag) (#287, #371). - **Storage correctness**: packed pages, B+tree indexes and range scans, cache behavior, file-header validation, migration (including v7→v8 index rebuild and v1–v6 rejection via `STG-028`), WAL replay, checksums, corruption handling (including a B+tree node that points back up, which fails a scan with `INT-049` instead of looping; #597), and fault injection. - **Reliability and concurrency**: concurrent reads and writes, rollback behavior, same-process handle exclusion, cross-process locking, PID namespaces, NFS and container lock behavior, SIGKILL recovery, and queries seeing each concurrent transaction whole and reading one state for all their patterns, including while a checkpoint runs (`tests/snapshot_atomicity_test.rs`, #554, #555, #558). Generation pins (#543): a pinned generation's pages are never written by later saves or index rebuilds and are reused once the pin is dropped (by page id, `storage::persistent_facts`, `storage::pins`, `storage::page`); fact logs stay correct while checkpoints, rebuilds and concurrent writers run, and see whole transactions only (`tests/fact_log_test.rs`). Query and prepared-query cursors keep their answer and their pages across writes, checkpoints and index rebuilds, and the file stops growing once they close (`tests/cursor_test.rs`); a snapshot leaves out facts appended after it on every scan (`graph::storage`); a crash at every write point of a save with a pinned generation loses no fact and no page, and the reopened database reuses the quarantined ids (`storage::persistent_facts`); the browser withholds free pages a pinned generation may read and releases them once out of force (`storage::pins::split_released`, and a `#[wasm_bindgen_test]` with an open `BrowserDb` cursor). -- **Streaming query engine** (#473, #544): every query the engine runs is also run by the existing executor under `cfg(test)` and the `test-oracle` feature, and the answers must agree (`query::engine::oracle`); CI runs the whole suite with the feature, so the model-based, property, golden-corpus and integration suites check the engine. `query::engine::tests` reaches every index choice, net-assert of pending records over committed ones, `:as-of`, valid time, long strings and reads of several batches, in memory, across checkpoints and after reopen, expression filters and bindings (including rebinding and failing expressions), pseudo-attribute columns, keyword/UUID/float constants against keywords, refs and UUID-named keywords, and checks which queries stay on the executor and that INT-026 and QRY-007 come first. Resumed `live_keys` reads equal one live read over random histories (`storage::persistent_facts`). Lazy cursors (`cursor::tests`, #544 PR 3): one pull reads one internal batch of the scan (operator counters), rows left in a batch need no pull, a closed stream reads nothing more, a filter's counters chain, and a cursor's answer is unchanged by writes and by checkpoints that free the leaves it has yet to read (file-backed) or by later writes (in memory); a read error after some rows are gathered comes on the next call, then the cursor ends (`query::engine::tests`). DICT lookups are cached for one pull only, and provisional ids keep their values across pulls (`query::engine::ids`). Joins (#545 PR 2): the oracle matrix adds two- and three-pattern joins on the entity (`IndexNestedLoopJoin`), value and attribute positions (`HashJoin`), cross products, keywords and refs of one entity in both text orders, UUID-named keywords, attributes that name entities, floats `0.0`/`-0.0`, long strings committed and pending, and expressions between joins, at every temporal; joins whose answers span many batches (one probe with more than a batch of matches, cross products, tables built on either side); the planner's join choice; a keyword's entity id (`query::engine::ids`). Pseudo-attributes across joins (#545 PR 3): the metadata of the last pattern before them that matched their entity, chosen per row (a pattern on another entity variable that equals theirs on some rows only, constant entities), pseudo-attribute patterns planned before any pattern with a stored attribute (joined with every fact of their entity, including cross products), and `:db/valid-at` at every temporal with variables, `nil` and integer constants; which pseudo-attribute shapes stay on the executor. +- **Streaming query engine** (#473, #544): the engine is the only query path (#551). Until then every query it ran in tests was also run by the executor and had to agree; the answers of `query::engine::tests`, `tests/recursive_engine_test.rs` and `tests/plan_independence_test.rs` were recorded then and are checked against `tests/answers/` (one line per test, query and answer: row count and a digest of the rows as a bag). The model-based, property and golden-corpus suites check against `tests/reference_model/` and the stored corpus. `query::engine::tests` reaches every index choice, net-assert of pending records over committed ones, `:as-of`, valid time, long strings and reads of several batches, in memory, across checkpoints and after reopen, expression filters and bindings (including rebinding and failing expressions), pseudo-attribute columns, keyword/UUID/float constants against keywords, refs and UUID-named keywords, and checks that every query runs on the engine and that INT-026 and QRY-007 come first. Resumed `live_keys` reads equal one live read over random histories (`storage::persistent_facts`). Lazy cursors (`cursor::tests`, #544 PR 3): one pull reads one internal batch of the scan (operator counters), rows left in a batch need no pull, a closed stream reads nothing more, a filter's counters chain, and a cursor's answer is unchanged by writes and by checkpoints that free the leaves it has yet to read (file-backed) or by later writes (in memory); a read error after some rows are gathered comes on the next call, then the cursor ends (`query::engine::tests`). DICT lookups are cached for one pull only, and provisional ids keep their values across pulls (`query::engine::ids`). Joins (#545 PR 2): the oracle matrix adds two- and three-pattern joins on the entity (`IndexNestedLoopJoin`), value and attribute positions (`HashJoin`), cross products, keywords and refs of one entity in both text orders, UUID-named keywords, attributes that name entities, floats `0.0`/`-0.0`, long strings committed and pending, and expressions between joins, at every temporal; joins whose answers span many batches (one probe with more than a batch of matches, cross products, tables built on either side); the planner's join choice; a keyword's entity id (`query::engine::ids`). Pseudo-attributes across joins (#545 PR 3): the metadata of the last pattern before them that matched their entity, chosen per row (a pattern on another entity variable that equals theirs on some rows only, constant entities), pseudo-attribute patterns planned before any pattern with a stored attribute (joined with every fact of their entity, including cross products), and `:db/valid-at` at every temporal with variables, `nil` and integer constants - **Magic-sets demand** (#608): `tests/magic_sets_test.rs` checks rule queries with a literal argument where some call site cannot carry the demand — a rule-body call with an argument nothing binds yet, the same rule called with free arguments, a call from a rule called with free arguments, calls inside `or` and `not`, a fully literal call, and a call bound only by a variable; `magic_sets.rs` unit tests check the adornment each shape solves to. - **`or` with no shared variable** (#610): `tests/disjunction_test.rs` checks that an `or` sharing no variable with the earlier clauses joins as a cross product, before or after them, through the seeded path (a branch with `not`) and in a rule body, keeps the earlier clauses' variables and fact metadata (a pseudo-attribute), and gives no rows when no branch matches. - **Prepared time travel** (#603): `tests/prepared_statements_test.rs` runs literal `:as-of` (counter and timestamp), `:valid-at`, `:any-valid-time` and a per-fact pseudo-attribute query through `execute`, a prepared `execute` and a prepared cursor, which must agree; a `prepared.rs` unit test checks that `substitute` keeps non-slot `:as-of` and `:valid-at`. -- **Rule queries on the engine** (`tests/recursive_engine_test.rs`, 10 tests; #548): linear and non-linear transitive closure, mutual recursion, strata whose `not` and `or` rules recurse (#633's cases), naive rules (a same-stratum read in an `or` branch, through a `:p` pattern, through `[?y ?a ?z]`), derived facts visible to every pattern and the magic-set predicate's attribute, identity of derived facts (keyword vs ref, `-0.0` vs `0.0`, long strings, a head equal to a stored fact), `nil` metadata and `:db/valid-at` over derived facts, one-argument heads, `QRY-013` and `INT-022` heads, both `INT-020` limits, and rule queries with aggregates, expressions, `not-join`, `or` and windows; each in memory, on a file with pending facts and after a checkpoint, and under `test-oracle` against the executor. Engine unit tests check routing (`:as-of` timestamp, an unplannable rule body, a three-argument call and a write transaction stay on the executor) and derived rows read across batches before and after a checkpoint; `relation.rs` unit tests check row identity and the `Old` / `Delta` / `Full` ranges. Every delta run of the magic-set rewrite of a recursive rule joins each clause on a variable bound before it, with no keyless join (`rule_delta_runs_join_on_a_bound_variable`, #694), and an optimizer unit test checks `plan_after`'s connected order. -- **Query memory limit** (`tests/memory_limit_test.rs`, 7 tests; #549): `OpenOptions::query_memory_limit` is off by default and set by its builder; `QRY-012` through `execute`, a cursor's first pull, a prepared query and a rule query (from `execute`, and from `query` when the rules run at open); the database answers after a query fails; a write transaction's query is counted until it stages a write, then runs uncounted on the executor; a prepared rule query uses the database's `max_derived_facts`. Engine unit tests (`src/query/engine/tests.rs`, 7 more): `HashJoin`, `AntiJoin`, `Union`, `Aggregate` and `Window` charge while they hold state and the meter is back at 0 after a drain and after an early drop; `QRY-012` names the holder over the limit (each operator, `IdSpace`, `Recursive`, `Distinct` and `Relations`), and its allocator form through the `try_reserve` test hook; a cursor returns rows, then `QRY-012`, then nothing; `rewind` and `close` release; the planner builds a keyless join on the side with the smaller product estimate (#575's shape, a selective outer side, a tie, reordering off). `meter.rs` (4 unit tests) checks charge, release, drop, peak and the allocator form. `Aggregate` charges its sorted map of groups until every row is built, and lets its hash table and group rows go first, with `sum-distinct` members charged once (`aggregate_finish_charges_its_sorted_groups`, `aggregate_finish_keeps_sum_distinct_members_charged_once`). -- **Join rules** (`tests/join_rules_test.rs`, 11 tests; #545): a join on a float value pairs `0.0` with `-0.0`, through the hash key and as a shared variable; a float constant in a pattern, bound to a `$slot`, in a rule body or in an `=` predicate matches equal floats only (`1e-17` does not match `0.0`, `0.0` matches `-0.0`; #706), in memory, on file before and after a checkpoint and after reopen; a variable bound to a keyword by one pattern and to the ref of the same entity by another returns the kind from the first pattern in `:where` text order, when the planner runs the patterns in another order, through the attribute position, before and after a rule call, and with a repeated pattern; an expression binding unifies with a pattern binding the same variable, and the first binder in the text, pattern or expression, gives the value (#596); a pseudo-attribute pattern never gives a variable its value, even when it runs first (#606; the plan-independence matrix checks it with reordering off). Under the `test-oracle` feature the joins among them also run on the streaming engine. A unit test checks that `-0.0` and `0.0` hash alike. +- **Rule queries on the engine** (`tests/recursive_engine_test.rs`, 11 tests; #548): linear and non-linear transitive closure, mutual recursion, strata whose `not` and `or` rules recurse (#633's cases), naive rules (a same-stratum read in an `or` branch, through a `:p` pattern, through `[?y ?a ?z]`), derived facts visible to every pattern and the magic-set predicate's attribute, identity of derived facts (keyword vs ref, `-0.0` vs `0.0`, long strings, a head equal to a stored fact), `nil` metadata and `:db/valid-at` over derived facts, one-argument heads, `QRY-013` and `INT-022` heads, both `INT-020` limits, and rule queries with aggregates, expressions, `not-join`, `or` and windows; each in memory, on a file with pending facts and after a checkpoint, against their frozen answers. Engine unit tests check routing (`:as-of` timestamps, a rule body with no pattern, a three-argument call and a write transaction) and derived rows read across batches before and after a checkpoint; `relation.rs` unit tests check row identity and the `Old` / `Delta` / `Full` ranges. Every delta run of the magic-set rewrite of a recursive rule joins each clause on a variable bound before it, with no keyless join (`rule_delta_runs_join_on_a_bound_variable`, #694), and an optimizer unit test checks `plan_after`'s connected order. +- **Query memory limit** (`tests/memory_limit_test.rs`, 7 tests; #549): `OpenOptions::query_memory_limit` is off by default and set by its builder; `QRY-012` through `execute`, a cursor's first pull, a prepared query and a rule query (from `execute`, and from `query` when the rules run at open); the database answers after a query fails; a write transaction's query is counted until it stages a write, then runs uncounted; a prepared rule query uses the database's `max_derived_facts`. Engine unit tests (`src/query/engine/tests.rs`, 7 more): `HashJoin`, `AntiJoin`, `Union`, `Aggregate` and `Window` charge while they hold state and the meter is back at 0 after a drain and after an early drop; `QRY-012` names the holder over the limit (each operator, `IdSpace`, `Recursive`, `Distinct` and `Relations`), and its allocator form through the `try_reserve` test hook; a cursor returns rows, then `QRY-012`, then nothing; `rewind` and `close` release; the planner builds a keyless join on the side with the smaller product estimate (#575's shape, a selective outer side, a tie, reordering off). `meter.rs` (4 unit tests) checks charge, release, drop, peak and the allocator form. `Aggregate` charges its sorted map of groups until every row is built, and lets its hash table and group rows go first, with `sum-distinct` members charged once (`aggregate_finish_charges_its_sorted_groups`, `aggregate_finish_keeps_sum_distinct_members_charged_once`). +- **Join rules** (`tests/join_rules_test.rs`, 11 tests; #545): a join on a float value pairs `0.0` with `-0.0`, through the hash key and as a shared variable; a float constant in a pattern, bound to a `$slot`, in a rule body or in an `=` predicate matches equal floats only (`1e-17` does not match `0.0`, `0.0` matches `-0.0`; #706), in memory, on file before and after a checkpoint and after reopen; a variable bound to a keyword by one pattern and to the ref of the same entity by another returns the kind from the first pattern in `:where` text order, when the planner runs the patterns in another order, through the attribute position, before and after a rule call, and with a repeated pattern; an expression binding unifies with a pattern binding the same variable, and the first binder in the text, pattern or expression, gives the value (#596); a pseudo-attribute pattern never gives a variable its value, even when it runs first (#606; the plan-independence matrix checks it with reordering off). A unit test checks that `-0.0` and `0.0` hash alike. - **Pseudo-attribute sources** (`tests/pseudo_source_test.rs`, 12 tests; #594): a per-fact pseudo-attribute reads the nearest earlier pattern in the text with the same entity term (#594's example in both text orders), two pseudo-attributes share a source, `[:alice ?a _]` gives one row per fact, constant and bound value terms check, `:alice` and its UUID are one term while `?e` and `:alice` are not, PRS-081 for a pattern after it, alone, `_`/`?_x` entities, another entity's pattern and a rule call; a `not` body reads the outer fact (and a source inside the body), `not-join` crosses for a listed variable only, `or` branches read the outer fact and never a sibling, `or-join`, closed rule bodies, `$slot`s by name at prepare time, and `:db/valid-at` once per fact. Parser unit tests check the hidden variables (`?#.`), the join variable a crossed `not-join` gains, and the PRS-081 text; an optimizer test places a pseudo-attribute pattern after its source and the pattern binding its value; matcher tests read the hidden variable, a substituted integer, and nothing without a source; the engine tests run the sourced shapes and check PRS-081 for the old fallback shapes. The plan-independence matrix gains eleven pseudo-attribute shapes. -- **Negation equality** (`tests/negation_equality_test.rs`, 5 tests; #546): a value a `not` / `not-join` body takes from the outer row compares by join equality on every path (exclusion set, per-row body with an expression, a query that invokes a rule, a rule body): `1e-20` and `2e-20` differ, `0.0` equals `-0.0`, a keyword imported into an entity position equals the ref, and a float literal in the body matches equal floats only (#706); through `execute` and a cursor, in memory and after a checkpoint. Engine unit tests (`src/query/engine/tests.rs`, 6 more) run every negation shape (hashed and correlated bodies, keys on entity, value and attribute positions, floats, keywords and refs, long strings, bodies reading an imported variable, variable-free bodies, per-fact pseudo-attributes and `:db/valid-at` in bodies, deferred and repeated negations) at six temporal settings with each body form forced and reordering on and off, in memory and on file before and after checkpoints, against the executor; and check the form the planner picks, routing, multiplicity, failing expressions and unknown predicates in bodies, and that a hashed body is read once while a correlated one probes once per outer row. Optimizer unit tests cover `plan_seeded` and the `SUBPLANS` switch. -- **Disjunction equality** (`tests/or_equality_test.rs`, 5 tests; #546): an `or` / `or-join` branch meets the outer row by join equality on every executor path (a keyword in the outer row meets a ref in a branch; `0.0` and `-0.0`; floats `1e-20` apart do not), branches naming different outer variables each meet the outer row on their own, and an `or-join` branch that does not bind its join variable keeps every outer row when it has a row; through `execute` and a cursor, in memory and after a checkpoint. Engine unit tests run every disjunction shape with each branch form forced and reordering on and off against the executor, and cover routing (rule invocations, nested `or`, registry predicates, branch-local metadata stay on the executor), the branch form the planner picks, `Distinct` (equal rows collapse; a keyword and a ref, `-0.0` and `0.0`), and that a hashed branch is read once and a correlated one runs only for rows earlier branches did not match. -- **Aggregates and windows** (`tests/aggregate_window_rules_test.rs`, 8 tests; #547): exact float `sum` and window `avg`, integer `sum` saturating once, exact window `sum` of integers above 2^53, `min`/`max` of `-0.0` and `0.0`, `rank` by keywords (peers 1 1 3 3), a running `sum` giving peers the value at the last peer, `row-number` breaking ties by the other `:find` variables, and `INT-041` from a failing group. `src/query/datalog/aggregate.rs` (15 unit tests) checks every accumulator over every order of small inputs and that `value_order` is a total order; `tests/window_functions_test.rs` checks `PRS-082` and a window over the groups of an aggregate query, and `tests/plan_independence_test.rs` runs aggregate, window and mixed queries with reordering on and off. `Aggregate` on the engine (#547 PR 2, `src/query/engine/tests.rs`, 3 tests): every built-in aggregate grouped by keywords, refs, booleans, floats and long strings, over `nil` values, keywords and refs, with `:with` and `or`, at six temporal settings in memory, after a checkpoint and after reopen, against the executor; an ungrouped aggregate reads every row and returns one batch of one row; the zero row and empty answers; groups in value order over several batches; `INT-041` from a later group; a group dropped by `min` of no value. `tests/aggregation_test.rs` checks that a group of `0.0` and `-0.0` returns `-0.0` in either insertion order. +- **Negation equality** (`tests/negation_equality_test.rs`, 5 tests; #546): a value a `not` / `not-join` body takes from the outer row compares by join equality on every path (exclusion set, per-row body with an expression, a query that invokes a rule, a rule body): `1e-20` and `2e-20` differ, `0.0` equals `-0.0`, a keyword imported into an entity position equals the ref, and a float literal in the body matches equal floats only (#706); through `execute` and a cursor, in memory and after a checkpoint. Engine unit tests (`src/query/engine/tests.rs`, 6 more) run every negation shape (hashed and correlated bodies, keys on entity, value and attribute positions, floats, keywords and refs, long strings, bodies reading an imported variable, variable-free bodies, per-fact pseudo-attributes and `:db/valid-at` in bodies, deferred and repeated negations) at six temporal settings with each body form forced and reordering on and off, in memory and on file before and after checkpoints, against their frozen answers; and check the form the planner picks, routing, multiplicity, failing expressions and unknown predicates in bodies, and that a hashed body is read once while a correlated one probes once per outer row. Optimizer unit tests cover `plan_seeded` and the `SUBPLANS` switch. +- **Disjunction equality** (`tests/or_equality_test.rs`, 5 tests; #546): an `or` / `or-join` branch meets the outer row by join equality on every path (a keyword in the outer row meets a ref in a branch; `0.0` and `-0.0`; floats `1e-20` apart do not), branches naming different outer variables each meet the outer row on their own, and an `or-join` branch that does not bind its join variable keeps every outer row when it has a row; through `execute` and a cursor, in memory and after a checkpoint. Engine unit tests run every disjunction shape with each branch form forced and reordering on and off against their frozen answers, and cover routing (rule invocations, nested `or`, registry predicates, branch-local metadata), the branch form the planner picks, `Distinct` (equal rows collapse; a keyword and a ref, `-0.0` and `0.0`), and that a hashed branch is read once and a correlated one runs only for rows earlier branches did not match. +- **Aggregates and windows** (`tests/aggregate_window_rules_test.rs`, 8 tests; #547): exact float `sum` and window `avg`, integer `sum` saturating once, exact window `sum` of integers above 2^53, `min`/`max` of `-0.0` and `0.0`, `rank` by keywords (peers 1 1 3 3), a running `sum` giving peers the value at the last peer, `row-number` breaking ties by the other `:find` variables, and `INT-041` from a failing group. `src/query/datalog/aggregate.rs` (15 unit tests) checks every accumulator over every order of small inputs and that `value_order` is a total order; `tests/window_functions_test.rs` checks `PRS-082` and a window over the groups of an aggregate query, and `tests/plan_independence_test.rs` runs aggregate, window and mixed queries with reordering on and off. `Aggregate` on the engine (#547 PR 2, `src/query/engine/tests.rs`, 3 tests): every built-in aggregate grouped by keywords, refs, booleans, floats and long strings, over `nil` values, keywords and refs, with `:with` and `or`, at six temporal settings in memory, after a checkpoint and after reopen, against their frozen answers; an ungrouped aggregate reads every row and returns one batch of one row; the zero row and empty answers; groups in value order over several batches; `INT-041` from a later group; a group dropped by `min` of no value. `tests/aggregation_test.rs` checks that a group of `0.0` and `-0.0` returns `-0.0` in either insertion order. - **Parser error codes** (`tests/error_codes_prs_test.rs`, 26 new tests; #643): each of `PRS-083` to `PRS-107` (the parse errors that were `INT-019`, and the retract arity that was `INT-000`) from its `docs/ERROR_REFERENCE.md` example, in the Parser category, with its argument in the message and without the old `datalog parser: ` prefix; three of them through `prepare`. - **Fact arity** (`tests/error_codes_prs_test.rs`, 2 tests; #649): a fact of five or six elements, with or without a map 4th, fails with `PRS-108`, and a transaction holding one stores none of its facts. - **Parser tightening** (`tests/error_codes_prs_test.rs`, 10 tests; #651): `PRS-109` to `PRS-114` from their inputs (an unterminated string, a `:` with no name, `(query [])`, an empty `:find`/`:where`/`:with` in each position, an unknown query keyword with and without a value after it, a constant rule head argument); `PRS-061` for a value after each query option; `PRS-097` for a clause list headed by an operator or a variable, also inside `not`, `or` and a rule body; `PRS-105` for a rule named by a variable or an operator; `PRS-025`/`PRS-029`/`PRS-063` for an aggregate, window or expression named by a variable; the forms next to them still run (an option followed by a keyword, `(- ?n 1)`, a zero-argument rule). Thirteen new `tests/grammar/invalid/syntax/` fixtures. - **Parser vs grammar** (`src/query/datalog/parser/verifier.rs`, 4 tests; #643): about 1.07M lexical strings and 555K structural inputs at the default bound (7.6M at `MINIGRAF_GRAMMAR_BOUND=4`) checked against `tests/grammar/grammar.pest`; known drift by cause in `KNOWN_DRIFT` (none left: #650, #651 fixed), semantic codes with witnesses in `SEMANTIC`. -- **The engine runs every query** (`src/query/engine/tests.rs`, 6 tests and 2 changed; `src/query/datalog/executor.rs`, 2 tests; `src/storage/persistent_facts.rs`, 2 tests and 1 extended; `src/graph/storage.rs`, 1 test; `tests/plan_independence_test.rs`, 1 test; `tests/disjunction_test.rs`, 1 changed; #551): `:as-of` timestamps on `LogWriter` files whose `tx_id`s rise and whose `tx_id`s fall and rise, before, between, at and after each transaction, with committed, pending and staged facts, plain and rule queries; `Snapshot::tx_bound` keeps the versions the executor's `tx_id <= t` filter keeps and is a counter bound exactly when `tx_id` rises with `tx_count`; the DICT's `tx_order`, `last_tx_at` (gaps, before the first and after the last transaction) and `tx_runs` against a scan; `live_keys` under range bounds equals net-assert over the kept records on random histories; `PendingStore::first_irregular` under `push`, `extend` and `of`; nested `or`/`or-join` in branches (one reading imports the branch cannot hash) under every subplan form; expressions and `not`s with no pattern first; `not` bodies with rule invocations; magic-set head constants and constants no cell equals; every planner error's code and the error order. The two answer changes of the spec (§4) and an unknown predicate in a `not` body are checked against both the engine and the executor, with the oracle exempted. +- **The engine runs every query** (`src/query/engine/tests.rs`, 6 tests and 2 changed; `src/query/datalog/executor.rs`, 2 tests; `src/storage/persistent_facts.rs`, 2 tests and 1 extended; `src/graph/storage.rs`, 1 test; `tests/plan_independence_test.rs`, 1 test; `tests/disjunction_test.rs`, 1 changed; #551): `:as-of` timestamps on `LogWriter` files whose `tx_id`s rise and whose `tx_id`s fall and rise, before, between, at and after each transaction, with committed, pending and staged facts, plain and rule queries; `Snapshot::tx_bound` keeps the versions the executor's `tx_id <= t` filter keeps and is a counter bound exactly when `tx_id` rises with `tx_count`; the DICT's `tx_order`, `last_tx_at` (gaps, before the first and after the last transaction) and `tx_runs` against a scan; `live_keys` under range bounds equals net-assert over the kept records on random histories; `PendingStore::first_irregular` under `push`, `extend` and `of`; nested `or`/`or-join` in branches (one reading imports the branch cannot hash) under every subplan form; expressions and `not`s with no pattern first; `not` bodies with rule invocations; magic-set head constants and constants no cell equals; every planner error's code and the error order. The two answer changes of the spec (§4) and an unknown predicate in a `not` body were checked against both the engine and the executor; their tests keep the engine's answer. - **Statement reader** (`src/query/datalog/parser/statement.rs`, 8 tests; `tests/read_only_open_test.rs`, 1 test; #550): every `transact`/`retract` built from up to three of 34 statement tokens (balanced or not) in 10 templates, and a corpus of statements with errors in several phases (a later lexer error over an earlier structure error, a later structure error over an earlier fact error, phase 3 in today's check order, too-deep nesting inside a fact and an extra element), give the same command or error through the reader as through the whole-input parser, and the same facts or error through the write path at chunk sizes 1, 2, 3 and the default; the sequences raise 24 distinct codes and reach pass 2; pass 2 resumes just after the last kept fact; materialisation and window errors come with the facts, after `API-014` on a read-only database; the parser's `keep` flag checks structure and holds nothing; lexer offsets are byte offsets. - **Copy-on-write delete** (`src/storage/btree.rs`, 3 tests; #550): `cow_update` against a `BTreeSet` model over random insert and delete batches (samples, contiguous runs that empty leaves and subtrees, a deleted key inserted again) on trees of 0 to 60,000 keys, each step walked as `verify` walks a tree, every page of the old tree unchanged, `freed` exactly the old nodes dropped; deleting everything, front half first, gives root 0 and root 0 takes inserts again; a missing, unsorted or repeated delete, or a delete on root 0, is `INT-049`. -- **Large transactions** (`src/storage/persistent_facts/large_tx.rs`, 7 tests; `src/fault_matrix.rs`, 4 tests; `src/storage/page.rs`, 2 tests; `src/storage/cache.rs`, `src/storage/btree.rs` and `statement.rs`, 4 tests; #550): a `transact`/`retract` of more than one chunk, run by `Minigraf::execute` on a file database at chunk sizes 1 to 4, stores the same records as the one-chunk path (repeats across chunks stored once, several values and windows of one attribute, shared long values, refs, keywords, transaction-level windows, retractions, pending WAL entries committed with it), returns its `tx_id`, answers `:as-of`, passes `verify`, deletes the WAL and survives reopen; another window of a triple an earlier chunk wrote (`API-011`) and a value too long for a checkpoint in a later chunk (`WAL-003`) give the one-chunk path's code and message, take no `tx_count`, write no meta and leave the WAL, and the next checkpoint writes a meta before deleting it, as the first checkpoint after an open with a WAL does; a crash before the meta write on a new file reopens through the WAL guard, and is `STG-033` without it; cursors and fact logs opened before and between chunks keep their snapshot through later checkpoints. The fault matrix injects every write and sync fault at every call of a large transaction on a file with one and with two valid meta slots, with and without a WAL beforehand. Allocator tracking and release, cache eviction, and cursor peeking have unit tests. With `test-oracle`, `tests/crash_kill_test.rs` adds a variant whose child makes most transactions large and rolls back a large statement after writing pages, and `tests/model_based_test.rs` runs at a chunk size of 2; `tests/large_transaction_acceptance_test.rs` (ignored, `test-oracle` only, nightly in `.github/workflows/smoke.yml`) holds at most 65,536 materialised facts (the default chunk) for a 1M-fact `transact` and prints peak RSS. -- **Statement bases and large write transactions** (`src/storage/persistent_facts/large_tx.rs`, 9 tests; `src/fault_matrix.rs`, 4 tests; `src/storage/page.rs` and `src/storage/btree.rs`, 2 tests; `tests/memory_limit_test.rs`, 1 test changed; #550): a `WriteTransaction` of statements that repeat, change, retract and re-assert earlier statements' facts within and across chunks, including two that fail `API-011` (one only through a repeat of an earlier statement's fact, the claims case), run at chunk sizes 1 to 4, gives every statement the small path's outcome and stores the same records, over one transaction and over two with committed and pending facts between them, passes `verify` and survives reopen; queries after each statement, inside the transaction at chunk sizes none and 1 to 4, return what a commit of the statements so far holds (including a staged retraction of a pending assertion and the reverse); a failed statement that replaced pages of the committed generation leaves them in use (`verify` after later checkpoints); a rolled-back large transaction leaves the file, generation and records as they were and the next checkpoint writes a meta; one whose only statement failed commits nothing and takes no `tx_count`; a staged window that has ended when the transaction becomes large rejects that statement with `API-019`, writes nothing and leaves the transaction small; a failed handle is refused (`STG-046`) when a transaction would become large, and a write failure inside one fails its commit with `STG-046` and leaves the file as it was. The fault matrix injects every fault at every call of a large `WriteTransaction` (staged statement, large statement, a failing one, then one changing earlier triples) on one and two meta slots, with and without a WAL. `OpenOptions::transaction_chunk_facts` sets the chunk size (0 is 1, above 1,000,000 is 1,000,000). Base id tracking and `tree_pages` have unit tests. With `test-oracle`, the crash-kill `Large` variant runs every third transaction as a `WriteTransaction` of three statements, and the model-based test's write-transaction steps cross chunks and statement bases at chunk size 2. Queries inside a write transaction run on the engine and count toward `query_memory_limit` with staged writes too. +- **Large transactions** (`src/storage/persistent_facts/large_tx.rs`, 7 tests; `src/fault_matrix.rs`, 4 tests; `src/storage/page.rs`, 2 tests; `src/storage/cache.rs`, `src/storage/btree.rs` and `statement.rs`, 4 tests; #550): a `transact`/`retract` of more than one chunk, run by `Minigraf::execute` on a file database at chunk sizes 1 to 4, stores the same records as the one-chunk path (repeats across chunks stored once, several values and windows of one attribute, shared long values, refs, keywords, transaction-level windows, retractions, pending WAL entries committed with it), returns its `tx_id`, answers `:as-of`, passes `verify`, deletes the WAL and survives reopen; another window of a triple an earlier chunk wrote (`API-011`) and a value too long for a checkpoint in a later chunk (`WAL-003`) give the one-chunk path's code and message, take no `tx_count`, write no meta and leave the WAL, and the next checkpoint writes a meta before deleting it, as the first checkpoint after an open with a WAL does; a crash before the meta write on a new file reopens through the WAL guard, and is `STG-033` without it; cursors and fact logs opened before and between chunks keep their snapshot through later checkpoints. The fault matrix injects every write and sync fault at every call of a large transaction on a file with one and with two valid meta slots, with and without a WAL beforehand. Allocator tracking and release, cache eviction, and cursor peeking have unit tests. With `test-hooks`, `tests/crash_kill_test.rs` adds a variant whose child makes most transactions large and rolls back a large statement after writing pages, and `tests/model_based_test.rs` runs at a chunk size of 2; `tests/large_transaction_acceptance_test.rs` (ignored, `test-hooks` only, nightly in `.github/workflows/smoke.yml`) holds at most 65,536 materialised facts (the default chunk) for a 1M-fact `transact` and prints peak RSS. +- **Statement bases and large write transactions** (`src/storage/persistent_facts/large_tx.rs`, 9 tests; `src/fault_matrix.rs`, 4 tests; `src/storage/page.rs` and `src/storage/btree.rs`, 2 tests; `tests/memory_limit_test.rs`, 1 test changed; #550): a `WriteTransaction` of statements that repeat, change, retract and re-assert earlier statements' facts within and across chunks, including two that fail `API-011` (one only through a repeat of an earlier statement's fact, the claims case), run at chunk sizes 1 to 4, gives every statement the small path's outcome and stores the same records, over one transaction and over two with committed and pending facts between them, passes `verify` and survives reopen; queries after each statement, inside the transaction at chunk sizes none and 1 to 4, return what a commit of the statements so far holds (including a staged retraction of a pending assertion and the reverse); a failed statement that replaced pages of the committed generation leaves them in use (`verify` after later checkpoints); a rolled-back large transaction leaves the file, generation and records as they were and the next checkpoint writes a meta; one whose only statement failed commits nothing and takes no `tx_count`; a staged window that has ended when the transaction becomes large rejects that statement with `API-019`, writes nothing and leaves the transaction small; a failed handle is refused (`STG-046`) when a transaction would become large, and a write failure inside one fails its commit with `STG-046` and leaves the file as it was. The fault matrix injects every fault at every call of a large `WriteTransaction` (staged statement, large statement, a failing one, then one changing earlier triples) on one and two meta slots, with and without a WAL. `OpenOptions::transaction_chunk_facts` sets the chunk size (0 is 1, above 1,000,000 is 1,000,000). Base id tracking and `tree_pages` have unit tests. With `test-hooks`, the crash-kill `Large` variant runs every third transaction as a `WriteTransaction` of three statements, and the model-based test's write-transaction steps cross chunks and statement bases at chunk size 2. Queries inside a write transaction run on the engine and count toward `query_memory_limit` with staged writes too. - **Grammar page** (`tests/grammar_doc.rs`, 10 tests; #643): `docs/GRAMMAR.md` matches the EBNF rendered from `tests/grammar/grammar.pest`; each rendering rule (sequence, choice and grouping, names and builtins, `SOI`/`EOI` dropped, lookaheads as comments, bounded repetition, quoting, token marks, section titles, line breaking, the whitespace note and the comment note it joins) on a small grammar. -- **Plan independence** (`tests/plan_independence_test.rs`, 15 tests, `test-oracle` feature only; #596): a matrix of queries (joins in both text orders, cross products, keyword and ref, floats, long strings, filter and binding expressions, recursive rules and rules with `not`, `or`/`or-join` including the #250 short-circuit shapes, placed and deferred `not`/`not-join`, aggregates, `:as-of`, `:valid-at`, `:any-valid-time`), in memory and on file after a checkpoint and a reopen, through `execute` and a cursor, gives the same bag of rows with clause reordering on and off (`minigraf::__reorder`) and with the engine's negation bodies and `or` branches chosen, forced hashed and forced correlated (`minigraf::__subplans`, #546; the matrix gains #546's negation and disjunction shapes); #596's example and the unification cases (an expression whose output is its input, two expressions on one variable, integer vs float, `-0.0` vs `0.0`); and `or` / `or-join` branches whose expressions read or bind from a variable only the outer row binds, nested and in rule bodies (#620); and expressions, chains of them and a `not` after them, reading a variable only an `or` binds, in queries, with rules and in rule bodies (#625; `tests/disjunction_test.rs` repeats them without `test-oracle`). Under `test-oracle` the model-based and property tests also rerun every generated query with reordering off (the property test also with negation bodies and `or` branches forced hashed; it generates `or` / `or-join` over bound variables, #546). Unit tests cover `branch_outer_reads` (#620), the planner deferring an expression only an `or` can bind for, after the expressions placed before it and ahead of the deferred `not`s (#625), `apply_expr` (equal, different, integer vs float, NaN, `-0.0`/`0.0` with and without replacing, keyword vs ref both ways, a failing expression), `Binders::expression`, the switch (source order kept, per thread, restored on drop), and the engine planner's `Bind` modes and build side with the switch off; the engine's join matrix gains six unification shapes. +- **Plan independence** (`tests/plan_independence_test.rs`, 16 tests, `test-hooks` feature only; #596): a matrix of queries (joins in both text orders, cross products, keyword and ref, floats, long strings, filter and binding expressions, recursive rules and rules with `not`, `or`/`or-join` including the #250 short-circuit shapes, placed and deferred `not`/`not-join`, aggregates, `:as-of`, `:valid-at`, `:any-valid-time`), in memory and on file after a checkpoint and a reopen, through `execute` and a cursor, gives the same bag of rows with clause reordering on and off (`minigraf::__reorder`) and with the engine's negation bodies and `or` branches chosen, forced hashed and forced correlated (`minigraf::__subplans`, #546; the matrix gains #546's negation and disjunction shapes); #596's example and the unification cases (an expression whose output is its input, two expressions on one variable, integer vs float, `-0.0` vs `0.0`); and `or` / `or-join` branches whose expressions read or bind from a variable only the outer row binds, nested and in rule bodies (#620); and expressions, chains of them and a `not` after them, reading a variable only an `or` binds, in queries, with rules and in rule bodies (#625; `tests/disjunction_test.rs` repeats them without `test-oracle`). Under `test-oracle` the model-based and property tests also rerun every generated query with reordering off (the property test also with negation bodies and `or` branches forced hashed; it generates `or` / `or-join` over bound variables, #546). Unit tests cover `branch_outer_reads` (#620), the planner deferring an expression only an `or` can bind for, after the expressions placed before it and ahead of the deferred `not`s (#625), `apply_expr` (equal, different, integer vs float, NaN, `-0.0`/`0.0` with and without replacing, keyword vs ref both ways, a failing expression), `Binders::expression`, the switch (source order kept, per thread, restored on drop), and the engine planner's `Bind` modes and build side with the switch off; the engine's join matrix gains six unification shapes. - **WAL entries of any size** (`src/wal.rs`, 3 tests, 1 replacing the 1,000,000-fact cap test; #686): an entry of 1,000,001 facts and the entries after it replay, and reopening the writer cuts none of them off; a fact count the bytes after it cannot hold (one more than a quarter of them, or `u64::MAX`) ends replay at that entry, and reopening the writer cuts the WAL off there. A count the bytes could hold whose facts are cut short, at a fact's length or inside its bytes, also ends replay there. - **Kani proofs of the encoders** (#627; not `#[test]`s, run by `cargo kani` and `.github/workflows/kani.yml`): 12 harnesses prove, for every input, that the byte encoders ordering index keys keep their order. `src/storage/keys/verification.rs` (7): `put_int`, `put_uint` and `put_valid_to` (including `VALID_TIME_FOREVER`) preserve order, `put_tx_desc` reverses it, `float_bits` preserves IEEE total order on non-NaN floats (`-0.0` before `0.0`), maps every NaN to one value after all others, and round-trips through `float_from_bits`. `src/storage/index/verification.rs` (5): `encode_value` writes `Null` as `[0x00]` and each of `Boolean`, `Integer`, `Float` and `Ref` with its own type byte and in its own order, and every NaN to the same bytes. Each harness fails when its encoder is broken on purpose. Decoders, strings, packed pages and the WAL are left out: CBMC does not finish on them (decoder error paths build an `anyhow::Error`; a 3-byte string order proof is a 105M-clause formula), so the fuzz and property tests cover them (spec `docs/superpowers/specs/2026-10-22-kani-storage-encoding-design.md` §5). - **Public diagnostics**: structured parser, query, storage, WAL, API, and internal error codes; the error-code registry is checked against [`ERROR_REFERENCE.md`](ERROR_REFERENCE.md). @@ -51,8 +51,8 @@ The fourteen ignored tests are intentionally excluded from a normal local run: - One soak test at 10M facts (`soak`), run weekly by `.github/workflows/soak.yml` (#392); `soak_short` runs the same driver at 20K facts in the normal suite. The memory bound is measured in a child process (`soak_memory_child`, #542). - 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): 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`; run by the nightly smoke workflow. -- Two query-memory acceptance tests (`tests/memory_limit_acceptance_test.rs`, #549, #575): 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; 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`. Run one at a time by the nightly smoke workflow, without `test-oracle`. -- 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 without the executor oracle. +- Two query-memory acceptance tests (`tests/memory_limit_acceptance_test.rs`, #549, #575): 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; 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`. Run one at a time by the nightly smoke workflow. +- 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. ### Reproducing diff --git a/docs/superpowers/plans/2026-10-23-551-executor-removal.md b/docs/superpowers/plans/2026-10-23-551-executor-removal.md index 20eb99f994..471ddefab8 100644 --- a/docs/superpowers/plans/2026-10-23-551-executor-removal.md +++ b/docs/superpowers/plans/2026-10-23-551-executor-removal.md @@ -7,7 +7,7 @@ called "the spec" below. PRs target `v3`, merge commits. None uses a closing key | PR | Steps | Branch | |---|---|---| | 1 | 1–13: the engine runs every query (spec §3, §4) | `feat/551-engine-everywhere` | -| 2 | delete the executor's query path and the oracle, `test-hooks`, size gate (spec §5) | planned after PR 1 | +| 2 | 14–21: delete the executor's query path and the oracle, `test-hooks`, size gate (spec §5) | `feat/551-delete-executor` | | 3 | measurement, acceptance, docs (spec §6, §7) | planned after PR 2 | Each PR leaves `v3` with no unused code outside `cfg(test)` and the oracle's `cfg`, and updates @@ -170,3 +170,114 @@ the executor's answer for the shape, through the oracle, and the step then keeps 13. **Docs and size:** `CLAUDE.md` module notes (engine runs every query, executor path is the oracle), test counts in `CLAUDE.md` and `docs/TEST_COVERAGE.md`; the release binary's size in the PR description. + +## Decisions not fixed by the spec (PR 2) + +PR 1 left everything PR 2 deletes under `cfg(any(test, feature = "test-oracle"))`: the release +binary already lacks it (1,140 KiB), so PR 2 is a deletion with no answer change, and every item +under that `cfg` is classified as one of: + +- **oracle**: reached only from the oracle (`engine/oracle.rs`, `DatalogExecutor::oracle`, the + executor's query path, `PatternMatcher`, the two evaluators, `evaluate_not_join`). Deleted. +- **test helper**: also used by `cfg(test)` code outside the oracle (for example + `FactStorage::get_all_facts` in `persistent_facts.rs`' tests, `get_asserted_facts` in + `db.rs`' tests, `Fact::new` in `wal.rs`' tests). Its `cfg` becomes `cfg(test)`. A helper used + only by its own unit tests is deleted with them. +- **test hook**: the thread-local switches behind `__reorder`, `__subplans`, + `__tx_chunk_facts` and `__statement_facts_high_water`. Their `cfg` becomes + `cfg(any(test, feature = "test-hooks"))`. + +13. **Unit tests that query through `DatalogExecutor::execute` stay where they are (deviation 6).** + After PR 1, `execute` runs a query on the engine (`execute_query` → `open_query`), so these + tests already check the engine's answer; moving them to `Minigraf::in_memory` (spec §5.2) + would change only their setup. Tests that call a deleted function + (`execute_query_on_executor`, `execute_query_with_rules`, `filter_facts_for_query`, + `apply_post_processing`, `apply_expr_clauses`, `evaluate_branch`, `branch_outer_reads`, + `apply_window_functions`, `selective_fact_fetch` and the like) are deleted, except that a + test whose query and expected answer are not already checked on the engine elsewhere is + rewritten to run that query through `execute` and keep its expected answer. The PR lists + each deleted test and the engine test that covers its shape. +14. **The two answer-change tests keep only the engine's answer.** Each asserted the executor's + answer through the oracle and the engine's; the executor's answer becomes a comment, with + the spec §4 item it documents. `oracle::exempt` goes with the oracle. +15. **`RUNS` stays** (`cfg(test)`): the routing tests assert with it that a query ran on the + engine and how often, which still guards against a second path coming back. +16. **CI.** `rust.yml`'s `oracle` job becomes `test-hooks` (`cargo test --features test-hooks`): + `plan_independence_test` and the `__subplans`/`__tx_chunk_facts` variants of the model, + property and crash tests still need the feature. `smoke.yml` passes `--features test-hooks`. + `crash-kill.yml` checks `^test-hooks = ` on `v3` and, in a separate PR, on `main`, so the + file stays the same on both (#687); `main` defines neither feature, so its run is unchanged. +17. **Coverage floors.** Deleting tested code changes the per-file and whole-crate ratios. If a + floor in the coverage workflow fails, the PR reports the new figure; a floor is lowered only + for a file whose remaining code is no less covered than before (checked line by line). + +18. **Frozen answers (found in step 15).** `query::engine::tests`, `tests/recursive_engine_test.rs` + and `tests/plan_independence_test.rs` checked their answers through the oracle only (the + engine unit tests' `rows()` returns a row count). Before the oracle goes, each of their + queries' answers is recorded, on the commit before step 15 with the oracle on, in + `tests/answers/.txt`: one line per test, query digest and answer (row count and a + digest of the rows as a bag). After it, each answer must be one of its query's recorded + ones in that test. Integers within a week of now (wall-clock `tx-id`s, default + `valid-from`s, a query's own `valid-at`) compare as "now". `MINIGRAF_BLESS_ANSWERS=1` + records instead; a changed file is a changed answer, justified in review. + +## Deviations from the spec (PR 2) + +6. §5.2's move of executor-level query tests to `Minigraf::in_memory` is not needed: they run + on the engine already (decision 13). +7. §5.2 assumed only the model-based, property and golden suites had their own oracle; three + more suites relied on the executor, and keep its answers frozen (decision 18). +8. §5.4's `SIZE_GATE: fail` is the gate without `SIZE_GATE`: the report-only branch goes with + it, so `binary-size.yml` differs from `main`'s only in its branch filters. + +## PR 2 steps + +Each step builds and passes clippy on all targets and features (`cargo clippy --all-targets`, +with `--features test-oracle`/`test-hooks`, `--no-default-features`, `wasm32-unknown-unknown` +with `browser`, `wasm32-wasip1`) and leaves the suite passing with and without the feature. + +14. **Plan.** This section. +15. **The oracle goes** (decisions 14, 15): `engine/oracle.rs`, the `check` blocks in + `open_query` and `open_rule_query`, `DatalogExecutor::oracle`; the two answer-change tests + keep the engine's answer. The `engine/mod.rs` docs say the engine is the only query path. +16. **The executor's query path goes** (decision 13): every `oracle` item in `executor.rs` + (`execute_query_on_executor`, `execute_query_with_rules`, `filter_facts_for_query`, + `live_source_facts`, `selective_fact_fetch`, `evaluate_branch`, `apply_or_clauses`, + `apply_expr_clauses`, `apply_post_processing` and every helper only they call), the imports + only they use, and their unit tests (`selective_lookup_tests`, `pushdown_tests` and the + rest, per decision 13). `eval_expr`, `is_truthy` and `Binders` stay; where the engine is + their only user they move to `query/engine/` (spec §5.1) in the same step. +17. **`PatternMatcher` and the evaluators go:** `matcher.rs` keeps `edn_to_value` and + `edn_to_entity_id` and their tests; `evaluator.rs` keeps `rule_invocation_to_pattern`, + `DEFAULT_MAX_ITERATIONS`, `DEFAULT_MAX_DERIVED_FACTS`, `derived_facts_exceeded`, + `iterations_exceeded` and their tests. Comments that name the deleted types + (`tests/error_codes_qry_test.rs`, `tests/not_join_test.rs`, `benches/minigraf_bench.rs`, + `stratification.rs`, `prepared.rs`, `plan.rs`, `db.rs`, `browser/mod.rs`) name what runs the + query now. +18. **Storage and type helpers** (classification above): in `graph/storage.rs` + (`all_facts`, `facts_as_of`, `live_facts_of_scans`, `get_all_facts`, `get_asserted_facts`, + `filter_facts_as_of`, `load_fact`/`restore_tx_counter`'s `cfg`), `storage/mod.rs` + (`CommittedReader::all_facts`, `facts_for_entity`, `facts_for_entity_attribute`, + `facts_for_attribute`, `live_facts`; `TxBound::of`), `storage/reader.rs` (their + implementations, `scan`, `live_scan`), `storage/dict.rs` (`seed_entity`, `seed_ident`), + `graph/types.rs` (`Fact::new`, `is_asserted`), `datalog/types.rs` (`FindSpec::var`, + `get_top_level_rule_invocations`), `optimizer.rs` (`plan`), `aggregate.rs` imports. After + this step no `test-oracle` `cfg` remains outside the hooks. +19. **`test-oracle` → `test-hooks`** (decision 16): `Cargo.toml`, `lib.rs`'s four hooks, the + hook `cfg`s in `optimizer.rs` and `parser/statement.rs`, the integration tests' `cfg`s and + doc comments (`crash_kill_test`, `model_based_test`, `property_test`, `integrity_test`, + `plan_independence_test`, `large_transaction_acceptance_test`, `memory_limit_acceptance_test`, + `recursive_engine_test`, `aggregate_window_rules_test`), `rust.yml`, `smoke.yml`, + `crash-kill.yml`; the unreleased `CHANGELOG.md` entries that name `test-oracle` (#596, #546). + A separate PR to `main` changes `crash-kill.yml`'s check; `git diff main v3 -- + .github/workflows/crash-kill.yml` is empty after both. +20. **Size gate** (spec §5.4): `binary-size.yml` on `v3` sets `SIZE_GATE: fail` and + `SIZE_LIMIT_BYTES: 1228800`, its temporary comment goes, and PHILOSOPHY.md §4's v3 note goes + (#680). If the release binary is over 1,200 KiB, stop and report `cargo bloat --release + --crates` and `-n 30` before any change to the limit. +21. **Docs, counts, verification:** `CLAUDE.md` module notes (`executor.rs` without its query + path, `matcher.rs`, `evaluator.rs`, `engine/oracle.rs` gone, `test-hooks`), test counts in + `CLAUDE.md` and `docs/TEST_COVERAGE.md` (its oracle notes too); the full suite plain and with + `--features test-hooks`, the wasm targets and the coverage workflow's commands on the bench + machine; the release binary's size and the deleted-test list (decision 13) in the PR + description. `CHANGELOG.md`'s migration notes and the docs site stay for PR 3. diff --git a/src/graph/storage.rs b/src/graph/storage.rs index 3f6cdf33ca..87790470b7 100644 --- a/src/graph/storage.rs +++ b/src/graph/storage.rs @@ -2,7 +2,7 @@ use crate::error::{ErrorCode, bail_coded, err_coded}; use crate::graph::types::{ Attribute, EntityId, Fact, TransactOptions, TxId, VALID_TIME_FOREVER, Value, tx_id_now, }; -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(test)] use crate::query::datalog::types::AsOf; use crate::storage::TxBound; use crate::storage::index::{Indexes, encode_value}; @@ -426,7 +426,7 @@ impl Snapshot { /// Every record of the snapshot (assertions and retractions): committed /// facts first, in EAVT order, then the pending facts in append order. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn all_facts(&self) -> Result> { let mut all = match &self.committed { Some(reader) => reader.all_facts()?, @@ -437,7 +437,7 @@ impl Snapshot { } /// The records of the snapshot visible as of `as_of`. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn facts_as_of(&self, as_of: &AsOf) -> Result> { Ok(filter_facts_as_of(self.all_facts()?, as_of)) } @@ -451,7 +451,7 @@ impl Snapshot { /// over every record of the scan up to `as_of` (see /// [`CommittedReader::live_facts`](crate::storage::CommittedReader::live_facts)), /// but committed history is not translated into facts. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn live_facts_of_scans( &self, scans: &[crate::storage::Scan<'_>], @@ -780,7 +780,7 @@ impl FactStorage { /// /// Checks for duplicate facts before loading (based on entity, attribute, value, /// valid_from, valid_to, tx_count, and asserted). - #[cfg(any(test, feature = "test-oracle", not(target_arch = "wasm32")))] + #[cfg(any(test, not(target_arch = "wasm32")))] pub(crate) fn load_fact(&self, fact: Fact) -> Result { self.write_pending(|p| p.push(fact)) } @@ -819,7 +819,7 @@ impl FactStorage { /// `transact()` call picks up from the right sequence number. The counter /// never moves backwards: it may already hold the file's checkpointed count, /// and when WAL replay loads no facts that count must survive (#447). - #[cfg(any(test, feature = "test-oracle", not(target_arch = "wasm32")))] + #[cfg(any(test, not(target_arch = "wasm32")))] pub(crate) fn restore_tx_counter(&self) -> Result<()> { let d = self .data @@ -856,7 +856,7 @@ impl FactStorage { /// Returns the complete append-only log. For current state, filter by /// asserted=true and take the most recent fact for each (E, A) pair. /// Includes both committed (on-disk) facts and pending (in-memory) facts. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn get_all_facts(&self) -> Result> { self.snapshot()?.all_facts() } @@ -874,7 +874,7 @@ impl FactStorage { /// /// Returns only facts where asserted=true. This gives you the currently /// valid facts, but includes all historical versions. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn get_asserted_facts(&self) -> Result> { let all = self.get_all_facts()?; Ok(all.into_iter().filter(|f| f.is_asserted()).collect()) @@ -995,7 +995,7 @@ impl FactStorage { /// Apply transaction-time snapshot semantics to a batch of facts. /// /// Used by `Snapshot::facts_as_of`. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(test)] pub(crate) fn filter_facts_as_of(facts: Vec, as_of: &AsOf) -> Vec { facts .into_iter() @@ -1028,12 +1028,13 @@ pub(crate) fn filter_facts_as_of(facts: Vec, as_of: &AsOf) -> Vec { /// (NaN canonicalisation, ±0.0 disambiguation) consistently with the rest of /// the storage layer. /// -/// This is the single source of truth for retraction semantics, shared by -/// `get_current_value` and `filter_facts_for_query`. +/// This is the single source of truth for retraction semantics over facts: +/// the engine's pending scans use it (committed keys decide net-assert on +/// the keys, #379), and so do the tests' fact-level reads. /// /// # Implementation note /// -/// Hot path for every non-`:as-of` query (#323). Each value is encoded once; +/// Hot path for a query's pending facts (#323). Each value is encoded once; /// the group maps borrow `(entity, attribute, value_bytes)` from the input /// instead of cloning them. They keep std's randomly keyed hasher on purpose: /// values are often untrusted text (agent memory), and a fixed-seed fast hash @@ -1044,7 +1045,6 @@ pub(crate) fn filter_facts_as_of(facts: Vec, as_of: &AsOf) -> Vec { /// /// Idempotent under duplicated input records (a duplicate assertion is kept /// once per window; a duplicate retraction leaves the max unchanged). -/// `selective_fact_fetch` relies on this instead of deduplicating. pub(crate) fn net_asserted_facts(facts: Vec) -> Vec { use std::collections::{HashMap, HashSet}; diff --git a/src/graph/types.rs b/src/graph/types.rs index 529224384c..be25ea038a 100644 --- a/src/graph/types.rs +++ b/src/graph/types.rs @@ -293,7 +293,7 @@ pub(crate) struct Fact { impl Fact { /// Create a new asserted fact with default valid time (valid_from=tx_id, valid_to=FOREVER). - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn new(entity: EntityId, attribute: Attribute, value: Value, tx_id: TxId) -> Self { Fact { entity, @@ -349,7 +349,7 @@ impl Fact { } /// Check if this is an assertion (not a retraction) - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub(crate) fn is_asserted(&self) -> bool { self.asserted } diff --git a/src/lib.rs b/src/lib.rs index bdb1936bb2..afb08236c7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -74,6 +74,10 @@ //! - **Browser** (`wasm32-unknown-unknown` + `browser` feature) — `wasm-pack build --target web --features browser` //! - **WASI / server-side** (`wasm32-wasip1`) — `cargo build --target wasm32-wasip1 --release --bin minigraf` +// The engine's unit tests share `tests/answers/`, which names the crate. +#[cfg(all(test, not(target_arch = "wasm32")))] +extern crate self as minigraf; + /// Incremental delivery of query results: [`Cursor`] and [`Batch`]. pub mod cursor; pub mod db; @@ -122,52 +126,52 @@ pub use query::datalog::types::{AsOf, ValidAt}; pub use query::datalog::prepared::{BindValue, PreparedQuery}; // Plan-independence tests (#596): run queries without reordering. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub use query::datalog::optimizer::ReorderGuard; /// Turns clause reordering on or off for queries on this thread until the /// returned guard drops. Only for tests that check no answer depends on the -/// plan (#596); built with the `test-oracle` feature only. -#[cfg(feature = "test-oracle")] +/// plan (#596); built with the `test-hooks` feature only. +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub fn __reorder(on: bool) -> ReorderGuard { query::datalog::optimizer::set_reorder(on) } // Large-transaction tests (#550): statements read and written in small chunks. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub use query::datalog::parser::statement::TxChunkGuard; /// Sets how many facts a `transact` or `retract` materialises at once on this /// thread until the returned guard drops (`None`: the built-in size), so a /// statement with more facts takes the large-transaction path (#550). Only -/// for tests; built with the `test-oracle` feature only. -#[cfg(feature = "test-oracle")] +/// for tests; built with the `test-hooks` feature only. +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub fn __tx_chunk_facts(n: Option) -> TxChunkGuard { query::datalog::parser::statement::set_tx_chunk_facts(n) } /// The most materialised statement facts this thread held at once since the -/// last call (#550 acceptance). Built with the `test-oracle` feature only. -#[cfg(feature = "test-oracle")] +/// last call (#550 acceptance). Built with the `test-hooks` feature only. +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub fn __statement_facts_high_water() -> usize { query::datalog::parser::statement::take_held_high_water() } // Plan-independence tests (#546): force how negation bodies and `or` branches run. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub use query::datalog::optimizer::{Subplans, SubplansGuard}; /// Forces how the streaming engine runs `not` / `not-join` bodies (hashed or /// correlated) on this thread until the returned guard drops. Only for tests /// that check both forms give the same rows (#546); built with the -/// `test-oracle` feature only. -#[cfg(feature = "test-oracle")] +/// `test-hooks` feature only. +#[cfg(feature = "test-hooks")] #[doc(hidden)] pub fn __subplans(mode: Subplans) -> SubplansGuard { query::datalog::optimizer::set_subplans(mode) diff --git a/src/query/datalog/evaluator.rs b/src/query/datalog/evaluator.rs index 038e4b16b9..40880d3efd 100644 --- a/src/query/datalog/evaluator.rs +++ b/src/query/datalog/evaluator.rs @@ -1,51 +1,6 @@ -/// Recursive rule evaluation using semi-naive fixed-point iteration. -/// -/// This module implements the semi-naive evaluation algorithm for recursive Datalog rules. -/// The algorithm repeatedly applies rules to derive new facts until no new facts can be -/// derived (fixed point is reached). -/// -/// # Algorithm Overview -/// -/// 1. Start with base facts from database -/// 2. Apply rules to generate derived facts -/// 3. Track "delta" (new facts generated in this iteration) -/// 4. In next iteration, only apply rules to delta facts (semi-naive optimization) -/// 5. Stop when delta is empty (fixed point) or max iterations reached -/// -/// # Example -/// -/// ```ignore -/// // Facts: A->B, B->C -/// // Rule: (reachable ?x ?y) <- [?x :connected ?y] -/// // (reachable ?x ?y) <- [?x :connected ?z] (reachable ?z ?y) -/// // -/// // Iteration 0: delta = {A->B, B->C} -/// // Iteration 1: Apply rules, derive {A->C}, delta = {A->C} -/// // Iteration 2: No new facts, delta = {}, STOP -/// ``` -#[cfg(any(test, feature = "test-oracle"))] -use super::functions::FunctionRegistry; -#[cfg(any(test, feature = "test-oracle"))] -use super::matcher::{Bindings, PatternMatcher, edn_to_entity_id, edn_to_value}; -#[cfg(any(test, feature = "test-oracle"))] -use super::rules::RuleRegistry; use super::types::{EdnValue, Pattern}; -#[cfg(any(test, feature = "test-oracle"))] -use super::types::{Rule, ValidAt, WhereClause}; use crate::error::{ErrorCode, err_coded}; -#[cfg(any(test, feature = "test-oracle"))] -use crate::graph::FactStorage; -#[cfg(any(test, feature = "test-oracle"))] -use crate::graph::types::{Fact, Value}; -#[cfg(any(test, feature = "test-oracle"))] -use crate::storage::index::encode_value; use anyhow::Result; -#[cfg(any(test, feature = "test-oracle"))] -use std::collections::BTreeSet; -#[cfg(any(test, feature = "test-oracle"))] -use std::collections::HashSet; -#[cfg(any(test, feature = "test-oracle"))] -use std::sync::{Arc, RwLock}; /// Default maximum iterations for recursive evaluation (kept for reference). #[allow(dead_code)] @@ -74,1650 +29,19 @@ pub(crate) fn iterations_exceeded(limit: usize) -> anyhow::Error { ) } -/// Recursive evaluator for Datalog rules using semi-naive evaluation. -/// -/// # Examples -/// -/// ```ignore -/// let evaluator = RecursiveEvaluator::new( -/// storage.clone(), -/// rules.clone(), -/// 1000 // max iterations -/// ); -/// -/// let derived_facts = evaluator.evaluate_recursive_rules(&["reachable"])?; -/// ``` -#[cfg(any(test, feature = "test-oracle"))] -pub struct RecursiveEvaluator { - /// Base fact storage - storage: FactStorage, - /// Rule registry - rules: Arc>, - /// Function registry for UDF predicates/aggregates - functions: Arc>, - /// Maximum iterations before giving up (prevents infinite loops) - max_iterations: usize, - /// Maximum facts the rules may derive in one evaluation; base facts do not count - max_derived_facts: usize, - /// The value a `:db/valid-at` pattern in a rule body binds (#617) - valid_at: Value, -} - -#[cfg(any(test, feature = "test-oracle"))] -impl RecursiveEvaluator { - /// Create a new recursive evaluator. - /// - /// # Arguments - /// * `storage` - Base fact storage - /// * `rules` - Rule registry - /// * `functions` - Function registry for UDF predicates/aggregates - /// * `max_iterations` - Safety limit (e.g., 1000) - /// * `max_derived_facts` - Maximum facts the rules may derive (base facts do not count) - #[cfg(any(test, feature = "test-oracle"))] - pub fn new( - storage: FactStorage, - rules: Arc>, - functions: Arc>, - max_iterations: usize, - max_derived_facts: usize, - ) -> Self { - RecursiveEvaluator { - storage, - rules, - functions, - max_iterations, - max_derived_facts, - valid_at: Value::Null, - } - } - - /// Set the value a `:db/valid-at` pattern in a rule body binds: the - /// query's valid time (#617). Without it the pattern binds `nil`. - #[cfg(any(test, feature = "test-oracle"))] - pub fn with_valid_at(mut self, valid_at: Value) -> Self { - self.valid_at = valid_at; - self - } - - /// Evaluate rules for given predicates using semi-naive fixed-point iteration. - /// - /// # Arguments - /// * `predicates` - Predicate names to evaluate (e.g., ["reachable"]) - /// - /// # Returns - /// A FactStorage containing all base facts + derived facts - /// - /// # Errors - /// Returns error if max iterations exceeded or evaluation fails - #[cfg(any(test, feature = "test-oracle"))] - pub fn evaluate_recursive_rules(&self, predicates: &[String]) -> Result { - // Start with base facts as initial delta - let base_facts = self.storage.get_asserted_facts()?; - - // Create storage for derived facts - let derived = FactStorage::new(); - - // Add base facts to derived storage as stored: a pseudo-attribute in a - // rule body reads their valid time and transaction (#661). - derived.load_facts(base_facts.iter().cloned())?; - derived.restore_tx_counter()?; - - // Track facts we've seen (for delta computation) using BTreeSet with canonical encoding. - let mut seen_facts: BTreeSet<(uuid::Uuid, String, Vec)> = base_facts - .iter() - .map(|f| { - let encoded = encode_value(&f.value); - (f.entity, f.attribute.clone(), encoded) - }) - .collect(); - // `max_derived_facts` limits the facts the rules derive, not the - // database (#528, #553). - let base_count = seen_facts.len(); - - let mut iteration = 0; - - // Fixed-point iteration - loop { - iteration += 1; - - if iteration > self.max_iterations { - return Err(iterations_exceeded(self.max_iterations)); - } - - // Evaluate rules once, get new facts - let new_facts = self.evaluate_iteration(predicates, &derived)?; - - // Compute delta: facts not yet seen - let mut delta = Vec::new(); - for fact in new_facts { - let encoded = encode_value(&fact.value); - let key = (fact.entity, fact.attribute.clone(), encoded); - if !seen_facts.contains(&key) { - // Check total derived-fact limit - if seen_facts.len() - base_count >= self.max_derived_facts { - return Err(derived_facts_exceeded(self.max_derived_facts)); - } - seen_facts.insert(key); - delta.push(fact); - } - } - - // If no new facts, we've reached fixed point - if delta.is_empty() { - break; - } - - // Add delta facts to derived storage, as derived (tx-count 0) - derived.load_facts(delta)?; - } - - Ok(derived) - } - - /// Evaluate all rules for given predicates once. - /// - /// This is a single iteration of the fixed-point loop. - /// It applies each rule to the current derived facts and returns newly derived facts. - #[cfg(any(test, feature = "test-oracle"))] - fn evaluate_iteration( - &self, - predicates: &[String], - current_facts: &FactStorage, - ) -> Result> { - let mut new_facts = Vec::new(); - - let registry = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - - // For each predicate, evaluate all its rules - for predicate in predicates { - let rules = registry.get_rules(predicate); - - for rule in rules { - let derived = self.evaluate_rule(&rule, current_facts)?; - new_facts.extend(derived); - } - } - - Ok(new_facts) - } - - /// Evaluate a single rule against current facts. - /// - /// # Algorithm - /// 1. Convert body patterns and rule invocations to Pattern structs - /// 2. Use PatternMatcher to find all bindings - /// 3. For each binding, instantiate rule head to create derived fact - #[cfg(any(test, feature = "test-oracle"))] - fn evaluate_rule(&self, rule: &Rule, current_facts: &FactStorage) -> Result> { - let mut derived = Vec::new(); - - // Separate Pattern/RuleInvocation clauses from Expr clauses - let mut patterns = Vec::new(); - let mut expr_clauses: Vec<&WhereClause> = Vec::new(); - for clause in &rule.body { - match clause { - WhereClause::Pattern(p) => { - patterns.push(p.clone()); - } - WhereClause::RuleInvocation { predicate, args } => { - // Convert (predicate arg0 arg1) → [arg0 :predicate arg1] - let list: Vec = std::iter::once(EdnValue::Symbol(predicate.clone())) - .chain(args.iter().cloned()) - .collect(); - let pattern = self.rule_invocation_to_pattern(&list)?; - patterns.push(pattern); - } - WhereClause::Not(_) => { - // Not clauses are handled by StratifiedEvaluator, not here. - return Err(err_coded!( - ErrorCode::Int021, - "WhereClause::Not in evaluate_rule: use StratifiedEvaluator for rules with negation" - )); - } - WhereClause::NotJoin { .. } => { - // NotJoin clauses are handled by StratifiedEvaluator, not here. - return Err(err_coded!( - ErrorCode::Int021, - "WhereClause::NotJoin in evaluate_rule: use StratifiedEvaluator for rules with negation" - )); - } - WhereClause::Expr { .. } => { - expr_clauses.push(clause); - } - WhereClause::Or(_) | WhereClause::OrJoin { .. } => { - // Or/OrJoin rules are routed to the mixed_rules path by StratifiedEvaluator before reaching here. - return Err(err_coded!( - ErrorCode::Int021, - "WhereClause::Or/OrJoin in evaluate_rule: not yet implemented" - )); - } - } - } - - if patterns.is_empty() && expr_clauses.is_empty() { - return Ok(derived); - } - - let matcher = - PatternMatcher::new(current_facts.clone()).with_valid_at(self.valid_at.clone()); - let bindings = if patterns.is_empty() { - // Expr-only rule body: seed with empty binding - vec![Bindings::new()] - } else { - matcher.match_patterns(&patterns) - }; - - // Apply Expr clauses to filter/extend bindings - let fn_guard = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - let bindings = apply_expr_clauses_in_evaluator(bindings, &expr_clauses, &fn_guard); - - for binding in bindings { - let fact = self.instantiate_head(&rule.head, &binding)?; - derived.push(fact); - } - - Ok(derived) - } - - /// Convert a rule invocation to a pattern. - /// - /// Example: (reachable ?x ?y) -> [?x :reachable ?y] - /// Example: (blocked ?x) -> [?x :blocked ?_rule_value] - #[cfg(any(test, feature = "test-oracle"))] - fn rule_invocation_to_pattern(&self, list: &[EdnValue]) -> Result { - if list.is_empty() { - return Err(err_coded!( - ErrorCode::Int022, - "Rule invocation cannot be empty" - )); - } - let predicate = match list.first() { - Some(EdnValue::Symbol(s)) => s.clone(), - Some(_) => { - return Err(err_coded!( - ErrorCode::Int022, - "Rule invocation must start with predicate name (symbol)" - )); - } - None => { - return Err(err_coded!( - ErrorCode::Int022, - "Rule invocation cannot be empty" - )); - } - }; - let args: Vec = list.get(1..).unwrap_or_default().to_vec(); - rule_invocation_to_pattern(&predicate, &args) - } - - /// Instantiate rule head with variable bindings to create a derived fact. - /// - /// # Example - /// Head: (reachable ?x ?y) - /// Bindings: {?x -> alice_uuid, ?y -> bob_uuid} - /// Result: Fact(alice_uuid, ":reachable", Ref(bob_uuid)) - #[cfg(any(test, feature = "test-oracle"))] - fn instantiate_head(&self, head: &[EdnValue], binding: &Bindings) -> Result { - if head.len() < 2 { - return Err(err_coded!( - ErrorCode::Int022, - "Rule head must have at least 2 elements: (predicate ?arg1)" - )); - } - - // head[0] is predicate name - let predicate = match head.first() { - Some(EdnValue::Symbol(s)) => s.clone(), - _ => { - return Err(err_coded!( - ErrorCode::Int022, - "Rule head must start with predicate name (symbol)" - )); - } - }; - - // head[1] is entity (usually a variable) - let head_1 = head - .get(1) - .ok_or_else(|| err_coded!(ErrorCode::Int022, "Rule head missing entity argument"))?; - let entity_edn = self.substitute_variable(head_1, binding)?; - // Only a ref or a keyword names an entity; anything else fails the - // query, on every path (#548). - let entity = edn_to_entity_id(&entity_edn).map_err(|_| { - let kind = edn_to_value(&entity_edn) - .map(|v| crate::query::datalog::aggregate::type_name(&v)) - .unwrap_or("symbol"); - err_coded!(ErrorCode::Qry013, predicate, kind) - })?; - - let value = if head.len() >= 3 { - // 2-arg head: (reachable ?from ?to) — value is head[2] - let head_2 = head - .get(2) - .ok_or_else(|| err_coded!(ErrorCode::Int022, "Rule head missing value argument"))?; - let value_edn = self.substitute_variable(head_2, binding)?; - edn_to_value(&value_edn).map_err(|e| { - err_coded!(ErrorCode::Int022, format!("Failed to convert value: {e}")) - })? - } else { - // 1-arg head: (blocked ?x) — store a Boolean(true) sentinel - crate::graph::types::Value::Boolean(true) - }; - - // Create fact with derived predicate as attribute - // Use ":predicate-name" as the attribute for derived facts - let attribute = format!(":{}", predicate); - - // A derived fact has no metadata: tx-count 0, which no stored fact - // has, makes a per-fact pseudo-attribute read `nil` from it (#548). - Ok(Fact::new(entity, attribute, value, 0)) - } - - /// Substitute a variable with its binding, or return as-is if not a variable. - #[cfg(any(test, feature = "test-oracle"))] - fn substitute_variable(&self, edn: &EdnValue, binding: &Bindings) -> Result { - match edn { - EdnValue::Symbol(s) if s.starts_with('?') => { - // This is a variable - if let Some(value) = binding.get(s) { - // Convert Value back to EdnValue for entity/value conversion - Ok(value_to_edn(value)) - } else { - Err(err_coded!( - ErrorCode::Int022, - format!("Unbound variable in rule head: {s}") - )) - } - } - _ => Ok(edn.clone()), // Not a variable, use as-is - } - } - - /// Public version of instantiate_head for use by StratifiedEvaluator. - #[cfg(any(test, feature = "test-oracle"))] - pub fn instantiate_head_public(&self, head: &[EdnValue], binding: &Bindings) -> Result { - self.instantiate_head(head, binding) - } -} - -/// Convert a stored Value back to EdnValue. -#[cfg(any(test, feature = "test-oracle"))] -pub fn value_to_edn(value: &Value) -> EdnValue { - match value { - Value::String(s) => EdnValue::String(s.clone()), - Value::Integer(i) => EdnValue::Integer(*i), - Value::Float(f) => EdnValue::Float(*f), - Value::Boolean(b) => EdnValue::Boolean(*b), - Value::Ref(uuid) => EdnValue::Uuid(*uuid), - Value::Keyword(k) => EdnValue::Keyword(k.clone()), - Value::Null => EdnValue::Symbol("nil".to_string()), - } -} - /// Convert a predicate name + argument list to a Pattern. /// /// 1-arg: `(blocked ?x)` → `[?x :blocked ?_rule_value]` /// 2-arg: `(reachable ?from ?to)` → `[?from :reachable ?to]` pub(crate) fn rule_invocation_to_pattern(predicate: &str, args: &[EdnValue]) -> Result { - match args.len() { - 1 => { - // Safety: length checked above - let arg0 = args - .first() - .ok_or_else(|| err_coded!(ErrorCode::Int022, "missing arg 0"))?; - Ok(Pattern::new( - arg0.clone(), - EdnValue::Keyword(format!(":{}", predicate)), - EdnValue::Symbol("?_rule_value".to_string()), - )) - } - 2 => { - let arg0 = args - .first() - .ok_or_else(|| err_coded!(ErrorCode::Int022, "missing arg 0"))?; - let arg1 = args - .get(1) - .ok_or_else(|| err_coded!(ErrorCode::Int022, "missing arg 1"))?; - Ok(Pattern::new( - arg0.clone(), - EdnValue::Keyword(format!(":{}", predicate)), - arg1.clone(), - )) - } - n => Err(err_coded!(ErrorCode::Int028, predicate, n)), - } -} - -/// The outer row's values of the variables a `not` body imports: every -/// variable the body names, `?_` ones aside (spec §2 of the #546 design). -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn not_seed(body: &[WhereClause], outer: &Bindings) -> Bindings { - crate::query::datalog::optimizer::clause_ref_vars(body) - .into_iter() - .filter(|v| !v.starts_with("?_")) - .filter_map(|v| outer.get(&v).map(|val| (v, val.clone()))) - .collect() -} - -/// The rows of a negation body's patterns and rule invocations, matched from -/// `seed`, the outer row's values of the variables the body imports. A seeded -/// variable is compared as a join compares it (`normalize_join_value`: floats -/// by IEEE `==`, a keyword equal to a ref to the entity it names), never -/// substituted as a literal (#546). Every row carries the seed; the caller -/// applies the body's expressions. -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn seeded_body_rows( - body: &[WhereClause], - seed: Bindings, - storage: Arc<[Fact]>, - valid_at: Value, -) -> Vec { - let patterns: Vec = body - .iter() - .filter_map(|c| match c { - WhereClause::Pattern(p) => Some(p.clone()), - // Rule-derived facts are already in `storage` (accumulated) from - // lower strata. - WhereClause::RuleInvocation { predicate, args } => { - rule_invocation_to_pattern(predicate, args).ok() - } - _ => None, - }) - .collect(); - PatternMatcher::from_slice_with_valid_at(storage, valid_at) - .match_patterns_seeded(&patterns, vec![seed]) -} - -/// Test whether a `not-join` body is satisfiable given a current binding. -/// -/// Returns `true` if the body IS satisfiable → outer binding should be **rejected**. -/// Returns `false` if the body cannot be satisfied → outer binding survives. -/// -/// The body is matched from the binding's join variables ([`seeded_body_rows`]), -/// with `valid_at` as the value a `:db/valid-at` pattern binds (#615), and its -/// expressions applied; any row left means the body is satisfiable. -#[cfg(any(test, feature = "test-oracle"))] -pub fn evaluate_not_join( - join_vars: &[String], - clauses: &[WhereClause], - binding: &Bindings, - storage: Arc<[Fact]>, - valid_at: Value, - functions: &FunctionRegistry, -) -> bool { - let seed: Bindings = join_vars - .iter() - .filter_map(|v| binding.get(v.as_str()).map(|val| (v.clone(), val.clone()))) - .collect(); - let expr_clauses: Vec<&WhereClause> = clauses - .iter() - .filter(|c| matches!(c, WhereClause::Expr { .. })) - .collect(); - let rows = seeded_body_rows(clauses, seed, storage, valid_at); - !apply_expr_clauses_in_evaluator(rows, &expr_clauses, functions).is_empty() -} - -// NOTE: This mirrors apply_expr_clauses in executor.rs but uses the evaluator's -// Bindings type alias (HashMap from matcher.rs). The duplication -// is structural — both type aliases resolve to the same concrete type but are -// defined separately. If expression evaluation semantics change, both must be -// updated in sync. TODO: unify into a shared module (e.g., expr.rs) in a future cleanup. -/// Apply WhereClause::Expr clauses to a list of bindings. -/// -/// Filter-form (`binding: None`) drops rows where the expr is not truthy or errors. -/// Binding-form (`binding: Some(var)`) extends the row with the computed value, -/// or keeps it only if an existing value of the variable is equal (#596). -#[cfg(any(test, feature = "test-oracle"))] -fn apply_expr_clauses_in_evaluator( - bindings: Vec, - expr_clauses: &[&WhereClause], - registry: &FunctionRegistry, -) -> Vec { - use crate::query::datalog::executor::apply_expr; - bindings - .into_iter() - .filter_map(|mut b| { - for clause in expr_clauses { - if let WhereClause::Expr { expr, binding: out } = clause { - b = apply_expr(expr, out.as_deref(), b, registry, false)?; - } - } - Some(b) - }) - .collect() -} - -/// Evaluates Datalog rules with stratified negation support. -/// -/// Strata are evaluated in ascending order. Within each stratum, positive-only -/// rules are handled by RecursiveEvaluator; rules containing `not` clauses are -/// handled by an inner loop that applies `not` filters to candidate bindings. -#[cfg(any(test, feature = "test-oracle"))] -pub struct StratifiedEvaluator { - storage: FactStorage, - rules: Arc>, - functions: Arc>, - max_iterations: usize, - /// Maximum facts the rules may derive in one evaluation, across strata - /// and repeated passes; base facts do not count (#553) - max_derived_facts: usize, - /// The value a `:db/valid-at` pattern in a rule body binds (#617) - valid_at: Value, -} - -#[cfg(any(test, feature = "test-oracle"))] -impl StratifiedEvaluator { - #[cfg(any(test, feature = "test-oracle"))] - pub fn new( - storage: FactStorage, - rules: Arc>, - functions: Arc>, - max_iterations: usize, - max_derived_facts: usize, - ) -> Self { - StratifiedEvaluator { - storage, - rules, - functions, - max_iterations, - max_derived_facts, - valid_at: Value::Null, - } - } - - /// Set the value a `:db/valid-at` pattern binds in rule bodies and their - /// `not` / `not-join` bodies and `or` branches: the query's `:valid-at` - /// value, the current time without one, `nil` for `:any-valid-time` (#617). - #[cfg(any(test, feature = "test-oracle"))] - pub fn with_valid_at(mut self, valid_at: Value) -> Self { - self.valid_at = valid_at; - self - } - - /// Derive all facts for the given predicates, respecting stratification order. - #[cfg(any(test, feature = "test-oracle"))] - pub fn evaluate(&self, predicates: &[String]) -> Result { - use crate::query::datalog::stratification::DependencyGraph; - - let registry = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - - // Build dependency graph and stratify - let graph = DependencyGraph::from_rules(®istry); - let strata = graph.stratify()?; - - // Collect transitive dependencies of requested predicates - let mut all_preds: Vec = predicates.to_vec(); - { - let mut i = 0; - while i < all_preds.len() { - let pred = all_preds - .get(i) - .ok_or_else(|| err_coded!(ErrorCode::Int022, "index out of bounds"))? - .clone(); - for rule in registry.get_rules(&pred) { - for clause in &rule.body { - for dep in clause.rule_invocations() { - if !all_preds.contains(&dep.to_string()) { - all_preds.push(dep.to_string()); - } - } - } - } - i += 1; - } - } - - // Group predicates by stratum - let max_stratum = all_preds - .iter() - .map(|p| *strata.get(p).unwrap_or(&0)) - .max() - .unwrap_or(0); - - drop(registry); // release read lock before recursive calls - - let accumulated = self.storage.clone(); - // Facts the rules derive, for `max_derived_facts` across strata and repeated - // passes (each pass's `RecursiveEvaluator` sees earlier ones as base). - let mut derived_total = 0usize; - - for stratum in 0..=max_stratum { - let registry = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - let stratum_preds: Vec = all_preds - .iter() - .filter(|p| *strata.get(*p).unwrap_or(&0) == stratum) - .cloned() - .collect(); - - if stratum_preds.is_empty() { - continue; - } - - // Partition rules into positive-only and mixed (containing Not) - let mut positive_rules: Vec<(String, Rule)> = Vec::new(); - let mut mixed_rules: Vec<(String, Rule)> = Vec::new(); - - for pred in &stratum_preds { - for rule in registry.get_rules(pred) { - if crate::query::datalog::stratification::has_mixed_clause(&rule.body) { - mixed_rules.push((pred.clone(), rule)); - } else { - positive_rules.push((pred.clone(), rule)); - } - } - } - drop(registry); - - // Recursion through a mixed rule stays in this stratum (#633): some - // rule here calls a mixed predicate of the stratum. Then the mixed - // rules' output feeds the positive rules and themselves, so the - // stratum repeats until the mixed pass derives nothing new. Every - // negated predicate sits in a lower, complete stratum, so this is - // monotone. - let mixed_preds: HashSet<&str> = mixed_rules.iter().map(|(p, _)| p.as_str()).collect(); - let repeat = positive_rules - .iter() - .chain(&mixed_rules) - .flat_map(|(_, rule)| rule.body.iter().flat_map(|c| c.rule_invocations())) - .any(|dep| mixed_preds.contains(dep)); - - let mut pass = 0; - loop { - pass += 1; - if pass > self.max_iterations { - return Err(iterations_exceeded(self.max_iterations)); - } - - // Evaluate positive-only rules via RecursiveEvaluator - if !positive_rules.is_empty() { - let mut sub_registry = RuleRegistry::new(); - for (pred, rule) in &positive_rules { - sub_registry.register_rule_unchecked(pred.clone(), rule.clone()); - } - let sub_rules = Arc::new(RwLock::new(sub_registry)); - let sub_eval = RecursiveEvaluator::new( - accumulated.clone(), - sub_rules, - self.functions.clone(), - self.max_iterations, - self.max_derived_facts, - ) - .with_valid_at(self.valid_at.clone()); - let derived = sub_eval.evaluate_recursive_rules(&stratum_preds)?; - // Snapshot existing fact keys so we only load truly new (derived) facts - let existing: HashSet<(uuid::Uuid, String, Vec)> = accumulated - .get_asserted_facts()? - .into_iter() - .map(|f| { - let encoded = encode_value(&f.value); - (f.entity, f.attribute, encoded) - }) - .collect(); - for fact in derived.get_asserted_facts()? { - let key = ( - fact.entity, - fact.attribute.clone(), - encode_value(&fact.value), - ); - if !existing.contains(&key) { - derived_total += 1; - if derived_total > self.max_derived_facts { - return Err(derived_facts_exceeded(self.max_derived_facts)); - } - let _ = accumulated.load_fact(fact); - } - } - accumulated.restore_tx_counter()?; - } - - // Evaluate mixed rules (with not-filter). A head already in - // `accumulated` is skipped, so a repeated pass sees what is new. - let mut known: HashSet<(uuid::Uuid, String, Vec)> = HashSet::new(); - if !mixed_rules.is_empty() { - known = accumulated - .get_asserted_facts()? - .into_iter() - .map(|f| { - let encoded = encode_value(&f.value); - (f.entity, f.attribute, encoded) - }) - .collect(); - } - let mut new_in_pass = false; - for (_pred, rule) in &mixed_rules { - // Collect Pattern and Expr clauses for the planner. - // RuleInvocations are converted to Pattern; Not/NotJoin/Or/OrJoin extracted separately. - let mut plan_clauses: Vec = Vec::new(); - for c in &rule.body { - match c { - WhereClause::Pattern(_) | WhereClause::Expr { .. } => { - plan_clauses.push(c.clone()); - } - WhereClause::RuleInvocation { predicate, args } => { - let pattern = match args.len() { - 1 => args.first().map(|a0| { - Pattern::new( - a0.clone(), - EdnValue::Keyword(format!(":{}", predicate)), - EdnValue::Symbol("?_rule_value".to_string()), - ) - }), - 2 => args.first().and_then(|a0| { - args.get(1).map(|a1| { - Pattern::new( - a0.clone(), - EdnValue::Keyword(format!(":{}", predicate)), - a1.clone(), - ) - }) - }), - _ => None, - }; - if let Some(p) = pattern { - plan_clauses.push(WhereClause::Pattern(p)); - } - } - WhereClause::Not(_) - | WhereClause::NotJoin { .. } - | WhereClause::Or(_) - | WhereClause::OrJoin { .. } => {} - } - } - - let mut not_clauses: Vec> = rule - .body - .iter() - .filter_map(|c| match c { - WhereClause::Not(inner) => Some(inner.clone()), - _ => None, - }) - .collect(); - - let mut not_join_clauses: Vec<(Vec, Vec)> = rule - .body - .iter() - .filter_map(|c| match c { - WhereClause::NotJoin { join_vars, clauses } => { - Some((join_vars.clone(), clauses.clone())) - } - _ => None, - }) - .collect(); - - if crate::query::datalog::optimizer::reorder() { - not_clauses.sort_by_key(|body| { - crate::query::datalog::optimizer::clause_cost(&WhereClause::Not( - body.clone(), - )) - }); - not_join_clauses.sort_by_key(|(vars, clauses)| { - crate::query::datalog::optimizer::clause_cost(&WhereClause::NotJoin { - join_vars: vars.clone(), - clauses: clauses.clone(), - }) - }); - } - - // Compute once; reuse for plan loop, apply_or_clauses, not-body matching. - let accumulated_facts: Arc<[Fact]> = - Arc::from(accumulated.get_asserted_facts()?); - - let matcher = PatternMatcher::from_slice_with_valid_at( - accumulated_facts.clone(), - self.valid_at.clone(), - ); - - // Plan: assigns index hints + pushes Expr to earliest binding position. - // Not/NotJoin are excluded from plan_clauses above, so `deferred` holds - // only expressions whose variables an Or/OrJoin binds (#625); they run - // after the or pass. Rule bodies keep their existing not-filter path. - let (planned, deferred) = crate::query::datalog::optimizer::plan(plan_clauses); - - // Process planned clauses in order: Pattern → join, Expr → filter/extend. - let fn_guard = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - let mut candidates: Vec = vec![Bindings::new()]; - for (clause, hint) in planned { - match clause { - WhereClause::Pattern(p) => { - candidates = matcher.match_with_hint_seeded( - candidates, - &p, - hint.as_ref().unwrap_or( - &crate::query::datalog::optimizer::IndexHint::Eavt, - ), - // Rule bodies keep today's rule until #548. - &[], - ); - } - WhereClause::Expr { expr, binding: out } => { - use crate::query::datalog::executor::apply_expr; - candidates = candidates - .into_iter() - .filter_map(|b| { - apply_expr(&expr, out.as_deref(), b, &fn_guard, false) - }) - .collect(); - } - _ => {} - } - } - drop(fn_guard); - - // Apply Or/OrJoin clauses (unchanged, applied after the plan loop). - let candidates = { - use crate::query::datalog::executor::apply_or_clauses; - let registry_guard = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - // The database's functions: a registered predicate in - // an or branch is known there too (#548). - let fn_registry = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - // An or branch binds `:db/valid-at` from a `ValidAt`, the - // inverse of the executor's mapping to `self.valid_at`. - let branch_valid_at = match &self.valid_at { - Value::Integer(t) => ValidAt::Timestamp(*t), - _ => ValidAt::AnyValidTime, - }; - let expanded = apply_or_clauses( - &rule.body, - candidates, - accumulated_facts.clone(), - ®istry_guard, - None, - Some(branch_valid_at), - &fn_registry, - )?; - drop(registry_guard); - expanded - }; - let candidates = { - let fn_guard = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - let exprs: Vec<&WhereClause> = deferred.iter().collect(); - apply_expr_clauses_in_evaluator(candidates, &exprs, &fn_guard) - }; - - // Build temp_eval once per rule (outside the binding loop); - // instantiate_head_public only uses storage, not the registry. - let temp_eval = RecursiveEvaluator::new( - accumulated.clone(), - Arc::clone(&self.rules), - Arc::clone(&self.functions), - 1, - self.max_derived_facts, - ); - - 'binding: for binding in candidates { - for not_body in ¬_clauses { - let not_bindings = seeded_body_rows( - not_body, - not_seed(not_body, &binding), - accumulated_facts.clone(), - self.valid_at.clone(), - ); - - // Apply Expr clauses from the not body - let not_body_expr_clauses: Vec<&WhereClause> = not_body - .iter() - .filter(|c| matches!(c, WhereClause::Expr { .. })) - .collect(); - let fn_guard = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - let not_bindings = apply_expr_clauses_in_evaluator( - not_bindings, - ¬_body_expr_clauses, - &fn_guard, - ); - drop(fn_guard); - if !not_bindings.is_empty() { - continue 'binding; // not condition violated -> discard binding - } - } - - for (join_vars, nj_clauses) in ¬_join_clauses { - let fn_guard = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - if evaluate_not_join( - join_vars, - nj_clauses, - &binding, - accumulated_facts.clone(), - self.valid_at.clone(), - &fn_guard, - ) { - continue 'binding; - } - } - - // All Not / NotJoin conditions held -> derive head fact - // A head that is not an entity, or names an unbound - // variable, fails the query as on the positive path (#548). - let fact = temp_eval.instantiate_head_public(&rule.head, &binding)?; - let key = ( - fact.entity, - fact.attribute.clone(), - encode_value(&fact.value), - ); - if !known.insert(key) { - continue; - } - new_in_pass = true; - derived_total += 1; - if derived_total > self.max_derived_facts { - return Err(derived_facts_exceeded(self.max_derived_facts)); - } - // Loaded as derived (tx-count 0): no metadata (#548). - accumulated.load_fact(fact)?; - } - } - - if !repeat || !new_in_pass { - break; - } - } - } - - Ok(accumulated) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::query::datalog::functions::FunctionRegistry; - use crate::query::datalog::parser::parse_datalog_command; - use crate::query::datalog::types::DatalogCommand; - use uuid::Uuid; - - fn create_test_storage() -> FactStorage { - let storage = FactStorage::new(); - - // Create a simple graph: A->B, B->C - let a = Uuid::new_v4(); - let b = Uuid::new_v4(); - let c = Uuid::new_v4(); - - storage - .transact( - vec![ - (a, ":connected".to_string(), Value::Ref(b)), - (b, ":connected".to_string(), Value::Ref(c)), - ], - None, - ) - .unwrap(); - - storage - } - - fn register_test_rule(rules: &Arc>, rule_str: &str) { - let cmd = parse_datalog_command(rule_str).unwrap(); - if let DatalogCommand::Rule(rule) = cmd { - let predicate = match &rule.head[0] { - EdnValue::Symbol(s) => s.clone(), - _ => panic!("Expected symbol as predicate name"), - }; - rules - .write() - .unwrap() - .register_rule(predicate, rule) - .unwrap(); - } else { - panic!("Expected Rule command"); - } - } - - #[test] - fn test_evaluator_creation() { - let storage = FactStorage::new(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - - let _evaluator = - RecursiveEvaluator::new(storage, rules, functions, 1000, DEFAULT_MAX_DERIVED_FACTS); - // Note: RecursiveEvaluator uses evaluate_recursive_rules, not evaluate - // let derived = _evaluator.evaluate(&["p".to_string()]).unwrap(); - } - - // ── Additional targeted branch coverage ─────────────────────────────────── - - /// `FactStorage` (the `Ok` type of `evaluate_recursive_rules`/`evaluate`) - /// deliberately does not implement `Debug`, so `Result::unwrap_err()` — which - /// requires `T: Debug` to format a panic message on the non-error branch — - /// cannot be used directly. Extract the code via a plain match instead. - fn expect_err_code(result: Result) -> String { - match result { - Ok(_) => panic!("expected an error"), - Err(e) => { - let err: crate::error::MinigrafError = e.into(); - err.code().to_string() - } - } - } - - #[test] - fn test_max_iterations_exceeded_returns_error() { - // Line 113: iteration > self.max_iterations → returns Err - // Use a recursive rule that keeps deriving new facts beyond max_iterations=0 - let storage = create_test_storage(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - - // Transitive closure rule — requires multiple iterations - register_test_rule(&rules, r#"(rule [(reachable ?x ?y) [?x :connected ?y]])"#); - register_test_rule( - &rules, - r#"(rule [(reachable ?x ?y) [?x :connected ?z] (reachable ?z ?y)])"#, - ); - - // max_iterations=0 means it will exceed the limit on the very first iteration - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let evaluator = RecursiveEvaluator::new( - storage, - rules, - functions.clone(), - 0, - DEFAULT_MAX_DERIVED_FACTS, - ); - let result = evaluator.evaluate_recursive_rules(&["reachable".to_string()]); - let code = expect_err_code(result); - // #277 step 6 (API+INT category PR) assigned this recursion/depth-limit - // family ("Max iterations exceeded", "Max derived facts exceeded", "Max - // query results exceeded") a shared INT-020 code — see ERROR_REFERENCE.md. - assert_eq!(code, "INT-020"); - } - - #[test] - fn test_max_derived_facts_exceeded_returns_int020() { - // Same rationale as test_max_iterations_exceeded_returns_error above: - // "Max derived facts exceeded" shares INT-020. - let storage = create_test_storage(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - register_test_rule(&rules, r#"(rule [(reachable ?x ?y) [?x :connected ?y]])"#); - register_test_rule( - &rules, - r#"(rule [(reachable ?x ?y) [?x :connected ?z] (reachable ?z ?y)])"#, - ); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - // max_derived_facts=0 means the first derived fact exceeds the limit. - let evaluator = RecursiveEvaluator::new(storage, rules, functions, 1000, 0); - let result = evaluator.evaluate_recursive_rules(&["reachable".to_string()]); - let code = expect_err_code(result); - assert_eq!(code, "INT-020"); - } - - #[test] - #[cfg_attr( - target_os = "wasi", - ignore = "poisons the lock from a spawned thread; WASI has no threads" - )] - fn evaluate_iteration_rule_registry_lock_poisoned_error() { - let storage = create_test_storage(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - register_test_rule(&rules, r#"(rule [(reachable ?x ?y) [?x :connected ?y]])"#); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - { - let rules = rules.clone(); - let _ = std::thread::spawn(move || { - let _guard = rules.write().unwrap(); - panic!( - "deliberate poison for evaluate_iteration_rule_registry_lock_poisoned_error" - ); - }) - .join(); - } - let evaluator = RecursiveEvaluator::new( - storage, - rules, - functions, - DEFAULT_MAX_ITERATIONS, - DEFAULT_MAX_DERIVED_FACTS, - ); - let result = evaluator.evaluate_recursive_rules(&["reachable".to_string()]); - let code = expect_err_code(result); - assert_eq!(code, "QRY-009"); - } - - #[test] - #[cfg_attr( - target_os = "wasi", - ignore = "poisons the lock from a spawned thread; WASI has no threads" - )] - fn evaluate_rule_function_registry_lock_poisoned_error() { - // Exercises evaluate_rule's function registry read (used to apply - // Expr clauses in a rule body). - let storage = create_test_storage(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - register_test_rule( - &rules, - r#"(rule [(over_ten ?x ?y) [?x :connected ?y] [(> 1 0)]])"#, - ); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - { - let functions = functions.clone(); - let _ = std::thread::spawn(move || { - let _guard = functions.write().unwrap(); - panic!("deliberate poison for evaluate_rule_function_registry_lock_poisoned_error"); - }) - .join(); - } - let evaluator = RecursiveEvaluator::new( - storage, - rules, - functions, - DEFAULT_MAX_ITERATIONS, - DEFAULT_MAX_DERIVED_FACTS, - ); - let result = evaluator.evaluate_recursive_rules(&["over_ten".to_string()]); - let code = expect_err_code(result); - assert_eq!(code, "QRY-008"); - } - - #[test] - #[cfg_attr( - target_os = "wasi", - ignore = "poisons the lock from a spawned thread; WASI has no threads" - )] - fn stratified_evaluate_rule_registry_lock_poisoned_error() { - let storage = create_test_storage(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - register_test_rule(&rules, r#"(rule [(reachable ?x ?y) [?x :connected ?y]])"#); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - { - let rules = rules.clone(); - let _ = std::thread::spawn(move || { - let _guard = rules.write().unwrap(); - panic!( - "deliberate poison for stratified_evaluate_rule_registry_lock_poisoned_error" - ); - }) - .join(); - } - let evaluator = StratifiedEvaluator::new( - storage, - rules, - functions, - DEFAULT_MAX_ITERATIONS, - DEFAULT_MAX_DERIVED_FACTS, - ); - let result = evaluator.evaluate(&["reachable".to_string()]); - let code = expect_err_code(result); - assert_eq!(code, "QRY-009"); - } - - #[test] - fn test_rule_invocation_empty_list_error() { - // Line 253: rule_invocation_to_pattern with empty list → Err - let storage = FactStorage::new(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let evaluator = - RecursiveEvaluator::new(storage, rules, functions, 1000, DEFAULT_MAX_DERIVED_FACTS); - let result = evaluator.rule_invocation_to_pattern(&[]); - assert!( - result.is_err(), - "empty rule invocation list should return error" - ); - } - - #[test] - fn test_head_requires_args() { - // Line 233: head.len() != arg_count → return Err - let storage = FactStorage::new(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let evaluator = - RecursiveEvaluator::new(storage, rules, functions, 1000, DEFAULT_MAX_DERIVED_FACTS); - let head = vec![EdnValue::Symbol("predicate".to_string())]; // only 1 element - let binding = std::collections::HashMap::new(); - let result = evaluator.instantiate_head(&head, &binding); - assert!( - result.is_err(), - "head with only predicate and no arg should fail" - ); - } - - #[test] - fn test_head_entity_must_be_an_entity() { - // A value or a bare symbol as the head entity is QRY-013 (#548). - let evaluator = RecursiveEvaluator::new( - FactStorage::new(), - Arc::new(RwLock::new(RuleRegistry::new())), - Arc::new(RwLock::new(FunctionRegistry::with_builtins())), - 1000, - DEFAULT_MAX_DERIVED_FACTS, - ); - let binding = std::collections::HashMap::new(); - for entity in [ - EdnValue::String("x".to_string()), - EdnValue::Integer(1), - EdnValue::Symbol("foo".to_string()), - ] { - let head = vec![EdnValue::Symbol("p".to_string()), entity]; - let err: crate::error::MinigrafError = evaluator - .instantiate_head(&head, &binding) - .unwrap_err() - .into(); - assert_eq!(err.code(), "QRY-013", "not an entity"); - } - let head = vec![ - EdnValue::Symbol("p".to_string()), - EdnValue::Keyword(":a".to_string()), - ]; - let fact = evaluator.instantiate_head(&head, &binding).unwrap(); - assert_eq!(fact.tx_count, 0, "a derived fact has tx-count 0"); - } - - #[test] - fn test_evaluate_rule_empty_body_returns_empty_derived() { - // Line 225 TRUE: patterns.is_empty() && expr_clauses.is_empty() → return Ok(derived) - // Achieved by a rule with an empty body (no clauses) - use crate::query::datalog::types::Rule; - - let storage = FactStorage::new(); - let mut registry = RuleRegistry::new(); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - // Rule with empty body: no patterns, no expr_clauses - let rule = Rule { - head: vec![ - EdnValue::Symbol("empty-body-pred".to_string()), - EdnValue::Symbol("?x".to_string()), - ], - body: vec![], // empty body - }; - registry.register_rule_unchecked("empty-body-pred".to_string(), rule); - let rules = Arc::new(RwLock::new(registry)); - let evaluator = - RecursiveEvaluator::new(storage, rules, functions, 1000, DEFAULT_MAX_DERIVED_FACTS); - let result = evaluator.evaluate_recursive_rules(&["empty-body-pred".to_string()]); - // Should succeed (returns base facts only, derives nothing) - assert!(result.is_ok(), "empty body rule should not fail"); - } - - #[test] - fn test_evaluate_rule_expr_only_body() { - // Line 230 TRUE: patterns.is_empty() but expr_clauses not empty → seed with empty binding - // Achieved by a rule with only Expr clauses in body - use crate::query::datalog::types::{Expr, Rule, WhereClause}; - - let storage = FactStorage::new(); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let e1 = Uuid::new_v4(); - storage - .transact( - vec![(e1, ":item/value".to_string(), Value::Integer(42))], - None, - ) - .unwrap(); - - // Rule with only an Expr that always evaluates to truthy - // Since there are no patterns, it seeds with ONE empty binding - // The Expr filters it (or not), then instantiate_head would fail if ?x is unbound - // Let's just test that evaluate_rule handles this path without crashing - let mut registry = RuleRegistry::new(); - let rule = Rule { - head: vec![ - EdnValue::Symbol("expr-only-pred".to_string()), - EdnValue::Symbol("?x".to_string()), - ], - body: vec![WhereClause::Expr { - expr: Expr::Lit(Value::Boolean(false)), // always false → no bindings pass - binding: None, - }], - }; - registry.register_rule_unchecked("expr-only-pred".to_string(), rule); - let rules = Arc::new(RwLock::new(registry)); - let evaluator = - RecursiveEvaluator::new(storage, rules, functions, 1000, DEFAULT_MAX_DERIVED_FACTS); - // This exercises the expr-only path. The expr evaluates to false → no facts derived. - let result = evaluator.evaluate_recursive_rules(&["expr-only-pred".to_string()]); - assert!(result.is_ok(), "expr-only rule body should not fail"); - let derived = result.unwrap(); - let facts = derived.get_asserted_facts().unwrap(); - let pred_facts: Vec<_> = facts - .iter() - .filter(|f| f.attribute == ":expr-only-pred") - .collect(); - assert_eq!( - pred_facts.len(), - 0, - "expr evaluating to false should derive no facts" - ); - } - - #[test] - fn test_evaluate_not_join_expr_only_body() { - // Line 448: evaluate_not_join with substituted.is_empty() (Expr-only not-join body) - // Uses an Expr-only clause in the not-join body to hit the "seed with partial binding" path - use crate::graph::types::Value; - use crate::query::datalog::types::{BinOp, Expr, WhereClause}; - - let storage = FactStorage::new(); - let e1 = Uuid::new_v4(); - storage - .transact(vec![(e1, ":score".to_string(), Value::Integer(100))], None) - .unwrap(); - - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - - // Build a not-join with an Expr-only body: (not-join [?x] [(> ?x 50)]) - // join_vars = ["?x"], clause = Expr that evaluates to true (100 > 50) - // → substituted is empty → seeds with partial binding → not_bindings has 1 entry - // → expr evaluates to true (100 > 50) → not_bindings not empty → returns true (reject) - let mut binding = std::collections::HashMap::new(); - binding.insert("?x".to_string(), Value::Integer(100)); - - let expr_clause = WhereClause::Expr { - expr: Expr::BinOp( - BinOp::Gt, - Box::new(Expr::Var("?x".to_string())), - Box::new(Expr::Lit(Value::Integer(50))), - ), - binding: None, - }; - - let result = evaluate_not_join( - &["?x".to_string()], - &[expr_clause], - &binding, - facts, - Value::Null, - &FunctionRegistry::with_builtins(), - ); - assert!( - result, - "not-join with expr (100 > 50) should return true (reject)" - ); - } - - #[test] - fn test_stratified_evaluator_empty_stratum_skipped() { - // Line 580: stratum_preds.is_empty() → continue - // This is hit when a predicate has a stratum but no rules match - // We can trigger it by evaluating predicates that exist in strata but have no rules - let storage = FactStorage::new(); - let e1 = Uuid::new_v4(); - storage - .transact( - vec![(e1, ":x".to_string(), crate::graph::types::Value::Integer(1))], - None, - ) - .unwrap(); - - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - // Register a rule for pred "a" — "b" has no rule, creating a gap in strata - register_test_rule(&rules, r#"(rule [(a ?x) [?x :x ?v]])"#); - - let evaluator = StratifiedEvaluator::new( - storage.clone(), - rules, - functions, - 1000, - DEFAULT_MAX_DERIVED_FACTS, - ); - // Ask for both "a" and "nonexistent" — nonexistent has no rules → stratum_preds may be empty - let result = evaluator.evaluate(&["a".to_string(), "nonexistent".to_string()]); - assert!( - result.is_ok(), - "evaluation with missing predicate should succeed" - ); - } - - #[test] - fn test_stratified_evaluator_not_body_empty_patterns() { - // Line 750: in the mixed-rule loop, not-body with substituted.is_empty() - // (Expr-only not body in a stratified mixed rule) - // This exercises the path where not-body has no patterns → seed with current binding - let storage = FactStorage::new(); - let e1 = Uuid::new_v4(); - let e2 = Uuid::new_v4(); - storage - .transact( - vec![ - ( - e1, - ":val".to_string(), - crate::graph::types::Value::Integer(200), - ), - ( - e2, - ":val".to_string(), - crate::graph::types::Value::Integer(50), - ), - ], - None, - ) - .unwrap(); - - // Rule with not + Expr-only not body: (big ?x) <- [?x :val ?v] (not [(< ?v 100)]) - // This rule uses not with an expr-only body: the not body has no Pattern clauses - use crate::graph::types::Value; - use crate::query::datalog::types::{BinOp, Expr, Pattern, Rule, WhereClause}; - - let mut registry = RuleRegistry::new(); - let rule = Rule { - head: vec![ - EdnValue::Symbol("big".to_string()), - EdnValue::Symbol("?x".to_string()), - ], - body: vec![ - WhereClause::Pattern(Pattern::new( - EdnValue::Symbol("?x".to_string()), - EdnValue::Keyword(":val".to_string()), - EdnValue::Symbol("?v".to_string()), - )), - WhereClause::Not(vec![WhereClause::Expr { - expr: Expr::BinOp( - BinOp::Lt, - Box::new(Expr::Var("?v".to_string())), - Box::new(Expr::Lit(Value::Integer(100))), - ), - binding: None, - }]), - ], - }; - registry.register_rule_unchecked("big".to_string(), rule); - let rules = Arc::new(RwLock::new(registry)); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let evaluator = StratifiedEvaluator::new( - storage.clone(), - rules, - functions, - 1000, - DEFAULT_MAX_DERIVED_FACTS, - ); - let result = evaluator.evaluate(&["big".to_string()]); - assert!( - result.is_ok(), - "stratified evaluation with expr-only not body should succeed" - ); - let derived = result.unwrap(); - let facts = derived.get_asserted_facts().unwrap(); - let big_facts: Vec<_> = facts.iter().filter(|f| f.attribute == ":big").collect(); - // Only e1 with val=200 should be derived (e2 with val=50 is excluded by not [(< ?v 100)]) - assert_eq!( - big_facts.len(), - 1, - "only entity with val=200 should be 'big'" - ); - } - - #[test] - fn test_stratified_max_derived_facts_limit() { - let storage = create_test_storage(); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - - register_test_rule(&rules, "(rule [(all ?x) [?x :connected _]])"); - - let evaluator = StratifiedEvaluator::new( - storage, rules, functions, 100, 1, // very low max_derived_facts - ); - - let result = evaluator.evaluate(&["all".to_string()]); - assert!( - result.is_err(), - "stratified should error when max_derived_facts exceeded" - ); - } - - #[test] - fn test_mixed_rule_with_expr_preserves_semantics() { - // Rule: (eligible ?x) :- [?x :val ?v] [(> ?v 10)] (not [?x :blocked true]) - // Expr should be pushed after [?x :val ?v] in the plan. - // Result must be the same as before. - let storage = FactStorage::new(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - - let e1 = Uuid::new_v4(); - let e2 = Uuid::new_v4(); - let e3 = Uuid::new_v4(); - - storage - .transact( - vec![ - (e1, ":val".to_string(), Value::Integer(5)), - (e2, ":val".to_string(), Value::Integer(20)), - (e3, ":val".to_string(), Value::Integer(30)), - (e3, ":blocked".to_string(), Value::Boolean(true)), - ], - None, - ) - .unwrap(); - - register_test_rule( - &rules, - r#"(rule [(eligible ?x) [?x :val ?v] [(> ?v 10)] (not [?x :blocked true])])"#, - ); - - let evaluator = StratifiedEvaluator::new( - storage, - Arc::clone(&rules), - Arc::clone(&functions), - DEFAULT_MAX_ITERATIONS, - DEFAULT_MAX_DERIVED_FACTS, - ); - - let derived = evaluator.evaluate(&["eligible".to_string()]).unwrap(); - let facts = derived.get_asserted_facts().unwrap(); - let eligible: Vec<_> = facts - .iter() - .filter(|f| f.attribute.contains("eligible")) - .collect(); - assert_eq!(eligible.len(), 1, "only e2 is eligible (e3 is blocked)"); - } - - /// A counter that recurses through a rule with `not` (#633). - fn counter_evaluator( - guard: &str, - max_iterations: usize, - max_derived_facts: usize, - ) -> StratifiedEvaluator { - let storage = FactStorage::new(); - storage - .transact( - vec![(Uuid::new_v4(), ":start".to_string(), Value::Integer(0))], - None, - ) - .unwrap(); - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - let functions = Arc::new(RwLock::new(FunctionRegistry::with_builtins())); - register_test_rule(&rules, "(rule [(n ?x ?v) [?x :start ?v]])"); - register_test_rule( - &rules, - &format!("(rule [(n ?x ?w) (n ?x ?v) {guard} [(+ ?v 1) ?w] (not [?x :stop true])])"), - ); - StratifiedEvaluator::new(storage, rules, functions, max_iterations, max_derived_facts) - } - - #[test] - fn test_recursion_through_mixed_rule_reaches_fixpoint() { - let derived = counter_evaluator( - "[(< ?v 3)]", - DEFAULT_MAX_ITERATIONS, - DEFAULT_MAX_DERIVED_FACTS, - ) - .evaluate(&["n".to_string()]) - .unwrap(); - let n = derived - .get_asserted_facts() - .unwrap() - .into_iter() - .filter(|f| f.attribute == ":n") - .count(); - assert_eq!(n, 4, "n is 0, 1, 2 and 3"); - } - - #[test] - fn test_recursion_through_mixed_rule_max_iterations() { - let result = - counter_evaluator("", 5, DEFAULT_MAX_DERIVED_FACTS).evaluate(&["n".to_string()]); - assert_eq!(expect_err_code(result), "INT-020"); - } - - #[test] - fn test_recursion_through_mixed_rule_max_derived_facts() { - let result = counter_evaluator("", DEFAULT_MAX_ITERATIONS, 3).evaluate(&["n".to_string()]); - assert_eq!(expect_err_code(result), "INT-020"); - } - - #[test] - fn test_recursion_through_mixed_rule_max_derived_facts_counts_every_pass() { - // n0 → m0 → n1 → m1 → n2 → m2 → n3: seven facts, three from the mixed - // rule and one from each positive pass. - let rules = Arc::new(RwLock::new(RuleRegistry::new())); - register_test_rule(&rules, "(rule [(n ?x ?v) [?x :start ?v]])"); - register_test_rule(&rules, "(rule [(n ?x ?w) (m ?x ?v) [(+ ?v 1) ?w]])"); - register_test_rule( - &rules, - "(rule [(m ?x ?v) (n ?x ?v) [(< ?v 3)] (not [?x :stop true])])", - ); - let evaluator = |max_derived_facts| { - // The evaluator adds what it derives to this storage. - let storage = FactStorage::new(); - storage - .transact( - vec![(Uuid::new_v4(), ":start".to_string(), Value::Integer(0))], - None, - ) - .unwrap(); - StratifiedEvaluator::new( - storage, - Arc::clone(&rules), - Arc::new(RwLock::new(FunctionRegistry::with_builtins())), - DEFAULT_MAX_ITERATIONS, - max_derived_facts, - ) - }; - evaluator(7).evaluate(&["n".to_string()]).unwrap(); - let result = evaluator(6).evaluate(&["n".to_string()]); - assert_eq!(expect_err_code(result), "INT-020"); + let attribute = EdnValue::Keyword(format!(":{}", predicate)); + match args { + [entity] => Ok(Pattern::new( + entity.clone(), + attribute, + EdnValue::Symbol("?_rule_value".to_string()), + )), + [entity, value] => Ok(Pattern::new(entity.clone(), attribute, value.clone())), + _ => Err(err_coded!(ErrorCode::Int028, predicate, args.len())), } } diff --git a/src/query/datalog/executor.rs b/src/query/datalog/executor.rs index 2a060c252a..58f77c9947 100644 --- a/src/query/datalog/executor.rs +++ b/src/query/datalog/executor.rs @@ -1,16 +1,6 @@ -#[cfg(any(test, feature = "test-oracle"))] -use super::aggregate::{Agg, Groups, finish_groups, named_vars, value_order, windows}; -#[cfg(any(test, feature = "test-oracle"))] -use super::evaluator::{StratifiedEvaluator, evaluate_not_join}; use super::functions::FunctionRegistry; -#[cfg(any(test, feature = "test-oracle"))] -use super::matcher::PatternMatcher; use super::matcher::{edn_to_entity_id, edn_to_value}; -#[cfg(any(test, feature = "test-oracle"))] -use super::optimizer; use super::rules::RuleRegistry; -#[cfg(any(test, feature = "test-oracle"))] -use super::types::AsOf; use super::types::{ AttributeSpec, BinOp, DatalogCommand, DatalogQuery, EdnValue, Expr, FindSpec, Pattern, Rule, Transaction, UnaryOp, ValidAt, WhereClause, WindowFunc, @@ -18,8 +8,6 @@ use super::types::{ use crate::error::{ErrorCode, bail_coded, err_coded}; use crate::graph::FactStorage; use crate::graph::storage::Snapshot; -#[cfg(any(test, feature = "test-oracle"))] -use crate::graph::types::{Fact, tx_id_now}; use crate::graph::types::{TransactOptions, TxId, Value}; use anyhow::Result; use std::collections::HashMap; @@ -35,23 +23,6 @@ fn check_per_fact_pseudo_attrs(query: &DatalogQuery) -> Result<()> { Ok(()) } -/// `QRY-007`: surface unknown UDF predicates as errors before processing any -/// rows (matches the behaviour of the former apply_expr_clauses post-pass). -#[cfg(any(test, feature = "test-oracle"))] -fn check_udf_predicates(query: &DatalogQuery, registry: &FunctionRegistry) -> Result<()> { - for clause in &query.where_clauses { - if let WhereClause::Expr { - expr: Expr::UnaryOp(UnaryOp::Udf(name), _), - .. - } = clause - && registry.get_predicate(name).is_none() - { - bail_coded!(ErrorCode::Qry007, name); - } - } - Ok(()) -} - /// `QRY-007` for the first of `names` that `registry` lacks: the engine /// resolves every predicate a query names, at any depth, when it opens /// (#551 spec §3.2). @@ -96,31 +67,6 @@ fn query_uses_per_fact_pseudo_attr(query: &DatalogQuery) -> bool { check_clauses(&query.where_clauses) } -/// Recursively collect all `Pattern` clauses from a slice of where clauses, -/// including those nested inside `Not`, `NotJoin`, `Or`, and `OrJoin` bodies. -/// Used by `selective_fact_fetch` to ensure every pattern that references a fact -/// (including not-body patterns) is considered when deciding which indexes to query. -#[cfg(any(test, feature = "test-oracle"))] -fn collect_all_patterns(clauses: &[WhereClause]) -> Vec { - let mut patterns = Vec::new(); - for clause in clauses { - match clause { - WhereClause::Pattern(p) => patterns.push(p.clone()), - WhereClause::Not(inner) => patterns.extend(collect_all_patterns(inner)), - WhereClause::NotJoin { clauses: inner, .. } => { - patterns.extend(collect_all_patterns(inner)) - } - WhereClause::Or(branches) | WhereClause::OrJoin { branches, .. } => { - for branch in branches { - patterns.extend(collect_all_patterns(branch)); - } - } - WhereClause::RuleInvocation { .. } | WhereClause::Expr { .. } => {} - } - } - patterns -} - /// What [`DatalogExecutor::open`] gives a cursor: a whole result, or a /// query on the streaming engine to pull rows from. pub(crate) enum Answer { @@ -269,16 +215,6 @@ impl DatalogExecutor { } } - /// Read-time "now" for query visibility: the snapshot's time when the - /// executor has one, otherwise the wall clock. A write transaction's - /// snapshot is at or after its newest staged fact (#550 spec §7). - #[cfg(any(test, feature = "test-oracle"))] - fn read_now(&self) -> i64 { - self.snapshot - .as_ref() - .map_or_else(|| tx_id_now().cast_signed(), Snapshot::now) - } - /// Execute a Datalog command pub fn execute(&self, command: DatalogCommand) -> Result { match command { @@ -363,169 +299,6 @@ impl DatalogExecutor { Ok(QueryResult::Retracted(tx_id)) } - /// Build a filtered fact snapshot for a query's temporal constraints. - /// - /// Step 1: apply transaction-time filter (`:as-of`) — defaults to all facts. - /// Step 2: discard retracted facts within the tx window (`net_asserted_facts`). - /// Step 3: apply valid-time filter (`:valid-at`) — defaults to "currently valid". - /// - /// Returns an `Arc<[Fact]>` snapshot. `.clone()` is a cheap Arc refcount increment, - /// so `or`-branches and `not`/`not-join` sub-evaluations share the same allocation. - /// The three steps above are paid exactly once per `execute_query` / - /// `execute_query_with_rules` call. - /// - /// Step 1 uses selective index-backed fetches when query patterns bind concrete entities - /// or attributes (up to 4 distinct lookups), and a full scan otherwise. Without a - /// transaction overlay, and for `:as-of` counters, committed history is already - /// reduced to its net-asserted records on index keys (#379); step 2 still runs over - /// the union with the pending facts, which gives the same result. - #[cfg(any(test, feature = "test-oracle"))] - fn filter_facts_for_query(&self, query: &DatalogQuery) -> Result> { - let now = self.read_now(); - - let source_facts: Vec = match query.as_of.as_ref() { - // A counter is a key bound, so committed history is cut on index keys. - Some(AsOf::Counter(n)) => self.live_source_facts(query, Some(*n))?, - Some(as_of) => self.read_snapshot()?.facts_as_of(as_of)?, - None => self.live_source_facts(query, None)?, - }; - - let tx_filtered = source_facts; - - // Step 2: compute net-asserted view — for each (entity, attribute, value) triple, - // keep it only if the record with the highest tx_count is an assertion. - // This correctly hides facts that have been retracted. - let asserted = crate::graph::storage::net_asserted_facts(tx_filtered); - - // Step 3: valid-time filter - let valid_filtered: Vec = match &query.valid_at { - Some(ValidAt::Timestamp(t)) => asserted - .into_iter() - .filter(|f| f.valid_from <= *t && *t < f.valid_to) - .collect(), - Some(ValidAt::AnyValidTime) => asserted, - Some(ValidAt::Slot(_)) => { - return Err(err_coded!(ErrorCode::Int025)); - } - None => asserted - .into_iter() - .filter(|f| f.valid_from <= now && now < f.valid_to) - .collect(), - }; - - Ok(Arc::from(valid_filtered)) - } - - /// Step 1 without a transaction overlay: pending facts up to `as_of` plus the - /// committed facts that survive net-assert at `as_of` (#379), selectively when the - /// patterns allow it. Rules need the whole fact base, so they always get a full scan. - #[cfg(any(test, feature = "test-oracle"))] - fn live_source_facts(&self, query: &DatalogQuery, as_of: Option) -> Result> { - if !query.uses_rules() { - let patterns = collect_all_patterns(&query.where_clauses); - if let Some(facts) = self.selective_fact_fetch(&patterns, 4, as_of)? { - return Ok(facts); - } - } - self.read_snapshot()? - .live_facts_of_scans(&[crate::storage::Scan::All], as_of) - } - - /// Attempt a selective index-backed fact fetch for the given patterns. - /// - /// Patterns with a bound entity literal (UUID or keyword → deterministic UUID) are - /// fetched by entity; if every pattern on that entity also binds a concrete attribute - /// keyword, only those `(entity, attribute)` EAVT ranges are read, so other attributes' - /// version history is never resolved (#323). An entity also referenced with a variable - /// or pseudo-attribute is read whole. Patterns without a bound entity are fetched by - /// attribute. If any pattern has neither, returns `None` (full scan). - /// - /// Lookup budget: if narrowing needs more than `threshold` lookups, every entity falls - /// back to a single whole-entity scan; only if that still exceeds `threshold` does this - /// return `None`. Narrowing therefore never turns a selective query into a full scan. - /// - /// A lookup error (a damaged page) is returned, never turned into a full scan. - /// - /// Results are not deduplicated: the sole caller feeds them to `net_asserted_facts`, - /// which is idempotent under duplicated records. Each lookup returns the pending facts - /// up to `as_of` and the committed facts live at `as_of`, and all lookups read one - /// state of the store (`Snapshot::live_facts_of_scans`, #555). - #[cfg(any(test, feature = "test-oracle"))] - fn selective_fact_fetch( - &self, - patterns: &[Pattern], - threshold: usize, - as_of: Option, - ) -> Result>> { - use crate::storage::Scan; - use std::collections::{BTreeMap, BTreeSet}; - - // Per bound entity: Some(attrs) = only these attributes are referenced; - // None = the whole entity is needed. BTree* for deterministic lookup order. - let mut entity_attrs: BTreeMap>> = BTreeMap::new(); - let mut attributes: BTreeSet = BTreeSet::new(); - - for pattern in patterns { - let bound_entity = match &pattern.entity { - EdnValue::Uuid(u) => Some(*u), - EdnValue::Keyword(_) => edn_to_entity_id(&pattern.entity).ok(), - _ => None, - }; - - if let Some(uid) = bound_entity { - let slot = entity_attrs - .entry(uid) - .or_insert_with(|| Some(BTreeSet::new())); - match &pattern.attribute { - AttributeSpec::Real(EdnValue::Keyword(attr)) => { - if let Some(attrs) = slot { - attrs.insert(attr.clone()); - } - } - _ => *slot = None, - } - continue; - } - - if let AttributeSpec::Real(EdnValue::Keyword(attr)) = &pattern.attribute { - attributes.insert(attr.clone()); - } else { - return Ok(None); - } - } - - let narrowed_lookups: usize = entity_attrs - .values() - .map(|a| a.as_ref().map_or(1, BTreeSet::len)) - .sum::() - + attributes.len(); - let narrow = narrowed_lookups <= threshold; - let total = if narrow { - narrowed_lookups - } else { - entity_attrs.len() + attributes.len() - }; - if total == 0 || total > threshold { - return Ok(None); - } - - // Every scan reads one state of the store, so a commit cannot land - // between two patterns of this query (#555). - let mut scans: Vec> = Vec::with_capacity(total); - for (uid, attrs) in &entity_attrs { - match attrs { - Some(attrs) if narrow => { - scans.extend(attrs.iter().map(|a| Scan::EntityAttribute(uid, a))); - } - _ => scans.push(Scan::Entity(uid)), - } - } - scans.extend(attributes.iter().map(|a| Scan::Attribute(a))); - let all_facts = self.read_snapshot()?.live_facts_of_scans(&scans, as_of)?; - - Ok(Some(all_facts)) - } - /// Execute a query: find matching facts and return specified variables fn execute_query(&self, query: DatalogQuery) -> Result { match self.open_query(query)? { @@ -589,22 +362,6 @@ impl DatalogExecutor { )?; #[cfg(test)] crate::query::engine::RUNS.with(|r| r.set(r.get() + 1)); - // The comparison drains a second stream, so the one returned stays - // unread. - #[cfg(any(test, feature = "test-oracle"))] - crate::query::engine::oracle::check( - &crate::query::engine::plan(&query) - .and_then(|plan| { - crate::query::engine::open( - snapshot.clone(), - plan, - self.functions.clone(), - self.query_memory_limit, - ) - }) - .and_then(crate::query::engine::Stream::collect), - &self.oracle(snapshot).execute_query_on_executor(query), - ); Ok(Answer::Stream(Box::new(stream))) } @@ -661,15 +418,6 @@ impl DatalogExecutor { check_predicates(&names, ®istry)?; Ok(stream) }; - // The comparison drains a second stream, so the one returned stays - // unread. - #[cfg(any(test, feature = "test-oracle"))] - crate::query::engine::oracle::check( - &open(plan.clone()).and_then(crate::query::engine::Stream::collect), - &self - .oracle(snapshot.clone()) - .execute_query_with_rules(query.clone()), - ); let stream = open(plan)?; #[cfg(test)] crate::query::engine::RUNS.with(|r| r.set(r.get() + 1)); @@ -686,439 +434,6 @@ impl DatalogExecutor { } } - /// This executor over `snapshot`, for the engine's oracle (#473 spec §9). - #[cfg(any(test, feature = "test-oracle"))] - fn oracle(&self, snapshot: Snapshot) -> DatalogExecutor { - DatalogExecutor { - storage: self.storage.clone(), - snapshot: Some(snapshot), - rules: self.rules.clone(), - functions: self.functions.clone(), - max_derived_facts: self.max_derived_facts, - query_memory_limit: self.query_memory_limit, - } - } - - /// [`Self::execute_query`] on this executor, after the checks every - /// query passes first. - #[cfg(any(test, feature = "test-oracle"))] - fn execute_query_on_executor(&self, query: DatalogQuery) -> Result { - // Compute query-level valid_at value for :db/valid-at pseudo-attribute binding. - let now = self.read_now(); - let valid_at_value = match &query.valid_at { - Some(ValidAt::Timestamp(t)) => Value::Integer(*t), - Some(ValidAt::AnyValidTime) => Value::Null, - Some(ValidAt::Slot(_)) => { - return Err(err_coded!(ErrorCode::Int025)); - } - None => Value::Integer(now), - }; - - check_per_fact_pseudo_attrs(&query)?; - - // Apply temporal filters before pattern matching - let filtered_facts = self.filter_facts_for_query(&query)?; - let matcher = PatternMatcher::from_slice_with_valid_at( - filtered_facts.clone(), - valid_at_value.clone(), - ); - // Acquire function registry before the plan loop — needed for inline Expr evaluation. - let registry = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - - check_udf_predicates(&query, ®istry)?; - - // Collect Pattern, Expr, Not, and NotJoin top-level clauses for the planner. - // Or/OrJoin are extracted separately below and applied as a post-pass. - let plan_clauses: Vec = query - .where_clauses - .iter() - .filter(|c| { - matches!( - c, - WhereClause::Pattern(_) - | WhereClause::Expr { .. } - | WhereClause::Not(_) - | WhereClause::NotJoin { .. } - ) - }) - .cloned() - .collect(); - - let mut binders = Binders::new(&query.where_clauses, Vec::new()); - let (planned, deferred_not_clauses) = optimizer::plan(plan_clauses); - - // Process planned clauses in order: Pattern → expand bindings, Expr → filter/extend, - // Not/NotJoin → shrink bindings as soon as their variables are bound (#248). - let mut bindings: Vec = vec![Binding::new()]; - for (clause, hint) in planned { - match clause { - WhereClause::Pattern(p) => { - let rebind = binders.pattern(&p); - bindings = matcher.match_with_hint_seeded( - bindings, - &p, - hint.as_ref().unwrap_or(&optimizer::IndexHint::Eavt), - &rebind, - ); - } - WhereClause::Expr { expr, binding: out } => { - let replace = out - .as_deref() - .is_some_and(|var| binders.expression(&expr, var)); - bindings = bindings - .into_iter() - .filter_map(|b| apply_expr(&expr, out.as_deref(), b, ®istry, replace)) - .collect(); - } - WhereClause::Not(body) => { - bindings = apply_not_clause( - bindings, - &body, - filtered_facts.clone(), - valid_at_value.clone(), - ®istry, - ); - } - WhereClause::NotJoin { join_vars, clauses } => { - bindings = apply_not_join_clause( - bindings, - &join_vars, - &clauses, - filtered_facts.clone(), - valid_at_value.clone(), - ®istry, - ); - } - _ => {} - } - } - - // Apply Or/OrJoin clauses (post-pass: after pattern matching, before deferred not/expr) - let rules_guard = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - let mut bindings = apply_or_clauses( - &query.where_clauses, - bindings, - filtered_facts.clone(), - &rules_guard, - query.as_of.clone(), - Some(branch_valid_at(&valid_at_value)), - ®istry, - )?; - drop(rules_guard); - - // Apply Not/NotJoin clauses the planner couldn't place inline (#248), and - // expressions (#625) — their variables are only bound by the Or/OrJoin pass - // above, so they must run here, after it. Sorted cheapest-first, same as the - // pre-#248 post-filter ordering; expressions cost 0 and come first, so a - // stable sort keeps them ahead of the nots, in text order. - let mut deferred_not_clauses = deferred_not_clauses; - if optimizer::reorder() { - deferred_not_clauses.sort_by_key(optimizer::clause_cost); - } - for clause in deferred_not_clauses { - bindings = match clause { - WhereClause::Expr { expr, binding: out } => { - let replace = out - .as_deref() - .is_some_and(|var| binders.expression(&expr, var)); - bindings - .into_iter() - .filter_map(|b| apply_expr(&expr, out.as_deref(), b, ®istry, replace)) - .collect() - } - WhereClause::Not(body) => apply_not_clause( - bindings, - &body, - filtered_facts.clone(), - valid_at_value.clone(), - ®istry, - ), - WhereClause::NotJoin { join_vars, clauses } => apply_not_join_clause( - bindings, - &join_vars, - &clauses, - filtered_facts.clone(), - valid_at_value.clone(), - ®istry, - ), - _ => bindings, - }; - } - - let results = apply_post_processing(bindings, &query.find, &query.with_vars, ®istry)?; - - Ok(QueryResult::QueryResults { - vars: query.find.iter().map(|s| s.display_name()).collect(), - results, - }) - } - - /// Execute a query that uses recursive rules - #[cfg(any(test, feature = "test-oracle"))] - fn execute_query_with_rules(&self, query: DatalogQuery) -> Result { - // Extract ALL predicates (including inside not bodies) so the StratifiedEvaluator - // evaluates every referenced rule. This is needed for not-post-filter to work. - let all_rule_invocations = query.get_rule_invocations(); - let predicates: Vec = all_rule_invocations - .iter() - .map(|(pred, _)| pred.clone()) - .collect(); - - // Compute query-level valid_at value for :db/valid-at pseudo-attribute binding. - let now = self.read_now(); - let valid_at_value = match &query.valid_at { - Some(ValidAt::Timestamp(t)) => Value::Integer(*t), - Some(ValidAt::AnyValidTime) => Value::Null, - Some(ValidAt::Slot(_)) => { - return Err(err_coded!(ErrorCode::Int025)); - } - None => Value::Integer(now), - }; - - check_per_fact_pseudo_attrs(&query)?; - - // Apply temporal filters before evaluating recursive rules - let filtered_facts = self.filter_facts_for_query(&query)?; - - // Convert to FactStorage for StratifiedEvaluator (needs mutable accumulation) - // TODO (post-1.0): use FactStorage::new_noindex() once profiling confirms rules-path - // index rebuild is also a bottleneck. - let filtered_storage = FactStorage::new(); - for fact in filtered_facts.iter().cloned() { - filtered_storage.load_fact(fact)?; - } - - let effective_max_derived = self.derived_limit(&query); - - // Apply magic sets rewriting for demand-driven recursive evaluation. - // Returns None for all-free queries — zero overhead path. - let rewritten = { - let reg = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - crate::query::datalog::magic_sets::rewrite(&query, ®) - }; - let (eval_rules, seed_facts) = match rewritten { - Some((rewritten_registry, seeds)) => (Arc::new(RwLock::new(rewritten_registry)), seeds), - None => (self.rules.clone(), vec![]), - }; - for (entity, attribute, value) in seed_facts { - // tx_id=0 is intentional: magic seed facts are synthetic EAV triples that carry - // no temporal semantics. They are inserted after temporal filtering has completed, - // so they never participate in valid-time or tx-time queries. - filtered_storage.load_fact(Fact::new(entity, attribute, value, 0))?; - } - - // Create StratifiedEvaluator — handles negation, stratification, and positive-only rules - let evaluator = StratifiedEvaluator::new( - filtered_storage, - eval_rules, - self.functions.clone(), - 1000, // max iterations - effective_max_derived, - ) - .with_valid_at(valid_at_value.clone()); - - let derived_storage = evaluator.evaluate(&predicates)?; - - // Compute derived_facts Arc once; reuse for plan loop, or-clauses and not-post-filter. - // Must use derived_storage (includes rule-derived facts), not filtered_facts (base only). - let derived_facts: Arc<[Fact]> = Arc::from(derived_storage.get_asserted_facts()?); - - let matcher = - PatternMatcher::from_slice_with_valid_at(derived_facts.clone(), valid_at_value.clone()); - - // Acquire function registry before the plan loop — needed for inline Expr evaluation. - let registry = self - .functions - .read() - .map_err(|_| err_coded!(ErrorCode::Qry008))?; - - // Pre-validate UDF predicate names. - for clause in &query.where_clauses { - if let WhereClause::Expr { - expr: Expr::UnaryOp(UnaryOp::Udf(name), _), - .. - } = clause - && registry.get_predicate(name).is_none() - { - bail_coded!(ErrorCode::Qry007, name); - } - } - - // Collect Pattern, Expr, Not, and NotJoin top-level clauses for the planner. - // Rule invocations are converted to WhereClause::Pattern against derived_storage. - let mut plan_clauses: Vec = query - .where_clauses - .iter() - .filter(|c| { - matches!( - c, - WhereClause::Pattern(_) - | WhereClause::Expr { .. } - | WhereClause::Not(_) - | WhereClause::NotJoin { .. } - ) - }) - .cloned() - .collect(); - - let rule_positions = query - .where_clauses - .iter() - .enumerate() - .filter(|(_, c)| matches!(c, WhereClause::RuleInvocation { .. })) - .map(|(i, _)| i); - let mut rule_patterns = Vec::new(); - for ((predicate, args), at) in query - .get_top_level_rule_invocations() - .into_iter() - .zip(rule_positions) - { - let pattern = match args.len() { - 1 => { - #[allow(clippy::indexing_slicing)] - let entity = args[0].clone(); - Pattern::new( - entity, - EdnValue::Keyword(format!(":{}", predicate)), - EdnValue::Symbol("?_rule_value".to_string()), - ) - } - 2 => { - #[allow(clippy::indexing_slicing)] - let entity = args[0].clone(); - #[allow(clippy::indexing_slicing)] - let value = args[1].clone(); - Pattern::new(entity, EdnValue::Keyword(format!(":{}", predicate)), value) - } - n => { - return Err(err_coded!(ErrorCode::Int028, predicate, n)); - } - }; - rule_patterns.push((pattern.clone(), at)); - plan_clauses.push(WhereClause::Pattern(pattern)); - } - - let mut binders = Binders::new(&query.where_clauses, rule_patterns); - let (planned, deferred_not_clauses) = optimizer::plan(plan_clauses); - - // Process planned clauses in order: Pattern → expand, Expr → filter/extend, - // Not/NotJoin → shrink bindings as soon as their variables are bound (#248). - let mut bindings: Vec = vec![Binding::new()]; - for (clause, hint) in planned { - match clause { - WhereClause::Pattern(p) => { - let rebind = binders.pattern(&p); - bindings = matcher.match_with_hint_seeded( - bindings, - &p, - hint.as_ref().unwrap_or(&optimizer::IndexHint::Eavt), - &rebind, - ); - } - WhereClause::Expr { expr, binding: out } => { - let replace = out - .as_deref() - .is_some_and(|var| binders.expression(&expr, var)); - bindings = bindings - .into_iter() - .filter_map(|b| apply_expr(&expr, out.as_deref(), b, ®istry, replace)) - .collect(); - } - WhereClause::Not(body) => { - bindings = apply_not_clause_derived( - bindings, - &body, - derived_facts.clone(), - valid_at_value.clone(), - ®istry, - ); - } - WhereClause::NotJoin { join_vars, clauses } => { - bindings = apply_not_join_clause_derived( - bindings, - &join_vars, - &clauses, - derived_facts.clone(), - valid_at_value.clone(), - ®istry, - ); - } - _ => {} - } - } - - // Apply Or/OrJoin clauses against derived facts (rules already evaluated) - let rules_guard = self - .rules - .read() - .map_err(|_| err_coded!(ErrorCode::Qry009))?; - let mut bindings = apply_or_clauses( - &query.where_clauses, - bindings, - derived_facts.clone(), - &rules_guard, - query.as_of.clone(), - Some(branch_valid_at(&valid_at_value)), - ®istry, - )?; - drop(rules_guard); - - // Apply Not/NotJoin clauses the planner couldn't place inline (#248), and - // expressions (#625) — their variables are only bound by the Or/OrJoin pass - // above. Expressions come first, as above. (The StratifiedEvaluator - // handles `not`/`not-join` in rule bodies; this handles them appearing directly - // in the query body alongside rule invocations.) - let mut deferred_not_clauses = deferred_not_clauses; - if optimizer::reorder() { - deferred_not_clauses.sort_by_key(optimizer::clause_cost); - } - for clause in deferred_not_clauses { - bindings = match clause { - WhereClause::Expr { expr, binding: out } => { - let replace = out - .as_deref() - .is_some_and(|var| binders.expression(&expr, var)); - bindings - .into_iter() - .filter_map(|b| apply_expr(&expr, out.as_deref(), b, ®istry, replace)) - .collect() - } - WhereClause::Not(body) => apply_not_clause_derived( - bindings, - &body, - derived_facts.clone(), - valid_at_value.clone(), - ®istry, - ), - WhereClause::NotJoin { join_vars, clauses } => apply_not_join_clause_derived( - bindings, - &join_vars, - &clauses, - derived_facts.clone(), - valid_at_value.clone(), - ®istry, - ), - _ => bindings, - }; - } - - let results = apply_post_processing(bindings, &query.find, &query.with_vars, ®istry)?; - - Ok(QueryResult::QueryResults { - vars: query.find.iter().map(|s| s.display_name()).collect(), - results, - }) - } - /// Execute a rule command: register the rule for later use fn execute_rule(&self, rule: Rule) -> Result { // Extract predicate name from rule head @@ -1164,387 +479,6 @@ impl DatalogExecutor { } } -/// Normalize a `Value` for use as a hash-join key. -/// -/// Entity keywords (`:foo`) and entity refs (`Value::Ref(uuid)`) represent the same -/// entity but appear as different variants depending on whether the value was stored in -/// the entity position (→ `Ref`) or the value position (→ `Keyword`) of a fact. -/// Normalize both to `Value::Ref` so that exclusion-set probes work correctly across -/// these two representations. -#[cfg(any(test, feature = "test-oracle"))] -fn normalize_value(v: &Value) -> Value { - if let Value::Keyword(k) = v { - use crate::query::datalog::matcher::edn_to_entity_id; - use crate::query::datalog::types::EdnValue; - if let Ok(uuid) = edn_to_entity_id(&EdnValue::Keyword(k.clone())) { - return Value::Ref(uuid); - } - } - v.clone() -} - -/// Evaluate a `not` body against the current outer binding. -/// -/// Returns true if the body "matches" (i.e., the outer binding should be excluded). -/// The body is matched from the outer values of the variables it names -/// (`seeded_body_rows`, #546). Rule invocations in it match the rule-derived -/// facts `storage` holds on the rules path. -#[cfg(any(test, feature = "test-oracle"))] -fn not_body_matches( - not_body: &[WhereClause], - outer: &Binding, - storage: Arc<[Fact]>, - valid_at: Value, - registry: &FunctionRegistry, -) -> bool { - use crate::query::datalog::evaluator::{not_seed, seeded_body_rows}; - let rows = seeded_body_rows(not_body, not_seed(not_body, outer), storage, valid_at); - // Errors (e.g. unknown UDF predicate) are treated as "no match" — same as an - // empty result — so the outer row is kept (not-condition not violated). - !apply_expr_clauses(rows, not_body, registry) - .unwrap_or_default() - .is_empty() -} - -/// Filter `bindings` through a single `(not ...)` body, for the rule-free query path -/// (`execute_query`). Used both inline — as `plan()` pushes a `Not` clause to the -/// earliest position where its variables are bound — and for clauses `plan()` had to -/// defer (evaluated last, after Or/OrJoin, exactly as before push-down existed). -/// -/// Precomputes one exclusion set from the body's patterns (matched once against -/// `filtered_facts`, independent of `bindings`), then probes it per binding — same -/// fast path as the pre-#248 post-filter, just scoped to one clause at a time. -#[cfg(any(test, feature = "test-oracle"))] -fn apply_not_clause( - bindings: Vec, - not_body: &[WhereClause], - filtered_facts: Arc<[Fact]>, - valid_at_value: Value, - registry: &FunctionRegistry, -) -> Vec { - // Expressions, and pseudo-attributes that may read an outer source - // (#594), need the outer row: no exclusion set matched without it. - let has_expr = not_body - .iter() - .any(|c| matches!(c, WhereClause::Expr { .. })) - || reads_metadata(not_body); - let patterns: Vec = not_body - .iter() - .filter_map(|c| match c { - WhereClause::Pattern(p) => Some(p.clone()), - _ => None, - }) - .collect(); - - if patterns.is_empty() { - // Expr-only body: no pre-computation possible, fall back to per-binding eval. - return bindings - .into_iter() - .filter(|b| { - !not_body_matches( - not_body, - b, - filtered_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect(); - } - - let matcher = - PatternMatcher::from_slice_with_valid_at(filtered_facts.clone(), valid_at_value.clone()); - let exclusion_set: std::collections::HashSet> = matcher - .match_patterns(&patterns) - .into_iter() - .map(|b| { - let mut kv: Vec<(String, Value)> = b - .into_iter() - .map(|(k, v)| (k, normalize_value(&v))) - .collect(); - kv.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - kv - }) - .collect(); - - if exclusion_set.is_empty() && !has_expr { - // No excluding bindings anywhere — every outer binding is safe. - return bindings; - } - - bindings - .into_iter() - .filter(|binding| { - if !has_expr && let Some(sample) = exclusion_set.iter().next() { - let key: Vec<(String, Value)> = sample - .iter() - .filter_map(|(var, _)| { - binding - .get(var) - .map(|val| (var.clone(), normalize_value(val))) - }) - .collect(); - if key.len() == sample.len() { - return !exclusion_set.contains(&key); - } - // Outer binding is underspecified (fewer vars than the exclusion set - // key) — fall back to the slow path. - } - !not_body_matches( - not_body, - binding, - filtered_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect() -} - -/// Filter `bindings` through a single `(not-join [...] ...)` body, for the rule-free -/// query path (`execute_query`). Mirrors [`apply_not_clause`] but keys the exclusion -/// set on `join_vars` (the subset actually bound in every body row) instead of all -/// body variables. -#[cfg(any(test, feature = "test-oracle"))] -fn apply_not_join_clause( - bindings: Vec, - join_vars: &[String], - nj_clauses: &[WhereClause], - filtered_facts: Arc<[Fact]>, - valid_at_value: Value, - registry: &FunctionRegistry, -) -> Vec { - // Expressions, and pseudo-attributes that may read an outer source - // (#594), need the outer row: no exclusion set matched without it. - let has_expr = nj_clauses - .iter() - .any(|c| matches!(c, WhereClause::Expr { .. })) - || reads_metadata(nj_clauses); - let patterns: Vec = nj_clauses - .iter() - .filter_map(|c| match c { - WhereClause::Pattern(p) => Some(p.clone()), - _ => None, - }) - .collect(); - - if patterns.is_empty() { - return bindings - .into_iter() - .filter(|b| { - !evaluate_not_join( - join_vars, - nj_clauses, - b, - filtered_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect(); - } - - let matcher = - PatternMatcher::from_slice_with_valid_at(filtered_facts.clone(), valid_at_value.clone()); - let body_bindings = matcher.match_patterns(&patterns); - - let key_vars: Vec = if body_bindings.is_empty() { - join_vars.to_vec() - } else { - join_vars - .iter() - .filter(|v| body_bindings.iter().all(|b| b.contains_key(*v))) - .cloned() - .collect() - }; - let exclusion_set: std::collections::HashSet> = body_bindings - .iter() - .map(|b| { - let mut kv: Vec<(String, Value)> = key_vars - .iter() - .filter_map(|v| b.get(v).map(|val| (v.clone(), normalize_value(val)))) - .collect(); - kv.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - kv - }) - .collect(); - - bindings - .into_iter() - .filter(|binding| { - if !has_expr { - if key_vars.is_empty() { - // Body bound no join vars: if exclusion set non-empty, the body - // always succeeds, so it excludes every outer binding. - return exclusion_set.is_empty(); - } - let mut key: Vec<(String, Value)> = key_vars - .iter() - .filter_map(|v| binding.get(v).map(|val| (v.clone(), normalize_value(val)))) - .collect(); - key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if key.len() == key_vars.len() { - return !exclusion_set.contains(&key); - } - // Outer binding underspecified relative to the not-join body — fall - // back to the slow path so the body is correctly evaluated. - } - !evaluate_not_join( - join_vars, - nj_clauses, - binding, - filtered_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect() -} - -/// Filter `bindings` through a single `(not ...)` body for the rules query path, -/// where rule invocations in the body match `derived_facts`. -#[cfg(any(test, feature = "test-oracle"))] -fn apply_not_clause_derived( - bindings: Vec, - not_body: &[WhereClause], - derived_facts: Arc<[Fact]>, - valid_at_value: Value, - registry: &FunctionRegistry, -) -> Vec { - bindings - .into_iter() - .filter(|b| { - !not_body_matches( - not_body, - b, - derived_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect() -} - -/// Whether `clauses`, or any clause list inside them, holds a per-fact -/// pseudo-attribute pattern (#594), which reads metadata a source bound, -/// possibly outside `clauses`. -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn reads_metadata(clauses: &[WhereClause]) -> bool { - clauses.iter().any(|c| match c { - WhereClause::Pattern(p) => p.pseudo_source.is_some(), - WhereClause::Not(body) | WhereClause::NotJoin { clauses: body, .. } => reads_metadata(body), - WhereClause::Or(branches) | WhereClause::OrJoin { branches, .. } => { - branches.iter().any(|b| reads_metadata(b)) - } - WhereClause::Expr { .. } | WhereClause::RuleInvocation { .. } => false, - }) -} - -/// The variables an `or` / `or-join` branch binds itself: by a pattern, a -/// rule invocation or an expression output. -#[cfg(any(test, feature = "test-oracle"))] -fn branch_binds(branch: &[WhereClause]) -> std::collections::HashSet { - let mut bound = std::collections::HashSet::new(); - for c in branch { - match c { - WhereClause::Pattern(p) => bound.extend(optimizer::pattern_bound_vars(p)), - WhereClause::RuleInvocation { args, .. } => { - for a in args { - if let EdnValue::Symbol(s) = a - && s.starts_with('?') - { - bound.insert(s.clone()); - } - } - } - WhereClause::Expr { - binding: Some(b), .. - } => { - bound.insert(b.clone()); - } - _ => {} - } - } - bound -} - -/// The variables an `or` / `or-join` branch's expressions read that the branch -/// itself never binds — by a pattern, a rule invocation or an expression output, -/// its own or an enclosing nested branch's. Only the outer row can bind them, so -/// a branch with any must be seeded with that row, not evaluated from an empty -/// binding and joined afterwards (#620). -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn branch_outer_reads(branch: &[WhereClause]) -> std::collections::HashSet { - let bound = branch_binds(branch); - let mut reads = std::collections::HashSet::new(); - for c in branch { - match c { - WhereClause::Expr { expr, .. } => reads.extend(optimizer::expr_vars(expr)), - WhereClause::Or(branches) | WhereClause::OrJoin { branches, .. } => { - for b in branches { - reads.extend(branch_outer_reads(b)); - } - } - _ => {} - } - } - reads.retain(|v| !bound.contains(v)); - reads -} - -/// Filter `bindings` through a single `(not-join [...] ...)` body for the rules query -/// path — no exclusion-set fast path here (matches the pre-#248 post-filter, which -/// never had one for this path either). -#[cfg(any(test, feature = "test-oracle"))] -fn apply_not_join_clause_derived( - bindings: Vec, - join_vars: &[String], - nj_clauses: &[WhereClause], - derived_facts: Arc<[Fact]>, - valid_at_value: Value, - registry: &FunctionRegistry, -) -> Vec { - bindings - .into_iter() - .filter(|b| { - !evaluate_not_join( - join_vars, - nj_clauses, - b, - derived_facts.clone(), - valid_at_value.clone(), - registry, - ) - }) - .collect() -} - -/// Extract plain variable values from bindings (non-aggregate path). -#[cfg(any(test, feature = "test-oracle"))] -fn extract_variables( - bindings: Vec>, - find_specs: &[FindSpec], -) -> Vec> { - let mut results = Vec::new(); - for binding in bindings { - let mut row = Vec::new(); - for spec in find_specs { - if let Some(value) = binding.get(spec.var()) { - row.push(value.clone()); - } else { - break; - } - } - if row.len() == find_specs.len() { - results.push(row); - } - } - results -} - -#[cfg(any(test, feature = "test-oracle"))] -type Binding = std::collections::HashMap; - /// Which clause of a query's top-level `:where` gave each variable its value /// (#545, #473 spec §5.4). /// @@ -1592,868 +526,76 @@ impl Binders { text, exprs, by_var: HashMap::new(), - } - } - - /// Record the pattern `p`, run next, and return the variables whose - /// value it replaces. - pub(crate) fn pattern(&mut self, p: &Pattern) -> Vec { - let real = matches!(p.attribute, AttributeSpec::Real(_)); - let at = match self.text.iter().position(|(q, _)| q == p) { - // A pseudo-attribute pattern never gives a variable its value: it - // ranks after every real pattern, whatever runs first (#606). - Some(i) if real => self.text.swap_remove(i).1, - Some(i) => { - self.text.swap_remove(i); - usize::MAX - } - None => usize::MAX, - }; - let attribute = match &p.attribute { - AttributeSpec::Real(a) => Some(a), - AttributeSpec::Pseudo(_) => None, - }; - let mut rebind = Vec::new(); - for c in [Some(&p.entity), attribute, Some(&p.value)] - .into_iter() - .flatten() - { - let EdnValue::Symbol(v) = c else { continue }; - if !v.starts_with('?') || v.starts_with("?_") { - continue; - } - match self.by_var.get(v) { - None => { - self.by_var.insert(v.clone(), at); - } - Some(b) if real && at < *b => { - self.by_var.insert(v.clone(), at); - if !rebind.contains(v) { - rebind.push(v.clone()); - } - } - Some(_) => {} - } - } - rebind - } - - /// Record the expression `expr` binding `var`, run next, and return - /// whether its value replaces the one a clause already gave `var`: when - /// that clause is later in the text. - pub(crate) fn expression(&mut self, expr: &Expr, var: &str) -> bool { - let at = match self - .exprs - .iter() - .position(|(e, v, _)| e == expr && v == var) - { - Some(i) => self.exprs.swap_remove(i).2, - None => usize::MAX, - }; - match self.by_var.get(var) { - None => { - self.by_var.insert(var.to_string(), at); - false - } - Some(b) if at < *b => { - self.by_var.insert(var.to_string(), at); - true - } - Some(_) => false, - } - } -} - -/// Unified post-processing: handles plain-variable extraction, aggregation, -/// window functions, and mixed (aggregate + window) queries. -/// -/// - Plain variables only → `extract_variables` (no change from current path). -/// - Aggregates only → group-by collapse, then project. -/// - Windows only → partition/sort/accumulate per spec, then project. -/// - Mixed → aggregate collapses first, window runs over collapsed rows. -#[cfg(any(test, feature = "test-oracle"))] -fn apply_post_processing( - bindings: Vec, - find_specs: &[FindSpec], - with_vars: &[String], - registry: &FunctionRegistry, -) -> Result>> { - let has_aggregates = find_specs - .iter() - .any(|s| matches!(s, FindSpec::Aggregate { .. })); - let has_windows = find_specs.iter().any(|s| matches!(s, FindSpec::Window(_))); - - if !has_aggregates && !has_windows { - return Ok(extract_variables(bindings, find_specs)); - } - - // Step 1: Aggregate (collapses rows, produces binding maps). - let mut working: Vec = if has_aggregates { - compute_aggregation(bindings, find_specs, with_vars, registry)? - } else { - bindings - }; - - // Step 2: Window functions (annotate each row, no collapse). - if has_windows { - apply_window_functions(&mut working, find_specs, registry)?; - } - - // Step 3: Project to output rows in find-spec order. - Ok(project_find_specs(&working, find_specs)) -} - -/// Group bindings by non-aggregate find vars + with_vars, apply aggregate functions, -/// return one binding map per group. Aggregate results stored under `"__agg_{i}"`. -/// -/// Each group holds one accumulator per aggregate (#547 spec §3.2), so the -/// result does not depend on the order of the bindings. Groups finish in -/// key order; the first aggregate in `:find` order whose result is an error -/// fails the query, except `INT-042`, which drops the group (spec §3.3). -#[cfg(any(test, feature = "test-oracle"))] -fn compute_aggregation( - bindings: Vec, - find_specs: &[FindSpec], - with_vars: &[String], - registry: &FunctionRegistry, -) -> Result> { - let has_grouping_vars = find_specs - .iter() - .any(|s| matches!(s, FindSpec::Variable(_))); - - // Special case: zero bindings + all-count specs → one zero row. - if bindings.is_empty() { - let all_count = !has_grouping_vars - && find_specs.iter().all(|s| { - matches!(s, FindSpec::Aggregate { func, .. } - if func == "count" || func == "count-distinct") - }); - if all_count { - let mut b = Binding::new(); - for (i, _) in find_specs.iter().enumerate() { - b.insert(format!("__agg_{}", i), Value::Integer(0)); - } - return Ok(vec![b]); - } - return Ok(vec![]); - } - - // In a mixed aggregate+window query, :with vars must NOT be added to the - // grouping key. The window phase runs after aggregation and reads only - // the grouping variables (PRS-082), so :with vars would only inflate the - // number of groups. - let has_windows = find_specs.iter().any(|s| matches!(s, FindSpec::Window(_))); - - // Grouping key = Variable find specs (in find order). - // In pure-aggregate queries, also include with_vars (Datomic semantics: :with - // prevents pre-aggregation de-duplication by adding vars to the group key). - let mut group_var_names: Vec<&str> = find_specs - .iter() - .filter_map(|s| match s { - FindSpec::Variable(v) => Some(v.as_str()), - _ => None, - }) - .collect(); - if !has_windows { - group_var_names.extend(with_vars.iter().map(|s| s.as_str())); - } - - // The aggregates of :find: their position, function and argument. - let aggs: Vec<(usize, &str, &str)> = find_specs - .iter() - .enumerate() - .filter_map(|(i, s)| match s { - FindSpec::Aggregate { func, var } => Some((i, func.as_str(), var.as_str())), - _ => None, - }) - .collect(); - - // Groups in key order, as `Value`'s `Ord` compares keys. Each holds the - // values it returns: of the key values `Ord` finds equal (`-0.0` and - // `0.0`, NaNs), the least by `value_order`, whatever the input order. - let mut groups = Groups::new(); - for b in bindings { - let key: Vec = group_var_names - .iter() - .map(|v| b.get(*v).cloned().unwrap_or(Value::Null)) - .collect(); - let (shown, accs) = match groups.entry(key) { - std::collections::btree_map::Entry::Occupied(e) => e.into_mut(), - std::collections::btree_map::Entry::Vacant(e) => { - let shown = e.key().clone(); - e.insert(( - shown, - aggs.iter() - .map(|(_, func, _)| Agg::new(func, registry)) - .collect::>>()?, - )) - } - }; - for (s, v) in shown.iter_mut().zip(&group_var_names) { - if let Some(v) = b.get(*v) - && value_order(v, s).is_lt() - { - *s = v.clone(); - } - } - for (acc, (_, _, var)) in accs.iter_mut().zip(&aggs) { - if let Some(v) = b.get(*var) { - acc.step(v); - } - } - } - - // The plain :find variables occupy the first key positions; with_vars - // follow and only group. - let plain: Vec<&str> = find_specs - .iter() - .filter_map(|s| match s { - FindSpec::Variable(v) => Some(v.as_str()), - _ => None, - }) - .collect(); - - let funcs: Vec<&str> = aggs.iter().map(|(_, func, _)| *func).collect(); - let mut results: Vec = Vec::new(); - for (shown, values) in finish_groups(groups, &funcs)? { - let mut binding = Binding::new(); - for (v, val) in plain.iter().zip(shown) { - binding.insert((*v).to_string(), val); - } - for (v, (i, _, _)) in values.into_iter().zip(&aggs) { - binding.insert(format!("__agg_{}", i), v); - } - results.push(binding); - } - - Ok(results) -} - -/// Compute window function values for each row and store under `"__win_{i}"`. -/// Modifies `bindings` in place; rows keep their order. The values come -/// from [`windows`], over each binding's named variables (`nil` when -/// absent). -#[cfg(any(test, feature = "test-oracle"))] -fn apply_window_functions( - bindings: &mut [Binding], - find_specs: &[FindSpec], - registry: &FunctionRegistry, -) -> Result<()> { - let named = named_vars(find_specs); - let rows: Vec> = bindings - .iter() - .map(|b| { - named - .iter() - .map(|v| b.get(v).cloned().unwrap_or(Value::Null)) - .collect() - }) - .collect(); - let positions = find_specs - .iter() - .enumerate() - .filter(|(_, s)| matches!(s, FindSpec::Window(_))) - .map(|(i, _)| i); - for (i, values) in positions.zip(windows(find_specs, &rows, registry)?) { - let key = format!("__win_{}", i); - for (b, v) in bindings.iter_mut().zip(values) { - b.insert(key.clone(), v); - } - } - Ok(()) -} - -/// Project binding maps to output rows in find-spec order. -#[cfg(any(test, feature = "test-oracle"))] -fn project_find_specs(bindings: &[Binding], find_specs: &[FindSpec]) -> Vec> { - let mut results = Vec::new(); - for binding in bindings { - let mut row = Vec::new(); - let mut complete = true; - for (i, spec) in find_specs.iter().enumerate() { - let val = match spec { - FindSpec::Variable(v) => binding.get(v).cloned(), - FindSpec::Aggregate { .. } => binding.get(&format!("__agg_{}", i)).cloned(), - FindSpec::Window(_) => binding.get(&format!("__win_{}", i)).cloned(), - }; - match val { - Some(v) => row.push(v), - // Invariant: all __agg_{i} and __win_{i} keys are populated for non-skipped rows. - // None here only occurs for skipped aggregate groups (e.g. min/max on all-null input). - None => { - complete = false; - break; - } - } - } - if complete { - results.push(row); - } - } - results -} - -/// The valid time an `or` branch binds `:db/valid-at` from: the query's, -/// with "now" read once for the whole query (#546), not again per branch. -#[cfg(any(test, feature = "test-oracle"))] -fn branch_valid_at(valid_at_value: &Value) -> ValidAt { - match valid_at_value { - Value::Integer(t) => ValidAt::Timestamp(*t), - _ => ValidAt::AnyValidTime, - } -} - -/// Evaluate a single branch of an `or`/`or-join` against incoming bindings. -/// -/// Processing order (note: top-level execute_query now uses an interleaved plan loop -/// where Expr clauses are pushed down inline; branches retain their own Expr post-pass): -/// 1. Pattern/RuleInvocation → match_patterns_seeded -/// 2. Nested Or/OrJoin → apply_or_clauses (recursive) -/// 3. Not/NotJoin → post-filter -/// 4. Expr → apply_expr_clauses -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn evaluate_branch( - branch: &[WhereClause], - incoming: Vec, - storage: Arc<[Fact]>, - rules: &crate::query::datalog::rules::RuleRegistry, - as_of: Option, - valid_at: Option, - registry: &FunctionRegistry, -) -> anyhow::Result> { - use crate::query::datalog::evaluator::rule_invocation_to_pattern; - use crate::query::datalog::matcher::PatternMatcher; - - if incoming.is_empty() { - return Ok(vec![]); - } - - // Compute valid_at_value for pseudo-attribute binding in this branch. - let branch_valid_at_value = match &valid_at { - Some(ValidAt::Timestamp(t)) => Value::Integer(*t), - Some(ValidAt::AnyValidTime) => Value::Null, - Some(ValidAt::Slot(_)) => { - return Err(err_coded!(ErrorCode::Int025)); - } - None => Value::Integer(tx_id_now().cast_signed()), - }; - - // Step 1: Collect Pattern and RuleInvocation clauses - let patterns: Vec = branch - .iter() - .filter_map(|c| match c { - WhereClause::Pattern(p) => Some(p.clone()), - WhereClause::RuleInvocation { predicate, args } => { - rule_invocation_to_pattern(predicate, args).ok() - } - _ => None, - }) - .collect(); - - let matcher = - PatternMatcher::from_slice_with_valid_at(storage.clone(), branch_valid_at_value.clone()); - let bindings = if patterns.is_empty() { - incoming - } else { - matcher.match_patterns_seeded(&patterns, incoming) - }; - - if bindings.is_empty() { - return Ok(vec![]); - } - - // Step 2: Nested Or/OrJoin - let bindings = apply_or_clauses( - branch, - bindings, - storage.clone(), - rules, - as_of.clone(), - valid_at.clone(), - registry, - )?; - - if bindings.is_empty() { - return Ok(vec![]); - } - - // Step 3: Not/NotJoin post-filter - let not_clauses: Vec<&Vec> = branch - .iter() - .filter_map(|c| match c { - WhereClause::Not(inner) => Some(inner), - _ => None, - }) - .collect(); - - let not_join_clauses: Vec<(Vec, Vec)> = branch - .iter() - .filter_map(|c| match c { - WhereClause::NotJoin { join_vars, clauses } => { - Some((join_vars.clone(), clauses.clone())) - } - _ => None, - }) - .collect(); - - let bindings = if not_clauses.is_empty() && not_join_clauses.is_empty() { - bindings - } else { - bindings - .into_iter() - .filter(|binding| { - for not_body in ¬_clauses { - if not_body_matches( - not_body, - binding, - storage.clone(), - branch_valid_at_value.clone(), - registry, - ) { - return false; - } - } - for (join_vars, nj_clauses) in ¬_join_clauses { - if evaluate_not_join( - join_vars, - nj_clauses, - binding, - storage.clone(), - branch_valid_at_value.clone(), - registry, - ) { - return false; - } - } - true - }) - .collect() - }; - - // Step 4: Expr clauses - let bindings = apply_expr_clauses(bindings, branch, registry)?; - - Ok(bindings) -} - -/// Apply all Or/OrJoin clauses from `clauses` to `bindings` in sequence. -/// -/// Non-Or/OrJoin clauses are ignored (handled elsewhere). -/// For `Or`: union results from all branches (deduplicated by full binding map). -/// For `OrJoin`: union results, then project out branch-private variables. -/// A branch row meets an outer row by join equality (#546, spec §5.3): a -/// keyword equals a ref to the entity it names; floats compare by IEEE `==` -/// (`Value`'s own equality). Dedup keys stay exact `Value`s. -#[cfg(any(test, feature = "test-oracle"))] -fn join_value(v: &Value) -> Value { - PatternMatcher::normalize_join_value(v) -} - -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn apply_or_clauses( - clauses: &[WhereClause], - mut bindings: Vec, - storage: Arc<[Fact]>, - rules: &crate::query::datalog::rules::RuleRegistry, - as_of: Option, - valid_at: Option, - registry: &FunctionRegistry, -) -> anyhow::Result> { - for clause in clauses { - match clause { - WhereClause::Or(branches) => { - let sorted_or_branches: Vec<&Vec> = { - let mut b: Vec<&Vec> = branches.iter().collect(); - // Sort branches by cost ascending so cheaper branches evaluate first, - // maximizing the chance the short-circuit below fires early (#250). - if optimizer::reorder() { - b.sort_by_key(|br| optimizer::branch_cost(br)); - } - b - }; - // If any branch contains Not/NotJoin clauses (which need bound variables - // from the outer scope to evaluate correctly), fall back to the classic - // seeded-branch evaluation to preserve correctness. - // So does a branch whose pseudo-attribute may read an outer - // source's metadata (#594), or whose expression reads a variable - // only the outer row binds (#620). - let any_branch_has_not = sorted_or_branches.iter().any(|b| { - b.iter() - .any(|c| matches!(c, WhereClause::Not(_) | WhereClause::NotJoin { .. })) - || reads_metadata(b) - || !branch_outer_reads(b).is_empty() - }); - - if any_branch_has_not { - // Classic O(N·B) seeded evaluation: each incoming binding seeds each branch. - let mut seen: std::collections::HashSet> = - std::collections::HashSet::new(); - let mut result: Vec = Vec::new(); - for branch in &sorted_or_branches { - let branch_result = evaluate_branch( - branch, - bindings.clone(), - storage.clone(), - rules, - as_of.clone(), - valid_at.clone(), - registry, - )?; - for b in branch_result { - let mut key: Vec<_> = b - .iter() - .filter(|(k, _)| !k.starts_with("__")) - .map(|(k, v)| (k.clone(), v.clone())) - .collect(); - key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if seen.insert(key) { - result.push(b); - } - } - } - bindings = result; - continue; - } - - // Fast path: no Not/NotJoin in any branch. - // Evaluate every branch from an empty seed (independent of incoming bindings), - // then hash-join the union back onto incoming bindings on shared variables. - let empty_seed: Vec = vec![HashMap::new()]; - let mut union_bindings: Vec = Vec::new(); - let mut seen_keys: std::collections::HashSet> = - std::collections::HashSet::new(); - - // Variable names already bound in the incoming scope — used below to detect - // whether a branch introduces a *new* variable (#250 short-circuit gating). - let reorder = optimizer::reorder(); - let incoming_var_names: std::collections::HashSet = if reorder { - bindings - .iter() - .flat_map(|b| b.keys().cloned()) - .filter(|k| !k.starts_with("__")) - .collect() - } else { - Default::default() - }; - - for branch in &sorted_or_branches { - let branch_result = evaluate_branch( - branch, - empty_seed.clone(), - storage.clone(), - rules, - as_of.clone(), - valid_at.clone(), - registry, - )?; - for b in branch_result { - // Deduplicate on user-visible variables only (exclude internal `__` keys). - let mut key: Vec<_> = b - .iter() - .filter(|(k, _)| !k.starts_with("__")) - .map(|(k, v)| (k.clone(), v.clone())) - .collect(); - key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if seen_keys.insert(key) { - union_bindings.push(b); - } - } - - // Short-circuit (#250): unlike or-join, a plain `or` branch's newly - // introduced variables DO survive into the merged result (see the - // `or_insert_with` merge below), so two branches matching the same - // shared key can legitimately produce different, both-needed rows. - // Skipping a branch is only safe when the branches evaluated so far - // introduce no variable beyond what's already bound in the incoming - // scope — i.e. this `or` is a pure filter (all branches bind the same - // new-var set per the parser's or-safety check), so any further match on - // an already-covered key would just re-derive an identical row. - if reorder { - let branch_var_names: std::collections::HashSet<&str> = union_bindings - .iter() - .flat_map(|bb| bb.keys().map(|k| k.as_str())) - .filter(|k| !k.starts_with("__")) - .collect(); - let is_pure_filter = !branch_var_names.is_empty() - && branch_var_names - .iter() - .all(|v| incoming_var_names.contains(*v)); - if is_pure_filter { - let covered: std::collections::HashSet> = - union_bindings - .iter() - .map(|b| { - let mut k: Vec<(String, Value)> = branch_var_names - .iter() - .filter_map(|v| { - b.get(*v) - .map(|val| (v.to_string(), join_value(val))) - }) - .collect(); - k.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - k - }) - .collect(); - let fully_covered = bindings.iter().all(|incoming| { - let mut k: Vec<(String, Value)> = branch_var_names - .iter() - .filter_map(|v| { - incoming.get(*v).map(|val| (v.to_string(), join_value(val))) - }) - .collect(); - k.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - covered.contains(&k) - }); - if fully_covered { - break; - } - } - } - } - - // Each branch row meets an incoming row on the variables both - // bind: the row's own, since branches may name different - // outer variables (#546). Exclude internal metadata keys - // (prefixed with `__`) — those are fact-specific and differ - // between patterns for the same entity. - let outer_vars: std::collections::HashSet<&str> = bindings - .iter() - .flat_map(|b| b.keys().map(|k| k.as_str())) - .filter(|k| !k.starts_with("__")) - .collect(); - - // With no shared variable every key is empty, so each incoming - // row joins every branch row: a cross product (#610). - - // Group the branch rows by their shared variables, then key - // each group's rows on them. - type Groups = Vec<(Vec, HashMap, Vec>)>; - let mut groups: Groups = Vec::new(); - for b in union_bindings { - let mut shared: Vec = b - .keys() - .filter(|k| outer_vars.contains(k.as_str())) - .cloned() - .collect(); - shared.sort_unstable(); - let key: Vec<(String, Value)> = shared - .iter() - .filter_map(|v| b.get(v).map(|val| (v.clone(), join_value(val)))) - .collect(); - if !groups.iter().any(|(vars, _)| *vars == shared) { - groups.push((shared.clone(), HashMap::new())); - } - if let Some((_, map)) = groups.iter_mut().find(|(vars, _)| *vars == shared) { - map.entry(key).or_default().push(b); - } - } - - // For each incoming binding, look up matching branch results and merge. - let mut result: Vec = Vec::new(); - let mut seen_result: std::collections::HashSet> = - std::collections::HashSet::new(); - for incoming in &bindings { - for (shared, branch_map) in &groups { - let key: Vec<(String, Value)> = shared - .iter() - .filter_map(|v| incoming.get(v).map(|val| (v.clone(), join_value(val)))) - .collect(); - let Some(matches) = branch_map.get(&key) else { - continue; - }; - for branch_binding in matches { - // Merge: start with incoming, extend with branch-introduced vars. - let mut merged = incoming.clone(); - for (k, v) in branch_binding { - merged.entry(k.clone()).or_insert_with(|| v.clone()); - } - let mut dedup_key: Vec<_> = - merged.iter().map(|(k, v)| (k.clone(), v.clone())).collect(); - dedup_key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if seen_result.insert(dedup_key) { - result.push(merged); - } - } - } - } - bindings = result; - } - - WhereClause::OrJoin { - join_vars, - branches, - } => { - // No incoming rows: the join is empty. Skip before the defensive check - // below, which derives outer_keys from the rows and would otherwise - // report every join var as unbound (#405). - if bindings.is_empty() { - continue; - } - let sorted_oj_branches: Vec<&Vec> = { - let mut b: Vec<&Vec> = branches.iter().collect(); - // Sort branches by cost ascending so cheaper branches evaluate first, - // maximizing the chance the short-circuit below fires early (#250). - if optimizer::reorder() { - b.sort_by_key(|br| optimizer::branch_cost(br)); - } - b - }; - let outer_keys: std::collections::HashSet = - bindings.iter().flat_map(|b| b.keys().cloned()).collect(); - - // Defensive check: every join_var must be bound in the incoming scope. - // The parser validates this, but guard here to avoid silent wrong results - // if a join_var is missing from outer_keys (hash-join key would be partial). - for jv in join_vars.iter() { - if !outer_keys.contains(jv.as_str()) { - bail_coded!(ErrorCode::Int031, jv); - } - } - - // A branch whose pseudo-attribute may read an outer source's - // metadata (#594) needs it from the outer row: evaluate the - // branches per row, seeded with its join variables only (the - // others are fresh inside), and keep the distinct rows some - // branch matches, as the joined path below does. So does a - // branch whose expression reads a join variable it does not - // bind itself (#620), and one that does not bind every join - // variable: the joined path would drop its rows (#546). - if sorted_oj_branches.iter().any(|b| { - reads_metadata(b) - || !branch_outer_reads(b).is_empty() - || !join_vars.iter().all(|v| branch_binds(b).contains(v)) - }) { - let mut seen: std::collections::HashSet> = - std::collections::HashSet::new(); - let mut result: Vec = Vec::new(); - for incoming in &bindings { - let seed: Binding = join_vars - .iter() - .filter_map(|v| incoming.get(v).map(|val| (v.clone(), val.clone()))) - .collect(); - let mut matched = false; - for branch in &sorted_oj_branches { - if !evaluate_branch( - branch, - vec![seed.clone()], - storage.clone(), - rules, - as_of.clone(), - valid_at.clone(), - registry, - )? - .is_empty() - { - matched = true; - break; - } - } - let mut key: Vec<_> = incoming - .iter() - .map(|(k, v)| (k.clone(), v.clone())) - .collect(); - key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if matched && seen.insert(key) { - result.push(incoming.clone()); - } - } - bindings = result; - continue; - } - - let empty_seed: Vec = vec![HashMap::new()]; - let mut seen_proj: std::collections::HashSet> = - std::collections::HashSet::new(); - let mut branch_map: HashMap, Vec> = HashMap::new(); - - // Distinct join_vars-keyed tuples required by the incoming bindings (#250). - // Every branch is projected to outer_keys below, which are all variables - // already bound before this or-join runs — a branch can never introduce a - // variable that survives into the result. So once every required key has at - // least one match, a further (costlier) branch matching that same key can - // only add a row identical to one already merged, which the dedup below - // would drop anyway — unlike plain `or`, this holds regardless of what the - // branch itself binds internally. - let reorder = optimizer::reorder(); - let required_keys: std::collections::HashSet> = if reorder { - bindings - .iter() - .map(|incoming| { - join_vars - .iter() - .filter_map(|v| { - incoming.get(v).map(|val| (v.clone(), join_value(val))) - }) - .collect::>() - }) - .collect() - } else { - Default::default() - }; - - for branch in &sorted_oj_branches { - let branch_result = evaluate_branch( - branch, - empty_seed.clone(), - storage.clone(), - rules, - as_of.clone(), - valid_at.clone(), - registry, - )?; - for mut b in branch_result { - if !join_vars.iter().all(|v| b.contains_key(v)) { - continue; - } - // Project to outer_keys (preserves join_vars since join_vars ⊆ outer_keys) - b.retain(|k, _| outer_keys.contains(k)); - let mut key: Vec<_> = - b.iter().map(|(k, v)| (k.clone(), v.clone())).collect(); - key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if seen_proj.insert(key) { - let bkey: Vec<(String, Value)> = join_vars - .iter() - .filter_map(|v| b.get(v).map(|val| (v.clone(), join_value(val)))) - .collect(); - branch_map.entry(bkey).or_default().push(b); - } - } + } + } - if reorder && required_keys.iter().all(|k| branch_map.contains_key(k)) { - break; - } + /// Record the pattern `p`, run next, and return the variables whose + /// value it replaces. + pub(crate) fn pattern(&mut self, p: &Pattern) -> Vec { + let real = matches!(p.attribute, AttributeSpec::Real(_)); + let at = match self.text.iter().position(|(q, _)| q == p) { + // A pseudo-attribute pattern never gives a variable its value: it + // ranks after every real pattern, whatever runs first (#606). + Some(i) if real => self.text.swap_remove(i).1, + Some(i) => { + self.text.swap_remove(i); + usize::MAX + } + None => usize::MAX, + }; + let attribute = match &p.attribute { + AttributeSpec::Real(a) => Some(a), + AttributeSpec::Pseudo(_) => None, + }; + let mut rebind = Vec::new(); + for c in [Some(&p.entity), attribute, Some(&p.value)] + .into_iter() + .flatten() + { + let EdnValue::Symbol(v) = c else { continue }; + if !v.starts_with('?') || v.starts_with("?_") { + continue; + } + match self.by_var.get(v) { + None => { + self.by_var.insert(v.clone(), at); } - - let mut result: Vec = Vec::new(); - let mut seen_result: std::collections::HashSet> = - std::collections::HashSet::new(); - for incoming in &bindings { - let key: Vec<(String, Value)> = join_vars - .iter() - .filter_map(|v| incoming.get(v).map(|val| (v.clone(), join_value(val)))) - .collect(); - if let Some(matches) = branch_map.get(&key) { - for branch_binding in matches { - let mut merged = incoming.clone(); - for (k, v) in branch_binding { - merged.entry(k.clone()).or_insert_with(|| v.clone()); - } - let mut dedup_key: Vec<_> = - merged.iter().map(|(k, v)| (k.clone(), v.clone())).collect(); - dedup_key.sort_unstable_by(|a, b| a.0.cmp(&b.0)); - if seen_result.insert(dedup_key) { - result.push(merged); - } - } + Some(b) if real && at < *b => { + self.by_var.insert(v.clone(), at); + if !rebind.contains(v) { + rebind.push(v.clone()); } } - bindings = result; + Some(_) => {} } + } + rebind + } - _ => {} // Other clause types handled elsewhere + /// Record the expression `expr` binding `var`, run next, and return + /// whether its value replaces the one a clause already gave `var`: when + /// that clause is later in the text. + pub(crate) fn expression(&mut self, expr: &Expr, var: &str) -> bool { + let at = match self + .exprs + .iter() + .position(|(e, v, _)| e == expr && v == var) + { + Some(i) => self.exprs.swap_remove(i).2, + None => usize::MAX, + }; + match self.by_var.get(var) { + None => { + self.by_var.insert(var.to_string(), at); + false + } + Some(b) if at < *b => { + self.by_var.insert(var.to_string(), at); + true + } + Some(_) => false, } } - Ok(bindings) } /// Returns true for Boolean(true), non-zero Integer, non-zero Float. @@ -2667,79 +809,6 @@ pub(crate) fn eval_expr( } } -/// Apply all WhereClause::Expr clauses from `where_clauses` to `bindings`. -/// -/// Filter-form (`binding: None`) drops the row if the expr is not truthy or errors. -/// Binding-form (`binding: Some(var)`) extends the row with the computed value, -/// or keeps it only if an existing value of the variable is equal (#596). -/// Type mismatches and errors silently drop the row. -/// -/// Pre-validates UDF predicate names: returns `Err` if a named UDF predicate is not -/// registered, so callers get a clear error rather than silently empty results. -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn apply_expr_clauses( - mut bindings: Vec, - where_clauses: &[WhereClause], - registry: &FunctionRegistry, -) -> anyhow::Result> { - // Pre-validate: surface unknown UDF predicate names as errors before filtering rows. - for clause in where_clauses { - if let WhereClause::Expr { - expr: Expr::UnaryOp(UnaryOp::Udf(name), _), - .. - } = clause - && registry.get_predicate(name).is_none() - { - bail_coded!(ErrorCode::Qry007, name); - } - } - - for clause in where_clauses { - if let WhereClause::Expr { expr, binding: out } = clause { - bindings = bindings - .into_iter() - .filter_map(|b| apply_expr(expr, out.as_deref(), b, registry, false)) - .collect(); - } - } - Ok(bindings) -} - -/// One expression clause over the row `b`: `None` drops the row. -/// -/// A filter (`out` is `None`) keeps the row when the result is truthy. A -/// binding keeps it with `out` bound to the result, or, when `b` already binds -/// `out`, only if the two are equal as a join compares them (#596): floats by -/// IEEE `==`, a keyword equal to a ref to the entity it names, an integer -/// never equal to a float. `replace` then takes the result as the value -/// (`Binders::expression`). A failing expression drops the row. -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) fn apply_expr( - expr: &Expr, - out: Option<&str>, - mut b: Binding, - registry: &FunctionRegistry, - replace: bool, -) -> Option { - let v = eval_expr(expr, &b, Some(registry)).ok()?; - let Some(var) = out else { - return is_truthy(&v).then_some(b); - }; - match b.get(var) { - Some(old) - if PatternMatcher::normalize_join_value(old) - != PatternMatcher::normalize_join_value(&v) => - { - None - } - Some(_) if !replace => Some(b), - _ => { - b.insert(var.to_string(), v); - Some(b) - } - } -} - #[cfg(test)] mod tests { use super::*; @@ -2771,16 +840,9 @@ mod tests { .expect("keyword entity") } - fn query_of(text: &str) -> DatalogQuery { - match parse_datalog_command(text).expect("parse") { - DatalogCommand::Query(q) => q, - _ => panic!("expected a query"), - } - } - /// Answer change 1 (#551 spec §4): a `not` in an `or` branch sees the - /// variable an expression of the branch binds on the engine; the - /// executor applied the branch's `not` before its expression. + /// variable an expression of the branch binds; the executor applied the + /// branch's `not` before its expression. #[test] fn branch_not_sees_its_expression_binding() { let executor = DatalogExecutor::new(FactStorage::new()); @@ -2788,7 +850,6 @@ mod tests { .execute(parse_datalog_command("(transact [[:x :n 1] [:y :n 2] [:z :n 5]])").unwrap()) .unwrap(); let q = "(query [:find ?e :where [?e :n ?v] (or-join [?e ?v] (and [(+ ?v 1) ?w] (not [?f :n ?w])) [?e :n 5])])"; - let _exempt = crate::query::engine::oracle::exempt(); let before = crate::query::engine::RUNS.with(std::cell::Cell::get); let engine = entities(executor.execute(parse_datalog_command(q).unwrap())); assert_eq!( @@ -2804,8 +865,7 @@ mod tests { }, "the engine: :y (no :n 3) and :z" ); - let old = entities(executor.execute_query_on_executor(query_of(q))); - assert!(old == vec![keyword(":z")], "the executor: :z only"); + // The executor returned :z only. } /// Answer change 2 (#551 spec §4): an unknown predicate in an `or` @@ -2828,19 +888,14 @@ mod tests { "(query [:find ?e :where [?e :n ?v] (or (and [?e :n 99] [(no-such? ?v)]) [?e :n 5])])"; let rule = "(query [:find ?e :where (odd ?e)])"; let negated = "(query [:find ?e :where [?e :n ?v] (not [?e :n ?v] [(no-such? ?v)])])"; - let _exempt = crate::query::engine::oracle::exempt(); for q in [plain, rule, negated] { let err = executor .execute(parse_datalog_command(q).unwrap()) .expect_err("the engine resolves every predicate"); assert_eq!(crate::error::MinigrafError::from(err).code(), "QRY-007"); } - let old = entities(executor.execute_query_on_executor(query_of(plain))); - assert!(old == vec![keyword(":z")], "the executor: :z"); - let old = entities(executor.execute_query_with_rules(query_of(rule))); - assert!(old == vec![keyword(":z")], "the executor, rule body: :z"); - let old = entities(executor.execute_query_on_executor(query_of(negated))); - assert_eq!(old.len(), 2, "the executor: every outer row"); + // The executor returned :z for `plain` and `rule`, and both outer + // rows for `negated`. } #[test] @@ -3561,7 +1616,7 @@ mod tests { } #[test] - fn test_execute_query_with_rules_not_in_query_body() { + fn test_rule_query_not_in_query_body() { // Query: [:find ?x :where (reachable ?_a ?x) (not [?x :blocked true])] // rule invocation + pattern-not in same query body use crate::query::datalog::types::{Pattern, WhereClause}; @@ -3699,7 +1754,7 @@ mod tests { } #[test] - fn test_execute_query_with_rules_not_join_in_query_body() { + fn test_rule_query_not_join_in_query_body() { // Rule: (reachable ?x ?y) :- [?x :edge ?y] // Query: find ?y reachable from root that do NOT have a blocked dep let storage = FactStorage::new(); @@ -3764,606 +1819,62 @@ mod tests { ], }, ], - ); - - let executor = DatalogExecutor::new_with_rules(storage, rules); - let result = executor - .execute(crate::query::datalog::types::DatalogCommand::Query(query)) - .unwrap(); - - match result { - QueryResult::QueryResults { results, .. } => { - // a is excluded (has a blocked dep); b passes - assert_eq!(results.len(), 1, "only b should pass"); - } - _ => panic!("Expected QueryResults"), - } - } - - #[test] - fn test_optimizer_does_not_change_query_results() { - // A multi-pattern query that the optimizer would reorder. - // Results must be identical regardless of execution order. - let storage = FactStorage::new(); - let alice = uuid::Uuid::new_v4(); - let bob = uuid::Uuid::new_v4(); - storage - .transact( - vec![ - ( - alice, - ":name".to_string(), - Value::String("Alice".to_string()), - ), - (alice, ":friend".to_string(), Value::Ref(bob)), - (bob, ":name".to_string(), Value::String("Bob".to_string())), - ], - None, - ) - .unwrap(); - - let executor = DatalogExecutor::new(storage); - // Simple query: find all names (no join reordering needed) - let result = executor - .execute( - parse_datalog_command("(query [:find ?name :where [?e :name ?name]])").unwrap(), - ) - .unwrap(); - - match result { - QueryResult::QueryResults { results, .. } => { - assert_eq!(results.len(), 2, "Alice and Bob both have names"); - } - _ => panic!("Expected QueryResults"), - } - } - - // Helper: build a binding map from key-value pairs - fn binding(pairs: &[(&str, Value)]) -> std::collections::HashMap { - pairs - .iter() - .map(|(k, v)| (k.to_string(), v.clone())) - .collect() - } - - #[test] - fn test_apply_aggregation_count_basic() { - let bindings = vec![ - binding(&[("?e", Value::Integer(1))]), - binding(&[("?e", Value::Integer(2))]), - binding(&[("?e", Value::Integer(3))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "count".to_string(), - var: "?e".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results.len(), 1); - assert_eq!(results[0][0], Value::Integer(3)); - } - - #[test] - fn test_apply_aggregation_count_with_grouping() { - let bindings = vec![ - binding(&[ - ("?dept", Value::String("eng".to_string())), - ("?e", Value::Integer(1)), - ]), - binding(&[ - ("?dept", Value::String("eng".to_string())), - ("?e", Value::Integer(2)), - ]), - binding(&[ - ("?dept", Value::String("hr".to_string())), - ("?e", Value::Integer(3)), - ]), - ]; - let find_specs = vec![ - FindSpec::Variable("?dept".to_string()), - FindSpec::Aggregate { - func: "count".to_string(), - var: "?e".to_string(), - }, - ]; - let mut results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - results.sort_by_key(|r| match &r[0] { - Value::String(s) => s.clone(), - _ => String::new(), - }); - assert_eq!(results.len(), 2); - assert_eq!( - results[0], - vec![Value::String("eng".to_string()), Value::Integer(2)] - ); - assert_eq!( - results[1], - vec![Value::String("hr".to_string()), Value::Integer(1)] - ); - } - - #[test] - fn test_apply_aggregation_count_distinct() { - let bindings = vec![ - binding(&[("?v", Value::Integer(1))]), - binding(&[("?v", Value::Integer(1))]), // duplicate - binding(&[("?v", Value::Integer(2))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "count-distinct".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(2)); - } - - #[test] - fn test_apply_aggregation_count_empty_no_grouping_vars() { - // count with no grouping vars + zero bindings → [[0]] - let find_specs = vec![FindSpec::Aggregate { - func: "count".to_string(), - var: "?e".to_string(), - }]; - let results = - apply_post_processing(vec![], &find_specs, &[], &FunctionRegistry::with_builtins()) - .unwrap(); - assert_eq!(results.len(), 1, "should return one row with 0"); - assert_eq!(results[0][0], Value::Integer(0)); - } - - #[test] - fn test_apply_aggregation_count_empty_with_grouping_var() { - // count with grouping var + zero bindings → empty result - let find_specs = vec![ - FindSpec::Variable("?dept".to_string()), - FindSpec::Aggregate { - func: "count".to_string(), - var: "?e".to_string(), - }, - ]; - let results = - apply_post_processing(vec![], &find_specs, &[], &FunctionRegistry::with_builtins()) - .unwrap(); - assert_eq!(results.len(), 0, "should return empty set"); - } - - #[test] - fn test_apply_aggregation_sum_integers() { - let bindings = vec![ - binding(&[("?v", Value::Integer(10))]), - binding(&[("?v", Value::Integer(20))]), - binding(&[("?v", Value::Integer(30))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "sum".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(60)); - } - - #[test] - fn test_apply_aggregation_sum_widens_to_float() { - let bindings = vec![ - binding(&[("?v", Value::Integer(10))]), - binding(&[("?v", Value::Float(0.5))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "sum".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Float(10.5)); - } - - #[test] - fn test_apply_aggregation_sum_distinct_deduplicates() { - let bindings = vec![ - binding(&[("?v", Value::Integer(5))]), - binding(&[("?v", Value::Integer(5))]), // duplicate - binding(&[("?v", Value::Integer(10))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "sum-distinct".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(15)); // 5 + 10, not 5 + 5 + 10 - } - - #[test] - fn test_apply_aggregation_sum_type_error() { - let bindings = vec![binding(&[("?v", Value::String("bad".to_string()))])]; - let find_specs = vec![FindSpec::Aggregate { - func: "sum".to_string(), - var: "?v".to_string(), - }]; - let result = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ); - assert!(result.is_err(), "sum of string should fail"); - } - - #[test] - fn test_apply_aggregation_min_integers() { - let bindings = vec![ - binding(&[("?v", Value::Integer(30))]), - binding(&[("?v", Value::Integer(10))]), - binding(&[("?v", Value::Integer(20))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "min".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(10)); - } - - #[test] - fn test_apply_aggregation_max_strings() { - let bindings = vec![ - binding(&[("?v", Value::String("apple".to_string()))]), - binding(&[("?v", Value::String("zebra".to_string()))]), - binding(&[("?v", Value::String("mango".to_string()))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "max".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::String("zebra".to_string())); - } - - #[test] - fn test_apply_aggregation_min_type_error_boolean() { - let bindings = vec![binding(&[("?v", Value::Boolean(true))])]; - let find_specs = vec![FindSpec::Aggregate { - func: "min".to_string(), - var: "?v".to_string(), - }]; - let result = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ); - assert!(result.is_err(), "min of boolean should fail"); - } - - #[test] - fn test_apply_aggregation_min_mixed_int_float_error() { - let bindings = vec![ - binding(&[("?v", Value::Integer(1))]), - binding(&[("?v", Value::Float(2.0))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "min".to_string(), - var: "?v".to_string(), - }]; - let result = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ); - assert!(result.is_err(), "min of mixed Integer/Float should fail"); - } - - #[test] - fn test_apply_aggregation_skips_nulls_in_sum() { - let bindings = vec![ - binding(&[("?v", Value::Integer(10))]), - binding(&[("?v", Value::Null)]), - binding(&[("?v", Value::Integer(20))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "sum".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(30)); - } - - #[test] - fn test_apply_aggregation_skips_nulls_in_count() { - let bindings = vec![ - binding(&[("?v", Value::Integer(1))]), - binding(&[("?v", Value::Null)]), - binding(&[("?v", Value::Integer(2))]), - ]; - let find_specs = vec![FindSpec::Aggregate { - func: "count".to_string(), - var: "?v".to_string(), - }]; - let results = apply_post_processing( - bindings, - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results[0][0], Value::Integer(2)); // null not counted - } - - #[test] - fn test_apply_aggregation_sum_empty_bindings() { - let find_specs = vec![FindSpec::Aggregate { - func: "sum".to_string(), - var: "?v".to_string(), - }]; - let results = - apply_post_processing(vec![], &find_specs, &[], &FunctionRegistry::with_builtins()) - .unwrap(); - assert_eq!(results.len(), 0, "sum on empty should return empty set"); - } - - #[test] - fn test_apply_aggregation_with_var_grouping() { - // :with ?e adds ?e to the group key. Two entities with same dept but different ?e - // form separate groups. - let bindings = vec![ - binding(&[ - ("?dept", Value::String("eng".to_string())), - ("?salary", Value::Integer(50)), - ("?e", Value::Integer(1)), - ]), - binding(&[ - ("?dept", Value::String("eng".to_string())), - ("?salary", Value::Integer(50)), - ("?e", Value::Integer(2)), - ]), - ]; - let find_specs = vec![ - FindSpec::Variable("?dept".to_string()), - FindSpec::Aggregate { - func: "sum".to_string(), - var: "?salary".to_string(), - }, - ]; - // Without :with: group key = ("eng",). Both bindings in one group → sum = 100. - let results_no_with = apply_post_processing( - bindings.clone(), - &find_specs, - &[], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results_no_with.len(), 1); - assert_eq!(results_no_with[0][1], Value::Integer(100)); - // With :with ?e: group key = ("eng", e). Two separate groups → two rows, each sum = 50. - let results_with = apply_post_processing( - bindings, - &find_specs, - &["?e".to_string()], - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(results_with.len(), 2); - assert_eq!(results_with[0][1], Value::Integer(50)); - } - - #[test] - fn test_filter_facts_for_query_returns_net_asserted_slice() { - // Setup: one fact asserted then retracted, one fact left standing. - // After filter_facts_for_query, only the standing fact should appear. - // The return type (Arc<[Fact]>) exposes .len() and index access [0]. - use uuid::Uuid; - let storage = FactStorage::new(); - let alice = Uuid::new_v4(); - - // tx 1: assert name - storage - .transact( - vec![( - alice, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - - // tx 2: retract name — net state for name is now gone - storage - .retract(vec![( - alice, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )]) - .unwrap(); + ); - // tx 3: assert age — this is the only net-asserted fact - storage - .transact( - vec![(alice, ":person/age".to_string(), Value::Integer(30))], - None, - ) + let executor = DatalogExecutor::new_with_rules(storage, rules); + let result = executor + .execute(crate::query::datalog::types::DatalogCommand::Query(query)) .unwrap(); - let executor = DatalogExecutor::new(storage); - let query = DatalogQuery { - find: vec![], - where_clauses: vec![], - as_of: None, - valid_at: Some(ValidAt::AnyValidTime), - with_vars: vec![], - max_derived_facts: None, - max_results: None, - }; - - let facts = executor.filter_facts_for_query(&query).unwrap(); - assert_eq!(facts.len(), 1, "expected exactly 1 net-asserted fact"); - assert_eq!(facts[0].attribute, ":person/age"); + match result { + QueryResult::QueryResults { results, .. } => { + // a is excluded (has a blocked dep); b passes + assert_eq!(results.len(), 1, "only b should pass"); + } + _ => panic!("Expected QueryResults"), + } } #[test] - fn test_filter_facts_for_query_valid_time_filter() { - // Setup: one fact with a narrow valid-time window (1000..2000), one open-ended. - // Query with valid_at inside the window → both facts visible. - // Query with valid_at outside the window → only the open-ended fact visible. - // filter_facts_for_query now returns Result> (changed in Task 5). - use crate::graph::types::TransactOptions; - use uuid::Uuid; + fn test_optimizer_does_not_change_query_results() { + // A multi-pattern query that the optimizer would reorder. + // Results must be identical regardless of execution order. let storage = FactStorage::new(); - let alice = Uuid::new_v4(); - - // Fact valid only during [1000, 2000) + let alice = uuid::Uuid::new_v4(); + let bob = uuid::Uuid::new_v4(); storage .transact( - vec![( - alice, - ":employment/status".to_string(), - Value::String("active".to_string()), - )], - Some(TransactOptions::new(Some(1000_i64), Some(2000_i64))), + vec![ + ( + alice, + ":name".to_string(), + Value::String("Alice".to_string()), + ), + (alice, ":friend".to_string(), Value::Ref(bob)), + (bob, ":name".to_string(), Value::String("Bob".to_string())), + ], + None, ) .unwrap(); - // Fact valid forever (open-ended): explicit valid_from=0 so it is visible at t=1500 and t=3000. - // Passing None would set valid_from=tx_id_now() (current epoch ms ≈ 1.7T), which is - // far beyond the test's query timestamps. - storage - .transact( - vec![( - alice, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )], - Some(TransactOptions::new(Some(0_i64), None)), + let executor = DatalogExecutor::new(storage); + // Simple query: find all names (no join reordering needed) + let result = executor + .execute( + parse_datalog_command("(query [:find ?name :where [?e :name ?name]])").unwrap(), ) .unwrap(); - let executor = DatalogExecutor::new(storage); - - // Query inside the window: both facts should be visible - let query_inside = DatalogQuery { - find: vec![], - where_clauses: vec![], - as_of: None, - valid_at: Some(ValidAt::Timestamp(1500_i64)), - with_vars: vec![], - max_derived_facts: None, - max_results: None, - }; - let facts_inside = executor.filter_facts_for_query(&query_inside).unwrap(); - assert_eq!(facts_inside.len(), 2, "both facts visible at t=1500"); - - // Query outside the window: only the open-ended name fact should be visible - let query_outside = DatalogQuery { - find: vec![], - where_clauses: vec![], - as_of: None, - valid_at: Some(ValidAt::Timestamp(3000_i64)), - with_vars: vec![], - max_derived_facts: None, - max_results: None, - }; - let facts_outside = executor.filter_facts_for_query(&query_outside).unwrap(); - assert_eq!( - facts_outside.len(), - 1, - "only open-ended fact visible at t=3000" - ); - assert_eq!(facts_outside[0].attribute, ":person/name"); - } - - #[test] - fn test_selective_fetch_prefers_bound_entity_over_attribute_scan() { - let storage = FactStorage::new(); - let executor = DatalogExecutor::new(storage); - - let mut cmd = String::from(r#"(transact [[:e0 :val 0][:e0 :name "entity0"]"#); - for i in 1..=20 { - cmd.push_str(&format!("[:e{i} :val {i}]")); + match result { + QueryResult::QueryResults { results, .. } => { + assert_eq!(results.len(), 2, "Alice and Bob both have names"); + } + _ => panic!("Expected QueryResults"), } - cmd.push_str("])"); - executor - .execute(parse_datalog_command(&cmd).unwrap()) - .unwrap(); - - let query = match parse_datalog_command("(query [:find ?v :where [:e0 :val ?v]])").unwrap() - { - DatalogCommand::Query(query) => query, - _ => panic!("expected query"), - }; - - let facts = executor.filter_facts_for_query(&query).unwrap(); - assert_eq!( - facts.len(), - 1, - "bound entity + attribute query should fetch only that (entity, attribute) pair (#323)" - ); - - // A variable attribute on the same bound entity still needs the whole entity. - let query = match parse_datalog_command("(query [:find ?a ?v :where [:e0 ?a ?v]])").unwrap() - { - DatalogCommand::Query(query) => query, - _ => panic!("expected query"), - }; - let facts = executor.filter_facts_for_query(&query).unwrap(); - assert_eq!( - facts.len(), - 2, - "bound entity + variable attribute should fetch all of the entity's facts" - ); } + // Helper: build a binding map from key-value pairs + #[test] fn test_per_query_max_derived_facts_overrides_executor_default() { let storage = FactStorage::new(); @@ -4756,104 +2267,6 @@ mod expr_eval_tests { assert!(!is_truthy(&Value::String("hi".to_string()))); } - #[test] - fn test_apply_expr_filter_keeps_truthy() { - // [(< ?v 100)] — keeps row where ?v < 100 - use crate::query::datalog::types::WhereClause; - let expr = Expr::BinOp( - BinOp::Lt, - Box::new(Expr::Var("?v".to_string())), - Box::new(Expr::Lit(Value::Integer(100))), - ); - let clauses = vec![WhereClause::Expr { - expr, - binding: None, - }]; - let bindings = vec![ - b(&[("?v", Value::Integer(50))]), - b(&[("?v", Value::Integer(150))]), - ]; - let result = - apply_expr_clauses(bindings, &clauses, &FunctionRegistry::with_builtins()).unwrap(); - assert_eq!(result.len(), 1); - assert_eq!(result[0].get("?v"), Some(&Value::Integer(50))); - } - - /// `apply_expr` of a literal bound to `?x` over a row binding `?x` to - /// `old`: whether the row is kept, and `?x` afterwards. - fn unify(old: Value, new: Value, replace: bool) -> Option { - let row = apply_expr( - &Expr::Lit(new), - Some("?x"), - b(&[("?x", old)]), - &FunctionRegistry::with_builtins(), - replace, - )?; - row.get("?x").cloned() - } - - #[test] - fn test_apply_expr_unifies_a_bound_variable() { - // #596: equal keeps the row, different drops it. - assert_eq!( - unify(Value::Integer(41), Value::Integer(41), false), - Some(Value::Integer(41)) - ); - assert!(unify(Value::Integer(41), Value::Integer(31), false).is_none()); - assert!(unify(Value::Integer(41), Value::Integer(31), true).is_none()); - // An integer never equals a float; NaN equals nothing. - assert!(unify(Value::Integer(1), Value::Float(1.0), false).is_none()); - assert!(unify(Value::Float(f64::NAN), Value::Float(f64::NAN), false).is_none()); - // IEEE `==`: -0.0 equals 0.0; the old value stays unless `replace`. - assert!(matches!( - unify(Value::Float(-0.0), Value::Float(0.0), false), - Some(Value::Float(f)) if f.is_sign_negative() - )); - assert!(matches!( - unify(Value::Float(-0.0), Value::Float(0.0), true), - Some(Value::Float(f)) if f.is_sign_positive() - )); - } - - #[test] - fn test_apply_expr_unifies_keyword_with_ref() { - let bob = crate::query::datalog::matcher::edn_to_entity_id(&EdnValue::Keyword( - ":bob".to_string(), - )) - .unwrap(); - let kw = || Value::Keyword(":bob".to_string()); - assert!(matches!( - unify(Value::Ref(bob), kw(), false), - Some(Value::Ref(_)) - )); - assert!(matches!( - unify(Value::Ref(bob), kw(), true), - Some(Value::Keyword(_)) - )); - assert!(matches!( - unify(kw(), Value::Ref(bob), false), - Some(Value::Keyword(_)) - )); - assert!(unify(Value::Keyword(":carol".to_string()), Value::Ref(bob), false).is_none()); - } - - #[test] - fn test_apply_expr_failure_drops_row() { - let div = Expr::BinOp( - BinOp::Div, - Box::new(Expr::Lit(Value::Integer(1))), - Box::new(Expr::Lit(Value::Integer(0))), - ); - let row = apply_expr( - &div, - Some("?x"), - b(&[]), - &FunctionRegistry::with_builtins(), - false, - ); - assert!(row.is_none()); - } - #[test] fn test_binders_expression_replaces_only_when_earlier_in_text() { use crate::query::datalog::types::WhereClause; @@ -4882,45 +2295,6 @@ mod expr_eval_tests { assert_eq!(binders.pattern(&pat), vec!["?x".to_string()]); } - #[test] - fn test_apply_expr_binding_extends_row() { - // [(+ ?a ?b) ?sum] — binds ?sum - use crate::query::datalog::types::WhereClause; - let expr = Expr::BinOp( - BinOp::Add, - Box::new(Expr::Var("?a".to_string())), - Box::new(Expr::Var("?b".to_string())), - ); - let clauses = vec![WhereClause::Expr { - expr, - binding: Some("?sum".to_string()), - }]; - let bindings = vec![b(&[("?a", Value::Integer(3)), ("?b", Value::Integer(4))])]; - let result = - apply_expr_clauses(bindings, &clauses, &FunctionRegistry::with_builtins()).unwrap(); - assert_eq!(result.len(), 1); - assert_eq!(result[0].get("?sum"), Some(&Value::Integer(7))); - } - - #[test] - fn test_apply_expr_type_mismatch_drops_row() { - // [(< ?v 100)] where ?v = "hello" — type mismatch silently drops row - use crate::query::datalog::types::WhereClause; - let expr = Expr::BinOp( - BinOp::Lt, - Box::new(Expr::Var("?v".to_string())), - Box::new(Expr::Lit(Value::Integer(100))), - ); - let clauses = vec![WhereClause::Expr { - expr, - binding: None, - }]; - let bindings = vec![b(&[("?v", Value::String("hello".to_string()))])]; - let result = - apply_expr_clauses(bindings, &clauses, &FunctionRegistry::with_builtins()).unwrap(); - assert_eq!(result.len(), 0); - } - #[test] fn test_execute_expr_filter_lt() { use crate::graph::storage::FactStorage; @@ -4959,12 +2333,10 @@ mod expr_eval_tests { } #[test] - fn test_apply_or_clauses_union_from_two_branches() { + fn test_or_union_from_two_branches() { // e1 has :color :red, e2 has :color :blue. // or-only where clause: (or [?e :color :red] [?e :color :blue]) - // Without apply_or_clauses, get_patterns() returns [] → match_patterns returns - // [{}] (one empty binding) → extract_variables finds no ?e binding → 0 results. - // With apply_or_clauses, both entities are returned → 2 results. + // Both entities are returned → 2 results. use uuid::Uuid; let storage = FactStorage::new(); let e1 = Uuid::new_v4(); @@ -4999,11 +2371,10 @@ mod expr_eval_tests { } #[test] - fn test_apply_or_clauses_deduplication() { + fn test_or_deduplication() { // e1 has :color :red AND :shape :circle. // or clause: (or [?e :color :red] [?e :shape :circle]) - // Without apply_or_clauses: or is skipped → 0 results (no non-or patterns). - // With apply_or_clauses: e1 is returned by both branches → deduplicated to 1 result. + // e1 is returned by both branches → deduplicated to 1 result. use uuid::Uuid; let storage = FactStorage::new(); let e1 = Uuid::new_v4(); @@ -5275,8 +2646,8 @@ mod expr_eval_tests { target_os = "wasi", ignore = "poisons the lock from a spawned thread; WASI has no threads" )] - fn execute_query_with_rules_rules_lock_poisoned_error() { - // Covers the magic-sets rewrite's rules.read() in execute_query_with_rules + fn rule_query_rules_lock_poisoned_error() { + // Covers the magic-sets rewrite's rules.read() in a rule query // (distinct call site from execute_rule's rules.write()). let storage = FactStorage::new(); let rules = Arc::new(RwLock::new(RuleRegistry::new())); @@ -5591,163 +2962,20 @@ mod expr_eval_tests { } } - // ── evaluate_branch / apply_or_clauses edge cases ──────────────────────── - - /// The branches of the query's last `or` / `or-join` clause. - fn last_or_branches(q: &str) -> Vec> { - let DatalogCommand::Query(query) = parse_datalog_command(q).expect("parse failed") else { - panic!("expected a query"); - }; - match query.where_clauses.last() { - Some(WhereClause::Or(b)) | Some(WhereClause::OrJoin { branches: b, .. }) => b.clone(), - _ => panic!("expected an or clause last"), - } - } - - #[test] - fn test_branch_outer_reads() { - let b = last_or_branches( - "(query [:find ?v :where [?e :n ?v] (or [(> ?v 1)] (and [?e :n ?v] [(< ?v 0)]))])", - ); - assert!(branch_outer_reads(&b[0]).contains("?v"), "reads outer ?v"); - assert!(branch_outer_reads(&b[1]).is_empty(), "binds ?v itself"); - - // A nested branch's private variable is not an outer read; the - // enclosing branch's variable is bound for the nested one. - let b = last_or_branches( - "(query [:find ?v :where [?e :n ?v] (or (and [?e :n ?v] (or-join [?v] (and [?x :n ?y] [(> ?y ?v)]))) [?e :n 5])])", - ); - assert!(branch_outer_reads(&b[0]).is_empty(), "nested reads bound"); - let b = last_or_branches( - "(query [:find ?v :where [?e :n ?v] (or (or [(> ?v 1)] [(< ?v 0)]) [?e :n 5])])", - ); - assert!( - branch_outer_reads(&b[0]).contains("?v"), - "nested reads outer" - ); - - // An expression output is bound by the branch. - let b = last_or_branches( - "(query [:find ?w :where [?e :n ?v] (or (and [?e :n ?v] [(+ ?v 1) ?w] [(> ?w 1)]) [?e :n ?w])])", - ); - assert!(branch_outer_reads(&b[0]).is_empty(), "?w bound by output"); - } - - #[test] - fn test_evaluate_branch_with_timestamp_valid_at() { - // Exercises executor.rs lines 930-931: evaluate_branch with Timestamp/AnyValidTime - use crate::query::datalog::types::ValidAt; - let storage = FactStorage::new(); - let e1 = Uuid::new_v4(); - storage - .transact( - vec![( - e1, - ":tag".to_string(), - crate::graph::types::Value::Integer(1), - )], - None, - ) - .unwrap(); - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - let rules = crate::query::datalog::rules::RuleRegistry::new(); - let branch = vec![WhereClause::Pattern(Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":tag".to_string()), - EdnValue::Symbol("?v".to_string()), - ))]; - let mut initial = std::collections::HashMap::new(); - initial.insert("?seed".to_string(), crate::graph::types::Value::Integer(0)); - - // Line 930: Some(ValidAt::Timestamp(t)) arm - let ts_result = evaluate_branch( - &branch, - vec![initial.clone()], - facts.clone(), - &rules, - None, - Some(ValidAt::Timestamp(crate::graph::types::tx_id_now() as i64)), - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(ts_result.len(), 1, "timestamp valid_at should match"); - - // Line 931: Some(ValidAt::AnyValidTime) arm - let any_result = evaluate_branch( - &branch, - vec![initial], - facts, - &rules, - None, - Some(ValidAt::AnyValidTime), - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(any_result.len(), 1, "any_valid_time should match"); - } + // ── or branch edge cases ───────────────────────────────────────────────── #[test] - fn test_execute_query_with_rules_valid_at_timestamp() { - // Exercises executor.rs lines 341-342 (valid_at_value in execute_query_with_rules - // for Timestamp and AnyValidTime arms) and lines 348-350 (hard-error guard). + fn rule_query_per_fact_pseudo_attr_needs_any_valid_time() { use crate::query::datalog::parser::parse_datalog_command; - use crate::query::datalog::types::ValidAt; - let storage = FactStorage::new(); - let executor = DatalogExecutor::new(storage); - - // Register a rule so the query routes through execute_query_with_rules - let rule_cmd = parse_datalog_command(r#"(rule [(tagged ?e) [?e :item/tag ?v]])"#) - .expect("rule parse failed"); - executor.execute(rule_cmd).expect("rule register failed"); - - // Transact a fact - executor - .execute( - parse_datalog_command(r#"(transact [[:item1 :item/tag "x"]])"#) - .expect("transact parse failed"), - ) - .expect("transact failed"); - - // Lines 341-342: call execute_query_with_rules directly with Timestamp and AnyValidTime. - // The public execute() routing may bypass it if query_uses_rules returns false; - // calling the private method directly guarantees coverage. - let q_ts = crate::query::datalog::types::DatalogQuery { - find: vec![crate::query::datalog::types::FindSpec::Variable( - "?e".to_string(), - )], - where_clauses: vec![], - as_of: None, - valid_at: Some(ValidAt::Timestamp(946684800000)), // 2000-01-01 - with_vars: vec![], - max_derived_facts: None, - max_results: None, - }; - let r_ts = executor.execute_query_with_rules(q_ts); - assert!( - r_ts.is_ok(), - "execute_query_with_rules with Timestamp must not error" - ); - - let q_any = crate::query::datalog::types::DatalogQuery { - find: vec![crate::query::datalog::types::FindSpec::Variable( - "?e".to_string(), - )], - where_clauses: vec![], - as_of: None, - valid_at: Some(ValidAt::AnyValidTime), - with_vars: vec![], - max_derived_facts: None, - max_results: None, - }; - let r_any = executor.execute_query_with_rules(q_any); - assert!( - r_any.is_ok(), - "execute_query_with_rules with AnyValidTime must not error" - ); - - // Lines 348-350: hard-error guard in execute_query_with_rules - // Per-fact pseudo-attr without :any-valid-time in a rules query + let executor = DatalogExecutor::new(FactStorage::new()); + for cmd in [ + r#"(rule [(tagged ?e) [?e :item/tag ?v]])"#, + r#"(transact [[:item1 :item/tag "x"]])"#, + ] { + executor + .execute(parse_datalog_command(cmd).unwrap()) + .unwrap(); + } let err_cmd = parse_datalog_command( "(query [:find ?e ?vf :where (tagged ?e) [?e ?a _] [?e :db/valid-from ?vf]])", ) @@ -5760,76 +2988,8 @@ mod expr_eval_tests { } #[test] - fn test_evaluate_branch_empty_incoming_returns_empty() { - // evaluate_branch with empty incoming bindings → returns [] immediately (line 842) - let storage = FactStorage::new(); - storage - .transact( - vec![( - Uuid::new_v4(), - ":a".to_string(), - crate::graph::types::Value::Integer(1), - )], - None, - ) - .unwrap(); - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - let rules = crate::query::datalog::rules::RuleRegistry::new(); - let branch = vec![WhereClause::Pattern(Pattern::new( - EdnValue::Symbol("?x".to_string()), - EdnValue::Keyword(":a".to_string()), - EdnValue::Symbol("?v".to_string()), - ))]; - let result = evaluate_branch( - &branch, - vec![], - facts, - &rules, - None, - None, - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!(result.len(), 0, "empty incoming should return empty"); - } - - #[test] - fn test_evaluate_branch_no_match_patterns_empty_bindings_returns_empty() { - // evaluate_branch: patterns exist but match nothing → bindings is empty (line 865) - let storage = FactStorage::new(); - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - let rules = crate::query::datalog::rules::RuleRegistry::new(); - // Branch has a pattern that won't match empty storage - let branch = vec![WhereClause::Pattern(Pattern::new( - EdnValue::Symbol("?x".to_string()), - EdnValue::Keyword(":no-such-attr".to_string()), - EdnValue::Symbol("?v".to_string()), - ))]; - // Seed with one binding so the branch has something to work with - let mut initial = std::collections::HashMap::new(); - initial.insert("?init".to_string(), crate::graph::types::Value::Integer(1)); - let result = evaluate_branch( - &branch, - vec![initial], - facts, - &rules, - None, - None, - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!( - result.len(), - 0, - "no matching facts should return empty bindings" - ); - } - - #[test] - fn test_evaluate_branch_not_filter_excludes_matching() { - // evaluate_branch with Not clause: entities that match the not body are excluded (line 909) + fn test_or_branch_not_excludes_matching() { + // Entities that match the not body are excluded. let storage = FactStorage::new(); let e1 = Uuid::new_v4(); let e2 = Uuid::new_v4(); @@ -5857,7 +3017,6 @@ mod expr_eval_tests { .unwrap(); let executor = DatalogExecutor::new(storage); // Query: find entities with :color but not :flagged - // Uses the not_body_matches path in not-post-filter (line 909) let cmd = parse_datalog_command( "(query [:find ?e :where [?e :color ?c] (not-join [?e] [?e :flagged ?fv])])", ) @@ -5874,7 +3033,6 @@ mod expr_eval_tests { #[test] fn test_or_join_deduplication() { // or-join where both branches bind ?e → duplicate bindings are deduplicated - // (line 991: if !result.contains(&b) { result.push(b); }) let storage = FactStorage::new(); let e1 = Uuid::new_v4(); storage @@ -5981,93 +3139,8 @@ mod expr_eval_tests { } #[test] - fn test_evaluate_branch_empty_patterns_passes_incoming_through() { - // Line 859: patterns.is_empty() = true → bindings = incoming (pass through) - // Achieved when branch contains only Not/Expr clauses, no Pattern/RuleInvocation - let storage = FactStorage::new(); - let e1 = Uuid::new_v4(); - storage - .transact( - vec![( - e1, - ":a".to_string(), - crate::graph::types::Value::Integer(10), - )], - None, - ) - .unwrap(); - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - let rules = crate::query::datalog::rules::RuleRegistry::new(); - - // Branch with only an Expr clause (no patterns) — patterns.is_empty() = true - let branch = vec![WhereClause::Expr { - expr: crate::query::datalog::types::Expr::Lit(crate::graph::types::Value::Boolean( - true, - )), - binding: None, - }]; - // Incoming with one binding - let mut initial = std::collections::HashMap::new(); - initial.insert("?x".to_string(), crate::graph::types::Value::Integer(42)); - let result = evaluate_branch( - &branch, - vec![initial], - facts, - &rules, - None, - None, - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - // The expr is truthy so the binding passes through - assert_eq!( - result.len(), - 1, - "expr-only branch should pass binding through" - ); - } - - #[test] - fn test_evaluate_branch_or_clause_produces_empty_bindings() { - // Line 879: bindings empty after apply_or_clauses → return Ok([]) - // This happens when an Or clause produces no results - let storage = FactStorage::new(); - // Empty storage → no facts - let facts: Arc<[crate::graph::types::Fact]> = - Arc::from(storage.get_asserted_facts().unwrap().as_slice()); - let rules = crate::query::datalog::rules::RuleRegistry::new(); - - // Branch with an Or clause that matches nothing - let or_branch = vec![WhereClause::Pattern(Pattern::new( - EdnValue::Symbol("?x".to_string()), - EdnValue::Keyword(":no-attr".to_string()), - EdnValue::Symbol("?v".to_string()), - ))]; - let branch = vec![WhereClause::Or(vec![or_branch])]; - - let mut initial = std::collections::HashMap::new(); - initial.insert("?seed".to_string(), crate::graph::types::Value::Integer(1)); - let result = evaluate_branch( - &branch, - vec![initial], - facts, - &rules, - None, - None, - &FunctionRegistry::with_builtins(), - ) - .unwrap(); - assert_eq!( - result.len(), - 0, - "or clause with no matches should yield empty" - ); - } - - #[test] - fn test_evaluate_branch_not_join_excludes_matching() { - // Line 914: evaluate_not_join returns true inside evaluate_branch → exclude + fn test_or_branch_not_join_excludes_matching() { + // An entity the not-join body matches is excluded. let storage = FactStorage::new(); let e1 = Uuid::new_v4(); let e2 = Uuid::new_v4(); @@ -6114,7 +3187,7 @@ mod expr_eval_tests { #[test] fn test_not_body_expr_only_filters_binding() { - // Exercises not_body_matches with patterns.is_empty() (Expr-only not body) at line 561 + // An expression-only not body. let storage = FactStorage::new(); let e1 = Uuid::new_v4(); let e2 = Uuid::new_v4(); @@ -6153,66 +3226,6 @@ mod expr_eval_tests { _ => panic!("expected QueryResults"), } } - - #[test] - fn window_sum_resets_per_partition() { - use super::super::functions::FunctionRegistry; - use super::super::types::{Order, WindowFunc, WindowSpec}; - - let mut bindings: Vec> = vec![ - [ - ("dept".into(), Value::String("A".into())), - ("salary".into(), Value::Integer(10)), - ] - .into_iter() - .collect(), - [ - ("dept".into(), Value::String("A".into())), - ("salary".into(), Value::Integer(20)), - ] - .into_iter() - .collect(), - [ - ("dept".into(), Value::String("B".into())), - ("salary".into(), Value::Integer(100)), - ] - .into_iter() - .collect(), - ]; - let find_specs = vec![ - FindSpec::Variable("dept".into()), - FindSpec::Variable("salary".into()), - FindSpec::Window(WindowSpec { - func: WindowFunc::Sum, - var: Some("salary".into()), - partition_by: Some("dept".into()), - order_by: "salary".into(), - order: Order::Asc, - }), - ]; - let registry = FunctionRegistry::with_builtins(); - apply_window_functions(&mut bindings, &find_specs, ®istry).expect("window"); - - // Partition A: 10 → sum=10, 20 → sum=30 - let row_a10 = bindings - .iter() - .find(|b| b.get("salary") == Some(&Value::Integer(10))) - .unwrap(); - assert_eq!(row_a10.get("__win_2"), Some(&Value::Integer(10))); - - let row_a20 = bindings - .iter() - .find(|b| b.get("salary") == Some(&Value::Integer(20))) - .unwrap(); - assert_eq!(row_a20.get("__win_2"), Some(&Value::Integer(30))); - - // Partition B: 100 → sum=100 (accumulator reset, NOT 130) - let row_b100 = bindings - .iter() - .find(|b| b.get("salary") == Some(&Value::Integer(100))) - .unwrap(); - assert_eq!(row_b100.get("__win_2"), Some(&Value::Integer(100))); - } } #[cfg(test)] diff --git a/src/query/datalog/matcher.rs b/src/query/datalog/matcher.rs index fc2c68c8ea..e2d800bd08 100644 --- a/src/query/datalog/matcher.rs +++ b/src/query/datalog/matcher.rs @@ -1,670 +1,7 @@ -#[cfg(any(test, feature = "test-oracle"))] -use super::optimizer::IndexHint; use super::types::EdnValue; -#[cfg(any(test, feature = "test-oracle"))] -use super::types::{AttributeSpec, Pattern, PseudoAttr}; -#[cfg(any(test, feature = "test-oracle"))] -use crate::graph::FactStorage; -#[cfg(any(test, feature = "test-oracle"))] -use crate::graph::types::Fact; use crate::graph::types::{EntityId, Value}; -#[cfg(any(test, feature = "test-oracle"))] -use std::borrow::Cow; -#[cfg(any(test, feature = "test-oracle"))] -use std::collections::HashMap; -#[cfg(any(test, feature = "test-oracle"))] -use std::sync::Arc; use uuid::Uuid; -/// Variable bindings for query execution -/// Maps variable names (e.g., "?name") to their bound values -#[cfg(any(test, feature = "test-oracle"))] -pub type Bindings = HashMap; - -#[cfg(any(test, feature = "test-oracle"))] -enum MatcherStorage { - Owned(FactStorage), - Slice(Arc<[Fact]>), -} - -/// Pattern matcher that finds facts matching a pattern and produces bindings -#[cfg(any(test, feature = "test-oracle"))] -pub struct PatternMatcher { - storage: MatcherStorage, - /// The `:db/valid-at` value for this query context (Value::Null when not set). - pub(crate) valid_at_value: Value, -} - -#[cfg(any(test, feature = "test-oracle"))] -impl PatternMatcher { - #[cfg(any(test, feature = "test-oracle"))] - pub fn new(storage: FactStorage) -> Self { - PatternMatcher { - storage: MatcherStorage::Owned(storage), - valid_at_value: Value::Null, - } - } - - /// Constructs a [`PatternMatcher`] over a pre-built, already-filtered slice of - /// asserted facts. The caller is responsible for ensuring the slice contains - /// only currently asserted facts (equivalent to `FactStorage::get_asserted_facts()` - /// at the snapshot moment). No additional filtering is applied at match time. - #[cfg(test)] - pub(crate) fn from_slice(facts: Arc<[Fact]>) -> Self { - PatternMatcher { - storage: MatcherStorage::Slice(facts), - valid_at_value: Value::Null, - } - } - - /// Constructs a matcher with an explicit `:db/valid-at` binding value. - /// Used by the executor when the query has a known `valid_at` point. - #[cfg(any(test, feature = "test-oracle"))] - pub(crate) fn from_slice_with_valid_at(facts: Arc<[Fact]>, valid_at: Value) -> Self { - PatternMatcher { - storage: MatcherStorage::Slice(facts), - valid_at_value: valid_at, - } - } - - /// Set the value a `:db/valid-at` pattern binds. - #[cfg(any(test, feature = "test-oracle"))] - pub(crate) fn with_valid_at(mut self, valid_at: Value) -> Self { - self.valid_at_value = valid_at; - self - } - - fn get_facts(&self) -> Cow<'_, [Fact]> { - match &self.storage { - MatcherStorage::Owned(s) => Cow::Owned(s.get_asserted_facts().unwrap_or_default()), - MatcherStorage::Slice(s) => Cow::Borrowed(s), - } - } - - /// Match a single pattern against all facts in storage - /// Returns a list of bindings, one for each matching fact - pub fn match_pattern(&self, pattern: &Pattern) -> Vec { - if Self::reads_source(pattern) { - return self - .match_pseudo(pattern, &HashMap::new()) - .into_iter() - .collect(); - } - let mut results = Vec::new(); - - // Get all currently asserted facts - let facts = self.get_facts(); - - for fact in &*facts { - if let Some(bindings) = self.match_fact_against_pattern(fact, pattern) { - results.push(bindings); - } - } - - results - } - - /// Try to match a single fact against a pattern - /// Returns Some(bindings) if successful, None otherwise - fn match_fact_against_pattern(&self, fact: &Fact, pattern: &Pattern) -> Option { - let mut bindings = HashMap::new(); - - // Match entity - if !self.match_component(&pattern.entity, &Value::Ref(fact.entity), &mut bindings) { - return None; - } - - match &pattern.attribute { - AttributeSpec::Real(attr_edn) => { - // Match attribute - if !self.match_component( - attr_edn, - &Value::Keyword(fact.attribute.clone()), - &mut bindings, - ) { - return None; - } - // Match value - if !self.match_component(&pattern.value, &fact.value, &mut bindings) { - return None; - } - // A source of pseudo-attribute patterns binds its hidden - // metadata variables from this fact (#594). - for (attr, var) in &pattern.meta { - bindings.insert(var.clone(), Self::metadata(fact, attr)); - } - } - AttributeSpec::Pseudo(_) => { - // `:db/valid-at`: the query's valid time, with every fact of - // the entity, as `[e _ _]` would. Per-fact pseudo-attributes - // read their source (`match_pseudo`) and never get here. - if !self.match_component(&pattern.value, &self.valid_at_value, &mut bindings) { - return None; - } - } - } - - Some(bindings) - } - - /// The metadata `attr` of `fact`. `:db/valid-at` is not per fact; it - /// never names a hidden variable. A fact a rule derived (tx-count 0, - /// which no stored fact has) has no metadata: `nil` (#548). - fn metadata(fact: &Fact, attr: &PseudoAttr) -> Value { - if fact.tx_count == 0 { - return Value::Null; - } - Value::Integer(match attr { - PseudoAttr::ValidFrom | PseudoAttr::ValidAt => fact.valid_from, - PseudoAttr::ValidTo => fact.valid_to, - PseudoAttr::TxCount => fact.tx_count.cast_signed(), - PseudoAttr::TxId => fact.tx_id.cast_signed(), - }) - } - - /// Whether `pattern` is a per-fact pseudo-attribute pattern, which reads - /// its source's metadata (#594) instead of matching facts. - fn reads_source(pattern: &Pattern) -> bool { - matches!(&pattern.attribute, AttributeSpec::Pseudo(a) if a.is_per_fact()) - } - - /// A per-fact pseudo-attribute pattern over the row `existing`: its value - /// term bound to, or compared with, the metadata its source bound (the - /// hidden variable, or the integer a substitution put in its place). No - /// row when the source did not bind it, which the parser rules out. - fn match_pseudo(&self, pattern: &Pattern, existing: &Bindings) -> Option { - let meta = match pattern.pseudo_source.as_ref()? { - EdnValue::Symbol(v) => existing.get(v)?.clone(), - other => edn_to_value(other).ok()?, - }; - let mut row = existing.clone(); - match &pattern.value { - EdnValue::Symbol(v) if v.starts_with('?') && !v.starts_with("?_") => match row.get(v) { - Some(old) => (Self::normalize_join_value(old) == Self::normalize_join_value(&meta)) - .then_some(row), - None => { - row.insert(v.clone(), meta); - Some(row) - } - }, - other => self.match_component(other, &meta, &mut row).then_some(row), - } - } - - /// Match a pattern component (entity, attribute, or value) against a fact value - /// Returns true if match succeeds, updating bindings for variables - fn match_component( - &self, - pattern_component: &EdnValue, - fact_value: &Value, - bindings: &mut Bindings, - ) -> bool { - match pattern_component { - // Anonymous wildcard `_`: match any value without binding - EdnValue::Symbol(var) if var == "_" => true, - - // Wildcard variable (starts with ?_): match any value without binding - EdnValue::Symbol(var) if var.starts_with("?_") => true, - - // Variable: bind it or check consistency - EdnValue::Symbol(var) if var.starts_with('?') => { - if let Some(existing) = bindings.get(var) { - // Variable already bound, check consistency - existing == fact_value - } else { - // Bind the variable - bindings.insert(var.clone(), fact_value.clone()); - true - } - } - - // Constant: must match exactly - EdnValue::Keyword(k) => { - // Keywords can match either Value::Keyword (for attributes) - // or Value::Ref (for entities - need to convert keyword to UUID) - match fact_value { - Value::Keyword(fk) => k == fk, - Value::Ref(entity_id) => { - // Convert keyword to UUID and compare - if let Ok(expected_id) = edn_to_entity_id(&EdnValue::Keyword(k.clone())) { - expected_id == *entity_id - } else { - false - } - } - _ => false, - } - } - - EdnValue::String(s) => { - if let Value::String(fs) = fact_value { - s == fs - } else { - false - } - } - - EdnValue::Integer(i) => { - if let Value::Integer(fi) = fact_value { - i == fi - } else { - false - } - } - - EdnValue::Float(f) => { - if let Value::Float(ff) = fact_value { - f == ff - } else { - false - } - } - - EdnValue::Boolean(b) => { - if let Value::Boolean(fb) = fact_value { - b == fb - } else { - false - } - } - - EdnValue::Uuid(u) => match fact_value { - Value::Ref(entity_id) => u == entity_id, - // A keyword stored as a value may represent an entity reference. - // Convert it to its canonical UUID and compare — symmetric with - // the EdnValue::Keyword arm above that handles Value::Ref. - Value::Keyword(k) => { - edn_to_entity_id(&EdnValue::Keyword(k.clone())).is_ok_and(|id| u == &id) - } - _ => false, - }, - - EdnValue::Nil => matches!(fact_value, Value::Null), - - // Symbols (non-variables) or other types are not supported in patterns - _ => false, - } - } - - /// Match multiple patterns with variable unification - /// Returns bindings that satisfy all patterns simultaneously - #[cfg(any(test, feature = "test-oracle"))] - pub fn match_patterns(&self, patterns: &[Pattern]) -> Vec { - if patterns.is_empty() { - return vec![HashMap::new()]; - } - - // Start with the first pattern - let Some(first) = patterns.first() else { - return vec![HashMap::new()]; - }; - let mut results = self.match_pattern(first); - - // Join with each subsequent pattern - for pattern in patterns.get(1..).unwrap_or(&[]) { - results = self.join_with_pattern(results, pattern, &[]); - } - - results - } - - /// Match multiple patterns with index hints for optimized lookups. - #[allow(dead_code)] - pub fn match_patterns_with_hints(&self, patterns: &[(Pattern, IndexHint)]) -> Vec { - if patterns.is_empty() { - return vec![HashMap::new()]; - } - - // Start with the first pattern - let Some(first) = patterns.first() else { - return vec![HashMap::new()]; - }; - let mut results = self.match_pattern_with_hint(&first.0, &first.1); - - // Join with each subsequent pattern - for (pattern, _hint) in patterns.get(1..).unwrap_or(&[]) { - results = self.join_with_pattern(results, pattern, &[]); - } - - results - } - - /// Match a single pattern against existing bindings, using an index hint when the - /// bindings are the unit seed (one empty map — i.e., this is the first pattern in - /// an incremental plan loop). - /// - /// - Unit seed (`[{}]`): delegates to `match_pattern_with_hint` for an indexed lookup. - /// - Any other non-empty seed: delegates to `join_with_pattern` (hash-join path). - /// - Empty seed (`[]`): returns empty immediately. - /// - /// Used by the executor and evaluator incremental plan loops introduced in #207. - /// - /// `rebind` names variables the seed binds whose value this pattern - /// replaces with its own (#545): an equal value of another kind, a keyword - /// for a ref or the reverse. - #[cfg(any(test, feature = "test-oracle"))] - pub(crate) fn match_with_hint_seeded( - &self, - seed: Vec, - pattern: &Pattern, - hint: &IndexHint, - rebind: &[String], - ) -> Vec { - if seed.is_empty() { - return vec![]; - } - if seed.len() == 1 && seed.first().map(|s| s.is_empty()).unwrap_or(false) { - // First pattern in the plan — use the index hint for a targeted lookup. - self.match_pattern_with_hint(pattern, hint) - } else { - // Subsequent pattern — join_with_pattern uses hash-join when possible. - self.join_with_pattern(seed, pattern, rebind) - } - } - - /// Match a single pattern. Every pattern scans the matcher's facts; the - /// hint only orders patterns in the optimizer. - fn match_pattern_with_hint(&self, pattern: &Pattern, _hint: &IndexHint) -> Vec { - self.match_pattern(pattern) - } - - /// Match multiple patterns starting from existing seed bindings. - /// - /// For each seed binding, extends it by matching all patterns in sequence. - /// Returns all extended bindings that satisfy every pattern. - /// If `seed` is empty, returns empty. If `patterns` is empty, returns `seed` unchanged. - #[cfg(any(test, feature = "test-oracle"))] - pub(crate) fn match_patterns_seeded( - &self, - patterns: &[Pattern], - seed: Vec, - ) -> Vec { - if seed.is_empty() { - return vec![]; - } - if patterns.is_empty() { - return seed; - } - - let mut results = seed; - for pattern in patterns { - results = self.join_with_pattern(results, pattern, &[]); - } - results - } - - /// Join existing bindings with a new pattern. - /// - /// Uses a hash-join when the pattern shares a variable with existing bindings - /// (the common `?e`-join shape). Falls back to the nested-loop scan when no - /// shared join variable is found (unrelated patterns, fully-literal patterns, - /// or pseudo-attribute patterns which have their own fast path in - /// `match_pattern_with_bindings`). - fn join_with_pattern( - &self, - existing_bindings: Vec, - pattern: &Pattern, - rebind: &[String], - ) -> Vec { - if existing_bindings.is_empty() { - return vec![]; - } - - // Detect the join variable: the first variable in entity, then value position - // of the new pattern that also appears as a bound key in the existing bindings. - // We skip pseudo-attributes (they have a dedicated fast path in - // match_pattern_with_bindings) and fully-literal patterns (nested loop is - // already O(1) per binding for those). - let is_pseudo = matches!(&pattern.attribute, AttributeSpec::Pseudo(_)); - - let join_var: Option = if is_pseudo { - None - } else { - // Check entity position first. - let entity_var = match &pattern.entity { - EdnValue::Symbol(s) if s.starts_with('?') => { - // It's a variable. Is it bound in existing bindings? - if existing_bindings.first().is_some_and(|b| b.contains_key(s)) { - Some(s.clone()) - } else { - None - } - } - _ => None, - }; - if entity_var.is_some() { - entity_var - } else { - // Check value position. - match &pattern.value { - EdnValue::Symbol(s) if s.starts_with('?') => { - if existing_bindings.first().is_some_and(|b| b.contains_key(s)) { - Some(s.clone()) - } else { - None - } - } - _ => None, - } - } - }; - - let Some(jvar) = join_var else { - // No join variable detected: fall back to nested-loop scan. - let mut results = Vec::new(); - for existing in existing_bindings { - let new_matches = self.match_pattern_with_bindings(pattern, &existing, rebind); - results.extend(new_matches); - } - return results; - }; - - // Hash-join path: - // 1. Scan all candidate facts for this pattern from an empty binding (no outer context). - // This gives us every binding the pattern can produce, keyed by the join variable. - let candidate_bindings = self.match_pattern(pattern); - - // 2. Build HashMap: join_var_value → Vec - // Normalize keyword values to Ref (UUID) so keyword entity references - // (e.g., Value::Keyword(":d-bad") stored as a value) can match the UUID - // that match_fact_against_pattern produces when the same entity appears - // in entity position (stored as Value::Ref). This mirrors the cross-type - // matching done by match_component's EdnValue::Keyword arm. - let mut build_side: HashMap> = HashMap::new(); - for b in candidate_bindings { - if let Some(val) = b.get(&jvar) { - let key = Self::normalize_join_value(val); - build_side.entry(key).or_default().push(b); - } - } - - // 3. Probe: for each existing binding, look up join_var value. - let mut results = Vec::new(); - for existing in existing_bindings { - let Some(probe_val) = existing.get(&jvar) else { - // Outer binding doesn't have the join var yet — fall back to scan for this row. - let new_matches = self.match_pattern_with_bindings(pattern, &existing, rebind); - results.extend(new_matches); - continue; - }; - let probe_key = Self::normalize_join_value(probe_val); - if let Some(matches) = build_side.get(&probe_key) { - for candidate in matches { - // Merge and consistency-check. - let mut merged = existing.clone(); - let mut consistent = true; - for (var, val) in candidate { - if let Some(merged_val) = merged.get(var) { - // Compare using normalized values so that keyword entity - // references (e.g., Keyword(":d-bad") stored as a value in - // one fact) are treated as equal to the UUID Ref produced - // when the same entity appears in entity position. - if Self::normalize_join_value(merged_val) - != Self::normalize_join_value(val) - { - consistent = false; - break; - } - if rebind.contains(var) { - merged.insert(var.clone(), val.clone()); - } - } else { - merged.insert(var.clone(), val.clone()); - } - } - if consistent { - results.push(merged); - } - } - } - // No match in build side → this outer binding is dropped (inner join semantics). - } - results - } - - /// Normalize a binding value for use as a hash-join key. - /// - /// Converts `Value::Keyword(k)` → `Value::Ref(uuid)` so that entity references - /// bound via keyword (value position) and via entity ID (entity position) hash - /// to the same key. Used only for key comparison — does NOT affect what is - /// stored in merged output bindings (the original `val` is always inserted into - /// the result binding, never the normalized form). - pub(crate) fn normalize_join_value(val: &Value) -> Value { - if let Value::Keyword(k) = val - && let Ok(uuid) = edn_to_entity_id(&EdnValue::Keyword(k.clone())) - { - return Value::Ref(uuid); - } - val.clone() - } - - /// Match a pattern given existing variable bindings - /// Returns new bindings that extend the existing ones - fn match_pattern_with_bindings( - &self, - pattern: &Pattern, - existing: &Bindings, - rebind: &[String], - ) -> Vec { - if Self::reads_source(pattern) { - return self.match_pseudo(pattern, existing).into_iter().collect(); - } - - // Default: scan all facts - self.match_pattern_with_bindings_scan(pattern, existing, rebind) - } - - /// Default join implementation: iterate all facts and try to match. - fn match_pattern_with_bindings_scan( - &self, - pattern: &Pattern, - existing: &Bindings, - rebind: &[String], - ) -> Vec { - let mut results = Vec::new(); - - let facts = self.get_facts(); - - for fact in &*facts { - // Try to match with existing bindings - let mut new_bindings = existing.clone(); - - // Apply existing bindings to pattern before matching - let resolved_pattern = self.apply_bindings_to_pattern(pattern, existing); - - if let Some(additional_bindings) = - self.match_fact_against_pattern(fact, &resolved_pattern) - { - // Check that additional bindings are consistent with existing. - let mut consistent = true; - for (var, val) in &additional_bindings { - if matches!(existing.get(var), Some(existing_val) if existing_val != val) { - consistent = false; - break; - } - } - - if consistent { - new_bindings.extend(additional_bindings); - // A substituted variable matched as a constant; take the - // fact's value at its first position instead. - for var in rebind { - if let Some(v) = Self::fact_value_of(pattern, fact, var) { - new_bindings.insert(var.clone(), v); - } - } - results.push(new_bindings); - } - } - } - - results - } - - /// The value `fact` gives the variable `var` at its first position in - /// `pattern` (entity, attribute, value). - fn fact_value_of(pattern: &Pattern, fact: &Fact, var: &str) -> Option { - let is_var = |c: &EdnValue| matches!(c, EdnValue::Symbol(s) if s == var); - if is_var(&pattern.entity) { - return Some(Value::Ref(fact.entity)); - } - if let AttributeSpec::Real(a) = &pattern.attribute - && is_var(a) - { - return Some(Value::Keyword(fact.attribute.clone())); - } - is_var(&pattern.value).then(|| fact.value.clone()) - } - - /// Apply existing bindings to a pattern, replacing bound variables with their values - fn apply_bindings_to_pattern(&self, pattern: &Pattern, bindings: &Bindings) -> Pattern { - let attribute = match &pattern.attribute { - AttributeSpec::Real(edn) => { - AttributeSpec::Real(self.apply_binding_to_component(edn, bindings)) - } - AttributeSpec::Pseudo(p) => AttributeSpec::Pseudo(p.clone()), - }; - Pattern { - entity: self.apply_binding_to_component(&pattern.entity, bindings), - attribute, - value: self.apply_binding_to_component(&pattern.value, bindings), - pseudo_source: pattern - .pseudo_source - .as_ref() - .map(|v| self.apply_binding_to_component(v, bindings)), - ..pattern.clone() - } - } - - /// Apply bindings to a single pattern component - fn apply_binding_to_component(&self, component: &EdnValue, bindings: &Bindings) -> EdnValue { - match component { - EdnValue::Symbol(var) if var.starts_with('?') => { - if let Some(value) = bindings.get(var) { - // Convert Value to EdnValue - self.value_to_edn(value) - } else { - component.clone() - } - } - _ => component.clone(), - } - } - - /// Convert a Value to EdnValue for pattern matching - fn value_to_edn(&self, value: &Value) -> EdnValue { - match value { - Value::String(s) => EdnValue::String(s.clone()), - Value::Integer(i) => EdnValue::Integer(*i), - Value::Float(f) => EdnValue::Float(*f), - Value::Boolean(b) => EdnValue::Boolean(*b), - Value::Ref(entity_id) => EdnValue::Uuid(*entity_id), - Value::Keyword(k) => EdnValue::Keyword(k.clone()), - Value::Null => EdnValue::Nil, - } - } -} - /// Convert EdnValue to Value for storage pub fn edn_to_value(edn: &EdnValue) -> Result { match edn { @@ -711,155 +48,6 @@ pub fn edn_to_entity_id(edn: &EdnValue) -> Result { mod tests { use super::*; - #[test] - fn test_from_slice_with_valid_at_field() { - use crate::graph::types::Value; - use std::sync::Arc; - let facts: Arc<[_]> = Arc::from(vec![]); - let m = PatternMatcher::from_slice_with_valid_at(facts, Value::Integer(12345)); - assert_eq!(m.valid_at_value, Value::Integer(12345)); - } - - #[test] - fn test_match_simple_pattern() { - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - - // Add some facts - storage - .transact( - vec![ - ( - alice_id, - ":person/name".to_string(), - Value::String("Alice".to_string()), - ), - (alice_id, ":person/age".to_string(), Value::Integer(30)), - ], - None, - ) - .unwrap(); - - let matcher = PatternMatcher::new(storage); - - // Pattern: [?e :person/name "Alice"] - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/name".to_string()), - EdnValue::String("Alice".to_string()), - ); - - let results = matcher.match_pattern(&pattern); - assert_eq!(results.len(), 1); - assert_eq!(results[0].get("?e"), Some(&Value::Ref(alice_id))); - } - - #[test] - fn test_match_pattern_with_variable_value() { - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - - storage - .transact( - vec![( - alice_id, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - - let matcher = PatternMatcher::new(storage); - - // Pattern: [?e :person/name ?name] - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/name".to_string()), - EdnValue::Symbol("?name".to_string()), - ); - - let results = matcher.match_pattern(&pattern); - assert_eq!(results.len(), 1); - assert_eq!( - results[0].get("?name"), - Some(&Value::String("Alice".to_string())) - ); - } - - #[test] - fn test_match_multiple_patterns() { - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - - storage - .transact( - vec![ - ( - alice_id, - ":person/name".to_string(), - Value::String("Alice".to_string()), - ), - (alice_id, ":person/age".to_string(), Value::Integer(30)), - ], - None, - ) - .unwrap(); - - let matcher = PatternMatcher::new(storage); - - // Patterns: [?e :person/name ?name] [?e :person/age ?age] - let patterns = vec![ - Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/name".to_string()), - EdnValue::Symbol("?name".to_string()), - ), - Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/age".to_string()), - EdnValue::Symbol("?age".to_string()), - ), - ]; - - let results = matcher.match_patterns(&patterns); - assert_eq!(results.len(), 1); - assert_eq!( - results[0].get("?name"), - Some(&Value::String("Alice".to_string())) - ); - assert_eq!(results[0].get("?age"), Some(&Value::Integer(30))); - } - - #[test] - fn test_match_patterns_no_match() { - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - - storage - .transact( - vec![( - alice_id, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - - let matcher = PatternMatcher::new(storage); - - // Pattern asks for Bob, but we only have Alice - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/name".to_string()), - EdnValue::String("Bob".to_string()), - ); - - let results = matcher.match_pattern(&pattern); - assert_eq!(results.len(), 0); - } - #[test] fn test_edn_to_value() { assert_eq!( @@ -890,530 +78,6 @@ mod tests { let result2 = edn_to_entity_id(&EdnValue::Keyword(":alice".to_string())).unwrap(); assert_eq!(result1, result2); // Same keyword = same UUID } - - #[test] - fn test_match_patterns_seeded_with_existing_bindings() { - use uuid::Uuid; - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - let bob_id = Uuid::new_v4(); - - storage - .transact( - vec![ - (alice_id, ":person/age".to_string(), Value::Integer(30)), - (bob_id, ":person/age".to_string(), Value::Integer(25)), - ], - None, - ) - .unwrap(); - - let matcher = PatternMatcher::new(storage); - - // Seed: ?e is already bound to alice_id - let seed = vec![{ - let mut m = HashMap::new(); - m.insert("?e".to_string(), Value::Ref(alice_id)); - m - }]; - - // Pattern: [?e :person/age ?age] - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/age".to_string()), - EdnValue::Symbol("?age".to_string()), - ); - - let results = matcher.match_patterns_seeded(&[pattern], seed); - // Should find age=30 for alice only (bob is not in seed) - assert_eq!(results.len(), 1); - assert_eq!(results[0].get("?age"), Some(&Value::Integer(30))); - } - - #[test] - fn test_match_patterns_seeded_empty_seed_returns_empty() { - use uuid::Uuid; - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - storage - .transact(vec![(alice_id, ":a".to_string(), Value::Integer(1))], None) - .unwrap(); - let matcher = PatternMatcher::new(storage); - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":a".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - let results = matcher.match_patterns_seeded(&[pattern], vec![]); - assert!(results.is_empty()); - } - - #[test] - fn test_match_patterns_seeded_empty_patterns_returns_seed() { - let storage = FactStorage::new(); - let matcher = PatternMatcher::new(storage); - let seed = vec![{ - let mut m = HashMap::new(); - m.insert("?x".to_string(), Value::Integer(42)); - m - }]; - let results = matcher.match_patterns_seeded(&[], seed.clone()); - assert_eq!(results.len(), 1); - assert_eq!(results[0].get("?x"), Some(&Value::Integer(42))); - } - - #[test] - fn test_from_slice_matches_same_as_owned() { - let storage = FactStorage::new(); - let alice = Uuid::new_v4(); - storage - .transact( - vec![( - alice, - ":person/name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - - // Build owned matcher the existing way - let owned_matcher = PatternMatcher::new(storage.clone()); - - // Build slice matcher via from_slice - let facts: Arc<[Fact]> = Arc::from(storage.get_asserted_facts().unwrap()); - let slice_matcher = PatternMatcher::from_slice(facts); - - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":person/name".to_string()), - EdnValue::Symbol("?name".to_string()), - ); - - let owned_results = owned_matcher.match_pattern(&pattern); - let slice_results = slice_matcher.match_pattern(&pattern); - - assert_eq!( - owned_results.len(), - slice_results.len(), - "result count mismatch" - ); - assert_eq!( - owned_results[0].get("?name"), - slice_results[0].get("?name"), - "bound value mismatch" - ); - } - - #[test] - fn test_from_slice_empty() { - let empty: Arc<[Fact]> = Arc::from(vec![]); - let matcher = PatternMatcher::from_slice(empty); - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":any".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - let results = matcher.match_pattern(&pattern); - assert!(results.is_empty(), "empty slice should produce no results"); - } - - #[test] - fn test_from_slice_respects_caller_prefiltering() { - // The Slice arm applies no internal filtering — the caller is responsible. - // This test verifies that if the caller correctly excludes retracted facts - // before building the slice, the matcher respects that. - let storage = FactStorage::new(); - let alice = Uuid::new_v4(); - storage - .transact( - vec![( - alice, - ":name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - storage - .retract(vec![( - alice, - ":name".to_string(), - Value::String("Alice".to_string()), - )]) - .unwrap(); - - // net_asserted_facts() returns the true net state: for each (entity, attribute, value) - // triple, the most recent record wins; retractions exclude the triple entirely. - let asserted: Arc<[Fact]> = Arc::from(crate::graph::storage::net_asserted_facts( - storage.get_all_facts().unwrap(), - )); - let matcher = PatternMatcher::from_slice(asserted); - - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":name".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - let results = matcher.match_pattern(&pattern); - assert!( - results.is_empty(), - "retracted fact should not appear in slice-based matcher" - ); - } - - #[test] - fn test_from_slice_no_internal_filtering() { - // from_slice does NO filtering — the caller must pre-filter. - // If the caller passes a raw slice that includes a retracted fact, - // the matcher will return it. This is intentional by design. - let storage = FactStorage::new(); - let alice = Uuid::new_v4(); - storage - .transact( - vec![( - alice, - ":name".to_string(), - Value::String("Alice".to_string()), - )], - None, - ) - .unwrap(); - storage - .retract(vec![( - alice, - ":name".to_string(), - Value::String("Alice".to_string()), - )]) - .unwrap(); - - // Deliberately build a raw, unfiltered slice (all facts, including the retraction) - // This simulates a caller mistake — passing unfiltered facts to from_slice. - let all_facts: Arc<[Fact]> = Arc::from(storage.get_all_facts().unwrap()); - let matcher = PatternMatcher::from_slice(all_facts); - - let pattern = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":name".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - let results = matcher.match_pattern(&pattern); - - // The matcher returns ALL facts in the slice — both the assert and retract records. - // Caller must pre-filter; from_slice does not filter internally. - assert!( - !results.is_empty(), - "from_slice does not filter internally — raw slice passes through unchanged" - ); - } - - #[test] - fn test_pseudo_attr_valid_from_join() { - // Simulates the time_interval_entire_interval test pattern: - // [?e :item/label _] [?e :db/valid-from ?vf] - use crate::graph::storage::net_asserted_facts; - use crate::graph::types::{Fact, Value}; - use crate::query::datalog::types::{AttributeSpec, PseudoAttr}; - use uuid::Uuid; - - let storage = crate::graph::FactStorage::new(); - let e1 = Uuid::new_v4(); - - // Transact e1 with explicit valid-from = 1577836800000 - let opt = - crate::graph::types::TransactOptions::new(Some(1577836800000), Some(1735689600000)); - storage - .transact_batch( - vec![( - e1, - ":item/label".to_string(), - Value::String("A".to_string()), - None, - )], - Some(opt), - ) - .unwrap(); - - // Get all facts - let all_facts: Arc<[Fact]> = - Arc::from(net_asserted_facts(storage.get_all_facts().unwrap())); - let matcher = PatternMatcher::from_slice(all_facts.clone()); - - // First pattern: [?e :item/label _], the source of the second (#594). - let p1 = Pattern { - entity: EdnValue::Symbol("?e".to_string()), - attribute: AttributeSpec::Real(EdnValue::Keyword(":item/label".to_string())), - value: EdnValue::Symbol("_".to_string()), - valid_from: None, - valid_to: None, - meta: vec![(PseudoAttr::ValidFrom, "?#0.valid-from".to_string())], - pseudo_source: None, - }; - let r1 = matcher.match_pattern(&p1); - assert_eq!(r1.len(), 1, "first pattern should bind ?e"); - - // Second pattern: [?e :db/valid-from ?vf] - let p2 = Pattern { - entity: EdnValue::Symbol("?e".to_string()), - attribute: AttributeSpec::Pseudo(PseudoAttr::ValidFrom), - value: EdnValue::Symbol("?vf".to_string()), - valid_from: None, - valid_to: None, - meta: Vec::new(), - pseudo_source: Some(EdnValue::Symbol("?#0.valid-from".to_string())), - }; - let r2 = matcher.match_patterns_seeded(&[p2], r1); - assert_eq!(r2.len(), 1, "second pattern should bind ?vf"); - assert_eq!(r2[0].get("?vf"), Some(&Value::Integer(1577836800000))); - } - - #[test] - fn test_pseudo_attr_valid_to_tx_count_tx_id_read_their_source() { - // A source binds one hidden variable per pseudo-attribute that reads - // it; each pseudo-attribute pattern reads its own (#594). - use crate::graph::storage::net_asserted_facts; - use crate::graph::types::Value as GValue; - use std::sync::Arc; - - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - storage - .transact( - vec![( - alice_id, - ":item/label".to_string(), - GValue::String("z".to_string()), - )], - None, - ) - .unwrap(); - - let all_facts: Arc<[Fact]> = - Arc::from(net_asserted_facts(storage.get_all_facts().unwrap())); - let fact = all_facts[0].clone(); - let matcher = PatternMatcher::from_slice(all_facts); - - let source = Pattern { - entity: EdnValue::Uuid(alice_id), - attribute: AttributeSpec::Real(EdnValue::Keyword(":item/label".to_string())), - value: EdnValue::Symbol("_".to_string()), - valid_from: None, - valid_to: None, - meta: vec![ - (PseudoAttr::ValidTo, "?#0.valid-to".to_string()), - (PseudoAttr::TxCount, "?#0.tx-count".to_string()), - (PseudoAttr::TxId, "?#0.tx-id".to_string()), - ], - pseudo_source: None, - }; - let reader = |attr: PseudoAttr, var: &str, hidden: &str| Pattern { - entity: EdnValue::Uuid(alice_id), - attribute: AttributeSpec::Pseudo(attr), - value: EdnValue::Symbol(var.to_string()), - valid_from: None, - valid_to: None, - meta: Vec::new(), - pseudo_source: Some(EdnValue::Symbol(hidden.to_string())), - }; - let rows = matcher.match_patterns_seeded( - &[ - source, - reader(PseudoAttr::ValidTo, "?vt", "?#0.valid-to"), - reader(PseudoAttr::TxCount, "?tc", "?#0.tx-count"), - reader(PseudoAttr::TxId, "?ti", "?#0.tx-id"), - ], - vec![HashMap::new()], - ); - assert_eq!(rows.len(), 1, "one row, from the source's one fact"); - assert_eq!(rows[0].get("?vt"), Some(&GValue::Integer(fact.valid_to))); - assert_eq!( - rows[0].get("?tc"), - Some(&GValue::Integer(fact.tx_count.cast_signed())) - ); - assert_eq!( - rows[0].get("?ti"), - Some(&GValue::Integer(fact.tx_id.cast_signed())) - ); - } - - #[test] - fn test_pseudo_attr_without_source_matches_nothing() { - // A per-fact pseudo-attribute pattern never scans facts: with no - // source (the parser refuses that, PRS-081), or a source variable the - // row does not bind, it gives no row (#594). A substituted source - // (an integer) is compared directly. - use crate::graph::storage::net_asserted_facts; - use crate::graph::types::Value as GValue; - use std::sync::Arc; - - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - storage - .transact( - vec![( - alice_id, - ":item/label".to_string(), - GValue::String("x".to_string()), - )], - None, - ) - .unwrap(); - - let all_facts: Arc<[Fact]> = - Arc::from(net_asserted_facts(storage.get_all_facts().unwrap())); - let matcher = PatternMatcher::from_slice(all_facts); - - let pattern = |source: Option, value: EdnValue| Pattern { - entity: EdnValue::Uuid(alice_id), - attribute: AttributeSpec::Pseudo(PseudoAttr::ValidFrom), - value, - valid_from: None, - valid_to: None, - meta: Vec::new(), - pseudo_source: source, - }; - let vf = || EdnValue::Symbol("?vf".to_string()); - assert!(matcher.match_pattern(&pattern(None, vf())).is_empty()); - let unbound = pattern(Some(EdnValue::Symbol("?#0.valid-from".to_string())), vf()); - assert!(matcher.match_pattern(&unbound).is_empty()); - let substituted = pattern(Some(EdnValue::Integer(7)), vf()); - let rows = matcher.match_pattern(&substituted); - assert_eq!(rows.len(), 1); - assert_eq!(rows[0].get("?vf"), Some(&GValue::Integer(7))); - let other = pattern(Some(EdnValue::Integer(7)), EdnValue::Integer(8)); - assert!(matcher.match_pattern(&other).is_empty()); - } - - #[test] - fn test_pseudo_attr_hidden_var_value_mismatch_returns_empty() { - // Exercises matcher.rs line 323: `return vec![]` when the stored hidden-key - // value doesn't match the pattern value component. - use crate::graph::storage::net_asserted_facts; - use crate::graph::types::Value as GValue; - use std::sync::Arc; - - let storage = FactStorage::new(); - let alice_id = Uuid::new_v4(); - storage - .transact( - vec![( - alice_id, - ":item/label".to_string(), - GValue::String("y".to_string()), - )], - None, - ) - .unwrap(); - - let all_facts: Arc<[Fact]> = - Arc::from(net_asserted_facts(storage.get_all_facts().unwrap())); - let matcher = PatternMatcher::from_slice(all_facts.clone()); - - // Seed bindings with the source, which binds the hidden variable. - let p1 = Pattern { - entity: EdnValue::Symbol("?e".to_string()), - attribute: AttributeSpec::Real(EdnValue::Keyword(":item/label".to_string())), - value: EdnValue::Symbol("_".to_string()), - valid_from: None, - valid_to: None, - meta: vec![(PseudoAttr::ValidFrom, "?#0.valid-from".to_string())], - pseudo_source: None, - }; - let seeded = matcher.match_pattern(&p1); - assert_eq!(seeded.len(), 1, "seed should match one fact"); - - // Ask for :db/valid-from with an impossible constant value (-999) - // The hidden variable is bound but -999 won't match it → vec![] - let p2 = Pattern { - entity: EdnValue::Symbol("?e".to_string()), - attribute: AttributeSpec::Pseudo(PseudoAttr::ValidFrom), - value: EdnValue::Integer(-999), - valid_from: None, - valid_to: None, - meta: Vec::new(), - pseudo_source: Some(EdnValue::Symbol("?#0.valid-from".to_string())), - }; - let results = matcher.match_patterns_seeded(&[p2], seeded); - assert_eq!( - results.len(), - 0, - "mismatched constant should return no bindings" - ); - } - - #[test] - fn test_match_with_hint_seeded_unit_seed_delegates_to_hint_path() { - use crate::query::datalog::optimizer::IndexHint; - use std::sync::Arc; - let storage = FactStorage::new(); - let entity = uuid::Uuid::new_v4(); - storage - .transact(vec![(entity, ":val".to_string(), Value::Integer(1))], None) - .unwrap(); - let facts: Arc<[Fact]> = Arc::from(storage.get_asserted_facts().unwrap()); - let matcher = PatternMatcher::from_slice(facts); - let p = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":val".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - let unit_seed = vec![HashMap::new()]; - let results = matcher.match_with_hint_seeded(unit_seed, &p, &IndexHint::Aevt, &[]); - assert_eq!( - results.len(), - 1, - "unit seed must produce one result per matching fact" - ); - assert!(results[0].contains_key("?v"), "binding must contain ?v"); - } - - #[test] - fn test_match_with_hint_seeded_real_bindings_uses_join() { - use crate::query::datalog::optimizer::IndexHint; - use std::sync::Arc; - let storage = FactStorage::new(); - let e = uuid::Uuid::new_v4(); - storage - .transact(vec![(e, ":val".to_string(), Value::Integer(42))], None) - .unwrap(); - let facts: Arc<[Fact]> = Arc::from(storage.get_asserted_facts().unwrap()); - let matcher = PatternMatcher::from_slice(facts); - let p = Pattern::new( - EdnValue::Uuid(e), - EdnValue::Keyword(":val".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - // Non-unit seed — simulates a second-pattern call with existing bindings - let seed = vec![{ - let mut m = HashMap::new(); - m.insert("?other".to_string(), Value::Integer(99)); - m - }]; - let results = matcher.match_with_hint_seeded(seed, &p, &IndexHint::Eavt, &[]); - assert_eq!( - results.len(), - 1, - "join path must unify with existing binding" - ); - assert_eq!(results[0].get("?v"), Some(&Value::Integer(42))); - } - - #[test] - fn test_match_with_hint_seeded_empty_seed_returns_empty() { - use crate::query::datalog::optimizer::IndexHint; - use std::sync::Arc; - let storage = FactStorage::new(); - let facts: Arc<[Fact]> = Arc::from(storage.get_asserted_facts().unwrap()); - let matcher = PatternMatcher::from_slice(facts); - let p = Pattern::new( - EdnValue::Symbol("?e".to_string()), - EdnValue::Keyword(":val".to_string()), - EdnValue::Symbol("?v".to_string()), - ); - // Completely empty seed (no rows at all) - let results = matcher.match_with_hint_seeded(vec![], &p, &IndexHint::Aevt, &[]); - assert!(results.is_empty(), "empty seed must produce empty results"); - } } #[cfg(test)] diff --git a/src/query/datalog/optimizer.rs b/src/query/datalog/optimizer.rs index f223fd5ba6..ba5d81acf9 100644 --- a/src/query/datalog/optimizer.rs +++ b/src/query/datalog/optimizer.rs @@ -1,6 +1,7 @@ //! Query optimizer: index selection and join ordering for Datalog patterns. //! -//! `plan()` is the single entry point. It assigns an `IndexHint` to each +//! `plan_seeded` and `plan_after` order the engine's clause lists (`plan`, +//! for tests, has nothing seeded). Each assigns an `IndexHint` to each //! pattern and sorts patterns by selectivity, on every build. //! //! [`reorder`] says whether this build reorders: patterns, `not`/`not-join` @@ -10,7 +11,7 @@ use crate::query::datalog::types::{AttributeSpec, EdnValue, Expr, Pattern, WhereClause}; -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] thread_local! { /// Whether queries on this thread reorder; tests only. static REORDER: std::cell::Cell = const { std::cell::Cell::new(true) }; @@ -21,7 +22,7 @@ thread_local! { /// longer turns it off: no answer depends on the plan (#594, #596). #[inline] pub(crate) fn reorder() -> bool { - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(any(test, feature = "test-hooks"))] if !REORDER.with(std::cell::Cell::get) { return false; } @@ -30,17 +31,17 @@ pub(crate) fn reorder() -> bool { /// Turns reordering on or off for queries on this thread until the guard /// drops, which restores the previous setting. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] pub(crate) fn set_reorder(on: bool) -> ReorderGuard { ReorderGuard(REORDER.with(|r| r.replace(on))) } /// Restores the previous [`set_reorder`] setting on drop. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] #[must_use = "reordering is restored when the guard drops"] pub struct ReorderGuard(bool); -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] impl Drop for ReorderGuard { fn drop(&mut self) { REORDER.with(|r| r.set(self.0)); @@ -51,7 +52,7 @@ impl Drop for ReorderGuard { /// choice, or one form forced by a test. #[derive(Clone, Copy, Debug, PartialEq, Eq)] #[cfg_attr( - not(any(test, feature = "test-oracle")), + not(any(test, feature = "test-hooks")), allow(dead_code, reason = "only tests force a form") )] pub enum Subplans { @@ -63,7 +64,7 @@ pub enum Subplans { Correlated, } -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] thread_local! { /// How bodies on this thread run; tests only. static SUBPLANS: std::cell::Cell = const { std::cell::Cell::new(Subplans::Choose) }; @@ -74,25 +75,25 @@ thread_local! { /// the same rows. #[inline] pub(crate) fn subplans() -> Subplans { - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(any(test, feature = "test-hooks"))] return SUBPLANS.with(std::cell::Cell::get); - #[cfg(not(any(test, feature = "test-oracle")))] + #[cfg(not(any(test, feature = "test-hooks")))] Subplans::Choose } /// Forces how bodies run on this thread until the guard drops, which /// restores the previous setting. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] pub(crate) fn set_subplans(mode: Subplans) -> SubplansGuard { SubplansGuard(SUBPLANS.with(|s| s.replace(mode))) } /// Restores the previous [`set_subplans`] setting on drop. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] #[must_use = "the setting is restored when the guard drops"] pub struct SubplansGuard(Subplans); -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] impl Drop for SubplansGuard { fn drop(&mut self) { SUBPLANS.with(|s| s.set(self.0)); @@ -253,14 +254,14 @@ pub(crate) fn clause_ref_vars(clauses: &[WhereClause]) -> std::collections::Hash /// by selectivity. /// /// `Pattern`, `Expr`, `Not`, and `NotJoin` variants may be passed in. `Or`, `OrJoin`, -/// and top-level `RuleInvocation` are handled by the executor and must not appear here. +/// and top-level `RuleInvocation` are planned around this list and must not appear here. /// /// A `Not`/`NotJoin` clause whose required variables (all body variables for `Not`; /// `join_vars` for `NotJoin`) are never fully bound by any prefix of the planned /// patterns is returned in the second element (`deferred`) rather than being placed — /// it depends on a binding source outside this clause list (e.g. an `Or`/`OrJoin` -/// clause, which the executor applies after this plan) and must be evaluated by the -/// executor's post-filter instead, to avoid running it before its dependency is bound. +/// clause, which runs after this plan) and runs after that instead, to avoid running +/// it before its dependency is bound. /// /// An `Expr` reading a variable that no pattern in the list and no `Expr` placed /// before it binds is deferred the same way (#625), ahead of the deferred @@ -269,7 +270,7 @@ pub(crate) fn clause_ref_vars(clauses: &[WhereClause]) -> std::collections::Hash /// /// Returns `(interleaved, deferred)` where `interleaved` pairs each Pattern with /// `Some(hint)` and each Expr/Not/NotJoin with `None`. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(test)] pub fn plan( clauses: Vec, ) -> (Vec<(WhereClause, Option)>, Vec) { diff --git a/src/query/datalog/parser/statement.rs b/src/query/datalog/parser/statement.rs index b3763e888d..29db80007a 100644 --- a/src/query/datalog/parser/statement.rs +++ b/src/query/datalog/parser/statement.rs @@ -29,7 +29,7 @@ pub(crate) const DEFAULT_TX_CHUNK_FACTS: usize = 65_536; /// memory and writes as one WAL entry. pub(crate) const MAX_TX_CHUNK_FACTS: usize = 1_000_000; -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] thread_local! { static CHUNK_FACTS: std::cell::Cell> = const { std::cell::Cell::new(None) }; /// Facts in [`Chunk`]s alive on this thread, and the most there have been. @@ -38,17 +38,17 @@ thread_local! { /// Set this thread's chunk size (`None`: the database's), so tests reach /// pass 2 and the large path with small statements. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] pub(crate) fn set_tx_chunk_facts(n: Option) -> TxChunkGuard { TxChunkGuard(CHUNK_FACTS.with(|c| c.replace(n))) } /// Restores the previous [`set_tx_chunk_facts`] setting on drop. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] #[must_use = "the chunk size is restored when the guard drops"] pub struct TxChunkGuard(Option); -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] impl Drop for TxChunkGuard { fn drop(&mut self) { CHUNK_FACTS.with(|c| c.set(self.0)); @@ -57,7 +57,7 @@ impl Drop for TxChunkGuard { /// The most facts [`Chunk`]s held at once on this thread since the last call /// (#550 spec §8.1 acceptance), then start counting again from those held now. -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] pub(crate) fn take_held_high_water() -> usize { HELD.with(|h| { let (now, high) = h.get(); @@ -69,7 +69,7 @@ pub(crate) fn take_held_high_water() -> usize { /// The chunk size for a database configured with `configured`: this /// thread's test setting if any, kept between 1 and [`MAX_TX_CHUNK_FACTS`]. pub(crate) fn tx_chunk_facts(configured: usize) -> usize { - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(any(test, feature = "test-hooks"))] if let Some(n) = CHUNK_FACTS.with(std::cell::Cell::get) { return n.clamp(1, MAX_TX_CHUNK_FACTS); } @@ -77,13 +77,13 @@ pub(crate) fn tx_chunk_facts(configured: usize) -> usize { } /// At most one chunk of a statement's materialised facts. With `test` or -/// `test-oracle`, the facts alive in chunks are counted for the acceptance +/// `test-hooks`, the facts alive in chunks are counted for the acceptance /// test's high-water mark. pub(crate) struct Chunk(Vec); impl Chunk { fn new(facts: Vec) -> Self { - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(any(test, feature = "test-hooks"))] HELD.with(|h| { let (now, high) = h.get(); let now = now.saturating_add(facts.len()); @@ -95,7 +95,7 @@ impl Chunk { /// The facts, no longer counted. pub(crate) fn into_vec(mut self) -> Vec { let facts = std::mem::take(&mut self.0); - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(any(test, feature = "test-hooks"))] HELD.with(|h| { let (now, high) = h.get(); h.set((now.saturating_sub(facts.len()), high)); @@ -104,7 +104,7 @@ impl Chunk { } } -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(any(test, feature = "test-hooks"))] impl Drop for Chunk { fn drop(&mut self) { let n = self.0.len(); diff --git a/src/query/datalog/stratification.rs b/src/query/datalog/stratification.rs index e192cc93c2..40b720fc96 100644 --- a/src/query/datalog/stratification.rs +++ b/src/query/datalog/stratification.rs @@ -39,8 +39,8 @@ fn collect_clause_deps(clause: &WhereClause, entry: &mut Vec<(String, bool)>) { } /// Whether a rule body holds a `not`, `not-join`, `or` or `or-join`. -/// `StratifiedEvaluator` runs such a rule once per stratum, after the -/// positive-only rules, so a rule that calls one must sit above it (#628). +/// Such a rule runs after its stratum's positive-only rules, so a rule +/// that calls one must sit above it (#628). pub(crate) fn has_mixed_clause(body: &[WhereClause]) -> bool { body.iter().any(|c| { matches!( diff --git a/src/query/datalog/types.rs b/src/query/datalog/types.rs index 6dc92de011..531f002ca1 100644 --- a/src/query/datalog/types.rs +++ b/src/query/datalog/types.rs @@ -260,17 +260,6 @@ impl FindSpec { }, } } - - /// The logic variable this spec draws values from. - /// For rank/row-number (no var), returns a synthetic placeholder. - #[cfg(any(test, feature = "test-oracle"))] - pub fn var(&self) -> &str { - match self { - FindSpec::Variable(v) => v.as_str(), - FindSpec::Aggregate { var, .. } => var.as_str(), - FindSpec::Window(ws) => ws.var.as_deref().unwrap_or("__window_var"), - } - } } /// Built-in pseudo-attributes — reserved `:db/*` keywords that bind fact metadata @@ -647,23 +636,6 @@ impl DatalogQuery { Self::collect_rule_invocations_recursive(&self.where_clauses) } - /// Get only top-level rule invocations — those NOT nested inside a Not body. - /// - /// Used by execute_query_with_rules to build positive patterns from rule heads; - /// rule invocations inside `not` are handled by the not-post-filter, not here. - #[cfg(any(test, feature = "test-oracle"))] - pub fn get_top_level_rule_invocations(&self) -> Vec<(String, Vec)> { - self.where_clauses - .iter() - .filter_map(|c| match c { - WhereClause::RuleInvocation { predicate, args } => { - Some((predicate.clone(), args.clone())) - } - _ => None, - }) - .collect() - } - /// Check if this query uses any rules (including inside Not bodies at any depth) pub fn uses_rules(&self) -> bool { self.where_clauses @@ -1083,48 +1055,18 @@ mod tests { } #[test] - fn test_get_top_level_rule_invocations_excludes_not_join_body() { - // not-join body rule invocations are NOT top-level - let query = DatalogQuery::new( - vec![FindSpec::Variable("?e".to_string())], - vec![ - WhereClause::RuleInvocation { - predicate: "reachable".to_string(), - args: vec![ - EdnValue::Symbol("?e".to_string()), - EdnValue::Symbol("?x".to_string()), - ], - }, - WhereClause::NotJoin { - join_vars: vec!["?e".to_string()], - clauses: vec![WhereClause::RuleInvocation { - predicate: "blocked".to_string(), - args: vec![EdnValue::Symbol("?e".to_string())], - }], - }, - ], - ); - let top_level = query.get_top_level_rule_invocations(); - // Only "reachable" is top-level; "blocked" is inside not-join - assert_eq!(top_level.len(), 1); - assert_eq!(top_level[0].0, "reachable"); - } - - #[test] - fn test_find_spec_variable_display_and_var() { + fn test_find_spec_variable_display() { let spec = FindSpec::Variable("?name".to_string()); assert_eq!(spec.display_name(), "?name"); - assert_eq!(spec.var(), "?name"); } #[test] - fn test_find_spec_aggregate_display_and_var() { + fn test_find_spec_aggregate_display() { let spec = FindSpec::Aggregate { func: "count-distinct".to_string(), var: "?e".to_string(), }; assert_eq!(spec.display_name(), "(count-distinct ?e)"); - assert_eq!(spec.var(), "?e"); } #[test] @@ -1192,7 +1134,7 @@ mod tests { } #[test] - fn test_find_spec_window_display_and_var() { + fn test_find_spec_window_display() { let ws_with_var = WindowSpec { func: WindowFunc::Sum, var: Some("?salary".to_string()), @@ -1202,7 +1144,6 @@ mod tests { }; let spec = FindSpec::Window(ws_with_var); assert_eq!(spec.display_name(), "(sum ?salary :over ...)"); - assert_eq!(spec.var(), "?salary"); let ws_no_var = WindowSpec { func: WindowFunc::Rank, @@ -1213,7 +1154,6 @@ mod tests { }; let spec2 = FindSpec::Window(ws_no_var); assert_eq!(spec2.display_name(), "(rank :over ...)"); - assert_eq!(spec2.var(), "__window_var"); } #[test] diff --git a/src/query/engine/meter.rs b/src/query/engine/meter.rs index 7261416aa6..f224cf8de7 100644 --- a/src/query/engine/meter.rs +++ b/src/query/engine/meter.rs @@ -148,8 +148,7 @@ impl Drop for Held { #[cfg(test)] thread_local! { - /// Makes every [`Held::reserve`] of this op fail while set (spec §6.2); - /// a query runs on the engine twice under the oracle. + /// Makes every [`Held::reserve`] of this op fail while set (spec §6.2). pub(crate) static FAIL_RESERVE: std::cell::Cell> = const { std::cell::Cell::new(None) }; } diff --git a/src/query/engine/mod.rs b/src/query/engine/mod.rs index 442342b91e..a87968d382 100644 --- a/src/query/engine/mod.rs +++ b/src/query/engine/mod.rs @@ -1,9 +1,7 @@ //! Streaming query engine (#473): operators that pass batches of id cells //! over one [`Snapshot`]. //! -//! Every query runs here (#551). Under `cfg(test)` and the `test-oracle` -//! feature, every query is also run by the executor's query path, which is -//! built for that only, and the answers are compared ([`oracle`]). +//! Every query runs here (#551). mod aggregate; mod anti; @@ -14,8 +12,6 @@ mod filter; mod ids; mod join; mod meter; -#[cfg(any(test, feature = "test-oracle"))] -pub(crate) mod oracle; mod plan; mod project; mod recursive; diff --git a/src/query/engine/oracle.rs b/src/query/engine/oracle.rs deleted file mode 100644 index 0c04dbeab2..0000000000 --- a/src/query/engine/oracle.rs +++ /dev/null @@ -1,83 +0,0 @@ -//! The existing executor as an oracle for the engine (#473 spec §9). - -use crate::error::{CodedError, ErrorCode}; -use crate::query::datalog::executor::QueryResult; -use crate::storage::index::encode_value; -use anyhow::Result; -use std::cell::Cell; - -thread_local! { - /// Whether [`check`] is skipped on this thread ([`exempt`]). - static EXEMPT: Cell = const { Cell::new(false) }; -} - -/// Skip [`check`] on this thread until the guard drops: only for the answers -/// the engine changes on purpose, whose tests check both answers (#551 spec -/// §4, plan decision 10). -#[cfg(test)] -pub(crate) fn exempt() -> Exempt { - EXEMPT.with(|e| e.set(true)); - Exempt(()) -} - -#[cfg(test)] -pub(crate) struct Exempt(()); - -#[cfg(test)] -impl Drop for Exempt { - fn drop(&mut self) { - EXEMPT.with(|e| e.set(false)); - } -} - -/// Panic unless `engine` and `oracle` give the same answer: both errors, or -/// the same columns and the same rows as a bag. An engine `QRY-012` agrees -/// with any answer, as the executor does not count memory (#549). Messages -/// hold counts and column names only, never values. -/// -/// Built only for tests (`cfg(test)`, the `test-oracle` feature), where a -/// panic is how a disagreement fails the test. -#[allow(clippy::panic)] -pub(crate) fn check(engine: &Result, oracle: &Result) { - if EXEMPT.with(Cell::get) { - return; - } - match (engine, oracle) { - (Err(_), Err(_)) => {} - (Err(e), Ok(_)) - if e.downcast_ref::().map(CodedError::code) == Some(ErrorCode::Qry012) => {} - ( - Ok(QueryResult::QueryResults { - vars: v1, - results: r1, - }), - Ok(QueryResult::QueryResults { - vars: v2, - results: r2, - }), - ) => { - assert!( - v1 == v2, - "engine and oracle columns differ: {v1:?} vs {v2:?}" - ); - assert!( - bag(r1) == bag(r2), - "engine and oracle rows differ for {v1:?}: {} vs {} rows", - r1.len(), - r2.len() - ); - } - (Ok(_), Err(_)) => panic!("engine answered where the oracle failed"), - (Err(_), Ok(_)) => panic!("engine failed where the oracle answered"), - (Ok(_), Ok(_)) => panic!("engine or oracle gave a non-query result"), - } -} - -fn bag(rows: &[Vec]) -> Vec>> { - let mut bag: Vec>> = rows - .iter() - .map(|r| r.iter().map(encode_value).collect()) - .collect(); - bag.sort(); - bag -} diff --git a/src/query/engine/plan.rs b/src/query/engine/plan.rs index 35fc0b6ce5..f8c0aa3020 100644 --- a/src/query/engine/plan.rs +++ b/src/query/engine/plan.rs @@ -58,8 +58,8 @@ pub(crate) enum Term { Never, } -/// A constant in the value position, with the executor's matching rules -/// (`PatternMatcher::match_component`). +/// A constant in the value position, with the matching rules the executor +/// had. #[derive(Debug, Clone)] pub(crate) enum ValueConst { /// A string, integer, boolean or `nil`: equal values only. @@ -598,8 +598,8 @@ pub(crate) fn plan_rules( ) -> Result { let (as_of, valid) = temporal(query)?; let strata = DependencyGraph::from_rules(registry).stratify()?; - // Every predicate the query invokes, and those their rules invoke, as - // `StratifiedEvaluator::evaluate` collects them. + // Every predicate the query invokes, and those their rules invoke, in + // the order the executor collected them. let mut preds: Vec = Vec::new(); for (p, _) in query.get_rule_invocations() { if !preds.contains(&p) { diff --git a/src/query/engine/tests.rs b/src/query/engine/tests.rs index ad230a0a0a..c222c42ef0 100644 --- a/src/query/engine/tests.rs +++ b/src/query/engine/tests.rs @@ -1,13 +1,16 @@ -//! Targeted shapes for the engine. Every query here also runs on the -//! executor, and the answers must agree (`oracle::check`), so these tests -//! check the engine against the executor over histories chosen to reach each -//! index choice, net-assert across committed and pending records, `:as-of`, +//! Targeted shapes for the engine. Until #551 every query here also ran on +//! the executor and the answers had to agree; each answer is now compared +//! with the one recorded then (`tests/answers/`), over histories chosen to +//! reach each index choice, net-assert across committed and pending records, `:as-of`, //! valid time, long strings, and cross-kind values. use super::RUNS; use crate::QueryResult; use crate::db::Minigraf; +#[path = "../../../tests/answers/mod.rs"] +mod answers; + fn runs() -> usize { RUNS.with(std::cell::Cell::get) } @@ -19,6 +22,7 @@ fn rows(db: &Minigraf, query: &str) -> usize { panic!("expected query results"); }; assert_eq!(runs(), before + 1, "query ran on the engine"); + answers::check("engine_tests", query, &results); results.len() } @@ -465,7 +469,7 @@ fn written(dir: &std::path::Path, name: &str, tx_ids: [u64; 6]) -> std::path::Pa /// `tx_id`s rise and on one whose `tx_id`s fall and rise (a `LogWriter` /// copy), at timestamps before, between, at and after its transactions, /// with committed, pending and staged facts, in plain and rule queries, -/// point and attribute scans. The oracle checks every answer. +/// point and attribute scans, each against its frozen answer. #[test] fn as_of_timestamps_run_on_the_engine() { let dir = tempfile::tempdir().unwrap(); @@ -534,8 +538,11 @@ fn as_of_timestamps_run_on_the_engine() { for t in [stamps[3], (base + 3500) as i64] { let q = format!("(query {})", q.replace("{t}", &iso(t))); let before = runs(); - tx.execute(&q).unwrap(); + let QueryResult::QueryResults { results, .. } = tx.execute(&q).unwrap() else { + panic!("expected query results"); + }; assert_eq!(runs(), before + 1, "staged reads run on the engine"); + answers::check("engine_tests", &q, &results); } } tx.rollback(); @@ -605,8 +612,8 @@ fn engine_filter_runs_registered_predicates() { } /// Cross-kind constants over committed and pending facts, `:as-of`, -/// retractions and reopen (from #518's branch): each answer agrees with the -/// executor (the oracle), and the expected entities are found. +/// retractions and reopen (from #518's branch): each answer matches its +/// frozen one, and the expected entities are found. #[test] fn cross_kind_constants_read_their_avet_ranges() { let dir = tempfile::tempdir().unwrap(); @@ -652,6 +659,11 @@ fn cross_kind_constants_read_their_avet_ranges() { panic!("expected query results"); }; assert_eq!(runs(), before + 1, "query ran on the engine"); + answers::check( + "engine_tests", + &format!("(query [:find ?e :where [?e :rel {c}]])"), + &results, + ); let mut es: Vec = results .iter() .map(|r| match r.first() { @@ -1043,7 +1055,7 @@ fn negation_queries(tx: u64) -> Vec { } /// Every negation shape with each body form forced and reordering on and -/// off; the oracle compares each run with the executor. +/// off, each against its frozen answer. fn check_negations(db: &Minigraf) -> usize { use crate::query::datalog::optimizer::{Subplans, set_reorder, set_subplans}; let tx = db.current_tx_count(); @@ -1543,7 +1555,7 @@ fn disjunction_queries(tx: u64) -> Vec { } /// Every disjunction shape with each branch form forced and reordering on -/// and off; the oracle compares each run with the executor. +/// and off, each against its frozen answer. fn check_disjunctions(db: &Minigraf) -> usize { use crate::query::datalog::optimizer::{Subplans, set_reorder, set_subplans}; let tx = db.current_tx_count(); @@ -2250,7 +2262,7 @@ fn memory_db(dir: &std::path::Path, n: usize, limit: usize) -> Minigraf { /// One shape per operator that holds state, the operator that holds it /// first, and the entities its database needs: more than one batch of -/// answer rows, few enough that the executor oracle's cross joins stay fast. +/// answer rows, few enough to stay fast. const MEMORY_SHAPES: [(&str, usize, &str); 5] = [ ( "HashJoin", @@ -2601,8 +2613,7 @@ fn proc_status_kb(field: &str) -> usize { /// The meter's peak against the peak RSS the query adds, for both /// acceptance shapes (#549 spec §3.2: the estimate is meant to be within a -/// factor of two). Opens the engine directly, without the executor oracle, -/// which would run out of memory on the cartesian shape. Prints only; run +/// factor of two). Opens the engine directly. Prints only; run /// alone, as the high-water mark is per process: /// /// ```text diff --git a/src/storage/dict.rs b/src/storage/dict.rs index a6415650f8..a4c385f2c3 100644 --- a/src/storage/dict.rs +++ b/src/storage/dict.rs @@ -94,13 +94,13 @@ impl<'a> DictReader<'a> { } /// Record a known `eid → uuid` pair (the caller looked the eid up by it). - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub fn seed_entity(&mut self, eid: u64, uuid: Uuid) { self.uuids.insert(eid, uuid); } /// Record a known `iid → ident` pair. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub fn seed_ident(&mut self, iid: u32, ident: &str) { self.names.insert(iid, ident.to_string()); } diff --git a/src/storage/mod.rs b/src/storage/mod.rs index 012993a7d9..1f3c8b4f16 100644 --- a/src/storage/mod.rs +++ b/src/storage/mod.rs @@ -369,23 +369,23 @@ impl Default for LegacyHeaderV7 { /// order. pub trait CommittedReader: Send + Sync { /// Every committed fact (an EAVT scan). - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn all_facts(&self) -> Result>; /// Every committed fact of `entity`. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_entity( &self, entity: &crate::graph::types::EntityId, ) -> Result>; /// Every committed fact of `(entity, attribute)`. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_entity_attribute( &self, entity: &crate::graph::types::EntityId, attribute: &str, ) -> Result>; /// Every committed fact with `attribute` (an AEVT scan). - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_attribute(&self, attribute: &str) -> Result>; /// The committed facts of `scan` that survive net-assert among the @@ -398,7 +398,7 @@ pub trait CommittedReader: Send + Sync { /// newer than each committed one and a record can only be hidden by a newer /// one. This default reads the history and filters it; `OnDiskReader` /// decides on index keys and translates only the survivors. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn live_facts( &self, scan: Scan<'_>, @@ -448,7 +448,7 @@ pub enum TxBound { impl TxBound { /// The bound of a counter `:as-of`, or of none. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] pub fn of(as_of: Option) -> Self { match as_of { Some(n) => TxBound::Upto(n), diff --git a/src/storage/persistent_facts.rs b/src/storage/persistent_facts.rs index 158d06620b..3207dc4244 100644 --- a/src/storage/persistent_facts.rs +++ b/src/storage/persistent_facts.rs @@ -1398,6 +1398,37 @@ mod tests { ); } + /// A committed live read of an entity or attribute the DICT does not + /// hold reads nothing. + #[test] + fn live_facts_of_unknown_ids_are_empty() { + use crate::storage::Scan; + let mut pfs = PersistentFactStorage::new(MemoryBackend::new(), 256).unwrap(); + pfs.storage() + .transact( + vec![(entity(1), ":name".to_string(), Value::Integer(1))], + None, + ) + .unwrap(); + pfs.mark_dirty(); + pfs.save().unwrap(); + let snap = pfs.storage().snapshot().unwrap(); + let reader = snap.committed.as_ref().expect("a committed generation"); + let (known, unknown) = (entity(1), entity(2)); + for scan in [ + Scan::Entity(&unknown), + Scan::EntityAttribute(&unknown, ":name"), + Scan::EntityAttribute(&known, ":age"), + Scan::Attribute(":age"), + ] { + assert!(reader.live_facts(scan, None).unwrap().is_empty()); + } + assert_eq!( + reader.live_facts(Scan::Entity(&known), None).unwrap().len(), + 1 + ); + } + #[test] fn save_and_reopen_preserve_facts_tx_id_and_tx_count() { let mut pfs = PersistentFactStorage::new(MemoryBackend::new(), 256).unwrap(); diff --git a/src/storage/reader.rs b/src/storage/reader.rs index 1cfded2639..c882767979 100644 --- a/src/storage/reader.rs +++ b/src/storage/reader.rs @@ -5,9 +5,9 @@ use crate::error::{ErrorCode, bail_coded}; use crate::graph::types::{EntityId, Fact}; -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(test)] use crate::storage::Scan; -#[cfg(any(test, feature = "test-oracle"))] +#[cfg(test)] use crate::storage::btree::prefix_scan; use crate::storage::btree::{LeafCursor, MutexStorageBackend}; use crate::storage::cache::PageCache; @@ -58,7 +58,7 @@ impl OnDiskReader { } /// Facts of every `index` entry starting with `prefix`. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn scan( &self, index: Index, @@ -108,7 +108,7 @@ impl OnDiskReader { /// Facts of `index` entries starting with `prefix` that survive net-assert /// at `as_of`, decided on the key bytes (#379, spec §5.3). Only kept /// entries are decoded and translated through the dictionary. - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn live_scan( &self, index: Index, @@ -461,7 +461,7 @@ impl CommittedReader for OnDiskReader { Some(self) } - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn live_facts(&self, scan: Scan<'_>, as_of: Option) -> Result> { let mut dict = self.dict(); let (index, root, prefix) = match scan { @@ -496,7 +496,7 @@ impl CommittedReader for OnDiskReader { self.live_scan(index, root, &prefix, as_of, &mut dict) } - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn all_facts(&self) -> Result> { if self.eavt_root == 0 { return Ok(Vec::new()); @@ -510,7 +510,7 @@ impl CommittedReader for OnDiskReader { Ok(facts) } - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_entity(&self, entity: &EntityId) -> Result> { let mut dict = self.dict(); let Some(e) = dict.eid_of(entity)? else { @@ -525,7 +525,7 @@ impl CommittedReader for OnDiskReader { ) } - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_entity_attribute(&self, entity: &EntityId, attribute: &str) -> Result> { let mut dict = self.dict(); let (Some(e), Some(a)) = (dict.eid_of(entity)?, dict.iid_of(attribute)?) else { @@ -537,7 +537,7 @@ impl CommittedReader for OnDiskReader { self.scan(Index::Eavt, self.eavt_root, &prefix, &mut dict) } - #[cfg(any(test, feature = "test-oracle"))] + #[cfg(test)] fn facts_for_attribute(&self, attribute: &str) -> Result> { let mut dict = self.dict(); let Some(a) = dict.iid_of(attribute)? else { diff --git a/tests/aggregate_window_rules_test.rs b/tests/aggregate_window_rules_test.rs index a60d067546..8b3642a9fc 100644 --- a/tests/aggregate_window_rules_test.rs +++ b/tests/aggregate_window_rules_test.rs @@ -1,8 +1,7 @@ //! Aggregate and window answers that do not depend on the plan (#547, spec //! `docs/superpowers/specs/2026-10-20-aggregate-window-engine-design.md` §3.4). //! `plan_independence_test.rs` runs the same shapes with reordering on and -//! off; these check the values themselves, without the `test-oracle` -//! feature. +//! off; these check the values themselves. use minigraf::{Minigraf, QueryResult, Value}; diff --git a/tests/aggregation_test.rs b/tests/aggregation_test.rs index d24e641cc6..d144a15940 100644 --- a/tests/aggregation_test.rs +++ b/tests/aggregation_test.rs @@ -165,6 +165,17 @@ fn sum_skips_nulls() { assert_eq!(results(&r)[0][0], Value::Integer(30)); } +#[test] +fn count_and_sum_skip_nil() { + let db = db(); + db.execute(r#"(transact [[:a :score 10] [:b :score nil] [:c :score 20]])"#) + .unwrap(); + let r = db + .execute(r#"(query [:find (count ?s) (sum ?s) :where [?e :score ?s]])"#) + .unwrap(); + assert_eq!(results(&r)[0], vec![Value::Integer(2), Value::Integer(30)]); +} + #[test] fn sum_type_error() { let db = db(); diff --git a/tests/answers/engine_tests.txt b/tests/answers/engine_tests.txt new file mode 100644 index 0000000000..194163fffc --- /dev/null +++ b/tests/answers/engine_tests.txt @@ -0,0 +1,5089 @@ +aggregates_match_executor 00587da71693e33a 1 2b0a3d192b555aa4 +aggregates_match_executor 01cc0df5e0bfa19f 1 40cdffbd08713d33 +aggregates_match_executor 04219a777b6b3539 1 77bce1c4a205d359 +aggregates_match_executor 043c16c49caa72b8 1 ab28de896e793031 +aggregates_match_executor 043c16c49caa72b8 1 fe0211fa40fa5ac8 +aggregates_match_executor 0598aa134ca2b742 1 2b0a39192b5553d8 +aggregates_match_executor 079c2d2f6b04d548 1 2b0a3f192b555e0a +aggregates_match_executor 07c85f7de14ba404 1 7233f7d29a04d673 +aggregates_match_executor 07f792b9be657c63 1 2b0a3d192b555aa4 +aggregates_match_executor 0b881ef375ab0849 1 77bce1c4a205d359 +aggregates_match_executor 0bc5bd36a9d9c96b 1 cb9fa5b645e76115 +aggregates_match_executor 0bf517b69bbbd4c9 1 77bce1c4a205d359 +aggregates_match_executor 0d75579b6231a7ad 1 58172f0e50ecdfc4 +aggregates_match_executor 0e78f65ddfb445b5 0 cbf29ce484222325 +aggregates_match_executor 104cae27fc6f6077 0 cbf29ce484222325 +aggregates_match_executor 10bd2b89c2776167 1 2b0a3d192b555aa4 +aggregates_match_executor 124e1a421a3f6bc2 1 2b0a3b192b55573e +aggregates_match_executor 159734cbf1104ecc 1 2b0a3d192b555aa4 +aggregates_match_executor 164ed79e3c061c8d 1 2b0a3b192b55573e +aggregates_match_executor 18a2844d388c9a01 6 03a241c665772d7c +aggregates_match_executor 18a2844d388c9a01 6 47a9df68fa53fe79 +aggregates_match_executor 1998e4c597be2c7c 6 16da1375f2a94a82 +aggregates_match_executor 1a9e5897cca4cfeb 2 4663dbfa49bd63aa +aggregates_match_executor 1d07f74fdc270930 1 77bce1c4a205d359 +aggregates_match_executor 1db8c6a4d18e6a13 3 2c7716abe2393cc0 +aggregates_match_executor 1e03051d4fe61d89 1 a8e4819cd807c070 +aggregates_match_executor 2113f31f715f3520 0 cbf29ce484222325 +aggregates_match_executor 22173a7b77875f8e 1 827c2cda1cb91f08 +aggregates_match_executor 22ff10eecbbddec5 0 cbf29ce484222325 +aggregates_match_executor 26d19bd5fecabea8 2 8fcacd50857ca666 +aggregates_match_executor 26d19bd5fecabea8 2 9685edabc9350fc0 +aggregates_match_executor 276e44bdb718c2e7 2 bc08af863eb486ea +aggregates_match_executor 2bce04a3d49cc3d5 1 58172f0e50ecdfc4 +aggregates_match_executor 2be602072c8157de 0 cbf29ce484222325 +aggregates_match_executor 2e0fa32a5d60536b 1 af53aa949df6e2f4 +aggregates_match_executor 2eaecb9d22b1702d 2 f0ac92b3405bc818 +aggregates_match_executor 309b659e66863eeb 1 b1eca9457d3bd2f9 +aggregates_match_executor 31080ac8fc2c5cf1 1 5177c452741d281a +aggregates_match_executor 31080ac8fc2c5cf1 1 e193323a35ea6fc7 +aggregates_match_executor 35d60d5efbd15294 0 cbf29ce484222325 +aggregates_match_executor 378f6f2430519a2e 0 cbf29ce484222325 +aggregates_match_executor 3b51642dc28c25a6 3 16183bcaab84d6df +aggregates_match_executor 3b51642dc28c25a6 3 d0af7bd148f6eac4 +aggregates_match_executor 3c90b0d544252c41 5 f74e4a6ac6857a8a +aggregates_match_executor 3cc99b51ffd3fdce 1 e21830886a8c9fa7 +aggregates_match_executor 3d310cd9242d2b5f 3 b323c9d0b121d226 +aggregates_match_executor 3fe9d7fdd6a252f2 0 cbf29ce484222325 +aggregates_match_executor 404673a65880c83e 1 2b0a3b192b55573e +aggregates_match_executor 40bb4404d07fbbe2 0 cbf29ce484222325 +aggregates_match_executor 418273227472523b 0 cbf29ce484222325 +aggregates_match_executor 42ede4960955b3f5 5 c757047d1e914f1f +aggregates_match_executor 490d3a01bab2cee7 6 5c1534a990bd7b92 +aggregates_match_executor 490d3a01bab2cee7 6 7997a66fb5f2c1b9 +aggregates_match_executor 4997d440139b18ea 6 73ea8ec063297758 +aggregates_match_executor 4b01c3a0788d5b9e 6 c2a1cc100be36614 +aggregates_match_executor 4dee8b456e1c7ccf 2 e8c95d5a654b4a22 +aggregates_match_executor 4f0cd5e830f73ae5 1 43f7f95af691d48f +aggregates_match_executor 4f1439550e10eb8b 1 2b0a39192b5553d8 +aggregates_match_executor 50a1893081f99853 1 2b0a3d192b555aa4 +aggregates_match_executor 529d070add55bb52 0 cbf29ce484222325 +aggregates_match_executor 5468f23a4cda201f 2 e8c95d5a654b4a22 +aggregates_match_executor 546ed22a46430f77 2 28bd7fb1f1138fa2 +aggregates_match_executor 546ed22a46430f77 2 5cf77de811f81172 +aggregates_match_executor 59dd3b993c0b777a 6 13a95ac53a6b5fd2 +aggregates_match_executor 5a08c20dcf8047e8 0 cbf29ce484222325 +aggregates_match_executor 5a88440af9688a0b 0 cbf29ce484222325 +aggregates_match_executor 5baa6a7c747deac7 1 2b0a3c192b5558f1 +aggregates_match_executor 5cd0becbb65c87d1 1 77bce1c4a205d359 +aggregates_match_executor 5cf284ad0b5e0625 1 2b0a3b192b55573e +aggregates_match_executor 60a8a6f621aa2bd9 2 848d5678b545d5a9 +aggregates_match_executor 626caaf7cc5f5f78 1 58172f0e50ecdfc4 +aggregates_match_executor 62cb496fa1b4c8c8 0 cbf29ce484222325 +aggregates_match_executor 63197bdea85de8a3 0 cbf29ce484222325 +aggregates_match_executor 65c2a52934082868 1 2b0a3c192b5558f1 +aggregates_match_executor 6613c4c1d3b2f271 1 7d833dc8c9b301f8 +aggregates_match_executor 6b5eed63cbd2cd96 1 2b0a39192b5553d8 +aggregates_match_executor 6b97cbdec16ad6ca 1 2b0a3b192b55573e +aggregates_match_executor 6c9abfdc8a125d97 0 cbf29ce484222325 +aggregates_match_executor 6df21f093994e977 0 cbf29ce484222325 +aggregates_match_executor 71006168bdbc4a74 3 618597d0bc33e8fe +aggregates_match_executor 71065575c296dcb2 1 2b0a3b192b55573e +aggregates_match_executor 71e458f26dd4d792 1 2b0a39192b5553d8 +aggregates_match_executor 73aeb3cf470e7e0b 2 e8c95d5a654b4a22 +aggregates_match_executor 74600136bb924173 1 58172f0e50ecdfc4 +aggregates_match_executor 7543a8b2d57bee88 6 f9cbb56f9329e606 +aggregates_match_executor 770522b549840474 1 2b0a3b192b55573e +aggregates_match_executor 7991d57708602857 1 2b0a3a192b55558b +aggregates_match_executor 79e7942fb896c831 3 16183acaab84d52c +aggregates_match_executor 7c4aa2ec70674241 1 c0e2a7d843f5c822 +aggregates_match_executor 7e03e519d51d2203 1 77bce4c4a205d872 +aggregates_match_executor 7e98a5edfaef70dd 1 77bce1c4a205d359 +aggregates_match_executor 7ec58a4c215e457a 1 2b0a3b192b55573e +aggregates_match_executor 7f57c7a7147c3db6 1 2b0a3c192b5558f1 +aggregates_match_executor 81657624bc5d07e4 1 77b2edc4a1fd9338 +aggregates_match_executor 8238c23af2f4ef9f 3 b323ccd0b121d73f +aggregates_match_executor 843b7ae4c74c10ac 0 cbf29ce484222325 +aggregates_match_executor 8845ec6b5d68121f 0 cbf29ce484222325 +aggregates_match_executor 8b99694effc7348b 0 cbf29ce484222325 +aggregates_match_executor 8c9197201dcd9a4f 1 58172f0e50ecdfc4 +aggregates_match_executor 8e683fd58809ac66 1 2b0a3d192b555aa4 +aggregates_match_executor 8f3367175e8ab0ed 2 9685edabc9350fc0 +aggregates_match_executor 8f518caedaef6b7f 1 77bce4c4a205d872 +aggregates_match_executor 8ff675e43775f080 1 58172f0e50ecdfc4 +aggregates_match_executor 909b3b8a968d863c 6 b3b5a1676c429bd2 +aggregates_match_executor 909b3b8a968d863c 6 d4b9b9d1cd5e8b6e +aggregates_match_executor 91401948b636dff3 1 d4f6acadaab27475 +aggregates_match_executor 922d2094a6f6a911 1 bc694847962fe6f5 +aggregates_match_executor 92cf9eed9517ca2a 0 cbf29ce484222325 +aggregates_match_executor 96d16b5766d6d49f 1 2b7cd624ca4246af +aggregates_match_executor 9776a100990bc7f3 2 e8c95d5a654b4a22 +aggregates_match_executor 988dc1e76b3aed58 1 58172f0e50ecdfc4 +aggregates_match_executor 995a019ca27f1409 5 4205e1959d3c815c +aggregates_match_executor 9f98e3032f243e82 1 58172f0e50ecdfc4 +aggregates_match_executor a047fa7a91615dc4 1 77bce7c4a205dd8b +aggregates_match_executor a165d559aaa1b63a 2 f0ac92b3405bc818 +aggregates_match_executor a209632269f9c6f1 3 b9f3ec3fd5846c7d +aggregates_match_executor a26546caa9378230 1 26a4d388d7f45bee +aggregates_match_executor a4745e826b80881a 0 cbf29ce484222325 +aggregates_match_executor a4b8a2589f548390 6 03a241c665772d7c +aggregates_match_executor a4b8a2589f548390 6 47a9df68fa53fe79 +aggregates_match_executor a5e62020bddc0296 1 2b0a3d192b555aa4 +aggregates_match_executor a5efd342ccc57fe2 6 cbde170f3d5b1422 +aggregates_match_executor a859d02300a1b75c 3 2037066d6c7b0099 +aggregates_match_executor abc1c1fa21210df3 1 2b0a39192b5553d8 +aggregates_match_executor abfe3e9a8cb51b94 0 cbf29ce484222325 +aggregates_match_executor ac1ebd924e88600e 1 2b0a3b192b55573e +aggregates_match_executor ac6e6c1d223494b4 0 cbf29ce484222325 +aggregates_match_executor acd570010958d28c 1 58172f0e50ecdfc4 +aggregates_match_executor aeebc1d12782b92b 1 58172f0e50ecdfc4 +aggregates_match_executor af65f8e95596d4e6 6 5c1534a990bd7b92 +aggregates_match_executor af65f8e95596d4e6 6 7997a66fb5f2c1b9 +aggregates_match_executor b08a15f1e1425a5b 1 2b0a39192b5553d8 +aggregates_match_executor b1dd1b2ca5d056dd 1 e193323a35ea6fc7 +aggregates_match_executor b5234238d346a909 1 2b0a3d192b555aa4 +aggregates_match_executor bc63255b4d797c25 1 58172f0e50ecdfc4 +aggregates_match_executor be6b5ee36a986e4e 2 6b3720423fa7e901 +aggregates_match_executor bf465011a052ec63 0 cbf29ce484222325 +aggregates_match_executor c0460e3dc0332929 1 12b0d808df61019d +aggregates_match_executor c053f70d891345d1 1 58172f0e50ecdfc4 +aggregates_match_executor c267c73ca5c3adef 0 cbf29ce484222325 +aggregates_match_executor c2731f3a4ed61594 2 e8c95d5a654b4a22 +aggregates_match_executor c348a4998721d6ca 8 e7be4ce788024a16 +aggregates_match_executor c4bab2f0ee623443 3 2037036d6c7afb80 +aggregates_match_executor c6c09ad3c9194345 3 16183bcaab84d6df +aggregates_match_executor c6c09ad3c9194345 3 d0af7bd148f6eac4 +aggregates_match_executor c90e7b405e3c715e 1 58172f0e50ecdfc4 +aggregates_match_executor c957c6a716f1f6b2 10 32d4e216344cfbd6 +aggregates_match_executor c97de5452163825f 1 2b0a39192b5553d8 +aggregates_match_executor ca259fd5c0d72dc3 1 2b0a3f192b555e0a +aggregates_match_executor ca27c86e4177e9db 2 1525eb2d29b75246 +aggregates_match_executor cc41299ca1416881 2 f0ac92b3405bc818 +aggregates_match_executor ccf76d3d1c9dc075 1 2b0a39192b5553d8 +aggregates_match_executor cd9c44aa44a71c70 0 cbf29ce484222325 +aggregates_match_executor cdfd674aaec6e61a 2 28bd7fb1f1138fa2 +aggregates_match_executor cdfd674aaec6e61a 2 5cf77de811f81172 +aggregates_match_executor ce72b28bcf6efdfb 1 9384ef1c2653bbd8 +aggregates_match_executor cfa32a6b7dcf71a7 1 2b0a3b192b55573e +aggregates_match_executor cfbcc046cb640e2e 1 58172f0e50ecdfc4 +aggregates_match_executor d0735ccd4aca3cb8 1 58172f0e50ecdfc4 +aggregates_match_executor d2043ef262d29c4f 1 77bce7c4a205dd8b +aggregates_match_executor d229346efeb16692 1 77bce4c4a205d872 +aggregates_match_executor d4047f2ef9bc16eb 1 77bce7c4a205dd8b +aggregates_match_executor d582b38f40048fad 0 cbf29ce484222325 +aggregates_match_executor d6bcbae9b08f8335 1 0da4a80b0c5eac4d +aggregates_match_executor d6bcbae9b08f8335 1 451650762da4dbc4 +aggregates_match_executor d71701bcf1eac51b 0 cbf29ce484222325 +aggregates_match_executor d807e0ddb39a355a 9 0e7f356887619189 +aggregates_match_executor d807e0ddb39a355a 9 534d64d4b937394c +aggregates_match_executor d8182f70a56de0d6 1 2b0a39192b5553d8 +aggregates_match_executor d9c6c1c9da7b37cd 9 0e7f356887619189 +aggregates_match_executor d9c6c1c9da7b37cd 9 534d64d4b937394c +aggregates_match_executor dc12c09dccafddaf 0 cbf29ce484222325 +aggregates_match_executor dd40c3e3ace48b96 2 e8c95d5a654b4a22 +aggregates_match_executor ddc9ec82650aef6e 1 77bce1c4a205d359 +aggregates_match_executor e044badc9cbef63d 3 21a0a154bb94a7a7 +aggregates_match_executor e476e811d80e48b8 3 b323ccd0b121d73f +aggregates_match_executor e7194d89eb004b16 1 2b0a3d192b555aa4 +aggregates_match_executor f037213604af1f7a 1 5177c452741d281a +aggregates_match_executor f037213604af1f7a 1 e193323a35ea6fc7 +aggregates_match_executor f129624955c38308 6 577b8cc15c05c176 +aggregates_match_executor f487a3485cef89c4 0 cbf29ce484222325 +aggregates_match_executor f7b9f5a712b8653d 1 58172f0e50ecdfc4 +aggregates_match_executor fcda20d92a09f2a7 0 cbf29ce484222325 +aggregates_match_executor fd787487a0f09a52 1 2b0a3b192b55573e +aggregates_match_executor fe114491045bcd90 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 00267e941b754447 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 00267e941b754447 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 04647691ce55ddb5 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 05484d1e52db294e 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 06c2c3644fc36051 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 06c2c3644fc36051 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 0a2d45b06d39f31b 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 0a2d45b06d39f31b 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 0d0db09c4a31502a 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 0e61bb37f454da40 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 0ecb7812d098a183 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 1393f309bdff2406 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 147d69086412607c 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 147d69086412607c 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine 149966aaea84ddd1 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 17f7d21755d1bd1d 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 19bff7b1253be785 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 1a0f6b85c69b8adc 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 1a7fe7aebb9c0b32 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 1c9cfca574bcf8c5 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 1c9cfca574bcf8c5 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 1d4d06e6625c275b 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 1d4d06e6625c275b 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 1d690c0e3f766fa5 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 20d2a7a2f5b2d43c 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 2a82e30d8dfe84e5 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 2b8de71b0e1da610 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 2fd053ff6a461dff 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 2fd053ff6a461dff 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 31efd79d64146c57 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 3b7ed581a0e4e7b4 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 3c3269d11f0271b0 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 3c57b3ad4cad9f86 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 3c57b3ad4cad9f86 1 2b0a3c192b5558f1 +as_of_timestamps_run_on_the_engine 3c93ea19e3ebaf5b 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 3c93ea19e3ebaf5b 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 402aeb3f6c15a21c 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 40881fbb3c548ed8 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 40881fbb3c548ed8 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 4111c9008be11e71 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 4179fb1ce76ab720 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 4179fb1ce76ab720 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 41ea678c025f4b26 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 44f00a3505bd753c 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 45b876f0892af74e 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 46968dab276a5b04 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 486b6b0041449f32 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 4a983af7c85c93e6 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 4a983af7c85c93e6 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 4a9a36366e7f7ece 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 4a9a36366e7f7ece 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 4c92fa6c944de56e 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 4dfc6259c9b5804d 2 4106d93edadce631 +as_of_timestamps_run_on_the_engine 4dfc6259c9b5804d 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 4dfc6259c9b5804d 3 7681a866da98e270 +as_of_timestamps_run_on_the_engine 537554a92273a7b2 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 54a6dc595e16a3ef 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 54a6dc595e16a3ef 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 5746c33395e2e75f 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 5746c33395e2e75f 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine 578ca8e71f800b19 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 578ca8e71f800b19 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine 5ac8dd6ddd5098d9 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 5ac8dd6ddd5098d9 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 5c0b670d18bb24cd 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 5c0b670d18bb24cd 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 5d51f509669ea30c 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 5d61b762327ed83f 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 5e2dc0672b51a4e9 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 627077b84ec095b8 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine 6312258ee997e6eb 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6312258ee997e6eb 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 634570ef2999f591 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6764668145adeca1 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6c5359cd27ecc4c3 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine 6d597cd72838b7ad 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6d597cd72838b7ad 1 2b0a3c192b5558f1 +as_of_timestamps_run_on_the_engine 6f2effc51e684702 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6f2effc51e684702 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 6fccd6b3534e0665 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 6fccd6b3534e0665 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine 6fd4cc25a9a2da65 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 6fd4cc25a9a2da65 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 732f58e0331fbc71 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 733931137b89794a 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine 733931137b89794a 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 73a6d73ec122181c 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine 7553368b30cc523d 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 7553368b30cc523d 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 78a71feb685f0d2f 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 78a71feb685f0d2f 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine 791e6ccba5a384fa 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 7d0dde2d1507f4c0 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine 82188700b63c6c86 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 82188700b63c6c86 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine 885997fdd93216bf 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 8dcbc87b445dd94c 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 8dcbc87b445dd94c 1 4b0fca7f2a4936d6 +as_of_timestamps_run_on_the_engine 8f6f84e90ddd410c 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 922fb00e18cf5da7 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 9642d3b09bc785a5 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 96f6f075ad477f64 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 9bb00f43445a9ac8 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine 9bb00f43445a9ac8 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine 9c4bd362fbfc7e5f 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine a3b7bd7d69b67092 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine a3b7bd7d69b67092 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine a45c1c2e07084095 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine a483813bf3041624 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine a483813bf3041624 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine a6f28a59f368d63e 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine a8545aee5ba24856 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine aa27e23ca6b44b64 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine ad4881c991a0dc1c 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine b13c10cab6d987ff 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine b338b338303f3484 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine b5a793d1e047bb83 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine b6ebecaadc14ad25 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine bcd91ca1f4aec228 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine bde5c303cffafec8 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine c573e133222e5cb3 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine c6860aab1e38a902 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine c6d8dee22df27b07 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine c6d8dee22df27b07 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine c77fc3f1820655ee 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine c77fc3f1820655ee 1 fc8a7c9b89c8735f +as_of_timestamps_run_on_the_engine ce3ddf8a751466a1 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine ce3ddf8a751466a1 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine cfa2158596cfbe60 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine cfa2158596cfbe60 3 fccb607c1cc4e6e4 +as_of_timestamps_run_on_the_engine d116dedb90cb60cf 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine d2ddd175f6b55b63 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine d793e31e9c964c68 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine dad7edc4202a0d43 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine dad7edc4202a0d43 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine db932952ebde3899 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine db932952ebde3899 1 2b0a3c192b5558f1 +as_of_timestamps_run_on_the_engine dd0297ecbcc1a485 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine ddcbd5a6583653db 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine ddcbd5a6583653db 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine dec38e7033ff4523 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine dff7e5d4d509fefa 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine dff7e5d4d509fefa 2 b93f5d19971666e0 +as_of_timestamps_run_on_the_engine e3ae2d6c53a82ff9 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine e454b70e6bd781c4 2 e01bff5bafd2dd3d +as_of_timestamps_run_on_the_engine ec84f19f219bc4ba 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine ec84f19f219bc4ba 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine ec85f3f6865b2416 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine f63276f670e94fcc 2 4106d93edadce631 +as_of_timestamps_run_on_the_engine f63276f670e94fcc 2 42fae12ac985218e +as_of_timestamps_run_on_the_engine f63276f670e94fcc 3 7681a866da98e270 +as_of_timestamps_run_on_the_engine f63ef767d6641713 0 cbf29ce484222325 +as_of_timestamps_run_on_the_engine f826c13bb2ee3071 1 4b0fc97f2a493523 +as_of_timestamps_run_on_the_engine f826c13bb2ee3071 1 6da24e6639ddca33 +as_of_timestamps_run_on_the_engine fab54f707b2c2d7e 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine fd89baa1683136da 1 2b0a39192b5553d8 +as_of_timestamps_run_on_the_engine fd9a221562f0de3d 0 cbf29ce484222325 +constants_run_on_the_engine 224fee17ba7eadce 0 cbf29ce484222325 +constants_run_on_the_engine 32e368947d79a0a0 0 cbf29ce484222325 +constants_run_on_the_engine 355bee83804e1f67 0 cbf29ce484222325 +constants_run_on_the_engine 36c4429e129dbfc9 0 cbf29ce484222325 +constants_run_on_the_engine 3acb50556f4da59d 0 cbf29ce484222325 +constants_run_on_the_engine 550e7f04f6579b3d 2 ff35bcc3a72b4338 +constants_run_on_the_engine 66c7b79f59f9a78b 2 02b1d1046853e1c4 +constants_run_on_the_engine 6be89223b33e279b 0 cbf29ce484222325 +constants_run_on_the_engine 8ce5934c5c479c42 0 cbf29ce484222325 +constants_run_on_the_engine 99663b64b3139793 0 cbf29ce484222325 +constants_run_on_the_engine ddf9b5978f860494 0 cbf29ce484222325 +constants_run_on_the_engine f67bc429381fa4d4 0 cbf29ce484222325 +constants_run_on_the_engine f8376d24fbf5a945 0 cbf29ce484222325 +constants_run_on_the_engine fb1e7c5f122866a0 0 cbf29ce484222325 +cross_kind_constants_read_their_avet_ranges 02c18b01230d5a86 1 04b33efa45692bb9 +cross_kind_constants_read_their_avet_ranges 06bfddd74514ff45 0 cbf29ce484222325 +cross_kind_constants_read_their_avet_ranges 136c0dbe52141cbf 1 604f5abece89b339 +cross_kind_constants_read_their_avet_ranges 2c9fd64d3a249d36 1 17aa6399587da023 +cross_kind_constants_read_their_avet_ranges 41fbdfe52a5ffa66 1 bd5fc6f0d95f60cd +cross_kind_constants_read_their_avet_ranges 4807303c1c8edf45 2 3609050103036cdf +cross_kind_constants_read_their_avet_ranges 4b302f2afdd083df 0 cbf29ce484222325 +cross_kind_constants_read_their_avet_ranges 4dfd6708749b273a 1 604f5abece89b339 +cross_kind_constants_read_their_avet_ranges 7d25135caf366282 1 90ea7f232b73bce7 +cross_kind_constants_read_their_avet_ranges 81a6c96e633923bd 1 bd5fc6f0d95f60cd +cross_kind_constants_read_their_avet_ranges 83292033f93ddef1 1 90ea7f232b73bce7 +cross_kind_constants_read_their_avet_ranges 8564964d55d00291 1 bd5fc6f0d95f60cd +cross_kind_constants_read_their_avet_ranges 89ded4f691960496 0 cbf29ce484222325 +cross_kind_constants_read_their_avet_ranges 8a86ee19be22ac5a 1 0db1787bb5341966 +cross_kind_constants_read_their_avet_ranges 94ffd086ee260338 1 604f5abece89b339 +cross_kind_constants_read_their_avet_ranges b24789a680e701bb 1 17aa6399587da023 +cross_kind_constants_read_their_avet_ranges b703a84d04ca96f8 1 90ea7f232b73bce7 +cross_kind_constants_read_their_avet_ranges b8b7d8b931287fd0 1 90ea7f232b73bce7 +cross_kind_constants_read_their_avet_ranges d279564669c61d36 1 bd5fc6f0d95f60cd +cross_kind_constants_read_their_avet_ranges dc3fc2f79752960f 0 cbf29ce484222325 +cross_kind_constants_read_their_avet_ranges df780a7a4295db8c 1 17aa6399587da023 +cross_kind_constants_read_their_avet_ranges e0e34a7f69cc875f 1 90ea7f232b73bce7 +cross_kind_constants_read_their_avet_ranges e3a7d8bf91a532a3 1 17aa6399587da023 +cross_kind_constants_read_their_avet_ranges f115b506fbeff657 1 0db1787bb5341966 +disjunction_matches_executor 0028b282346f642a 6 861eb491878c8fca +disjunction_matches_executor 0166bf5557fefb3d 1 81811716bd6b8225 +disjunction_matches_executor 017bca560d104bc4 2 3609050103036cdf +disjunction_matches_executor 0334af8924e7b674 18 ea9b291f0a34e76b +disjunction_matches_executor 0334af8924e7b674 27 2e0175f3c9c3ab68 +disjunction_matches_executor 0334af8924e7b674 9 4a53d23778e95eda +disjunction_matches_executor 033cf03c9e9be35e 9 4a53d23778e95eda +disjunction_matches_executor 047d93432ba59ed9 12 5e01d4a04e62cd99 +disjunction_matches_executor 047d93432ba59ed9 18 8cca15abaef472f7 +disjunction_matches_executor 047d93432ba59ed9 6 4e6f0430fcae4f43 +disjunction_matches_executor 04a0c24d856cc38a 0 cbf29ce484222325 +disjunction_matches_executor 05265f6c7c88e55e 0 cbf29ce484222325 +disjunction_matches_executor 05265f6c7c88e55e 4 26fe2c1f0f31c44e +disjunction_matches_executor 05265f6c7c88e55e 5 ef63909160f1a1e2 +disjunction_matches_executor 052852e943e7f071 0 cbf29ce484222325 +disjunction_matches_executor 05af9377213ab1aa 2 dd5187ca97af06b9 +disjunction_matches_executor 0664697c19b61729 5 553d899498126645 +disjunction_matches_executor 0780d9ce11259c3d 10 cdc32918fb77d385 +disjunction_matches_executor 0780d9ce11259c3d 6 494af065717d8bbe +disjunction_matches_executor 0780d9ce11259c3d 8 f8a1dc20aca5f0ad +disjunction_matches_executor 07b5974def04bfdb 2 0ff2a7752c591f09 +disjunction_matches_executor 09563272748b3255 0 cbf29ce484222325 +disjunction_matches_executor 0adee7d86c502406 3 6f595b518c33e6b0 +disjunction_matches_executor 0adee7d86c502406 6 861eb491878c8fca +disjunction_matches_executor 0c248e9f8dadb83d 2 f5ffc68f2c61860d +disjunction_matches_executor 0d6aee02886be837 6 e56d7262862414ed +disjunction_matches_executor 10ab64feb2a0e857 0 cbf29ce484222325 +disjunction_matches_executor 116ce950915b0ad2 3 f1ecf86fc14d95e1 +disjunction_matches_executor 122fe86b8f7ea6a6 2 90252118cc54d288 +disjunction_matches_executor 122fe86b8f7ea6a6 4 04dc0861a5edb66c +disjunction_matches_executor 122fe86b8f7ea6a6 4 d4beeeb89c6410cf +disjunction_matches_executor 14368686c8b044a9 0 cbf29ce484222325 +disjunction_matches_executor 1499d7d9b73389b7 6 861eb491878c8fca +disjunction_matches_executor 152a484122728612 2 0de3e678b8a32d78 +disjunction_matches_executor 153e53734f680d08 2 1b380d281bd5536b +disjunction_matches_executor 1802a45c5980760a 4 2d63146e1655bf14 +disjunction_matches_executor 18400faf280b5397 1 17aa6399587da023 +disjunction_matches_executor 190984d00b9dd108 6 861eb491878c8fca +disjunction_matches_executor 191be546f1823113 3 cd8f0522a739b22e +disjunction_matches_executor 191be546f1823113 6 18674433ff6738f0 +disjunction_matches_executor 191be546f1823113 9 958513356c4496a4 +disjunction_matches_executor 1aaeab75c1b6aa4f 3 6f595b518c33e6b0 +disjunction_matches_executor 1ac2823d4a0402f6 4 2d63146e1655bf14 +disjunction_matches_executor 1b02e6514b49d098 1 172f08ba9c63e405 +disjunction_matches_executor 1dece2285d9f296e 0 cbf29ce484222325 +disjunction_matches_executor 1f452726f2e28681 0 cbf29ce484222325 +disjunction_matches_executor 1fe801eb9130ac9f 0 cbf29ce484222325 +disjunction_matches_executor 20131524f9d0d777 12 4ef313c9219ec6a7 +disjunction_matches_executor 20c0005f9b11998d 7 410e7ae9768b6133 +disjunction_matches_executor 2272bfc865486a08 10 de567f8b1c082d75 +disjunction_matches_executor 24a43fbe292c3ae5 4 3111762bc3453b1b +disjunction_matches_executor 24a43fbe292c3ae5 4 b4b163030bad6519 +disjunction_matches_executor 24a43fbe292c3ae5 6 26fd682ceb1edf9c +disjunction_matches_executor 252b8e0a5ba77f2f 6 861eb491878c8fca +disjunction_matches_executor 27ec8366d4c4a096 5 eb5ab7b230a9d200 +disjunction_matches_executor 29c60e3e3f5e9bf9 0 cbf29ce484222325 +disjunction_matches_executor 2a87d6f708762ea6 24 26f11ed11ba95b25 +disjunction_matches_executor 2bd977379b1e5083 0 cbf29ce484222325 +disjunction_matches_executor 2da9ab687f471b26 8 651b7cca778491d1 +disjunction_matches_executor 2e2fc1aa951cf6dc 22 929c4ae6b970b5cf +disjunction_matches_executor 304fb400e8f6703b 0 cbf29ce484222325 +disjunction_matches_executor 30860034e6fec9ce 2 8b2a687ade49a765 +disjunction_matches_executor 327fd1818fdaedbe 0 cbf29ce484222325 +disjunction_matches_executor 32aa4dac91b7ad20 0 cbf29ce484222325 +disjunction_matches_executor 33fd6565a755ecc6 5 52a1017611c8c651 +disjunction_matches_executor 36ca46db738ec913 9 8808f66479b2301f +disjunction_matches_executor 37789b15a4e7b596 3 6f595b518c33e6b0 +disjunction_matches_executor 3829ff65319b6210 12 316daa8fbfb69840 +disjunction_matches_executor 3829ff65319b6210 15 8c0eef114d1ccac6 +disjunction_matches_executor 3829ff65319b6210 9 d55661c082cc11da +disjunction_matches_executor 3977e0a23316c013 0 cbf29ce484222325 +disjunction_matches_executor 3977e0a23316c013 18 79d7b22706fc09e0 +disjunction_matches_executor 3977e0a23316c013 36 89b856ab6db78171 +disjunction_matches_executor 3bac5b2f1bcd0c44 4 51827564f9988371 +disjunction_matches_executor 3bdab58b80cd4b27 10 660d50e1ca583c92 +disjunction_matches_executor 3bdab58b80cd4b27 14 86384c3520589d6e +disjunction_matches_executor 3bdab58b80cd4b27 5 553d899498126645 +disjunction_matches_executor 3c96c77a0a2d1a2b 6 861eb491878c8fca +disjunction_matches_executor 3e06b430c6a796bf 6 861eb491878c8fca +disjunction_matches_executor 3e10b7d913e27049 3 6f595b518c33e6b0 +disjunction_matches_executor 3e10b7d913e27049 6 861eb491878c8fca +disjunction_matches_executor 3e40490dac69390a 2 86bd2c7a526e97fd +disjunction_matches_executor 3f828647b885727b 4 809e300c376a14dd +disjunction_matches_executor 438acabf5264708a 0 cbf29ce484222325 +disjunction_matches_executor 43fcbf9e75b74d6d 4 78a9bc5525c530dd +disjunction_matches_executor 44f36856d405cc3a 3 1419ec70940d65b0 +disjunction_matches_executor 453a25ea8d199481 3 6f595b518c33e6b0 +disjunction_matches_executor 45e000e11ffaa9ae 17 13ae3c5dee8e4f8e +disjunction_matches_executor 46499b991d0d786b 12 4ef313c9219ec6a7 +disjunction_matches_executor 46499b991d0d786b 18 5563a8526cfad225 +disjunction_matches_executor 46499b991d0d786b 6 967c5c6d5a844ffb +disjunction_matches_executor 4c0608511f8d170d 0 cbf29ce484222325 +disjunction_matches_executor 4cb09c91b9a1470d 10 54a7bb767e9d46f8 +disjunction_matches_executor 4f6c030bb04a61b3 6 861eb491878c8fca +disjunction_matches_executor 505116fe7807e50d 6 967c5c6d5a844ffb +disjunction_matches_executor 507dbce8167b8ed7 3 dd85ff3c7bda0ce2 +disjunction_matches_executor 50eefbbf3b3cf343 0 cbf29ce484222325 +disjunction_matches_executor 51509ee258396938 1 a006d93e27ee99ab +disjunction_matches_executor 5304955a571936d4 3 4bdb5eb026698857 +disjunction_matches_executor 551da5017abd6a5c 6 4e6f0430fcae4f43 +disjunction_matches_executor 55878bb58f5cb94a 12 5e01d4a04e62cd99 +disjunction_matches_executor 55f259d342198a1d 6 861eb491878c8fca +disjunction_matches_executor 5699e83a25000104 6 861eb491878c8fca +disjunction_matches_executor 5903c332c23c839d 0 cbf29ce484222325 +disjunction_matches_executor 5936e63af1e805c6 3 6f595b518c33e6b0 +disjunction_matches_executor 5936e63af1e805c6 6 861eb491878c8fca +disjunction_matches_executor 599ecd23c5a61570 6 861eb491878c8fca +disjunction_matches_executor 5bffbd6238d8c76c 1 17aa6399587da023 +disjunction_matches_executor 5f0a3e6b5ecd8f80 12 d0aed1190eb12303 +disjunction_matches_executor 5f0a3e6b5ecd8f80 18 52377df0f47122f8 +disjunction_matches_executor 5f0a3e6b5ecd8f80 4 2d63146e1655bf14 +disjunction_matches_executor 5f2f5f4c79519b37 18 79d7b22706fc09e0 +disjunction_matches_executor 5f8f899b29ce96d7 1 172f08ba9c63e405 +disjunction_matches_executor 5fb16d516b98826c 2 9de41c9d35adb9f3 +disjunction_matches_executor 6013106238d91507 6 861eb491878c8fca +disjunction_matches_executor 609247f0dafd6ada 6 861eb491878c8fca +disjunction_matches_executor 6184858070b73728 0 cbf29ce484222325 +disjunction_matches_executor 6294a67f8c4c9172 5 a40fa92fb73e393d +disjunction_matches_executor 6339f5fb1954e633 3 6f595b518c33e6b0 +disjunction_matches_executor 63578937d4070bff 0 cbf29ce484222325 +disjunction_matches_executor 64544cd840b2c242 12 4ef313c9219ec6a7 +disjunction_matches_executor 64544cd840b2c242 18 5563a8526cfad225 +disjunction_matches_executor 64544cd840b2c242 6 967c5c6d5a844ffb +disjunction_matches_executor 64e2f67726abed01 1 17aa6399587da023 +disjunction_matches_executor 659cb3022bf19c4a 0 cbf29ce484222325 +disjunction_matches_executor 665092e5d8373508 0 cbf29ce484222325 +disjunction_matches_executor 665092e5d8373508 3 4bdb5eb026698857 +disjunction_matches_executor 670f4788ede4f477 8 ba1e04019687bed3 +disjunction_matches_executor 671c95cc563e1d0b 0 cbf29ce484222325 +disjunction_matches_executor 671c95cc563e1d0b 3 6f595b518c33e6b0 +disjunction_matches_executor 671c95cc563e1d0b 6 861eb491878c8fca +disjunction_matches_executor 68d394901037124d 3 7ea12c01f35984d9 +disjunction_matches_executor 6a22e2e44ca726a8 0 cbf29ce484222325 +disjunction_matches_executor 6b37c54efc64c6db 8 a6bec28ea6284578 +disjunction_matches_executor 6b9705c09bf1be00 0 cbf29ce484222325 +disjunction_matches_executor 6bb51f43b1c479b2 4 82d6045f8c420cb5 +disjunction_matches_executor 6cad369c2ee136ac 2 3609050103036cdf +disjunction_matches_executor 6dfd60fc18ff9644 1 8422d0cc6efcd56a +disjunction_matches_executor 6ed1fd7b62ab930e 0 cbf29ce484222325 +disjunction_matches_executor 727897a3d7180806 5 9d7d87b71cdc649b +disjunction_matches_executor 7347141d68498d83 1 04b33efa45692bb9 +disjunction_matches_executor 76056290bf98eebf 0 cbf29ce484222325 +disjunction_matches_executor 7b1c2f48d3941414 4 3111762bc3453b1b +disjunction_matches_executor 7b1c2f48d3941414 7 be9faf0126bb3ecf +disjunction_matches_executor 7b1c2f48d3941414 9 8d4e18dbc009bc75 +disjunction_matches_executor 7ba3ef45a2b0c22b 6 dedd6ea12aeebd90 +disjunction_matches_executor 7f8771ffac81b0e6 0 cbf29ce484222325 +disjunction_matches_executor 81cc8f5fc55a8404 6 18674433ff6738f0 +disjunction_matches_executor 81cc8f5fc55a8404 6 2e307855eb6cd122 +disjunction_matches_executor 81cc8f5fc55a8404 9 958513356c4496a4 +disjunction_matches_executor 841fa49e0899f5cb 30 b89a7385d7dfdb78 +disjunction_matches_executor 84beb34cb5a1d6ed 3 6f595b518c33e6b0 +disjunction_matches_executor 84beb34cb5a1d6ed 6 861eb491878c8fca +disjunction_matches_executor 865d4ca73822ebad 0 cbf29ce484222325 +disjunction_matches_executor 8781bdf51e2ea217 0 cbf29ce484222325 +disjunction_matches_executor 8781bdf51e2ea217 6 861eb491878c8fca +disjunction_matches_executor 8781bdf51e2ea217 9 67514579e8b21c58 +disjunction_matches_executor 87b98cf2ef1ac037 2 3609050103036cdf +disjunction_matches_executor 88334fc73be2479c 8 a6bec28ea6284578 +disjunction_matches_executor 89e486943c86ae37 5 5e8b43ada6edf4d7 +disjunction_matches_executor 8aebd63019a30889 1 04b33efa45692bb9 +disjunction_matches_executor 8d227175d499367f 12 d0aed1190eb12303 +disjunction_matches_executor 8d227175d499367f 18 52377df0f47122f8 +disjunction_matches_executor 8d227175d499367f 4 2d63146e1655bf14 +disjunction_matches_executor 92718ba81d949a40 6 2e307855eb6cd122 +disjunction_matches_executor 93b1d795a6ea0023 3 6f595b518c33e6b0 +disjunction_matches_executor 93b1d795a6ea0023 6 861eb491878c8fca +disjunction_matches_executor 9413c9fd1ca0b2ba 4 2d63146e1655bf14 +disjunction_matches_executor 97380d410f8b85e2 24 26f11ed11ba95b25 +disjunction_matches_executor 97380d410f8b85e2 54 3f43e1b9df474e82 +disjunction_matches_executor 97380d410f8b85e2 6 861eb491878c8fca +disjunction_matches_executor 98640889571b116a 1 17aa6399587da023 +disjunction_matches_executor 9af885f02c0dc4b4 7 cedac02420219149 +disjunction_matches_executor 9ba02c15f510b81b 13 8b3d0ec023a160ce +disjunction_matches_executor 9ca18864fff3ce13 1 04b33efa45692bb9 +disjunction_matches_executor 9d00d9fec920330c 17 ece7cb61872aebd8 +disjunction_matches_executor a1113dfe256b22df 15 a12f7e16dbdaa5ce +disjunction_matches_executor a1704318b7fd57b8 0 cbf29ce484222325 +disjunction_matches_executor a1704318b7fd57b8 6 861eb491878c8fca +disjunction_matches_executor a1704318b7fd57b8 9 67514579e8b21c58 +disjunction_matches_executor a1f72d4436a709ae 0 cbf29ce484222325 +disjunction_matches_executor a1f72d4436a709ae 6 861eb491878c8fca +disjunction_matches_executor a1f72d4436a709ae 9 67514579e8b21c58 +disjunction_matches_executor a265c92dd06e20b6 49 ec0e58870145f1c6 +disjunction_matches_executor a3ed1c3b8dffcd99 0 cbf29ce484222325 +disjunction_matches_executor a560a3ff49a75a7d 3 cd8f0522a739b22e +disjunction_matches_executor a59721aa324a3208 3 58021e1f4f922d1c +disjunction_matches_executor a5fdef07b7eba30a 0 cbf29ce484222325 +disjunction_matches_executor a6493a1ed3835e3b 1 17aa6399587da023 +disjunction_matches_executor a86dc3b5fd13b879 0 cbf29ce484222325 +disjunction_matches_executor a874033bf4b2f727 6 18674433ff6738f0 +disjunction_matches_executor a8b590ac1fe2759b 6 2e307855eb6cd122 +disjunction_matches_executor a8c7197db0a1faf0 4 36804b72f297d3d6 +disjunction_matches_executor ae9afb7c1d6b2162 2 88bc514fa07656a2 +disjunction_matches_executor aece3a086288cad1 2 42a12df1328852f7 +disjunction_matches_executor af0be6c4ccbd4b79 6 861eb491878c8fca +disjunction_matches_executor afbc8aaf742cd7c9 18 ea9b291f0a34e76b +disjunction_matches_executor afbc8aaf742cd7c9 27 2e0175f3c9c3ab68 +disjunction_matches_executor afbc8aaf742cd7c9 9 4a53d23778e95eda +disjunction_matches_executor b131e163afb98fdb 5 1d529cd8654bc5fc +disjunction_matches_executor b19b3e62022ee9e1 0 cbf29ce484222325 +disjunction_matches_executor b19b3e62022ee9e1 3 4bdb5eb026698857 +disjunction_matches_executor b2543a8147745d13 17 32931fde848cb184 +disjunction_matches_executor b2c3f2851bd220dc 3 6f595b518c33e6b0 +disjunction_matches_executor b4172ced34a1339a 3 f7e6f8edbbe1b780 +disjunction_matches_executor b7515628a918653b 0 cbf29ce484222325 +disjunction_matches_executor b798c809cf8453fc 1 17aa6399587da023 +disjunction_matches_executor b8dfcec2475e6c4e 0 cbf29ce484222325 +disjunction_matches_executor bac9dea611dcbdb0 5 9d7d87b71cdc649b +disjunction_matches_executor bceca0e4358f49c6 0 cbf29ce484222325 +disjunction_matches_executor bdbb01f2b2be143d 8 c8432a3d5f4272a9 +disjunction_matches_executor c0288cecb51f90dd 0 cbf29ce484222325 +disjunction_matches_executor c0288cecb51f90dd 6 861eb491878c8fca +disjunction_matches_executor c0288cecb51f90dd 9 67514579e8b21c58 +disjunction_matches_executor c0b2046bd319e837 11 ff5d4da5b10890b4 +disjunction_matches_executor c28115e51bca482c 2 3609050103036cdf +disjunction_matches_executor c32a459edf87bece 2 1b380d281bd5536b +disjunction_matches_executor c419a7018befb766 9 d55661c082cc11da +disjunction_matches_executor c4d5a157eceda212 12 31d234da266d4922 +disjunction_matches_executor c4d5a157eceda212 4 3111762bc3453b1b +disjunction_matches_executor c4d5a157eceda212 8 9c3fc727ee48d988 +disjunction_matches_executor c5749f70aca90b54 0 cbf29ce484222325 +disjunction_matches_executor c6168d4cb839b6d2 3 58021e1f4f922d1c +disjunction_matches_executor c6168d4cb839b6d2 6 c369485b5f37d49f +disjunction_matches_executor c632301dd142442d 3 7ea12c01f35984d9 +disjunction_matches_executor c66cbd9699a03ded 0 cbf29ce484222325 +disjunction_matches_executor c79b04f621998c4c 6 861eb491878c8fca +disjunction_matches_executor c840496617614838 0 cbf29ce484222325 +disjunction_matches_executor c8f0f66db2d482b7 0 cbf29ce484222325 +disjunction_matches_executor c9e91d94e6e47f5f 5 3fabd2a839185437 +disjunction_matches_executor cb1e1e3a35eb4a6b 6 861eb491878c8fca +disjunction_matches_executor cb678ab57b989750 3 cd8f0522a739b22e +disjunction_matches_executor cb678ab57b989750 6 18674433ff6738f0 +disjunction_matches_executor cb678ab57b989750 9 958513356c4496a4 +disjunction_matches_executor cbc46849eae8d6e2 6 18674433ff6738f0 +disjunction_matches_executor cbc46849eae8d6e2 6 2e307855eb6cd122 +disjunction_matches_executor cbc46849eae8d6e2 9 958513356c4496a4 +disjunction_matches_executor cef8d8ece5bc0d88 18 ea9b291f0a34e76b +disjunction_matches_executor cfc1ee866c21f304 0 cbf29ce484222325 +disjunction_matches_executor cfc1ee866c21f304 18 79d7b22706fc09e0 +disjunction_matches_executor cfc1ee866c21f304 36 89b856ab6db78171 +disjunction_matches_executor d0458505145fbe16 1 17aa6399587da023 +disjunction_matches_executor d0e88dc7e161495b 4 412d7fa1a059a2fd +disjunction_matches_executor d18cc462760d0aeb 2 0ff2a7752c591f09 +disjunction_matches_executor d1dfaada95c6bf47 0 cbf29ce484222325 +disjunction_matches_executor d1dfaada95c6bf47 2 43f78a2f1420b720 +disjunction_matches_executor d1dfaada95c6bf47 3 aea43b1111000d5d +disjunction_matches_executor d376fc0405ff378a 1 17aa6399587da023 +disjunction_matches_executor d54ec14c855023f8 0 cbf29ce484222325 +disjunction_matches_executor d54ec14c855023f8 3 6f595b518c33e6b0 +disjunction_matches_executor d54ec14c855023f8 6 861eb491878c8fca +disjunction_matches_executor d7492ed789d1499e 12 5e01d4a04e62cd99 +disjunction_matches_executor d7492ed789d1499e 18 8cca15abaef472f7 +disjunction_matches_executor d7492ed789d1499e 6 4e6f0430fcae4f43 +disjunction_matches_executor da0642c8cf855459 2 0de3e678b8a32d78 +disjunction_matches_executor da41ade9365d571b 24 26f11ed11ba95b25 +disjunction_matches_executor da41ade9365d571b 54 3f43e1b9df474e82 +disjunction_matches_executor da41ade9365d571b 6 861eb491878c8fca +disjunction_matches_executor db1894b17f270df1 12 963a03e1186f6c1a +disjunction_matches_executor db1894b17f270df1 18 605e9f8000ac5b94 +disjunction_matches_executor db1894b17f270df1 6 2e307855eb6cd122 +disjunction_matches_executor dbfe10c490dda4f5 2 1b380d281bd5536b +disjunction_matches_executor dc082a4739b566bb 0 cbf29ce484222325 +disjunction_matches_executor dc2b615bcb19b984 10 d613124221c446f1 +disjunction_matches_executor dd5343a12f619642 6 2e307855eb6cd122 +disjunction_matches_executor dd787f481367d6ee 1 8422d0cc6efcd56a +disjunction_matches_executor dde2eb45e96e1d7b 2 1b380d281bd5536b +disjunction_matches_executor de8a65cb772a49fc 4 f68eef7fce8992ea +disjunction_matches_executor deab6fd68365bf14 5 3fabd2a839185437 +disjunction_matches_executor e167f5e4aeaa3f52 0 cbf29ce484222325 +disjunction_matches_executor e30b324e648f1513 3 6f595b518c33e6b0 +disjunction_matches_executor e33e2d3a54286c9c 8 fcddc5990656a201 +disjunction_matches_executor e3a9b66137c6883f 5 31fe0d791953e42a +disjunction_matches_executor e419820674b3a607 3 6bae5dde14049d28 +disjunction_matches_executor e487c7389458c2dd 0 cbf29ce484222325 +disjunction_matches_executor e52e453b535e0d1f 9 479baa3c499d55ae +disjunction_matches_executor e73eaa58d62ca81f 3 4bdb5eb026698857 +disjunction_matches_executor ea76f9c095630844 6 861eb491878c8fca +disjunction_matches_executor ea8485f37cb94767 4 3111762bc3453b1b +disjunction_matches_executor ea8485f37cb94767 4 b4b163030bad6519 +disjunction_matches_executor ea8485f37cb94767 6 26fd682ceb1edf9c +disjunction_matches_executor ec000c2e7f8377bd 2 90252118cc54d288 +disjunction_matches_executor ec32c7d7882746d4 0 cbf29ce484222325 +disjunction_matches_executor ece8642446c3aa63 2 b8ff948a4274c70c +disjunction_matches_executor ed1ee657e3602fd1 3 7ea12c01f35984d9 +disjunction_matches_executor ed326cb3c2343ce4 0 cbf29ce484222325 +disjunction_matches_executor ed3b0c19302544c8 0 cbf29ce484222325 +disjunction_matches_executor ef4162995defae56 0 cbf29ce484222325 +disjunction_matches_executor f064ca500d1999b2 5 31fe0d791953e42a +disjunction_matches_executor f08acc4bda3f8ec3 0 cbf29ce484222325 +disjunction_matches_executor f0d15f087b3062a1 3 1550a0a9912ebeaf +disjunction_matches_executor f1b0acaa3a47207d 0 cbf29ce484222325 +disjunction_matches_executor f2f5b542f442c251 5 6677f437185af8cc +disjunction_matches_executor f454e1950e7a9c06 3 7ea12c01f35984d9 +disjunction_matches_executor f471fc6601e8a267 2 88bc514fa07656a2 +disjunction_matches_executor f471fc6601e8a267 4 5dfcd2146e828f37 +disjunction_matches_executor f471fc6601e8a267 4 acbc6d9f0c52a136 +disjunction_matches_executor f5f7955090195cda 2 4e006b68fa0d1fe4 +disjunction_matches_executor f5f7955090195cda 2 5c6ae55a889f7a3f +disjunction_matches_executor f5f7955090195cda 2 d149d496331d0fdd +disjunction_matches_executor f658e35a7a70a61f 0 cbf29ce484222325 +disjunction_matches_executor f70cb5640c82ee1e 2 9de41c9d35adb9f3 +disjunction_matches_executor f721e84578027d34 4 82d6045f8c420cb5 +disjunction_matches_executor f9e842e85db4b130 4 2d63146e1655bf14 +disjunction_matches_executor fa94e6c58234b935 6 861eb491878c8fca +disjunction_matches_executor faa796990fdd341c 12 d0aed1190eb12303 +disjunction_matches_executor fb4e0c905022357e 1 172f08ba9c63e405 +disjunction_matches_executor fbb2103bff9e3ec7 0 cbf29ce484222325 +disjunction_matches_executor fdb6eb9025a3f5cc 9 af528f6ec0a1406b +disjunction_matches_executor fdb7f96490d21560 0 cbf29ce484222325 +disjunction_matches_executor fdcf8f5629b1940c 3 b366d81396a9b58e +disjunction_matches_executor ff519269dcf38a78 0 cbf29ce484222325 +disjunction_routing 14d1c2a6288fbd39 2 90252118cc54d288 +disjunction_routing 3912e83baf0fb95f 6 861eb491878c8fca +disjunction_routing 8005546b7adbe95c 3 6f595b518c33e6b0 +disjunction_routing ac207e7eb9babf5c 2 90252118cc54d288 +disjunction_routing afa4c52b49a2ebad 2 90252118cc54d288 +disjunction_routing e6f5c402717236f1 2 90252118cc54d288 +disjunction_rows_are_distinct 3312a19b50fe3e54 1 fc8a7c9b89c8735f +disjunction_rows_are_distinct 4b7bd5241c621988 2 c61e042cd7106651 +disjunction_rows_are_distinct 75cac388c9e60635 2 cad3a4b2a769fb39 +engine_filter_runs_registered_predicates be1807f5d3b5160e 3 cfebdd838ce29455 +engine_joins_read_many_batches 00928d33cbde5ed8 571430 8db540a2f518f3ad +engine_joins_read_many_batches 7fde51eea2f8f185 81796 f57dffbc2ca405d9 +engine_joins_read_many_batches 9302b1496a54b1b2 1999 669749d63e1d8242 +engine_joins_read_many_batches bec77a17a37a3324 286 ddb73eebeffe5507 +engine_joins_read_many_batches e917eba3b8d3e4d4 2598 5320c70a7f34e3e9 +engine_matches_executor_across_checkpoints_and_reopen 000b050197d3ccf7 48 549e677ee65c16f1 +engine_matches_executor_across_checkpoints_and_reopen 0015fad8270361cf 12 713cac63084fa059 +engine_matches_executor_across_checkpoints_and_reopen 001f9b0cdde6f188 5 c2e4890abeb04ef9 +engine_matches_executor_across_checkpoints_and_reopen 007338880cc914a5 162 df454dd10fa45d4e +engine_matches_executor_across_checkpoints_and_reopen 008c38c612de6cf6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 009a0124d365f9d3 24 bc3f0459eed80e05 +engine_matches_executor_across_checkpoints_and_reopen 00c38b65cc3da8af 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 01187dcf462224e1 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen 0122853a4a46431a 4 8db39cbd3f6f643c +engine_matches_executor_across_checkpoints_and_reopen 0123990b3c2c4228 9 1f3c5eb0d219b224 +engine_matches_executor_across_checkpoints_and_reopen 014829292b6ba30b 78 dc4469f778fde468 +engine_matches_executor_across_checkpoints_and_reopen 014c8dda674c80a7 1 0650de74ddbdc8e4 +engine_matches_executor_across_checkpoints_and_reopen 01b4183ea20c7317 6 18674433ff6738f0 +engine_matches_executor_across_checkpoints_and_reopen 02043bde89d7fc05 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 021e48432bfe92a1 25 c6b900a17cc7d061 +engine_matches_executor_across_checkpoints_and_reopen 02225853a4ebf3ac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0239b9fff996bef9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 026f13d965a95088 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 02c76f9888ea640c 3 adfee00140c30310 +engine_matches_executor_across_checkpoints_and_reopen 02f5038f439cbded 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0325a6d23e47f3bc 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 03666cb2e92b6abe 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 03cc8ea3edba0de6 12 515b63929da42b0f +engine_matches_executor_across_checkpoints_and_reopen 03cc8ea3edba0de6 3 adfee00140c30310 +engine_matches_executor_across_checkpoints_and_reopen 03cc8ea3edba0de6 6 33227bf297dc2fac +engine_matches_executor_across_checkpoints_and_reopen 03cc8ea3edba0de6 9 5bd4e58745983525 +engine_matches_executor_across_checkpoints_and_reopen 03e45093c1cf6461 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0452867efc287fc5 65 6615a1addd482b42 +engine_matches_executor_across_checkpoints_and_reopen 0459590c1815c54f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 045962cf31c5d4a4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0469cae43f75c0c0 5 9a56e215e0e47753 +engine_matches_executor_across_checkpoints_and_reopen 047acfa349896387 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 04f568e4515c6cd5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 05106a4daa1f25c1 12 4ac858146048ec2b +engine_matches_executor_across_checkpoints_and_reopen 05106a4daa1f25c1 29 82963ded38219180 +engine_matches_executor_across_checkpoints_and_reopen 05106a4daa1f25c1 3 f56f857e49d50c9f +engine_matches_executor_across_checkpoints_and_reopen 05106a4daa1f25c1 56 e8e5957794cefc6b +engine_matches_executor_across_checkpoints_and_reopen 05106a4daa1f25c1 79 230aa079500dddae +engine_matches_executor_across_checkpoints_and_reopen 052667448c65b0aa 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 05484949324b6738 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 054c89554ab9e170 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 05732e1af84ede1d 12 39485df0c5341e49 +engine_matches_executor_across_checkpoints_and_reopen 05732e1af84ede1d 18 ce529b68cd7f17f6 +engine_matches_executor_across_checkpoints_and_reopen 05732e1af84ede1d 24 ddfb5c148ca4b8c9 +engine_matches_executor_across_checkpoints_and_reopen 05732e1af84ede1d 30 c667b808c471fe6a +engine_matches_executor_across_checkpoints_and_reopen 05732e1af84ede1d 6 0ad0488b47d1c3be +engine_matches_executor_across_checkpoints_and_reopen 05d6f7c6ae66e4b8 4 09bb376159ad3d90 +engine_matches_executor_across_checkpoints_and_reopen 05dda33b4b758b68 12 fe1675751629a00d +engine_matches_executor_across_checkpoints_and_reopen 0613943be2626516 2 af0baac2c60bd53b +engine_matches_executor_across_checkpoints_and_reopen 0617bd6c19bbc478 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 06557fda75577d51 100 444d0179a79ef317 +engine_matches_executor_across_checkpoints_and_reopen 06557fda75577d51 129 09c8d795a89a72be +engine_matches_executor_across_checkpoints_and_reopen 06557fda75577d51 153 efcd48515b3c16d2 +engine_matches_executor_across_checkpoints_and_reopen 06557fda75577d51 174 fb98192c8e6ba6b5 +engine_matches_executor_across_checkpoints_and_reopen 06557fda75577d51 65 bace5c29a4bdb5ff +engine_matches_executor_across_checkpoints_and_reopen 0659b143935b0d65 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 06642df9c21473a1 1 81e5007182b29744 +engine_matches_executor_across_checkpoints_and_reopen 067148060f4a2172 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 06aedf0b080b92e7 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 06d7819d5a1f8c17 2 043bcdf2e77e0fa5 +engine_matches_executor_across_checkpoints_and_reopen 070361d88c71ad9c 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 07196659ccdf7344 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0738b2c5cdfd5404 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 07437cd6d794bb55 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 075492556eb39b85 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 075a6d662baff8de 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 079cfc36bff196d2 5 3fabd2a839185437 +engine_matches_executor_across_checkpoints_and_reopen 07ad38fc20a2958b 200 ce5708eaab786136 +engine_matches_executor_across_checkpoints_and_reopen 07ad38fc20a2958b 387 d0ff8f0c66c1d1cb +engine_matches_executor_across_checkpoints_and_reopen 07ad38fc20a2958b 612 f944749513ce682f +engine_matches_executor_across_checkpoints_and_reopen 07ad38fc20a2958b 65 6a704160801fc391 +engine_matches_executor_across_checkpoints_and_reopen 07ad38fc20a2958b 870 e8df2d0cb7ea38e3 +engine_matches_executor_across_checkpoints_and_reopen 07c7310b72c6dd83 4 2b1e1bdf2d001b19 +engine_matches_executor_across_checkpoints_and_reopen 07da424a27a6e049 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen 07da554dc14c2f56 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 07e2d18f0fec80d8 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen 083dab14bd5e4159 8 3ad40e9a426c20da +engine_matches_executor_across_checkpoints_and_reopen 0862d78d01527159 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 089d78dc131c7375 12 e5eef43644a946e9 +engine_matches_executor_across_checkpoints_and_reopen 08b5e25a3630dd56 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 08c0a2250a85bb71 101 42052a6004d3ab3f +engine_matches_executor_across_checkpoints_and_reopen 093df22dbaf300b4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0972e23311ffad51 3 280df05b87730ad6 +engine_matches_executor_across_checkpoints_and_reopen 099b01f1b3124061 3 9277156909ee2a23 +engine_matches_executor_across_checkpoints_and_reopen 09b423d876ab8f59 3 2751db75b62b5cbe +engine_matches_executor_across_checkpoints_and_reopen 09bbc2ca862967af 8 2830fb548d86db8a +engine_matches_executor_across_checkpoints_and_reopen 0a21f0e9002db195 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 0a33b38987ea2598 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0a5a35e97e4bec43 10 ac8017774bf19f7d +engine_matches_executor_across_checkpoints_and_reopen 0a5cac8fc9674a39 4 a01af21913e40d01 +engine_matches_executor_across_checkpoints_and_reopen 0a7f7881ac8bd84d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0a9d4726d46291a7 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 0aa21d3ea28c19f7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0b048070961edde3 8 cf7ad75becdacf69 +engine_matches_executor_across_checkpoints_and_reopen 0b11e501e01e0826 95 e17b0e62f0b4d9ff +engine_matches_executor_across_checkpoints_and_reopen 0b169e79616a0f18 6 0e7421042f63c82c +engine_matches_executor_across_checkpoints_and_reopen 0b37fda71f9f3fff 1 d8054e5592aedb2e +engine_matches_executor_across_checkpoints_and_reopen 0b5415931eacb9e6 24 f292068678b09f7d +engine_matches_executor_across_checkpoints_and_reopen 0b54f32de56b59e5 10 4a316bbaa771a7fb +engine_matches_executor_across_checkpoints_and_reopen 0b54f32de56b59e5 12 89624ed133360d72 +engine_matches_executor_across_checkpoints_and_reopen 0b54f32de56b59e5 4 5c72f8882c87073a +engine_matches_executor_across_checkpoints_and_reopen 0b54f32de56b59e5 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen 0b54f32de56b59e5 8 7f2fea02558d8d74 +engine_matches_executor_across_checkpoints_and_reopen 0b61248fdcf3ab1c 2 c70b48a0fbacf660 +engine_matches_executor_across_checkpoints_and_reopen 0b61248fdcf3ab1c 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen 0b61248fdcf3ab1c 4 fff0cf5422a798f4 +engine_matches_executor_across_checkpoints_and_reopen 0b61248fdcf3ab1c 5 25fcbcdf5a3beaea +engine_matches_executor_across_checkpoints_and_reopen 0b61248fdcf3ab1c 6 285a2f89f9536571 +engine_matches_executor_across_checkpoints_and_reopen 0b751b3a3508dcc0 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 0ba9d91d16ac8ab5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0bfc5bc0d85cf582 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0c18d909d926b0f2 2 9223fa0539ed5745 +engine_matches_executor_across_checkpoints_and_reopen 0c752f067da1b6c0 34 5a093831feed4394 +engine_matches_executor_across_checkpoints_and_reopen 0d07bc7bceff1f22 34 1c6767c1b0da220b +engine_matches_executor_across_checkpoints_and_reopen 0d213eadfa3fc387 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 0d45296b2aca2608 15 f2fd3e1172b80c3a +engine_matches_executor_across_checkpoints_and_reopen 0d6c1e4bc82fa7f3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0d9cc08b67e46703 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 0dada0d812e6a835 9 41dbe62d3248875c +engine_matches_executor_across_checkpoints_and_reopen 0db7b367e7fb6312 1 d808d65592b1f81d +engine_matches_executor_across_checkpoints_and_reopen 0dc4c999be7bb5e7 12 32f4290d14c39ea9 +engine_matches_executor_across_checkpoints_and_reopen 0dc4c999be7bb5e7 18 ed71e9284ee3eada +engine_matches_executor_across_checkpoints_and_reopen 0dc4c999be7bb5e7 24 79e1d31cd9d1f6a9 +engine_matches_executor_across_checkpoints_and_reopen 0dc4c999be7bb5e7 30 a26f1cbea8b9bebe +engine_matches_executor_across_checkpoints_and_reopen 0dc4c999be7bb5e7 6 87b4f8fbb61769c2 +engine_matches_executor_across_checkpoints_and_reopen 0e0b6c2b3a2026dc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0e2e91be119fe791 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0e2e91be119fe791 3 f7c2fffb9375f5e7 +engine_matches_executor_across_checkpoints_and_reopen 0e2e91be119fe791 6 458eecda77c33287 +engine_matches_executor_across_checkpoints_and_reopen 0e485ef95f54ae20 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0e81a305d999dc40 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen 0e9c9b606a025dde 2 adcefce1bdf0c70d +engine_matches_executor_across_checkpoints_and_reopen 0eb88d15175e7752 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 0ee394feb753f55a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0f54c5f204304ea2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0f616f8b8dcc04f5 7 5ae1cdeeeba37934 +engine_matches_executor_across_checkpoints_and_reopen 0f6fbd2a4f3cc36d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0f6fbd2a4f3cc36d 3 7aa1bc07fa786255 +engine_matches_executor_across_checkpoints_and_reopen 0f6fbd2a4f3cc36d 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen 0f81ce6094200cd8 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 0fab9b58f3a55b01 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 0fb3ae726f8cccd9 12 fe1675751629a00d +engine_matches_executor_across_checkpoints_and_reopen 0fb4b1587024bc10 3 2bf04f04e1243264 +engine_matches_executor_across_checkpoints_and_reopen 1003fc8c258507d3 1 0ea3b784283ac215 +engine_matches_executor_across_checkpoints_and_reopen 101748bc06b07fb6 12 354e058f8d6dbf7f +engine_matches_executor_across_checkpoints_and_reopen 101f028f52ae2602 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 10310be9fa2f75fa 5 b25ddf4253ca8815 +engine_matches_executor_across_checkpoints_and_reopen 10aa0f58c8b10074 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 10dae0aa19225f09 30 e22fa4c18e483eca +engine_matches_executor_across_checkpoints_and_reopen 11083b7a39d09811 12 e5eef43644a946e9 +engine_matches_executor_across_checkpoints_and_reopen 11083b7a39d09811 18 25be0c7cdc625594 +engine_matches_executor_across_checkpoints_and_reopen 11083b7a39d09811 18 48b148bc08eb0b3c +engine_matches_executor_across_checkpoints_and_reopen 11083b7a39d09811 18 4afe62f84f668e3c +engine_matches_executor_across_checkpoints_and_reopen 11083b7a39d09811 3 9277156909ee2a23 +engine_matches_executor_across_checkpoints_and_reopen 113951426e5b418d 10 2871baa61cf62133 +engine_matches_executor_across_checkpoints_and_reopen 1155703c1e0812b4 16 7c8ada434af11c37 +engine_matches_executor_across_checkpoints_and_reopen 117902ffc53f45c6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 118a9615904a6459 58 27960b3098d592b9 +engine_matches_executor_across_checkpoints_and_reopen 11a93397dd96298c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 11ab748ecbe0c39e 2 a1ae4f40f66aa14a +engine_matches_executor_across_checkpoints_and_reopen 11b2dd4c602717b6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 11c04184157c1f87 12 43b7e885d6f10365 +engine_matches_executor_across_checkpoints_and_reopen 11d242d2d8411c1e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 11f52030cd2f59ae 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1210b29fe9cb5c4e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1243bc96c3c22668 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen 126a6da081cebf2f 1 58b8dd4d3d545d11 +engine_matches_executor_across_checkpoints_and_reopen 12774be719e9b3c9 12 de1ef4fdf114e5ab +engine_matches_executor_across_checkpoints_and_reopen 12c31c6cf9ce138c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 12d1bf04e04dd4bf 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 12e31217120d8b3b 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen 12f8504698759e10 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 1306a865be779f67 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1314739d04ccd55f 3 18a18852d8af9803 +engine_matches_executor_across_checkpoints_and_reopen 1315e49228f3ead7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1327ebaaa438ce0b 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 1327ebaaa438ce0b 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 1327ebaaa438ce0b 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen 1327ebaaa438ce0b 3 e6dd8deeca389e9e +engine_matches_executor_across_checkpoints_and_reopen 1327ebaaa438ce0b 3 f7e6f8edbbe1b780 +engine_matches_executor_across_checkpoints_and_reopen 134562ea28052cb5 11 eb05ea49ed16a8d0 +engine_matches_executor_across_checkpoints_and_reopen 134562ea28052cb5 3 d8dbefadddb9dc30 +engine_matches_executor_across_checkpoints_and_reopen 134562ea28052cb5 5 48270ff9f563bc99 +engine_matches_executor_across_checkpoints_and_reopen 134562ea28052cb5 7 752c17b2b4a444d4 +engine_matches_executor_across_checkpoints_and_reopen 134562ea28052cb5 9 f1f9dde166aa3e79 +engine_matches_executor_across_checkpoints_and_reopen 136de343fb44466f 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen 13830bdd7d7ea23e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 13b389a3e7e9c1f7 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen 13f03b223fe59f71 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 142e8aa7aac31ee5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 14375fd0974ca9aa 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen 1455ac0ebd6ee35b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 146bc1da0e5484fc 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 14c27b997732e21a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1501511c46053119 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1504ea5ed34008e5 6 893df393fb4dfd20 +engine_matches_executor_across_checkpoints_and_reopen 15793c7c2972dbcd 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen 15b3bf894fe7f813 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 15ee0b82cce8f2fe 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 160468808ce6a89b 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen 160468808ce6a89b 16 5d5bb8c2de25a299 +engine_matches_executor_across_checkpoints_and_reopen 160468808ce6a89b 36 af674fc80e764dd9 +engine_matches_executor_across_checkpoints_and_reopen 160468808ce6a89b 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen 160468808ce6a89b 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen 1626f40184abce51 3 07ae4731ce3b3fc3 +engine_matches_executor_across_checkpoints_and_reopen 16270854d909c6a2 29 4b25abdaf0ce6fa4 +engine_matches_executor_across_checkpoints_and_reopen 1631c068d7237ddd 125 db4d2bdc1cf0fb3c +engine_matches_executor_across_checkpoints_and_reopen 163e5d41d5814d21 9 c82b16d8a00787f0 +engine_matches_executor_across_checkpoints_and_reopen 16ade6d5af888462 5 f64b648c4a4ed56c +engine_matches_executor_across_checkpoints_and_reopen 16f650f35d025b9b 17 4b2a923567950807 +engine_matches_executor_across_checkpoints_and_reopen 171ccc349fef204c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 17c403cdab48346d 9 babe89c55f990c15 +engine_matches_executor_across_checkpoints_and_reopen 17fc63301f3bce81 2 826d132e0086ad50 +engine_matches_executor_across_checkpoints_and_reopen 17ff55c7aa1cd7c4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 180ddb4cebce50c6 3 8422728fc1519fd7 +engine_matches_executor_across_checkpoints_and_reopen 184b69b8147472a9 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen 185153268aabdcee 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1876fdeda04d6042 1 601e5bcec97f730b +engine_matches_executor_across_checkpoints_and_reopen 187df45d0299a6c7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 18a92e10d34aa6c0 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen 18bd0cb945fce33a 5 6193fcda33904ef8 +engine_matches_executor_across_checkpoints_and_reopen 19985cf7c198db9d 3 95adde3810f78a6c +engine_matches_executor_across_checkpoints_and_reopen 19ee705d7c8a2112 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 19f019340a6c525d 18 25be0c7cdc625594 +engine_matches_executor_across_checkpoints_and_reopen 1a05dfa473010581 3 47584621149b75df +engine_matches_executor_across_checkpoints_and_reopen 1a66b9405c4b91de 16 53a0dc2d990cf59c +engine_matches_executor_across_checkpoints_and_reopen 1a902ab06b4e5963 1 ff2ec67c0fc3b7aa +engine_matches_executor_across_checkpoints_and_reopen 1aca65c67e5e4053 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1acda422a7b22b36 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1acda422a7b22b36 1 601e5bcec97f730b +engine_matches_executor_across_checkpoints_and_reopen 1acda422a7b22b36 2 d502e23700df61b7 +engine_matches_executor_across_checkpoints_and_reopen 1acda422a7b22b36 4 2887891473b7ca25 +engine_matches_executor_across_checkpoints_and_reopen 1adb3071e24c7622 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 1ae59ef0baf54d21 24 79ea8703d69e7659 +engine_matches_executor_across_checkpoints_and_reopen 1b22ec416ece0a50 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 1b2439475dfbd0f9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1bbbc729f325e716 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1bf407461aaed490 9 257ff00e97b032c5 +engine_matches_executor_across_checkpoints_and_reopen 1bfe08f5cf6def09 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 1bff648a3a2cac42 25 42883a4f6e0a8432 +engine_matches_executor_across_checkpoints_and_reopen 1c561f1081c0bbec 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1c561f1081c0bbec 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen 1cc796ee1d8923f2 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 1ccaa649ab5029a7 8 ba1e04019687bed3 +engine_matches_executor_across_checkpoints_and_reopen 1ce784a500a957c3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1ceb3073cd67b7ed 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen 1cf8ea4fd12600d6 24 f292068678b09f7d +engine_matches_executor_across_checkpoints_and_reopen 1d226824a402df40 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1d43a7ffd415fce0 1 d808d65592b1f81d +engine_matches_executor_across_checkpoints_and_reopen 1d4dbdf29b1b3253 2 66eef2eb76c3791b +engine_matches_executor_across_checkpoints_and_reopen 1d60f183120c1edf 15 95bf2b0d725fa850 +engine_matches_executor_across_checkpoints_and_reopen 1d612640f335af21 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1de6854a2f873f68 25 d97492125d91d266 +engine_matches_executor_across_checkpoints_and_reopen 1e0280c7f0c5c321 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 1e084b0600bcd109 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 1e0919beb2f43d9c 11 eb05ea49ed16a8d0 +engine_matches_executor_across_checkpoints_and_reopen 1e476d4fca28fc1c 23 2336126d9c11f05f +engine_matches_executor_across_checkpoints_and_reopen 1e494f2d9a18860d 34 bab200d1618e4dd5 +engine_matches_executor_across_checkpoints_and_reopen 1e4c631d27d0ae10 112 739d921667303772 +engine_matches_executor_across_checkpoints_and_reopen 1e4c631d27d0ae10 42 c0c2aa482f9249d2 +engine_matches_executor_across_checkpoints_and_reopen 1e4c631d27d0ae10 64 13fc0d03532b7e39 +engine_matches_executor_across_checkpoints_and_reopen 1e4c631d27d0ae10 82 f53835411076ab85 +engine_matches_executor_across_checkpoints_and_reopen 1e4c631d27d0ae10 98 7cac5d3d18ebd892 +engine_matches_executor_across_checkpoints_and_reopen 1e5627056673fd8b 16 caa4a2629e02da05 +engine_matches_executor_across_checkpoints_and_reopen 1e640fc6293dfe64 5 52a1017611c8c651 +engine_matches_executor_across_checkpoints_and_reopen 1e84887c8dafc781 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1e877a9786a0f7e6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1e8fc85fa9314b67 6 125405a256c292ce +engine_matches_executor_across_checkpoints_and_reopen 1ee7333ba0d87bee 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1f0602670a99401a 12 cc2b1bdab54294bb +engine_matches_executor_across_checkpoints_and_reopen 1f351fcaa3a351a1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1f57e7bd771d04a1 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen 1fa27bfbb3d21b6c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1fa51be7ecd7e6ef 4 09bb376159ad3d90 +engine_matches_executor_across_checkpoints_and_reopen 1fa51be7ecd7e6ef 4 5dfcd2146e828f37 +engine_matches_executor_across_checkpoints_and_reopen 1fa51be7ecd7e6ef 4 acbc6d9f0c52a136 +engine_matches_executor_across_checkpoints_and_reopen 1fabd9b19d4db3ec 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 1fbca73566102685 5 ddcf853d801c97eb +engine_matches_executor_across_checkpoints_and_reopen 1fc6ad9e1011c647 18 8f5ff12b787df1ae +engine_matches_executor_across_checkpoints_and_reopen 1fc6ad9e1011c647 27 af597e5fa00c92d9 +engine_matches_executor_across_checkpoints_and_reopen 1fc6ad9e1011c647 36 5032dba31996734b +engine_matches_executor_across_checkpoints_and_reopen 1fc6ad9e1011c647 9 f66974282bfc4de4 +engine_matches_executor_across_checkpoints_and_reopen 1fec03ffd76c411d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 200209523aaa4e81 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 200a0e6e9836de69 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 201c3fe1929ed3bc 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 203d3cd0770e3eae 12 1d8ce129fc2cd61f +engine_matches_executor_across_checkpoints_and_reopen 206d1fbe99079e05 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2079607842fa3387 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 20c89517b4c0752e 1 b18871f0d59a8bc2 +engine_matches_executor_across_checkpoints_and_reopen 212b49cedac55c9d 5 8112d25c39f3a9cd +engine_matches_executor_across_checkpoints_and_reopen 214c5e48c3643f83 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2184ac9699168002 1 8c8788e481e31b2e +engine_matches_executor_across_checkpoints_and_reopen 21a5babd2bbbfd71 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 21cc8cbad89f1763 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2213223373d624a1 13 7e3f3ec8055f230c +engine_matches_executor_across_checkpoints_and_reopen 221402e38099f04f 5 92ed8a96edd4efae +engine_matches_executor_across_checkpoints_and_reopen 222229c73efd1986 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 226d41d7d86029fb 12 65a6beca2cd75161 +engine_matches_executor_across_checkpoints_and_reopen 226d41d7d86029fb 15 1f90c78e35bf414d +engine_matches_executor_across_checkpoints_and_reopen 226d41d7d86029fb 3 cd8f0522a739b22e +engine_matches_executor_across_checkpoints_and_reopen 226d41d7d86029fb 6 18674433ff6738f0 +engine_matches_executor_across_checkpoints_and_reopen 226d41d7d86029fb 9 958513356c4496a4 +engine_matches_executor_across_checkpoints_and_reopen 2285e2355a6a4678 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 22b6e6e7d100760b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 22cc7f2d46775a08 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 230e2eecfe7ebf34 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 23261723aabbb60f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 23918c11b4364008 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen 23c808c2f10873e5 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 23d401e2ba3e2c8c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 241abc5c294f499d 69 e8b35bb6c4ee67cf +engine_matches_executor_across_checkpoints_and_reopen 2426c1bf6f6d358a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 242cacefd09cce22 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen 24e11d47edbb9367 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 24e31a9b5c05e178 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 24e31a9b5c05e178 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 24e31a9b5c05e178 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen 24e31a9b5c05e178 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen 24e31a9b5c05e178 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen 24f624cb6500052e 5 aae2bd875aee1684 +engine_matches_executor_across_checkpoints_and_reopen 2595f86d6561531a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 260c377c93711e2b 5 3649b789177ca8a7 +engine_matches_executor_across_checkpoints_and_reopen 2636dc58e2ee3bec 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 264a658e1f43d812 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen 266433ad25de0555 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2666347df5a46d0a 1 d1c8bd90077e4faf +engine_matches_executor_across_checkpoints_and_reopen 2666347df5a46d0a 12 e8e12c96cf0ee98d +engine_matches_executor_across_checkpoints_and_reopen 2666347df5a46d0a 14 cd70330a35261e77 +engine_matches_executor_across_checkpoints_and_reopen 2666347df5a46d0a 2 a61a68742dc374c2 +engine_matches_executor_across_checkpoints_and_reopen 2666347df5a46d0a 7 5c0ccd63ac05e796 +engine_matches_executor_across_checkpoints_and_reopen 268987f840b3811b 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 26a2a0e4c866657e 100 990381a0d7471002 +engine_matches_executor_across_checkpoints_and_reopen 27065f987b80499a 334 2ceb873fb73556a7 +engine_matches_executor_across_checkpoints_and_reopen 272834b1ba782e47 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen 2757f79ec41a2761 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2776c204d4997c36 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 278018cbf46a3615 60 5e74e8ed3384e589 +engine_matches_executor_across_checkpoints_and_reopen 2791eb9445a3bc20 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 2791eb9445a3bc20 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen 2791eb9445a3bc20 4 ac01b96d51ed3fa3 +engine_matches_executor_across_checkpoints_and_reopen 2791eb9445a3bc20 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 2791eb9445a3bc20 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen 2794d22a9fde8337 6 a23fbe14418efb53 +engine_matches_executor_across_checkpoints_and_reopen 27a0107647b5312c 2 53fd04fb42e19abb +engine_matches_executor_across_checkpoints_and_reopen 27bdc46779ae5e23 12 5cdc20067e6e40b1 +engine_matches_executor_across_checkpoints_and_reopen 27d6b31bb626c0a3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 27dd6131c99c1228 12 43b7e885d6f10365 +engine_matches_executor_across_checkpoints_and_reopen 27dd6131c99c1228 18 3e8df8db84971c46 +engine_matches_executor_across_checkpoints_and_reopen 27dd6131c99c1228 24 bc3f0459eed80e05 +engine_matches_executor_across_checkpoints_and_reopen 27dd6131c99c1228 30 d9f2ae2d3aeb6c16 +engine_matches_executor_across_checkpoints_and_reopen 27dd6131c99c1228 6 21bff0010da6e5a2 +engine_matches_executor_across_checkpoints_and_reopen 27f93e2a87409680 9 6380498d2813d364 +engine_matches_executor_across_checkpoints_and_reopen 282e570faa5cfa74 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2854a18fcae6a518 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 28d0297448ac2796 2 3609050103036cdf +engine_matches_executor_across_checkpoints_and_reopen 28d0ca5c87b7accd 24 91bb9a8395167992 +engine_matches_executor_across_checkpoints_and_reopen 28d4d98b789205c0 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 28fb45a5b0f6b74d 8 f32673a4cbf23a30 +engine_matches_executor_across_checkpoints_and_reopen 290768110c8d9b35 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 290d2b0d0d8714c7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 291f5805a9733f98 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 293725c14f000af8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 293c881df3b2ec93 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen 296559a08ed18e39 15 d2b20a7e3382fd5a +engine_matches_executor_across_checkpoints_and_reopen 299cf8ff28e4a468 1 99bad883d8b821dd +engine_matches_executor_across_checkpoints_and_reopen 29b37b82fb7907d9 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 29cb23c66b508c8b 12 0052db137fd81fc6 +engine_matches_executor_across_checkpoints_and_reopen 29cb23c66b508c8b 12 a99b7926c6a6c397 +engine_matches_executor_across_checkpoints_and_reopen 29cb23c66b508c8b 3 8cefef79e4d610e2 +engine_matches_executor_across_checkpoints_and_reopen 29cb23c66b508c8b 6 e1753466c4728415 +engine_matches_executor_across_checkpoints_and_reopen 29cb23c66b508c8b 9 26ea09bda2041a83 +engine_matches_executor_across_checkpoints_and_reopen 29cb5ea92c2001cc 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen 2a0eff23ad0beb81 5 b14c05bd122002c3 +engine_matches_executor_across_checkpoints_and_reopen 2a6582f7daefa9a2 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen 2a6cec114d042ac2 2 2ec11106f22303e6 +engine_matches_executor_across_checkpoints_and_reopen 2a6cec114d042ac2 2 7514b511b93da0a9 +engine_matches_executor_across_checkpoints_and_reopen 2a6cec114d042ac2 2 a14f00fc126f8f18 +engine_matches_executor_across_checkpoints_and_reopen 2b5858a8b8bb4b97 8 b6c60b9b1aa6bea6 +engine_matches_executor_across_checkpoints_and_reopen 2b93010ff331a20f 3 9c0b41361d9ad4e7 +engine_matches_executor_across_checkpoints_and_reopen 2c03bcb65bd70413 49 24bd0de9f6ed8e75 +engine_matches_executor_across_checkpoints_and_reopen 2c42ea57481b1f2f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2ca3ef96af161aca 30 3f3ecd0461f8d9ca +engine_matches_executor_across_checkpoints_and_reopen 2ccc89d35f48ff0e 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 2ccfd377013ea7be 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2d083e210e8f146a 12 e8e12c96cf0ee98d +engine_matches_executor_across_checkpoints_and_reopen 2d083e210e8f146a 3 cfebdd838ce29455 +engine_matches_executor_across_checkpoints_and_reopen 2d083e210e8f146a 6 caf5fd7df73c383b +engine_matches_executor_across_checkpoints_and_reopen 2d083e210e8f146a 9 5d9a3e35cf697559 +engine_matches_executor_across_checkpoints_and_reopen 2d5200291f296293 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 2dc29926511577d7 6 125405a256c292ce +engine_matches_executor_across_checkpoints_and_reopen 2dc9cfd6dc0eb8a1 12 05e8aabfda4a4add +engine_matches_executor_across_checkpoints_and_reopen 2dc9cfd6dc0eb8a1 16 1348a20b0d70dea9 +engine_matches_executor_across_checkpoints_and_reopen 2dc9cfd6dc0eb8a1 46 ea4a0beba6a435bd +engine_matches_executor_across_checkpoints_and_reopen 2dc9cfd6dc0eb8a1 50 36da8993e4b7bc65 +engine_matches_executor_across_checkpoints_and_reopen 2dc9cfd6dc0eb8a1 60 20c72755037391ed +engine_matches_executor_across_checkpoints_and_reopen 2dcc8bdf751548e4 12 cdda145c5e817551 +engine_matches_executor_across_checkpoints_and_reopen 2dcc8bdf751548e4 3 41c2c9642f03a638 +engine_matches_executor_across_checkpoints_and_reopen 2dcc8bdf751548e4 6 125405a256c292ce +engine_matches_executor_across_checkpoints_and_reopen 2dcc8bdf751548e4 9 8fdcb97bea2d9339 +engine_matches_executor_across_checkpoints_and_reopen 2e3bcbb86a3f8d07 1 601e5acec97f7158 +engine_matches_executor_across_checkpoints_and_reopen 2e4226fd3f432809 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2e64d6b5787236ca 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2e9c3232393f4325 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2ea55dab6ed710a2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2ebd971d495fb53e 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen 2f290a75958a5ba7 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 2f5a349531a98f7f 100 2fb9bc76154f6e93 +engine_matches_executor_across_checkpoints_and_reopen 2f5f04aa662a9f9c 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 2fa45bbebdaa1cbd 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 2fa684e9f910d11d 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 2fb315859349b6de 288 4a8be4716f4351c9 +engine_matches_executor_across_checkpoints_and_reopen 2fb39d7972800e4d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 2fcd98591f1eeacb 6 5c444bd52b26befc +engine_matches_executor_across_checkpoints_and_reopen 2fd3c7a703757e99 6 c369485b5f37d49f +engine_matches_executor_across_checkpoints_and_reopen 2ff2aea9841cca95 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen 3068d7a9c659b1d2 100 cf106879b5672327 +engine_matches_executor_across_checkpoints_and_reopen 3068d7a9c659b1d2 129 e524f8b163d5a9cf +engine_matches_executor_across_checkpoints_and_reopen 3068d7a9c659b1d2 153 674eb5ea7cefb25d +engine_matches_executor_across_checkpoints_and_reopen 3068d7a9c659b1d2 174 1186c5a849bc9121 +engine_matches_executor_across_checkpoints_and_reopen 3068d7a9c659b1d2 65 1d5b390aa4bd1cda +engine_matches_executor_across_checkpoints_and_reopen 3076785bb1ebef77 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 30981417c47b3e81 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 30e8823bcacfa913 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 312ea446bd64e8a9 12 39485df0c5341e49 +engine_matches_executor_across_checkpoints_and_reopen 31a371e835198598 15 a74ff5ea6e6114d6 +engine_matches_executor_across_checkpoints_and_reopen 31a854ebd4cda015 64 df515aaf301e337a +engine_matches_executor_across_checkpoints_and_reopen 320264133e623810 9 f66974282bfc4de4 +engine_matches_executor_across_checkpoints_and_reopen 326a47fb70d4e447 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 329be71c4d9b96ca 6 d4c5192cd4d89a96 +engine_matches_executor_across_checkpoints_and_reopen 32a3ef8553af4236 188 f58ef6820a393b60 +engine_matches_executor_across_checkpoints_and_reopen 32a3ef8553af4236 363 3de4dea94af26d3f +engine_matches_executor_across_checkpoints_and_reopen 32a3ef8553af4236 580 27cb60e407134434 +engine_matches_executor_across_checkpoints_and_reopen 32a3ef8553af4236 61 f596bab0c6202a59 +engine_matches_executor_across_checkpoints_and_reopen 32a3ef8553af4236 830 fdde82d40c7791e6 +engine_matches_executor_across_checkpoints_and_reopen 32daf09370e49cb1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 331f9ecba0c566ac 100 68bade370efca39f +engine_matches_executor_across_checkpoints_and_reopen 332a483c0f56e81a 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 33a77a7550f69123 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen 33b10d1b04615d6b 3 f3dd195b655a762c +engine_matches_executor_across_checkpoints_and_reopen 33f732ea354534e3 1 d808d65592b1f81d +engine_matches_executor_across_checkpoints_and_reopen 34086781bbdc301d 150 5798decf5a8c4672 +engine_matches_executor_across_checkpoints_and_reopen 34086781bbdc301d 24 398d4019728a360d +engine_matches_executor_across_checkpoints_and_reopen 34086781bbdc301d 54 238393ae1b86e9a2 +engine_matches_executor_across_checkpoints_and_reopen 34086781bbdc301d 6 4c599e6ab6611a56 +engine_matches_executor_across_checkpoints_and_reopen 34086781bbdc301d 96 175ce787cc729ebd +engine_matches_executor_across_checkpoints_and_reopen 344f63db3a51c135 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 34a4e0c22d9a8a09 15 d77b91b2d475887d +engine_matches_executor_across_checkpoints_and_reopen 34f7e29a03bf80e5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 356227e15689fc7e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 356adc5e95423fc8 100 aa4bbb66c140d197 +engine_matches_executor_across_checkpoints_and_reopen 3579aee733c1eb96 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 35af1a6fc5a85836 9 41dbe62d3248875c +engine_matches_executor_across_checkpoints_and_reopen 35d3d9eccf3390b5 6 9d8524af4f9c2c3f +engine_matches_executor_across_checkpoints_and_reopen 35f323e99b9b413f 10 475851473d15ec7d +engine_matches_executor_across_checkpoints_and_reopen 35f323e99b9b413f 12 bef3f4c3c41f7bf6 +engine_matches_executor_across_checkpoints_and_reopen 35f323e99b9b413f 2 3cba14159b036c4c +engine_matches_executor_across_checkpoints_and_reopen 35f323e99b9b413f 4 e3a3e48200a0a5fc +engine_matches_executor_across_checkpoints_and_reopen 35f323e99b9b413f 7 4b5390923ba91818 +engine_matches_executor_across_checkpoints_and_reopen 360a251bfc9f114b 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 3646f64c5eb7a548 3 fe47719e9e67fad8 +engine_matches_executor_across_checkpoints_and_reopen 3671a9a07c635518 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen 3692403df6102ea3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3703c3f98fd0d283 12 2586c30d824a4ccb +engine_matches_executor_across_checkpoints_and_reopen 3703c3f98fd0d283 16 53a0dc2d990cf59c +engine_matches_executor_across_checkpoints_and_reopen 3703c3f98fd0d283 20 cd1058e47a05ae3b +engine_matches_executor_across_checkpoints_and_reopen 3703c3f98fd0d283 4 54ed403bcdfba5c9 +engine_matches_executor_across_checkpoints_and_reopen 3703c3f98fd0d283 8 2a06eb7fa1c21e28 +engine_matches_executor_across_checkpoints_and_reopen 3706e122bbffef74 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 37967480f1bb520d 49 1b6e19dc8350b662 +engine_matches_executor_across_checkpoints_and_reopen 37aa7219c4807598 3 6ce05a9057f2cc35 +engine_matches_executor_across_checkpoints_and_reopen 37c29f6d5bccaa6b 6 7ef9f5fd2b670626 +engine_matches_executor_across_checkpoints_and_reopen 37c96d0221fcbd59 141 7937f65787dd36ef +engine_matches_executor_across_checkpoints_and_reopen 389068644c055fd6 8 e45322fcaa3f56d0 +engine_matches_executor_across_checkpoints_and_reopen 3897230e3183c8c9 9 f4d27fdfca1c0fb8 +engine_matches_executor_across_checkpoints_and_reopen 38c35d9a872a1989 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 38d627c135e7c018 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 38dd33115e7524c6 8 ca97cd70dde8c072 +engine_matches_executor_across_checkpoints_and_reopen 390b44da3f430053 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen 3915195fe66fe44a 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 392530b5bacf0631 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 39574aca21fc26d9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 395924cf6109e36c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 397075f16b6ad8ad 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 397075f16b6ad8ad 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen 397075f16b6ad8ad 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 397075f16b6ad8ad 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen 397075f16b6ad8ad 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen 39c81a29ba48a38c 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen 3a23bed37a4dbdd7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3a23d0261aef4168 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 3a3ff8d1cbd40b22 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3a4318aa0173749a 6 5aa7420496fc37bc +engine_matches_executor_across_checkpoints_and_reopen 3a773143d3af1a25 116 580fe354de3c0eb7 +engine_matches_executor_across_checkpoints_and_reopen 3a83ee23d181b81a 22 923cbb4b62706672 +engine_matches_executor_across_checkpoints_and_reopen 3a8b0266d4a5d19c 12 e8ee335a6003b271 +engine_matches_executor_across_checkpoints_and_reopen 3a8b0266d4a5d19c 18 4b962f179874ce46 +engine_matches_executor_across_checkpoints_and_reopen 3a8b0266d4a5d19c 24 d525d644807968c9 +engine_matches_executor_across_checkpoints_and_reopen 3a8b0266d4a5d19c 30 a55f38247fb45626 +engine_matches_executor_across_checkpoints_and_reopen 3a8b0266d4a5d19c 6 64d778a92d95baa6 +engine_matches_executor_across_checkpoints_and_reopen 3ab268c7724a7638 5 da1608b3ec41e922 +engine_matches_executor_across_checkpoints_and_reopen 3ab85975eead4d7d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3ab85975eead4d7d 3 66f719885e592e8a +engine_matches_executor_across_checkpoints_and_reopen 3ad74dc8ec3be4ec 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3adb2e1eabeabc5b 5 f732dc62a7ed825d +engine_matches_executor_across_checkpoints_and_reopen 3adc1db2b48ed06f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3b75a1473812b914 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3ba9cc2762fd870e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3be7ed142bfa2af1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3bffd76ced7ff199 3 7aa1bc07fa786255 +engine_matches_executor_across_checkpoints_and_reopen 3c184a7b642508a1 16 438be19255feff2a +engine_matches_executor_across_checkpoints_and_reopen 3c45d4600a798744 150 38bded9076ceb5e9 +engine_matches_executor_across_checkpoints_and_reopen 3c45d4600a798744 24 1ee2038ee883f25d +engine_matches_executor_across_checkpoints_and_reopen 3c45d4600a798744 54 ab14bf2f996957a7 +engine_matches_executor_across_checkpoints_and_reopen 3c45d4600a798744 6 7c029f89e9a90a65 +engine_matches_executor_across_checkpoints_and_reopen 3c45d4600a798744 96 689cd81e1b638a19 +engine_matches_executor_across_checkpoints_and_reopen 3c751284c2df46f1 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen 3c751284c2df46f1 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 3c7f6eaa81db7191 12 5507e9eba629875d +engine_matches_executor_across_checkpoints_and_reopen 3c95a8a4da6bf1b5 1 d1f214b56944841f +engine_matches_executor_across_checkpoints_and_reopen 3cccc0a2c68a1d33 6 4caf4e58d2f71a3d +engine_matches_executor_across_checkpoints_and_reopen 3cd3d9351d5ba020 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 3cd3d9351d5ba020 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen 3cd3d9351d5ba020 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 3cd3d9351d5ba020 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen 3cd3d9351d5ba020 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen 3d23511625919d1d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3d303ca6b0978f94 6 a105ddcda2d05dfb +engine_matches_executor_across_checkpoints_and_reopen 3d97e89ed79ab936 2 385fb2b8c73258ed +engine_matches_executor_across_checkpoints_and_reopen 3e06b4760c71daf4 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 3e395cc3b0f1a353 8 3ad40e9a426c20da +engine_matches_executor_across_checkpoints_and_reopen 3e3dce49c2561a99 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3e9a7974fed0db68 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3ebb1216fedd3c1f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3ec27c3f984f3e67 321 72cbc11e0d841e0a +engine_matches_executor_across_checkpoints_and_reopen 3ed34b382d19dcbb 16 7c8ada434af11c37 +engine_matches_executor_across_checkpoints_and_reopen 3eedfbf3bc1291ad 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3f0091c49c106d73 6 0ad0488b47d1c3be +engine_matches_executor_across_checkpoints_and_reopen 3f012731d679aa50 24 d525d644807968c9 +engine_matches_executor_across_checkpoints_and_reopen 3f1c8ff9d3312034 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 3f21f23a08d87368 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3f3e6d2c23c91dea 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3f46c0b18a5d6222 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 3fda20338ef442f9 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 4012d185a25dc295 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 40249373e2cf9449 150 bac33a7b360bba60 +engine_matches_executor_across_checkpoints_and_reopen 40249373e2cf9449 24 5b53e79e8bcbab81 +engine_matches_executor_across_checkpoints_and_reopen 40249373e2cf9449 54 f79c6bd42108b8ea +engine_matches_executor_across_checkpoints_and_reopen 40249373e2cf9449 6 70831860fa875f4c +engine_matches_executor_across_checkpoints_and_reopen 40249373e2cf9449 96 04e08083113c9801 +engine_matches_executor_across_checkpoints_and_reopen 404a2b761af148bf 12 ac5efaf6e4bfe009 +engine_matches_executor_across_checkpoints_and_reopen 405f28035a6f9d25 1 99bad883d8b821dd +engine_matches_executor_across_checkpoints_and_reopen 405fe0745e16fa64 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 40779a562b0897e7 1 592e65f36322ea3b +engine_matches_executor_across_checkpoints_and_reopen 408b8d9fae88b346 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 40d31f6055fae0ef 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 40d8edb4b856f9bf 8 4a85e8b440bd9ee8 +engine_matches_executor_across_checkpoints_and_reopen 40d907bfa487a51f 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen 41300cf29328b231 1 fb5cc1e4287b2e07 +engine_matches_executor_across_checkpoints_and_reopen 413760218c503d1d 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen 413a5062b0f8a72f 22 4e5ed6d56ccfb19a +engine_matches_executor_across_checkpoints_and_reopen 415f98e3c227166d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 41677ca7b78a4788 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4179242f8b21c62a 3 0e21b8240d44401a +engine_matches_executor_across_checkpoints_and_reopen 41a65398beb45007 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 41c79a3ea0deb0c9 12 e5eef43644a946e9 +engine_matches_executor_across_checkpoints_and_reopen 41d18c3547754a1e 2 adcefce1bdf0c70d +engine_matches_executor_across_checkpoints_and_reopen 42334bbc58c2ae24 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen 424118bfff8b7e7d 3 138f357547a401df +engine_matches_executor_across_checkpoints_and_reopen 424118bfff8b7e7d 6 d7264077dca1890a +engine_matches_executor_across_checkpoints_and_reopen 424118bfff8b7e7d 9 688d36349666ae5e +engine_matches_executor_across_checkpoints_and_reopen 424118bfff8b7e7d 9 76b7e537eae2e54d +engine_matches_executor_across_checkpoints_and_reopen 424118bfff8b7e7d 9 aafd9c32b0609d82 +engine_matches_executor_across_checkpoints_and_reopen 426830890f9b01eb 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 427d6222b15b041b 15 1f90c78e35bf414d +engine_matches_executor_across_checkpoints_and_reopen 42b728c86f10bcb6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 42d3731076c21e7b 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 4342231042a99ecc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 435826e30856426e 16 caa4a2629e02da05 +engine_matches_executor_across_checkpoints_and_reopen 435eb563a2478c3b 6 7c029f89e9a90a65 +engine_matches_executor_across_checkpoints_and_reopen 438a6f8a3601fb92 12 bef3f4c3c41f7bf6 +engine_matches_executor_across_checkpoints_and_reopen 439c4aba3a3b33f6 5 0b2a7003b5c64b14 +engine_matches_executor_across_checkpoints_and_reopen 439c5ec8fe9f460a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 43cc7940889ba19d 186 c1fe683502536faf +engine_matches_executor_across_checkpoints_and_reopen 43cc7940889ba19d 290 43956a6c503c4821 +engine_matches_executor_across_checkpoints_and_reopen 43cc7940889ba19d 332 244946b0d2bd8111 +engine_matches_executor_across_checkpoints_and_reopen 43cc7940889ba19d 35 385d33c590361697 +engine_matches_executor_across_checkpoints_and_reopen 43cc7940889ba19d 94 43d78c9c8a8ec60c +engine_matches_executor_across_checkpoints_and_reopen 43d48ef090b4c7b0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 441aa40eab74b10f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 44307b48e472ce84 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen 4466c0aca35a7a54 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4477b9688742e884 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen 447be16fb201dcee 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 450d1efde88c6f9a 3 2bf04f04e1243264 +engine_matches_executor_across_checkpoints_and_reopen 452c66db1e8be14c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 452f413d3911e2d7 30 d9f2ae2d3aeb6c16 +engine_matches_executor_across_checkpoints_and_reopen 456e6500b5a18d46 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 459843d6af5a4bf8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 45b24a7a93fab4ea 1 d808d65592b1f81d +engine_matches_executor_across_checkpoints_and_reopen 45b24a7a93fab4ea 2 adcefce1bdf0c70d +engine_matches_executor_across_checkpoints_and_reopen 45b24a7a93fab4ea 3 0e21b8240d44401a +engine_matches_executor_across_checkpoints_and_reopen 45b24a7a93fab4ea 6 22bb81d1b9f9b552 +engine_matches_executor_across_checkpoints_and_reopen 45b24a7a93fab4ea 6 d5f19d03cc6edea3 +engine_matches_executor_across_checkpoints_and_reopen 45d9672c31744a6c 12 e5eef43644a946e9 +engine_matches_executor_across_checkpoints_and_reopen 45d9672c31744a6c 18 25be0c7cdc625594 +engine_matches_executor_across_checkpoints_and_reopen 45d9672c31744a6c 18 48b148bc08eb0b3c +engine_matches_executor_across_checkpoints_and_reopen 45d9672c31744a6c 18 4afe62f84f668e3c +engine_matches_executor_across_checkpoints_and_reopen 45d9672c31744a6c 3 9277156909ee2a23 +engine_matches_executor_across_checkpoints_and_reopen 45e0ac3a147e3d68 9 870eb89cd61e8f42 +engine_matches_executor_across_checkpoints_and_reopen 45fc4a127bc25abc 1 d1c8bd90077e4faf +engine_matches_executor_across_checkpoints_and_reopen 45fc8a2e66e30322 12 4ac858146048ec2b +engine_matches_executor_across_checkpoints_and_reopen 45fc8a2e66e30322 29 82963ded38219180 +engine_matches_executor_across_checkpoints_and_reopen 45fc8a2e66e30322 3 f56f857e49d50c9f +engine_matches_executor_across_checkpoints_and_reopen 45fc8a2e66e30322 56 e8e5957794cefc6b +engine_matches_executor_across_checkpoints_and_reopen 45fc8a2e66e30322 79 230aa079500dddae +engine_matches_executor_across_checkpoints_and_reopen 460d12c9efe947c4 4 9bb94d523b910521 +engine_matches_executor_across_checkpoints_and_reopen 461f6e4ed8027e02 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 46c70320de5d2948 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 46d60ffdee3157f9 10 4fc8321d6407a10f +engine_matches_executor_across_checkpoints_and_reopen 47130a3fa99fb40c 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen 47538798942ef7e0 1 57c34273beddeb94 +engine_matches_executor_across_checkpoints_and_reopen 4761a88f0d9d2a96 2 a61a68742dc374c2 +engine_matches_executor_across_checkpoints_and_reopen 47ce237e51f238b6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 481b80fec7debc97 3 f56f857e49d50c9f +engine_matches_executor_across_checkpoints_and_reopen 48aba04199a00a81 5 df60777b351368aa +engine_matches_executor_across_checkpoints_and_reopen 48b20d3c2ed20d09 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 48b4f38f27e88fab 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen 48b8853738321efa 2 ec5bb16de3d23be2 +engine_matches_executor_across_checkpoints_and_reopen 490902404b51d32b 5 f74e4a6ac6857a8a +engine_matches_executor_across_checkpoints_and_reopen 49c0d48bf7d14a0e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4a0d1438918c9be1 10 39c3951ae27d56f7 +engine_matches_executor_across_checkpoints_and_reopen 4a0d1438918c9be1 10 4fea6fdd630c38b4 +engine_matches_executor_across_checkpoints_and_reopen 4a0d1438918c9be1 10 61786662a674d441 +engine_matches_executor_across_checkpoints_and_reopen 4a12b2df43f651bf 13 1e143a7320c80705 +engine_matches_executor_across_checkpoints_and_reopen 4a26a15caee78dc1 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen 4a2febccf8837aad 3 41c2c9642f03a638 +engine_matches_executor_across_checkpoints_and_reopen 4a7c8e66d64e490b 2 b8ff948a4274c70c +engine_matches_executor_across_checkpoints_and_reopen 4a93b59a6a98f056 1 ff2ec67c0fc3b7aa +engine_matches_executor_across_checkpoints_and_reopen 4a977e0981408e98 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4ac379418e942a60 9 21473d56862e061e +engine_matches_executor_across_checkpoints_and_reopen 4ac727c3cc95072d 24 1ee2038ee883f25d +engine_matches_executor_across_checkpoints_and_reopen 4acc3e5e89af8238 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4adaeb72411c41ed 3 a7639882cbc1e5b3 +engine_matches_executor_across_checkpoints_and_reopen 4b1996a946cd636d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4b326e2aae84a5b7 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen 4b338e3b4c026854 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4b7b6f5439d86c11 2 adcefce1bdf0c70d +engine_matches_executor_across_checkpoints_and_reopen 4bfbb1e651196a10 6 e5d5753f75b888bc +engine_matches_executor_across_checkpoints_and_reopen 4c2b9e144aa44fa1 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 4c2fea6bcb6b72a6 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen 4c5c56c80ab17341 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4cab38a29fda3d2d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4cb356d57fa0fb2b 12 05e8aabfda4a4add +engine_matches_executor_across_checkpoints_and_reopen 4ccf834dfbaef87a 1 76b48d54dad1a495 +engine_matches_executor_across_checkpoints_and_reopen 4cfb3551008e07c3 2 91354be013e1f0bb +engine_matches_executor_across_checkpoints_and_reopen 4d34a90cb1bf6ad4 12 4195c35bf5c5e653 +engine_matches_executor_across_checkpoints_and_reopen 4d34a90cb1bf6ad4 18 d35a70bbe2914d78 +engine_matches_executor_across_checkpoints_and_reopen 4d34a90cb1bf6ad4 24 15b07d178224c4f5 +engine_matches_executor_across_checkpoints_and_reopen 4d34a90cb1bf6ad4 30 f586815c1b95bf1a +engine_matches_executor_across_checkpoints_and_reopen 4d34a90cb1bf6ad4 6 52a4ac892f494396 +engine_matches_executor_across_checkpoints_and_reopen 4d3ccb473047a253 8 7dc5b17501687d70 +engine_matches_executor_across_checkpoints_and_reopen 4db0ebefc339fc68 7 752c17b2b4a444d4 +engine_matches_executor_across_checkpoints_and_reopen 4e072f3916542d64 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 4e106632557a0407 1 601e5bcec97f730b +engine_matches_executor_across_checkpoints_and_reopen 4e294fc9d113d7c3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4e8f0bb75d8ae86b 12 1d8ce129fc2cd61f +engine_matches_executor_across_checkpoints_and_reopen 4e8f0bb75d8ae86b 12 6f4db756ffcd32d5 +engine_matches_executor_across_checkpoints_and_reopen 4e8f0bb75d8ae86b 6 5bcff50d2a29af85 +engine_matches_executor_across_checkpoints_and_reopen 4ec97c7cabf5dd91 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4ee5908a8ea65449 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4ee87d59da70faae 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4ee87d59da70faae 3 7aa1bc07fa786255 +engine_matches_executor_across_checkpoints_and_reopen 4ee87d59da70faae 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen 4f0693e42d8bedb0 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 4f1e0da12317c928 12 6c2473739f72d811 +engine_matches_executor_across_checkpoints_and_reopen 4f1e0da12317c928 16 0c62dcbe78642f82 +engine_matches_executor_across_checkpoints_and_reopen 4f1e0da12317c928 20 2b80d4f7701aaa9a +engine_matches_executor_across_checkpoints_and_reopen 4f1e0da12317c928 4 a44e29a1993850ce +engine_matches_executor_across_checkpoints_and_reopen 4f1e0da12317c928 8 3157ba75e536ac9e +engine_matches_executor_across_checkpoints_and_reopen 4f2f9be6f47225ff 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4f797a443909e75f 12 476309068ae10adc +engine_matches_executor_across_checkpoints_and_reopen 4f797a443909e75f 16 7c8ada434af11c37 +engine_matches_executor_across_checkpoints_and_reopen 4f797a443909e75f 23 2336126d9c11f05f +engine_matches_executor_across_checkpoints_and_reopen 4f797a443909e75f 25 8683362928dc5c61 +engine_matches_executor_across_checkpoints_and_reopen 4f797a443909e75f 30 8119bb1908bd7c48 +engine_matches_executor_across_checkpoints_and_reopen 4fc1a2d1a4bc5928 6 c369485b5f37d49f +engine_matches_executor_across_checkpoints_and_reopen 4ff38e0db318ffd7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 4ff38e0db318ffd7 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen 503073032cb89195 9 5a01f0e6b5148228 +engine_matches_executor_across_checkpoints_and_reopen 5061a0a86ce16c71 9 4f4c57ec96f57cb1 +engine_matches_executor_across_checkpoints_and_reopen 5087b1d9f6a70245 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 50928aeacdcd36d0 1 69d34b0102501287 +engine_matches_executor_across_checkpoints_and_reopen 50accca8f592f5e1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5114ac5e73621c03 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen 511f2a2e26502f0b 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen 5126ac0dbc911cd4 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 5226c768b367d026 6 caf5fd7df73c383b +engine_matches_executor_across_checkpoints_and_reopen 522da55cf93600f1 6 44fcf5430afde7a2 +engine_matches_executor_across_checkpoints_and_reopen 522f2c61cdba72b4 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen 52522e4f9bf8ee12 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 527044153f8750f0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 539225843600e494 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 539225843600e494 1 a5597ef1b58ef469 +engine_matches_executor_across_checkpoints_and_reopen 539225843600e494 2 ca45b8e68eb2899e +engine_matches_executor_across_checkpoints_and_reopen 53a110c4d6776505 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 53b1eeaa255e1cd9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 53cf1da2f5cc578b 12 5cdc20067e6e40b1 +engine_matches_executor_across_checkpoints_and_reopen 53cf1da2f5cc578b 3 280df05b87730ad6 +engine_matches_executor_across_checkpoints_and_reopen 53cf1da2f5cc578b 6 d7e0f8ed096cb869 +engine_matches_executor_across_checkpoints_and_reopen 53cf1da2f5cc578b 9 cc451edf7c407500 +engine_matches_executor_across_checkpoints_and_reopen 53d419ddec5fc841 10 a8b4d60d94b116bf +engine_matches_executor_across_checkpoints_and_reopen 53d7cfa3f686be01 5 0bf9300a4723ee9c +engine_matches_executor_across_checkpoints_and_reopen 53e6669447d85764 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 53e6669447d85764 27 04eefaef424c5524 +engine_matches_executor_across_checkpoints_and_reopen 53e6669447d85764 54 757d25d2570e0eb9 +engine_matches_executor_across_checkpoints_and_reopen 53e6669447d85764 9 dc0e89f9c7e2c31a +engine_matches_executor_across_checkpoints_and_reopen 53edbac83e4b9306 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 53edbac83e4b9306 3 f7c2fffb9375f5e7 +engine_matches_executor_across_checkpoints_and_reopen 53edbac83e4b9306 6 458eecda77c33287 +engine_matches_executor_across_checkpoints_and_reopen 5418835b0cde0d2e 3 fd4ab9da21ba5524 +engine_matches_executor_across_checkpoints_and_reopen 541bf866cc66c25e 9 009ea355574d2996 +engine_matches_executor_across_checkpoints_and_reopen 542e756364b84a9c 2 bce273c5c5e3697e +engine_matches_executor_across_checkpoints_and_reopen 5442d62580dbb17a 1 d8054e5592aedb2e +engine_matches_executor_across_checkpoints_and_reopen 5442d62580dbb17a 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 5442d62580dbb17a 3 561ee1995d21aa56 +engine_matches_executor_across_checkpoints_and_reopen 5442d62580dbb17a 4 e96cb5244cf0840e +engine_matches_executor_across_checkpoints_and_reopen 5442d62580dbb17a 5 ba124444c138d9e1 +engine_matches_executor_across_checkpoints_and_reopen 5468d1a5a2962796 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 548426350b5c63ab 1 81849d16bd6e9bae +engine_matches_executor_across_checkpoints_and_reopen 548ebbfb267459ed 12 6d5f0f6a2721b39d +engine_matches_executor_across_checkpoints_and_reopen 548ebbfb267459ed 16 caa4a2629e02da05 +engine_matches_executor_across_checkpoints_and_reopen 548ebbfb267459ed 21 6e875f66cdb85b48 +engine_matches_executor_across_checkpoints_and_reopen 548ebbfb267459ed 24 2f572bfe8ff4d435 +engine_matches_executor_across_checkpoints_and_reopen 548ebbfb267459ed 29 4b25abdaf0ce6fa4 +engine_matches_executor_across_checkpoints_and_reopen 5495de1b4b161091 2 a8bc450894057987 +engine_matches_executor_across_checkpoints_and_reopen 54bf1753779e6fd0 5 52a1017611c8c651 +engine_matches_executor_across_checkpoints_and_reopen 54d718419e07e34d 65 a241e85840ee1c32 +engine_matches_executor_across_checkpoints_and_reopen 54f010c787757bd8 3 afbb45863a4e333b +engine_matches_executor_across_checkpoints_and_reopen 54f0f8e62215590a 84 bb342e7116e73ffb +engine_matches_executor_across_checkpoints_and_reopen 54f5e16c1015d097 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 551b8578c63c9dec 12 06dba2c2b98ae181 +engine_matches_executor_across_checkpoints_and_reopen 551b8578c63c9dec 3 28e71fda4c1b5f3a +engine_matches_executor_across_checkpoints_and_reopen 551b8578c63c9dec 6 16da1375f2a94a82 +engine_matches_executor_across_checkpoints_and_reopen 551b8578c63c9dec 9 a701ba03bb360259 +engine_matches_executor_across_checkpoints_and_reopen 55352678e4e669f5 2 c70b48a0fbacf660 +engine_matches_executor_across_checkpoints_and_reopen 55352678e4e669f5 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen 55352678e4e669f5 4 fff0cf5422a798f4 +engine_matches_executor_across_checkpoints_and_reopen 55352678e4e669f5 5 25fcbcdf5a3beaea +engine_matches_executor_across_checkpoints_and_reopen 55352678e4e669f5 6 285a2f89f9536571 +engine_matches_executor_across_checkpoints_and_reopen 5565fc163a11f282 6 d5f19d03cc6edea3 +engine_matches_executor_across_checkpoints_and_reopen 55885d7fa8fee5d1 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen 55a1ae50c751a9b6 12 65a6beca2cd75161 +engine_matches_executor_across_checkpoints_and_reopen 55a1ae50c751a9b6 15 1f90c78e35bf414d +engine_matches_executor_across_checkpoints_and_reopen 55a1ae50c751a9b6 3 cd8f0522a739b22e +engine_matches_executor_across_checkpoints_and_reopen 55a1ae50c751a9b6 6 18674433ff6738f0 +engine_matches_executor_across_checkpoints_and_reopen 55a1ae50c751a9b6 9 958513356c4496a4 +engine_matches_executor_across_checkpoints_and_reopen 55a9a02c38deaad5 3 70368f01fac86498 +engine_matches_executor_across_checkpoints_and_reopen 55b49ccf4aedf497 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 55f1536afc7b06f7 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 55ffc8cc2e36c8a9 2 8d46e0730917a88f +engine_matches_executor_across_checkpoints_and_reopen 5609919d406e7621 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 564756437880f649 63 0d33e7366b471c33 +engine_matches_executor_across_checkpoints_and_reopen 56bc11b4c69f8e76 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen 56bf83c2cb1a6f98 11 eb05ea49ed16a8d0 +engine_matches_executor_across_checkpoints_and_reopen 56bf83c2cb1a6f98 3 d8dbefadddb9dc30 +engine_matches_executor_across_checkpoints_and_reopen 56bf83c2cb1a6f98 5 48270ff9f563bc99 +engine_matches_executor_across_checkpoints_and_reopen 56bf83c2cb1a6f98 7 752c17b2b4a444d4 +engine_matches_executor_across_checkpoints_and_reopen 56bf83c2cb1a6f98 9 f1f9dde166aa3e79 +engine_matches_executor_across_checkpoints_and_reopen 5708c5497e75e376 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 5743b6a2f8dd85c0 8 5cb39cc2f644acc6 +engine_matches_executor_across_checkpoints_and_reopen 574656b02e25dd6e 5 455f52009bf64fdc +engine_matches_executor_across_checkpoints_and_reopen 5797777ee8ce2ea4 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 57cc3e3c93c9ee6d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 57fa0fb75c4f9a88 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 5869f049c86d35ce 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 586d4985b4cf7f6b 16 b2c8e8e25939ab99 +engine_matches_executor_across_checkpoints_and_reopen 587abd06384f30e4 6 c4d6b299634ec196 +engine_matches_executor_across_checkpoints_and_reopen 5881c4a371536cfc 8 b7a87fd95284d368 +engine_matches_executor_across_checkpoints_and_reopen 58bc72995ffbe593 15 fecd979738824bb5 +engine_matches_executor_across_checkpoints_and_reopen 58d3d452d78e0d50 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 58d3d452d78e0d50 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen 58d3d452d78e0d50 4 ac01b96d51ed3fa3 +engine_matches_executor_across_checkpoints_and_reopen 58d3d452d78e0d50 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 58d3d452d78e0d50 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen 5902230df3e0fdd1 1 088eab074d14a11a +engine_matches_executor_across_checkpoints_and_reopen 5921504ccde3bc49 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 59b8c1fe6d42b89d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 59d99fa47aeeef2b 3 f7e6f8edbbe1b780 +engine_matches_executor_across_checkpoints_and_reopen 59f7407f7d22eeb9 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 5a027bb225d0b18b 13 8ff5451c277a99a2 +engine_matches_executor_across_checkpoints_and_reopen 5a29d253cecc9eb5 16 9068935ea5556dd1 +engine_matches_executor_across_checkpoints_and_reopen 5a29d253cecc9eb5 36 7650a3ad4ff15551 +engine_matches_executor_across_checkpoints_and_reopen 5a29d253cecc9eb5 4 2b1e1bdf2d001b19 +engine_matches_executor_across_checkpoints_and_reopen 5a2c72580a6acd44 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5a33fb5c7dbbcc0d 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen 5a6a6f174f6a279d 8 c5df19a173d7ea6b +engine_matches_executor_across_checkpoints_and_reopen 5a8a89013acc2bc1 1 d8054e5592aedb2e +engine_matches_executor_across_checkpoints_and_reopen 5a9ba4a2c251e41f 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 5aed437c70f83ddd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5b1260d27807b5bd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5b3de7174962d355 4 e96cb5244cf0840e +engine_matches_executor_across_checkpoints_and_reopen 5b433788e25e9555 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5b5d1fdde8d9c157 12 4a028e9cdab9279f +engine_matches_executor_across_checkpoints_and_reopen 5b5d1fdde8d9c157 12 ce726a87afa893a8 +engine_matches_executor_across_checkpoints_and_reopen 5b5d1fdde8d9c157 3 47584621149b75df +engine_matches_executor_across_checkpoints_and_reopen 5b5d1fdde8d9c157 6 40a7aac6b4fe7cee +engine_matches_executor_across_checkpoints_and_reopen 5b5d1fdde8d9c157 9 a150fde7b0f4d9b1 +engine_matches_executor_across_checkpoints_and_reopen 5bf2c53b65bf2281 3 cd8f0522a739b22e +engine_matches_executor_across_checkpoints_and_reopen 5c0a0ca0f8880e5e 1 d1c8bd90077e4faf +engine_matches_executor_across_checkpoints_and_reopen 5c5619aa9bf252d0 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen 5c5a69e46978b56c 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 5c7143c05ddf1ef2 6 72ce49ac42ed5e77 +engine_matches_executor_across_checkpoints_and_reopen 5cf067f0e76a5f0d 2 e14809bc41fd6490 +engine_matches_executor_across_checkpoints_and_reopen 5d12513f719c0dd2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5d2985b5ebe37f3e 95 cab7b4a902104dca +engine_matches_executor_across_checkpoints_and_reopen 5d5b1f4282236d90 9 f1f9dde166aa3e79 +engine_matches_executor_across_checkpoints_and_reopen 5d6d092decc3f66a 3 0709e1530c9e69e6 +engine_matches_executor_across_checkpoints_and_reopen 5d7f3107af6ea22e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5e39abd336588750 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5e65fcb2bebf6ae9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5e7efef3eb1d1419 150 5798decf5a8c4672 +engine_matches_executor_across_checkpoints_and_reopen 5ee17d529f79f418 2 4ac6fbb661ab1b38 +engine_matches_executor_across_checkpoints_and_reopen 5ee599f895c07ba1 54 757d25d2570e0eb9 +engine_matches_executor_across_checkpoints_and_reopen 5efa048cce7b98b4 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 5f09671d51dc6c37 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5f1a868c0e46c777 4 c46ec3c90fc731c4 +engine_matches_executor_across_checkpoints_and_reopen 5f1a868c0e46c777 6 6451f224b48e8ac8 +engine_matches_executor_across_checkpoints_and_reopen 5f1a868c0e46c777 8 86f62784e40de2a9 +engine_matches_executor_across_checkpoints_and_reopen 5f1a868c0e46c777 8 ba31a3187118f96f +engine_matches_executor_across_checkpoints_and_reopen 5f1a868c0e46c777 8 c1d5f977e9899fca +engine_matches_executor_across_checkpoints_and_reopen 5f20c9520439c350 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5f4bcf73a9364981 2 c70b48a0fbacf660 +engine_matches_executor_across_checkpoints_and_reopen 5f5feb889d17423b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5f8e5bc96014c92d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 5fc334e9bae7960c 8 c0e43b90d2fba4d3 +engine_matches_executor_across_checkpoints_and_reopen 60039e1c3312acf3 162 ee4a7729ac66271f +engine_matches_executor_across_checkpoints_and_reopen 600f24d46260a1b1 3 dae9e9cc898f46e7 +engine_matches_executor_across_checkpoints_and_reopen 6015e430c3f5e858 5 4e08c703ebd6f1bf +engine_matches_executor_across_checkpoints_and_reopen 606d011745b35731 6 21bff0010da6e5a2 +engine_matches_executor_across_checkpoints_and_reopen 60b44a4477c5335f 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 60c90051fc8d365a 84 b0e28cff9f0b0296 +engine_matches_executor_across_checkpoints_and_reopen 60d580f5e19e70b7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 60ddd8892d3db26b 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 6102509517e53de1 100 02e0869febf43e2e +engine_matches_executor_across_checkpoints_and_reopen 6102509517e53de1 129 7ff00bed09c0e1fd +engine_matches_executor_across_checkpoints_and_reopen 6102509517e53de1 153 290c0e0649e3c613 +engine_matches_executor_across_checkpoints_and_reopen 6102509517e53de1 174 e901c5ac6cafded7 +engine_matches_executor_across_checkpoints_and_reopen 6102509517e53de1 65 c3243aa6572502bd +engine_matches_executor_across_checkpoints_and_reopen 61177c63891ebfe9 1 2a60efb47f296537 +engine_matches_executor_across_checkpoints_and_reopen 61177c63891ebfe9 10 7a647daffa82c357 +engine_matches_executor_across_checkpoints_and_reopen 61177c63891ebfe9 2 4ac6fbb661ab1b38 +engine_matches_executor_across_checkpoints_and_reopen 61177c63891ebfe9 6 9b8cc566c0ebff5d +engine_matches_executor_across_checkpoints_and_reopen 61177c63891ebfe9 8 1ed4db4500bcc4d5 +engine_matches_executor_across_checkpoints_and_reopen 6131bc66cbe298a0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 62211102150df788 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6222450f671d3543 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6225a089211b9236 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6234f3cf822107ca 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 627f24f2ad697579 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 62cd6000b15eacf6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 62cd7c47e67f505e 49 d3f9f528cee9292c +engine_matches_executor_across_checkpoints_and_reopen 62ed27c795ac822b 7 bed4ef47a416a22a +engine_matches_executor_across_checkpoints_and_reopen 62f611983a4874b8 12 415fc3b2591f85ff +engine_matches_executor_across_checkpoints_and_reopen 62f611983a4874b8 12 953d195f7ced8530 +engine_matches_executor_across_checkpoints_and_reopen 62f611983a4874b8 3 db67d59796fe67d9 +engine_matches_executor_across_checkpoints_and_reopen 62f611983a4874b8 6 4ca910f2bbd47048 +engine_matches_executor_across_checkpoints_and_reopen 62f611983a4874b8 9 c5065b1781e84889 +engine_matches_executor_across_checkpoints_and_reopen 6318296f12d2a7a1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6392c531b0204f52 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 639a3e5e5c3128fc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 639be0c1e6d74086 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 639be0c1e6d74086 3 66f719885e592e8a +engine_matches_executor_across_checkpoints_and_reopen 63b740a9bb657ce8 15 387714fd31ac02ed +engine_matches_executor_across_checkpoints_and_reopen 63da366521444959 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 641e8e127aede741 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6438c999c4fa6c6c 1 172f08ba9c63e405 +engine_matches_executor_across_checkpoints_and_reopen 646a1544a914eeb7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 649b215b5ecbcca0 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 64c30ff6da11b4bd 10 4a316bbaa771a7fb +engine_matches_executor_across_checkpoints_and_reopen 64d2fa8ef3223a1c 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 655a7b4c0d14f6fb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 65829358e5b53224 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 658b967bcff5612a 3 db67d59796fe67d9 +engine_matches_executor_across_checkpoints_and_reopen 65b1642fc5aa85d3 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 65eeb772c647bd49 6 458eecda77c33287 +engine_matches_executor_across_checkpoints_and_reopen 65f2c8f82682c0d6 48 74060e2e0c8644ad +engine_matches_executor_across_checkpoints_and_reopen 6602e4eef1974710 12 e8ee335a6003b271 +engine_matches_executor_across_checkpoints_and_reopen 6652c9dafc3926ca 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen 665bf561b471a383 9 6b9fc4d431323d01 +engine_matches_executor_across_checkpoints_and_reopen 6680747c92a7c85b 49 6b969001b154c502 +engine_matches_executor_across_checkpoints_and_reopen 66a6e07a88f47d9f 6 d7e0f8ed096cb869 +engine_matches_executor_across_checkpoints_and_reopen 679665b12f99be18 2 0c916c28893e812f +engine_matches_executor_across_checkpoints_and_reopen 67ea2ad5e50d40c4 25 6c71d0b469e8fded +engine_matches_executor_across_checkpoints_and_reopen 68adc7e762cc180d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 68fc465bcb46c8f8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 690fb3dde9babad4 11 fdfb9eefc7d6df44 +engine_matches_executor_across_checkpoints_and_reopen 696fec586f0a898c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 696fec586f0a898c 1 69d34b0102501287 +engine_matches_executor_across_checkpoints_and_reopen 6987c8fb2e1a2504 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 69c6237442278e86 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 69df289fd421ab80 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 69faf334d86a9e1d 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 69faf334d86a9e1d 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen 69faf334d86a9e1d 4 ac01b96d51ed3fa3 +engine_matches_executor_across_checkpoints_and_reopen 69faf334d86a9e1d 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 69faf334d86a9e1d 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen 6a515d7e616628c1 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 6a61e7a847f2894d 24 5b53e79e8bcbab81 +engine_matches_executor_across_checkpoints_and_reopen 6a65452aa3c6674d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6ae81230a8537ba9 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen 6aec104798da1a9d 12 e5eef43644a946e9 +engine_matches_executor_across_checkpoints_and_reopen 6b4135cf2eaefa2e 12 476309068ae10adc +engine_matches_executor_across_checkpoints_and_reopen 6b8c95ae6a57cb4e 6 45ca3e62e57c334d +engine_matches_executor_across_checkpoints_and_reopen 6c0a36cd08072e1a 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen 6c0b75b5e16be667 200 ce5708eaab786136 +engine_matches_executor_across_checkpoints_and_reopen 6c17dcc4baa87aa9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6c1e7308430eb10c 39 cc65771f929e5dcc +engine_matches_executor_across_checkpoints_and_reopen 6c3fa0b40e856be6 11 a3b4851b5816d266 +engine_matches_executor_across_checkpoints_and_reopen 6c576b22da620ed9 96 689cd81e1b638a19 +engine_matches_executor_across_checkpoints_and_reopen 6c9624ff4832c9e7 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 6cd45662fee6ab58 150 5798decf5a8c4672 +engine_matches_executor_across_checkpoints_and_reopen 6cd45662fee6ab58 24 398d4019728a360d +engine_matches_executor_across_checkpoints_and_reopen 6cd45662fee6ab58 54 238393ae1b86e9a2 +engine_matches_executor_across_checkpoints_and_reopen 6cd45662fee6ab58 6 4c599e6ab6611a56 +engine_matches_executor_across_checkpoints_and_reopen 6cd45662fee6ab58 96 175ce787cc729ebd +engine_matches_executor_across_checkpoints_and_reopen 6cf69762ee087c68 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 6d1a4bee989d2e31 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6d249bf06ce6f5e6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6d315118f168ae44 84 a6f461122b365d11 +engine_matches_executor_across_checkpoints_and_reopen 6d5effb336a09324 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6daf8b5e4eedbe44 4 9db76fa8be2daa9b +engine_matches_executor_across_checkpoints_and_reopen 6dafd635a9391512 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen 6dd265dc7db0e374 34 408b20c0cf81234d +engine_matches_executor_across_checkpoints_and_reopen 6e18e7e4f7da6bc7 1 687564f6b7ea5c3a +engine_matches_executor_across_checkpoints_and_reopen 6e327ee4da1e8785 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 6e3dcfdd5253545e 12 1fcdd0a4e5e401ff +engine_matches_executor_across_checkpoints_and_reopen 6e3dcfdd5253545e 12 5226dfecb7f3ef83 +engine_matches_executor_across_checkpoints_and_reopen 6e3dcfdd5253545e 3 6ce05a9057f2cc35 +engine_matches_executor_across_checkpoints_and_reopen 6e3dcfdd5253545e 6 701aac6ac17ed0e7 +engine_matches_executor_across_checkpoints_and_reopen 6e3dcfdd5253545e 9 d6fc803476d7979c +engine_matches_executor_across_checkpoints_and_reopen 6e5f467596928d85 100 444d0179a79ef317 +engine_matches_executor_across_checkpoints_and_reopen 6ec754d598a079df 2 926dcdfd7e3ef191 +engine_matches_executor_across_checkpoints_and_reopen 6f26ec7ae664e29e 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 6f4d4b56d2e8edc0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6f51a166c4473c79 65 6a704160801fc391 +engine_matches_executor_across_checkpoints_and_reopen 6fb2bf2e01e9fc2d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 6fb2bf2e01e9fc2d 1 601e5bcec97f730b +engine_matches_executor_across_checkpoints_and_reopen 6fb2bf2e01e9fc2d 2 d502e23700df61b7 +engine_matches_executor_across_checkpoints_and_reopen 6fb2bf2e01e9fc2d 4 2887891473b7ca25 +engine_matches_executor_across_checkpoints_and_reopen 70167bf594431353 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 701dbd7514138192 16 7171349914c8017b +engine_matches_executor_across_checkpoints_and_reopen 7059f93419ab9aae 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 705c36666bcad2d2 5 79ea87de4ee0256e +engine_matches_executor_across_checkpoints_and_reopen 708e780f716476dc 49 6b969001b154c502 +engine_matches_executor_across_checkpoints_and_reopen 70afa5c624bf440a 6 701aac6ac17ed0e7 +engine_matches_executor_across_checkpoints_and_reopen 70bd0e901ce716c7 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 70d42e565ce8c41e 24 2f572bfe8ff4d435 +engine_matches_executor_across_checkpoints_and_reopen 70f4d07e32c0324e 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 7104d1062d4ea2a4 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 712c23ba76f1264a 46 ea4a0beba6a435bd +engine_matches_executor_across_checkpoints_and_reopen 71524f36d9dc6df0 6 73fdaef98d0479a5 +engine_matches_executor_across_checkpoints_and_reopen 718ee73be071ad70 7 bed4ef47a416a22a +engine_matches_executor_across_checkpoints_and_reopen 71aeee1bd4d31b0a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 71b676209330b02f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 71fe1315d70b673c 12 5507e9eba629875d +engine_matches_executor_across_checkpoints_and_reopen 71fe1315d70b673c 16 edbc24ab003cb509 +engine_matches_executor_across_checkpoints_and_reopen 71fe1315d70b673c 42 842edc3637728d09 +engine_matches_executor_across_checkpoints_and_reopen 71fe1315d70b673c 48 988ae18b86ed8109 +engine_matches_executor_across_checkpoints_and_reopen 71fe1315d70b673c 58 27960b3098d592b9 +engine_matches_executor_across_checkpoints_and_reopen 720cab54c550fdf1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7230323f9fb5dfbd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 724248cedc78c396 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 725087ac71a27a37 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 728fc6df7c749876 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen 729c8d57843f10d7 190 8066e3647b2918db +engine_matches_executor_across_checkpoints_and_reopen 72a0663d12f32040 12 e8ee335a6003b271 +engine_matches_executor_across_checkpoints_and_reopen 72d5e0116c54a442 3 972e3c6cca3bd954 +engine_matches_executor_across_checkpoints_and_reopen 7336f7c7098ef1a9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7349aa371ef71c3d 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen 735c4111f1b57d69 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7360de31e6fa6e7a 6 e9f3ef25377a629e +engine_matches_executor_across_checkpoints_and_reopen 74a1cebc06573dc9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 74ae7e0fe10550ab 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 74dd71d7296267a4 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen 75203810c401a76d 1 10ecff6bb07d0691 +engine_matches_executor_across_checkpoints_and_reopen 755de2b4a49149f6 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen 755de2b4a49149f6 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 757b8c809ed9c44e 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen 757b8c809ed9c44e 16 5d5bb8c2de25a299 +engine_matches_executor_across_checkpoints_and_reopen 757b8c809ed9c44e 36 af674fc80e764dd9 +engine_matches_executor_across_checkpoints_and_reopen 757b8c809ed9c44e 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen 757b8c809ed9c44e 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen 75d4db2227e0474d 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 75e2e6859e5dab3e 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 7618ec94c2701a4c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 763e2b38cb1e90eb 2 23742fb0ed610812 +engine_matches_executor_across_checkpoints_and_reopen 7641e697cda4dc04 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 765a007b8c009bd7 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 768bfb6e3ae9c2a5 1 69c1cb8586d9ab07 +engine_matches_executor_across_checkpoints_and_reopen 76bb91fa7d1cfc28 1 ff2ec67c0fc3b7aa +engine_matches_executor_across_checkpoints_and_reopen 76de8bf34e8a3b92 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7702b5b37f891a4f 121 761d012906296989 +engine_matches_executor_across_checkpoints_and_reopen 7702b5b37f891a4f 145 461caeb8551fdedc +engine_matches_executor_across_checkpoints_and_reopen 7702b5b37f891a4f 166 494c06119b2f4e6a +engine_matches_executor_across_checkpoints_and_reopen 7702b5b37f891a4f 61 6d99eb625b079284 +engine_matches_executor_across_checkpoints_and_reopen 7702b5b37f891a4f 94 26e1aceb197c6b75 +engine_matches_executor_across_checkpoints_and_reopen 7736647c7eefcff8 116 1aa58e723ad47a1c +engine_matches_executor_across_checkpoints_and_reopen 773d3064e99972f2 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen 774b4a1827498d8c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 776a7617a28e8637 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen 778b91a63f4ac694 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 77a123a2e07981f7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 77cc8a272f3ec5d8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 782888110769501c 3 6b32068b744d03cc +engine_matches_executor_across_checkpoints_and_reopen 7831c9ed32f87e7c 3 d84b517a33c8e75d +engine_matches_executor_across_checkpoints_and_reopen 785c946262244264 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7861b9d0ac91c136 6 52a4ac892f494396 +engine_matches_executor_across_checkpoints_and_reopen 78badb507e63562e 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen 78c5154e7241effa 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 78c5154e7241effa 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen 78e89ab4399b7306 12 cc2b1bdab54294bb +engine_matches_executor_across_checkpoints_and_reopen 78e89ab4399b7306 18 80d38d98f23d346c +engine_matches_executor_across_checkpoints_and_reopen 78e89ab4399b7306 24 f5f3f55f2bf12bc1 +engine_matches_executor_across_checkpoints_and_reopen 78e89ab4399b7306 30 c6774cc2f7ced344 +engine_matches_executor_across_checkpoints_and_reopen 78e89ab4399b7306 6 0e7421042f63c82c +engine_matches_executor_across_checkpoints_and_reopen 78fb6604a4d34e64 39 f04d57613a1c64dc +engine_matches_executor_across_checkpoints_and_reopen 791937b7e4332f89 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 79547c922eca2146 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen 7971068cff58db79 12 28f427906a75f209 +engine_matches_executor_across_checkpoints_and_reopen 7971068cff58db79 12 deb9cb9283dab699 +engine_matches_executor_across_checkpoints_and_reopen 7971068cff58db79 3 901ee687b20c92e8 +engine_matches_executor_across_checkpoints_and_reopen 7971068cff58db79 6 ec509cb124a5dc10 +engine_matches_executor_across_checkpoints_and_reopen 7971068cff58db79 9 70a3eca1df3d5700 +engine_matches_executor_across_checkpoints_and_reopen 797358de01ee641c 6 8344a710d174277f +engine_matches_executor_across_checkpoints_and_reopen 7a28aca534177e17 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 7ac256fc312a8f95 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7ac34daa4c9fa83f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7b064cdbcadd9c84 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen 7b57d0fd1a92c0c7 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 7b6147a6fa71ca4f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7b773e1bc1aabc1b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7bfd48bf8b09f97b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7c564bb3066feeb8 9 41dbe62d3248875c +engine_matches_executor_across_checkpoints_and_reopen 7c5860ca1648a9bf 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 7c5860ca1648a9bf 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen 7c5a32f478d39ca9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7cdc2de5a888a4b6 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 7d22422d2bfd42c0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7d3a34ab10e50600 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7d49cd354d49d3a5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7d554c67652dbc71 6 87b4f8fbb61769c2 +engine_matches_executor_across_checkpoints_and_reopen 7d565621cdafa1a5 80 f8754bc52b44c699 +engine_matches_executor_across_checkpoints_and_reopen 7d7cb8aa1af3adaa 2 fbf6bc7510df255f +engine_matches_executor_across_checkpoints_and_reopen 7d88a4b86112b8c4 3 1419ec70940d65b0 +engine_matches_executor_across_checkpoints_and_reopen 7e4d4dd4dbd05488 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7e57aff1dfe81d91 1 d8054e5592aedb2e +engine_matches_executor_across_checkpoints_and_reopen 7e57aff1dfe81d91 2 fef2cacccac0967f +engine_matches_executor_across_checkpoints_and_reopen 7e57aff1dfe81d91 3 561ee1995d21aa56 +engine_matches_executor_across_checkpoints_and_reopen 7e57aff1dfe81d91 4 e96cb5244cf0840e +engine_matches_executor_across_checkpoints_and_reopen 7e57aff1dfe81d91 5 ba124444c138d9e1 +engine_matches_executor_across_checkpoints_and_reopen 7e8c7f99efd8d7cd 1 928198d2403b0e52 +engine_matches_executor_across_checkpoints_and_reopen 7e8e4d8d718e413c 12 4d1bb454989fd859 +engine_matches_executor_across_checkpoints_and_reopen 7ea87d519cbabe42 2 ab367f7400e3bc40 +engine_matches_executor_across_checkpoints_and_reopen 7f0203b1d77103b6 37 6039c59f3e60315f +engine_matches_executor_across_checkpoints_and_reopen 7f1874d45b7aefe9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7f1874d45b7aefe9 27 04eefaef424c5524 +engine_matches_executor_across_checkpoints_and_reopen 7f1874d45b7aefe9 54 757d25d2570e0eb9 +engine_matches_executor_across_checkpoints_and_reopen 7f1874d45b7aefe9 9 dc0e89f9c7e2c31a +engine_matches_executor_across_checkpoints_and_reopen 7f213cccf5daa5df 6 5bcff50d2a29af85 +engine_matches_executor_across_checkpoints_and_reopen 7f3f314bede7d92a 3 349b4d5824a44483 +engine_matches_executor_across_checkpoints_and_reopen 7f545511df05c5bb 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 7f6e7b8dce2ec7b1 6 fba03c86c5f2142c +engine_matches_executor_across_checkpoints_and_reopen 7f9c1b88fc6c8ab5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 7fea408d8c6da90c 8 c49a523b6b640058 +engine_matches_executor_across_checkpoints_and_reopen 807aa24f12ce074b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8087204be4f6d0ba 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 80c1c4534739c08a 6 33227bf297dc2fac +engine_matches_executor_across_checkpoints_and_reopen 80eb6039766c366a 65 d90a7475ce57c24b +engine_matches_executor_across_checkpoints_and_reopen 81a0aaa302b3ae34 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 81d5f6dd360d101e 5 6fcd3e7bf9f76e30 +engine_matches_executor_across_checkpoints_and_reopen 81f1375588387e01 4 5c72f8882c87073a +engine_matches_executor_across_checkpoints_and_reopen 82126a1932e130c6 6 c369485b5f37d49f +engine_matches_executor_across_checkpoints_and_reopen 82538b79857ca611 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 826fea13a09c371d 9 dc0e89f9c7e2c31a +engine_matches_executor_across_checkpoints_and_reopen 8275adc42e8e7ee1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 82788433b57fa95e 13 09abf7e130ea548e +engine_matches_executor_across_checkpoints_and_reopen 82834d0c31093fcd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 828dffe221d2297d 3 b366d81396a9b58e +engine_matches_executor_across_checkpoints_and_reopen 82a1f0f9c6ccb878 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 82aa8b8c502ed2fc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 82baab86973c2d7a 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen 82d6e5e9e34cc693 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 83038b5e674d5dc7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 83269d0e80bbeff3 12 e8e12c96cf0ee98d +engine_matches_executor_across_checkpoints_and_reopen 83269d0e80bbeff3 3 cfebdd838ce29455 +engine_matches_executor_across_checkpoints_and_reopen 83269d0e80bbeff3 6 caf5fd7df73c383b +engine_matches_executor_across_checkpoints_and_reopen 83269d0e80bbeff3 9 5d9a3e35cf697559 +engine_matches_executor_across_checkpoints_and_reopen 8376a78895c4bd6b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 83c3d459380ac023 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 83c7f205b411823f 2 9de2ebbe4948c411 +engine_matches_executor_across_checkpoints_and_reopen 83d738e29a30817d 21 67a5a3764279b2ca +engine_matches_executor_across_checkpoints_and_reopen 83dbf7721f1b0cb4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8422a48c691f7fc0 15 26c04c7e44705a17 +engine_matches_executor_across_checkpoints_and_reopen 842db5ee336982d7 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 84673049cdc347a1 8 2d2d51bfe69c0706 +engine_matches_executor_across_checkpoints_and_reopen 84a9c17810fb3c21 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen 84d223335c468605 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 84e25a9ba4b6ddff 6 d7e0f8ed096cb869 +engine_matches_executor_across_checkpoints_and_reopen 84edfde1a004acdc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 85694dd112a84bb7 150 a7eda0204df457b5 +engine_matches_executor_across_checkpoints_and_reopen 85694dd112a84bb7 24 f292068678b09f7d +engine_matches_executor_across_checkpoints_and_reopen 85694dd112a84bb7 54 500f00a362424179 +engine_matches_executor_across_checkpoints_and_reopen 85694dd112a84bb7 6 73fdaef98d0479a5 +engine_matches_executor_across_checkpoints_and_reopen 85694dd112a84bb7 96 35f93b0cd503d2a5 +engine_matches_executor_across_checkpoints_and_reopen 85869419a2429518 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 858c2f06a35db63a 1 927a1d03ea20cb8e +engine_matches_executor_across_checkpoints_and_reopen 85c353da12d915a7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 85dbe768811a7e1c 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen 85dd23f0c5a8dba1 1 d1c8bd90077e4faf +engine_matches_executor_across_checkpoints_and_reopen 85dd23f0c5a8dba1 12 e8e12c96cf0ee98d +engine_matches_executor_across_checkpoints_and_reopen 85dd23f0c5a8dba1 14 cd70330a35261e77 +engine_matches_executor_across_checkpoints_and_reopen 85dd23f0c5a8dba1 2 a61a68742dc374c2 +engine_matches_executor_across_checkpoints_and_reopen 85dd23f0c5a8dba1 7 5c0ccd63ac05e796 +engine_matches_executor_across_checkpoints_and_reopen 85f41aac55cd89fb 4 5c72f8882c87073a +engine_matches_executor_across_checkpoints_and_reopen 860c879e0f2841b9 1 a1d4248ed47613c7 +engine_matches_executor_across_checkpoints_and_reopen 8649051af813f2f5 49 ca69df98cb2b32f3 +engine_matches_executor_across_checkpoints_and_reopen 86517e571dc48d11 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 867b39d04f577b1b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 86852edad83b67a2 1 81811716bd6b8225 +engine_matches_executor_across_checkpoints_and_reopen 86b05ade04a83f19 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 86b05ade04a83f19 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 86b05ade04a83f19 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen 86b05ade04a83f19 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen 86b05ade04a83f19 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen 86ef6f306ec7c1df 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen 874014e4348ed57d 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen 87bd0fbd7c3a0139 12 89624ed133360d72 +engine_matches_executor_across_checkpoints_and_reopen 87cac80ced1c3b91 18 a47870965d8ebc40 +engine_matches_executor_across_checkpoints_and_reopen 881a17e2eb40f77a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 88227f7153ab2389 3 292589bdd0c11d3c +engine_matches_executor_across_checkpoints_and_reopen 883680c76e1acb19 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 883a845d6fbc1d43 4 330d02b71a3a300b +engine_matches_executor_across_checkpoints_and_reopen 883ca3e813da7d35 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8893e572b28bfa8d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8894515ef7d85c95 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 889cbb423b90dd79 12 221d1f03ddd5bc7b +engine_matches_executor_across_checkpoints_and_reopen 889cbb423b90dd79 3 e40edea33ab884b0 +engine_matches_executor_across_checkpoints_and_reopen 889cbb423b90dd79 6 bd68d19ad7ab7c16 +engine_matches_executor_across_checkpoints_and_reopen 889cbb423b90dd79 9 7c5f9dcfd99b22f9 +engine_matches_executor_across_checkpoints_and_reopen 88a71268c0e0c1e1 20 f7a84d94a7b1044b +engine_matches_executor_across_checkpoints_and_reopen 88c23d987822d883 6 40a7aac6b4fe7cee +engine_matches_executor_across_checkpoints_and_reopen 88c32eae69d89de6 14 cd70330a35261e77 +engine_matches_executor_across_checkpoints_and_reopen 8966e09eb8b93dc0 5 92ed8a96edd4efae +engine_matches_executor_across_checkpoints_and_reopen 89d6582d3a9e63f1 2 4cec1df3a3d20a9f +engine_matches_executor_across_checkpoints_and_reopen 89da9a40300508b0 12 42effd69a1a78371 +engine_matches_executor_across_checkpoints_and_reopen 89da9a40300508b0 16 438be19255feff2a +engine_matches_executor_across_checkpoints_and_reopen 89da9a40300508b0 20 676582a984dd8f73 +engine_matches_executor_across_checkpoints_and_reopen 89da9a40300508b0 4 86c430c16333d7fb +engine_matches_executor_across_checkpoints_and_reopen 89da9a40300508b0 8 d7370e7e909cdd3c +engine_matches_executor_across_checkpoints_and_reopen 89f5a9fdc2ac5266 16 caa4a2629e02da05 +engine_matches_executor_across_checkpoints_and_reopen 8a20029351c471d2 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen 8af3441db252e1f7 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 8b356a39665a0c86 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8b48df89869c3bf6 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8b51c8ac491dbb26 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8b62d6ab68dc5029 75 0a052f222f2d7baa +engine_matches_executor_across_checkpoints_and_reopen 8b7da114e4bfc655 24 5b53e79e8bcbab81 +engine_matches_executor_across_checkpoints_and_reopen 8b81bdbf8eeed6c4 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 8c0852cdab7bed26 16 1348a20b0d70dea9 +engine_matches_executor_across_checkpoints_and_reopen 8c2bc12007fe154b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8c5d8f922249794e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8c73c01bcb126861 12 06dba2c2b98ae181 +engine_matches_executor_across_checkpoints_and_reopen 8c73c01bcb126861 3 28e71fda4c1b5f3a +engine_matches_executor_across_checkpoints_and_reopen 8c73c01bcb126861 6 16da1375f2a94a82 +engine_matches_executor_across_checkpoints_and_reopen 8c73c01bcb126861 9 a701ba03bb360259 +engine_matches_executor_across_checkpoints_and_reopen 8c76534d02b5aa2c 12 fe1675751629a00d +engine_matches_executor_across_checkpoints_and_reopen 8d50a9615b2ee596 12 e8e12c96cf0ee98d +engine_matches_executor_across_checkpoints_and_reopen 8dbe36e4eba0fe42 18 8f5ff12b787df1ae +engine_matches_executor_across_checkpoints_and_reopen 8dbe36e4eba0fe42 27 af597e5fa00c92d9 +engine_matches_executor_across_checkpoints_and_reopen 8dbe36e4eba0fe42 36 5032dba31996734b +engine_matches_executor_across_checkpoints_and_reopen 8dbe36e4eba0fe42 9 f66974282bfc4de4 +engine_matches_executor_across_checkpoints_and_reopen 8dd6a99e05d6558a 8 eedf2c7acf626255 +engine_matches_executor_across_checkpoints_and_reopen 8de645f1d3dbd209 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8de6c38901aee073 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen 8e0d6c8071a90cc6 4 e3a3e48200a0a5fc +engine_matches_executor_across_checkpoints_and_reopen 8e1369bd4398155d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8e635293390df398 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8eb10e297e55f2fe 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8ec92c9e6cdc5a00 13 17dfaefe129ac139 +engine_matches_executor_across_checkpoints_and_reopen 8ef4a58e23bd6119 150 38bded9076ceb5e9 +engine_matches_executor_across_checkpoints_and_reopen 8ef4a58e23bd6119 24 1ee2038ee883f25d +engine_matches_executor_across_checkpoints_and_reopen 8ef4a58e23bd6119 54 ab14bf2f996957a7 +engine_matches_executor_across_checkpoints_and_reopen 8ef4a58e23bd6119 6 7c029f89e9a90a65 +engine_matches_executor_across_checkpoints_and_reopen 8ef4a58e23bd6119 96 689cd81e1b638a19 +engine_matches_executor_across_checkpoints_and_reopen 8f2208d44beef335 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8f3a1c982c3e6255 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 8f449c415d58a9fe 2 f04f033a623dfcd7 +engine_matches_executor_across_checkpoints_and_reopen 8f8ac188685eed67 2 c70b48a0fbacf660 +engine_matches_executor_across_checkpoints_and_reopen 8fd0c451093fe865 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9032aaa44af4b529 6 285a2f89f9536571 +engine_matches_executor_across_checkpoints_and_reopen 908011f1e8396488 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 90d950da3aff1a40 1 2a60efb47f296537 +engine_matches_executor_across_checkpoints_and_reopen 90ff8dd087710cbf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9104afd87633261c 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen 9104afd87633261c 16 5d5bb8c2de25a299 +engine_matches_executor_across_checkpoints_and_reopen 9104afd87633261c 36 af674fc80e764dd9 +engine_matches_executor_across_checkpoints_and_reopen 9104afd87633261c 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen 9104afd87633261c 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen 910e5b57be0b1e8a 12 528b82f3d3dd5928 +engine_matches_executor_across_checkpoints_and_reopen 910e5b57be0b1e8a 12 8b73c35a34c162b7 +engine_matches_executor_across_checkpoints_and_reopen 910e5b57be0b1e8a 3 2bf04f04e1243264 +engine_matches_executor_across_checkpoints_and_reopen 910e5b57be0b1e8a 6 70b06d654f921286 +engine_matches_executor_across_checkpoints_and_reopen 910e5b57be0b1e8a 9 03dcc1b718e6f4ac +engine_matches_executor_across_checkpoints_and_reopen 9140c34433676589 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen 91b1613eb2665aa2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 91bba6e7c7e1eca3 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 91be8decd045b3b1 25 20b7f8c4ff8542c5 +engine_matches_executor_across_checkpoints_and_reopen 91c898a43106b791 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 921642b25b7fdf39 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 921642b25b7fdf39 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen 9216ebd20b2cb591 2 3e66a74cff0b516e +engine_matches_executor_across_checkpoints_and_reopen 922a1f714ab82edf 1 2a60efb47f296537 +engine_matches_executor_across_checkpoints_and_reopen 92327384d4d66aa5 7 752c17b2b4a444d4 +engine_matches_executor_across_checkpoints_and_reopen 924a926693037d00 3 18a18852d8af9803 +engine_matches_executor_across_checkpoints_and_reopen 927e11272239750e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 92a2d8bf2c4f1f65 4 d4beeeb89c6410cf +engine_matches_executor_across_checkpoints_and_reopen 92c35a0029016586 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen 92c35a0029016586 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 92c35a0029016586 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen 92c35a0029016586 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen 92c35a0029016586 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen 9319eff65733c3fd 6 5bcff50d2a29af85 +engine_matches_executor_across_checkpoints_and_reopen 931b853818f4c5d8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 933860401c8c49f5 12 4ac858146048ec2b +engine_matches_executor_across_checkpoints_and_reopen 936472c2794dab39 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 93dea18becddfade 148 f7e6dd4081b18a9a +engine_matches_executor_across_checkpoints_and_reopen 943483160d491146 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen 94480dfe3e1cef89 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 94b2ff01ea63aabe 36 5032dba31996734b +engine_matches_executor_across_checkpoints_and_reopen 94b3e9dc4a4baefe 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 94ba8f2d7a1331dc 3 67b8fd74342ef287 +engine_matches_executor_across_checkpoints_and_reopen 94f35c60fe6bc58e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 95049facc07115f9 5 ba124444c138d9e1 +engine_matches_executor_across_checkpoints_and_reopen 95552e1aab480732 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen 958d27fafe20eed5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 95c737d29cb3cc81 5 f732dc62a7ed825d +engine_matches_executor_across_checkpoints_and_reopen 95e856ba9e7fcb25 48 988ae18b86ed8109 +engine_matches_executor_across_checkpoints_and_reopen 9616a8c5ba38aa58 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 964ed55eb85dab6d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9699dcc675b6a23a 3 28e71fda4c1b5f3a +engine_matches_executor_across_checkpoints_and_reopen 96d96aa8ac814585 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen 96f1f8d89e01f9dd 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 97bb3b7dcb07fc1b 65 c3243aa6572502bd +engine_matches_executor_across_checkpoints_and_reopen 97c8d51e6f98dd25 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 97cfd193d71a899a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 97d61c83416d5893 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 97deca0c73dbe2bb 6 70831860fa875f4c +engine_matches_executor_across_checkpoints_and_reopen 98365b941a8ed465 16 1348a20b0d70dea9 +engine_matches_executor_across_checkpoints_and_reopen 986108def3adf1ff 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen 98ef332fd4e7e5d7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 990e872b680beeec 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 991a322f6ac38d7b 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen 9942266dd09470ab 13 05319f97fbf0802f +engine_matches_executor_across_checkpoints_and_reopen 9970e965c7025dc8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 99b4d60a45744cfa 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen 99c6f44293aa91fc 12 528b82f3d3dd5928 +engine_matches_executor_across_checkpoints_and_reopen 99c6f44293aa91fc 12 8b73c35a34c162b7 +engine_matches_executor_across_checkpoints_and_reopen 99c6f44293aa91fc 3 2bf04f04e1243264 +engine_matches_executor_across_checkpoints_and_reopen 99c6f44293aa91fc 6 70b06d654f921286 +engine_matches_executor_across_checkpoints_and_reopen 99c6f44293aa91fc 9 03dcc1b718e6f4ac +engine_matches_executor_across_checkpoints_and_reopen 99ec10f377328b11 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9a0310608f71c3ad 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9a12e9c81925e4f1 24 398d4019728a360d +engine_matches_executor_across_checkpoints_and_reopen 9a12f958860a97b9 3 66f719885e592e8a +engine_matches_executor_across_checkpoints_and_reopen 9ab020a7f9911bd6 8 6b2c5e7f7c7e1878 +engine_matches_executor_across_checkpoints_and_reopen 9b065134f69311b1 10 107650893881007e +engine_matches_executor_across_checkpoints_and_reopen 9b359d9df7671797 23 60be68f2e6dfc9db +engine_matches_executor_across_checkpoints_and_reopen 9b4ee34fd4955bd7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9b535cb122761866 12 05e8aabfda4a4add +engine_matches_executor_across_checkpoints_and_reopen 9ba8caecfc7a5e77 36 6f3f22de92913d1f +engine_matches_executor_across_checkpoints_and_reopen 9c600829ce7d31c6 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen 9cc1421e24c1f45d 1 897824935613a4ed +engine_matches_executor_across_checkpoints_and_reopen 9cf9121f30596ec8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9d1e5a9928709b31 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9d8a902a89fadee2 2 b1a307f58d760af7 +engine_matches_executor_across_checkpoints_and_reopen 9e037182454deb3b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9e23861d15dd6430 1 01899acbb5049a39 +engine_matches_executor_across_checkpoints_and_reopen 9e33513d822b83a3 1 57c34273beddeb94 +engine_matches_executor_across_checkpoints_and_reopen 9e4b3bcea6ba578a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9e7a9028d456be97 5 d493d2b682a6e84e +engine_matches_executor_across_checkpoints_and_reopen 9ec084c9604a615d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9ec24184c6ebd177 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9ef8caeaa71e6e47 1 99bad883d8b821dd +engine_matches_executor_across_checkpoints_and_reopen 9f408f67c1aadf85 8 26bda39cca3526c4 +engine_matches_executor_across_checkpoints_and_reopen 9f4f90bdfaa2af90 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9f8457164c91716f 3 7903ff4f7f693996 +engine_matches_executor_across_checkpoints_and_reopen 9f9760ce52bf4241 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9fa8f8f1f5c364f7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9fc7ed1ef45bf9bc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen 9fde790abb57af4a 1 3420549d9686942d +engine_matches_executor_across_checkpoints_and_reopen a0309bddc528c4f3 100 53b80245de45553d +engine_matches_executor_across_checkpoints_and_reopen a0309bddc528c4f3 129 9c35cf355b761c22 +engine_matches_executor_across_checkpoints_and_reopen a0309bddc528c4f3 153 14c7547e627b020a +engine_matches_executor_across_checkpoints_and_reopen a0309bddc528c4f3 174 0920006165330956 +engine_matches_executor_across_checkpoints_and_reopen a0309bddc528c4f3 65 a241e85840ee1c32 +engine_matches_executor_across_checkpoints_and_reopen a0347b340349f15e 116 19f537044e73b093 +engine_matches_executor_across_checkpoints_and_reopen a051035ec341e66e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a052b51e73a6e9f8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a0a1c7bf7bdce3cf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a0c6d6de6e0327e7 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen a0eae9c93ece8629 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a0eedaf41c35df7b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a1345592f26f03c5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a13491be489359eb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a15d3deb7cf77be3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a1727f1fa4355751 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a1a00e99dc14911f 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen a1a7f79410567e9f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a1aaa83bdf328d14 15 399aca6e153377ab +engine_matches_executor_across_checkpoints_and_reopen a1c6a8996779833a 8 fd366b6c436fb0f1 +engine_matches_executor_across_checkpoints_and_reopen a1ee5560efda5bed 25 bf874cb1c383bb72 +engine_matches_executor_across_checkpoints_and_reopen a2356b2038cc9d9b 3 e6dd8deeca389e9e +engine_matches_executor_across_checkpoints_and_reopen a2549caa9caa5743 15 e239079e66933916 +engine_matches_executor_across_checkpoints_and_reopen a27f97f7f41c9e7c 6 4ca910f2bbd47048 +engine_matches_executor_across_checkpoints_and_reopen a286555f5b7c9fb7 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen a29ad8196df58ee0 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen a29ccba35727872a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a2a5b95c2bfd69b0 9 64062bbfd2a9320d +engine_matches_executor_across_checkpoints_and_reopen a2a74907b8f0e012 116 da2b9bf86a3bbb0a +engine_matches_executor_across_checkpoints_and_reopen a2c482669b8d261e 6 caf5fd7df73c383b +engine_matches_executor_across_checkpoints_and_reopen a30a1d3e30f59c8f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a33268e9f523026f 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen a3841bc5694437b4 150 bac33a7b360bba60 +engine_matches_executor_across_checkpoints_and_reopen a3841bc5694437b4 24 5b53e79e8bcbab81 +engine_matches_executor_across_checkpoints_and_reopen a3841bc5694437b4 54 f79c6bd42108b8ea +engine_matches_executor_across_checkpoints_and_reopen a3841bc5694437b4 6 70831860fa875f4c +engine_matches_executor_across_checkpoints_and_reopen a3841bc5694437b4 96 04e08083113c9801 +engine_matches_executor_across_checkpoints_and_reopen a39253b4c953f86d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a3992c86ea8a189f 3 9277156909ee2a23 +engine_matches_executor_across_checkpoints_and_reopen a39a720f4590d7ea 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen a3d004257eb5a4d3 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen a3fbd2ac6c20ef9c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a412ff224e20ea59 1 76b48d54dad1a495 +engine_matches_executor_across_checkpoints_and_reopen a432b083580c59b0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a43b8da7de2447ac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a45deb79e72f31c0 2 2c244a37025b6a79 +engine_matches_executor_across_checkpoints_and_reopen a45deb79e72f31c0 4 4c8b134937bedf06 +engine_matches_executor_across_checkpoints_and_reopen a45deb79e72f31c0 6 89b602cd918b985b +engine_matches_executor_across_checkpoints_and_reopen a45deb79e72f31c0 8 6ba1c16bccc70a97 +engine_matches_executor_across_checkpoints_and_reopen a45deb79e72f31c0 8 d421315e2424b83f +engine_matches_executor_across_checkpoints_and_reopen a461d4d8c66558a8 1 3420549d9686942d +engine_matches_executor_across_checkpoints_and_reopen a461d4d8c66558a8 10 fdbbe89b17c2e3bf +engine_matches_executor_across_checkpoints_and_reopen a461d4d8c66558a8 2 d0ef367a5325838d +engine_matches_executor_across_checkpoints_and_reopen a461d4d8c66558a8 6 e0688e135740dd2a +engine_matches_executor_across_checkpoints_and_reopen a461d4d8c66558a8 8 ab62f9e0a2a6628b +engine_matches_executor_across_checkpoints_and_reopen a465c11d2388d70f 12 43b7e885d6f10365 +engine_matches_executor_across_checkpoints_and_reopen a47b630da94a3caf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a482987002485ce5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a495f8711b68f809 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a4e5e272e6f25c98 37 1dcede62998d6764 +engine_matches_executor_across_checkpoints_and_reopen a52427836d6d0913 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a569020b578fae8b 9 f75d280453f47706 +engine_matches_executor_across_checkpoints_and_reopen a5760652747d4b2e 4 2887891473b7ca25 +engine_matches_executor_across_checkpoints_and_reopen a5a2f179d923ecb1 1 fb5cc1e4287b2e07 +engine_matches_executor_across_checkpoints_and_reopen a5a8a1ea2762af9e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a5a9a1139f70fbb9 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen a5d034ef103a2eee 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a5f6789b5c8d4685 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen a618c3a5a895c516 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a64e2cb6a29100e5 16 9068935ea5556dd1 +engine_matches_executor_across_checkpoints_and_reopen a64e2cb6a29100e5 36 7650a3ad4ff15551 +engine_matches_executor_across_checkpoints_and_reopen a64e2cb6a29100e5 4 2b1e1bdf2d001b19 +engine_matches_executor_across_checkpoints_and_reopen a66972ca16b42296 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a6a952c9e177f94e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a6f99610ce45761f 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen a7607415cd69556a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a78112f0aede8c8c 5 aecbe895d3b988a6 +engine_matches_executor_across_checkpoints_and_reopen a78c66ff062f1c70 12 6d5f0f6a2721b39d +engine_matches_executor_across_checkpoints_and_reopen a7d8ee29fa812579 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a8059ac1525296b7 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a810b2730bd2c15a 10 4a316bbaa771a7fb +engine_matches_executor_across_checkpoints_and_reopen a810b2730bd2c15a 12 89624ed133360d72 +engine_matches_executor_across_checkpoints_and_reopen a810b2730bd2c15a 4 5c72f8882c87073a +engine_matches_executor_across_checkpoints_and_reopen a810b2730bd2c15a 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen a810b2730bd2c15a 8 7f2fea02558d8d74 +engine_matches_executor_across_checkpoints_and_reopen a8177cd48cfc49bb 65 bace5c29a4bdb5ff +engine_matches_executor_across_checkpoints_and_reopen a819ef163cb08ff1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen a9f0e0140b5d77ed 12 db51be599169d07b +engine_matches_executor_across_checkpoints_and_reopen a9f0e0140b5d77ed 3 1056e3766ad41119 +engine_matches_executor_across_checkpoints_and_reopen a9f0e0140b5d77ed 6 44fcf5430afde7a2 +engine_matches_executor_across_checkpoints_and_reopen a9f0e0140b5d77ed 9 7d053cfc42ed2526 +engine_matches_executor_across_checkpoints_and_reopen a9fe0bc72a16e79f 6 30089ca5bd8841a4 +engine_matches_executor_across_checkpoints_and_reopen aa2aa676a0831338 6 4ac5a0a5d30b385f +engine_matches_executor_across_checkpoints_and_reopen aa44ab7c1f1e2cbd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aa605a9486cae18a 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen aa9285bca31c67ce 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aa9b0a25220e163b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aa9d0fbfc927cccb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aafb98f2df69f2f8 116 0f36735a9fd9e73a +engine_matches_executor_across_checkpoints_and_reopen ab328b531beed6f4 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen ab6c558134322749 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ab77ae4c8780369b 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen aba721912793cd90 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen abad158a70a24032 150 a7eda0204df457b5 +engine_matches_executor_across_checkpoints_and_reopen abe4b40fdc743356 49 0da80faf1338c3bb +engine_matches_executor_across_checkpoints_and_reopen abed69550ea1b4fe 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ac081ae5cfcd57bf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ac0cbe414582bfe4 100 aa4bbb66c140d197 +engine_matches_executor_across_checkpoints_and_reopen ac0cbe414582bfe4 129 c200775733181852 +engine_matches_executor_across_checkpoints_and_reopen ac0cbe414582bfe4 153 b1567e5149f31e2e +engine_matches_executor_across_checkpoints_and_reopen ac0cbe414582bfe4 174 0f3a89b1920cca79 +engine_matches_executor_across_checkpoints_and_reopen ac0cbe414582bfe4 65 d90a7475ce57c24b +engine_matches_executor_across_checkpoints_and_reopen aca7ee33fb13d4e6 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen aca7ee33fb13d4e6 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen aca7ee33fb13d4e6 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen aca7ee33fb13d4e6 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen aca7ee33fb13d4e6 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen acb79bc8feccfd6f 1 92d14ab4b8db0af4 +engine_matches_executor_across_checkpoints_and_reopen acdab556caab5489 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen acdab556caab5489 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen acdab556caab5489 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen acdab556caab5489 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen acdab556caab5489 5 6677f437185af8cc +engine_matches_executor_across_checkpoints_and_reopen acf794358ad69e71 5 350badcff0fa6534 +engine_matches_executor_across_checkpoints_and_reopen ad0967026ba8bc82 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ad2fb80721520da2 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen ad323c5eee219fd8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ad329825623c30d5 3 66f719885e592e8a +engine_matches_executor_across_checkpoints_and_reopen ad8364d1f98313ac 5 48270ff9f563bc99 +engine_matches_executor_across_checkpoints_and_reopen adb480d5160a3fbb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen adf9b98ff390cbed 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen ae1c890f527f4319 12 ae47b40fbf4f995b +engine_matches_executor_across_checkpoints_and_reopen ae1c890f527f4319 18 162e436b84e5677e +engine_matches_executor_across_checkpoints_and_reopen ae1c890f527f4319 24 84bce92689670a27 +engine_matches_executor_across_checkpoints_and_reopen ae1c890f527f4319 30 e9fab1ee4f812934 +engine_matches_executor_across_checkpoints_and_reopen ae1c890f527f4319 6 b4b1e964ac56252c +engine_matches_executor_across_checkpoints_and_reopen ae59fcedbb6731da 10 475851473d15ec7d +engine_matches_executor_across_checkpoints_and_reopen ae59fcedbb6731da 12 bef3f4c3c41f7bf6 +engine_matches_executor_across_checkpoints_and_reopen ae59fcedbb6731da 2 3cba14159b036c4c +engine_matches_executor_across_checkpoints_and_reopen ae59fcedbb6731da 4 e3a3e48200a0a5fc +engine_matches_executor_across_checkpoints_and_reopen ae59fcedbb6731da 7 4b5390923ba91818 +engine_matches_executor_across_checkpoints_and_reopen ae5f720b6233b8d0 12 4195c35bf5c5e653 +engine_matches_executor_across_checkpoints_and_reopen ae73a7b06f7b1283 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ae7e874f72fbe5d5 5 941bcb12d724d140 +engine_matches_executor_across_checkpoints_and_reopen aec5800f7be14c89 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aecb7f6144e52e7a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aedb5d8a4e976394 4 5c72f8882c87073a +engine_matches_executor_across_checkpoints_and_reopen aede7bb67a1d81ad 3 18a18852d8af9803 +engine_matches_executor_across_checkpoints_and_reopen af025df857bb8b10 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen af2961d867ee75ad 49 256934f5c7e1fb0f +engine_matches_executor_across_checkpoints_and_reopen af42b62b2a817cbb 12 2dab216f197598c1 +engine_matches_executor_across_checkpoints_and_reopen af42b62b2a817cbb 3 c92580b4a540e8f1 +engine_matches_executor_across_checkpoints_and_reopen af42b62b2a817cbb 6 45ca3e62e57c334d +engine_matches_executor_across_checkpoints_and_reopen af42b62b2a817cbb 9 332172c300c36409 +engine_matches_executor_across_checkpoints_and_reopen af4ecdfc2ad9a40e 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen af59d638a1a6c9c4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen afba21bdcca23270 3 60ba04293f08d31b +engine_matches_executor_across_checkpoints_and_reopen afba974fcbbcb9ac 18 67b9d4e1f9b0970f +engine_matches_executor_across_checkpoints_and_reopen afdde9858fd79872 4 2d63146e1655bf14 +engine_matches_executor_across_checkpoints_and_reopen afe3aab100c81b28 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen afe9f814b37f25c5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen aff9262e5b57dcff 6 4c599e6ab6611a56 +engine_matches_executor_across_checkpoints_and_reopen b038d0f80067957e 12 11f9252ce8dadeb1 +engine_matches_executor_across_checkpoints_and_reopen b038d0f80067957e 12 3c5a55724fbeb559 +engine_matches_executor_across_checkpoints_and_reopen b038d0f80067957e 12 437343aea9f9930b +engine_matches_executor_across_checkpoints_and_reopen b038d0f80067957e 6 e9f3ef25377a629e +engine_matches_executor_across_checkpoints_and_reopen b038d0f80067957e 6 f5b22044ca12680d +engine_matches_executor_across_checkpoints_and_reopen b053b198fecda115 3 dfc709430522e7d8 +engine_matches_executor_across_checkpoints_and_reopen b056145c805d4a62 13 af986cac76239e4a +engine_matches_executor_across_checkpoints_and_reopen b0635f1c3d0f6232 100 990381a0d7471002 +engine_matches_executor_across_checkpoints_and_reopen b0635f1c3d0f6232 198 a295b38a972a455b +engine_matches_executor_across_checkpoints_and_reopen b0635f1c3d0f6232 306 b3f266712202a04b +engine_matches_executor_across_checkpoints_and_reopen b0635f1c3d0f6232 348 898fbdcea3afb5d5 +engine_matches_executor_across_checkpoints_and_reopen b0635f1c3d0f6232 37 1dcede62998d6764 +engine_matches_executor_across_checkpoints_and_reopen b079e9b761a47591 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen b08d4588abde8af1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b1695bbaec05d474 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b1a24977dd7bd37b 1 ff2ec67c0fc3b7aa +engine_matches_executor_across_checkpoints_and_reopen b1bd5636aa144ad0 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen b1c9e3983359e7ac 6 c369485b5f37d49f +engine_matches_executor_across_checkpoints_and_reopen b1f73abaa183c7ff 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen b20bb5ad1720645e 18 8f5ff12b787df1ae +engine_matches_executor_across_checkpoints_and_reopen b23902d559148257 1 3420549d9686942d +engine_matches_executor_across_checkpoints_and_reopen b239afa448e7e45d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b23b3729df839c6f 6 b4b1e964ac56252c +engine_matches_executor_across_checkpoints_and_reopen b24ccf359474d229 2 843bb90e43e406c3 +engine_matches_executor_across_checkpoints_and_reopen b25a21467ebdd21a 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen b286141383c25583 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b29d013fa2a12058 2 91354be013e1f0bb +engine_matches_executor_across_checkpoints_and_reopen b2a8cadce7b3aad0 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen b2c56b330784a343 12 6d5f0f6a2721b39d +engine_matches_executor_across_checkpoints_and_reopen b2ef1a61c11e9942 6 64d778a92d95baa6 +engine_matches_executor_across_checkpoints_and_reopen b33fd8bdf2754671 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b35104f6b08e4e2b 12 43b7e885d6f10365 +engine_matches_executor_across_checkpoints_and_reopen b35104f6b08e4e2b 18 3e8df8db84971c46 +engine_matches_executor_across_checkpoints_and_reopen b35104f6b08e4e2b 24 bc3f0459eed80e05 +engine_matches_executor_across_checkpoints_and_reopen b35104f6b08e4e2b 30 d9f2ae2d3aeb6c16 +engine_matches_executor_across_checkpoints_and_reopen b35104f6b08e4e2b 6 21bff0010da6e5a2 +engine_matches_executor_across_checkpoints_and_reopen b3587ac332b39d9f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b36140f8c0a12553 72 9dfc2c11ab619f05 +engine_matches_executor_across_checkpoints_and_reopen b3635fa8ccda283d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b3bb1c3298a46e02 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen b414dace36cec98f 8 6ec48ab3b9e7c027 +engine_matches_executor_across_checkpoints_and_reopen b41fb13d5bb1d284 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b421b31bbb198fa4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b451648d3125d08d 5 48270ff9f563bc99 +engine_matches_executor_across_checkpoints_and_reopen b4b4b7d36131c961 16 9068935ea5556dd1 +engine_matches_executor_across_checkpoints_and_reopen b4ce8d8ab3cdb879 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b4fb7d9d533dbc9f 2 d0ef367a5325838d +engine_matches_executor_across_checkpoints_and_reopen b50d98f9ec521279 6 d7264077dca1890a +engine_matches_executor_across_checkpoints_and_reopen b52ac79be5994555 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b52ac79be5994555 1 69d34b0102501287 +engine_matches_executor_across_checkpoints_and_reopen b57c661a1179f816 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b5999de71ec63f0b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b5d95288e26ea08b 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen b5dbb89bbf08e7d5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b5faf5bae3c7dc0a 5 31fe0d791953e42a +engine_matches_executor_across_checkpoints_and_reopen b608a0f0a975499f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b623371304a1ffa1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b6236760b027b39d 5 674f39543c9bf611 +engine_matches_executor_across_checkpoints_and_reopen b658c4eac8c86ae9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b6762ecd03e37ef8 1 d8054e5592aedb2e +engine_matches_executor_across_checkpoints_and_reopen b6951007bf016ead 5 9aa3b6fd82624172 +engine_matches_executor_across_checkpoints_and_reopen b70059e2dbc0dc2d 12 476309068ae10adc +engine_matches_executor_across_checkpoints_and_reopen b730169ecf0065c3 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen b754c06ce0e6d717 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen b79b5aa87f297848 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen b79b5aa87f297848 16 e6584de8d575340f +engine_matches_executor_across_checkpoints_and_reopen b79b5aa87f297848 25 6c71d0b469e8fded +engine_matches_executor_across_checkpoints_and_reopen b79b5aa87f297848 4 9bb94d523b910521 +engine_matches_executor_across_checkpoints_and_reopen b79b5aa87f297848 9 7eed4d82afb62e73 +engine_matches_executor_across_checkpoints_and_reopen b7a3df8652d4b2e6 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen b7f22e608e187ca4 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen b808637e7bd3985a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b81625798f26827d 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen b81625798f26827d 16 e6584de8d575340f +engine_matches_executor_across_checkpoints_and_reopen b81625798f26827d 25 6c71d0b469e8fded +engine_matches_executor_across_checkpoints_and_reopen b81625798f26827d 4 9bb94d523b910521 +engine_matches_executor_across_checkpoints_and_reopen b81625798f26827d 9 7eed4d82afb62e73 +engine_matches_executor_across_checkpoints_and_reopen b829f990a701c50b 12 ac5efaf6e4bfe009 +engine_matches_executor_across_checkpoints_and_reopen b829f990a701c50b 18 8d2089a49048843e +engine_matches_executor_across_checkpoints_and_reopen b829f990a701c50b 24 5d79304cbca41e1b +engine_matches_executor_across_checkpoints_and_reopen b829f990a701c50b 30 d3f35d1b787d2d82 +engine_matches_executor_across_checkpoints_and_reopen b829f990a701c50b 6 9d8524af4f9c2c3f +engine_matches_executor_across_checkpoints_and_reopen b851d1509ce98650 84 ff983fc8af211725 +engine_matches_executor_across_checkpoints_and_reopen b8682fa7ab8c0e57 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b86f2ea17c8fb9cf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b8e0b506551caad9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b98d76f090b4c7fc 3 1550a0a9912ebeaf +engine_matches_executor_across_checkpoints_and_reopen b99f16fe67f4704b 84 2181658a65247eb1 +engine_matches_executor_across_checkpoints_and_reopen b9c1693cfe21278c 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen b9d1bbcfc5dff18b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen b9ef43cca7dfe21b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ba5bc1a5aa29e540 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ba7c52af4faeb177 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ba83e0662ef8bb03 8 83fb1f87c9b5de5b +engine_matches_executor_across_checkpoints_and_reopen ba8a33ce837e5b15 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen baba09a3259f55b1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bb35b8295268cffc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bb38f0e3086f8587 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen bb3cb40abd795735 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bb423741feb5e56a 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen bb58d7ef2e22ca69 4 c5ccfd726fafa813 +engine_matches_executor_across_checkpoints_and_reopen bb5abae4100a466f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bb96ae6fc648554e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bc0ebe0cd6c7cc5c 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen bc19f4e1a90dd6aa 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bc403fdf3fc22db1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bc5be5aa0c526477 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen bc71df08b59c859b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bc8491f61da9021b 3 138f357547a401df +engine_matches_executor_across_checkpoints_and_reopen bcbb5d8512ab2a5b 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen bce8c3ef4cc1068b 13 4bc69f7f37d45dee +engine_matches_executor_across_checkpoints_and_reopen bcf09dd965310d1b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bd074e847651042f 39 9fde725e415d69a7 +engine_matches_executor_across_checkpoints_and_reopen bd10597c2e72be5b 2 826d132e0086ad50 +engine_matches_executor_across_checkpoints_and_reopen bd314d5aee645ca9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bd395080463d5695 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bd6187dec73b1a60 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen bd6f028a719a26bb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bdbc72951891b99d 2 4ac6fbb661ab1b38 +engine_matches_executor_across_checkpoints_and_reopen be0fecd094af5283 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen be1413b107b41e6b 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen be4f8f15c23e3402 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen be5c986a71fdcf17 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen bf6ddb44f9e5707c 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen bf71f107de913be1 1 844ae97cd5c86f64 +engine_matches_executor_across_checkpoints_and_reopen bfab4a88257a7232 12 2dab216f197598c1 +engine_matches_executor_across_checkpoints_and_reopen bfab4a88257a7232 3 c92580b4a540e8f1 +engine_matches_executor_across_checkpoints_and_reopen bfab4a88257a7232 6 45ca3e62e57c334d +engine_matches_executor_across_checkpoints_and_reopen bfab4a88257a7232 9 332172c300c36409 +engine_matches_executor_across_checkpoints_and_reopen bfda51e2733b0480 8 7dc5b17501687d70 +engine_matches_executor_across_checkpoints_and_reopen bffdde325cd46204 3 d8dbefadddb9dc30 +engine_matches_executor_across_checkpoints_and_reopen bffe20e1708bbffd 95 392d3d2b9e4de5cd +engine_matches_executor_across_checkpoints_and_reopen bfffa41f018ed40a 96 35f93b0cd503d2a5 +engine_matches_executor_across_checkpoints_and_reopen c033f5073b31bf69 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c0340d4daafe9d5d 2 9af7c7a28481726d +engine_matches_executor_across_checkpoints_and_reopen c034525caf47873c 121 d8c04980dec4ca48 +engine_matches_executor_across_checkpoints_and_reopen c034525caf47873c 145 2671d0c5fd2fc477 +engine_matches_executor_across_checkpoints_and_reopen c034525caf47873c 166 fef9e030f3665cb7 +engine_matches_executor_across_checkpoints_and_reopen c034525caf47873c 61 140a95f667deb6a4 +engine_matches_executor_across_checkpoints_and_reopen c034525caf47873c 94 894d1d97f23764cd +engine_matches_executor_across_checkpoints_and_reopen c0542c7ac9b69de8 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen c0aef7aedacb0bf7 1 99bad883d8b821dd +engine_matches_executor_across_checkpoints_and_reopen c0aef7aedacb0bf7 16 b2c8e8e25939ab99 +engine_matches_executor_across_checkpoints_and_reopen c0aef7aedacb0bf7 25 182558fbb1492b9b +engine_matches_executor_across_checkpoints_and_reopen c0aef7aedacb0bf7 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen c0aef7aedacb0bf7 9 8025d3b06be63fb1 +engine_matches_executor_across_checkpoints_and_reopen c11dbda72b20776e 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen c145253bfa732832 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c14a8a5fb37bb79c 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen c19dc281e032875a 3 54ce163e49a737a7 +engine_matches_executor_across_checkpoints_and_reopen c1d66ecccb8f76b5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c1d8b16b9562ea88 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c1e232120d0802b4 2 d0ef367a5325838d +engine_matches_executor_across_checkpoints_and_reopen c211a199dad1cd48 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c25a6832438b9e48 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen c27a6fe03c7c6d2a 2 670616e81c94b537 +engine_matches_executor_across_checkpoints_and_reopen c2853dacb1666874 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c2c30a6044c145ba 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen c2c6cc7f27eba6c2 8 0bee0937e9fdc92c +engine_matches_executor_across_checkpoints_and_reopen c2c8800bf2933d98 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c2d7780c9655b0eb 15 74a2776dc8ee912c +engine_matches_executor_across_checkpoints_and_reopen c2dd2be66260b592 2 0495a8a6918be0f4 +engine_matches_executor_across_checkpoints_and_reopen c2de7f87cb2e3f86 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c2f4f8838dbbf321 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c310b2e100244d90 12 06dba2c2b98ae181 +engine_matches_executor_across_checkpoints_and_reopen c312763a4a1c5aea 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen c3224f0f07a4737a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c3224f0f07a4737a 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen c334057c2d037438 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen c378d200c32cc29b 3 e40edea33ab884b0 +engine_matches_executor_across_checkpoints_and_reopen c3a270019a21f1b0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c3b35c1f4741a7d4 2 0de3e678b8a32d78 +engine_matches_executor_across_checkpoints_and_reopen c3bc244125aa119b 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen c3bc244125aa119b 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen c3bc244125aa119b 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen c3bc244125aa119b 4 b4db417880bbc4f9 +engine_matches_executor_across_checkpoints_and_reopen c3bc244125aa119b 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen c3e20a72b919c8ab 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen c3e844fbc7bd2269 4 8db39cbd3f6f643c +engine_matches_executor_across_checkpoints_and_reopen c3ed47ac829e40aa 5 a6351dd912a01994 +engine_matches_executor_across_checkpoints_and_reopen c4195248d28a8296 114 158321fb562363d3 +engine_matches_executor_across_checkpoints_and_reopen c42577a1d0cd74bb 12 e1cc084cd66ee9ad +engine_matches_executor_across_checkpoints_and_reopen c49e6472418ed342 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen c49fd45e70b9dea2 8 56da82560c2a3989 +engine_matches_executor_across_checkpoints_and_reopen c4a5a2c41853cea5 9 aafd9c32b0609d82 +engine_matches_executor_across_checkpoints_and_reopen c4a74268a1d5c6cb 2 400fc96da32be273 +engine_matches_executor_across_checkpoints_and_reopen c4aa62630301a7ed 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c4c02f498159ebb0 2 c00d7ea0e541ef03 +engine_matches_executor_across_checkpoints_and_reopen c4d64c4f36523d12 8 bb7afce7481aaa89 +engine_matches_executor_across_checkpoints_and_reopen c4e742b8dbba2377 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen c4f53decdae43432 21 6e875f66cdb85b48 +engine_matches_executor_across_checkpoints_and_reopen c52e582144e4cd65 3 972e3c6cca3bd954 +engine_matches_executor_across_checkpoints_and_reopen c52e582144e4cd65 4 8db39cbd3f6f643c +engine_matches_executor_across_checkpoints_and_reopen c52e582144e4cd65 8 83fb1f87c9b5de5b +engine_matches_executor_across_checkpoints_and_reopen c568b76abe9051fc 2 3cba14159b036c4c +engine_matches_executor_across_checkpoints_and_reopen c57fe2c0b9aa695e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c584dc5071620db8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c5f048e7adf21341 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c5f048e7adf21341 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen c62190720e0489f9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c653abed8ea9525e 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen c65ab5771f714571 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c68d89619b239a7b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c7876ca9092db338 15 efa3bd410d4e131f +engine_matches_executor_across_checkpoints_and_reopen c7987356f5b4416a 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen c7c0d15696cf89c9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c7cf5bcf386fc2f6 167 1b77237508866c5c +engine_matches_executor_across_checkpoints_and_reopen c7e92032a55e1729 24 398d4019728a360d +engine_matches_executor_across_checkpoints_and_reopen c7f14118f7cb6ea5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c7fe9a222722e38d 6 ec509cb124a5dc10 +engine_matches_executor_across_checkpoints_and_reopen c7ff17fe346a18c6 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen c84572b7afa6fa78 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c85173fa92d749a0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c8ee6b923ad0d437 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c936dfcaf4a8c962 34 97dd05adf3c20ca1 +engine_matches_executor_across_checkpoints_and_reopen c951804d6d90f0a4 5 48270ff9f563bc99 +engine_matches_executor_across_checkpoints_and_reopen c9659947eacd55d9 4 5a8c1584f7a93211 +engine_matches_executor_across_checkpoints_and_reopen c9659947eacd55d9 4 5d8abe1a7802cbdd +engine_matches_executor_across_checkpoints_and_reopen c9659947eacd55d9 4 93a680b7d2689da9 +engine_matches_executor_across_checkpoints_and_reopen c98300b94d8c952f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen c98300b94d8c952f 1 72ab9d2934ddeebf +engine_matches_executor_across_checkpoints_and_reopen c9856b07fccba335 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen c9a5ed9b70ce7e3e 18 a47870965d8ebc40 +engine_matches_executor_across_checkpoints_and_reopen c9a5ed9b70ce7e3e 36 6f3f22de92913d1f +engine_matches_executor_across_checkpoints_and_reopen c9a5ed9b70ce7e3e 54 490dc274983b6e7e +engine_matches_executor_across_checkpoints_and_reopen c9a5ed9b70ce7e3e 72 9dfc2c11ab619f05 +engine_matches_executor_across_checkpoints_and_reopen ca314614612ad6dd 12 4ac858146048ec2b +engine_matches_executor_across_checkpoints_and_reopen ca5bfd0892cc8989 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen ca67782e0b74d608 34 cf4d1ae26ec96018 +engine_matches_executor_across_checkpoints_and_reopen ca82973eb7c917b7 7 4c118e0ed8c3fa55 +engine_matches_executor_across_checkpoints_and_reopen ca883fa7c6aee65f 100 53b80245de45553d +engine_matches_executor_across_checkpoints_and_reopen cab4671c23599885 3 a9f432979bf6e055 +engine_matches_executor_across_checkpoints_and_reopen cac07713c3d6c123 4 6f5575d280e0a18d +engine_matches_executor_across_checkpoints_and_reopen cac81c70884ab92b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cb06cdbba5bf2ce8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cb133ab35d3c04e3 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen cb961c311c3cf93b 5 f72ac1ad077329c6 +engine_matches_executor_across_checkpoints_and_reopen cba2fd0d59560b2a 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen cba2fd0d59560b2a 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen cba2fd0d59560b2a 3 b6fa59262e533d19 +engine_matches_executor_across_checkpoints_and_reopen cba2fd0d59560b2a 3 e6dd8deeca389e9e +engine_matches_executor_across_checkpoints_and_reopen cba2fd0d59560b2a 3 f7e6f8edbbe1b780 +engine_matches_executor_across_checkpoints_and_reopen cc13b3d214eec1b2 3 60458418704e9735 +engine_matches_executor_across_checkpoints_and_reopen cc4bcb17693840bd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cc58e7df8e1ce43d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cc58e7df8e1ce43d 18 45fd5d2b790f98b3 +engine_matches_executor_across_checkpoints_and_reopen cc58e7df8e1ce43d 27 a71e88b2c32f69ae +engine_matches_executor_across_checkpoints_and_reopen cc58e7df8e1ce43d 9 f4d27fdfca1c0fb8 +engine_matches_executor_across_checkpoints_and_reopen cc895b2bbda44001 1 6ee4dc1e77bd0b21 +engine_matches_executor_across_checkpoints_and_reopen cc8a2b20744608ac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cce05dd659a8aa82 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ccf4b74ef01f8ff1 12 fe1675751629a00d +engine_matches_executor_across_checkpoints_and_reopen cd06fed505170868 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cd58834fe03df52c 5 1d529cd8654bc5fc +engine_matches_executor_across_checkpoints_and_reopen cd9210cabd0b79ed 1 90ea7f232b73bce7 +engine_matches_executor_across_checkpoints_and_reopen cdc181c0ef5af175 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen cdc181c0ef5af175 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen cdc74e292cfdcd64 8 83fb1f87c9b5de5b +engine_matches_executor_across_checkpoints_and_reopen ce29ea861d9a63e0 15 b468851ef1a1cdf9 +engine_matches_executor_across_checkpoints_and_reopen ce35e61c7e4f3346 3 95adde3810f78a6c +engine_matches_executor_across_checkpoints_and_reopen ce4fbf0c96152863 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen ce6da314bc8b4eb4 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen ce7d24b6e7876e24 1 af144c146cedcd4e +engine_matches_executor_across_checkpoints_and_reopen ce9bf6d2c4b13468 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ceba66f3a0bf9601 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cec3d754ffe58d02 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen cf0f9f2fe0c0b1fd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cf34c667a2a6ee99 79 230aa079500dddae +engine_matches_executor_across_checkpoints_and_reopen cf4f4ee539a5451f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cf5c0d3a74097696 37 dc9433e5aa16ccfa +engine_matches_executor_across_checkpoints_and_reopen cf601c5ee8219d3d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cf8ee2f241ad0601 8 ca174e8d88b7cfcd +engine_matches_executor_across_checkpoints_and_reopen cfb10a39d1285ed0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen cfc41c351e3c983f 25 182558fbb1492b9b +engine_matches_executor_across_checkpoints_and_reopen cfe4f737bddc3588 4 ad8bd214312d10a9 +engine_matches_executor_across_checkpoints_and_reopen cfe4f737bddc3588 6 e9aa76b0d27a6479 +engine_matches_executor_across_checkpoints_and_reopen cfe4f737bddc3588 8 3572bf9a1ffd34d5 +engine_matches_executor_across_checkpoints_and_reopen cfe4f737bddc3588 8 8d06f3b2fc3260e8 +engine_matches_executor_across_checkpoints_and_reopen cfe4f737bddc3588 8 eb6c7a5a17c3168c +engine_matches_executor_across_checkpoints_and_reopen cffb95cd196e3725 9 20f5175f1404b1bc +engine_matches_executor_across_checkpoints_and_reopen d04364bdacfc61c5 150 bac33a7b360bba60 +engine_matches_executor_across_checkpoints_and_reopen d05c2b2a91a58cee 100 b3c295dc9a527f59 +engine_matches_executor_across_checkpoints_and_reopen d05c2b2a91a58cee 16 a2f6b2743f8cc5ff +engine_matches_executor_across_checkpoints_and_reopen d05c2b2a91a58cee 36 2e2a2720f3c88fa5 +engine_matches_executor_across_checkpoints_and_reopen d05c2b2a91a58cee 4 c5df626cfc6f94e4 +engine_matches_executor_across_checkpoints_and_reopen d05c2b2a91a58cee 64 df515aaf301e337a +engine_matches_executor_across_checkpoints_and_reopen d070d812379c9ba4 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen d130e32693163895 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d153bd880f6bfcc7 6 18674433ff6738f0 +engine_matches_executor_across_checkpoints_and_reopen d189a13e30481ce4 11 fdfb9eefc7d6df44 +engine_matches_executor_across_checkpoints_and_reopen d1bae0c8a2e2d225 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d1ce9d7539062f86 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d1ce9d7539062f86 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen d1df206be3b63a1e 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen d2152644e5dd0e09 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen d25f21e810490ef2 323 8519138ad9bddcca +engine_matches_executor_across_checkpoints_and_reopen d291657f90fcaeab 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d2dfc209192dd0c3 2 0902cd9b55681795 +engine_matches_executor_across_checkpoints_and_reopen d30b04425e597bcc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d31060725e4bc48c 9 187fb06fea7acee6 +engine_matches_executor_across_checkpoints_and_reopen d3203e472987f1b0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d33cf3cd61fc526f 4 add2a9873aa7b437 +engine_matches_executor_across_checkpoints_and_reopen d3806ed78d8be427 6 e1753466c4728415 +engine_matches_executor_across_checkpoints_and_reopen d38aec406327e8c4 3 cb355cc9f650b085 +engine_matches_executor_across_checkpoints_and_reopen d3d61c78577d6c56 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d42f696f7b867a3d 16 edbc24ab003cb509 +engine_matches_executor_across_checkpoints_and_reopen d45cc323c6ecc294 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen d45f642736e3a75e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d45ffadd0aa4f16b 12 cdda145c5e817551 +engine_matches_executor_across_checkpoints_and_reopen d45ffadd0aa4f16b 3 41c2c9642f03a638 +engine_matches_executor_across_checkpoints_and_reopen d45ffadd0aa4f16b 6 125405a256c292ce +engine_matches_executor_across_checkpoints_and_reopen d45ffadd0aa4f16b 9 8fdcb97bea2d9339 +engine_matches_executor_across_checkpoints_and_reopen d4919a0a877297cf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d4a088ff37ebaf1b 34 3a07fb9bba899659 +engine_matches_executor_across_checkpoints_and_reopen d4c589512bca8f81 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d4cbc6a96535eed8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d4d0067dbf0cd664 2 6657b3bd97e29d6c +engine_matches_executor_across_checkpoints_and_reopen d4e5f4dbf48c0e3a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d4eb903e14d4377a 12 d0aed1190eb12303 +engine_matches_executor_across_checkpoints_and_reopen d4eb903e14d4377a 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen d50025d6c9838313 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d511dd86ae2ed59c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d511dd86ae2ed59c 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen d53cc3e84c4d8520 10 61786662a674d441 +engine_matches_executor_across_checkpoints_and_reopen d570146cf799aa20 3 c92580b4a540e8f1 +engine_matches_executor_across_checkpoints_and_reopen d596ce657b69d681 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d5d33b5376b30591 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d5d6ea6f1ac03c47 36 6f3f22de92913d1f +engine_matches_executor_across_checkpoints_and_reopen d5fe80903afde214 65 1d5b390aa4bd1cda +engine_matches_executor_across_checkpoints_and_reopen d64bede7b8ef8533 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen d664dce631cafe28 1 d251ad192a466b73 +engine_matches_executor_across_checkpoints_and_reopen d67755e46c051e2f 116 322e47504238e74c +engine_matches_executor_across_checkpoints_and_reopen d67c6f09dd362417 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d69b46c9366e3381 3 7aa1bc07fa786255 +engine_matches_executor_across_checkpoints_and_reopen d6f8d90f668f4280 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d7079ddf62ebf105 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen d7245d529d13f03b 24 743aab6015b9e95a +engine_matches_executor_across_checkpoints_and_reopen d727b4b8d5a25756 18 8f5ff12b787df1ae +engine_matches_executor_across_checkpoints_and_reopen d741405e570daa41 2 400fc96da32be273 +engine_matches_executor_across_checkpoints_and_reopen d741405e570daa41 4 d4beeeb89c6410cf +engine_matches_executor_across_checkpoints_and_reopen d741405e570daa41 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen d744058694154b5d 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen d744bd23b6e83022 1 95e9a2d67cdaf354 +engine_matches_executor_across_checkpoints_and_reopen d74bf339f5c091cb 592 a39b66a71e8befe1 +engine_matches_executor_across_checkpoints_and_reopen d7529406aabe67ba 14 28d3112a62f20e31 +engine_matches_executor_across_checkpoints_and_reopen d762bc124e20b545 6 bd68d19ad7ab7c16 +engine_matches_executor_across_checkpoints_and_reopen d772addb235323ac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d792e51c1a4ecd0c 15 07128e3cc9f9c53a +engine_matches_executor_across_checkpoints_and_reopen d7960dc79207af7a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d7d4d142a97633d5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d7e733dfe54cedbb 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen d7e91a72fd47a9cf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d7f3e800cd1198c8 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen d81ae5f134cae64d 1 d808d65592b1f81d +engine_matches_executor_across_checkpoints_and_reopen d81ae5f134cae64d 2 adcefce1bdf0c70d +engine_matches_executor_across_checkpoints_and_reopen d81ae5f134cae64d 3 0e21b8240d44401a +engine_matches_executor_across_checkpoints_and_reopen d81ae5f134cae64d 6 22bb81d1b9f9b552 +engine_matches_executor_across_checkpoints_and_reopen d81ae5f134cae64d 6 d5f19d03cc6edea3 +engine_matches_executor_across_checkpoints_and_reopen d824fede69cf1435 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d871e022c6bc3371 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d8792555f57825b8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d8796908ad46470a 8 4efea27a5566e557 +engine_matches_executor_across_checkpoints_and_reopen d89fd333f76da383 835 6a931fb978470102 +engine_matches_executor_across_checkpoints_and_reopen d8f9f9173b742b64 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d91a7f89a5170fef 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d91f06b80b8c43e8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen d91f06b80b8c43e8 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen d988291b6a1cf131 150 38bded9076ceb5e9 +engine_matches_executor_across_checkpoints_and_reopen da011ec93dea5339 3 a706e3d53ff3e3eb +engine_matches_executor_across_checkpoints_and_reopen da02a3fb70e885b4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen da094482816351aa 12 2dab216f197598c1 +engine_matches_executor_across_checkpoints_and_reopen da2dc30d2c90d7ca 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen da437b773b782155 12 ae47b40fbf4f995b +engine_matches_executor_across_checkpoints_and_reopen da808b52174bdf30 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dac2f533ee07b25b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dadc7c0308024899 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen db08921dc09ccce6 12 fe1675751629a00d +engine_matches_executor_across_checkpoints_and_reopen db1c49b867812e5f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen db27aefdd073b10b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen db27aefdd073b10b 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen db3ca5f921f1bccb 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen db84ea3bf578cd66 6 5bcff50d2a29af85 +engine_matches_executor_across_checkpoints_and_reopen dbd68f26716e2e7c 12 de92db87231e7d15 +engine_matches_executor_across_checkpoints_and_reopen dbd68f26716e2e7c 15 95bf2b0d725fa850 +engine_matches_executor_across_checkpoints_and_reopen dbd68f26716e2e7c 3 70368f01fac86498 +engine_matches_executor_across_checkpoints_and_reopen dbd68f26716e2e7c 6 4caf4e58d2f71a3d +engine_matches_executor_across_checkpoints_and_reopen dbd68f26716e2e7c 9 d0867478874fb475 +engine_matches_executor_across_checkpoints_and_reopen dbdcfbfbe1a04dd9 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen dc0a8fda9a0999a3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dc39efb4829ce214 8 b0ec0fb2f348a8f8 +engine_matches_executor_across_checkpoints_and_reopen dc638d2b6447110a 1 d9a8561e9f938fde +engine_matches_executor_across_checkpoints_and_reopen dc8374a5deaec97a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dca915079039da6d 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen dcad82fc86b64d3a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dce049282e92b2d9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dcffa5e9b17e6d30 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dd08e05e7234da22 130 d938a2947bb03058 +engine_matches_executor_across_checkpoints_and_reopen dd0b220eb2bc1712 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen dd7965199607f6a2 12 6d5f0f6a2721b39d +engine_matches_executor_across_checkpoints_and_reopen dd7965199607f6a2 16 caa4a2629e02da05 +engine_matches_executor_across_checkpoints_and_reopen dd7965199607f6a2 23 60be68f2e6dfc9db +engine_matches_executor_across_checkpoints_and_reopen dd7965199607f6a2 25 63d9ec9d598222c9 +engine_matches_executor_across_checkpoints_and_reopen dd7965199607f6a2 30 ada5dbe6dc57a340 +engine_matches_executor_across_checkpoints_and_reopen ddc5bf2a667efadd 30 faadea52d714b11e +engine_matches_executor_across_checkpoints_and_reopen ddc664c57852a805 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ddcd9af463d03f3d 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen dde11789dd72028e 2 d502e23700df61b7 +engine_matches_executor_across_checkpoints_and_reopen dde8a8d2053990f3 100 2fb9bc76154f6e93 +engine_matches_executor_across_checkpoints_and_reopen dde8a8d2053990f3 129 aaad515c9e06730b +engine_matches_executor_across_checkpoints_and_reopen dde8a8d2053990f3 153 c8a5362a9b722a07 +engine_matches_executor_across_checkpoints_and_reopen dde8a8d2053990f3 174 f08741e59dba84c8 +engine_matches_executor_across_checkpoints_and_reopen dde8a8d2053990f3 65 6615a1addd482b42 +engine_matches_executor_across_checkpoints_and_reopen de325484de035690 15 b7d0b5c68db9391c +engine_matches_executor_across_checkpoints_and_reopen de3945b98d48b938 39 c72c67dcd63d5043 +engine_matches_executor_across_checkpoints_and_reopen de3f6d0bdf6c8c37 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen de42a0ce0cde53ea 23 9ba61e50fe3514b8 +engine_matches_executor_across_checkpoints_and_reopen dee47b0b2d86839f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen df014b614f3dbb59 3 8cefef79e4d610e2 +engine_matches_executor_across_checkpoints_and_reopen df0d24177e63dd9d 5 25fcbcdf5a3beaea +engine_matches_executor_across_checkpoints_and_reopen df6c8bbc3178ed14 6 2b3b8b38abf31b04 +engine_matches_executor_across_checkpoints_and_reopen df6c8bbc3178ed14 6 5aa7420496fc37bc +engine_matches_executor_across_checkpoints_and_reopen df6c8bbc3178ed14 6 e5d5753f75b888bc +engine_matches_executor_across_checkpoints_and_reopen df754527713b2ef5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen df884bc943347fe0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen df884bc943347fe0 18 45fd5d2b790f98b3 +engine_matches_executor_across_checkpoints_and_reopen df884bc943347fe0 27 a71e88b2c32f69ae +engine_matches_executor_across_checkpoints_and_reopen df884bc943347fe0 9 f4d27fdfca1c0fb8 +engine_matches_executor_across_checkpoints_and_reopen dfbf7429ba98d88a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e00d7164244d6a91 6 d7264077dca1890a +engine_matches_executor_across_checkpoints_and_reopen e052d980ac572abe 18 8ff52a71bb57a804 +engine_matches_executor_across_checkpoints_and_reopen e055ce48a09915dc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e0d657f03446fe04 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen e111fd048d2b964a 150 a7eda0204df457b5 +engine_matches_executor_across_checkpoints_and_reopen e111fd048d2b964a 24 f292068678b09f7d +engine_matches_executor_across_checkpoints_and_reopen e111fd048d2b964a 54 500f00a362424179 +engine_matches_executor_across_checkpoints_and_reopen e111fd048d2b964a 6 73fdaef98d0479a5 +engine_matches_executor_across_checkpoints_and_reopen e111fd048d2b964a 96 35f93b0cd503d2a5 +engine_matches_executor_across_checkpoints_and_reopen e121483e090bb957 3 1056e3766ad41119 +engine_matches_executor_across_checkpoints_and_reopen e13d236e4caa2593 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen e1b664dc8799ff38 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e1c02160341a75c8 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen e1ccc7710634b458 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e1d8ebef23cf5b08 3 138f357547a401df +engine_matches_executor_across_checkpoints_and_reopen e1d8ebef23cf5b08 6 d7264077dca1890a +engine_matches_executor_across_checkpoints_and_reopen e1d8ebef23cf5b08 9 688d36349666ae5e +engine_matches_executor_across_checkpoints_and_reopen e1d8ebef23cf5b08 9 76b7e537eae2e54d +engine_matches_executor_across_checkpoints_and_reopen e1d8ebef23cf5b08 9 aafd9c32b0609d82 +engine_matches_executor_across_checkpoints_and_reopen e2ad7d7fe987e4a8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e2bf1023c2cf8f5a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e2c847426029320c 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen e2fa7b62d6e83860 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e318fd78b0ae2683 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e32ee726602a7aa8 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen e34b73d1b13e7302 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e363e3d59ab07014 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen e3801835549feca5 6 c369485b5f37d49f +engine_matches_executor_across_checkpoints_and_reopen e3e41c56996505d8 100 68bade370efca39f +engine_matches_executor_across_checkpoints_and_reopen e3e41c56996505d8 198 dc4ce1c2115e2525 +engine_matches_executor_across_checkpoints_and_reopen e3e41c56996505d8 306 55ab647a20ab6321 +engine_matches_executor_across_checkpoints_and_reopen e3e41c56996505d8 348 f20dc391b8030461 +engine_matches_executor_across_checkpoints_and_reopen e3e41c56996505d8 37 dc9433e5aa16ccfa +engine_matches_executor_across_checkpoints_and_reopen e3f731c048fc74ff 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e3f731c048fc74ff 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen e441c4c5e91e1851 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen e44a93211acdcfdc 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e4da5dc388b1294e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e4e031e43afa7725 5 edfa8e81a247e6cc +engine_matches_executor_across_checkpoints_and_reopen e4ee5b59d18a856d 148 7b58ca015087406b +engine_matches_executor_across_checkpoints_and_reopen e531c4476248e9b3 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen e5535f28d096f183 12 32f4290d14c39ea9 +engine_matches_executor_across_checkpoints_and_reopen e570a38a4da9e60c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e57295f3cf92e363 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen e57ed2c682f31d5a 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen e5b20cc724ed35b7 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen e5bf563b16bc2d4d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e5e4ab2c5c79c663 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e61fff3f757d783c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e622b00508738052 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e622b00508738052 3 6f595b518c33e6b0 +engine_matches_executor_across_checkpoints_and_reopen e622edc6047d81b0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e64297a384476a48 5 a40fa92fb73e393d +engine_matches_executor_across_checkpoints_and_reopen e6cae33d9955ff1c 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e6d730a7f59a0f9e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e6ecdddfc5679255 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e6f0d7d51491f97a 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e71929b5c69cd49b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e78456e0d11a21fd 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e79a39389afc29c1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e7e7bd7b804ac40c 21 6c9f384dc6ab8f8e +engine_matches_executor_across_checkpoints_and_reopen e7f02e0422b8d92d 1 de3c307e024bac78 +engine_matches_executor_across_checkpoints_and_reopen e7f02e0422b8d92d 16 5d5bb8c2de25a299 +engine_matches_executor_across_checkpoints_and_reopen e7f02e0422b8d92d 36 af674fc80e764dd9 +engine_matches_executor_across_checkpoints_and_reopen e7f02e0422b8d92d 4 e3ce27647f40d44d +engine_matches_executor_across_checkpoints_and_reopen e7f02e0422b8d92d 49 c391b78310286da6 +engine_matches_executor_across_checkpoints_and_reopen e7f07b96bba0ccf1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e7f7098182ee7cd6 100 cf106879b5672327 +engine_matches_executor_across_checkpoints_and_reopen e7fc0f80d7d666a6 8 34d8c622730b2001 +engine_matches_executor_across_checkpoints_and_reopen e812082c04da77ff 12 de92db87231e7d15 +engine_matches_executor_across_checkpoints_and_reopen e812082c04da77ff 15 95bf2b0d725fa850 +engine_matches_executor_across_checkpoints_and_reopen e812082c04da77ff 3 70368f01fac86498 +engine_matches_executor_across_checkpoints_and_reopen e812082c04da77ff 6 4caf4e58d2f71a3d +engine_matches_executor_across_checkpoints_and_reopen e812082c04da77ff 9 d0867478874fb475 +engine_matches_executor_across_checkpoints_and_reopen e8423a89c23950f4 3 cfebdd838ce29455 +engine_matches_executor_across_checkpoints_and_reopen e86da73207ebd026 2 3552c547523335b0 +engine_matches_executor_across_checkpoints_and_reopen e8748cdc1a952c91 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e90a1ef77ef0ceb8 2 3609050103036cdf +engine_matches_executor_across_checkpoints_and_reopen e90fd53be83c0779 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e923c2044f43ea87 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e932256417eca939 42 842edc3637728d09 +engine_matches_executor_across_checkpoints_and_reopen e94992ac1dd8cdc3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e95e9856a3949307 1 172f08ba9c63e405 +engine_matches_executor_across_checkpoints_and_reopen e9be0c25ef1158ba 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen e9d9ce2d72b08970 12 9032ec9cfc48f31e +engine_matches_executor_across_checkpoints_and_reopen e9d9ce2d72b08970 12 b1e7daf66a7f768b +engine_matches_executor_across_checkpoints_and_reopen e9d9ce2d72b08970 3 0709e1530c9e69e6 +engine_matches_executor_across_checkpoints_and_reopen e9d9ce2d72b08970 6 c4d6b299634ec196 +engine_matches_executor_across_checkpoints_and_reopen e9d9ce2d72b08970 9 f292c7a52bbfb656 +engine_matches_executor_across_checkpoints_and_reopen ea0a546cf341cf12 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen ea199eea0a84509f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ea361ec42a4940f3 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ea5a04e89ae21614 3 18a18852d8af9803 +engine_matches_executor_across_checkpoints_and_reopen ea7dfd9c5d58874b 18 a47870965d8ebc40 +engine_matches_executor_across_checkpoints_and_reopen ea7dfd9c5d58874b 36 6f3f22de92913d1f +engine_matches_executor_across_checkpoints_and_reopen ea7dfd9c5d58874b 54 490dc274983b6e7e +engine_matches_executor_across_checkpoints_and_reopen ea7dfd9c5d58874b 72 9dfc2c11ab619f05 +engine_matches_executor_across_checkpoints_and_reopen ea93ad5f0ac3f183 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen eaaccbb02dd651e9 18 4afe62f84f668e3c +engine_matches_executor_across_checkpoints_and_reopen eac33c5b16cbd9be 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ead9ac4f001c434e 157 909a04374f7f52be +engine_matches_executor_across_checkpoints_and_reopen eafd2b34a95bb22e 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen eaffd26e3063dd13 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen eb15c22ea153f572 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen eb4bfb0862ebeb90 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen eb5b04d1c1115ce5 18 d5748d48706e0078 +engine_matches_executor_across_checkpoints_and_reopen eb5bf08cb89531a0 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen eb5bf08cb89531a0 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen eb848d972b25e9d5 96 175ce787cc729ebd +engine_matches_executor_across_checkpoints_and_reopen eb9ed8aade58009d 24 1ee2038ee883f25d +engine_matches_executor_across_checkpoints_and_reopen eba6a50f74c998cf 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ebb53e2046af1ae4 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen ebf63c4ecee89ece 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ec1942e8ff8348d5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ec55b93d1f08758c 6 f5b22044ca12680d +engine_matches_executor_across_checkpoints_and_reopen ec77bbb4cc9e5115 27 a71e88b2c32f69ae +engine_matches_executor_across_checkpoints_and_reopen ecb6b6076a07574d 100 02e0869febf43e2e +engine_matches_executor_across_checkpoints_and_reopen ecdd88993547ba21 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen ecfe67e3c4acfbc3 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen ed43df0fd6a5d81b 6 8fcec5e314f33d7f +engine_matches_executor_across_checkpoints_and_reopen edd1eb57252ce6b1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen edda4d206d91b149 6 dd18bbf42804f263 +engine_matches_executor_across_checkpoints_and_reopen edebeea296042502 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ee0325f7be83f766 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen ee0a1dcefdac51a6 12 b6191fb5fc5afa65 +engine_matches_executor_across_checkpoints_and_reopen ee0a1dcefdac51a6 12 e73ee09cc7ace95d +engine_matches_executor_across_checkpoints_and_reopen ee0a1dcefdac51a6 3 60ba04293f08d31b +engine_matches_executor_across_checkpoints_and_reopen ee0a1dcefdac51a6 6 d4c5192cd4d89a96 +engine_matches_executor_across_checkpoints_and_reopen ee0a1dcefdac51a6 9 a8ae940c8bdf3dbe +engine_matches_executor_across_checkpoints_and_reopen ee15486c45e8e040 6 16da1375f2a94a82 +engine_matches_executor_across_checkpoints_and_reopen ee4764c408808a20 30 a55f38247fb45626 +engine_matches_executor_across_checkpoints_and_reopen ee57d10d7b364373 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ee85564d356fd7be 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen eedb655a92fad5a8 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ef0560545fb58e7e 2 a61a68742dc374c2 +engine_matches_executor_across_checkpoints_and_reopen ef2548d356ea2317 1 d5afeee0fe417b01 +engine_matches_executor_across_checkpoints_and_reopen ef3003a719e5bb07 13 8cd3e54054c6dc7c +engine_matches_executor_across_checkpoints_and_reopen ef5326e4fd198456 6 70b06d654f921286 +engine_matches_executor_across_checkpoints_and_reopen ef7dd8ca25bd386d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen efb7b0df8894d3ab 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen efc8fb31fea48527 9 41dbe62d3248875c +engine_matches_executor_across_checkpoints_and_reopen efdcc315322c6ac0 5 b83f4908583fe274 +engine_matches_executor_across_checkpoints_and_reopen efeb95bfeabdcf02 1 ff2ec67c0fc3b7aa +engine_matches_executor_across_checkpoints_and_reopen efeb95bfeabdcf02 2 23742fb0ed610812 +engine_matches_executor_across_checkpoints_and_reopen efeb95bfeabdcf02 2 7278d471fa75d90f +engine_matches_executor_across_checkpoints_and_reopen f00c113af925ab78 2 344a5a56d95e8222 +engine_matches_executor_across_checkpoints_and_reopen f00c113af925ab78 2 7602b8b1dd2031c1 +engine_matches_executor_across_checkpoints_and_reopen f00c113af925ab78 2 f1b10ab0d647f6b7 +engine_matches_executor_across_checkpoints_and_reopen f020c199476521d4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f045f007fc111283 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f0788a2a44bf6281 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen f09800abe11b7c86 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f0d80709e2a162ff 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f1201830ad9b942f 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f1cf3c697d697e6b 75 a7005e5648e71ab0 +engine_matches_executor_across_checkpoints_and_reopen f1d584937c461879 2 9de41c9d35adb9f3 +engine_matches_executor_across_checkpoints_and_reopen f1e2d172b5c2e71a 1 601e5bcec97f730b +engine_matches_executor_across_checkpoints_and_reopen f1f2bffe45bc0a1d 167 f6ff958c8c5e801b +engine_matches_executor_across_checkpoints_and_reopen f1f4fcf4564b34c7 2 bd8bbd30fb86c454 +engine_matches_executor_across_checkpoints_and_reopen f1fa12d7c8dd1182 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f24b2d9cc86b0dd3 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen f2685073b4537f6b 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen f26a06e5cbf961c1 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f2701b3389cb0071 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f274612de9aad5fc 3 7ea12c01f35984d9 +engine_matches_executor_across_checkpoints_and_reopen f2889a0f96b5a394 16 e6584de8d575340f +engine_matches_executor_across_checkpoints_and_reopen f2eb8be3fde15399 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f2ed868ea1f57b9a 43 e0e57327e652269d +engine_matches_executor_across_checkpoints_and_reopen f34aedf56d008a1d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f3662baa53ef4b82 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen f3bfb31a0bf5f5a9 2 a61a68742dc374c2 +engine_matches_executor_across_checkpoints_and_reopen f3c21d8e373a62b9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f3c4fc393494deac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f3d62f08edaffdbe 4 e3a3e48200a0a5fc +engine_matches_executor_across_checkpoints_and_reopen f4043d1137551235 6 d077fa5600215a07 +engine_matches_executor_across_checkpoints_and_reopen f41c189f59fdd561 3 a6bee7380871d90f +engine_matches_executor_across_checkpoints_and_reopen f456f300900c0c97 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen f48fcb11646977f9 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f490be55a3fcd9b0 6 16da1375f2a94a82 +engine_matches_executor_across_checkpoints_and_reopen f4cae3ab2c1637ed 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f4cae3ab2c1637ed 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen f4db12165672633b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f4e633f58d1d54b6 3 d8dbefadddb9dc30 +engine_matches_executor_across_checkpoints_and_reopen f5253a1de6093e94 1 04b33efa45692bb9 +engine_matches_executor_across_checkpoints_and_reopen f533e102427b842d 9 dc0e89f9c7e2c31a +engine_matches_executor_across_checkpoints_and_reopen f53dea54a8c78f96 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen f5ae4be3040b2196 1 a006d93e27ee99ab +engine_matches_executor_across_checkpoints_and_reopen f5c0914ae75195a4 4 9bb94d523b910521 +engine_matches_executor_across_checkpoints_and_reopen f5d58306a811f2a5 16 0c62dcbe78642f82 +engine_matches_executor_across_checkpoints_and_reopen f5e30413e85890f0 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen f603f336a41dbbad 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f60d5eaecc51fbc3 3 901ee687b20c92e8 +engine_matches_executor_across_checkpoints_and_reopen f6653c952fa929d5 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f67d09205d4c6fe2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f68a8ba9ea9db5ac 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f7084dbc8eac52cd 2 165c3461e0fdcca5 +engine_matches_executor_across_checkpoints_and_reopen f7344ac718317d0a 1 99bad883d8b821dd +engine_matches_executor_across_checkpoints_and_reopen f7344ac718317d0a 16 b2c8e8e25939ab99 +engine_matches_executor_across_checkpoints_and_reopen f7344ac718317d0a 25 182558fbb1492b9b +engine_matches_executor_across_checkpoints_and_reopen f7344ac718317d0a 4 a016bb0c65291141 +engine_matches_executor_across_checkpoints_and_reopen f7344ac718317d0a 9 8025d3b06be63fb1 +engine_matches_executor_across_checkpoints_and_reopen f737ff388ef3915b 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen f78d1360f78c95f7 12 e8ee335a6003b271 +engine_matches_executor_across_checkpoints_and_reopen f78d1360f78c95f7 18 4b962f179874ce46 +engine_matches_executor_across_checkpoints_and_reopen f78d1360f78c95f7 24 d525d644807968c9 +engine_matches_executor_across_checkpoints_and_reopen f78d1360f78c95f7 30 a55f38247fb45626 +engine_matches_executor_across_checkpoints_and_reopen f78d1360f78c95f7 6 64d778a92d95baa6 +engine_matches_executor_across_checkpoints_and_reopen f7a9cdc207ad743b 1 bd5fc6f0d95f60cd +engine_matches_executor_across_checkpoints_and_reopen f7a9cdc207ad743b 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen f7a9cdc207ad743b 4 ac01b96d51ed3fa3 +engine_matches_executor_across_checkpoints_and_reopen f7a9cdc207ad743b 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen f7a9cdc207ad743b 7 2ebc2e797e806464 +engine_matches_executor_across_checkpoints_and_reopen f7e67a687a2a90ca 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f82b62d9ed544213 2 91354de013e1f421 +engine_matches_executor_across_checkpoints_and_reopen f8626667c41b28d8 9 8ca71f9b8089854b +engine_matches_executor_across_checkpoints_and_reopen f869c32dd064c39d 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f8fa9016c3858192 12 5cdc20067e6e40b1 +engine_matches_executor_across_checkpoints_and_reopen f8fa9016c3858192 3 280df05b87730ad6 +engine_matches_executor_across_checkpoints_and_reopen f8fa9016c3858192 6 d7e0f8ed096cb869 +engine_matches_executor_across_checkpoints_and_reopen f8fa9016c3858192 9 cc451edf7c407500 +engine_matches_executor_across_checkpoints_and_reopen f908d2bbe5b655f7 12 cdda145c5e817551 +engine_matches_executor_across_checkpoints_and_reopen f9173b04f3dfb2b0 6 70b06d654f921286 +engine_matches_executor_across_checkpoints_and_reopen f9357053dbec4556 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen f938f757e56d94b6 6 45ca3e62e57c334d +engine_matches_executor_across_checkpoints_and_reopen f9508d43258a9619 1 17aa6399587da023 +engine_matches_executor_across_checkpoints_and_reopen f96f5ee77fcd9c41 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen f9a9fcd3e6eecc7d 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen f9ba1ded78d906ec 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fa63cdaf79596f7f 2 86bd2c7a526e97fd +engine_matches_executor_across_checkpoints_and_reopen fa9451ac19c3a074 1 2b0a3a192b55558b +engine_matches_executor_across_checkpoints_and_reopen fa964c7aacf2b3db 6 4caf4e58d2f71a3d +engine_matches_executor_across_checkpoints_and_reopen fab334098d87e286 4 feb9196f7fff18b5 +engine_matches_executor_across_checkpoints_and_reopen fadb347c9e0bdbed 114 2edf26b5caf773ab +engine_matches_executor_across_checkpoints_and_reopen fafb214c7475c636 4 c85c2256280d6152 +engine_matches_executor_across_checkpoints_and_reopen fb11e284fac8ac72 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fb441fa135c14162 4 2887891473b7ca25 +engine_matches_executor_across_checkpoints_and_reopen fb4dfd54b1d8603e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fb64a67b20fd3745 3 30648b85fdf25569 +engine_matches_executor_across_checkpoints_and_reopen fb99bc69bb5c317f 1 c3f77eeec1657e38 +engine_matches_executor_across_checkpoints_and_reopen fbdb74079af161c0 2 d69b4a517d2cc546 +engine_matches_executor_across_checkpoints_and_reopen fbee3fc53c3e45ea 3 6526f0696876a02f +engine_matches_executor_across_checkpoints_and_reopen fbf42e554bc579f3 8 b92f8e05d0d9724e +engine_matches_executor_across_checkpoints_and_reopen fbf6cf1f9fa31b9b 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fc14cbc1f4468b07 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fc34f499749808d4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fc38f634cf89c0b2 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fc3bf7d6a8cfa6e9 9 f4d27fdfca1c0fb8 +engine_matches_executor_across_checkpoints_and_reopen fc5e1846ccaa9262 10 b5ae1711d5e51afb +engine_matches_executor_across_checkpoints_and_reopen fc60da2457021f36 2 dd5187ca97af06b9 +engine_matches_executor_across_checkpoints_and_reopen fc6fb97a762e4659 49 1173ab68adb3e8a8 +engine_matches_executor_across_checkpoints_and_reopen fceadc5130774153 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fd1848351649b8bd 12 9d936610709bcdd9 +engine_matches_executor_across_checkpoints_and_reopen fd6672da00d14266 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fd7c0bdd496d3762 2 c70b48a0fbacf660 +engine_matches_executor_across_checkpoints_and_reopen fda9d4a7af61989a 12 6d5f0f6a2721b39d +engine_matches_executor_across_checkpoints_and_reopen fdcdf9c8a95561d0 17 b60d9877bcaad67e +engine_matches_executor_across_checkpoints_and_reopen fdf09fc019cdadde 1 cce6be2e1764baec +engine_matches_executor_across_checkpoints_and_reopen fe3102d22fa968c4 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen fe3fad897753500d 84 9511e0ef6a48f3ce +engine_matches_executor_across_checkpoints_and_reopen fe54010f36a81119 2 400fc96da32be273 +engine_matches_executor_across_checkpoints_and_reopen fe54010f36a81119 4 d4beeeb89c6410cf +engine_matches_executor_across_checkpoints_and_reopen fe54010f36a81119 6 861eb491878c8fca +engine_matches_executor_across_checkpoints_and_reopen fe770d6f5ccd9d84 6 967c5c6d5a844ffb +engine_matches_executor_across_checkpoints_and_reopen fe8f3837a4886aee 1 687565f6b7ea5ded +engine_matches_executor_across_checkpoints_and_reopen feb3fd7021daa2a2 2 cbb58e52af0e0313 +engine_matches_executor_across_checkpoints_and_reopen feddf5dd3502c879 22 975bc14609632ae8 +engine_matches_executor_across_checkpoints_and_reopen fee34c0c83f27f2e 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ff08dd19d6370c33 0 cbf29ce484222325 +engine_matches_executor_across_checkpoints_and_reopen ff2d79784729d821 1 77b2edc4a1fd9338 +engine_matches_executor_across_checkpoints_and_reopen ffd5159b7608c081 96 04e08083113c9801 +engine_matches_executor_across_checkpoints_and_reopen fff08bfb3f05ad55 150 28fc38d7d31324f7 +engine_matches_executor_across_checkpoints_and_reopen fff08bfb3f05ad55 24 79ea8703d69e7659 +engine_matches_executor_across_checkpoints_and_reopen fff08bfb3f05ad55 54 a3a71ce818ab892b +engine_matches_executor_across_checkpoints_and_reopen fff08bfb3f05ad55 6 a23fbe14418efb53 +engine_matches_executor_across_checkpoints_and_reopen fff08bfb3f05ad55 96 3f61ceaccf5e9785 +engine_matches_executor_across_checkpoints_and_reopen fff512fc56593ba8 1 af144c146cedcd4e +engine_matches_executor_in_memory 000b050197d3ccf7 48 549e677ee65c16f1 +engine_matches_executor_in_memory 0015fad8270361cf 12 713cac63084fa059 +engine_matches_executor_in_memory 001f9b0cdde6f188 5 c2e4890abeb04ef9 +engine_matches_executor_in_memory 008c38c612de6cf6 0 cbf29ce484222325 +engine_matches_executor_in_memory 009a0124d365f9d3 24 bc3f0459eed80e05 +engine_matches_executor_in_memory 01187dcf462224e1 1 c3f77eeec1657e38 +engine_matches_executor_in_memory 0122853a4a46431a 4 8db39cbd3f6f643c +engine_matches_executor_in_memory 0123990b3c2c4228 9 1f3c5eb0d219b224 +engine_matches_executor_in_memory 014829292b6ba30b 78 dc4469f778fde468 +engine_matches_executor_in_memory 014c8dda674c80a7 1 0650de74ddbdc8e4 +engine_matches_executor_in_memory 01b4183ea20c7317 6 18674433ff6738f0 +engine_matches_executor_in_memory 02225853a4ebf3ac 0 cbf29ce484222325 +engine_matches_executor_in_memory 0239b9fff996bef9 0 cbf29ce484222325 +engine_matches_executor_in_memory 026f13d965a95088 1 2b0a3a192b55558b +engine_matches_executor_in_memory 02c76f9888ea640c 3 adfee00140c30310 +engine_matches_executor_in_memory 02f5038f439cbded 0 cbf29ce484222325 +engine_matches_executor_in_memory 03666cb2e92b6abe 0 cbf29ce484222325 +engine_matches_executor_in_memory 03cc8ea3edba0de6 12 515b63929da42b0f +engine_matches_executor_in_memory 03cc8ea3edba0de6 3 adfee00140c30310 +engine_matches_executor_in_memory 03cc8ea3edba0de6 6 33227bf297dc2fac +engine_matches_executor_in_memory 03cc8ea3edba0de6 9 5bd4e58745983525 +engine_matches_executor_in_memory 03e45093c1cf6461 0 cbf29ce484222325 +engine_matches_executor_in_memory 0452867efc287fc5 65 6615a1addd482b42 +engine_matches_executor_in_memory 0459590c1815c54f 0 cbf29ce484222325 +engine_matches_executor_in_memory 045962cf31c5d4a4 0 cbf29ce484222325 +engine_matches_executor_in_memory 0469cae43f75c0c0 5 9a56e215e0e47753 +engine_matches_executor_in_memory 047acfa349896387 0 cbf29ce484222325 +engine_matches_executor_in_memory 04f568e4515c6cd5 0 cbf29ce484222325 +engine_matches_executor_in_memory 05106a4daa1f25c1 12 4ac858146048ec2b +engine_matches_executor_in_memory 05106a4daa1f25c1 29 82963ded38219180 +engine_matches_executor_in_memory 05106a4daa1f25c1 3 f56f857e49d50c9f +engine_matches_executor_in_memory 05106a4daa1f25c1 56 e8e5957794cefc6b +engine_matches_executor_in_memory 052667448c65b0aa 0 cbf29ce484222325 +engine_matches_executor_in_memory 05484949324b6738 0 cbf29ce484222325 +engine_matches_executor_in_memory 054c89554ab9e170 0 cbf29ce484222325 +engine_matches_executor_in_memory 05732e1af84ede1d 12 39485df0c5341e49 +engine_matches_executor_in_memory 05732e1af84ede1d 18 ce529b68cd7f17f6 +engine_matches_executor_in_memory 05732e1af84ede1d 24 ddfb5c148ca4b8c9 +engine_matches_executor_in_memory 05732e1af84ede1d 6 0ad0488b47d1c3be +engine_matches_executor_in_memory 05d6f7c6ae66e4b8 4 09bb376159ad3d90 +engine_matches_executor_in_memory 05dda33b4b758b68 12 fe1675751629a00d +engine_matches_executor_in_memory 0613943be2626516 2 af0baac2c60bd53b +engine_matches_executor_in_memory 0617bd6c19bbc478 2 fef2cacccac0967f +engine_matches_executor_in_memory 06557fda75577d51 100 444d0179a79ef317 +engine_matches_executor_in_memory 06557fda75577d51 129 09c8d795a89a72be +engine_matches_executor_in_memory 06557fda75577d51 153 efcd48515b3c16d2 +engine_matches_executor_in_memory 06557fda75577d51 65 bace5c29a4bdb5ff +engine_matches_executor_in_memory 0659b143935b0d65 0 cbf29ce484222325 +engine_matches_executor_in_memory 06642df9c21473a1 1 81e5007182b29744 +engine_matches_executor_in_memory 067148060f4a2172 0 cbf29ce484222325 +engine_matches_executor_in_memory 06aedf0b080b92e7 1 17aa6399587da023 +engine_matches_executor_in_memory 06d7819d5a1f8c17 2 043bcdf2e77e0fa5 +engine_matches_executor_in_memory 070361d88c71ad9c 1 af144c146cedcd4e +engine_matches_executor_in_memory 07196659ccdf7344 0 cbf29ce484222325 +engine_matches_executor_in_memory 0738b2c5cdfd5404 0 cbf29ce484222325 +engine_matches_executor_in_memory 07437cd6d794bb55 0 cbf29ce484222325 +engine_matches_executor_in_memory 075492556eb39b85 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 075a6d662baff8de 0 cbf29ce484222325 +engine_matches_executor_in_memory 079cfc36bff196d2 5 3fabd2a839185437 +engine_matches_executor_in_memory 07ad38fc20a2958b 200 ce5708eaab786136 +engine_matches_executor_in_memory 07ad38fc20a2958b 387 d0ff8f0c66c1d1cb +engine_matches_executor_in_memory 07ad38fc20a2958b 612 f944749513ce682f +engine_matches_executor_in_memory 07ad38fc20a2958b 65 6a704160801fc391 +engine_matches_executor_in_memory 07c7310b72c6dd83 4 2b1e1bdf2d001b19 +engine_matches_executor_in_memory 07da424a27a6e049 4 e3ce27647f40d44d +engine_matches_executor_in_memory 07da554dc14c2f56 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 07e2d18f0fec80d8 6 967c5c6d5a844ffb +engine_matches_executor_in_memory 0862d78d01527159 0 cbf29ce484222325 +engine_matches_executor_in_memory 089d78dc131c7375 12 e5eef43644a946e9 +engine_matches_executor_in_memory 08b5e25a3630dd56 0 cbf29ce484222325 +engine_matches_executor_in_memory 08c0a2250a85bb71 101 42052a6004d3ab3f +engine_matches_executor_in_memory 0972e23311ffad51 3 280df05b87730ad6 +engine_matches_executor_in_memory 099b01f1b3124061 3 9277156909ee2a23 +engine_matches_executor_in_memory 09b423d876ab8f59 3 2751db75b62b5cbe +engine_matches_executor_in_memory 09bbc2ca862967af 8 2830fb548d86db8a +engine_matches_executor_in_memory 0a33b38987ea2598 0 cbf29ce484222325 +engine_matches_executor_in_memory 0a5a35e97e4bec43 10 ac8017774bf19f7d +engine_matches_executor_in_memory 0a5cac8fc9674a39 4 a01af21913e40d01 +engine_matches_executor_in_memory 0a7f7881ac8bd84d 0 cbf29ce484222325 +engine_matches_executor_in_memory 0a9d4726d46291a7 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 0aa21d3ea28c19f7 0 cbf29ce484222325 +engine_matches_executor_in_memory 0b11e501e01e0826 95 e17b0e62f0b4d9ff +engine_matches_executor_in_memory 0b169e79616a0f18 6 0e7421042f63c82c +engine_matches_executor_in_memory 0b37fda71f9f3fff 1 d8054e5592aedb2e +engine_matches_executor_in_memory 0b5415931eacb9e6 24 f292068678b09f7d +engine_matches_executor_in_memory 0b54f32de56b59e5 10 4a316bbaa771a7fb +engine_matches_executor_in_memory 0b54f32de56b59e5 4 5c72f8882c87073a +engine_matches_executor_in_memory 0b54f32de56b59e5 6 d077fa5600215a07 +engine_matches_executor_in_memory 0b54f32de56b59e5 8 7f2fea02558d8d74 +engine_matches_executor_in_memory 0b61248fdcf3ab1c 2 c70b48a0fbacf660 +engine_matches_executor_in_memory 0b61248fdcf3ab1c 3 a9f432979bf6e055 +engine_matches_executor_in_memory 0b61248fdcf3ab1c 4 fff0cf5422a798f4 +engine_matches_executor_in_memory 0b61248fdcf3ab1c 5 25fcbcdf5a3beaea +engine_matches_executor_in_memory 0b751b3a3508dcc0 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 0ba9d91d16ac8ab5 0 cbf29ce484222325 +engine_matches_executor_in_memory 0bfc5bc0d85cf582 0 cbf29ce484222325 +engine_matches_executor_in_memory 0c18d909d926b0f2 2 9223fa0539ed5745 +engine_matches_executor_in_memory 0c752f067da1b6c0 34 5a093831feed4394 +engine_matches_executor_in_memory 0d07bc7bceff1f22 34 1c6767c1b0da220b +engine_matches_executor_in_memory 0d213eadfa3fc387 1 04b33efa45692bb9 +engine_matches_executor_in_memory 0d6c1e4bc82fa7f3 0 cbf29ce484222325 +engine_matches_executor_in_memory 0db7b367e7fb6312 1 d808d65592b1f81d +engine_matches_executor_in_memory 0dc4c999be7bb5e7 12 32f4290d14c39ea9 +engine_matches_executor_in_memory 0dc4c999be7bb5e7 18 ed71e9284ee3eada +engine_matches_executor_in_memory 0dc4c999be7bb5e7 24 79e1d31cd9d1f6a9 +engine_matches_executor_in_memory 0dc4c999be7bb5e7 6 87b4f8fbb61769c2 +engine_matches_executor_in_memory 0e0b6c2b3a2026dc 0 cbf29ce484222325 +engine_matches_executor_in_memory 0e2e91be119fe791 0 cbf29ce484222325 +engine_matches_executor_in_memory 0e2e91be119fe791 3 f7c2fffb9375f5e7 +engine_matches_executor_in_memory 0e2e91be119fe791 6 458eecda77c33287 +engine_matches_executor_in_memory 0e485ef95f54ae20 0 cbf29ce484222325 +engine_matches_executor_in_memory 0e9c9b606a025dde 2 adcefce1bdf0c70d +engine_matches_executor_in_memory 0eb88d15175e7752 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 0ee394feb753f55a 0 cbf29ce484222325 +engine_matches_executor_in_memory 0f54c5f204304ea2 0 cbf29ce484222325 +engine_matches_executor_in_memory 0f616f8b8dcc04f5 7 5ae1cdeeeba37934 +engine_matches_executor_in_memory 0f6fbd2a4f3cc36d 0 cbf29ce484222325 +engine_matches_executor_in_memory 0f6fbd2a4f3cc36d 3 7aa1bc07fa786255 +engine_matches_executor_in_memory 0f6fbd2a4f3cc36d 6 dd18bbf42804f263 +engine_matches_executor_in_memory 0f81ce6094200cd8 1 2b0a3a192b55558b +engine_matches_executor_in_memory 0fab9b58f3a55b01 0 cbf29ce484222325 +engine_matches_executor_in_memory 0fb3ae726f8cccd9 12 fe1675751629a00d +engine_matches_executor_in_memory 0fb4b1587024bc10 3 2bf04f04e1243264 +engine_matches_executor_in_memory 1003fc8c258507d3 1 0ea3b784283ac215 +engine_matches_executor_in_memory 101748bc06b07fb6 12 354e058f8d6dbf7f +engine_matches_executor_in_memory 101f028f52ae2602 0 cbf29ce484222325 +engine_matches_executor_in_memory 10310be9fa2f75fa 5 b25ddf4253ca8815 +engine_matches_executor_in_memory 10aa0f58c8b10074 0 cbf29ce484222325 +engine_matches_executor_in_memory 10dae0aa19225f09 30 e22fa4c18e483eca +engine_matches_executor_in_memory 11083b7a39d09811 12 e5eef43644a946e9 +engine_matches_executor_in_memory 11083b7a39d09811 18 25be0c7cdc625594 +engine_matches_executor_in_memory 11083b7a39d09811 18 48b148bc08eb0b3c +engine_matches_executor_in_memory 11083b7a39d09811 3 9277156909ee2a23 +engine_matches_executor_in_memory 113951426e5b418d 10 2871baa61cf62133 +engine_matches_executor_in_memory 1155703c1e0812b4 16 7c8ada434af11c37 +engine_matches_executor_in_memory 117902ffc53f45c6 0 cbf29ce484222325 +engine_matches_executor_in_memory 11a93397dd96298c 0 cbf29ce484222325 +engine_matches_executor_in_memory 11ab748ecbe0c39e 2 a1ae4f40f66aa14a +engine_matches_executor_in_memory 11b2dd4c602717b6 0 cbf29ce484222325 +engine_matches_executor_in_memory 11c04184157c1f87 12 43b7e885d6f10365 +engine_matches_executor_in_memory 11d242d2d8411c1e 0 cbf29ce484222325 +engine_matches_executor_in_memory 11f52030cd2f59ae 0 cbf29ce484222325 +engine_matches_executor_in_memory 1210b29fe9cb5c4e 0 cbf29ce484222325 +engine_matches_executor_in_memory 1243bc96c3c22668 3 cb355cc9f650b085 +engine_matches_executor_in_memory 126a6da081cebf2f 1 58b8dd4d3d545d11 +engine_matches_executor_in_memory 12c31c6cf9ce138c 0 cbf29ce484222325 +engine_matches_executor_in_memory 12d1bf04e04dd4bf 3 7ea12c01f35984d9 +engine_matches_executor_in_memory 12f8504698759e10 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 1306a865be779f67 0 cbf29ce484222325 +engine_matches_executor_in_memory 1314739d04ccd55f 3 18a18852d8af9803 +engine_matches_executor_in_memory 1315e49228f3ead7 0 cbf29ce484222325 +engine_matches_executor_in_memory 1327ebaaa438ce0b 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 1327ebaaa438ce0b 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 1327ebaaa438ce0b 3 b6fa59262e533d19 +engine_matches_executor_in_memory 1327ebaaa438ce0b 3 e6dd8deeca389e9e +engine_matches_executor_in_memory 134562ea28052cb5 3 d8dbefadddb9dc30 +engine_matches_executor_in_memory 134562ea28052cb5 5 48270ff9f563bc99 +engine_matches_executor_in_memory 134562ea28052cb5 7 752c17b2b4a444d4 +engine_matches_executor_in_memory 134562ea28052cb5 9 f1f9dde166aa3e79 +engine_matches_executor_in_memory 136de343fb44466f 2 86bd2c7a526e97fd +engine_matches_executor_in_memory 13830bdd7d7ea23e 0 cbf29ce484222325 +engine_matches_executor_in_memory 13f03b223fe59f71 0 cbf29ce484222325 +engine_matches_executor_in_memory 142e8aa7aac31ee5 0 cbf29ce484222325 +engine_matches_executor_in_memory 14375fd0974ca9aa 1 c3f77eeec1657e38 +engine_matches_executor_in_memory 1455ac0ebd6ee35b 0 cbf29ce484222325 +engine_matches_executor_in_memory 146bc1da0e5484fc 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 14c27b997732e21a 0 cbf29ce484222325 +engine_matches_executor_in_memory 1501511c46053119 0 cbf29ce484222325 +engine_matches_executor_in_memory 15793c7c2972dbcd 18 d5748d48706e0078 +engine_matches_executor_in_memory 15b3bf894fe7f813 1 17aa6399587da023 +engine_matches_executor_in_memory 15ee0b82cce8f2fe 0 cbf29ce484222325 +engine_matches_executor_in_memory 160468808ce6a89b 1 de3c307e024bac78 +engine_matches_executor_in_memory 160468808ce6a89b 16 5d5bb8c2de25a299 +engine_matches_executor_in_memory 160468808ce6a89b 36 af674fc80e764dd9 +engine_matches_executor_in_memory 160468808ce6a89b 4 e3ce27647f40d44d +engine_matches_executor_in_memory 1626f40184abce51 3 07ae4731ce3b3fc3 +engine_matches_executor_in_memory 163e5d41d5814d21 9 c82b16d8a00787f0 +engine_matches_executor_in_memory 16ade6d5af888462 5 f64b648c4a4ed56c +engine_matches_executor_in_memory 16f650f35d025b9b 17 4b2a923567950807 +engine_matches_executor_in_memory 171ccc349fef204c 0 cbf29ce484222325 +engine_matches_executor_in_memory 17c403cdab48346d 9 babe89c55f990c15 +engine_matches_executor_in_memory 17fc63301f3bce81 2 826d132e0086ad50 +engine_matches_executor_in_memory 17ff55c7aa1cd7c4 0 cbf29ce484222325 +engine_matches_executor_in_memory 180ddb4cebce50c6 3 8422728fc1519fd7 +engine_matches_executor_in_memory 185153268aabdcee 0 cbf29ce484222325 +engine_matches_executor_in_memory 1876fdeda04d6042 1 601e5bcec97f730b +engine_matches_executor_in_memory 187df45d0299a6c7 0 cbf29ce484222325 +engine_matches_executor_in_memory 18a92e10d34aa6c0 1 d251ad192a466b73 +engine_matches_executor_in_memory 18bd0cb945fce33a 5 6193fcda33904ef8 +engine_matches_executor_in_memory 19985cf7c198db9d 3 95adde3810f78a6c +engine_matches_executor_in_memory 19ee705d7c8a2112 0 cbf29ce484222325 +engine_matches_executor_in_memory 19f019340a6c525d 18 25be0c7cdc625594 +engine_matches_executor_in_memory 1a05dfa473010581 3 47584621149b75df +engine_matches_executor_in_memory 1a66b9405c4b91de 16 53a0dc2d990cf59c +engine_matches_executor_in_memory 1a902ab06b4e5963 1 ff2ec67c0fc3b7aa +engine_matches_executor_in_memory 1aca65c67e5e4053 0 cbf29ce484222325 +engine_matches_executor_in_memory 1acda422a7b22b36 0 cbf29ce484222325 +engine_matches_executor_in_memory 1acda422a7b22b36 1 601e5bcec97f730b +engine_matches_executor_in_memory 1acda422a7b22b36 2 d502e23700df61b7 +engine_matches_executor_in_memory 1acda422a7b22b36 4 2887891473b7ca25 +engine_matches_executor_in_memory 1adb3071e24c7622 1 04b33efa45692bb9 +engine_matches_executor_in_memory 1ae59ef0baf54d21 24 79ea8703d69e7659 +engine_matches_executor_in_memory 1b22ec416ece0a50 1 04b33efa45692bb9 +engine_matches_executor_in_memory 1b2439475dfbd0f9 0 cbf29ce484222325 +engine_matches_executor_in_memory 1bbbc729f325e716 0 cbf29ce484222325 +engine_matches_executor_in_memory 1bf407461aaed490 9 257ff00e97b032c5 +engine_matches_executor_in_memory 1c561f1081c0bbec 0 cbf29ce484222325 +engine_matches_executor_in_memory 1c561f1081c0bbec 3 cb355cc9f650b085 +engine_matches_executor_in_memory 1ccaa649ab5029a7 8 ba1e04019687bed3 +engine_matches_executor_in_memory 1ce784a500a957c3 0 cbf29ce484222325 +engine_matches_executor_in_memory 1ceb3073cd67b7ed 1 de3c307e024bac78 +engine_matches_executor_in_memory 1cf8ea4fd12600d6 24 f292068678b09f7d +engine_matches_executor_in_memory 1d226824a402df40 0 cbf29ce484222325 +engine_matches_executor_in_memory 1d43a7ffd415fce0 1 d808d65592b1f81d +engine_matches_executor_in_memory 1d4dbdf29b1b3253 2 66eef2eb76c3791b +engine_matches_executor_in_memory 1d612640f335af21 0 cbf29ce484222325 +engine_matches_executor_in_memory 1e0280c7f0c5c321 6 861eb491878c8fca +engine_matches_executor_in_memory 1e084b0600bcd109 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 1e494f2d9a18860d 34 bab200d1618e4dd5 +engine_matches_executor_in_memory 1e4c631d27d0ae10 42 c0c2aa482f9249d2 +engine_matches_executor_in_memory 1e4c631d27d0ae10 64 13fc0d03532b7e39 +engine_matches_executor_in_memory 1e4c631d27d0ae10 82 f53835411076ab85 +engine_matches_executor_in_memory 1e4c631d27d0ae10 98 7cac5d3d18ebd892 +engine_matches_executor_in_memory 1e5627056673fd8b 16 caa4a2629e02da05 +engine_matches_executor_in_memory 1e84887c8dafc781 0 cbf29ce484222325 +engine_matches_executor_in_memory 1e877a9786a0f7e6 0 cbf29ce484222325 +engine_matches_executor_in_memory 1e8fc85fa9314b67 6 125405a256c292ce +engine_matches_executor_in_memory 1ee7333ba0d87bee 0 cbf29ce484222325 +engine_matches_executor_in_memory 1f0602670a99401a 12 cc2b1bdab54294bb +engine_matches_executor_in_memory 1f351fcaa3a351a1 0 cbf29ce484222325 +engine_matches_executor_in_memory 1f57e7bd771d04a1 3 a9f432979bf6e055 +engine_matches_executor_in_memory 1fa27bfbb3d21b6c 0 cbf29ce484222325 +engine_matches_executor_in_memory 1fa51be7ecd7e6ef 4 09bb376159ad3d90 +engine_matches_executor_in_memory 1fa51be7ecd7e6ef 4 5dfcd2146e828f37 +engine_matches_executor_in_memory 1fa51be7ecd7e6ef 4 acbc6d9f0c52a136 +engine_matches_executor_in_memory 1fabd9b19d4db3ec 0 cbf29ce484222325 +engine_matches_executor_in_memory 1fbca73566102685 5 ddcf853d801c97eb +engine_matches_executor_in_memory 1fc6ad9e1011c647 18 8f5ff12b787df1ae +engine_matches_executor_in_memory 1fc6ad9e1011c647 27 af597e5fa00c92d9 +engine_matches_executor_in_memory 1fc6ad9e1011c647 36 5032dba31996734b +engine_matches_executor_in_memory 1fc6ad9e1011c647 9 f66974282bfc4de4 +engine_matches_executor_in_memory 1fec03ffd76c411d 0 cbf29ce484222325 +engine_matches_executor_in_memory 200a0e6e9836de69 0 cbf29ce484222325 +engine_matches_executor_in_memory 201c3fe1929ed3bc 1 af144c146cedcd4e +engine_matches_executor_in_memory 206d1fbe99079e05 0 cbf29ce484222325 +engine_matches_executor_in_memory 20c89517b4c0752e 1 b18871f0d59a8bc2 +engine_matches_executor_in_memory 214c5e48c3643f83 0 cbf29ce484222325 +engine_matches_executor_in_memory 2184ac9699168002 1 8c8788e481e31b2e +engine_matches_executor_in_memory 21a5babd2bbbfd71 0 cbf29ce484222325 +engine_matches_executor_in_memory 21cc8cbad89f1763 0 cbf29ce484222325 +engine_matches_executor_in_memory 2213223373d624a1 13 7e3f3ec8055f230c +engine_matches_executor_in_memory 221402e38099f04f 5 92ed8a96edd4efae +engine_matches_executor_in_memory 226d41d7d86029fb 12 65a6beca2cd75161 +engine_matches_executor_in_memory 226d41d7d86029fb 3 cd8f0522a739b22e +engine_matches_executor_in_memory 226d41d7d86029fb 6 18674433ff6738f0 +engine_matches_executor_in_memory 226d41d7d86029fb 9 958513356c4496a4 +engine_matches_executor_in_memory 22b6e6e7d100760b 0 cbf29ce484222325 +engine_matches_executor_in_memory 230e2eecfe7ebf34 0 cbf29ce484222325 +engine_matches_executor_in_memory 23261723aabbb60f 0 cbf29ce484222325 +engine_matches_executor_in_memory 23918c11b4364008 4 e3ce27647f40d44d +engine_matches_executor_in_memory 23c808c2f10873e5 1 04b33efa45692bb9 +engine_matches_executor_in_memory 23d401e2ba3e2c8c 0 cbf29ce484222325 +engine_matches_executor_in_memory 241abc5c294f499d 69 e8b35bb6c4ee67cf +engine_matches_executor_in_memory 242cacefd09cce22 2 3552c547523335b0 +engine_matches_executor_in_memory 24e11d47edbb9367 0 cbf29ce484222325 +engine_matches_executor_in_memory 24e31a9b5c05e178 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 24e31a9b5c05e178 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 24e31a9b5c05e178 3 b6fa59262e533d19 +engine_matches_executor_in_memory 24e31a9b5c05e178 4 c85c2256280d6152 +engine_matches_executor_in_memory 24f624cb6500052e 5 aae2bd875aee1684 +engine_matches_executor_in_memory 2595f86d6561531a 0 cbf29ce484222325 +engine_matches_executor_in_memory 260c377c93711e2b 5 3649b789177ca8a7 +engine_matches_executor_in_memory 264a658e1f43d812 6 d077fa5600215a07 +engine_matches_executor_in_memory 266433ad25de0555 0 cbf29ce484222325 +engine_matches_executor_in_memory 2666347df5a46d0a 1 d1c8bd90077e4faf +engine_matches_executor_in_memory 2666347df5a46d0a 12 e8e12c96cf0ee98d +engine_matches_executor_in_memory 2666347df5a46d0a 2 a61a68742dc374c2 +engine_matches_executor_in_memory 2666347df5a46d0a 7 5c0ccd63ac05e796 +engine_matches_executor_in_memory 268987f840b3811b 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 26a2a0e4c866657e 100 990381a0d7471002 +engine_matches_executor_in_memory 272834b1ba782e47 3 6f595b518c33e6b0 +engine_matches_executor_in_memory 2757f79ec41a2761 0 cbf29ce484222325 +engine_matches_executor_in_memory 278018cbf46a3615 60 5e74e8ed3384e589 +engine_matches_executor_in_memory 2791eb9445a3bc20 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 2791eb9445a3bc20 2 86bd2c7a526e97fd +engine_matches_executor_in_memory 2791eb9445a3bc20 4 ac01b96d51ed3fa3 +engine_matches_executor_in_memory 2791eb9445a3bc20 6 861eb491878c8fca +engine_matches_executor_in_memory 2794d22a9fde8337 6 a23fbe14418efb53 +engine_matches_executor_in_memory 27d6b31bb626c0a3 0 cbf29ce484222325 +engine_matches_executor_in_memory 27dd6131c99c1228 12 43b7e885d6f10365 +engine_matches_executor_in_memory 27dd6131c99c1228 18 3e8df8db84971c46 +engine_matches_executor_in_memory 27dd6131c99c1228 24 bc3f0459eed80e05 +engine_matches_executor_in_memory 27dd6131c99c1228 6 21bff0010da6e5a2 +engine_matches_executor_in_memory 27f93e2a87409680 9 6380498d2813d364 +engine_matches_executor_in_memory 282e570faa5cfa74 0 cbf29ce484222325 +engine_matches_executor_in_memory 28d0297448ac2796 2 3609050103036cdf +engine_matches_executor_in_memory 28d0ca5c87b7accd 24 91bb9a8395167992 +engine_matches_executor_in_memory 28d4d98b789205c0 1 04b33efa45692bb9 +engine_matches_executor_in_memory 290768110c8d9b35 0 cbf29ce484222325 +engine_matches_executor_in_memory 290d2b0d0d8714c7 0 cbf29ce484222325 +engine_matches_executor_in_memory 291f5805a9733f98 0 cbf29ce484222325 +engine_matches_executor_in_memory 293725c14f000af8 0 cbf29ce484222325 +engine_matches_executor_in_memory 293c881df3b2ec93 2 91354de013e1f421 +engine_matches_executor_in_memory 296559a08ed18e39 15 d2b20a7e3382fd5a +engine_matches_executor_in_memory 299cf8ff28e4a468 1 99bad883d8b821dd +engine_matches_executor_in_memory 29b37b82fb7907d9 2 fef2cacccac0967f +engine_matches_executor_in_memory 29cb23c66b508c8b 12 a99b7926c6a6c397 +engine_matches_executor_in_memory 29cb23c66b508c8b 3 8cefef79e4d610e2 +engine_matches_executor_in_memory 29cb23c66b508c8b 6 e1753466c4728415 +engine_matches_executor_in_memory 29cb23c66b508c8b 9 26ea09bda2041a83 +engine_matches_executor_in_memory 2a0eff23ad0beb81 5 b14c05bd122002c3 +engine_matches_executor_in_memory 2a6cec114d042ac2 2 2ec11106f22303e6 +engine_matches_executor_in_memory 2a6cec114d042ac2 2 7514b511b93da0a9 +engine_matches_executor_in_memory 2a6cec114d042ac2 2 a14f00fc126f8f18 +engine_matches_executor_in_memory 2b5858a8b8bb4b97 8 b6c60b9b1aa6bea6 +engine_matches_executor_in_memory 2b93010ff331a20f 3 9c0b41361d9ad4e7 +engine_matches_executor_in_memory 2c03bcb65bd70413 49 24bd0de9f6ed8e75 +engine_matches_executor_in_memory 2c42ea57481b1f2f 0 cbf29ce484222325 +engine_matches_executor_in_memory 2ca3ef96af161aca 30 3f3ecd0461f8d9ca +engine_matches_executor_in_memory 2ccc89d35f48ff0e 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 2ccfd377013ea7be 0 cbf29ce484222325 +engine_matches_executor_in_memory 2d083e210e8f146a 12 e8e12c96cf0ee98d +engine_matches_executor_in_memory 2d083e210e8f146a 3 cfebdd838ce29455 +engine_matches_executor_in_memory 2d083e210e8f146a 6 caf5fd7df73c383b +engine_matches_executor_in_memory 2d083e210e8f146a 9 5d9a3e35cf697559 +engine_matches_executor_in_memory 2d5200291f296293 3 7ea12c01f35984d9 +engine_matches_executor_in_memory 2dc29926511577d7 6 125405a256c292ce +engine_matches_executor_in_memory 2dc9cfd6dc0eb8a1 12 05e8aabfda4a4add +engine_matches_executor_in_memory 2dc9cfd6dc0eb8a1 16 1348a20b0d70dea9 +engine_matches_executor_in_memory 2dc9cfd6dc0eb8a1 46 ea4a0beba6a435bd +engine_matches_executor_in_memory 2dc9cfd6dc0eb8a1 50 36da8993e4b7bc65 +engine_matches_executor_in_memory 2dcc8bdf751548e4 12 cdda145c5e817551 +engine_matches_executor_in_memory 2dcc8bdf751548e4 3 41c2c9642f03a638 +engine_matches_executor_in_memory 2dcc8bdf751548e4 6 125405a256c292ce +engine_matches_executor_in_memory 2dcc8bdf751548e4 9 8fdcb97bea2d9339 +engine_matches_executor_in_memory 2e3bcbb86a3f8d07 1 601e5acec97f7158 +engine_matches_executor_in_memory 2e4226fd3f432809 0 cbf29ce484222325 +engine_matches_executor_in_memory 2e64d6b5787236ca 0 cbf29ce484222325 +engine_matches_executor_in_memory 2e9c3232393f4325 0 cbf29ce484222325 +engine_matches_executor_in_memory 2ea55dab6ed710a2 0 cbf29ce484222325 +engine_matches_executor_in_memory 2ebd971d495fb53e 12 d0aed1190eb12303 +engine_matches_executor_in_memory 2f290a75958a5ba7 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 2f5a349531a98f7f 100 2fb9bc76154f6e93 +engine_matches_executor_in_memory 2fa45bbebdaa1cbd 2 fef2cacccac0967f +engine_matches_executor_in_memory 2fa684e9f910d11d 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 2fb39d7972800e4d 0 cbf29ce484222325 +engine_matches_executor_in_memory 2fcd98591f1eeacb 6 5c444bd52b26befc +engine_matches_executor_in_memory 2fd3c7a703757e99 6 c369485b5f37d49f +engine_matches_executor_in_memory 2ff2aea9841cca95 6 dd18bbf42804f263 +engine_matches_executor_in_memory 3068d7a9c659b1d2 100 cf106879b5672327 +engine_matches_executor_in_memory 3068d7a9c659b1d2 129 e524f8b163d5a9cf +engine_matches_executor_in_memory 3068d7a9c659b1d2 153 674eb5ea7cefb25d +engine_matches_executor_in_memory 3068d7a9c659b1d2 65 1d5b390aa4bd1cda +engine_matches_executor_in_memory 30e8823bcacfa913 0 cbf29ce484222325 +engine_matches_executor_in_memory 312ea446bd64e8a9 12 39485df0c5341e49 +engine_matches_executor_in_memory 31a854ebd4cda015 64 df515aaf301e337a +engine_matches_executor_in_memory 320264133e623810 9 f66974282bfc4de4 +engine_matches_executor_in_memory 326a47fb70d4e447 0 cbf29ce484222325 +engine_matches_executor_in_memory 329be71c4d9b96ca 6 d4c5192cd4d89a96 +engine_matches_executor_in_memory 32a3ef8553af4236 188 f58ef6820a393b60 +engine_matches_executor_in_memory 32a3ef8553af4236 363 3de4dea94af26d3f +engine_matches_executor_in_memory 32a3ef8553af4236 580 27cb60e407134434 +engine_matches_executor_in_memory 32a3ef8553af4236 61 f596bab0c6202a59 +engine_matches_executor_in_memory 32daf09370e49cb1 0 cbf29ce484222325 +engine_matches_executor_in_memory 331f9ecba0c566ac 100 68bade370efca39f +engine_matches_executor_in_memory 332a483c0f56e81a 1 04b33efa45692bb9 +engine_matches_executor_in_memory 33b10d1b04615d6b 3 f3dd195b655a762c +engine_matches_executor_in_memory 33f732ea354534e3 1 d808d65592b1f81d +engine_matches_executor_in_memory 34086781bbdc301d 24 398d4019728a360d +engine_matches_executor_in_memory 34086781bbdc301d 54 238393ae1b86e9a2 +engine_matches_executor_in_memory 34086781bbdc301d 6 4c599e6ab6611a56 +engine_matches_executor_in_memory 34086781bbdc301d 96 175ce787cc729ebd +engine_matches_executor_in_memory 344f63db3a51c135 2 fef2cacccac0967f +engine_matches_executor_in_memory 34f7e29a03bf80e5 0 cbf29ce484222325 +engine_matches_executor_in_memory 356227e15689fc7e 0 cbf29ce484222325 +engine_matches_executor_in_memory 356adc5e95423fc8 100 aa4bbb66c140d197 +engine_matches_executor_in_memory 3579aee733c1eb96 0 cbf29ce484222325 +engine_matches_executor_in_memory 35d3d9eccf3390b5 6 9d8524af4f9c2c3f +engine_matches_executor_in_memory 35f323e99b9b413f 10 475851473d15ec7d +engine_matches_executor_in_memory 35f323e99b9b413f 2 3cba14159b036c4c +engine_matches_executor_in_memory 35f323e99b9b413f 4 e3a3e48200a0a5fc +engine_matches_executor_in_memory 35f323e99b9b413f 7 4b5390923ba91818 +engine_matches_executor_in_memory 360a251bfc9f114b 1 17aa6399587da023 +engine_matches_executor_in_memory 3646f64c5eb7a548 3 fe47719e9e67fad8 +engine_matches_executor_in_memory 3692403df6102ea3 0 cbf29ce484222325 +engine_matches_executor_in_memory 3703c3f98fd0d283 12 2586c30d824a4ccb +engine_matches_executor_in_memory 3703c3f98fd0d283 16 53a0dc2d990cf59c +engine_matches_executor_in_memory 3703c3f98fd0d283 4 54ed403bcdfba5c9 +engine_matches_executor_in_memory 3703c3f98fd0d283 8 2a06eb7fa1c21e28 +engine_matches_executor_in_memory 3706e122bbffef74 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 37967480f1bb520d 49 1b6e19dc8350b662 +engine_matches_executor_in_memory 37aa7219c4807598 3 6ce05a9057f2cc35 +engine_matches_executor_in_memory 3897230e3183c8c9 9 f4d27fdfca1c0fb8 +engine_matches_executor_in_memory 38d627c135e7c018 0 cbf29ce484222325 +engine_matches_executor_in_memory 390b44da3f430053 4 a016bb0c65291141 +engine_matches_executor_in_memory 3915195fe66fe44a 1 af144c146cedcd4e +engine_matches_executor_in_memory 392530b5bacf0631 0 cbf29ce484222325 +engine_matches_executor_in_memory 397075f16b6ad8ad 1 04b33efa45692bb9 +engine_matches_executor_in_memory 397075f16b6ad8ad 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory 397075f16b6ad8ad 3 7ea12c01f35984d9 +engine_matches_executor_in_memory 397075f16b6ad8ad 4 b4db417880bbc4f9 +engine_matches_executor_in_memory 3a23bed37a4dbdd7 0 cbf29ce484222325 +engine_matches_executor_in_memory 3a23d0261aef4168 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 3a3ff8d1cbd40b22 0 cbf29ce484222325 +engine_matches_executor_in_memory 3a4318aa0173749a 6 5aa7420496fc37bc +engine_matches_executor_in_memory 3a83ee23d181b81a 22 923cbb4b62706672 +engine_matches_executor_in_memory 3a8b0266d4a5d19c 12 e8ee335a6003b271 +engine_matches_executor_in_memory 3a8b0266d4a5d19c 18 4b962f179874ce46 +engine_matches_executor_in_memory 3a8b0266d4a5d19c 24 d525d644807968c9 +engine_matches_executor_in_memory 3a8b0266d4a5d19c 6 64d778a92d95baa6 +engine_matches_executor_in_memory 3ab268c7724a7638 5 da1608b3ec41e922 +engine_matches_executor_in_memory 3ab85975eead4d7d 0 cbf29ce484222325 +engine_matches_executor_in_memory 3ab85975eead4d7d 3 66f719885e592e8a +engine_matches_executor_in_memory 3ad74dc8ec3be4ec 0 cbf29ce484222325 +engine_matches_executor_in_memory 3adb2e1eabeabc5b 5 f732dc62a7ed825d +engine_matches_executor_in_memory 3adc1db2b48ed06f 0 cbf29ce484222325 +engine_matches_executor_in_memory 3b75a1473812b914 0 cbf29ce484222325 +engine_matches_executor_in_memory 3ba9cc2762fd870e 0 cbf29ce484222325 +engine_matches_executor_in_memory 3be7ed142bfa2af1 0 cbf29ce484222325 +engine_matches_executor_in_memory 3bffd76ced7ff199 3 7aa1bc07fa786255 +engine_matches_executor_in_memory 3c184a7b642508a1 16 438be19255feff2a +engine_matches_executor_in_memory 3c45d4600a798744 24 1ee2038ee883f25d +engine_matches_executor_in_memory 3c45d4600a798744 54 ab14bf2f996957a7 +engine_matches_executor_in_memory 3c45d4600a798744 6 7c029f89e9a90a65 +engine_matches_executor_in_memory 3c45d4600a798744 96 689cd81e1b638a19 +engine_matches_executor_in_memory 3c751284c2df46f1 12 d0aed1190eb12303 +engine_matches_executor_in_memory 3c751284c2df46f1 6 861eb491878c8fca +engine_matches_executor_in_memory 3c7f6eaa81db7191 12 5507e9eba629875d +engine_matches_executor_in_memory 3c95a8a4da6bf1b5 1 d1f214b56944841f +engine_matches_executor_in_memory 3cccc0a2c68a1d33 6 4caf4e58d2f71a3d +engine_matches_executor_in_memory 3cd3d9351d5ba020 1 04b33efa45692bb9 +engine_matches_executor_in_memory 3cd3d9351d5ba020 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory 3cd3d9351d5ba020 3 7ea12c01f35984d9 +engine_matches_executor_in_memory 3cd3d9351d5ba020 4 b4db417880bbc4f9 +engine_matches_executor_in_memory 3d23511625919d1d 0 cbf29ce484222325 +engine_matches_executor_in_memory 3d303ca6b0978f94 6 a105ddcda2d05dfb +engine_matches_executor_in_memory 3e06b4760c71daf4 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 3e3dce49c2561a99 0 cbf29ce484222325 +engine_matches_executor_in_memory 3e9a7974fed0db68 0 cbf29ce484222325 +engine_matches_executor_in_memory 3ec27c3f984f3e67 321 72cbc11e0d841e0a +engine_matches_executor_in_memory 3ed34b382d19dcbb 16 7c8ada434af11c37 +engine_matches_executor_in_memory 3eedfbf3bc1291ad 0 cbf29ce484222325 +engine_matches_executor_in_memory 3f0091c49c106d73 6 0ad0488b47d1c3be +engine_matches_executor_in_memory 3f012731d679aa50 24 d525d644807968c9 +engine_matches_executor_in_memory 3f1c8ff9d3312034 1 af144c146cedcd4e +engine_matches_executor_in_memory 3f21f23a08d87368 0 cbf29ce484222325 +engine_matches_executor_in_memory 3f3e6d2c23c91dea 0 cbf29ce484222325 +engine_matches_executor_in_memory 3fda20338ef442f9 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 4012d185a25dc295 0 cbf29ce484222325 +engine_matches_executor_in_memory 40249373e2cf9449 24 5b53e79e8bcbab81 +engine_matches_executor_in_memory 40249373e2cf9449 54 f79c6bd42108b8ea +engine_matches_executor_in_memory 40249373e2cf9449 6 70831860fa875f4c +engine_matches_executor_in_memory 40249373e2cf9449 96 04e08083113c9801 +engine_matches_executor_in_memory 404a2b761af148bf 12 ac5efaf6e4bfe009 +engine_matches_executor_in_memory 405f28035a6f9d25 1 99bad883d8b821dd +engine_matches_executor_in_memory 405fe0745e16fa64 0 cbf29ce484222325 +engine_matches_executor_in_memory 40779a562b0897e7 1 592e65f36322ea3b +engine_matches_executor_in_memory 408b8d9fae88b346 0 cbf29ce484222325 +engine_matches_executor_in_memory 40d31f6055fae0ef 0 cbf29ce484222325 +engine_matches_executor_in_memory 40d907bfa487a51f 6 967c5c6d5a844ffb +engine_matches_executor_in_memory 41300cf29328b231 1 fb5cc1e4287b2e07 +engine_matches_executor_in_memory 413760218c503d1d 6 dd18bbf42804f263 +engine_matches_executor_in_memory 41677ca7b78a4788 0 cbf29ce484222325 +engine_matches_executor_in_memory 4179242f8b21c62a 3 0e21b8240d44401a +engine_matches_executor_in_memory 41a65398beb45007 0 cbf29ce484222325 +engine_matches_executor_in_memory 41c79a3ea0deb0c9 12 e5eef43644a946e9 +engine_matches_executor_in_memory 41d18c3547754a1e 2 adcefce1bdf0c70d +engine_matches_executor_in_memory 42334bbc58c2ae24 3 cb355cc9f650b085 +engine_matches_executor_in_memory 424118bfff8b7e7d 3 138f357547a401df +engine_matches_executor_in_memory 424118bfff8b7e7d 6 d7264077dca1890a +engine_matches_executor_in_memory 424118bfff8b7e7d 9 688d36349666ae5e +engine_matches_executor_in_memory 424118bfff8b7e7d 9 76b7e537eae2e54d +engine_matches_executor_in_memory 426830890f9b01eb 1 04b33efa45692bb9 +engine_matches_executor_in_memory 42d3731076c21e7b 1 17aa6399587da023 +engine_matches_executor_in_memory 4342231042a99ecc 0 cbf29ce484222325 +engine_matches_executor_in_memory 435826e30856426e 16 caa4a2629e02da05 +engine_matches_executor_in_memory 435eb563a2478c3b 6 7c029f89e9a90a65 +engine_matches_executor_in_memory 439c4aba3a3b33f6 5 0b2a7003b5c64b14 +engine_matches_executor_in_memory 43cc7940889ba19d 186 c1fe683502536faf +engine_matches_executor_in_memory 43cc7940889ba19d 290 43956a6c503c4821 +engine_matches_executor_in_memory 43cc7940889ba19d 35 385d33c590361697 +engine_matches_executor_in_memory 43cc7940889ba19d 94 43d78c9c8a8ec60c +engine_matches_executor_in_memory 43d48ef090b4c7b0 0 cbf29ce484222325 +engine_matches_executor_in_memory 441aa40eab74b10f 0 cbf29ce484222325 +engine_matches_executor_in_memory 4466c0aca35a7a54 0 cbf29ce484222325 +engine_matches_executor_in_memory 4477b9688742e884 2 86bd2c7a526e97fd +engine_matches_executor_in_memory 447be16fb201dcee 0 cbf29ce484222325 +engine_matches_executor_in_memory 450d1efde88c6f9a 3 2bf04f04e1243264 +engine_matches_executor_in_memory 452c66db1e8be14c 0 cbf29ce484222325 +engine_matches_executor_in_memory 456e6500b5a18d46 0 cbf29ce484222325 +engine_matches_executor_in_memory 459843d6af5a4bf8 0 cbf29ce484222325 +engine_matches_executor_in_memory 45b24a7a93fab4ea 1 d808d65592b1f81d +engine_matches_executor_in_memory 45b24a7a93fab4ea 2 adcefce1bdf0c70d +engine_matches_executor_in_memory 45b24a7a93fab4ea 3 0e21b8240d44401a +engine_matches_executor_in_memory 45b24a7a93fab4ea 6 22bb81d1b9f9b552 +engine_matches_executor_in_memory 45d9672c31744a6c 12 e5eef43644a946e9 +engine_matches_executor_in_memory 45d9672c31744a6c 18 25be0c7cdc625594 +engine_matches_executor_in_memory 45d9672c31744a6c 18 48b148bc08eb0b3c +engine_matches_executor_in_memory 45d9672c31744a6c 3 9277156909ee2a23 +engine_matches_executor_in_memory 45e0ac3a147e3d68 9 870eb89cd61e8f42 +engine_matches_executor_in_memory 45fc4a127bc25abc 1 d1c8bd90077e4faf +engine_matches_executor_in_memory 45fc8a2e66e30322 12 4ac858146048ec2b +engine_matches_executor_in_memory 45fc8a2e66e30322 29 82963ded38219180 +engine_matches_executor_in_memory 45fc8a2e66e30322 3 f56f857e49d50c9f +engine_matches_executor_in_memory 45fc8a2e66e30322 56 e8e5957794cefc6b +engine_matches_executor_in_memory 460d12c9efe947c4 4 9bb94d523b910521 +engine_matches_executor_in_memory 461f6e4ed8027e02 0 cbf29ce484222325 +engine_matches_executor_in_memory 46c70320de5d2948 1 af144c146cedcd4e +engine_matches_executor_in_memory 47130a3fa99fb40c 1 d5afeee0fe417b01 +engine_matches_executor_in_memory 47538798942ef7e0 1 57c34273beddeb94 +engine_matches_executor_in_memory 4761a88f0d9d2a96 2 a61a68742dc374c2 +engine_matches_executor_in_memory 47ce237e51f238b6 0 cbf29ce484222325 +engine_matches_executor_in_memory 481b80fec7debc97 3 f56f857e49d50c9f +engine_matches_executor_in_memory 48aba04199a00a81 5 df60777b351368aa +engine_matches_executor_in_memory 48b20d3c2ed20d09 0 cbf29ce484222325 +engine_matches_executor_in_memory 48b4f38f27e88fab 4 a016bb0c65291141 +engine_matches_executor_in_memory 48b8853738321efa 2 ec5bb16de3d23be2 +engine_matches_executor_in_memory 490902404b51d32b 5 f74e4a6ac6857a8a +engine_matches_executor_in_memory 49c0d48bf7d14a0e 0 cbf29ce484222325 +engine_matches_executor_in_memory 4a0d1438918c9be1 10 39c3951ae27d56f7 +engine_matches_executor_in_memory 4a0d1438918c9be1 10 4fea6fdd630c38b4 +engine_matches_executor_in_memory 4a0d1438918c9be1 10 61786662a674d441 +engine_matches_executor_in_memory 4a12b2df43f651bf 13 1e143a7320c80705 +engine_matches_executor_in_memory 4a2febccf8837aad 3 41c2c9642f03a638 +engine_matches_executor_in_memory 4a7c8e66d64e490b 2 b8ff948a4274c70c +engine_matches_executor_in_memory 4a93b59a6a98f056 1 ff2ec67c0fc3b7aa +engine_matches_executor_in_memory 4a977e0981408e98 0 cbf29ce484222325 +engine_matches_executor_in_memory 4ac379418e942a60 9 21473d56862e061e +engine_matches_executor_in_memory 4ac727c3cc95072d 24 1ee2038ee883f25d +engine_matches_executor_in_memory 4acc3e5e89af8238 0 cbf29ce484222325 +engine_matches_executor_in_memory 4adaeb72411c41ed 3 a7639882cbc1e5b3 +engine_matches_executor_in_memory 4b1996a946cd636d 0 cbf29ce484222325 +engine_matches_executor_in_memory 4b326e2aae84a5b7 1 c3f77eeec1657e38 +engine_matches_executor_in_memory 4b338e3b4c026854 0 cbf29ce484222325 +engine_matches_executor_in_memory 4b7b6f5439d86c11 2 adcefce1bdf0c70d +engine_matches_executor_in_memory 4bfbb1e651196a10 6 e5d5753f75b888bc +engine_matches_executor_in_memory 4cab38a29fda3d2d 0 cbf29ce484222325 +engine_matches_executor_in_memory 4cb356d57fa0fb2b 12 05e8aabfda4a4add +engine_matches_executor_in_memory 4ccf834dfbaef87a 1 76b48d54dad1a495 +engine_matches_executor_in_memory 4cfb3551008e07c3 2 91354be013e1f0bb +engine_matches_executor_in_memory 4d34a90cb1bf6ad4 12 4195c35bf5c5e653 +engine_matches_executor_in_memory 4d34a90cb1bf6ad4 18 d35a70bbe2914d78 +engine_matches_executor_in_memory 4d34a90cb1bf6ad4 24 15b07d178224c4f5 +engine_matches_executor_in_memory 4d34a90cb1bf6ad4 6 52a4ac892f494396 +engine_matches_executor_in_memory 4db0ebefc339fc68 7 752c17b2b4a444d4 +engine_matches_executor_in_memory 4e072f3916542d64 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 4e106632557a0407 1 601e5bcec97f730b +engine_matches_executor_in_memory 4e294fc9d113d7c3 0 cbf29ce484222325 +engine_matches_executor_in_memory 4e8f0bb75d8ae86b 12 1d8ce129fc2cd61f +engine_matches_executor_in_memory 4e8f0bb75d8ae86b 6 5bcff50d2a29af85 +engine_matches_executor_in_memory 4ec97c7cabf5dd91 0 cbf29ce484222325 +engine_matches_executor_in_memory 4ee5908a8ea65449 0 cbf29ce484222325 +engine_matches_executor_in_memory 4ee87d59da70faae 0 cbf29ce484222325 +engine_matches_executor_in_memory 4ee87d59da70faae 3 7aa1bc07fa786255 +engine_matches_executor_in_memory 4ee87d59da70faae 6 dd18bbf42804f263 +engine_matches_executor_in_memory 4f0693e42d8bedb0 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 4f1e0da12317c928 12 6c2473739f72d811 +engine_matches_executor_in_memory 4f1e0da12317c928 16 0c62dcbe78642f82 +engine_matches_executor_in_memory 4f1e0da12317c928 4 a44e29a1993850ce +engine_matches_executor_in_memory 4f1e0da12317c928 8 3157ba75e536ac9e +engine_matches_executor_in_memory 4f2f9be6f47225ff 0 cbf29ce484222325 +engine_matches_executor_in_memory 4f797a443909e75f 12 476309068ae10adc +engine_matches_executor_in_memory 4f797a443909e75f 16 7c8ada434af11c37 +engine_matches_executor_in_memory 4f797a443909e75f 23 2336126d9c11f05f +engine_matches_executor_in_memory 4f797a443909e75f 25 8683362928dc5c61 +engine_matches_executor_in_memory 4fc1a2d1a4bc5928 6 c369485b5f37d49f +engine_matches_executor_in_memory 4ff38e0db318ffd7 0 cbf29ce484222325 +engine_matches_executor_in_memory 4ff38e0db318ffd7 3 6f595b518c33e6b0 +engine_matches_executor_in_memory 503073032cb89195 9 5a01f0e6b5148228 +engine_matches_executor_in_memory 5061a0a86ce16c71 9 4f4c57ec96f57cb1 +engine_matches_executor_in_memory 5087b1d9f6a70245 0 cbf29ce484222325 +engine_matches_executor_in_memory 50accca8f592f5e1 0 cbf29ce484222325 +engine_matches_executor_in_memory 5126ac0dbc911cd4 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 5226c768b367d026 6 caf5fd7df73c383b +engine_matches_executor_in_memory 522da55cf93600f1 6 44fcf5430afde7a2 +engine_matches_executor_in_memory 522f2c61cdba72b4 1 de3c307e024bac78 +engine_matches_executor_in_memory 527044153f8750f0 0 cbf29ce484222325 +engine_matches_executor_in_memory 539225843600e494 0 cbf29ce484222325 +engine_matches_executor_in_memory 539225843600e494 1 a5597ef1b58ef469 +engine_matches_executor_in_memory 539225843600e494 2 ca45b8e68eb2899e +engine_matches_executor_in_memory 53a110c4d6776505 0 cbf29ce484222325 +engine_matches_executor_in_memory 53b1eeaa255e1cd9 0 cbf29ce484222325 +engine_matches_executor_in_memory 53cf1da2f5cc578b 12 5cdc20067e6e40b1 +engine_matches_executor_in_memory 53cf1da2f5cc578b 3 280df05b87730ad6 +engine_matches_executor_in_memory 53cf1da2f5cc578b 6 d7e0f8ed096cb869 +engine_matches_executor_in_memory 53cf1da2f5cc578b 9 cc451edf7c407500 +engine_matches_executor_in_memory 53d419ddec5fc841 10 a8b4d60d94b116bf +engine_matches_executor_in_memory 53d7cfa3f686be01 5 0bf9300a4723ee9c +engine_matches_executor_in_memory 53e6669447d85764 0 cbf29ce484222325 +engine_matches_executor_in_memory 53e6669447d85764 27 04eefaef424c5524 +engine_matches_executor_in_memory 53e6669447d85764 54 757d25d2570e0eb9 +engine_matches_executor_in_memory 53e6669447d85764 9 dc0e89f9c7e2c31a +engine_matches_executor_in_memory 53edbac83e4b9306 0 cbf29ce484222325 +engine_matches_executor_in_memory 53edbac83e4b9306 3 f7c2fffb9375f5e7 +engine_matches_executor_in_memory 53edbac83e4b9306 6 458eecda77c33287 +engine_matches_executor_in_memory 5418835b0cde0d2e 3 fd4ab9da21ba5524 +engine_matches_executor_in_memory 541bf866cc66c25e 9 009ea355574d2996 +engine_matches_executor_in_memory 542e756364b84a9c 2 bce273c5c5e3697e +engine_matches_executor_in_memory 5442d62580dbb17a 1 d8054e5592aedb2e +engine_matches_executor_in_memory 5442d62580dbb17a 2 fef2cacccac0967f +engine_matches_executor_in_memory 5442d62580dbb17a 3 561ee1995d21aa56 +engine_matches_executor_in_memory 5442d62580dbb17a 4 e96cb5244cf0840e +engine_matches_executor_in_memory 5468d1a5a2962796 0 cbf29ce484222325 +engine_matches_executor_in_memory 548426350b5c63ab 1 81849d16bd6e9bae +engine_matches_executor_in_memory 548ebbfb267459ed 12 6d5f0f6a2721b39d +engine_matches_executor_in_memory 548ebbfb267459ed 16 caa4a2629e02da05 +engine_matches_executor_in_memory 548ebbfb267459ed 21 6e875f66cdb85b48 +engine_matches_executor_in_memory 548ebbfb267459ed 24 2f572bfe8ff4d435 +engine_matches_executor_in_memory 5495de1b4b161091 2 a8bc450894057987 +engine_matches_executor_in_memory 54bf1753779e6fd0 5 52a1017611c8c651 +engine_matches_executor_in_memory 54d718419e07e34d 65 a241e85840ee1c32 +engine_matches_executor_in_memory 54f010c787757bd8 3 afbb45863a4e333b +engine_matches_executor_in_memory 54f0f8e62215590a 84 bb342e7116e73ffb +engine_matches_executor_in_memory 54f5e16c1015d097 0 cbf29ce484222325 +engine_matches_executor_in_memory 551b8578c63c9dec 12 06dba2c2b98ae181 +engine_matches_executor_in_memory 551b8578c63c9dec 3 28e71fda4c1b5f3a +engine_matches_executor_in_memory 551b8578c63c9dec 6 16da1375f2a94a82 +engine_matches_executor_in_memory 551b8578c63c9dec 9 a701ba03bb360259 +engine_matches_executor_in_memory 55352678e4e669f5 2 c70b48a0fbacf660 +engine_matches_executor_in_memory 55352678e4e669f5 3 a9f432979bf6e055 +engine_matches_executor_in_memory 55352678e4e669f5 4 fff0cf5422a798f4 +engine_matches_executor_in_memory 55352678e4e669f5 5 25fcbcdf5a3beaea +engine_matches_executor_in_memory 55a1ae50c751a9b6 12 65a6beca2cd75161 +engine_matches_executor_in_memory 55a1ae50c751a9b6 3 cd8f0522a739b22e +engine_matches_executor_in_memory 55a1ae50c751a9b6 6 18674433ff6738f0 +engine_matches_executor_in_memory 55a1ae50c751a9b6 9 958513356c4496a4 +engine_matches_executor_in_memory 55a9a02c38deaad5 3 70368f01fac86498 +engine_matches_executor_in_memory 55b49ccf4aedf497 0 cbf29ce484222325 +engine_matches_executor_in_memory 55f1536afc7b06f7 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 55ffc8cc2e36c8a9 2 8d46e0730917a88f +engine_matches_executor_in_memory 5609919d406e7621 0 cbf29ce484222325 +engine_matches_executor_in_memory 564756437880f649 63 0d33e7366b471c33 +engine_matches_executor_in_memory 56bf83c2cb1a6f98 3 d8dbefadddb9dc30 +engine_matches_executor_in_memory 56bf83c2cb1a6f98 5 48270ff9f563bc99 +engine_matches_executor_in_memory 56bf83c2cb1a6f98 7 752c17b2b4a444d4 +engine_matches_executor_in_memory 56bf83c2cb1a6f98 9 f1f9dde166aa3e79 +engine_matches_executor_in_memory 574656b02e25dd6e 5 455f52009bf64fdc +engine_matches_executor_in_memory 5797777ee8ce2ea4 1 17aa6399587da023 +engine_matches_executor_in_memory 57cc3e3c93c9ee6d 0 cbf29ce484222325 +engine_matches_executor_in_memory 5869f049c86d35ce 0 cbf29ce484222325 +engine_matches_executor_in_memory 586d4985b4cf7f6b 16 b2c8e8e25939ab99 +engine_matches_executor_in_memory 587abd06384f30e4 6 c4d6b299634ec196 +engine_matches_executor_in_memory 58d3d452d78e0d50 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 58d3d452d78e0d50 2 86bd2c7a526e97fd +engine_matches_executor_in_memory 58d3d452d78e0d50 4 ac01b96d51ed3fa3 +engine_matches_executor_in_memory 58d3d452d78e0d50 6 861eb491878c8fca +engine_matches_executor_in_memory 5902230df3e0fdd1 1 088eab074d14a11a +engine_matches_executor_in_memory 5921504ccde3bc49 0 cbf29ce484222325 +engine_matches_executor_in_memory 59b8c1fe6d42b89d 0 cbf29ce484222325 +engine_matches_executor_in_memory 5a027bb225d0b18b 13 8ff5451c277a99a2 +engine_matches_executor_in_memory 5a29d253cecc9eb5 16 9068935ea5556dd1 +engine_matches_executor_in_memory 5a29d253cecc9eb5 36 7650a3ad4ff15551 +engine_matches_executor_in_memory 5a29d253cecc9eb5 4 2b1e1bdf2d001b19 +engine_matches_executor_in_memory 5a2c72580a6acd44 0 cbf29ce484222325 +engine_matches_executor_in_memory 5a33fb5c7dbbcc0d 18 d5748d48706e0078 +engine_matches_executor_in_memory 5a8a89013acc2bc1 1 d8054e5592aedb2e +engine_matches_executor_in_memory 5aed437c70f83ddd 0 cbf29ce484222325 +engine_matches_executor_in_memory 5b1260d27807b5bd 0 cbf29ce484222325 +engine_matches_executor_in_memory 5b3de7174962d355 4 e96cb5244cf0840e +engine_matches_executor_in_memory 5b433788e25e9555 0 cbf29ce484222325 +engine_matches_executor_in_memory 5b5d1fdde8d9c157 12 4a028e9cdab9279f +engine_matches_executor_in_memory 5b5d1fdde8d9c157 3 47584621149b75df +engine_matches_executor_in_memory 5b5d1fdde8d9c157 6 40a7aac6b4fe7cee +engine_matches_executor_in_memory 5b5d1fdde8d9c157 9 a150fde7b0f4d9b1 +engine_matches_executor_in_memory 5bf2c53b65bf2281 3 cd8f0522a739b22e +engine_matches_executor_in_memory 5c0a0ca0f8880e5e 1 d1c8bd90077e4faf +engine_matches_executor_in_memory 5c5619aa9bf252d0 4 b4db417880bbc4f9 +engine_matches_executor_in_memory 5c5a69e46978b56c 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 5c7143c05ddf1ef2 6 72ce49ac42ed5e77 +engine_matches_executor_in_memory 5cf067f0e76a5f0d 2 e14809bc41fd6490 +engine_matches_executor_in_memory 5d12513f719c0dd2 0 cbf29ce484222325 +engine_matches_executor_in_memory 5d2985b5ebe37f3e 95 cab7b4a902104dca +engine_matches_executor_in_memory 5d5b1f4282236d90 9 f1f9dde166aa3e79 +engine_matches_executor_in_memory 5d6d092decc3f66a 3 0709e1530c9e69e6 +engine_matches_executor_in_memory 5d7f3107af6ea22e 0 cbf29ce484222325 +engine_matches_executor_in_memory 5e65fcb2bebf6ae9 0 cbf29ce484222325 +engine_matches_executor_in_memory 5ee17d529f79f418 2 4ac6fbb661ab1b38 +engine_matches_executor_in_memory 5efa048cce7b98b4 1 2b0a3a192b55558b +engine_matches_executor_in_memory 5f09671d51dc6c37 0 cbf29ce484222325 +engine_matches_executor_in_memory 5f1a868c0e46c777 4 c46ec3c90fc731c4 +engine_matches_executor_in_memory 5f1a868c0e46c777 6 6451f224b48e8ac8 +engine_matches_executor_in_memory 5f1a868c0e46c777 8 ba31a3187118f96f +engine_matches_executor_in_memory 5f1a868c0e46c777 8 c1d5f977e9899fca +engine_matches_executor_in_memory 5f20c9520439c350 0 cbf29ce484222325 +engine_matches_executor_in_memory 5f4bcf73a9364981 2 c70b48a0fbacf660 +engine_matches_executor_in_memory 5f5feb889d17423b 0 cbf29ce484222325 +engine_matches_executor_in_memory 5f8e5bc96014c92d 0 cbf29ce484222325 +engine_matches_executor_in_memory 600f24d46260a1b1 3 dae9e9cc898f46e7 +engine_matches_executor_in_memory 6015e430c3f5e858 5 4e08c703ebd6f1bf +engine_matches_executor_in_memory 606d011745b35731 6 21bff0010da6e5a2 +engine_matches_executor_in_memory 60b44a4477c5335f 1 04b33efa45692bb9 +engine_matches_executor_in_memory 60c90051fc8d365a 84 b0e28cff9f0b0296 +engine_matches_executor_in_memory 60d580f5e19e70b7 0 cbf29ce484222325 +engine_matches_executor_in_memory 60ddd8892d3db26b 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 6102509517e53de1 100 02e0869febf43e2e +engine_matches_executor_in_memory 6102509517e53de1 129 7ff00bed09c0e1fd +engine_matches_executor_in_memory 6102509517e53de1 153 290c0e0649e3c613 +engine_matches_executor_in_memory 6102509517e53de1 65 c3243aa6572502bd +engine_matches_executor_in_memory 61177c63891ebfe9 1 2a60efb47f296537 +engine_matches_executor_in_memory 61177c63891ebfe9 2 4ac6fbb661ab1b38 +engine_matches_executor_in_memory 61177c63891ebfe9 6 9b8cc566c0ebff5d +engine_matches_executor_in_memory 61177c63891ebfe9 8 1ed4db4500bcc4d5 +engine_matches_executor_in_memory 6131bc66cbe298a0 0 cbf29ce484222325 +engine_matches_executor_in_memory 62211102150df788 0 cbf29ce484222325 +engine_matches_executor_in_memory 6222450f671d3543 0 cbf29ce484222325 +engine_matches_executor_in_memory 6225a089211b9236 0 cbf29ce484222325 +engine_matches_executor_in_memory 6234f3cf822107ca 0 cbf29ce484222325 +engine_matches_executor_in_memory 627f24f2ad697579 0 cbf29ce484222325 +engine_matches_executor_in_memory 62cd6000b15eacf6 0 cbf29ce484222325 +engine_matches_executor_in_memory 62cd7c47e67f505e 49 d3f9f528cee9292c +engine_matches_executor_in_memory 62ed27c795ac822b 7 bed4ef47a416a22a +engine_matches_executor_in_memory 62f611983a4874b8 12 415fc3b2591f85ff +engine_matches_executor_in_memory 62f611983a4874b8 3 db67d59796fe67d9 +engine_matches_executor_in_memory 62f611983a4874b8 6 4ca910f2bbd47048 +engine_matches_executor_in_memory 62f611983a4874b8 9 c5065b1781e84889 +engine_matches_executor_in_memory 6392c531b0204f52 0 cbf29ce484222325 +engine_matches_executor_in_memory 639a3e5e5c3128fc 0 cbf29ce484222325 +engine_matches_executor_in_memory 639be0c1e6d74086 0 cbf29ce484222325 +engine_matches_executor_in_memory 639be0c1e6d74086 3 66f719885e592e8a +engine_matches_executor_in_memory 63b740a9bb657ce8 15 387714fd31ac02ed +engine_matches_executor_in_memory 63da366521444959 0 cbf29ce484222325 +engine_matches_executor_in_memory 641e8e127aede741 0 cbf29ce484222325 +engine_matches_executor_in_memory 6438c999c4fa6c6c 1 172f08ba9c63e405 +engine_matches_executor_in_memory 646a1544a914eeb7 0 cbf29ce484222325 +engine_matches_executor_in_memory 64c30ff6da11b4bd 10 4a316bbaa771a7fb +engine_matches_executor_in_memory 64d2fa8ef3223a1c 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 655a7b4c0d14f6fb 0 cbf29ce484222325 +engine_matches_executor_in_memory 658b967bcff5612a 3 db67d59796fe67d9 +engine_matches_executor_in_memory 65b1642fc5aa85d3 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 6602e4eef1974710 12 e8ee335a6003b271 +engine_matches_executor_in_memory 665bf561b471a383 9 6b9fc4d431323d01 +engine_matches_executor_in_memory 6680747c92a7c85b 49 6b969001b154c502 +engine_matches_executor_in_memory 66a6e07a88f47d9f 6 d7e0f8ed096cb869 +engine_matches_executor_in_memory 679665b12f99be18 2 0c916c28893e812f +engine_matches_executor_in_memory 68adc7e762cc180d 0 cbf29ce484222325 +engine_matches_executor_in_memory 68fc465bcb46c8f8 0 cbf29ce484222325 +engine_matches_executor_in_memory 690fb3dde9babad4 11 fdfb9eefc7d6df44 +engine_matches_executor_in_memory 696fec586f0a898c 0 cbf29ce484222325 +engine_matches_executor_in_memory 6987c8fb2e1a2504 0 cbf29ce484222325 +engine_matches_executor_in_memory 69c6237442278e86 0 cbf29ce484222325 +engine_matches_executor_in_memory 69df289fd421ab80 1 2b0a3a192b55558b +engine_matches_executor_in_memory 69faf334d86a9e1d 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 69faf334d86a9e1d 2 86bd2c7a526e97fd +engine_matches_executor_in_memory 69faf334d86a9e1d 4 ac01b96d51ed3fa3 +engine_matches_executor_in_memory 69faf334d86a9e1d 6 861eb491878c8fca +engine_matches_executor_in_memory 6a515d7e616628c1 6 861eb491878c8fca +engine_matches_executor_in_memory 6a61e7a847f2894d 24 5b53e79e8bcbab81 +engine_matches_executor_in_memory 6a65452aa3c6674d 0 cbf29ce484222325 +engine_matches_executor_in_memory 6aec104798da1a9d 12 e5eef43644a946e9 +engine_matches_executor_in_memory 6b4135cf2eaefa2e 12 476309068ae10adc +engine_matches_executor_in_memory 6b8c95ae6a57cb4e 6 45ca3e62e57c334d +engine_matches_executor_in_memory 6c0b75b5e16be667 200 ce5708eaab786136 +engine_matches_executor_in_memory 6c17dcc4baa87aa9 0 cbf29ce484222325 +engine_matches_executor_in_memory 6c3fa0b40e856be6 11 a3b4851b5816d266 +engine_matches_executor_in_memory 6c576b22da620ed9 96 689cd81e1b638a19 +engine_matches_executor_in_memory 6cd45662fee6ab58 24 398d4019728a360d +engine_matches_executor_in_memory 6cd45662fee6ab58 54 238393ae1b86e9a2 +engine_matches_executor_in_memory 6cd45662fee6ab58 6 4c599e6ab6611a56 +engine_matches_executor_in_memory 6cd45662fee6ab58 96 175ce787cc729ebd +engine_matches_executor_in_memory 6cf69762ee087c68 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 6d249bf06ce6f5e6 0 cbf29ce484222325 +engine_matches_executor_in_memory 6d315118f168ae44 84 a6f461122b365d11 +engine_matches_executor_in_memory 6dafd635a9391512 6 967c5c6d5a844ffb +engine_matches_executor_in_memory 6dd265dc7db0e374 34 408b20c0cf81234d +engine_matches_executor_in_memory 6e18e7e4f7da6bc7 1 687564f6b7ea5c3a +engine_matches_executor_in_memory 6e327ee4da1e8785 1 af144c146cedcd4e +engine_matches_executor_in_memory 6e3dcfdd5253545e 12 5226dfecb7f3ef83 +engine_matches_executor_in_memory 6e3dcfdd5253545e 3 6ce05a9057f2cc35 +engine_matches_executor_in_memory 6e3dcfdd5253545e 6 701aac6ac17ed0e7 +engine_matches_executor_in_memory 6e3dcfdd5253545e 9 d6fc803476d7979c +engine_matches_executor_in_memory 6e5f467596928d85 100 444d0179a79ef317 +engine_matches_executor_in_memory 6ec754d598a079df 2 926dcdfd7e3ef191 +engine_matches_executor_in_memory 6f26ec7ae664e29e 1 17aa6399587da023 +engine_matches_executor_in_memory 6f4d4b56d2e8edc0 0 cbf29ce484222325 +engine_matches_executor_in_memory 6f51a166c4473c79 65 6a704160801fc391 +engine_matches_executor_in_memory 6fb2bf2e01e9fc2d 0 cbf29ce484222325 +engine_matches_executor_in_memory 6fb2bf2e01e9fc2d 1 601e5bcec97f730b +engine_matches_executor_in_memory 6fb2bf2e01e9fc2d 2 d502e23700df61b7 +engine_matches_executor_in_memory 6fb2bf2e01e9fc2d 4 2887891473b7ca25 +engine_matches_executor_in_memory 701dbd7514138192 16 7171349914c8017b +engine_matches_executor_in_memory 7059f93419ab9aae 1 2b0a3a192b55558b +engine_matches_executor_in_memory 705c36666bcad2d2 5 79ea87de4ee0256e +engine_matches_executor_in_memory 708e780f716476dc 49 6b969001b154c502 +engine_matches_executor_in_memory 70afa5c624bf440a 6 701aac6ac17ed0e7 +engine_matches_executor_in_memory 70bd0e901ce716c7 1 17aa6399587da023 +engine_matches_executor_in_memory 70d42e565ce8c41e 24 2f572bfe8ff4d435 +engine_matches_executor_in_memory 70f4d07e32c0324e 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 7104d1062d4ea2a4 1 2b0a3a192b55558b +engine_matches_executor_in_memory 71524f36d9dc6df0 6 73fdaef98d0479a5 +engine_matches_executor_in_memory 718ee73be071ad70 7 bed4ef47a416a22a +engine_matches_executor_in_memory 71aeee1bd4d31b0a 0 cbf29ce484222325 +engine_matches_executor_in_memory 71b676209330b02f 0 cbf29ce484222325 +engine_matches_executor_in_memory 71fe1315d70b673c 12 5507e9eba629875d +engine_matches_executor_in_memory 71fe1315d70b673c 16 edbc24ab003cb509 +engine_matches_executor_in_memory 71fe1315d70b673c 42 842edc3637728d09 +engine_matches_executor_in_memory 71fe1315d70b673c 48 988ae18b86ed8109 +engine_matches_executor_in_memory 720cab54c550fdf1 0 cbf29ce484222325 +engine_matches_executor_in_memory 7230323f9fb5dfbd 0 cbf29ce484222325 +engine_matches_executor_in_memory 724248cedc78c396 0 cbf29ce484222325 +engine_matches_executor_in_memory 725087ac71a27a37 1 17aa6399587da023 +engine_matches_executor_in_memory 728fc6df7c749876 1 17aa6399587da023 +engine_matches_executor_in_memory 729c8d57843f10d7 190 8066e3647b2918db +engine_matches_executor_in_memory 72a0663d12f32040 12 e8ee335a6003b271 +engine_matches_executor_in_memory 7336f7c7098ef1a9 0 cbf29ce484222325 +engine_matches_executor_in_memory 7349aa371ef71c3d 2 3552c547523335b0 +engine_matches_executor_in_memory 7360de31e6fa6e7a 6 e9f3ef25377a629e +engine_matches_executor_in_memory 74a1cebc06573dc9 0 cbf29ce484222325 +engine_matches_executor_in_memory 74ae7e0fe10550ab 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 74dd71d7296267a4 3 a9f432979bf6e055 +engine_matches_executor_in_memory 75203810c401a76d 1 10ecff6bb07d0691 +engine_matches_executor_in_memory 755de2b4a49149f6 3 6f595b518c33e6b0 +engine_matches_executor_in_memory 755de2b4a49149f6 6 861eb491878c8fca +engine_matches_executor_in_memory 757b8c809ed9c44e 1 de3c307e024bac78 +engine_matches_executor_in_memory 757b8c809ed9c44e 16 5d5bb8c2de25a299 +engine_matches_executor_in_memory 757b8c809ed9c44e 36 af674fc80e764dd9 +engine_matches_executor_in_memory 757b8c809ed9c44e 4 e3ce27647f40d44d +engine_matches_executor_in_memory 75d4db2227e0474d 1 2b0a3a192b55558b +engine_matches_executor_in_memory 75e2e6859e5dab3e 1 2b0a3a192b55558b +engine_matches_executor_in_memory 7618ec94c2701a4c 0 cbf29ce484222325 +engine_matches_executor_in_memory 7641e697cda4dc04 0 cbf29ce484222325 +engine_matches_executor_in_memory 765a007b8c009bd7 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 76bb91fa7d1cfc28 1 ff2ec67c0fc3b7aa +engine_matches_executor_in_memory 76de8bf34e8a3b92 0 cbf29ce484222325 +engine_matches_executor_in_memory 7702b5b37f891a4f 121 761d012906296989 +engine_matches_executor_in_memory 7702b5b37f891a4f 145 461caeb8551fdedc +engine_matches_executor_in_memory 7702b5b37f891a4f 61 6d99eb625b079284 +engine_matches_executor_in_memory 7702b5b37f891a4f 94 26e1aceb197c6b75 +engine_matches_executor_in_memory 773d3064e99972f2 18 d5748d48706e0078 +engine_matches_executor_in_memory 774b4a1827498d8c 0 cbf29ce484222325 +engine_matches_executor_in_memory 776a7617a28e8637 1 d251ad192a466b73 +engine_matches_executor_in_memory 778b91a63f4ac694 0 cbf29ce484222325 +engine_matches_executor_in_memory 77a123a2e07981f7 0 cbf29ce484222325 +engine_matches_executor_in_memory 77cc8a272f3ec5d8 0 cbf29ce484222325 +engine_matches_executor_in_memory 782888110769501c 3 6b32068b744d03cc +engine_matches_executor_in_memory 7831c9ed32f87e7c 3 d84b517a33c8e75d +engine_matches_executor_in_memory 785c946262244264 0 cbf29ce484222325 +engine_matches_executor_in_memory 7861b9d0ac91c136 6 52a4ac892f494396 +engine_matches_executor_in_memory 78badb507e63562e 1 d251ad192a466b73 +engine_matches_executor_in_memory 78c5154e7241effa 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 78c5154e7241effa 2 91354de013e1f421 +engine_matches_executor_in_memory 78e89ab4399b7306 12 cc2b1bdab54294bb +engine_matches_executor_in_memory 78e89ab4399b7306 18 80d38d98f23d346c +engine_matches_executor_in_memory 78e89ab4399b7306 24 f5f3f55f2bf12bc1 +engine_matches_executor_in_memory 78e89ab4399b7306 6 0e7421042f63c82c +engine_matches_executor_in_memory 791937b7e4332f89 0 cbf29ce484222325 +engine_matches_executor_in_memory 79547c922eca2146 1 d5afeee0fe417b01 +engine_matches_executor_in_memory 7971068cff58db79 12 deb9cb9283dab699 +engine_matches_executor_in_memory 7971068cff58db79 3 901ee687b20c92e8 +engine_matches_executor_in_memory 7971068cff58db79 6 ec509cb124a5dc10 +engine_matches_executor_in_memory 7971068cff58db79 9 70a3eca1df3d5700 +engine_matches_executor_in_memory 797358de01ee641c 6 8344a710d174277f +engine_matches_executor_in_memory 7a28aca534177e17 1 af144c146cedcd4e +engine_matches_executor_in_memory 7ac256fc312a8f95 0 cbf29ce484222325 +engine_matches_executor_in_memory 7b064cdbcadd9c84 1 04b33efa45692bb9 +engine_matches_executor_in_memory 7b57d0fd1a92c0c7 1 2b0a3a192b55558b +engine_matches_executor_in_memory 7b6147a6fa71ca4f 0 cbf29ce484222325 +engine_matches_executor_in_memory 7b773e1bc1aabc1b 0 cbf29ce484222325 +engine_matches_executor_in_memory 7bfd48bf8b09f97b 0 cbf29ce484222325 +engine_matches_executor_in_memory 7c564bb3066feeb8 9 41dbe62d3248875c +engine_matches_executor_in_memory 7c5860ca1648a9bf 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 7c5860ca1648a9bf 2 91354de013e1f421 +engine_matches_executor_in_memory 7c5a32f478d39ca9 0 cbf29ce484222325 +engine_matches_executor_in_memory 7cdc2de5a888a4b6 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 7d22422d2bfd42c0 0 cbf29ce484222325 +engine_matches_executor_in_memory 7d3a34ab10e50600 0 cbf29ce484222325 +engine_matches_executor_in_memory 7d49cd354d49d3a5 0 cbf29ce484222325 +engine_matches_executor_in_memory 7d554c67652dbc71 6 87b4f8fbb61769c2 +engine_matches_executor_in_memory 7d565621cdafa1a5 80 f8754bc52b44c699 +engine_matches_executor_in_memory 7d7cb8aa1af3adaa 2 fbf6bc7510df255f +engine_matches_executor_in_memory 7d88a4b86112b8c4 3 1419ec70940d65b0 +engine_matches_executor_in_memory 7e4d4dd4dbd05488 0 cbf29ce484222325 +engine_matches_executor_in_memory 7e57aff1dfe81d91 1 d8054e5592aedb2e +engine_matches_executor_in_memory 7e57aff1dfe81d91 2 fef2cacccac0967f +engine_matches_executor_in_memory 7e57aff1dfe81d91 3 561ee1995d21aa56 +engine_matches_executor_in_memory 7e57aff1dfe81d91 4 e96cb5244cf0840e +engine_matches_executor_in_memory 7e8c7f99efd8d7cd 1 928198d2403b0e52 +engine_matches_executor_in_memory 7e8e4d8d718e413c 12 4d1bb454989fd859 +engine_matches_executor_in_memory 7ea87d519cbabe42 2 ab367f7400e3bc40 +engine_matches_executor_in_memory 7f1874d45b7aefe9 0 cbf29ce484222325 +engine_matches_executor_in_memory 7f1874d45b7aefe9 27 04eefaef424c5524 +engine_matches_executor_in_memory 7f1874d45b7aefe9 54 757d25d2570e0eb9 +engine_matches_executor_in_memory 7f1874d45b7aefe9 9 dc0e89f9c7e2c31a +engine_matches_executor_in_memory 7f213cccf5daa5df 6 5bcff50d2a29af85 +engine_matches_executor_in_memory 7f3f314bede7d92a 3 349b4d5824a44483 +engine_matches_executor_in_memory 7f545511df05c5bb 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 7f6e7b8dce2ec7b1 6 fba03c86c5f2142c +engine_matches_executor_in_memory 7f9c1b88fc6c8ab5 0 cbf29ce484222325 +engine_matches_executor_in_memory 7fea408d8c6da90c 8 c49a523b6b640058 +engine_matches_executor_in_memory 8087204be4f6d0ba 0 cbf29ce484222325 +engine_matches_executor_in_memory 80c1c4534739c08a 6 33227bf297dc2fac +engine_matches_executor_in_memory 80eb6039766c366a 65 d90a7475ce57c24b +engine_matches_executor_in_memory 81a0aaa302b3ae34 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 81d5f6dd360d101e 5 6fcd3e7bf9f76e30 +engine_matches_executor_in_memory 81f1375588387e01 4 5c72f8882c87073a +engine_matches_executor_in_memory 82126a1932e130c6 6 c369485b5f37d49f +engine_matches_executor_in_memory 82538b79857ca611 0 cbf29ce484222325 +engine_matches_executor_in_memory 826fea13a09c371d 9 dc0e89f9c7e2c31a +engine_matches_executor_in_memory 82788433b57fa95e 13 09abf7e130ea548e +engine_matches_executor_in_memory 82834d0c31093fcd 0 cbf29ce484222325 +engine_matches_executor_in_memory 828dffe221d2297d 3 b366d81396a9b58e +engine_matches_executor_in_memory 82a1f0f9c6ccb878 0 cbf29ce484222325 +engine_matches_executor_in_memory 82aa8b8c502ed2fc 0 cbf29ce484222325 +engine_matches_executor_in_memory 82baab86973c2d7a 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory 82d6e5e9e34cc693 0 cbf29ce484222325 +engine_matches_executor_in_memory 83038b5e674d5dc7 0 cbf29ce484222325 +engine_matches_executor_in_memory 83269d0e80bbeff3 12 e8e12c96cf0ee98d +engine_matches_executor_in_memory 83269d0e80bbeff3 3 cfebdd838ce29455 +engine_matches_executor_in_memory 83269d0e80bbeff3 6 caf5fd7df73c383b +engine_matches_executor_in_memory 83269d0e80bbeff3 9 5d9a3e35cf697559 +engine_matches_executor_in_memory 8376a78895c4bd6b 0 cbf29ce484222325 +engine_matches_executor_in_memory 83c3d459380ac023 0 cbf29ce484222325 +engine_matches_executor_in_memory 83c7f205b411823f 2 9de2ebbe4948c411 +engine_matches_executor_in_memory 83d738e29a30817d 21 67a5a3764279b2ca +engine_matches_executor_in_memory 83dbf7721f1b0cb4 0 cbf29ce484222325 +engine_matches_executor_in_memory 8422a48c691f7fc0 15 26c04c7e44705a17 +engine_matches_executor_in_memory 842db5ee336982d7 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 84a9c17810fb3c21 6 d077fa5600215a07 +engine_matches_executor_in_memory 84d223335c468605 0 cbf29ce484222325 +engine_matches_executor_in_memory 84e25a9ba4b6ddff 6 d7e0f8ed096cb869 +engine_matches_executor_in_memory 84edfde1a004acdc 0 cbf29ce484222325 +engine_matches_executor_in_memory 85694dd112a84bb7 24 f292068678b09f7d +engine_matches_executor_in_memory 85694dd112a84bb7 54 500f00a362424179 +engine_matches_executor_in_memory 85694dd112a84bb7 6 73fdaef98d0479a5 +engine_matches_executor_in_memory 85694dd112a84bb7 96 35f93b0cd503d2a5 +engine_matches_executor_in_memory 85869419a2429518 1 af144c146cedcd4e +engine_matches_executor_in_memory 858c2f06a35db63a 1 927a1d03ea20cb8e +engine_matches_executor_in_memory 85dbe768811a7e1c 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory 85dd23f0c5a8dba1 1 d1c8bd90077e4faf +engine_matches_executor_in_memory 85dd23f0c5a8dba1 12 e8e12c96cf0ee98d +engine_matches_executor_in_memory 85dd23f0c5a8dba1 2 a61a68742dc374c2 +engine_matches_executor_in_memory 85dd23f0c5a8dba1 7 5c0ccd63ac05e796 +engine_matches_executor_in_memory 85f41aac55cd89fb 4 5c72f8882c87073a +engine_matches_executor_in_memory 860c879e0f2841b9 1 a1d4248ed47613c7 +engine_matches_executor_in_memory 8649051af813f2f5 49 ca69df98cb2b32f3 +engine_matches_executor_in_memory 86517e571dc48d11 6 861eb491878c8fca +engine_matches_executor_in_memory 867b39d04f577b1b 0 cbf29ce484222325 +engine_matches_executor_in_memory 86852edad83b67a2 1 81811716bd6b8225 +engine_matches_executor_in_memory 86b05ade04a83f19 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 86b05ade04a83f19 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 86b05ade04a83f19 3 b6fa59262e533d19 +engine_matches_executor_in_memory 86b05ade04a83f19 4 c85c2256280d6152 +engine_matches_executor_in_memory 86ef6f306ec7c1df 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory 874014e4348ed57d 1 d251ad192a466b73 +engine_matches_executor_in_memory 87cac80ced1c3b91 18 a47870965d8ebc40 +engine_matches_executor_in_memory 881a17e2eb40f77a 0 cbf29ce484222325 +engine_matches_executor_in_memory 88227f7153ab2389 3 292589bdd0c11d3c +engine_matches_executor_in_memory 883680c76e1acb19 0 cbf29ce484222325 +engine_matches_executor_in_memory 883ca3e813da7d35 0 cbf29ce484222325 +engine_matches_executor_in_memory 8893e572b28bfa8d 0 cbf29ce484222325 +engine_matches_executor_in_memory 8894515ef7d85c95 0 cbf29ce484222325 +engine_matches_executor_in_memory 889cbb423b90dd79 12 221d1f03ddd5bc7b +engine_matches_executor_in_memory 889cbb423b90dd79 3 e40edea33ab884b0 +engine_matches_executor_in_memory 889cbb423b90dd79 6 bd68d19ad7ab7c16 +engine_matches_executor_in_memory 889cbb423b90dd79 9 7c5f9dcfd99b22f9 +engine_matches_executor_in_memory 88a71268c0e0c1e1 20 f7a84d94a7b1044b +engine_matches_executor_in_memory 88c23d987822d883 6 40a7aac6b4fe7cee +engine_matches_executor_in_memory 8966e09eb8b93dc0 5 92ed8a96edd4efae +engine_matches_executor_in_memory 89d6582d3a9e63f1 2 4cec1df3a3d20a9f +engine_matches_executor_in_memory 89da9a40300508b0 12 42effd69a1a78371 +engine_matches_executor_in_memory 89da9a40300508b0 16 438be19255feff2a +engine_matches_executor_in_memory 89da9a40300508b0 4 86c430c16333d7fb +engine_matches_executor_in_memory 89da9a40300508b0 8 d7370e7e909cdd3c +engine_matches_executor_in_memory 89f5a9fdc2ac5266 16 caa4a2629e02da05 +engine_matches_executor_in_memory 8a20029351c471d2 2 3552c547523335b0 +engine_matches_executor_in_memory 8af3441db252e1f7 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 8b356a39665a0c86 0 cbf29ce484222325 +engine_matches_executor_in_memory 8b48df89869c3bf6 0 cbf29ce484222325 +engine_matches_executor_in_memory 8b51c8ac491dbb26 0 cbf29ce484222325 +engine_matches_executor_in_memory 8b62d6ab68dc5029 75 0a052f222f2d7baa +engine_matches_executor_in_memory 8b7da114e4bfc655 24 5b53e79e8bcbab81 +engine_matches_executor_in_memory 8b81bdbf8eeed6c4 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 8c0852cdab7bed26 16 1348a20b0d70dea9 +engine_matches_executor_in_memory 8c2bc12007fe154b 0 cbf29ce484222325 +engine_matches_executor_in_memory 8c5d8f922249794e 0 cbf29ce484222325 +engine_matches_executor_in_memory 8c73c01bcb126861 12 06dba2c2b98ae181 +engine_matches_executor_in_memory 8c73c01bcb126861 3 28e71fda4c1b5f3a +engine_matches_executor_in_memory 8c73c01bcb126861 6 16da1375f2a94a82 +engine_matches_executor_in_memory 8c73c01bcb126861 9 a701ba03bb360259 +engine_matches_executor_in_memory 8c76534d02b5aa2c 12 fe1675751629a00d +engine_matches_executor_in_memory 8dbe36e4eba0fe42 18 8f5ff12b787df1ae +engine_matches_executor_in_memory 8dbe36e4eba0fe42 27 af597e5fa00c92d9 +engine_matches_executor_in_memory 8dbe36e4eba0fe42 36 5032dba31996734b +engine_matches_executor_in_memory 8dbe36e4eba0fe42 9 f66974282bfc4de4 +engine_matches_executor_in_memory 8dd6a99e05d6558a 8 eedf2c7acf626255 +engine_matches_executor_in_memory 8de645f1d3dbd209 0 cbf29ce484222325 +engine_matches_executor_in_memory 8de6c38901aee073 1 af144c146cedcd4e +engine_matches_executor_in_memory 8e0d6c8071a90cc6 4 e3a3e48200a0a5fc +engine_matches_executor_in_memory 8e1369bd4398155d 0 cbf29ce484222325 +engine_matches_executor_in_memory 8e635293390df398 0 cbf29ce484222325 +engine_matches_executor_in_memory 8eb10e297e55f2fe 0 cbf29ce484222325 +engine_matches_executor_in_memory 8ec92c9e6cdc5a00 13 17dfaefe129ac139 +engine_matches_executor_in_memory 8ef4a58e23bd6119 24 1ee2038ee883f25d +engine_matches_executor_in_memory 8ef4a58e23bd6119 54 ab14bf2f996957a7 +engine_matches_executor_in_memory 8ef4a58e23bd6119 6 7c029f89e9a90a65 +engine_matches_executor_in_memory 8ef4a58e23bd6119 96 689cd81e1b638a19 +engine_matches_executor_in_memory 8f2208d44beef335 0 cbf29ce484222325 +engine_matches_executor_in_memory 8f3a1c982c3e6255 0 cbf29ce484222325 +engine_matches_executor_in_memory 8f449c415d58a9fe 2 f04f033a623dfcd7 +engine_matches_executor_in_memory 8f8ac188685eed67 2 c70b48a0fbacf660 +engine_matches_executor_in_memory 8fd0c451093fe865 0 cbf29ce484222325 +engine_matches_executor_in_memory 908011f1e8396488 0 cbf29ce484222325 +engine_matches_executor_in_memory 90d950da3aff1a40 1 2a60efb47f296537 +engine_matches_executor_in_memory 90ff8dd087710cbf 0 cbf29ce484222325 +engine_matches_executor_in_memory 9104afd87633261c 1 de3c307e024bac78 +engine_matches_executor_in_memory 9104afd87633261c 16 5d5bb8c2de25a299 +engine_matches_executor_in_memory 9104afd87633261c 36 af674fc80e764dd9 +engine_matches_executor_in_memory 9104afd87633261c 4 e3ce27647f40d44d +engine_matches_executor_in_memory 910e5b57be0b1e8a 12 8b73c35a34c162b7 +engine_matches_executor_in_memory 910e5b57be0b1e8a 3 2bf04f04e1243264 +engine_matches_executor_in_memory 910e5b57be0b1e8a 6 70b06d654f921286 +engine_matches_executor_in_memory 910e5b57be0b1e8a 9 03dcc1b718e6f4ac +engine_matches_executor_in_memory 9140c34433676589 18 d5748d48706e0078 +engine_matches_executor_in_memory 91b1613eb2665aa2 0 cbf29ce484222325 +engine_matches_executor_in_memory 91bba6e7c7e1eca3 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 91be8decd045b3b1 25 20b7f8c4ff8542c5 +engine_matches_executor_in_memory 921642b25b7fdf39 0 cbf29ce484222325 +engine_matches_executor_in_memory 921642b25b7fdf39 3 cb355cc9f650b085 +engine_matches_executor_in_memory 9216ebd20b2cb591 2 3e66a74cff0b516e +engine_matches_executor_in_memory 922a1f714ab82edf 1 2a60efb47f296537 +engine_matches_executor_in_memory 927e11272239750e 0 cbf29ce484222325 +engine_matches_executor_in_memory 92a2d8bf2c4f1f65 4 d4beeeb89c6410cf +engine_matches_executor_in_memory 92c35a0029016586 1 90ea7f232b73bce7 +engine_matches_executor_in_memory 92c35a0029016586 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 92c35a0029016586 3 b6fa59262e533d19 +engine_matches_executor_in_memory 92c35a0029016586 4 c85c2256280d6152 +engine_matches_executor_in_memory 9319eff65733c3fd 6 5bcff50d2a29af85 +engine_matches_executor_in_memory 931b853818f4c5d8 0 cbf29ce484222325 +engine_matches_executor_in_memory 933860401c8c49f5 12 4ac858146048ec2b +engine_matches_executor_in_memory 936472c2794dab39 0 cbf29ce484222325 +engine_matches_executor_in_memory 93dea18becddfade 148 f7e6dd4081b18a9a +engine_matches_executor_in_memory 94480dfe3e1cef89 0 cbf29ce484222325 +engine_matches_executor_in_memory 94b3e9dc4a4baefe 0 cbf29ce484222325 +engine_matches_executor_in_memory 94ba8f2d7a1331dc 3 67b8fd74342ef287 +engine_matches_executor_in_memory 94f35c60fe6bc58e 0 cbf29ce484222325 +engine_matches_executor_in_memory 95552e1aab480732 2 dd5187ca97af06b9 +engine_matches_executor_in_memory 958d27fafe20eed5 0 cbf29ce484222325 +engine_matches_executor_in_memory 95c737d29cb3cc81 5 f732dc62a7ed825d +engine_matches_executor_in_memory 95e856ba9e7fcb25 48 988ae18b86ed8109 +engine_matches_executor_in_memory 9616a8c5ba38aa58 0 cbf29ce484222325 +engine_matches_executor_in_memory 9699dcc675b6a23a 3 28e71fda4c1b5f3a +engine_matches_executor_in_memory 96d96aa8ac814585 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory 96f1f8d89e01f9dd 1 2b0a3a192b55558b +engine_matches_executor_in_memory 97bb3b7dcb07fc1b 65 c3243aa6572502bd +engine_matches_executor_in_memory 97c8d51e6f98dd25 0 cbf29ce484222325 +engine_matches_executor_in_memory 97cfd193d71a899a 0 cbf29ce484222325 +engine_matches_executor_in_memory 97d61c83416d5893 0 cbf29ce484222325 +engine_matches_executor_in_memory 97deca0c73dbe2bb 6 70831860fa875f4c +engine_matches_executor_in_memory 98365b941a8ed465 16 1348a20b0d70dea9 +engine_matches_executor_in_memory 986108def3adf1ff 1 72ab9d2934ddeebf +engine_matches_executor_in_memory 98ef332fd4e7e5d7 0 cbf29ce484222325 +engine_matches_executor_in_memory 990e872b680beeec 1 2b0a3a192b55558b +engine_matches_executor_in_memory 991a322f6ac38d7b 6 8fcec5e314f33d7f +engine_matches_executor_in_memory 9942266dd09470ab 13 05319f97fbf0802f +engine_matches_executor_in_memory 9970e965c7025dc8 0 cbf29ce484222325 +engine_matches_executor_in_memory 99c6f44293aa91fc 12 8b73c35a34c162b7 +engine_matches_executor_in_memory 99c6f44293aa91fc 3 2bf04f04e1243264 +engine_matches_executor_in_memory 99c6f44293aa91fc 6 70b06d654f921286 +engine_matches_executor_in_memory 99c6f44293aa91fc 9 03dcc1b718e6f4ac +engine_matches_executor_in_memory 99ec10f377328b11 0 cbf29ce484222325 +engine_matches_executor_in_memory 9a0310608f71c3ad 0 cbf29ce484222325 +engine_matches_executor_in_memory 9a12e9c81925e4f1 24 398d4019728a360d +engine_matches_executor_in_memory 9b065134f69311b1 10 107650893881007e +engine_matches_executor_in_memory 9b4ee34fd4955bd7 0 cbf29ce484222325 +engine_matches_executor_in_memory 9b535cb122761866 12 05e8aabfda4a4add +engine_matches_executor_in_memory 9ba8caecfc7a5e77 36 6f3f22de92913d1f +engine_matches_executor_in_memory 9c600829ce7d31c6 1 2b0a3a192b55558b +engine_matches_executor_in_memory 9cc1421e24c1f45d 1 897824935613a4ed +engine_matches_executor_in_memory 9d1e5a9928709b31 0 cbf29ce484222325 +engine_matches_executor_in_memory 9d8a902a89fadee2 2 b1a307f58d760af7 +engine_matches_executor_in_memory 9e23861d15dd6430 1 01899acbb5049a39 +engine_matches_executor_in_memory 9e33513d822b83a3 1 57c34273beddeb94 +engine_matches_executor_in_memory 9e4b3bcea6ba578a 0 cbf29ce484222325 +engine_matches_executor_in_memory 9e7a9028d456be97 5 d493d2b682a6e84e +engine_matches_executor_in_memory 9ec084c9604a615d 0 cbf29ce484222325 +engine_matches_executor_in_memory 9ec24184c6ebd177 0 cbf29ce484222325 +engine_matches_executor_in_memory 9ef8caeaa71e6e47 1 99bad883d8b821dd +engine_matches_executor_in_memory 9f408f67c1aadf85 8 26bda39cca3526c4 +engine_matches_executor_in_memory 9f4f90bdfaa2af90 0 cbf29ce484222325 +engine_matches_executor_in_memory 9f8457164c91716f 3 7903ff4f7f693996 +engine_matches_executor_in_memory 9f9760ce52bf4241 0 cbf29ce484222325 +engine_matches_executor_in_memory 9fc7ed1ef45bf9bc 0 cbf29ce484222325 +engine_matches_executor_in_memory 9fde790abb57af4a 1 3420549d9686942d +engine_matches_executor_in_memory a0309bddc528c4f3 100 53b80245de45553d +engine_matches_executor_in_memory a0309bddc528c4f3 129 9c35cf355b761c22 +engine_matches_executor_in_memory a0309bddc528c4f3 153 14c7547e627b020a +engine_matches_executor_in_memory a0309bddc528c4f3 65 a241e85840ee1c32 +engine_matches_executor_in_memory a052b51e73a6e9f8 0 cbf29ce484222325 +engine_matches_executor_in_memory a0a1c7bf7bdce3cf 0 cbf29ce484222325 +engine_matches_executor_in_memory a0c6d6de6e0327e7 3 6f595b518c33e6b0 +engine_matches_executor_in_memory a0eae9c93ece8629 0 cbf29ce484222325 +engine_matches_executor_in_memory a1345592f26f03c5 0 cbf29ce484222325 +engine_matches_executor_in_memory a13491be489359eb 0 cbf29ce484222325 +engine_matches_executor_in_memory a15d3deb7cf77be3 0 cbf29ce484222325 +engine_matches_executor_in_memory a1727f1fa4355751 0 cbf29ce484222325 +engine_matches_executor_in_memory a1a00e99dc14911f 18 d5748d48706e0078 +engine_matches_executor_in_memory a1a7f79410567e9f 0 cbf29ce484222325 +engine_matches_executor_in_memory a1c6a8996779833a 8 fd366b6c436fb0f1 +engine_matches_executor_in_memory a2356b2038cc9d9b 3 e6dd8deeca389e9e +engine_matches_executor_in_memory a2549caa9caa5743 15 e239079e66933916 +engine_matches_executor_in_memory a27f97f7f41c9e7c 6 4ca910f2bbd47048 +engine_matches_executor_in_memory a286555f5b7c9fb7 1 17aa6399587da023 +engine_matches_executor_in_memory a29ad8196df58ee0 1 2b0a3a192b55558b +engine_matches_executor_in_memory a29ccba35727872a 0 cbf29ce484222325 +engine_matches_executor_in_memory a2a5b95c2bfd69b0 9 64062bbfd2a9320d +engine_matches_executor_in_memory a2c482669b8d261e 6 caf5fd7df73c383b +engine_matches_executor_in_memory a30a1d3e30f59c8f 0 cbf29ce484222325 +engine_matches_executor_in_memory a33268e9f523026f 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory a3841bc5694437b4 24 5b53e79e8bcbab81 +engine_matches_executor_in_memory a3841bc5694437b4 54 f79c6bd42108b8ea +engine_matches_executor_in_memory a3841bc5694437b4 6 70831860fa875f4c +engine_matches_executor_in_memory a3841bc5694437b4 96 04e08083113c9801 +engine_matches_executor_in_memory a39253b4c953f86d 0 cbf29ce484222325 +engine_matches_executor_in_memory a3992c86ea8a189f 3 9277156909ee2a23 +engine_matches_executor_in_memory a39a720f4590d7ea 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory a3d004257eb5a4d3 1 72ab9d2934ddeebf +engine_matches_executor_in_memory a3fbd2ac6c20ef9c 0 cbf29ce484222325 +engine_matches_executor_in_memory a412ff224e20ea59 1 76b48d54dad1a495 +engine_matches_executor_in_memory a432b083580c59b0 0 cbf29ce484222325 +engine_matches_executor_in_memory a43b8da7de2447ac 0 cbf29ce484222325 +engine_matches_executor_in_memory a45deb79e72f31c0 2 2c244a37025b6a79 +engine_matches_executor_in_memory a45deb79e72f31c0 4 4c8b134937bedf06 +engine_matches_executor_in_memory a45deb79e72f31c0 6 89b602cd918b985b +engine_matches_executor_in_memory a45deb79e72f31c0 8 d421315e2424b83f +engine_matches_executor_in_memory a461d4d8c66558a8 1 3420549d9686942d +engine_matches_executor_in_memory a461d4d8c66558a8 2 d0ef367a5325838d +engine_matches_executor_in_memory a461d4d8c66558a8 6 e0688e135740dd2a +engine_matches_executor_in_memory a461d4d8c66558a8 8 ab62f9e0a2a6628b +engine_matches_executor_in_memory a465c11d2388d70f 12 43b7e885d6f10365 +engine_matches_executor_in_memory a47b630da94a3caf 0 cbf29ce484222325 +engine_matches_executor_in_memory a482987002485ce5 0 cbf29ce484222325 +engine_matches_executor_in_memory a495f8711b68f809 0 cbf29ce484222325 +engine_matches_executor_in_memory a4e5e272e6f25c98 37 1dcede62998d6764 +engine_matches_executor_in_memory a52427836d6d0913 0 cbf29ce484222325 +engine_matches_executor_in_memory a569020b578fae8b 9 f75d280453f47706 +engine_matches_executor_in_memory a5a2f179d923ecb1 1 fb5cc1e4287b2e07 +engine_matches_executor_in_memory a5a8a1ea2762af9e 0 cbf29ce484222325 +engine_matches_executor_in_memory a5a9a1139f70fbb9 3 a9f432979bf6e055 +engine_matches_executor_in_memory a5d034ef103a2eee 0 cbf29ce484222325 +engine_matches_executor_in_memory a5f6789b5c8d4685 6 861eb491878c8fca +engine_matches_executor_in_memory a64e2cb6a29100e5 16 9068935ea5556dd1 +engine_matches_executor_in_memory a64e2cb6a29100e5 36 7650a3ad4ff15551 +engine_matches_executor_in_memory a64e2cb6a29100e5 4 2b1e1bdf2d001b19 +engine_matches_executor_in_memory a66972ca16b42296 0 cbf29ce484222325 +engine_matches_executor_in_memory a6f99610ce45761f 4 a016bb0c65291141 +engine_matches_executor_in_memory a7607415cd69556a 0 cbf29ce484222325 +engine_matches_executor_in_memory a78112f0aede8c8c 5 aecbe895d3b988a6 +engine_matches_executor_in_memory a78c66ff062f1c70 12 6d5f0f6a2721b39d +engine_matches_executor_in_memory a7d8ee29fa812579 0 cbf29ce484222325 +engine_matches_executor_in_memory a8059ac1525296b7 0 cbf29ce484222325 +engine_matches_executor_in_memory a810b2730bd2c15a 10 4a316bbaa771a7fb +engine_matches_executor_in_memory a810b2730bd2c15a 4 5c72f8882c87073a +engine_matches_executor_in_memory a810b2730bd2c15a 6 d077fa5600215a07 +engine_matches_executor_in_memory a810b2730bd2c15a 8 7f2fea02558d8d74 +engine_matches_executor_in_memory a8177cd48cfc49bb 65 bace5c29a4bdb5ff +engine_matches_executor_in_memory a819ef163cb08ff1 0 cbf29ce484222325 +engine_matches_executor_in_memory a9f0e0140b5d77ed 12 db51be599169d07b +engine_matches_executor_in_memory a9f0e0140b5d77ed 3 1056e3766ad41119 +engine_matches_executor_in_memory a9f0e0140b5d77ed 6 44fcf5430afde7a2 +engine_matches_executor_in_memory a9f0e0140b5d77ed 9 7d053cfc42ed2526 +engine_matches_executor_in_memory a9fe0bc72a16e79f 6 30089ca5bd8841a4 +engine_matches_executor_in_memory aa2aa676a0831338 6 4ac5a0a5d30b385f +engine_matches_executor_in_memory aa44ab7c1f1e2cbd 0 cbf29ce484222325 +engine_matches_executor_in_memory aa605a9486cae18a 12 d0aed1190eb12303 +engine_matches_executor_in_memory aa9285bca31c67ce 0 cbf29ce484222325 +engine_matches_executor_in_memory aa9b0a25220e163b 0 cbf29ce484222325 +engine_matches_executor_in_memory aa9d0fbfc927cccb 0 cbf29ce484222325 +engine_matches_executor_in_memory ab328b531beed6f4 2 86bd2c7a526e97fd +engine_matches_executor_in_memory ab6c558134322749 0 cbf29ce484222325 +engine_matches_executor_in_memory aba721912793cd90 6 967c5c6d5a844ffb +engine_matches_executor_in_memory abe4b40fdc743356 49 0da80faf1338c3bb +engine_matches_executor_in_memory abed69550ea1b4fe 0 cbf29ce484222325 +engine_matches_executor_in_memory ac081ae5cfcd57bf 0 cbf29ce484222325 +engine_matches_executor_in_memory ac0cbe414582bfe4 100 aa4bbb66c140d197 +engine_matches_executor_in_memory ac0cbe414582bfe4 129 c200775733181852 +engine_matches_executor_in_memory ac0cbe414582bfe4 153 b1567e5149f31e2e +engine_matches_executor_in_memory ac0cbe414582bfe4 65 d90a7475ce57c24b +engine_matches_executor_in_memory aca7ee33fb13d4e6 1 04b33efa45692bb9 +engine_matches_executor_in_memory aca7ee33fb13d4e6 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory aca7ee33fb13d4e6 3 7ea12c01f35984d9 +engine_matches_executor_in_memory aca7ee33fb13d4e6 4 b4db417880bbc4f9 +engine_matches_executor_in_memory acb79bc8feccfd6f 1 92d14ab4b8db0af4 +engine_matches_executor_in_memory acdab556caab5489 1 90ea7f232b73bce7 +engine_matches_executor_in_memory acdab556caab5489 2 dd5187ca97af06b9 +engine_matches_executor_in_memory acdab556caab5489 3 b6fa59262e533d19 +engine_matches_executor_in_memory acdab556caab5489 4 c85c2256280d6152 +engine_matches_executor_in_memory ad0967026ba8bc82 0 cbf29ce484222325 +engine_matches_executor_in_memory ad323c5eee219fd8 0 cbf29ce484222325 +engine_matches_executor_in_memory ad329825623c30d5 3 66f719885e592e8a +engine_matches_executor_in_memory ad8364d1f98313ac 5 48270ff9f563bc99 +engine_matches_executor_in_memory adb480d5160a3fbb 0 cbf29ce484222325 +engine_matches_executor_in_memory adf9b98ff390cbed 1 2b0a3a192b55558b +engine_matches_executor_in_memory ae1c890f527f4319 12 ae47b40fbf4f995b +engine_matches_executor_in_memory ae1c890f527f4319 18 162e436b84e5677e +engine_matches_executor_in_memory ae1c890f527f4319 24 84bce92689670a27 +engine_matches_executor_in_memory ae1c890f527f4319 6 b4b1e964ac56252c +engine_matches_executor_in_memory ae59fcedbb6731da 10 475851473d15ec7d +engine_matches_executor_in_memory ae59fcedbb6731da 2 3cba14159b036c4c +engine_matches_executor_in_memory ae59fcedbb6731da 4 e3a3e48200a0a5fc +engine_matches_executor_in_memory ae59fcedbb6731da 7 4b5390923ba91818 +engine_matches_executor_in_memory ae5f720b6233b8d0 12 4195c35bf5c5e653 +engine_matches_executor_in_memory ae73a7b06f7b1283 0 cbf29ce484222325 +engine_matches_executor_in_memory ae7e874f72fbe5d5 5 941bcb12d724d140 +engine_matches_executor_in_memory aec5800f7be14c89 0 cbf29ce484222325 +engine_matches_executor_in_memory aecb7f6144e52e7a 0 cbf29ce484222325 +engine_matches_executor_in_memory aedb5d8a4e976394 4 5c72f8882c87073a +engine_matches_executor_in_memory af025df857bb8b10 0 cbf29ce484222325 +engine_matches_executor_in_memory af2961d867ee75ad 49 256934f5c7e1fb0f +engine_matches_executor_in_memory af42b62b2a817cbb 12 2dab216f197598c1 +engine_matches_executor_in_memory af42b62b2a817cbb 3 c92580b4a540e8f1 +engine_matches_executor_in_memory af42b62b2a817cbb 6 45ca3e62e57c334d +engine_matches_executor_in_memory af42b62b2a817cbb 9 332172c300c36409 +engine_matches_executor_in_memory afba21bdcca23270 3 60ba04293f08d31b +engine_matches_executor_in_memory afdde9858fd79872 4 2d63146e1655bf14 +engine_matches_executor_in_memory afe3aab100c81b28 4 a016bb0c65291141 +engine_matches_executor_in_memory afe9f814b37f25c5 0 cbf29ce484222325 +engine_matches_executor_in_memory aff9262e5b57dcff 6 4c599e6ab6611a56 +engine_matches_executor_in_memory b038d0f80067957e 12 11f9252ce8dadeb1 +engine_matches_executor_in_memory b038d0f80067957e 12 437343aea9f9930b +engine_matches_executor_in_memory b038d0f80067957e 6 e9f3ef25377a629e +engine_matches_executor_in_memory b038d0f80067957e 6 f5b22044ca12680d +engine_matches_executor_in_memory b053b198fecda115 3 dfc709430522e7d8 +engine_matches_executor_in_memory b056145c805d4a62 13 af986cac76239e4a +engine_matches_executor_in_memory b0635f1c3d0f6232 100 990381a0d7471002 +engine_matches_executor_in_memory b0635f1c3d0f6232 198 a295b38a972a455b +engine_matches_executor_in_memory b0635f1c3d0f6232 306 b3f266712202a04b +engine_matches_executor_in_memory b0635f1c3d0f6232 37 1dcede62998d6764 +engine_matches_executor_in_memory b08d4588abde8af1 0 cbf29ce484222325 +engine_matches_executor_in_memory b1695bbaec05d474 0 cbf29ce484222325 +engine_matches_executor_in_memory b1a24977dd7bd37b 1 ff2ec67c0fc3b7aa +engine_matches_executor_in_memory b1bd5636aa144ad0 1 2b0a3a192b55558b +engine_matches_executor_in_memory b1c9e3983359e7ac 6 c369485b5f37d49f +engine_matches_executor_in_memory b1f73abaa183c7ff 6 8fcec5e314f33d7f +engine_matches_executor_in_memory b20bb5ad1720645e 18 8f5ff12b787df1ae +engine_matches_executor_in_memory b23902d559148257 1 3420549d9686942d +engine_matches_executor_in_memory b239afa448e7e45d 0 cbf29ce484222325 +engine_matches_executor_in_memory b23b3729df839c6f 6 b4b1e964ac56252c +engine_matches_executor_in_memory b24ccf359474d229 2 843bb90e43e406c3 +engine_matches_executor_in_memory b25a21467ebdd21a 4 e3ce27647f40d44d +engine_matches_executor_in_memory b286141383c25583 0 cbf29ce484222325 +engine_matches_executor_in_memory b29d013fa2a12058 2 91354be013e1f0bb +engine_matches_executor_in_memory b2a8cadce7b3aad0 6 967c5c6d5a844ffb +engine_matches_executor_in_memory b2c56b330784a343 12 6d5f0f6a2721b39d +engine_matches_executor_in_memory b2ef1a61c11e9942 6 64d778a92d95baa6 +engine_matches_executor_in_memory b33fd8bdf2754671 0 cbf29ce484222325 +engine_matches_executor_in_memory b35104f6b08e4e2b 12 43b7e885d6f10365 +engine_matches_executor_in_memory b35104f6b08e4e2b 18 3e8df8db84971c46 +engine_matches_executor_in_memory b35104f6b08e4e2b 24 bc3f0459eed80e05 +engine_matches_executor_in_memory b35104f6b08e4e2b 6 21bff0010da6e5a2 +engine_matches_executor_in_memory b3587ac332b39d9f 0 cbf29ce484222325 +engine_matches_executor_in_memory b3635fa8ccda283d 0 cbf29ce484222325 +engine_matches_executor_in_memory b3bb1c3298a46e02 2 dd5187ca97af06b9 +engine_matches_executor_in_memory b414dace36cec98f 8 6ec48ab3b9e7c027 +engine_matches_executor_in_memory b41fb13d5bb1d284 0 cbf29ce484222325 +engine_matches_executor_in_memory b421b31bbb198fa4 0 cbf29ce484222325 +engine_matches_executor_in_memory b451648d3125d08d 5 48270ff9f563bc99 +engine_matches_executor_in_memory b4b4b7d36131c961 16 9068935ea5556dd1 +engine_matches_executor_in_memory b4ce8d8ab3cdb879 0 cbf29ce484222325 +engine_matches_executor_in_memory b4fb7d9d533dbc9f 2 d0ef367a5325838d +engine_matches_executor_in_memory b50d98f9ec521279 6 d7264077dca1890a +engine_matches_executor_in_memory b52ac79be5994555 0 cbf29ce484222325 +engine_matches_executor_in_memory b57c661a1179f816 0 cbf29ce484222325 +engine_matches_executor_in_memory b5999de71ec63f0b 0 cbf29ce484222325 +engine_matches_executor_in_memory b5d95288e26ea08b 1 17aa6399587da023 +engine_matches_executor_in_memory b5dbb89bbf08e7d5 0 cbf29ce484222325 +engine_matches_executor_in_memory b5faf5bae3c7dc0a 5 31fe0d791953e42a +engine_matches_executor_in_memory b608a0f0a975499f 0 cbf29ce484222325 +engine_matches_executor_in_memory b623371304a1ffa1 0 cbf29ce484222325 +engine_matches_executor_in_memory b6236760b027b39d 5 674f39543c9bf611 +engine_matches_executor_in_memory b6762ecd03e37ef8 1 d8054e5592aedb2e +engine_matches_executor_in_memory b6951007bf016ead 5 9aa3b6fd82624172 +engine_matches_executor_in_memory b70059e2dbc0dc2d 12 476309068ae10adc +engine_matches_executor_in_memory b730169ecf0065c3 1 c3f77eeec1657e38 +engine_matches_executor_in_memory b754c06ce0e6d717 1 17aa6399587da023 +engine_matches_executor_in_memory b79b5aa87f297848 1 d5afeee0fe417b01 +engine_matches_executor_in_memory b79b5aa87f297848 16 e6584de8d575340f +engine_matches_executor_in_memory b79b5aa87f297848 4 9bb94d523b910521 +engine_matches_executor_in_memory b79b5aa87f297848 9 7eed4d82afb62e73 +engine_matches_executor_in_memory b7a3df8652d4b2e6 1 d5afeee0fe417b01 +engine_matches_executor_in_memory b7f22e608e187ca4 1 17aa6399587da023 +engine_matches_executor_in_memory b808637e7bd3985a 0 cbf29ce484222325 +engine_matches_executor_in_memory b81625798f26827d 1 d5afeee0fe417b01 +engine_matches_executor_in_memory b81625798f26827d 16 e6584de8d575340f +engine_matches_executor_in_memory b81625798f26827d 4 9bb94d523b910521 +engine_matches_executor_in_memory b81625798f26827d 9 7eed4d82afb62e73 +engine_matches_executor_in_memory b829f990a701c50b 12 ac5efaf6e4bfe009 +engine_matches_executor_in_memory b829f990a701c50b 18 8d2089a49048843e +engine_matches_executor_in_memory b829f990a701c50b 24 5d79304cbca41e1b +engine_matches_executor_in_memory b829f990a701c50b 6 9d8524af4f9c2c3f +engine_matches_executor_in_memory b851d1509ce98650 84 ff983fc8af211725 +engine_matches_executor_in_memory b8682fa7ab8c0e57 0 cbf29ce484222325 +engine_matches_executor_in_memory b86f2ea17c8fb9cf 0 cbf29ce484222325 +engine_matches_executor_in_memory b8e0b506551caad9 0 cbf29ce484222325 +engine_matches_executor_in_memory b98d76f090b4c7fc 3 1550a0a9912ebeaf +engine_matches_executor_in_memory b99f16fe67f4704b 84 2181658a65247eb1 +engine_matches_executor_in_memory b9c1693cfe21278c 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory b9d1bbcfc5dff18b 0 cbf29ce484222325 +engine_matches_executor_in_memory b9ef43cca7dfe21b 0 cbf29ce484222325 +engine_matches_executor_in_memory ba5bc1a5aa29e540 0 cbf29ce484222325 +engine_matches_executor_in_memory ba7c52af4faeb177 0 cbf29ce484222325 +engine_matches_executor_in_memory ba83e0662ef8bb03 8 83fb1f87c9b5de5b +engine_matches_executor_in_memory ba8a33ce837e5b15 0 cbf29ce484222325 +engine_matches_executor_in_memory bb35b8295268cffc 0 cbf29ce484222325 +engine_matches_executor_in_memory bb38f0e3086f8587 1 c3f77eeec1657e38 +engine_matches_executor_in_memory bb3cb40abd795735 0 cbf29ce484222325 +engine_matches_executor_in_memory bb423741feb5e56a 6 8fcec5e314f33d7f +engine_matches_executor_in_memory bb58d7ef2e22ca69 4 c5ccfd726fafa813 +engine_matches_executor_in_memory bb5abae4100a466f 0 cbf29ce484222325 +engine_matches_executor_in_memory bb96ae6fc648554e 0 cbf29ce484222325 +engine_matches_executor_in_memory bc0ebe0cd6c7cc5c 1 04b33efa45692bb9 +engine_matches_executor_in_memory bc19f4e1a90dd6aa 0 cbf29ce484222325 +engine_matches_executor_in_memory bc403fdf3fc22db1 0 cbf29ce484222325 +engine_matches_executor_in_memory bc5be5aa0c526477 1 17aa6399587da023 +engine_matches_executor_in_memory bc71df08b59c859b 0 cbf29ce484222325 +engine_matches_executor_in_memory bc8491f61da9021b 3 138f357547a401df +engine_matches_executor_in_memory bcbb5d8512ab2a5b 3 6f595b518c33e6b0 +engine_matches_executor_in_memory bce8c3ef4cc1068b 13 4bc69f7f37d45dee +engine_matches_executor_in_memory bcf09dd965310d1b 0 cbf29ce484222325 +engine_matches_executor_in_memory bd10597c2e72be5b 2 826d132e0086ad50 +engine_matches_executor_in_memory bd314d5aee645ca9 0 cbf29ce484222325 +engine_matches_executor_in_memory bd395080463d5695 0 cbf29ce484222325 +engine_matches_executor_in_memory bd6187dec73b1a60 1 04b33efa45692bb9 +engine_matches_executor_in_memory bd6f028a719a26bb 0 cbf29ce484222325 +engine_matches_executor_in_memory bdbc72951891b99d 2 4ac6fbb661ab1b38 +engine_matches_executor_in_memory be0fecd094af5283 1 c3f77eeec1657e38 +engine_matches_executor_in_memory be1413b107b41e6b 4 b4db417880bbc4f9 +engine_matches_executor_in_memory be4f8f15c23e3402 0 cbf29ce484222325 +engine_matches_executor_in_memory be5c986a71fdcf17 0 cbf29ce484222325 +engine_matches_executor_in_memory bf6ddb44f9e5707c 1 2b0a3a192b55558b +engine_matches_executor_in_memory bf71f107de913be1 1 844ae97cd5c86f64 +engine_matches_executor_in_memory bfab4a88257a7232 12 2dab216f197598c1 +engine_matches_executor_in_memory bfab4a88257a7232 3 c92580b4a540e8f1 +engine_matches_executor_in_memory bfab4a88257a7232 6 45ca3e62e57c334d +engine_matches_executor_in_memory bfab4a88257a7232 9 332172c300c36409 +engine_matches_executor_in_memory bfda51e2733b0480 8 7dc5b17501687d70 +engine_matches_executor_in_memory bffdde325cd46204 3 d8dbefadddb9dc30 +engine_matches_executor_in_memory bffe20e1708bbffd 95 392d3d2b9e4de5cd +engine_matches_executor_in_memory bfffa41f018ed40a 96 35f93b0cd503d2a5 +engine_matches_executor_in_memory c033f5073b31bf69 0 cbf29ce484222325 +engine_matches_executor_in_memory c0340d4daafe9d5d 2 9af7c7a28481726d +engine_matches_executor_in_memory c034525caf47873c 121 d8c04980dec4ca48 +engine_matches_executor_in_memory c034525caf47873c 145 2671d0c5fd2fc477 +engine_matches_executor_in_memory c034525caf47873c 61 140a95f667deb6a4 +engine_matches_executor_in_memory c034525caf47873c 94 894d1d97f23764cd +engine_matches_executor_in_memory c0542c7ac9b69de8 4 c85c2256280d6152 +engine_matches_executor_in_memory c0aef7aedacb0bf7 1 99bad883d8b821dd +engine_matches_executor_in_memory c0aef7aedacb0bf7 16 b2c8e8e25939ab99 +engine_matches_executor_in_memory c0aef7aedacb0bf7 4 a016bb0c65291141 +engine_matches_executor_in_memory c0aef7aedacb0bf7 9 8025d3b06be63fb1 +engine_matches_executor_in_memory c11dbda72b20776e 12 d0aed1190eb12303 +engine_matches_executor_in_memory c145253bfa732832 0 cbf29ce484222325 +engine_matches_executor_in_memory c14a8a5fb37bb79c 6 967c5c6d5a844ffb +engine_matches_executor_in_memory c19dc281e032875a 3 54ce163e49a737a7 +engine_matches_executor_in_memory c1d66ecccb8f76b5 0 cbf29ce484222325 +engine_matches_executor_in_memory c1d8b16b9562ea88 0 cbf29ce484222325 +engine_matches_executor_in_memory c1e232120d0802b4 2 d0ef367a5325838d +engine_matches_executor_in_memory c211a199dad1cd48 0 cbf29ce484222325 +engine_matches_executor_in_memory c25a6832438b9e48 18 d5748d48706e0078 +engine_matches_executor_in_memory c27a6fe03c7c6d2a 2 670616e81c94b537 +engine_matches_executor_in_memory c2853dacb1666874 0 cbf29ce484222325 +engine_matches_executor_in_memory c2c30a6044c145ba 1 2b0a3a192b55558b +engine_matches_executor_in_memory c2c8800bf2933d98 0 cbf29ce484222325 +engine_matches_executor_in_memory c2dd2be66260b592 2 0495a8a6918be0f4 +engine_matches_executor_in_memory c2de7f87cb2e3f86 0 cbf29ce484222325 +engine_matches_executor_in_memory c2f4f8838dbbf321 0 cbf29ce484222325 +engine_matches_executor_in_memory c312763a4a1c5aea 1 2b0a3a192b55558b +engine_matches_executor_in_memory c3224f0f07a4737a 0 cbf29ce484222325 +engine_matches_executor_in_memory c3224f0f07a4737a 1 72ab9d2934ddeebf +engine_matches_executor_in_memory c334057c2d037438 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory c378d200c32cc29b 3 e40edea33ab884b0 +engine_matches_executor_in_memory c3a270019a21f1b0 0 cbf29ce484222325 +engine_matches_executor_in_memory c3b35c1f4741a7d4 2 0de3e678b8a32d78 +engine_matches_executor_in_memory c3bc244125aa119b 1 04b33efa45692bb9 +engine_matches_executor_in_memory c3bc244125aa119b 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory c3bc244125aa119b 3 7ea12c01f35984d9 +engine_matches_executor_in_memory c3bc244125aa119b 4 b4db417880bbc4f9 +engine_matches_executor_in_memory c3e20a72b919c8ab 3 6f595b518c33e6b0 +engine_matches_executor_in_memory c3e844fbc7bd2269 4 8db39cbd3f6f643c +engine_matches_executor_in_memory c3ed47ac829e40aa 5 a6351dd912a01994 +engine_matches_executor_in_memory c4195248d28a8296 114 158321fb562363d3 +engine_matches_executor_in_memory c42577a1d0cd74bb 12 e1cc084cd66ee9ad +engine_matches_executor_in_memory c49fd45e70b9dea2 8 56da82560c2a3989 +engine_matches_executor_in_memory c4a74268a1d5c6cb 2 400fc96da32be273 +engine_matches_executor_in_memory c4aa62630301a7ed 0 cbf29ce484222325 +engine_matches_executor_in_memory c4c02f498159ebb0 2 c00d7ea0e541ef03 +engine_matches_executor_in_memory c4e742b8dbba2377 4 e3ce27647f40d44d +engine_matches_executor_in_memory c4f53decdae43432 21 6e875f66cdb85b48 +engine_matches_executor_in_memory c52e582144e4cd65 3 972e3c6cca3bd954 +engine_matches_executor_in_memory c52e582144e4cd65 4 8db39cbd3f6f643c +engine_matches_executor_in_memory c52e582144e4cd65 8 83fb1f87c9b5de5b +engine_matches_executor_in_memory c568b76abe9051fc 2 3cba14159b036c4c +engine_matches_executor_in_memory c57fe2c0b9aa695e 0 cbf29ce484222325 +engine_matches_executor_in_memory c584dc5071620db8 0 cbf29ce484222325 +engine_matches_executor_in_memory c5f048e7adf21341 0 cbf29ce484222325 +engine_matches_executor_in_memory c5f048e7adf21341 2 3552c547523335b0 +engine_matches_executor_in_memory c62190720e0489f9 0 cbf29ce484222325 +engine_matches_executor_in_memory c653abed8ea9525e 12 d0aed1190eb12303 +engine_matches_executor_in_memory c65ab5771f714571 0 cbf29ce484222325 +engine_matches_executor_in_memory c68d89619b239a7b 0 cbf29ce484222325 +engine_matches_executor_in_memory c7987356f5b4416a 1 c3f77eeec1657e38 +engine_matches_executor_in_memory c7c0d15696cf89c9 0 cbf29ce484222325 +engine_matches_executor_in_memory c7e92032a55e1729 24 398d4019728a360d +engine_matches_executor_in_memory c7fe9a222722e38d 6 ec509cb124a5dc10 +engine_matches_executor_in_memory c7ff17fe346a18c6 6 8fcec5e314f33d7f +engine_matches_executor_in_memory c84572b7afa6fa78 0 cbf29ce484222325 +engine_matches_executor_in_memory c85173fa92d749a0 0 cbf29ce484222325 +engine_matches_executor_in_memory c8ee6b923ad0d437 0 cbf29ce484222325 +engine_matches_executor_in_memory c936dfcaf4a8c962 34 97dd05adf3c20ca1 +engine_matches_executor_in_memory c951804d6d90f0a4 5 48270ff9f563bc99 +engine_matches_executor_in_memory c9659947eacd55d9 4 5a8c1584f7a93211 +engine_matches_executor_in_memory c9659947eacd55d9 4 5d8abe1a7802cbdd +engine_matches_executor_in_memory c9659947eacd55d9 4 93a680b7d2689da9 +engine_matches_executor_in_memory c98300b94d8c952f 0 cbf29ce484222325 +engine_matches_executor_in_memory c98300b94d8c952f 1 72ab9d2934ddeebf +engine_matches_executor_in_memory c9856b07fccba335 2 dd5187ca97af06b9 +engine_matches_executor_in_memory c9a5ed9b70ce7e3e 18 a47870965d8ebc40 +engine_matches_executor_in_memory c9a5ed9b70ce7e3e 36 6f3f22de92913d1f +engine_matches_executor_in_memory c9a5ed9b70ce7e3e 54 490dc274983b6e7e +engine_matches_executor_in_memory c9a5ed9b70ce7e3e 72 9dfc2c11ab619f05 +engine_matches_executor_in_memory ca314614612ad6dd 12 4ac858146048ec2b +engine_matches_executor_in_memory ca5bfd0892cc8989 1 17aa6399587da023 +engine_matches_executor_in_memory ca67782e0b74d608 34 cf4d1ae26ec96018 +engine_matches_executor_in_memory ca883fa7c6aee65f 100 53b80245de45553d +engine_matches_executor_in_memory cab4671c23599885 3 a9f432979bf6e055 +engine_matches_executor_in_memory cac81c70884ab92b 0 cbf29ce484222325 +engine_matches_executor_in_memory cb06cdbba5bf2ce8 0 cbf29ce484222325 +engine_matches_executor_in_memory cb133ab35d3c04e3 1 17aa6399587da023 +engine_matches_executor_in_memory cb961c311c3cf93b 5 f72ac1ad077329c6 +engine_matches_executor_in_memory cba2fd0d59560b2a 1 90ea7f232b73bce7 +engine_matches_executor_in_memory cba2fd0d59560b2a 2 dd5187ca97af06b9 +engine_matches_executor_in_memory cba2fd0d59560b2a 3 b6fa59262e533d19 +engine_matches_executor_in_memory cba2fd0d59560b2a 3 e6dd8deeca389e9e +engine_matches_executor_in_memory cc13b3d214eec1b2 3 60458418704e9735 +engine_matches_executor_in_memory cc4bcb17693840bd 0 cbf29ce484222325 +engine_matches_executor_in_memory cc58e7df8e1ce43d 0 cbf29ce484222325 +engine_matches_executor_in_memory cc58e7df8e1ce43d 18 45fd5d2b790f98b3 +engine_matches_executor_in_memory cc58e7df8e1ce43d 27 a71e88b2c32f69ae +engine_matches_executor_in_memory cc58e7df8e1ce43d 9 f4d27fdfca1c0fb8 +engine_matches_executor_in_memory cc895b2bbda44001 1 6ee4dc1e77bd0b21 +engine_matches_executor_in_memory cce05dd659a8aa82 0 cbf29ce484222325 +engine_matches_executor_in_memory cd06fed505170868 0 cbf29ce484222325 +engine_matches_executor_in_memory cd58834fe03df52c 5 1d529cd8654bc5fc +engine_matches_executor_in_memory cd9210cabd0b79ed 1 90ea7f232b73bce7 +engine_matches_executor_in_memory cdc181c0ef5af175 3 6f595b518c33e6b0 +engine_matches_executor_in_memory cdc181c0ef5af175 6 861eb491878c8fca +engine_matches_executor_in_memory cdc74e292cfdcd64 8 83fb1f87c9b5de5b +engine_matches_executor_in_memory ce35e61c7e4f3346 3 95adde3810f78a6c +engine_matches_executor_in_memory ce4fbf0c96152863 1 d251ad192a466b73 +engine_matches_executor_in_memory ce6da314bc8b4eb4 2 86bd2c7a526e97fd +engine_matches_executor_in_memory ce9bf6d2c4b13468 0 cbf29ce484222325 +engine_matches_executor_in_memory ceba66f3a0bf9601 0 cbf29ce484222325 +engine_matches_executor_in_memory cec3d754ffe58d02 2 3552c547523335b0 +engine_matches_executor_in_memory cf0f9f2fe0c0b1fd 0 cbf29ce484222325 +engine_matches_executor_in_memory cf4f4ee539a5451f 0 cbf29ce484222325 +engine_matches_executor_in_memory cf5c0d3a74097696 37 dc9433e5aa16ccfa +engine_matches_executor_in_memory cfb10a39d1285ed0 0 cbf29ce484222325 +engine_matches_executor_in_memory cfe4f737bddc3588 4 ad8bd214312d10a9 +engine_matches_executor_in_memory cfe4f737bddc3588 6 e9aa76b0d27a6479 +engine_matches_executor_in_memory cfe4f737bddc3588 8 3572bf9a1ffd34d5 +engine_matches_executor_in_memory cfe4f737bddc3588 8 8d06f3b2fc3260e8 +engine_matches_executor_in_memory cffb95cd196e3725 9 20f5175f1404b1bc +engine_matches_executor_in_memory d05c2b2a91a58cee 16 a2f6b2743f8cc5ff +engine_matches_executor_in_memory d05c2b2a91a58cee 36 2e2a2720f3c88fa5 +engine_matches_executor_in_memory d05c2b2a91a58cee 4 c5df626cfc6f94e4 +engine_matches_executor_in_memory d05c2b2a91a58cee 64 df515aaf301e337a +engine_matches_executor_in_memory d130e32693163895 0 cbf29ce484222325 +engine_matches_executor_in_memory d153bd880f6bfcc7 6 18674433ff6738f0 +engine_matches_executor_in_memory d1bae0c8a2e2d225 0 cbf29ce484222325 +engine_matches_executor_in_memory d1ce9d7539062f86 0 cbf29ce484222325 +engine_matches_executor_in_memory d1ce9d7539062f86 2 3552c547523335b0 +engine_matches_executor_in_memory d2152644e5dd0e09 6 d077fa5600215a07 +engine_matches_executor_in_memory d25f21e810490ef2 323 8519138ad9bddcca +engine_matches_executor_in_memory d291657f90fcaeab 0 cbf29ce484222325 +engine_matches_executor_in_memory d2dfc209192dd0c3 2 0902cd9b55681795 +engine_matches_executor_in_memory d30b04425e597bcc 0 cbf29ce484222325 +engine_matches_executor_in_memory d31060725e4bc48c 9 187fb06fea7acee6 +engine_matches_executor_in_memory d3203e472987f1b0 0 cbf29ce484222325 +engine_matches_executor_in_memory d33cf3cd61fc526f 4 add2a9873aa7b437 +engine_matches_executor_in_memory d3806ed78d8be427 6 e1753466c4728415 +engine_matches_executor_in_memory d3d61c78577d6c56 0 cbf29ce484222325 +engine_matches_executor_in_memory d42f696f7b867a3d 16 edbc24ab003cb509 +engine_matches_executor_in_memory d45f642736e3a75e 0 cbf29ce484222325 +engine_matches_executor_in_memory d45ffadd0aa4f16b 12 cdda145c5e817551 +engine_matches_executor_in_memory d45ffadd0aa4f16b 3 41c2c9642f03a638 +engine_matches_executor_in_memory d45ffadd0aa4f16b 6 125405a256c292ce +engine_matches_executor_in_memory d45ffadd0aa4f16b 9 8fdcb97bea2d9339 +engine_matches_executor_in_memory d4919a0a877297cf 0 cbf29ce484222325 +engine_matches_executor_in_memory d4a088ff37ebaf1b 34 3a07fb9bba899659 +engine_matches_executor_in_memory d4c589512bca8f81 0 cbf29ce484222325 +engine_matches_executor_in_memory d4cbc6a96535eed8 0 cbf29ce484222325 +engine_matches_executor_in_memory d4d0067dbf0cd664 2 6657b3bd97e29d6c +engine_matches_executor_in_memory d4e5f4dbf48c0e3a 0 cbf29ce484222325 +engine_matches_executor_in_memory d4eb903e14d4377a 12 d0aed1190eb12303 +engine_matches_executor_in_memory d4eb903e14d4377a 6 861eb491878c8fca +engine_matches_executor_in_memory d50025d6c9838313 0 cbf29ce484222325 +engine_matches_executor_in_memory d511dd86ae2ed59c 0 cbf29ce484222325 +engine_matches_executor_in_memory d511dd86ae2ed59c 1 04b33efa45692bb9 +engine_matches_executor_in_memory d53cc3e84c4d8520 10 61786662a674d441 +engine_matches_executor_in_memory d570146cf799aa20 3 c92580b4a540e8f1 +engine_matches_executor_in_memory d596ce657b69d681 0 cbf29ce484222325 +engine_matches_executor_in_memory d5d33b5376b30591 0 cbf29ce484222325 +engine_matches_executor_in_memory d5d6ea6f1ac03c47 36 6f3f22de92913d1f +engine_matches_executor_in_memory d5fe80903afde214 65 1d5b390aa4bd1cda +engine_matches_executor_in_memory d64bede7b8ef8533 1 de3c307e024bac78 +engine_matches_executor_in_memory d67c6f09dd362417 0 cbf29ce484222325 +engine_matches_executor_in_memory d69b46c9366e3381 3 7aa1bc07fa786255 +engine_matches_executor_in_memory d6f8d90f668f4280 0 cbf29ce484222325 +engine_matches_executor_in_memory d7079ddf62ebf105 3 6f595b518c33e6b0 +engine_matches_executor_in_memory d7245d529d13f03b 24 743aab6015b9e95a +engine_matches_executor_in_memory d727b4b8d5a25756 18 8f5ff12b787df1ae +engine_matches_executor_in_memory d741405e570daa41 2 400fc96da32be273 +engine_matches_executor_in_memory d741405e570daa41 4 d4beeeb89c6410cf +engine_matches_executor_in_memory d741405e570daa41 6 861eb491878c8fca +engine_matches_executor_in_memory d744bd23b6e83022 1 95e9a2d67cdaf354 +engine_matches_executor_in_memory d74bf339f5c091cb 592 a39b66a71e8befe1 +engine_matches_executor_in_memory d7529406aabe67ba 14 28d3112a62f20e31 +engine_matches_executor_in_memory d762bc124e20b545 6 bd68d19ad7ab7c16 +engine_matches_executor_in_memory d772addb235323ac 0 cbf29ce484222325 +engine_matches_executor_in_memory d792e51c1a4ecd0c 15 07128e3cc9f9c53a +engine_matches_executor_in_memory d7960dc79207af7a 0 cbf29ce484222325 +engine_matches_executor_in_memory d7e733dfe54cedbb 3 6f595b518c33e6b0 +engine_matches_executor_in_memory d7e91a72fd47a9cf 0 cbf29ce484222325 +engine_matches_executor_in_memory d7f3e800cd1198c8 4 e3ce27647f40d44d +engine_matches_executor_in_memory d81ae5f134cae64d 1 d808d65592b1f81d +engine_matches_executor_in_memory d81ae5f134cae64d 2 adcefce1bdf0c70d +engine_matches_executor_in_memory d81ae5f134cae64d 3 0e21b8240d44401a +engine_matches_executor_in_memory d81ae5f134cae64d 6 22bb81d1b9f9b552 +engine_matches_executor_in_memory d824fede69cf1435 0 cbf29ce484222325 +engine_matches_executor_in_memory d871e022c6bc3371 0 cbf29ce484222325 +engine_matches_executor_in_memory d8792555f57825b8 0 cbf29ce484222325 +engine_matches_executor_in_memory d8f9f9173b742b64 0 cbf29ce484222325 +engine_matches_executor_in_memory d91a7f89a5170fef 0 cbf29ce484222325 +engine_matches_executor_in_memory d91f06b80b8c43e8 0 cbf29ce484222325 +engine_matches_executor_in_memory d91f06b80b8c43e8 1 2b0a3a192b55558b +engine_matches_executor_in_memory da011ec93dea5339 3 a706e3d53ff3e3eb +engine_matches_executor_in_memory da02a3fb70e885b4 0 cbf29ce484222325 +engine_matches_executor_in_memory da2dc30d2c90d7ca 1 de3c307e024bac78 +engine_matches_executor_in_memory da437b773b782155 12 ae47b40fbf4f995b +engine_matches_executor_in_memory da808b52174bdf30 0 cbf29ce484222325 +engine_matches_executor_in_memory dac2f533ee07b25b 0 cbf29ce484222325 +engine_matches_executor_in_memory dadc7c0308024899 0 cbf29ce484222325 +engine_matches_executor_in_memory db08921dc09ccce6 12 fe1675751629a00d +engine_matches_executor_in_memory db27aefdd073b10b 0 cbf29ce484222325 +engine_matches_executor_in_memory db27aefdd073b10b 1 04b33efa45692bb9 +engine_matches_executor_in_memory db3ca5f921f1bccb 0 cbf29ce484222325 +engine_matches_executor_in_memory db84ea3bf578cd66 6 5bcff50d2a29af85 +engine_matches_executor_in_memory dbd68f26716e2e7c 12 de92db87231e7d15 +engine_matches_executor_in_memory dbd68f26716e2e7c 3 70368f01fac86498 +engine_matches_executor_in_memory dbd68f26716e2e7c 6 4caf4e58d2f71a3d +engine_matches_executor_in_memory dbd68f26716e2e7c 9 d0867478874fb475 +engine_matches_executor_in_memory dc0a8fda9a0999a3 0 cbf29ce484222325 +engine_matches_executor_in_memory dc39efb4829ce214 8 b0ec0fb2f348a8f8 +engine_matches_executor_in_memory dc638d2b6447110a 1 d9a8561e9f938fde +engine_matches_executor_in_memory dc8374a5deaec97a 0 cbf29ce484222325 +engine_matches_executor_in_memory dca915079039da6d 1 2b0a3a192b55558b +engine_matches_executor_in_memory dce049282e92b2d9 0 cbf29ce484222325 +engine_matches_executor_in_memory dcffa5e9b17e6d30 0 cbf29ce484222325 +engine_matches_executor_in_memory dd08e05e7234da22 130 d938a2947bb03058 +engine_matches_executor_in_memory dd0b220eb2bc1712 0 cbf29ce484222325 +engine_matches_executor_in_memory dd7965199607f6a2 12 6d5f0f6a2721b39d +engine_matches_executor_in_memory dd7965199607f6a2 16 caa4a2629e02da05 +engine_matches_executor_in_memory dd7965199607f6a2 23 60be68f2e6dfc9db +engine_matches_executor_in_memory dd7965199607f6a2 25 63d9ec9d598222c9 +engine_matches_executor_in_memory ddc5bf2a667efadd 30 faadea52d714b11e +engine_matches_executor_in_memory ddc664c57852a805 0 cbf29ce484222325 +engine_matches_executor_in_memory ddcd9af463d03f3d 6 967c5c6d5a844ffb +engine_matches_executor_in_memory dde11789dd72028e 2 d502e23700df61b7 +engine_matches_executor_in_memory dde8a8d2053990f3 100 2fb9bc76154f6e93 +engine_matches_executor_in_memory dde8a8d2053990f3 129 aaad515c9e06730b +engine_matches_executor_in_memory dde8a8d2053990f3 153 c8a5362a9b722a07 +engine_matches_executor_in_memory dde8a8d2053990f3 65 6615a1addd482b42 +engine_matches_executor_in_memory de3f6d0bdf6c8c37 1 17aa6399587da023 +engine_matches_executor_in_memory de42a0ce0cde53ea 23 9ba61e50fe3514b8 +engine_matches_executor_in_memory dee47b0b2d86839f 0 cbf29ce484222325 +engine_matches_executor_in_memory df014b614f3dbb59 3 8cefef79e4d610e2 +engine_matches_executor_in_memory df0d24177e63dd9d 5 25fcbcdf5a3beaea +engine_matches_executor_in_memory df6c8bbc3178ed14 6 2b3b8b38abf31b04 +engine_matches_executor_in_memory df6c8bbc3178ed14 6 5aa7420496fc37bc +engine_matches_executor_in_memory df6c8bbc3178ed14 6 e5d5753f75b888bc +engine_matches_executor_in_memory df754527713b2ef5 0 cbf29ce484222325 +engine_matches_executor_in_memory df884bc943347fe0 0 cbf29ce484222325 +engine_matches_executor_in_memory df884bc943347fe0 18 45fd5d2b790f98b3 +engine_matches_executor_in_memory df884bc943347fe0 27 a71e88b2c32f69ae +engine_matches_executor_in_memory df884bc943347fe0 9 f4d27fdfca1c0fb8 +engine_matches_executor_in_memory e00d7164244d6a91 6 d7264077dca1890a +engine_matches_executor_in_memory e055ce48a09915dc 0 cbf29ce484222325 +engine_matches_executor_in_memory e0d657f03446fe04 1 2b0a3a192b55558b +engine_matches_executor_in_memory e111fd048d2b964a 24 f292068678b09f7d +engine_matches_executor_in_memory e111fd048d2b964a 54 500f00a362424179 +engine_matches_executor_in_memory e111fd048d2b964a 6 73fdaef98d0479a5 +engine_matches_executor_in_memory e111fd048d2b964a 96 35f93b0cd503d2a5 +engine_matches_executor_in_memory e121483e090bb957 3 1056e3766ad41119 +engine_matches_executor_in_memory e13d236e4caa2593 1 17aa6399587da023 +engine_matches_executor_in_memory e1b664dc8799ff38 0 cbf29ce484222325 +engine_matches_executor_in_memory e1ccc7710634b458 0 cbf29ce484222325 +engine_matches_executor_in_memory e1d8ebef23cf5b08 3 138f357547a401df +engine_matches_executor_in_memory e1d8ebef23cf5b08 6 d7264077dca1890a +engine_matches_executor_in_memory e1d8ebef23cf5b08 9 688d36349666ae5e +engine_matches_executor_in_memory e1d8ebef23cf5b08 9 76b7e537eae2e54d +engine_matches_executor_in_memory e2ad7d7fe987e4a8 0 cbf29ce484222325 +engine_matches_executor_in_memory e2bf1023c2cf8f5a 0 cbf29ce484222325 +engine_matches_executor_in_memory e2c847426029320c 6 861eb491878c8fca +engine_matches_executor_in_memory e2fa7b62d6e83860 0 cbf29ce484222325 +engine_matches_executor_in_memory e318fd78b0ae2683 0 cbf29ce484222325 +engine_matches_executor_in_memory e32ee726602a7aa8 1 17aa6399587da023 +engine_matches_executor_in_memory e34b73d1b13e7302 0 cbf29ce484222325 +engine_matches_executor_in_memory e363e3d59ab07014 1 04b33efa45692bb9 +engine_matches_executor_in_memory e3e41c56996505d8 100 68bade370efca39f +engine_matches_executor_in_memory e3e41c56996505d8 198 dc4ce1c2115e2525 +engine_matches_executor_in_memory e3e41c56996505d8 306 55ab647a20ab6321 +engine_matches_executor_in_memory e3e41c56996505d8 37 dc9433e5aa16ccfa +engine_matches_executor_in_memory e3f731c048fc74ff 0 cbf29ce484222325 +engine_matches_executor_in_memory e3f731c048fc74ff 1 2b0a3a192b55558b +engine_matches_executor_in_memory e441c4c5e91e1851 18 d5748d48706e0078 +engine_matches_executor_in_memory e44a93211acdcfdc 0 cbf29ce484222325 +engine_matches_executor_in_memory e4da5dc388b1294e 0 cbf29ce484222325 +engine_matches_executor_in_memory e4e031e43afa7725 5 edfa8e81a247e6cc +engine_matches_executor_in_memory e4ee5b59d18a856d 148 7b58ca015087406b +engine_matches_executor_in_memory e531c4476248e9b3 6 8fcec5e314f33d7f +engine_matches_executor_in_memory e5535f28d096f183 12 32f4290d14c39ea9 +engine_matches_executor_in_memory e57295f3cf92e363 1 2b0a3a192b55558b +engine_matches_executor_in_memory e57ed2c682f31d5a 1 17aa6399587da023 +engine_matches_executor_in_memory e5b20cc724ed35b7 4 e3ce27647f40d44d +engine_matches_executor_in_memory e5bf563b16bc2d4d 0 cbf29ce484222325 +engine_matches_executor_in_memory e5e4ab2c5c79c663 0 cbf29ce484222325 +engine_matches_executor_in_memory e61fff3f757d783c 0 cbf29ce484222325 +engine_matches_executor_in_memory e622b00508738052 0 cbf29ce484222325 +engine_matches_executor_in_memory e622b00508738052 3 6f595b518c33e6b0 +engine_matches_executor_in_memory e622edc6047d81b0 0 cbf29ce484222325 +engine_matches_executor_in_memory e6cae33d9955ff1c 0 cbf29ce484222325 +engine_matches_executor_in_memory e6d730a7f59a0f9e 0 cbf29ce484222325 +engine_matches_executor_in_memory e6ecdddfc5679255 0 cbf29ce484222325 +engine_matches_executor_in_memory e6f0d7d51491f97a 0 cbf29ce484222325 +engine_matches_executor_in_memory e71929b5c69cd49b 0 cbf29ce484222325 +engine_matches_executor_in_memory e78456e0d11a21fd 0 cbf29ce484222325 +engine_matches_executor_in_memory e79a39389afc29c1 0 cbf29ce484222325 +engine_matches_executor_in_memory e7f02e0422b8d92d 1 de3c307e024bac78 +engine_matches_executor_in_memory e7f02e0422b8d92d 16 5d5bb8c2de25a299 +engine_matches_executor_in_memory e7f02e0422b8d92d 36 af674fc80e764dd9 +engine_matches_executor_in_memory e7f02e0422b8d92d 4 e3ce27647f40d44d +engine_matches_executor_in_memory e7f07b96bba0ccf1 0 cbf29ce484222325 +engine_matches_executor_in_memory e7f7098182ee7cd6 100 cf106879b5672327 +engine_matches_executor_in_memory e812082c04da77ff 12 de92db87231e7d15 +engine_matches_executor_in_memory e812082c04da77ff 3 70368f01fac86498 +engine_matches_executor_in_memory e812082c04da77ff 6 4caf4e58d2f71a3d +engine_matches_executor_in_memory e812082c04da77ff 9 d0867478874fb475 +engine_matches_executor_in_memory e8423a89c23950f4 3 cfebdd838ce29455 +engine_matches_executor_in_memory e86da73207ebd026 2 3552c547523335b0 +engine_matches_executor_in_memory e8748cdc1a952c91 0 cbf29ce484222325 +engine_matches_executor_in_memory e90a1ef77ef0ceb8 2 3609050103036cdf +engine_matches_executor_in_memory e90fd53be83c0779 0 cbf29ce484222325 +engine_matches_executor_in_memory e923c2044f43ea87 0 cbf29ce484222325 +engine_matches_executor_in_memory e932256417eca939 42 842edc3637728d09 +engine_matches_executor_in_memory e94992ac1dd8cdc3 0 cbf29ce484222325 +engine_matches_executor_in_memory e95e9856a3949307 1 172f08ba9c63e405 +engine_matches_executor_in_memory e9be0c25ef1158ba 0 cbf29ce484222325 +engine_matches_executor_in_memory e9d9ce2d72b08970 12 b1e7daf66a7f768b +engine_matches_executor_in_memory e9d9ce2d72b08970 3 0709e1530c9e69e6 +engine_matches_executor_in_memory e9d9ce2d72b08970 6 c4d6b299634ec196 +engine_matches_executor_in_memory e9d9ce2d72b08970 9 f292c7a52bbfb656 +engine_matches_executor_in_memory ea0a546cf341cf12 1 17aa6399587da023 +engine_matches_executor_in_memory ea199eea0a84509f 0 cbf29ce484222325 +engine_matches_executor_in_memory ea361ec42a4940f3 0 cbf29ce484222325 +engine_matches_executor_in_memory ea5a04e89ae21614 3 18a18852d8af9803 +engine_matches_executor_in_memory ea7dfd9c5d58874b 18 a47870965d8ebc40 +engine_matches_executor_in_memory ea7dfd9c5d58874b 36 6f3f22de92913d1f +engine_matches_executor_in_memory ea7dfd9c5d58874b 54 490dc274983b6e7e +engine_matches_executor_in_memory ea7dfd9c5d58874b 72 9dfc2c11ab619f05 +engine_matches_executor_in_memory ea93ad5f0ac3f183 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory eac33c5b16cbd9be 0 cbf29ce484222325 +engine_matches_executor_in_memory ead9ac4f001c434e 157 909a04374f7f52be +engine_matches_executor_in_memory eafd2b34a95bb22e 1 04b33efa45692bb9 +engine_matches_executor_in_memory eb15c22ea153f572 1 17aa6399587da023 +engine_matches_executor_in_memory eb4bfb0862ebeb90 1 2b0a3a192b55558b +engine_matches_executor_in_memory eb5b04d1c1115ce5 18 d5748d48706e0078 +engine_matches_executor_in_memory eb5bf08cb89531a0 0 cbf29ce484222325 +engine_matches_executor_in_memory eb5bf08cb89531a0 1 c3f77eeec1657e38 +engine_matches_executor_in_memory eb848d972b25e9d5 96 175ce787cc729ebd +engine_matches_executor_in_memory eb9ed8aade58009d 24 1ee2038ee883f25d +engine_matches_executor_in_memory eba6a50f74c998cf 0 cbf29ce484222325 +engine_matches_executor_in_memory ebb53e2046af1ae4 6 967c5c6d5a844ffb +engine_matches_executor_in_memory ebf63c4ecee89ece 0 cbf29ce484222325 +engine_matches_executor_in_memory ec1942e8ff8348d5 0 cbf29ce484222325 +engine_matches_executor_in_memory ec55b93d1f08758c 6 f5b22044ca12680d +engine_matches_executor_in_memory ecb6b6076a07574d 100 02e0869febf43e2e +engine_matches_executor_in_memory ecdd88993547ba21 1 04b33efa45692bb9 +engine_matches_executor_in_memory ecfe67e3c4acfbc3 6 8fcec5e314f33d7f +engine_matches_executor_in_memory ed43df0fd6a5d81b 6 8fcec5e314f33d7f +engine_matches_executor_in_memory edd1eb57252ce6b1 0 cbf29ce484222325 +engine_matches_executor_in_memory edebeea296042502 0 cbf29ce484222325 +engine_matches_executor_in_memory ee0325f7be83f766 1 2b0a3a192b55558b +engine_matches_executor_in_memory ee0a1dcefdac51a6 12 e73ee09cc7ace95d +engine_matches_executor_in_memory ee0a1dcefdac51a6 3 60ba04293f08d31b +engine_matches_executor_in_memory ee0a1dcefdac51a6 6 d4c5192cd4d89a96 +engine_matches_executor_in_memory ee0a1dcefdac51a6 9 a8ae940c8bdf3dbe +engine_matches_executor_in_memory ee15486c45e8e040 6 16da1375f2a94a82 +engine_matches_executor_in_memory ee57d10d7b364373 0 cbf29ce484222325 +engine_matches_executor_in_memory ee85564d356fd7be 0 cbf29ce484222325 +engine_matches_executor_in_memory eedb655a92fad5a8 0 cbf29ce484222325 +engine_matches_executor_in_memory ef0560545fb58e7e 2 a61a68742dc374c2 +engine_matches_executor_in_memory ef2548d356ea2317 1 d5afeee0fe417b01 +engine_matches_executor_in_memory ef3003a719e5bb07 13 8cd3e54054c6dc7c +engine_matches_executor_in_memory ef5326e4fd198456 6 70b06d654f921286 +engine_matches_executor_in_memory ef7dd8ca25bd386d 0 cbf29ce484222325 +engine_matches_executor_in_memory efb7b0df8894d3ab 0 cbf29ce484222325 +engine_matches_executor_in_memory efc8fb31fea48527 9 41dbe62d3248875c +engine_matches_executor_in_memory efeb95bfeabdcf02 1 ff2ec67c0fc3b7aa +engine_matches_executor_in_memory efeb95bfeabdcf02 2 23742fb0ed610812 +engine_matches_executor_in_memory f00c113af925ab78 2 344a5a56d95e8222 +engine_matches_executor_in_memory f00c113af925ab78 2 7602b8b1dd2031c1 +engine_matches_executor_in_memory f00c113af925ab78 2 f1b10ab0d647f6b7 +engine_matches_executor_in_memory f045f007fc111283 0 cbf29ce484222325 +engine_matches_executor_in_memory f0788a2a44bf6281 1 17aa6399587da023 +engine_matches_executor_in_memory f09800abe11b7c86 0 cbf29ce484222325 +engine_matches_executor_in_memory f0d80709e2a162ff 0 cbf29ce484222325 +engine_matches_executor_in_memory f1201830ad9b942f 0 cbf29ce484222325 +engine_matches_executor_in_memory f1cf3c697d697e6b 75 a7005e5648e71ab0 +engine_matches_executor_in_memory f1d584937c461879 2 9de41c9d35adb9f3 +engine_matches_executor_in_memory f1e2d172b5c2e71a 1 601e5bcec97f730b +engine_matches_executor_in_memory f1f4fcf4564b34c7 2 bd8bbd30fb86c454 +engine_matches_executor_in_memory f1fa12d7c8dd1182 0 cbf29ce484222325 +engine_matches_executor_in_memory f24b2d9cc86b0dd3 1 04b33efa45692bb9 +engine_matches_executor_in_memory f2685073b4537f6b 1 17aa6399587da023 +engine_matches_executor_in_memory f26a06e5cbf961c1 0 cbf29ce484222325 +engine_matches_executor_in_memory f2701b3389cb0071 0 cbf29ce484222325 +engine_matches_executor_in_memory f274612de9aad5fc 3 7ea12c01f35984d9 +engine_matches_executor_in_memory f2889a0f96b5a394 16 e6584de8d575340f +engine_matches_executor_in_memory f2eb8be3fde15399 0 cbf29ce484222325 +engine_matches_executor_in_memory f2ed868ea1f57b9a 43 e0e57327e652269d +engine_matches_executor_in_memory f34aedf56d008a1d 0 cbf29ce484222325 +engine_matches_executor_in_memory f3662baa53ef4b82 1 2b0a3a192b55558b +engine_matches_executor_in_memory f3bfb31a0bf5f5a9 2 a61a68742dc374c2 +engine_matches_executor_in_memory f3c4fc393494deac 0 cbf29ce484222325 +engine_matches_executor_in_memory f3d62f08edaffdbe 4 e3a3e48200a0a5fc +engine_matches_executor_in_memory f4043d1137551235 6 d077fa5600215a07 +engine_matches_executor_in_memory f41c189f59fdd561 3 a6bee7380871d90f +engine_matches_executor_in_memory f456f300900c0c97 2 dd5187ca97af06b9 +engine_matches_executor_in_memory f48fcb11646977f9 0 cbf29ce484222325 +engine_matches_executor_in_memory f490be55a3fcd9b0 6 16da1375f2a94a82 +engine_matches_executor_in_memory f4cae3ab2c1637ed 0 cbf29ce484222325 +engine_matches_executor_in_memory f4cae3ab2c1637ed 1 c3f77eeec1657e38 +engine_matches_executor_in_memory f4db12165672633b 0 cbf29ce484222325 +engine_matches_executor_in_memory f4e633f58d1d54b6 3 d8dbefadddb9dc30 +engine_matches_executor_in_memory f5253a1de6093e94 1 04b33efa45692bb9 +engine_matches_executor_in_memory f533e102427b842d 9 dc0e89f9c7e2c31a +engine_matches_executor_in_memory f53dea54a8c78f96 1 2b0a3a192b55558b +engine_matches_executor_in_memory f5ae4be3040b2196 1 a006d93e27ee99ab +engine_matches_executor_in_memory f5c0914ae75195a4 4 9bb94d523b910521 +engine_matches_executor_in_memory f5d58306a811f2a5 16 0c62dcbe78642f82 +engine_matches_executor_in_memory f5e30413e85890f0 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory f603f336a41dbbad 0 cbf29ce484222325 +engine_matches_executor_in_memory f60d5eaecc51fbc3 3 901ee687b20c92e8 +engine_matches_executor_in_memory f6653c952fa929d5 0 cbf29ce484222325 +engine_matches_executor_in_memory f67d09205d4c6fe2 0 cbf29ce484222325 +engine_matches_executor_in_memory f68a8ba9ea9db5ac 0 cbf29ce484222325 +engine_matches_executor_in_memory f7084dbc8eac52cd 2 165c3461e0fdcca5 +engine_matches_executor_in_memory f7344ac718317d0a 1 99bad883d8b821dd +engine_matches_executor_in_memory f7344ac718317d0a 16 b2c8e8e25939ab99 +engine_matches_executor_in_memory f7344ac718317d0a 4 a016bb0c65291141 +engine_matches_executor_in_memory f7344ac718317d0a 9 8025d3b06be63fb1 +engine_matches_executor_in_memory f78d1360f78c95f7 12 e8ee335a6003b271 +engine_matches_executor_in_memory f78d1360f78c95f7 18 4b962f179874ce46 +engine_matches_executor_in_memory f78d1360f78c95f7 24 d525d644807968c9 +engine_matches_executor_in_memory f78d1360f78c95f7 6 64d778a92d95baa6 +engine_matches_executor_in_memory f7a9cdc207ad743b 1 bd5fc6f0d95f60cd +engine_matches_executor_in_memory f7a9cdc207ad743b 2 86bd2c7a526e97fd +engine_matches_executor_in_memory f7a9cdc207ad743b 4 ac01b96d51ed3fa3 +engine_matches_executor_in_memory f7a9cdc207ad743b 6 861eb491878c8fca +engine_matches_executor_in_memory f7e67a687a2a90ca 0 cbf29ce484222325 +engine_matches_executor_in_memory f82b62d9ed544213 2 91354de013e1f421 +engine_matches_executor_in_memory f8626667c41b28d8 9 8ca71f9b8089854b +engine_matches_executor_in_memory f869c32dd064c39d 0 cbf29ce484222325 +engine_matches_executor_in_memory f8fa9016c3858192 12 5cdc20067e6e40b1 +engine_matches_executor_in_memory f8fa9016c3858192 3 280df05b87730ad6 +engine_matches_executor_in_memory f8fa9016c3858192 6 d7e0f8ed096cb869 +engine_matches_executor_in_memory f8fa9016c3858192 9 cc451edf7c407500 +engine_matches_executor_in_memory f9173b04f3dfb2b0 6 70b06d654f921286 +engine_matches_executor_in_memory f9357053dbec4556 0 cbf29ce484222325 +engine_matches_executor_in_memory f938f757e56d94b6 6 45ca3e62e57c334d +engine_matches_executor_in_memory f9508d43258a9619 1 17aa6399587da023 +engine_matches_executor_in_memory f96f5ee77fcd9c41 2 86bd2c7a526e97fd +engine_matches_executor_in_memory f9a9fcd3e6eecc7d 1 2b0a3a192b55558b +engine_matches_executor_in_memory f9ba1ded78d906ec 0 cbf29ce484222325 +engine_matches_executor_in_memory fa63cdaf79596f7f 2 86bd2c7a526e97fd +engine_matches_executor_in_memory fa9451ac19c3a074 1 2b0a3a192b55558b +engine_matches_executor_in_memory fa964c7aacf2b3db 6 4caf4e58d2f71a3d +engine_matches_executor_in_memory fab334098d87e286 4 feb9196f7fff18b5 +engine_matches_executor_in_memory fadb347c9e0bdbed 114 2edf26b5caf773ab +engine_matches_executor_in_memory fafb214c7475c636 4 c85c2256280d6152 +engine_matches_executor_in_memory fb441fa135c14162 4 2887891473b7ca25 +engine_matches_executor_in_memory fb4dfd54b1d8603e 0 cbf29ce484222325 +engine_matches_executor_in_memory fb64a67b20fd3745 3 30648b85fdf25569 +engine_matches_executor_in_memory fb99bc69bb5c317f 1 c3f77eeec1657e38 +engine_matches_executor_in_memory fbdb74079af161c0 2 d69b4a517d2cc546 +engine_matches_executor_in_memory fbee3fc53c3e45ea 3 6526f0696876a02f +engine_matches_executor_in_memory fc14cbc1f4468b07 0 cbf29ce484222325 +engine_matches_executor_in_memory fc34f499749808d4 0 cbf29ce484222325 +engine_matches_executor_in_memory fc3bf7d6a8cfa6e9 9 f4d27fdfca1c0fb8 +engine_matches_executor_in_memory fc5e1846ccaa9262 10 b5ae1711d5e51afb +engine_matches_executor_in_memory fc60da2457021f36 2 dd5187ca97af06b9 +engine_matches_executor_in_memory fc6fb97a762e4659 49 1173ab68adb3e8a8 +engine_matches_executor_in_memory fceadc5130774153 0 cbf29ce484222325 +engine_matches_executor_in_memory fd1848351649b8bd 12 9d936610709bcdd9 +engine_matches_executor_in_memory fd6672da00d14266 0 cbf29ce484222325 +engine_matches_executor_in_memory fd7c0bdd496d3762 2 c70b48a0fbacf660 +engine_matches_executor_in_memory fda9d4a7af61989a 12 6d5f0f6a2721b39d +engine_matches_executor_in_memory fdcdf9c8a95561d0 17 b60d9877bcaad67e +engine_matches_executor_in_memory fdf09fc019cdadde 1 cce6be2e1764baec +engine_matches_executor_in_memory fe3fad897753500d 84 9511e0ef6a48f3ce +engine_matches_executor_in_memory fe54010f36a81119 2 400fc96da32be273 +engine_matches_executor_in_memory fe54010f36a81119 4 d4beeeb89c6410cf +engine_matches_executor_in_memory fe54010f36a81119 6 861eb491878c8fca +engine_matches_executor_in_memory fe8f3837a4886aee 1 687565f6b7ea5ded +engine_matches_executor_in_memory feb3fd7021daa2a2 2 cbb58e52af0e0313 +engine_matches_executor_in_memory feddf5dd3502c879 22 975bc14609632ae8 +engine_matches_executor_in_memory fee34c0c83f27f2e 0 cbf29ce484222325 +engine_matches_executor_in_memory ff08dd19d6370c33 0 cbf29ce484222325 +engine_matches_executor_in_memory ff2d79784729d821 1 77b2edc4a1fd9338 +engine_matches_executor_in_memory ffd5159b7608c081 96 04e08083113c9801 +engine_matches_executor_in_memory fff08bfb3f05ad55 24 79ea8703d69e7659 +engine_matches_executor_in_memory fff08bfb3f05ad55 54 a3a71ce818ab892b +engine_matches_executor_in_memory fff08bfb3f05ad55 6 a23fbe14418efb53 +engine_matches_executor_in_memory fff08bfb3f05ad55 96 3f61ceaccf5e9785 +engine_matches_executor_in_memory fff512fc56593ba8 1 af144c146cedcd4e +engine_reads_many_batches 3c0b32afd6f2077d 1 8c7a0fe481d7c337 +engine_reads_many_batches 4472257428c69c7e 1 f42b1ff80d67a9bf +engine_reads_many_batches 5bc03ef82b47a3bb 4498 33050821d08d0451 +engine_reads_many_batches d8b3cb9636ced2d8 7498 dff81fbe156d7937 +negation_keeps_multiplicity 718150d3e78c8031 2 b93f601997166bf9 +negation_keeps_multiplicity c73f340dd299e035 1 adec6a7dba485089 +negation_matches_executor 047be29d0833f36f 0 cbf29ce484222325 +negation_matches_executor 051f1a837f12d8cc 0 cbf29ce484222325 +negation_matches_executor 084c559bb7daa483 0 cbf29ce484222325 +negation_matches_executor 092ba8573dd95c01 0 cbf29ce484222325 +negation_matches_executor 092ba8573dd95c01 1 e9d4f815bf863abe +negation_matches_executor 0a77883a14facbbb 0 cbf29ce484222325 +negation_matches_executor 0b07d06e041b5ec5 0 cbf29ce484222325 +negation_matches_executor 0d98fd0ccff8a759 1 e473788b7e0dd2bf +negation_matches_executor 0f3f78fba3f58416 0 cbf29ce484222325 +negation_matches_executor 1033de200924834e 0 cbf29ce484222325 +negation_matches_executor 12fe320efe3a9567 6 c369485b5f37d49f +negation_matches_executor 135c8a139f4cf27d 0 cbf29ce484222325 +negation_matches_executor 135c8a139f4cf27d 6 c369485b5f37d49f +negation_matches_executor 13c68e472f5cc172 0 cbf29ce484222325 +negation_matches_executor 163a2c73ecc78d37 0 cbf29ce484222325 +negation_matches_executor 163a2c73ecc78d37 2 409255853785855f +negation_matches_executor 1710e149a4aa05f2 0 cbf29ce484222325 +negation_matches_executor 1710e149a4aa05f2 3 cfebdd838ce29455 +negation_matches_executor 1727f8e6b8dd515c 0 cbf29ce484222325 +negation_matches_executor 18135379375a9513 6 c369485b5f37d49f +negation_matches_executor 1842470856e41a34 0 cbf29ce484222325 +negation_matches_executor 1842470856e41a34 3 2acc8a26116c1302 +negation_matches_executor 1a2b53c655fa9798 0 cbf29ce484222325 +negation_matches_executor 1ad2ddfd2af5ebe4 0 cbf29ce484222325 +negation_matches_executor 1affeddf00ddef77 0 cbf29ce484222325 +negation_matches_executor 1b51a338dd39ee5e 0 cbf29ce484222325 +negation_matches_executor 1cb389136079eadd 6 c369485b5f37d49f +negation_matches_executor 1eee9e1d87e35098 0 cbf29ce484222325 +negation_matches_executor 20dd9084e6901f1e 0 cbf29ce484222325 +negation_matches_executor 22516c3a0a558ed0 0 cbf29ce484222325 +negation_matches_executor 23fda4e9e5206606 6 caf5fd7df73c383b +negation_matches_executor 258104f95d89179a 1 592e65f36322ea3b +negation_matches_executor 2a58766e73106de5 0 cbf29ce484222325 +negation_matches_executor 2a6a858d9c9f9ef3 2 04652a0bbf9856fd +negation_matches_executor 2b174b012b998eb9 0 cbf29ce484222325 +negation_matches_executor 2c0332fbc5a3c695 2 2ec11106f22303e6 +negation_matches_executor 2c0332fbc5a3c695 2 7514b511b93da0a9 +negation_matches_executor 2c0332fbc5a3c695 2 a14f00fc126f8f18 +negation_matches_executor 2cf58a3b5fe6204f 0 cbf29ce484222325 +negation_matches_executor 2d460fae7b6a7035 0 cbf29ce484222325 +negation_matches_executor 2fbff3adc35c2906 0 cbf29ce484222325 +negation_matches_executor 303a4dd0a16de914 2 ec8f95a385dfec23 +negation_matches_executor 30cb6c574bf6eed1 3 a19d471c2957c486 +negation_matches_executor 311ae3d9a90d00a8 3 cfebdd838ce29455 +negation_matches_executor 3274ba7766c0883e 1 687565f6b7ea5ded +negation_matches_executor 3450e5e3c5a8611e 0 cbf29ce484222325 +negation_matches_executor 352d46f6f558be30 6 f496a16541fb381c +negation_matches_executor 36a3a2d665d5f195 6 f496a16541fb381c +negation_matches_executor 37b621d4364d10ca 3 d406dd7c06fe561e +negation_matches_executor 3851cb4eed378241 0 cbf29ce484222325 +negation_matches_executor 38a5f94bcb2f4460 3 cfebdd838ce29455 +negation_matches_executor 3b1555c8eb6ff128 2 2ec11106f22303e6 +negation_matches_executor 3b1555c8eb6ff128 2 7514b511b93da0a9 +negation_matches_executor 3b1555c8eb6ff128 2 a14f00fc126f8f18 +negation_matches_executor 3ca05b091b73ba42 0 cbf29ce484222325 +negation_matches_executor 3ca05b091b73ba42 2 409255853785855f +negation_matches_executor 3d427c4aadee6bd8 0 cbf29ce484222325 +negation_matches_executor 3e649df532ea2876 3 bcd5b383f3919bc2 +negation_matches_executor 40e64a3afc446b1c 1 687565f6b7ea5ded +negation_matches_executor 42e2ce7ed903256b 2 ec8f95a385dfec23 +negation_matches_executor 43903f13cff73398 6 c369485b5f37d49f +negation_matches_executor 43ac284d6e158f90 2 4b3009c387b3c55f +negation_matches_executor 44db48575cf01eb7 0 cbf29ce484222325 +negation_matches_executor 4578a9b140353e73 0 cbf29ce484222325 +negation_matches_executor 4578a9b140353e73 3 bcd5b383f3919bc2 +negation_matches_executor 48c57c0e9f611566 0 cbf29ce484222325 +negation_matches_executor 48c57c0e9f611566 2 ec8f95a385dfec23 +negation_matches_executor 493ad14535a50b4e 1 c15c412b10e3c9f4 +negation_matches_executor 49e8ef6acb8a50c4 1 0bc011c217739264 +negation_matches_executor 4ad1ca6e94c6ca0a 0 cbf29ce484222325 +negation_matches_executor 4d31b1046534989f 5 6de9d5dc79b39471 +negation_matches_executor 4ed78f3af4b74982 0 cbf29ce484222325 +negation_matches_executor 4fb7203c42ffadb1 0 cbf29ce484222325 +negation_matches_executor 547b51977640b9e3 0 cbf29ce484222325 +negation_matches_executor 58140bee6188c490 0 cbf29ce484222325 +negation_matches_executor 5a33fa74e2ab091a 3 9cbe245a315e8096 +negation_matches_executor 5a33fa74e2ab091a 3 cb355cc9f650b085 +negation_matches_executor 5a33fa74e2ab091a 3 e1e00dbfe43478ae +negation_matches_executor 5a59ec1d88318b13 5 3649b789177ca8a7 +negation_matches_executor 5abccbd5f42ddaff 0 cbf29ce484222325 +negation_matches_executor 5abffca91d816acd 0 cbf29ce484222325 +negation_matches_executor 5b73d385c8cefaa2 0 cbf29ce484222325 +negation_matches_executor 5bc024f1037ad3ee 2 f04f033a623dfcd7 +negation_matches_executor 5ea6b9691e76b809 3 cfebdd838ce29455 +negation_matches_executor 5f5ee1f0080cf6d7 0 cbf29ce484222325 +negation_matches_executor 61207b41a94bf9f8 0 cbf29ce484222325 +negation_matches_executor 62f5bdd3037a945b 4 509ad647b1227e48 +negation_matches_executor 667641110e105431 0 cbf29ce484222325 +negation_matches_executor 67d877e3b970f7c1 2 ec8f95a385dfec23 +negation_matches_executor 68172463f39fe07c 2 2ec11106f22303e6 +negation_matches_executor 68172463f39fe07c 2 7514b511b93da0a9 +negation_matches_executor 68172463f39fe07c 2 a14f00fc126f8f18 +negation_matches_executor 69a679f0952cfc70 1 019e1dcbb51621dc +negation_matches_executor 6c497641933ac3a2 0 cbf29ce484222325 +negation_matches_executor 6ceba112e6ba550e 0 cbf29ce484222325 +negation_matches_executor 6d5419094e8b5c97 2 2ec11106f22303e6 +negation_matches_executor 6d5419094e8b5c97 2 7514b511b93da0a9 +negation_matches_executor 6d5419094e8b5c97 2 a14f00fc126f8f18 +negation_matches_executor 6e6cc06b36eb0151 1 0bc011c217739264 +negation_matches_executor 6f4fa53d29e58eac 0 cbf29ce484222325 +negation_matches_executor 7165f0e6bc19cba3 1 a006d93e27ee99ab +negation_matches_executor 73760f7693225722 0 cbf29ce484222325 +negation_matches_executor 73760f7693225722 1 a006d93e27ee99ab +negation_matches_executor 741a6abcd4ef63ae 2 1f230fde47728c45 +negation_matches_executor 7564f51d84932b56 0 cbf29ce484222325 +negation_matches_executor 759d62a09f0ccf3e 3 cb355cc9f650b085 +negation_matches_executor 75ca8f756b499d77 0 cbf29ce484222325 +negation_matches_executor 76308cf468df1f33 1 d1c8bd90077e4faf +negation_matches_executor 770b5b6de366c0d9 3 9cbe245a315e8096 +negation_matches_executor 770b5b6de366c0d9 3 cb355cc9f650b085 +negation_matches_executor 770b5b6de366c0d9 3 e1e00dbfe43478ae +negation_matches_executor 797ca6a964bc14d0 0 cbf29ce484222325 +negation_matches_executor 797ca6a964bc14d0 3 bcd5b383f3919bc2 +negation_matches_executor 79bf616f6a342c87 0 cbf29ce484222325 +negation_matches_executor 7b6d774057bca2de 0 cbf29ce484222325 +negation_matches_executor 7cef05adf62ff699 0 cbf29ce484222325 +negation_matches_executor 7e065b6d281aa28f 0 cbf29ce484222325 +negation_matches_executor 7e065b6d281aa28f 3 2acc8a26116c1302 +negation_matches_executor 7efe6560b6623726 0 cbf29ce484222325 +negation_matches_executor 8278d4fc30d4777f 0 cbf29ce484222325 +negation_matches_executor 85b6e0c21dca86bb 0 cbf29ce484222325 +negation_matches_executor 881af6003cdd3bd6 0 cbf29ce484222325 +negation_matches_executor 88b64e140addd6f4 1 088eab074d14a11a +negation_matches_executor 88b88d10991a0c7a 0 cbf29ce484222325 +negation_matches_executor 8957232ce294f56d 2 3ed5c0df91fa32e5 +negation_matches_executor 8a303927303d7820 2 a6d9008eb69a069b +negation_matches_executor 8c4c2ca0f457fa43 0 cbf29ce484222325 +negation_matches_executor 8e0dc7df0b67d0f8 3 9cbe245a315e8096 +negation_matches_executor 900b9238ce5d1f43 2 843bb90e43e406c3 +negation_matches_executor 90cb2ee4a4135bea 0 cbf29ce484222325 +negation_matches_executor 9153d2216fd21bac 0 cbf29ce484222325 +negation_matches_executor 91ca4e6e2b6c5d54 0 cbf29ce484222325 +negation_matches_executor 92cca12e0d72adb3 0 cbf29ce484222325 +negation_matches_executor 94a0f90e313d6e47 0 cbf29ce484222325 +negation_matches_executor 94f9d0429dc0505f 1 291906242b078546 +negation_matches_executor 959f1333efa59fa3 1 687565f6b7ea5ded +negation_matches_executor 973a9e1f7317f7f7 6 f496a16541fb381c +negation_matches_executor 973d40294ec2a071 3 cfebdd838ce29455 +negation_matches_executor 99b09c6e25eac38b 3 cfebdd838ce29455 +negation_matches_executor 99b09c6e25eac38b 6 caf5fd7df73c383b +negation_matches_executor a185bb5b72f44aa1 2 843bb90e43e406c3 +negation_matches_executor a1c86c9966f59d51 0 cbf29ce484222325 +negation_matches_executor a262ba5e624da433 2 be8f485dea13e2a1 +negation_matches_executor a2c8255fa674efcc 1 a006d93e27ee99ab +negation_matches_executor a37527973b157c68 2 ec8f95a385dfec23 +negation_matches_executor a56600e47e85df47 6 f496a16541fb381c +negation_matches_executor a68f72885639700e 2 f04f033a623dfcd7 +negation_matches_executor aaed822b6ecd8acf 0 cbf29ce484222325 +negation_matches_executor abb3cee9a8a00264 0 cbf29ce484222325 +negation_matches_executor abde857a1a34c5c2 3 cfebdd838ce29455 +negation_matches_executor abde857a1a34c5c2 6 caf5fd7df73c383b +negation_matches_executor b0278b1a65d4e6b7 0 cbf29ce484222325 +negation_matches_executor b0367f21a62d2bb0 1 eb7deb3203c95fa7 +negation_matches_executor b13c32333596a993 0 cbf29ce484222325 +negation_matches_executor b181091ff90c1643 0 cbf29ce484222325 +negation_matches_executor b46e1a24566041fa 0 cbf29ce484222325 +negation_matches_executor b47e285953b22585 0 cbf29ce484222325 +negation_matches_executor b47e285953b22585 3 cfebdd838ce29455 +negation_matches_executor b51b4a1770ab4194 0 cbf29ce484222325 +negation_matches_executor b537d3fe96f81530 3 cfebdd838ce29455 +negation_matches_executor b6b7fb0b3ef4c408 0 cbf29ce484222325 +negation_matches_executor b7067ee699d19ae8 3 292589bdd0c11d3c +negation_matches_executor b727256c013f3563 1 172f08ba9c63e405 +negation_matches_executor b750ad05f8d67d19 3 2acc8a26116c1302 +negation_matches_executor b81c563fbb4e4f8a 0 cbf29ce484222325 +negation_matches_executor b9a41054623f2913 0 cbf29ce484222325 +negation_matches_executor ba30fb5c126780d4 3 cfebdd838ce29455 +negation_matches_executor bbd6a47cec97cf32 2 2ec11106f22303e6 +negation_matches_executor bbd6a47cec97cf32 2 7514b511b93da0a9 +negation_matches_executor bbd6a47cec97cf32 2 a14f00fc126f8f18 +negation_matches_executor bbf689722df85b97 0 cbf29ce484222325 +negation_matches_executor bda9c4dd4ff6804a 0 cbf29ce484222325 +negation_matches_executor bf17ace7fe453fdf 0 cbf29ce484222325 +negation_matches_executor c10744b57224a5fd 0 cbf29ce484222325 +negation_matches_executor c19a7e8e8a3f7ab6 0 cbf29ce484222325 +negation_matches_executor c1eddd15c47c6614 3 cfebdd838ce29455 +negation_matches_executor c677497b30bd7049 0 cbf29ce484222325 +negation_matches_executor c6a622acf767157d 0 cbf29ce484222325 +negation_matches_executor c6a622acf767157d 3 d406dd7c06fe561e +negation_matches_executor c6c22a0cfbb1a1f3 0 cbf29ce484222325 +negation_matches_executor c855d2d141acfe8e 0 cbf29ce484222325 +negation_matches_executor ce298f56dce55e76 3 2acc8a26116c1302 +negation_matches_executor d38be57ccb0406e0 3 22a64ab75998c914 +negation_matches_executor d7d949d281b38b87 2 3ed5c0df91fa32e5 +negation_matches_executor d7d949d281b38b87 4 509ad647b1227e48 +negation_matches_executor d7d949d281b38b87 6 208e79580529bd6c +negation_matches_executor d80ecb995a29e14d 0 cbf29ce484222325 +negation_matches_executor d827dfb1c69bdce2 6 f496a16541fb381c +negation_matches_executor dbe837530981a54e 3 cfebdd838ce29455 +negation_matches_executor dc9b7a1b1f1a95ac 0 cbf29ce484222325 +negation_matches_executor dd8e6e74bde572a9 0 cbf29ce484222325 +negation_matches_executor de77765e4e5af5c8 2 3ed5c0df91fa32e5 +negation_matches_executor de77765e4e5af5c8 4 509ad647b1227e48 +negation_matches_executor de77765e4e5af5c8 6 208e79580529bd6c +negation_matches_executor df54cd4abed2ae86 0 cbf29ce484222325 +negation_matches_executor e030487c6c3c6308 0 cbf29ce484222325 +negation_matches_executor e030487c6c3c6308 3 d406dd7c06fe561e +negation_matches_executor e11b07cc96e09582 0 cbf29ce484222325 +negation_matches_executor e17b6c7cdeb07c28 3 7a36c68b4da28dfc +negation_matches_executor e19af11b3ce2e6fb 0 cbf29ce484222325 +negation_matches_executor e2d72a31cd2745d6 0 cbf29ce484222325 +negation_matches_executor e426d25ab0f0e2f8 0 cbf29ce484222325 +negation_matches_executor e486fe6bcd00d82c 2 f04f033a623dfcd7 +negation_matches_executor e4d336a11a70c397 5 26323288c68397e4 +negation_matches_executor e8999e06fd7e2e8b 6 f496a16541fb381c +negation_matches_executor e98b4e9428ab9a39 0 cbf29ce484222325 +negation_matches_executor eb8cbea2f7311966 0 cbf29ce484222325 +negation_matches_executor ecd86c206cbfba3f 1 0bc011c217739264 +negation_matches_executor ed73ec61eda1480e 3 292589bdd0c11d3c +negation_matches_executor ef643d1b66213818 0 cbf29ce484222325 +negation_matches_executor f07b3a09928d2ebe 0 cbf29ce484222325 +negation_matches_executor f33fb46726e89616 0 cbf29ce484222325 +negation_matches_executor f3627a6ad32b45c9 0 cbf29ce484222325 +negation_matches_executor f65862acbf217257 0 cbf29ce484222325 +negation_matches_executor f6ea378cd1b723ad 3 67b8fd74342ef287 +negation_matches_executor f8b50ee4be0d0cd2 6 caf5fd7df73c383b +negation_matches_executor f8f331042e624793 0 cbf29ce484222325 +negation_matches_executor f9792c9f87c2d481 1 a006d93e27ee99ab +negation_matches_executor fc4d8b28e88c0242 0 cbf29ce484222325 +negation_matches_executor fc944fd99e9c8182 0 cbf29ce484222325 +negation_matches_executor fd7bc29ddd72bc11 1 d8054e5592aedb2e +negation_matches_executor fd7ecc79e2416210 0 cbf29ce484222325 +negation_matches_executor fd7ecc79e2416210 4 09bb376159ad3d90 +negation_matches_executor fd9386d3d7ae5de8 0 cbf29ce484222325 +negation_matches_executor fe2cefbd1a131355 1 e276580c97777e8c +negation_matches_executor fe588eb067f2d646 2 63487c34d23f2409 +negation_matches_executor ff535635fecd04a1 0 cbf29ce484222325 +negation_matches_executor ff9b63e231c32d84 1 0bc011c217739264 +negation_matches_executor ffd1ffeca3477e0f 0 cbf29ce484222325 +negation_routing 1ac5587a032e0127 2 ec05e7dc68f74987 +negation_routing 5a87f86ba8fe394f 4 c1a8b5275c1c709c +negation_routing 89f7398c10dd1cb6 3 4bdb5eb026698857 +negation_routing c2fe7da1d5ab107a 2 ec05e7dc68f74987 +no_pattern_first 223f8d244b0a862a 1 2b0a39192b5553d8 +no_pattern_first 275682864dc4ac68 0 cbf29ce484222325 +no_pattern_first 445b293529a84fb5 1 75741c9011909650 +no_pattern_first 788ab7ba8ce78364 2 b01fdf1165eee7af +no_pattern_first ce7c4046a77d431a 1 6da24d6639ddc880 +no_pattern_first df24c5f45173ddd4 0 cbf29ce484222325 +no_pattern_first e841a06f6d06a221 1 6da24d6639ddc880 +not_bodies_plan_as_clause_lists 07a2cd1cfc45bcc6 2 54e8aae90ee45459 +not_bodies_plan_as_clause_lists 92ae19a63d955c9d 3 334b7473ff8bc18a +not_bodies_plan_as_clause_lists 9c4ccbd1c930e739 3 334b7473ff8bc18a +planner_errors_keep_their_codes 8d2f701fd7f4a458 1 d800c42686702fe9 +rule_delta_runs_join_on_a_bound_variable 3a840c32501fd782 110 78d43ae4a90656ea +rule_delta_runs_join_on_a_bound_variable ae359baa9829c163 10 2b10d79d79ce1507 +rule_queries_read_derived_rows_in_batches 012b6bf9d9c1ae59 1 c13a0e3963062b18 +rule_queries_read_derived_rows_in_batches 369983c34fa19a12 1770 a558c80e22ebd308 +rule_queries_read_derived_rows_in_batches 39ceb6c40d7ac3dc 1770 a558c80e22ebd308 +rule_queries_read_derived_rows_in_batches 7ed6e72e3bc58582 59 eda3b47cdcdf4d04 +rule_query_routing 32d3e4d5050e44e3 1 75741c9011909650 +rule_query_routing 369983c34fa19a12 3 2b9101d4b11ba754 +rule_query_routing 4fb26550baf3a6d1 1 75741c9011909650 +rule_query_routing 57c18e0e4c2d3d59 2 02b1d1046853e1c4 +rule_query_routing 9cdc76b397fe1ac5 3 2b9101d4b11ba754 +rule_query_routing e3c9735c8586e200 0 cbf29ce484222325 +window_routing 34f4a4cc8f6e63ca 4 7edb2d3ac44b6289 +window_routing b16fb0833e2b5faf 4 ad00ad205380e0a2 +window_routing d1a4aa676b518bd6 0 cbf29ce484222325 +windows_match_executor 049960d8600d68b2 17 f7ee94d03c1e7cc8 +windows_match_executor 051588f3f32eb801 5 f20e1e2d18aa6e21 +windows_match_executor 05bb526bab17adbc 0 cbf29ce484222325 +windows_match_executor 07694d9147dfcc8f 9 81b1dc6f0b16f436 +windows_match_executor 0b89f7302e4bc96c 1 a6d60c8c1fbea68c +windows_match_executor 0ba916e2bf040052 12 766e8c3963b39a83 +windows_match_executor 0ea5fa5dd3e38baa 0 cbf29ce484222325 +windows_match_executor 0ed3c15a4392ea16 3 a9453d5768699dda +windows_match_executor 0fe9da31592552f6 3 8c35f220f469d49e +windows_match_executor 10ab1988207b6c02 18 516a56738210d103 +windows_match_executor 10ab1988207b6c02 24 00a53c16ab60bf05 +windows_match_executor 134ecd0a47bb6454 1 a46c848c0b0413a2 +windows_match_executor 165efaf1a456f0e2 3 865bb7beae42c541 +windows_match_executor 18e8373ea10ccaec 18 60cff4ca546bf0aa +windows_match_executor 19cd21b3e5c61eed 0 cbf29ce484222325 +windows_match_executor 1ba6d8f3ff035e60 8 d63754e7930f7d88 +windows_match_executor 1eac7b050c7e395c 8 63b2dc400f1af348 +windows_match_executor 22599faaf3c91a19 3 44cab34423b5e357 +windows_match_executor 2c6ee93656d5850c 6 75a0aab90313959b +windows_match_executor 2d57249bca595fed 12 9f9e3b1d5a730247 +windows_match_executor 2d57249bca595fed 9 c3e9b4ca48a7815f +windows_match_executor 36c0bff0160ede58 0 cbf29ce484222325 +windows_match_executor 371f2bb5698db120 12 0c6af1088307b250 +windows_match_executor 39fc000763ea9705 12 ee1ddb5277a06dde +windows_match_executor 39fc000763ea9705 9 10a4196e0ae5da8c +windows_match_executor 3b0d89b8fd409879 12 82f293712995d141 +windows_match_executor 3b0d89b8fd409879 9 8844aa41500fbfbb +windows_match_executor 3d54b37103110f98 3 11a6d92e74fe2828 +windows_match_executor 3d54b37103110f98 3 1874456422f8a464 +windows_match_executor 42fead0d6c5ca64e 1 8284c1a67b849b90 +windows_match_executor 48264e8068967c25 24 bff1c9a615f826ad +windows_match_executor 48264e8068967c25 30 12376209da7a0ff8 +windows_match_executor 4a272ac32cc34056 17 5d235d4b0376c94f +windows_match_executor 4d39988d9d980ad4 13 657e4481fe0f3efd +windows_match_executor 4f5c7220eb6cca36 24 fa18315a05a26b6d +windows_match_executor 51e28f001fb3e5f4 1 231b031e1990a7be +windows_match_executor 589af32aa2b99410 30 12376209da7a0ff8 +windows_match_executor 5a66d917fa402bdc 8 25c671dfbeea746d +windows_match_executor 5bbcf19e1bde2cd8 0 cbf29ce484222325 +windows_match_executor 649630956b7bf76c 12 ee1ddb5277a06dde +windows_match_executor 649630956b7bf76c 9 10a4196e0ae5da8c +windows_match_executor 6734557e9be34f88 3 458627117fa27b52 +windows_match_executor 698ca315726c3aad 15 766604fc4d521c9d +windows_match_executor 6b1b74c7f8260af8 13 6834ebd28dfd3bda +windows_match_executor 6cfa7c7437748c20 0 cbf29ce484222325 +windows_match_executor 6e015ea90d200219 0 cbf29ce484222325 +windows_match_executor 6e0483478577d032 18 c0290f3cda4f8ffa +windows_match_executor 6e0483478577d032 24 cbd422c46f2661a5 +windows_match_executor 6e7afb69f3d627a9 18 516a56738210d103 +windows_match_executor 6e7afb69f3d627a9 24 00a53c16ab60bf05 +windows_match_executor 749c1883727e7866 3 8683a9938d539bac +windows_match_executor 7528a587f61e12b4 8 5d585d0197bc04c8 +windows_match_executor 7528a587f61e12b4 8 702ea3ecda8571aa +windows_match_executor 76ff84417a422753 0 cbf29ce484222325 +windows_match_executor 79d7b9f012b365fc 0 cbf29ce484222325 +windows_match_executor 7b6f9cdd6d342d10 6 f3293a2f253a59f1 +windows_match_executor 7b9cc94ccdf9634c 6 3590df31d29a4060 +windows_match_executor 7bfe047a40ba1917 6 955e5bf086ac5b52 +windows_match_executor 7bfe047a40ba1917 6 c998411419e477ee +windows_match_executor 833031ca6c0f3796 12 e3cb4ad2be0971bb +windows_match_executor 83c65cbf0fa065bf 18 c0290f3cda4f8ffa +windows_match_executor 83c65cbf0fa065bf 24 cbd422c46f2661a5 +windows_match_executor 84f888b06a370ae8 24 bff1c9a615f826ad +windows_match_executor 84f888b06a370ae8 30 12376209da7a0ff8 +windows_match_executor 855bbebb850bfa40 1 af5455a7aef63c90 +windows_match_executor 85b1dafc8708b41b 4 37482500190355fa +windows_match_executor 85bb24296c0cdfec 148 8a07b3b6f7face8e +windows_match_executor 865d6ecbbdd746e6 3 a5ff90cdeffbca42 +windows_match_executor 8b39c08550e0214c 129 0f3f5034028713d7 +windows_match_executor 8b39c08550e0214c 153 683a84230b48ef88 +windows_match_executor 8c54c179a9cea3b6 6 497d1bcfd6ed2a40 +windows_match_executor 8c54c179a9cea3b6 6 dc075e5a357b0014 +windows_match_executor 8d7105a2f8c4453b 3 11a6d92e74fe2828 +windows_match_executor 8d7105a2f8c4453b 3 1874456422f8a464 +windows_match_executor 8da5deaabf018778 114 77cb8f93ce51cf77 +windows_match_executor 8e10bdc9f56d95d3 121 9aec99d6ef41fd4b +windows_match_executor 8e10bdc9f56d95d3 145 a6894228bcbe700d +windows_match_executor 9131cbd916f6d1b6 5 b174e2bc74d16229 +windows_match_executor 982a3e31ecee23be 12 9b069e0e13119e85 +windows_match_executor 98bb1c919e5164e9 5 b8a9a33c5a2fc278 +windows_match_executor 9d9a1b742d4edf98 1 8351abde393ad3c5 +windows_match_executor 9da90ba454e97a44 6 2cdc8c657bc58d4c +windows_match_executor 9fc11f5d7ebbc9e0 13 e9051e213f55557d +windows_match_executor a6e1a7c5a449d8f8 23 8f9d8a687720797b +windows_match_executor a92b381b5694243f 84 82cf30f10de85ef2 +windows_match_executor aa9c5f6249816991 6 5aa0602082e11d8c +windows_match_executor ab8bc83615ac6f9b 7 e0dbc671d564c4c7 +windows_match_executor acd488f284026f64 1 ed01da2bd57b04be +windows_match_executor ad9ac6a4016f9388 12 82f293712995d141 +windows_match_executor ad9ac6a4016f9388 9 8844aa41500fbfbb +windows_match_executor b0e21069931d7960 12 ee6537f58418c2ee +windows_match_executor b0e21069931d7960 9 143452864bcace43 +windows_match_executor b3521ec9740a418f 12 766e8c3963b39a83 +windows_match_executor b41b8c4ca5378836 12 766e8c3963b39a83 +windows_match_executor b50596bc52b05e38 13 08b247b255e41666 +windows_match_executor b82c2bf9cedd2c60 0 cbf29ce484222325 +windows_match_executor ba87ce125d9c15d1 12 ee6537f58418c2ee +windows_match_executor ba87ce125d9c15d1 9 143452864bcace43 +windows_match_executor bd320b595f1414f8 12 9f9e3b1d5a730247 +windows_match_executor bd320b595f1414f8 9 c3e9b4ca48a7815f +windows_match_executor c02867517dce1f83 8 74f788a21ca35ab8 +windows_match_executor c49034f131fbde59 6 5aa0602082e11d8c +windows_match_executor c6312a4e1ac53855 9 f23a15ffef4449ee +windows_match_executor c6e1bc81875c63c5 0 cbf29ce484222325 +windows_match_executor cf6967b4efa80977 1 31a7d8e54b73c53a +windows_match_executor d0b67b1cc3136dac 1 9cc40c08fa38810e +windows_match_executor d1f3d7bc4ee8cfd2 12 766e8c3963b39a83 +windows_match_executor d27b03fdd9130cc2 0 cbf29ce484222325 +windows_match_executor d35ae698bbe25420 0 cbf29ce484222325 +windows_match_executor d7a0f91e4723b1cd 5 619b8030eaf3da94 +windows_match_executor d8573dc709254e4c 3 712e5cc79e039753 +windows_match_executor ddb951e25390e1bf 6 76b580a1543c4306 +windows_match_executor de92963cebe9ec3c 3 ff8042dfa1e5a0d4 +windows_match_executor dedc2103a71f8093 9 590aef2b5c1b96be +windows_match_executor dedc2103a71f8093 9 cf6c330577bf7cea +windows_match_executor e196407ba9117fea 12 766e8c3963b39a83 +windows_match_executor e7012e5e786d9f78 8 ba5f3e5d4f9ee5f4 +windows_match_executor e9dd91414f1d7327 3 865bb7beae42c541 +windows_match_executor ee8f672b0ab68d7f 3 886532a66a3c1b0a +windows_match_executor f3b03e2a929aeaa8 0 cbf29ce484222325 +windows_match_executor f42fd67d1f4e9508 100 6b54992e4d5f1ace +windows_match_executor f444392945caf9b0 0 cbf29ce484222325 +windows_match_executor f51bff38895f25bc 2 3909e457ac7077be +windows_match_executor f5b12cee302ea7a4 1 50a1e694048ad72d +windows_match_executor f70b54dda609cdae 24 cbd422c46f2661a5 +windows_match_executor f8a221a40e2bbafd 4 a78f05bd9c8fe7a5 +windows_match_executor ff4b9ea28429b1d1 5 78156efd357167aa diff --git a/tests/answers/mod.rs b/tests/answers/mod.rs new file mode 100644 index 0000000000..3570ecf76c --- /dev/null +++ b/tests/answers/mod.rs @@ -0,0 +1,130 @@ +//! Frozen answers (#551). Until #551 every query the engine ran in these +//! tests was also run by the executor, and a different answer failed the +//! test. With the executor gone, each answer is compared with those +//! recorded while that check still ran, in `tests/answers/.txt`: one +//! line per test, query and answer (row count and a digest of the rows as a +//! bag). A query a test runs over several states has one line per answer, +//! and its answer must be one of them. Integers within a week of now (wall +//! clock `tx-id`s, default `valid-from`s, a query's own `valid-at`) are +//! compared as "now", so data integers there would be too. Values and rows +//! are joined with U+001F and U+001E, which no string in these suites holds. +//! +//! `MINIGRAF_BLESS_ANSWERS=1` appends instead of comparing; then +//! `LC_ALL=C sort -u -o `. A changed file is a changed answer, +//! to be justified in review. +#![allow(dead_code)] + +use minigraf::Value; +use std::collections::HashMap; +use std::io::Write; +use std::sync::{Mutex, OnceLock}; + +/// A value as text, without `Debug` (CodeQL `rust/cleartext-logging`). +fn key(v: &Value) -> String { + match v { + Value::String(s) => format!("s:{s}"), + Value::Integer(i) if now().abs_diff(*i) < WEEK_MS => "i:now".to_string(), + Value::Integer(i) => format!("i:{i}"), + Value::Float(f) => format!("f:{:016x}", f.to_bits()), + Value::Boolean(b) => format!("b:{b}"), + Value::Ref(u) => format!("r:{}", u.as_hyphenated()), + Value::Keyword(k) => format!("k:{k}"), + Value::Null => "nil".to_string(), + } +} + +const WEEK_MS: u64 = 7 * 86_400_000; + +fn now() -> i64 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_millis() as i64) + .unwrap_or(0) +} + +/// FNV-1a: stable across Rust versions, unlike `DefaultHasher`. +fn fnv(bytes: &[u8]) -> u64 { + bytes.iter().fold(0xcbf2_9ce4_8422_2325, |h, b| { + (h ^ u64::from(*b)).wrapping_mul(0x0100_0000_01b3) + }) +} + +fn digest(rows: &[Vec]) -> u64 { + let mut bag: Vec = rows + .iter() + .map(|r| r.iter().map(key).collect::>().join("\u{1f}")) + .collect(); + bag.sort(); + fnv(bag.join("\u{1e}").as_bytes()) +} + +fn path(suite: &str) -> String { + format!("{}/tests/answers/{suite}.txt", env!("CARGO_MANIFEST_DIR")) +} + +fn bless() -> bool { + std::env::var_os("MINIGRAF_BLESS_ANSWERS").is_some_and(|v| v == "1") +} + +/// The test running on this thread, without its module path. +fn test_name() -> String { + let name = std::thread::current() + .name() + .filter(|n| *n != "main") + .expect("frozen answers need the test's own thread") + .to_string(); + name.rsplit("::").next().unwrap_or(&name).to_string() +} + +/// Each test and query digest's recorded answers. +type Frozen = HashMap<(String, u64), Vec<(usize, u64)>>; + +fn frozen(suite: &str) -> &'static Mutex { + static FILES: OnceLock> = OnceLock::new(); + FILES.get_or_init(|| { + let mut map: Frozen = HashMap::new(); + if !bless() { + let text = std::fs::read_to_string(path(suite)).expect("frozen answers file"); + for line in text.lines() { + let f: Vec<&str> = line.split('\t').collect(); + let hex = |s: &str| u64::from_str_radix(s, 16).expect("hex digest"); + map.entry((f[0].to_string(), hex(f[1]))) + .or_default() + .push((f[2].parse().expect("row count"), hex(f[3]))); + } + } + Mutex::new(map) + }) +} + +/// Compare `rows`, the answer to `query`, with the frozen ones (or record +/// it). One suite per test binary. +pub fn check(suite: &str, query: &str, rows: &[Vec]) { + let test = test_name(); + let q = fnv(query.as_bytes()); + let (count, digest) = (rows.len(), digest(rows)); + let map = frozen(suite); + if bless() { + let _held = map + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let mut file = std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(path(suite)) + .unwrap(); + file.write_all(format!("{test}\t{q:016x}\t{count}\t{digest:016x}\n").as_bytes()) + .unwrap(); + return; + } + let map = map + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let Some(answers) = map.get(&(test.clone(), q)) else { + panic!("{test}: no frozen answer to {query}"); + }; + assert!( + answers.contains(&(count, digest)), + "{test}: {count} rows, not a frozen answer to {query}" + ); +} diff --git a/tests/answers/plan_independence_test.txt b/tests/answers/plan_independence_test.txt new file mode 100644 index 0000000000..eada47733d --- /dev/null +++ b/tests/answers/plan_independence_test.txt @@ -0,0 +1,209 @@ +expression_chain_on_variable_bound_only_by_or 72fe7ae611c36b38 1 77bcdec4a205ce40 +expression_chain_on_variable_bound_only_by_or efe1d228a74ad3ea 1 77bce1c4a205d359 +expression_output_equal_to_its_input_never_matches 28759eac5e160295 0 cbf29ce484222325 +expression_reads_variable_bound_only_by_or 27390f5eb673c4bb 1 6da24d6639ddc880 +expression_reads_variable_bound_only_by_or c4a051069168eb56 2 b93f5d19971666e0 +expression_reads_variable_bound_only_by_or_with_rules 2a8f00802f3b48d9 1 2b0a39192b5553d8 +expression_reads_variable_bound_only_by_or_with_rules 488334c0e8bc0bcb 1 2b0a39192b5553d8 +issue_596_example 63a6fd8bbca16842 1 a572dca476abc67b +matrix_file_backed_after_checkpoint 00477823483b7554 4 bc72c96770a22295 +matrix_file_backed_after_checkpoint 0484bea3e26563d4 4 5e1bdf768140d943 +matrix_file_backed_after_checkpoint 07d0175376196443 20 0f18d33234fa7a13 +matrix_file_backed_after_checkpoint 0b2c3ac44daaef34 5 96418b81ef6b8a41 +matrix_file_backed_after_checkpoint 11549146dce73ba9 4 5e1bdf768140d943 +matrix_file_backed_after_checkpoint 143eb85cfe06f3e7 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 1491c265c02611fb 1 63d460ea7091befb +matrix_file_backed_after_checkpoint 18a9434ce027dcfe 4 592dd01c1974d8f7 +matrix_file_backed_after_checkpoint 19adbc631ce883a1 9 0ebfb6e223332995 +matrix_file_backed_after_checkpoint 1a9cdbb59b594562 2 34bedc58544e5f39 +matrix_file_backed_after_checkpoint 1c9cd0e69122598b 1 b6244b779ae251c9 +matrix_file_backed_after_checkpoint 1ceb712563e7cf63 1 9ea9d48d05645123 +matrix_file_backed_after_checkpoint 240e972aa892ce63 1 33a9eb46581e0ea8 +matrix_file_backed_after_checkpoint 261e487c0e99f64b 1 273b06efa38b7c60 +matrix_file_backed_after_checkpoint 274a0a4a7d922adb 1 de8afa6b20debbbb +matrix_file_backed_after_checkpoint 28759eac5e160295 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 2c4e7aa796bb2e08 15 ae5ef5c0c69702a6 +matrix_file_backed_after_checkpoint 2cab371a525c5603 2 fbe904e8f46b6482 +matrix_file_backed_after_checkpoint 2d8809893940098e 4 27f95544908da1a8 +matrix_file_backed_after_checkpoint 308c112d6f7c8a65 4 9ce0a5b3c51ee83f +matrix_file_backed_after_checkpoint 3501de86105a2bdb 11 4d55e95b6aeb3721 +matrix_file_backed_after_checkpoint 357d6feb2a3b3685 2 4d7a86f8923bdfcc +matrix_file_backed_after_checkpoint 36eceb4e7e7f7b8c 3 d9a62b3b857e3578 +matrix_file_backed_after_checkpoint 3c301b2153a0a4e5 5 ce1eb7dc766bf5b6 +matrix_file_backed_after_checkpoint 3c8c2109fc833026 1 273b06efa38b7c60 +matrix_file_backed_after_checkpoint 3dcbb4fc05fb108a 10 fd5d78ddd5627917 +matrix_file_backed_after_checkpoint 408925cd301f652c 3 187cf54306323406 +matrix_file_backed_after_checkpoint 416a01c7fa6033e5 1 273b06efa38b7c60 +matrix_file_backed_after_checkpoint 41ae11a628af7a4e 5 ce1eb7dc766bf5b6 +matrix_file_backed_after_checkpoint 45b088ed29eebe03 3 a3c5f2126709f82a +matrix_file_backed_after_checkpoint 4721ee50188168cf 2 d4f9971f4c5cd21b +matrix_file_backed_after_checkpoint 48222b69d52b0272 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 4b2d6471afad05a5 5 ec7dd20771d6ff80 +matrix_file_backed_after_checkpoint 502e40cd058b7305 5 c5683630f0bb3bb2 +matrix_file_backed_after_checkpoint 559f6caaae7189ef 1 98220bb1f1a150f2 +matrix_file_backed_after_checkpoint 572caca328c3261a 1 9ea9d48d05645123 +matrix_file_backed_after_checkpoint 5b19dc66e957347f 4 b11611d01aadf765 +matrix_file_backed_after_checkpoint 5c607991f526957d 4 5e1bdf768140d943 +matrix_file_backed_after_checkpoint 5d2241144ff4a67d 6 026fc6f0a6028013 +matrix_file_backed_after_checkpoint 5dba272e9d207a1f 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 63a6fd8bbca16842 3 4d0519a89fa2badf +matrix_file_backed_after_checkpoint 67b1a4f8e01106c5 1 273b06efa38b7c60 +matrix_file_backed_after_checkpoint 683146a61da8a48d 2 dc4007a6f9aca9aa +matrix_file_backed_after_checkpoint 6cb6fae58d39e10b 4 252347cf233558c5 +matrix_file_backed_after_checkpoint 6e2017545e54290b 1 2cbd97255d305f28 +matrix_file_backed_after_checkpoint 75c251a81d53e122 4 27f95544908da1a8 +matrix_file_backed_after_checkpoint 78599138313e81ad 1 9c3c42d1e9ba4697 +matrix_file_backed_after_checkpoint 78669deef252ba9b 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 78b9c6e44538c5d1 7 4dae1b59c277a2df +matrix_file_backed_after_checkpoint 7d567691fc37c30c 3 5dc29bc980800a99 +matrix_file_backed_after_checkpoint 7d5b98a5bba6dc40 1 2fa403f688abc622 +matrix_file_backed_after_checkpoint 7f52223343c3f859 1 daa3331ac7c5a0aa +matrix_file_backed_after_checkpoint 80e4cb87eae2a573 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint 82fa607421fcf8cc 4 b813d963a325418e +matrix_file_backed_after_checkpoint 8980e5a99e50b9b4 4 a956eef414d579b0 +matrix_file_backed_after_checkpoint 8a4874ebce66cb0c 3 3e2710468d38d986 +matrix_file_backed_after_checkpoint 8acfea7aac0fa048 2 3076684b3eef7ee2 +matrix_file_backed_after_checkpoint 8f65a83fb3ac9dad 2 fbe904e8f46b6482 +matrix_file_backed_after_checkpoint 92e76c280c9639f4 20 d2378f86062227b3 +matrix_file_backed_after_checkpoint 94d4305918b1b707 11 8e0535ddaa40cb2c +matrix_file_backed_after_checkpoint 9a8d5f940f1dcd8b 5 ce1eb7dc766bf5b6 +matrix_file_backed_after_checkpoint 9b22f09c698421dd 5 ce1eb7dc766bf5b6 +matrix_file_backed_after_checkpoint 9b4ef39ba87b3de0 4 464a90811c63cb38 +matrix_file_backed_after_checkpoint 9f299995574b8f0c 4 1261c2efacf32884 +matrix_file_backed_after_checkpoint a73d169e66e3f429 5 597cc218193cc16e +matrix_file_backed_after_checkpoint ae7f2a307ce19aa5 6 acda828eeac26cc7 +matrix_file_backed_after_checkpoint af47cbb1f81d7c77 4 252347cf233558c5 +matrix_file_backed_after_checkpoint b0e27fc068467c0d 4 ba3c184d008c078c +matrix_file_backed_after_checkpoint b35f19362f833e06 6 bb94575bddc003c7 +matrix_file_backed_after_checkpoint b363754d17f03668 1 9c3c42d1e9ba4697 +matrix_file_backed_after_checkpoint b43458dcbcb0a586 11 2de8e4f332ef223c +matrix_file_backed_after_checkpoint b43d792b4e08d51f 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint b47a69ffd54348c6 2 4e331134b38163d3 +matrix_file_backed_after_checkpoint b8e91e2eb578829b 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint bfcbd5f93dc1f6ed 4 370ca92c2028a723 +matrix_file_backed_after_checkpoint c00b6a4927b721d2 4 605aabaace1424f6 +matrix_file_backed_after_checkpoint c108ca11c27783aa 7 db2e769bf91a7826 +matrix_file_backed_after_checkpoint c375d89e34ce682d 2 439bbdc887a691c3 +matrix_file_backed_after_checkpoint c45f9c1b429670db 27 1811b087545425bd +matrix_file_backed_after_checkpoint d2601434e7cdcbe6 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint d42f6a184e025b35 4 dc466c5b15fe1266 +matrix_file_backed_after_checkpoint d77186092e771793 1 33a9eb46581e0ea8 +matrix_file_backed_after_checkpoint e3db581885060b50 5 96418b81ef6b8a41 +matrix_file_backed_after_checkpoint e7ee02bdaecaa79b 0 cbf29ce484222325 +matrix_file_backed_after_checkpoint ecff4f7b33cdf84f 6 a34094c646a15340 +matrix_file_backed_after_checkpoint f41413af44f114b6 4 5e1bdf768140d943 +matrix_file_backed_after_checkpoint f7316effa93eae8e 4 0254fea3e1791489 +matrix_file_backed_after_checkpoint fa883199fea3c2e2 1 daa3331ac7c5a0aa +matrix_file_backed_after_checkpoint fc1cc3adaf02e2fa 3 8065136d004d6686 +matrix_file_backed_after_checkpoint ff2c471ccb603b48 2 f104c82a0a6de4ef +matrix_in_memory 00477823483b7554 3 4c2f52d052ce97b3 +matrix_in_memory 0484bea3e26563d4 3 a3c5f2126709f82a +matrix_in_memory 07d0175376196443 15 e4c20822528a6d5a +matrix_in_memory 0b2c3ac44daaef34 4 d8ce7375ba623172 +matrix_in_memory 11549146dce73ba9 3 a3c5f2126709f82a +matrix_in_memory 143eb85cfe06f3e7 0 cbf29ce484222325 +matrix_in_memory 1491c265c02611fb 1 63d460ea7091befb +matrix_in_memory 18a9434ce027dcfe 3 9ce2380844f307dc +matrix_in_memory 19adbc631ce883a1 7 e3210b55536ab84f +matrix_in_memory 1a9cdbb59b594562 1 57df332671134404 +matrix_in_memory 1c9cd0e69122598b 1 b6244b779ae251c9 +matrix_in_memory 1ceb712563e7cf63 0 cbf29ce484222325 +matrix_in_memory 240e972aa892ce63 1 33a9eb46581e0ea8 +matrix_in_memory 261e487c0e99f64b 1 273b06efa38b7c60 +matrix_in_memory 274a0a4a7d922adb 1 de8afa6b20debbbb +matrix_in_memory 28759eac5e160295 0 cbf29ce484222325 +matrix_in_memory 2c4e7aa796bb2e08 12 8652239273486cc7 +matrix_in_memory 2cab371a525c5603 2 fbe905e8f46b6635 +matrix_in_memory 2d8809893940098e 3 a6d600034bff9cd7 +matrix_in_memory 308c112d6f7c8a65 4 9ce0a5b3c51ee83f +matrix_in_memory 3501de86105a2bdb 7 9f37f81566ee6f8d +matrix_in_memory 357d6feb2a3b3685 1 44e69951e79ff84b +matrix_in_memory 36eceb4e7e7f7b8c 2 33cf95ab1b35cc47 +matrix_in_memory 3c301b2153a0a4e5 4 9ce0a5b3c51ee83f +matrix_in_memory 3c8c2109fc833026 1 273b06efa38b7c60 +matrix_in_memory 3dcbb4fc05fb108a 5 c4f3ac249a052e6e +matrix_in_memory 408925cd301f652c 2 b147cdaa5210f4cf +matrix_in_memory 416a01c7fa6033e5 1 273b06efa38b7c60 +matrix_in_memory 41ae11a628af7a4e 4 9ce0a5b3c51ee83f +matrix_in_memory 45b088ed29eebe03 3 a3c5f2126709f82a +matrix_in_memory 4721ee50188168cf 2 b4f391c32d579d59 +matrix_in_memory 48222b69d52b0272 0 cbf29ce484222325 +matrix_in_memory 4b2d6471afad05a5 4 8dac24d3b8b7c5c8 +matrix_in_memory 502e40cd058b7305 5 c5683630f0bb3bb2 +matrix_in_memory 559f6caaae7189ef 1 98220bb1f1a150f2 +matrix_in_memory 572caca328c3261a 0 cbf29ce484222325 +matrix_in_memory 5b19dc66e957347f 3 7f659949ae4da37f +matrix_in_memory 5c607991f526957d 3 a3c5f2126709f82a +matrix_in_memory 5d2241144ff4a67d 5 686d818109da153a +matrix_in_memory 5dba272e9d207a1f 0 cbf29ce484222325 +matrix_in_memory 63a6fd8bbca16842 2 45b7d05e7745ac4d +matrix_in_memory 67b1a4f8e01106c5 1 273b06efa38b7c60 +matrix_in_memory 683146a61da8a48d 2 dc4007a6f9aca9aa +matrix_in_memory 6cb6fae58d39e10b 3 efa603293d505094 +matrix_in_memory 6e2017545e54290b 1 2cbd97255d305f28 +matrix_in_memory 75c251a81d53e122 3 a6d600034bff9cd7 +matrix_in_memory 78599138313e81ad 1 9c3c42d1e9ba4697 +matrix_in_memory 78669deef252ba9b 0 cbf29ce484222325 +matrix_in_memory 78b9c6e44538c5d1 7 4dae1b59c277a2df +matrix_in_memory 7d567691fc37c30c 2 70d899cdaf38b5cc +matrix_in_memory 7d5b98a5bba6dc40 1 2fa403f688abc622 +matrix_in_memory 7f52223343c3f859 1 daa3331ac7c5a0aa +matrix_in_memory 80e4cb87eae2a573 0 cbf29ce484222325 +matrix_in_memory 82fa607421fcf8cc 3 38e386a33ee0224f +matrix_in_memory 8980e5a99e50b9b4 3 74fd449f3094dd4d +matrix_in_memory 8a4874ebce66cb0c 3 3e2710468d38d986 +matrix_in_memory 8acfea7aac0fa048 2 3076684b3eef7ee2 +matrix_in_memory 8f65a83fb3ac9dad 2 fbe905e8f46b6635 +matrix_in_memory 92e76c280c9639f4 15 d889b994043c55cc +matrix_in_memory 94d4305918b1b707 7 d809e9f991fa63f4 +matrix_in_memory 9a8d5f940f1dcd8b 4 9ce0a5b3c51ee83f +matrix_in_memory 9b22f09c698421dd 4 9ce0a5b3c51ee83f +matrix_in_memory 9b4ef39ba87b3de0 3 9ce1e05577ff8c12 +matrix_in_memory 9f299995574b8f0c 3 4f4e27ffdaf70d4c +matrix_in_memory a73d169e66e3f429 4 ad3ba947875cd25d +matrix_in_memory ae7f2a307ce19aa5 4 febcfe0c91e3ae15 +matrix_in_memory af47cbb1f81d7c77 3 efa603293d505094 +matrix_in_memory b0e27fc068467c0d 3 00e8e8de19c3febe +matrix_in_memory b35f19362f833e06 4 6b65479c49110ad0 +matrix_in_memory b363754d17f03668 1 9c3c42d1e9ba4697 +matrix_in_memory b43458dcbcb0a586 7 61bd3213e106f81e +matrix_in_memory b43d792b4e08d51f 0 cbf29ce484222325 +matrix_in_memory b47a69ffd54348c6 2 223ee72220043a04 +matrix_in_memory b8e91e2eb578829b 0 cbf29ce484222325 +matrix_in_memory bfcbd5f93dc1f6ed 3 d619fcb06493b4ad +matrix_in_memory c00b6a4927b721d2 3 3e2710468d38d986 +matrix_in_memory c108ca11c27783aa 6 37d1b62002744b56 +matrix_in_memory c375d89e34ce682d 1 daa3331ac7c5a0aa +matrix_in_memory c45f9c1b429670db 24 ddc21faff3dabd19 +matrix_in_memory d2601434e7cdcbe6 0 cbf29ce484222325 +matrix_in_memory d42f6a184e025b35 3 adb97abc58a34fea +matrix_in_memory d77186092e771793 1 33a9eb46581e0ea8 +matrix_in_memory e3db581885060b50 4 d8ce7375ba623172 +matrix_in_memory e7ee02bdaecaa79b 0 cbf29ce484222325 +matrix_in_memory ecff4f7b33cdf84f 5 3ec1aa53d90b362f +matrix_in_memory f41413af44f114b6 3 a3c5f2126709f82a +matrix_in_memory f7316effa93eae8e 3 82bf4f290df25e04 +matrix_in_memory fa883199fea3c2e2 1 daa3331ac7c5a0aa +matrix_in_memory fc1cc3adaf02e2fa 3 8065136d004d6686 +matrix_in_memory ff2c471ccb603b48 2 f104c82a0a6de4ef +nested_or_expression_reads_variable_of_enclosing_branch c3843da97aa7800d 1 2b0a39192b5553d8 +nested_or_expression_reads_variable_of_enclosing_branch e65af95079f38928 1 2b0a39192b5553d8 +nested_or_in_a_branch 03d4242a20f7d43f 3 a3c5f2126709f82a +nested_or_in_a_branch 620e3847574d1997 3 a3c5f2126709f82a +nested_or_in_a_branch 96e7b15645719c94 4 9ce0a5b3c51ee83f +nested_or_in_a_branch e3990d85b5ffca67 3 0757a2b1e2d1342c +nested_or_in_a_branch e82790277afbb824 3 a3c5f2126709f82a +or_branch_expression_binds_from_outer_variable 0bed8fa3f4336b94 4 d5ac9c719e313f9f +or_branch_expression_reads_outer_variable 55fb3d272c32b17a 2 b93f5d19971666e0 +or_branch_expression_reads_outer_variable 58fe1a910c4461a9 1 2b0a39192b5553d8 +or_branch_expression_reads_outer_variable 767a57cec158137e 1 2b0a39192b5553d8 +or_branch_expression_reads_outer_variable_in_rule_body 3cf6c050e43a549a 2 b93f5d19971666e0 +or_branch_expression_reads_outer_variable_in_rule_body 67bf7b647d80ee81 1 2b0a39192b5553d8 +or_branch_expression_reads_outer_variable_in_rule_body a90161af05bd5849 1 2b0a39192b5553d8 +or_join_branch_expression_reads_join_variable 6d5f8c061c46530d 1 2b0a39192b5553d8 +or_join_branch_expression_reads_join_variable 9de15d7cc138cdf7 1 2b0a39192b5553d8 +two_expressions_on_one_variable_must_agree 7de6cbfcef790abe 0 cbf29ce484222325 +two_expressions_on_one_variable_must_agree 97668cd36406f4e7 2 dd65a3c4b543c03a +unify_int_never_equals_float 41b785650872d332 1 74e06170401b952a +unify_int_never_equals_float 4f08e88811923ed0 1 e120643accc89b65 +unify_negative_zero_equals_zero 0395edf0b6b4bc67 1 a6c8dc255a9855d1 diff --git a/tests/answers/recursive_engine_test.txt b/tests/answers/recursive_engine_test.txt new file mode 100644 index 0000000000..921db1b7a1 --- /dev/null +++ b/tests/answers/recursive_engine_test.txt @@ -0,0 +1,30 @@ +derived_metadata_is_nil 06b1426be0ff29b1 6 e57cc1c0a264bc5d +derived_metadata_is_nil 47120147906117f4 0 cbf29ce484222325 +derived_metadata_is_nil 86881ac31d6f320d 20 f3def622d58c73f0 +heads 29d77297f63d7f1f 3 b79c08a89d0e929a +heads f88567c7ea8bf1a2 1 13989b6554a79ab5 +identity_of_derived_facts 685b75c858ef6c39 2 44b36fcfd4923639 +identity_of_derived_facts 7023eb79ad307b70 2 cdb90355370497c4 +identity_of_derived_facts b18afc8b4fa572f9 1 50b595db1ef4fa1c +limit_counts_every_fact_through_a_not_rule 6466c1ef6ab3e0f7 4 40965a9cebe92e51 +linear_and_non_linear_transitive_closure 243f98f92fd1367d 6 c68d71369dd57c51 +linear_and_non_linear_transitive_closure 369983c34fa19a12 6 c68d71369dd57c51 +linear_and_non_linear_transitive_closure 86c21397f7453fc2 6 c68d71369dd57c51 +merged_visibility 2baba6a2e5af3623 15 b4835a74d58f8a78 +merged_visibility 369983c34fa19a12 7 71c6a5878262639a +merged_visibility 57c18e0e4c2d3d59 3 f6d43d68bef86fe1 +merged_visibility 721e7b93fc86d323 2 9cbeeca1086ec598 +merged_visibility e3efbbe0473dd62d 7 7a61a11d6f11939f +mutual_recursion 9cda5ebcd9c29c54 9 8c2e9b53bd94b267 +mutual_recursion d95ced17700218bd 6 10a05c5195b63ea5 +naive_rules 2e390a40fa151a54 7 34869b455460ad69 +naive_rules 5d9cf12dc3fded37 6 c68d71369dd57c51 +naive_rules d6ca6f43b1f8f97e 6 c68d71369dd57c51 +recursion_through_not_and_or_rules 3a326d13d63001a9 4 58beac9384ea91ec +recursion_through_not_and_or_rules 5ca4eefbf8b4cbc2 4 01d9d11d48321f64 +recursion_through_not_and_or_rules d731c02a16c9f590 8 6612d84ba3e275f4 +rule_queries_with_every_operator 34f02ca60532e5da 3 978f45755b371eb2 +rule_queries_with_every_operator 49b5ec3cf738026e 1 adec6a7dba485089 +rule_queries_with_every_operator cd42bae038db53aa 5 20e771339234df65 +rule_queries_with_every_operator d66b4bcc87035447 6 acf2aaffdd99175b +rule_queries_with_every_operator e22a2d83f6d94e0e 6 c68d71369dd57c51 diff --git a/tests/crash_kill_test.rs b/tests/crash_kill_test.rs index 44e9030dfd..0919dace42 100644 --- a/tests/crash_kill_test.rs +++ b/tests/crash_kill_test.rs @@ -21,7 +21,7 @@ //! This also covers the original #308 report (a kill mid-checkpoint left a //! header checksum mismatch): every round must reopen. //! -//! With the `test-oracle` feature a sixth variant makes most transactions +//! With the `test-hooks` feature a sixth variant makes most transactions //! large (#550): they write pages and commit as a checkpoint, with no WAL //! entry, and every fourth one is followed by a large statement that fails //! after writing pages and rolls back. Every third runs as a @@ -185,7 +185,7 @@ enum Variant { /// failing large statement follows every fourth transaction, every third /// is a `WriteTransaction` ([`in_write_tx`]); `checkpoint()` after every /// fifth. - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] Large, } @@ -195,23 +195,23 @@ const VARIANTS: &[Variant] = &[ Variant::WalOnly, Variant::AutoCheckpoint, Variant::NormalSync, - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] Variant::Large, ]; /// The chunk size of the `Large` variant's child. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] const LARGE_CHUNK: usize = 2; /// Fails with API-011 in its second chunk, after the first is written. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] const FAILS_LARGE: &str = r#"(transact [[:e0 :a0 0 {:valid-from "2020-01-01T00:00:00Z"}] [:e1 :a0 0] [:e2 :a0 0] [:e0 :a0 0 {:valid-from "2021-01-01T00:00:00Z"}]])"#; /// Run `stmt` as a `WriteTransaction` with the same result: the opposite /// statement over the same triples, [`FAILS_LARGE`] (rejected, the /// transaction stays usable), then `stmt`, which wins every triple. -#[cfg(feature = "test-oracle")] +#[cfg(feature = "test-hooks")] fn in_write_tx(db: &Minigraf, stmt: &str) { let opposite = match stmt.strip_prefix("(transact ") { Some(rest) => format!("(retract {rest}"), @@ -235,7 +235,7 @@ impl Variant { Variant::AutoCheckpoint => opts.wal_checkpoint_threshold(2), Variant::NormalSync => opts.synchronous(SyncMode::Normal), Variant::CheckpointEach | Variant::CheckpointEvery3 => opts, - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] Variant::Large => opts, } } @@ -245,7 +245,7 @@ impl Variant { Variant::CheckpointEach => true, Variant::CheckpointEvery3 | Variant::NormalSync => k % 3 == 0, Variant::WalOnly | Variant::AutoCheckpoint => false, - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] Variant::Large => k % 5 == 0, } } @@ -496,26 +496,26 @@ fn crash_kill_child_entrypoint() { .expect("child opens log"); let db = Minigraf::open_with_options(&db_path, variant.options()).expect("child opens db"); - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] let large = matches!(variant, Variant::Large); - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] let _chunk = large.then(|| minigraf::__tx_chunk_facts(Some(LARGE_CHUNK))); let mut rng = Rng::new(seed); let mut live = BTreeSet::new(); for k in 1.. { let (stmt, next) = next_tx(&mut rng, &live); - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] if large && k % 3 == 0 { in_write_tx(&db, &stmt); } else { db.execute(&stmt).expect("child transaction"); } - #[cfg(not(feature = "test-oracle"))] + #[cfg(not(feature = "test-hooks"))] db.execute(&stmt).expect("child transaction"); log.write_all(format!("{k}\n").as_bytes()) .expect("child logs transaction"); live = next; - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] if large && k % 4 == 0 { let e = db .execute(FAILS_LARGE) diff --git a/tests/disjunction_test.rs b/tests/disjunction_test.rs index 84deeeeb29..1b37340b44 100644 --- a/tests/disjunction_test.rs +++ b/tests/disjunction_test.rs @@ -346,7 +346,7 @@ fn test_or_with_rule_invocation_positive_dep() { /// The bug: HashMap::iter() returns entries in non-deterministic order. Two bindings /// that are logically identical can produce different Vec orderings, causing /// BTreeSet::insert to treat them as distinct and failing to deduplicate. -/// The fix: sort the key before inserting into BTreeSet (apply_or_clauses lines ~1205, ~1247). +/// The fix sorted the key before inserting into the BTreeSet. #[test] fn test_or_does_not_return_duplicate_bindings() { let db = db(); diff --git a/tests/error_codes_qry_test.rs b/tests/error_codes_qry_test.rs index de98e45765..3022f78d73 100644 --- a/tests/error_codes_qry_test.rs +++ b/tests/error_codes_qry_test.rs @@ -51,8 +51,8 @@ fn query_unknown_predicate_returns_qry_007() { #[test] fn query_with_rules_unknown_predicate_returns_qry_007() { - // Same check, but through the rules-aware execute_query_with_rules path - // (a distinct call site from the plain execute_query path above). + // Same check, but in a rule query (a distinct call site from the plain + // query above). let db = Minigraf::in_memory().unwrap(); db.execute(r#"(transact [[:a :x "hello"]])"#).unwrap(); db.execute(r#"(rule [(p ?e) [?e :x ?v]])"#).unwrap(); @@ -65,8 +65,8 @@ fn query_with_rules_unknown_predicate_returns_qry_007() { // ─── Limit/recursion-error family: no documented QRY code (INT-020) ─────── /// A recursive rule with an artificially tiny per-query `max_derived_facts` -/// hits `RecursiveEvaluator::evaluate_recursive_rules`'s "Max derived facts -/// exceeded" branch (src/query/datalog/evaluator.rs). No +/// hits the engine's "Max derived facts exceeded" limit +/// (`derived_facts_exceeded`, src/query/datalog/evaluator.rs). No /// QRY-0xx code is documented for this in ERROR_REFERENCE.md — see the /// module doc comment above for why. #277 step 6 assigned this shared /// "limit exceeded" family the INT-020 code. diff --git a/tests/integrity_test.rs b/tests/integrity_test.rs index 0ec9927999..72a4cf999b 100644 --- a/tests/integrity_test.rs +++ b/tests/integrity_test.rs @@ -130,15 +130,7 @@ fn damaged_leaves_are_reported_and_index_damage_is_repaired() { /// Every internal node whose rightmost child is redirected to itself, in turn: /// a scan comes back to leaves it already read. Each query fails with INT-049 /// or answers; it never resumes from a key it saw and runs forever (#597). -/// -/// Not run with the `test-oracle` feature: on a damaged file the engine and -/// the executor read different pages (the executor also looks up each fact's -/// tx timestamp), so one can fail where the other answers. #[test] -#[cfg_attr( - feature = "test-oracle", - ignore = "plans read different pages of a damaged file" -)] fn internal_node_pointing_at_itself_fails_the_scan_instead_of_looping() { const PAGE_TYPE_INTERNAL: u8 = 0x62; const RIGHTMOST_CHILD: usize = 24; diff --git a/tests/large_transaction_acceptance_test.rs b/tests/large_transaction_acceptance_test.rs index 336f94c369..67005e0d68 100644 --- a/tests/large_transaction_acceptance_test.rs +++ b/tests/large_transaction_acceptance_test.rs @@ -5,14 +5,14 @@ //! Ignored by default; `.github/workflows/smoke.yml` runs it nightly: //! //! ```text -//! cargo test --profile bench --features test-oracle --test large_transaction_acceptance_test -- --ignored --nocapture +//! cargo test --profile bench --features test-hooks --test large_transaction_acceptance_test -- --ignored --nocapture //! ``` //! //! The count of facts held comes from a high-water mark the statement reader -//! keeps (`minigraf::__statement_facts_high_water`, `test-oracle` only). Peak +//! keeps (`minigraf::__statement_facts_high_water`, `test-hooks` only). Peak //! RSS comes from `/proc/self/status` (Linux only) and is printed, not //! checked: the bound is on facts, and the input string alone is about 25 MB. -#![cfg(all(feature = "test-oracle", not(target_arch = "wasm32")))] +#![cfg(all(feature = "test-hooks", not(target_arch = "wasm32")))] use minigraf::{Minigraf, QueryResult}; diff --git a/tests/memory_limit_acceptance_test.rs b/tests/memory_limit_acceptance_test.rs index 2e0a551030..c35bee5305 100644 --- a/tests/memory_limit_acceptance_test.rs +++ b/tests/memory_limit_acceptance_test.rs @@ -11,8 +11,7 @@ //! ``` //! //! Peak RSS comes from `/proc/self/status` (Linux only): the high-water mark -//! is reset just before the query. Without the `test-oracle` feature, as the -//! executor would itself run out of memory on the cartesian shape. +//! is reset just before the query. // // File-backed (Minigraf::open, tempfile): native only, like the other file tests. #![cfg(not(target_arch = "wasm32"))] diff --git a/tests/model_based_test.rs b/tests/model_based_test.rs index fc8778a864..b3fa571458 100644 --- a/tests/model_based_test.rs +++ b/tests/model_based_test.rs @@ -19,15 +19,15 @@ mod reference_model; use proptest::prelude::*; use reference_model::*; -/// With `test-oracle`, every query also runs without clause reordering and +/// With `test-hooks`, every query also runs without clause reordering and /// must give the same rows (#596). fn source_order() -> Option { - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] return Some(|db, q| { let _off = minigraf::__reorder(false); db.execute(q) }); - #[cfg(not(feature = "test-oracle"))] + #[cfg(not(feature = "test-hooks"))] None } @@ -111,11 +111,11 @@ proptest! { #![proptest_config(ProptestConfig::with_cases(cases()))] /// Every read after every step matches the reference model. With - /// `test-oracle`, statements of more than two facts are large (#550): + /// `test-hooks`, statements of more than two facts are large (#550): /// written in chunks and committed as a checkpoint. #[test] fn file_backed_db_matches_model(steps in arb_steps()) { - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] let _chunk = minigraf::__tx_chunk_facts(Some(2)); run_with(&steps, Checks::All, source_order())?; } diff --git a/tests/multi_value_test.rs b/tests/multi_value_test.rs index 0bbb0acba9..8dbff76974 100644 --- a/tests/multi_value_test.rs +++ b/tests/multi_value_test.rs @@ -340,8 +340,8 @@ fn v7_multivalue_fixture_migrates_and_reads_correctly() { /// in one transaction they are API-011 (#435); written in two, the second /// replaces the first, so a `:valid-at` query inside the second window returns /// exactly one row on every selective path, the first window is visible only -/// `:as-of` tx 1, and `:any-valid-time` sees one stint. A full scan does not -/// go through `selective_fact_fetch` and serves as the control. +/// `:as-of` tx 1, and `:any-valid-time` sees one stint. A full scan serves as +/// the control. #[test] fn multi_value_time_stints_visible_at_correct_valid_time_on_every_path() { let db = Minigraf::in_memory().unwrap(); diff --git a/tests/not_join_test.rs b/tests/not_join_test.rs index 994fa905c5..e23b4268e4 100644 --- a/tests/not_join_test.rs +++ b/tests/not_join_test.rs @@ -144,7 +144,7 @@ fn test_not_join_in_rule_body() { /// 5. not-join in a two-stage rule chain. /// /// LIMITATION: When rule B positively invokes rule A (both in the same stratum) -/// and rule A contains a not-join, the StratifiedEvaluator processes all mixed +/// and rule A contains a not-join, the old executor processed all mixed /// rules within a stratum in a single pass in declaration order. Because /// `approved` is declared before `eligible`, its positive-pattern match for /// `[?x :eligible ?_rule_value]` finds no facts yet, producing an empty result. diff --git a/tests/plan_independence_test.rs b/tests/plan_independence_test.rs index 9b9c627950..92e6f3a397 100644 --- a/tests/plan_independence_test.rs +++ b/tests/plan_independence_test.rs @@ -5,11 +5,13 @@ //! `Minigraf::query` cursor, with clause reordering on and off //! (`minigraf::__reorder`), and with the engine's `not` bodies chosen, //! forced hashed and forced correlated (`minigraf::__subplans`, #546); all -//! twelve answers must be the same bag. With -//! the `test-oracle` feature, every query the streaming engine runs is also -//! run by the executor and must agree, so each run compares the two as well. +//! twelve answers must be the same bag. The +//! answer must also be the one recorded while the executor still checked it +//! (`tests/answers/`, #551). //! Per-fact pseudo-attributes read the source the parser names (#594). -#![cfg(all(feature = "test-oracle", not(target_arch = "wasm32")))] +#![cfg(all(feature = "test-hooks", not(target_arch = "wasm32")))] + +mod answers; use minigraf::{Minigraf, QueryResult, Value}; @@ -53,7 +55,13 @@ fn check(db: &Minigraf, q: &str) -> Result>, String> { use minigraf::Subplans; let on = { let _g = minigraf::__reorder(true); - executed(db, q) + match db.execute(q).expect("query") { + QueryResult::QueryResults { results, .. } => { + answers::check("plan_independence_test", q, &results); + bag(&results) + } + _ => panic!("expected QueryResults"), + } }; for mode in [Subplans::Choose, Subplans::Hash, Subplans::Correlated] { let _m = minigraf::__subplans(mode); diff --git a/tests/property_test.rs b/tests/property_test.rs index b33fbe9a92..68055146a1 100644 --- a/tests/property_test.rs +++ b/tests/property_test.rs @@ -983,17 +983,17 @@ fn ctx() -> Ctx { } } -/// With `test-oracle`, every query also runs without clause reordering +/// With `test-hooks`, every query also runs without clause reordering /// (#596) and with `not` bodies hashed where the engine would probe them /// (#546), and must give the same rows. fn source_order() -> Option { - #[cfg(feature = "test-oracle")] + #[cfg(feature = "test-hooks")] return Some(|db, q| { let _off = minigraf::__reorder(false); let _hash = minigraf::__subplans(minigraf::Subplans::Hash); db.execute(q) }); - #[cfg(not(feature = "test-oracle"))] + #[cfg(not(feature = "test-hooks"))] None } diff --git a/tests/recursive_engine_test.rs b/tests/recursive_engine_test.rs index ce977eb4ca..b99cf572be 100644 --- a/tests/recursive_engine_test.rs +++ b/tests/recursive_engine_test.rs @@ -1,11 +1,13 @@ //! Rule queries on the streaming engine (#548 spec §7). Each query runs on //! an in-memory database, on a file with its facts pending, and on the same -//! file after a checkpoint; under the `test-oracle` feature the executor -//! runs it too and must agree. +//! file after a checkpoint, and its answer must be the one recorded while the +//! executor still checked it (`tests/answers/`, #551). // // File-backed (Minigraf::open, tempfile): native only, like the other file tests. #![cfg(not(target_arch = "wasm32"))] +mod answers; + use minigraf::{Minigraf, QueryResult, Value}; /// The databases a test reads: in memory, a file, and the file again once @@ -43,6 +45,7 @@ impl Dbs { all.push(sorted(rows(&self.file, query))); assert!(all[0] == all[1], "in memory and pending agree"); assert!(all[1] == all[2], "pending and committed agree"); + answers::check("recursive_engine_test", query, &all[0]); all.swap_remove(0) } @@ -318,6 +321,28 @@ fn limits() { ); } +/// The derived-fact limit counts every fact of a stratum that recurses +/// through a `not` rule (#633): n0, m0, n1, m1, n2, m2, n3 are seven. +#[test] +fn limit_counts_every_fact_through_a_not_rule() { + let db = Dbs::new(&[ + "(transact [[:c :start 0]])", + "(rule [(n ?x ?v) [?x :start ?v]])", + "(rule [(n ?x ?w) (m ?x ?v) [(+ ?v 1) ?w]])", + "(rule [(m ?x ?v) (n ?x ?v) [(< ?v 3)] (not [?x :stop true])])", + ]); + assert!( + db.rows("(query [:find ?v :where (n ?x ?v) :max-derived-facts 7])") + == (0..4).map(|v| vec![Value::Integer(v)]).collect::>(), + "seven facts fit: n0 to n3" + ); + assert_eq!( + db.err("(query [:find ?v :where (n ?x ?v) :max-derived-facts 6])"), + "INT-020", + "six do not" + ); +} + #[test] fn rule_queries_with_every_operator() { let db = Dbs::new(&[ diff --git a/tests/retraction_test.rs b/tests/retraction_test.rs index 55640051b4..d003408792 100644 --- a/tests/retraction_test.rs +++ b/tests/retraction_test.rs @@ -1,7 +1,6 @@ //! Integration tests for retraction semantics in Datalog queries. //! -//! These tests verify that `filter_facts_for_query` computes the net-asserted -//! view per (entity, attribute, value) triple, correctly hiding retracted facts. +//! These tests verify that queries see the net-asserted view per (entity, attribute, value) triple, correctly hiding retracted facts. use minigraf::Minigraf; @@ -124,7 +123,7 @@ fn test_retraction_rule_as_of_before_sees_fact() { // ── Test 7: Atomic retract+transact in WriteTransaction (issue #285) ───────── // When both a retraction and a new assertion share the same tx_count (because they -// are committed together), selective_fact_fetch must not drop the assertion due to +// are committed together), a query must not drop the assertion due to // dedup on (entity, attribute, tx_count). #[test] diff --git a/tests/temporal_metadata_test.rs b/tests/temporal_metadata_test.rs index a73794a035..efa4880fa0 100644 --- a/tests/temporal_metadata_test.rs +++ b/tests/temporal_metadata_test.rs @@ -404,7 +404,6 @@ fn valid_at_succeeds_without_any_valid_time() { // ─── Coverage Gap Tests (Phase 7.6) ───────────────────────────────────────── /// Gap 1: Hard error in rules-based query path — per-fact pseudo-attr without :any-valid-time. -/// Exercises executor.rs lines 341–353 (execute_query_with_rules guard). #[test] fn runtime_error_rules_per_fact_pseudo_without_any_valid_time() { let db = db(); @@ -426,8 +425,7 @@ fn runtime_error_rules_per_fact_pseudo_without_any_valid_time() { ); } -/// Gap 2: or-clause query with no :valid-at exercises the evaluate_branch None path. -/// Exercises executor.rs lines 930–931 (branch_valid_at_value for None valid_at). +/// Gap 2: or-clause query with no :valid-at. #[test] fn or_clause_no_valid_at_executes() { let db = db(); @@ -507,7 +505,7 @@ fn pseudo_attr_constant_filter_no_match() { } /// Gap 5: not-join body containing a pseudo-attr pattern. -/// Exercises a per-fact pseudo-attribute in a seeded `not-join` body (`evaluate_not_join`). +/// Exercises a per-fact pseudo-attribute in a seeded `not-join` body. #[test] fn not_join_body_with_pseudo_attr() { let db = db();