Implement GreaterThanOrEqual and LessThanOrEqual to handle boundary cases in Chain.

Add `ComparatorEnum::NaturalNoneHigher`, which matches Postgres's `DESC NULLS FIRST` behavior in `TopDocs::order_by`.

Expands comments on `Comparator` implementations to ensure that behavior for `None` is explicit.

Upstream as https://github.com/quickwit-oss/tantivy/pull/2780

.claude/skills/rationalize-deps/SKILL.md

@@ -1,125 +0,0 @@
----
-name: rationalize-deps
-description: Analyze Cargo.toml dependencies and attempt to remove unused features to reduce compile times and binary size
----
-
-# Rationalize Dependencies
-
-This skill analyzes Cargo.toml dependencies to identify and remove unused features.
-
-## Overview
-
-Many crates enable features by default that may not be needed. This skill:
-1. Identifies dependencies with default features enabled
-2. Tests if `default-features = false` works
-3. Identifies which specific features are actually needed
-4. Verifies compilation after changes
-
-## Step 1: Identify the target
-
-Ask the user which crate(s) to analyze:
-- A specific crate name (e.g., "tokio", "serde")
-- A specific workspace member (e.g., "quickwit-search")
-- "all" to scan the entire workspace
-
-## Step 2: Analyze current dependencies
-
-For the workspace Cargo.toml (`quickwit/Cargo.toml`), list dependencies that:
-- Do NOT have `default-features = false`
-- Have default features that might be unnecessary
-
-Run: `cargo tree -p <crate> -f "{p} {f}" --edges features` to see what features are actually used.
-
-## Step 3: For each candidate dependency
-
-### 3a: Check the crate's default features
-
-Look up the crate on crates.io or check its Cargo.toml to understand:
-- What features are enabled by default
-- What each feature provides
-
-Use: `cargo metadata --format-version=1 | jq '.packages[] | select(.name == "<crate>") | .features'`
-
-### 3b: Try disabling default features
-
-Modify the dependency in `quickwit/Cargo.toml`:
-
-From:
-```toml
-some-crate = { version = "1.0" }
-```
-
-To:
-```toml
-some-crate = { version = "1.0", default-features = false }
-```
-
-### 3c: Run cargo check
-
-Run: `cargo check --workspace` (or target specific packages for faster feedback)
-
-If compilation fails:
-1. Read the error messages to identify which features are needed
-2. Add only the required features explicitly:
-   ```toml
-   some-crate = { version = "1.0", default-features = false, features = ["needed-feature"] }
-   ```
-3. Re-run cargo check
-
-### 3d: Binary search for minimal features
-
-If there are many default features, use binary search:
-1. Start with no features
-2. If it fails, add half the default features
-3. Continue until you find the minimal set
-
-## Step 4: Document findings
-
-For each dependency analyzed, report:
-- Original configuration
-- New configuration (if changed)
-- Features that were removed
-- Any features that are required
-
-## Step 5: Verify full build
-
-After all changes, run:
-```bash
-cargo check --workspace --all-targets
-cargo test --workspace --no-run
-```
-
-## Common Patterns
-
-### Serde
-Often only needs `derive`:
-```toml
-serde = { version = "1.0", default-features = false, features = ["derive", "std"] }
-```
-
-### Tokio
-Identify which runtime features are actually used:
-```toml
-tokio = { version = "1.0", default-features = false, features = ["rt-multi-thread", "macros", "sync"] }
-```
-
-### Reqwest
-Often doesn't need all TLS backends:
-```toml
-reqwest = { version = "0.11", default-features = false, features = ["rustls-tls", "json"] }
-```
-
-## Rollback
-
-If changes cause issues:
-```bash
-git checkout quickwit/Cargo.toml
-cargo check --workspace
-```
-
-## Tips
-
-- Start with large crates that have many default features (tokio, reqwest, hyper)
-- Use `cargo bloat --crates` to identify large dependencies
-- Check `cargo tree -d` for duplicate dependencies that might indicate feature conflicts
-- Some features are needed only for tests - consider using `[dev-dependencies]` features

.claude/skills/simple-pr/SKILL.md

@@ -1,60 +0,0 @@
----
-name: simple-pr
-description: Create a simple PR from staged changes with an auto-generated commit message
-disable-model-invocation: true
----
-
-# Simple PR
-
-Follow these steps to create a simple PR from staged changes:
-
-## Step 1: Check workspace state
-
-Run: `git status`
-
-Verify that all changes have been staged (no unstaged changes). If there are unstaged changes, abort and ask the user to stage their changes first with `git add`.
-
-Also verify that we are on the `main` branch. If not, abort and ask the user to switch to main first.
-
-## Step 2: Ensure main is up to date
-
-Run: `git pull origin main`
-
-This ensures we're working from the latest code.
-
-## Step 3: Review staged changes
-
-Run: `git diff --cached`
-
-Review the staged changes to understand what the PR will contain.
-
-## Step 4: Generate commit message
-
-Based on the staged changes, generate a concise commit message (1-2 sentences) that describes the "why" rather than the "what".
-
-Display the proposed commit message to the user and ask for confirmation before proceeding.
-
-## Step 5: Create a new branch
-
-Get the git username: `git config user.name | tr ' ' '-' | tr '[:upper:]' '[:lower:]'`
-
-Create a short, descriptive branch name based on the changes (e.g., `fix-typo-in-readme`, `add-retry-logic`, `update-deps`).
-
-Create and checkout the branch: `git checkout -b {username}/{short-descriptive-name}`
-
-## Step 6: Commit changes
-
-Commit with the message from step 3:
-```
-git commit -m "{commit-message}"
-```
-
-## Step 7: Push and open a PR
-
-Push the branch and open a PR:
-```
-git push -u origin {branch-name}
-gh pr create --title "{commit-message-title}" --body "{longer-description-if-needed}"
-```
-
-Report the PR URL to the user when complete.

.claude/skills/update-changelog/SKILL.md

@@ -1,87 +0,0 @@
----
-name: update-changelog
-description: Update CHANGELOG.md with merged PRs since the last changelog update, categorized by type
----
-
-# Update Changelog
-
-This skill updates CHANGELOG.md with merged PRs that aren't already listed.
-
-## Step 1: Determine the changelog scope
-
-Read `CHANGELOG.md` to identify the current unreleased version section at the top (e.g., `Tantivy 0.26 (Unreleased)`).
-
-Collect all PR numbers already mentioned in the unreleased section by extracting `#NNNN` references.
-
-## Step 2: Find merged PRs not yet in the changelog
-
-Use `gh` to list recently merged PRs from the upstream repo:
-
-```bash
-gh pr list --repo quickwit-oss/tantivy --state merged --limit 100 --json number,title,author,labels,mergedAt
-```
-
-Filter out any PRs whose number already appears in the unreleased section of the changelog.
-
-## Step 3: Consolidate related PRs
-
-Before categorizing, group PRs that belong to the same logical change. This is critical for producing a clean changelog. Use PR descriptions, titles, cross-references, and the files touched to identify relationships.
-
-**Merge follow-up PRs into the original:**
-- If a PR is a bugfix, refinement, or follow-up to another PR in the same unreleased cycle, combine them into a single changelog entry with multiple `[#N](url)` links.
-- Also consolidate PRs that touch the same feature area even if not explicitly linked — e.g., a PR fixing an edge case in a new API should be folded into the entry for the PR that introduced that API.
-
-**Filter out bugfixes on unreleased features:**
-- If a bugfix PR fixes something introduced by another PR in the **same unreleased version**, it must NOT appear as a separate Bugfixes entry. Instead, silently fold it into the original feature/improvement entry. The changelog should describe the final shipped state, not the development history.
-- To detect this: check if the bugfix PR references or reverts changes from another PR in the same release cycle, or if it touches code that was newly added (not present in the previous release).
-
-## Step 4: Review the actual code diff
-
-**Do not rely on PR titles or descriptions alone.** For every candidate PR, run `gh pr diff <number> --repo quickwit-oss/tantivy` and read the actual changes. PR titles are often misleading — the diff is the source of truth.
-
-**What to look for in the diff:**
-- Does it change observable behavior, public API surface, or performance characteristics?
-- Is the change something a user of the library would notice or need to know about?
-- Could the change break existing code (API changes, removed features)?
-
-**Skip PRs where the diff reveals the change is not meaningful enough for the changelog** — e.g., cosmetic renames, trivial visibility tweaks, test-only changes, etc.
-
-## Step 5: Categorize each PR group
-
-For each PR (or consolidated group) that survived the diff review, determine its category:
-
-- **Bugfixes** — fixes to behavior that existed in the **previous release**. NOT fixes to features introduced in this release cycle.
-- **Features/Improvements** — new features, API additions, new options, improvements that change user-facing behavior or add new capabilities.
-- **Performance** — optimizations, speed improvements, memory reductions. **If a PR adds new API whose primary purpose is enabling a performance optimization, categorize it as Performance, not Features.** The deciding question is: does a user benefit from this because of new functionality, or because things got faster/leaner? For example, a new trait method that exists solely to enable cheaper intersection ordering is Performance, not a Feature.
-
-If a PR doesn't clearly fit any category (e.g., CI-only changes, internal refactors with no user-facing impact, dependency bumps with no behavior change), skip it — not everything belongs in the changelog.
-
-When unclear, use your best judgment or ask the user.
-
-## Step 6: Format entries
-
-Each entry must follow this exact format:
-
-```
-- Description [#NUMBER](https://github.com/quickwit-oss/tantivy/pull/NUMBER)(@author)
-```
-
-Rules:
-- The description should be concise and describe the user-facing change (not the implementation). Describe the final shipped state, not the incremental development steps.
-- Use sub-categories with bold headers when multiple entries relate to the same area (e.g., `- **Aggregation**` with indented entries beneath). Follow the existing grouping style in the changelog.
-- Author is the GitHub username from the PR, prefixed with `@`. For consolidated entries, include all contributing authors.
-- For consolidated PRs, list all PR links in a single entry: `[#100](url) [#110](url)` (see existing entries for examples).
-
-## Step 7: Present changes to the user
-
-Show the user the proposed changelog entries grouped by category **before** editing the file. Ask for confirmation or adjustments.
-
-## Step 8: Update CHANGELOG.md
-
-Insert the new entries into the appropriate sections of the unreleased version block. If a section doesn't exist yet, create it following the order: Bugfixes, Features/Improvements, Performance.
-
-Append new entries at the end of each section (before the next section header or version header).
-
-## Step 9: Verify
-
-Read back the updated unreleased section and display it to the user for final review.

.github/dependabot.yml

@@ -6,8 +6,6 @@ updates:
     interval: daily
     time: "20:00"
   open-pull-requests-limit: 10
-  cooldown:
-    default-days: 2
 
 - package-ecosystem: "github-actions"
   directory: "/"
@@ -15,5 +13,3 @@ updates:
     interval: daily
     time: "20:00"
   open-pull-requests-limit: 10
-  cooldown:
-    default-days: 2

.github/workflows/coverage.yml

@@ -1,36 +0,0 @@
-name: Coverage
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  contents: read
-
-# Ensures that we cancel running jobs for the same PR / same workflow.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  coverage:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - name: Install Rust
-        run: rustup toolchain install nightly-2025-12-01 --profile minimal --component llvm-tools-preview
-      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
-      - uses: taiki-e/install-action@e4b3a0453201addddc06d3a72db90326aad87084 # cargo-llvm-cov
-      - name: Generate code coverage
-        run: cargo +nightly-2025-12-01 llvm-cov --all-features --workspace --doctests --lcov --output-path lcov.info
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
-        continue-on-error: true
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }} # not required for public repos
-          files: lcov.info
-          fail_ci_if_error: true

.github/workflows/long_running.yml

@@ -8,9 +8,6 @@ env:
   CARGO_TERM_COLOR: always
   NUM_FUNCTIONAL_TEST_ITERATIONS: 20000
 
-permissions:
-  contents: read
-
 # Ensures that we cancel running jobs for the same PR / same workflow.
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -21,13 +18,10 @@ jobs:
 
     runs-on: ubuntu-latest
 
-    permissions:
-      contents: read
-
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: actions/checkout@v4
     - name: Install stable
-      uses: actions-rs/toolchain@16499b5e05bf2e26879000db0c1d13f7e13fa3af # v1.0.7
+      uses: actions-rs/toolchain@v1
       with:
           toolchain: stable
           profile: minimal

.github/workflows/scorecard.yml

@@ -1,49 +0,0 @@
-name: OpenSSF Scorecard
-
-on:
-  schedule:
-    - cron: '0 0 * * 0'
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Needed to publish results
-      id-token: write
-
-    steps:
-      - name: 'Checkout code'
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-
-      - name: 'Run analysis'
-        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_results: true
-
-      # Upload the results as artifacts.
-      - name: 'Upload artifact'
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      # Upload the results to GitHub's code scanning dashboard.
-      - name: 'Upload to code-scanning'
-        uses: github/codeql-action/upload-sarif@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
-        with:
-          sarif_file: results.sarif

.github/workflows/test.yml

@@ -9,9 +9,6 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
-permissions:
-  contents: read
-
 # Ensures that we cancel running jobs for the same PR / same workflow.
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -22,39 +19,35 @@ jobs:
 
     runs-on: ubuntu-latest
 
-    permissions:
-      contents: read
-      checks: write
-
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: actions/checkout@v4
 
     - name: Install nightly
-      uses: actions-rs/toolchain@16499b5e05bf2e26879000db0c1d13f7e13fa3af # v1.0.7
+      uses: actions-rs/toolchain@v1
       with:
             toolchain: nightly
             profile: minimal
             components: rustfmt
     - name: Install stable
-      uses: actions-rs/toolchain@16499b5e05bf2e26879000db0c1d13f7e13fa3af # v1.0.7
+      uses: actions-rs/toolchain@v1
       with:
             toolchain: stable
             profile: minimal
             components: clippy
 
-    - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+    - uses: Swatinem/rust-cache@v2
 
     - name: Check Formatting
       run: cargo +nightly fmt --all -- --check
-
+    
     - name: Check Stable Compilation
       run: cargo build --all-features
 
-
+    
     - name: Check Bench Compilation
       run: cargo +nightly bench --no-run --profile=dev --all-features
 
-    - uses: actions-rs/clippy-check@b5b5f21f4797c02da247df37026fcd0a5024aa4d # v1.0.7
+    - uses: actions-rs/clippy-check@v1
       with:
         toolchain: stable
         token: ${{ secrets.GITHUB_TOKEN }}
@@ -64,47 +57,32 @@ jobs:
 
     runs-on: ubuntu-latest
 
-    permissions:
-      contents: read
-
     strategy:
       matrix:
-        features:
-          - { label: "all", flags: "mmap,stopwords,lz4-compression,zstd-compression,failpoints,stemmer" }
-          - { label: "quickwit", flags: "mmap,quickwit,failpoints" }
-          - { label: "none", flags: "" }
+        features: [
+            { label: "all", flags: "mmap,stopwords,lz4-compression,zstd-compression,failpoints" },
+            { label: "quickwit", flags: "mmap,quickwit,failpoints" }
+        ]
 
     name: test-${{ matrix.features.label}}
 
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: actions/checkout@v4
 
     - name: Install stable
-      uses: actions-rs/toolchain@16499b5e05bf2e26879000db0c1d13f7e13fa3af # v1.0.7
+      uses: actions-rs/toolchain@v1
       with:
             toolchain: stable
             profile: minimal
             override: true
 
-    - uses: taiki-e/install-action@56cc9adf3a3e2c23eafb56e8acaf9d0373cb845a # nextest
-    - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+    - uses: taiki-e/install-action@v2
+      with:
+        tool: 'nextest'
+    - uses: Swatinem/rust-cache@v2
 
     - name: Run tests
-      run: |
-        # if matrix.feature.flags is empty then run on --lib to avoid compiling examples
-        # (as most of them rely on mmap) otherwise run all
-        if [ -z "${{ matrix.features.flags }}" ]; then
-          cargo +stable nextest run --lib --no-default-features --verbose --workspace
-        else
-          cargo +stable nextest run --features ${{ matrix.features.flags }} --no-default-features --verbose --workspace
-        fi
+      run: cargo +stable nextest run --features ${{ matrix.features.flags }} --verbose --workspace
 
     - name: Run doctests
-      run: |
-        # if matrix.feature.flags is empty then run on --lib to avoid compiling examples
-        # (as most of them rely on mmap) otherwise run all
-        if [ -z "${{ matrix.features.flags }}" ]; then
-          echo "no doctest for no feature flag"
-        else
-          cargo +stable test --doc --features ${{ matrix.features.flags }} --verbose --workspace
-        fi
+      run: cargo +stable test --doc --features ${{ matrix.features.flags }} --verbose --workspace

.gitignore

@@ -6,7 +6,6 @@ target
 target/debug
 .vscode
 target/release
-Cargo.lock
 benchmark
 .DS_Store
 *.bk
@@ -15,3 +14,7 @@ trace.dat
 cargo-timing*
 control
 variable
+
+# for `sample record -p`
+profile.json
+profile.json.gz

CHANGELOG.md

@@ -1,58 +1,3 @@
-Tantivy 0.26.1
-================================
-
-## Performance
-- Fix quadratic runtime in nested term and composite aggregations: memory accounting scanned all parent buckets on every collect instead of just the current parent (@PSeitz @fulmicoton)
-
-Tantivy 0.26 (Unreleased)
-================================
-
-## Bugfixes
-- Align float query coercion during search with the columnar coercion rules [#2692](https://github.com/quickwit-oss/tantivy/pull/2692)(@fulmicoton)
-- Fix lenient elastic range queries with trailing closing parentheses [#2816](https://github.com/quickwit-oss/tantivy/pull/2816)(@evance-br)
-- Fix intersection `seek()` advancing below current doc id [#2812](https://github.com/quickwit-oss/tantivy/pull/2812)(@fulmicoton)
-- Fix phrase query prefixed with `*` [#2751](https://github.com/quickwit-oss/tantivy/pull/2751)(@Darkheir)
-- Fix `vint` buffer overflow during index creation [#2778](https://github.com/quickwit-oss/tantivy/pull/2778)(@rebasedming)
-- Fix integer overflow in `ExpUnrolledLinkedList` for large datasets [#2735](https://github.com/quickwit-oss/tantivy/pull/2735)(@mdashti)
-- Fix integer overflow in segment sorting and merge policy truncation [#2846](https://github.com/quickwit-oss/tantivy/pull/2846)(@anaslimem)
-- Fix merging of intermediate aggregation results [#2719](https://github.com/quickwit-oss/tantivy/pull/2719)(@PSeitz)
-- Fix deduplicate doc counts in term aggregation for multi-valued fields [#2854](https://github.com/quickwit-oss/tantivy/pull/2854)(@nuri-yoo)
-
-## Features/Improvements
-- **Aggregation**
-    - Add filter aggregation [#2711](https://github.com/quickwit-oss/tantivy/pull/2711)(@mdashti)
-    - Add include/exclude filtering for term aggregations [#2717](https://github.com/quickwit-oss/tantivy/pull/2717)(@PSeitz)
-    - Add public accessors for intermediate aggregation results [#2829](https://github.com/quickwit-oss/tantivy/pull/2829)(@congx4)
-    - Replace HyperLogLog++ with Apache DataSketches HLL for cardinality aggregation [#2837](https://github.com/quickwit-oss/tantivy/pull/2837) [#2842](https://github.com/quickwit-oss/tantivy/pull/2842)(@congx4)
-    - Add composite aggregation [#2856](https://github.com/quickwit-oss/tantivy/pull/2856)(@fulmicoton)
-- **Fast Fields**
-    - Add fast field fallback for `TermQuery` when the field is not indexed [#2693](https://github.com/quickwit-oss/tantivy/pull/2693)(@PSeitz-dd)
-    - Add fast field support for `Bytes` values [#2830](https://github.com/quickwit-oss/tantivy/pull/2830)(@mdashti)
-- **Query Parser**
-    - Add support for regexes in the query grammar [#2677](https://github.com/quickwit-oss/tantivy/pull/2677) [#2818](https://github.com/quickwit-oss/tantivy/pull/2818)(@Darkheir)
-    - Deduplicate queries in query parser [#2698](https://github.com/quickwit-oss/tantivy/pull/2698)(@PSeitz-dd)
-- Add erased `SortKeyComputer` for sorting on column types unknown until runtime [#2770](https://github.com/quickwit-oss/tantivy/pull/2770) [#2790](https://github.com/quickwit-oss/tantivy/pull/2790)(@stuhood @PSeitz)
-- Add natural-order-with-none-highest support in `TopDocs::order_by` [#2780](https://github.com/quickwit-oss/tantivy/pull/2780)(@stuhood)
-- Move stemming behing `stemmer` feature flag [#2791](https://github.com/quickwit-oss/tantivy/pull/2791)(@fulmicoton)
-- Make `DeleteMeta`, `AddOperation`, `advance_deletes`, `with_max_doc`, `serializer` module, and `delete_queue` public [#2762](https://github.com/quickwit-oss/tantivy/pull/2762) [#2765](https://github.com/quickwit-oss/tantivy/pull/2765) [#2766](https://github.com/quickwit-oss/tantivy/pull/2766) [#2835](https://github.com/quickwit-oss/tantivy/pull/2835)(@philippemnoel @PSeitz)
-- Make `Language` hashable [#2763](https://github.com/quickwit-oss/tantivy/pull/2763)(@philippemnoel)
-- Improve `space_usage` reporting for JSON fields and columnar data [#2761](https://github.com/quickwit-oss/tantivy/pull/2761)(@PSeitz-dd)
-- Split `Term` into `Term` and `IndexingTerm` [#2744](https://github.com/quickwit-oss/tantivy/pull/2744) [#2750](https://github.com/quickwit-oss/tantivy/pull/2750)(@PSeitz-dd @PSeitz)
-
-## Performance
-- **Aggregation**
-    - Large speed up and memory reduction for nested high cardinality aggregations by using one collector per request instead of one per bucket, and adding `PagedTermMap` for faster medium cardinality term aggregations [#2715](https://github.com/quickwit-oss/tantivy/pull/2715) [#2759](https://github.com/quickwit-oss/tantivy/pull/2759)(@PSeitz @PSeitz-dd)
-    - Optimize low-cardinality term aggregations by using a `Vec` instead of a `HashMap` [#2740](https://github.com/quickwit-oss/tantivy/pull/2740)(@fulmicoton-dd)
-- Optimize `ExistsQuery` for a high number of dynamic columns [#2694](https://github.com/quickwit-oss/tantivy/pull/2694)(@PSeitz-dd)
-- Add lazy scorers to stop score evaluation early when a doc won't reach the top-K threshold [#2726](https://github.com/quickwit-oss/tantivy/pull/2726) [#2777](https://github.com/quickwit-oss/tantivy/pull/2777)(@fulmicoton @stuhood)
-- Add `DocSet::cost()` and use it to order scorers in intersections [#2707](https://github.com/quickwit-oss/tantivy/pull/2707)(@PSeitz)
-- Add `collect_block` support for collector wrappers [#2727](https://github.com/quickwit-oss/tantivy/pull/2727)(@stuhood)
-- Optimize saturated posting lists by replacing them with `AllScorer` in boolean queries [#2745](https://github.com/quickwit-oss/tantivy/pull/2745) [#2760](https://github.com/quickwit-oss/tantivy/pull/2760) [#2774](https://github.com/quickwit-oss/tantivy/pull/2774)(@fulmicoton @mdashti @trinity-1686a)
-- Add `seek_danger` on `DocSet` for more efficient intersections [#2538](https://github.com/quickwit-oss/tantivy/pull/2538) [#2810](https://github.com/quickwit-oss/tantivy/pull/2810)(@PSeitz @stuhood @fulmicoton)
-- Skip column traversal in `RangeDocSet` when query range does not overlap with column bounds [#2783](https://github.com/quickwit-oss/tantivy/pull/2783)(@ChangRui-Ryan)
-- Speed up exclude queries by supporting multiple excluded `DocSet`s without intermediate union [#2825](https://github.com/quickwit-oss/tantivy/pull/2825)(@PSeitz)
-- Improve union performance for non-score unions with `fill_buffer` and optimized `TinySet` [#2863](https://github.com/quickwit-oss/tantivy/pull/2863)(@PSeitz)
-
 Tantivy 0.25
 ================================
 

Cargo.toml

@@ -11,23 +11,23 @@ repository = "https://github.com/quickwit-oss/tantivy"
 readme = "README.md"
 keywords = ["search", "information", "retrieval"]
 edition = "2021"
-rust-version = "1.86"
+rust-version = "1.85"
 exclude = ["benches/*.json", "benches/*.txt"]
 
 [dependencies]
-oneshot = "0.1.13"
+oneshot = "0.1.7"
 base64 = "0.22.0"
 byteorder = "1.4.3"
 crc32fast = "1.3.2"
 once_cell = "1.10.0"
 regex = { version = "1.5.5", default-features = false, features = [
-    "std",
-    "unicode",
+  "std",
+  "unicode",
 ] }
 aho-corasick = "1.0"
-tantivy-fst = "0.5"
+tantivy-fst = { git = "https://github.com/paradedb/fst.git" }
 memmap2 = { version = "0.9.0", optional = true }
-lz4_flex = { version = "0.13", default-features = false, optional = true }
+lz4_flex = { version = "0.11", default-features = false, optional = true }
 zstd = { version = "0.13", optional = true, default-features = false }
 tempfile = { version = "3.12.0", optional = true }
 log = "0.4.16"
@@ -37,62 +37,68 @@ fs4 = { version = "0.13.1", optional = true }
 levenshtein_automata = "0.2.1"
 uuid = { version = "1.0.0", features = ["v4", "serde"] }
 crossbeam-channel = "0.5.4"
-rust-stemmers = { version = "1.2.0", optional = true }
+rust-stemmers = "1.2.0"
+tantivy-stemmers = { version = "0.4.0", default-features = false, features = ["polish_yarovoy"] }
 downcast-rs = "2.0.1"
-bitpacking = { version = "0.9.3", default-features = false, features = [
-    "bitpacker4x",
+bitpacking = { version = "0.9.2", default-features = false, features = [
+  "bitpacker4x",
 ] }
 census = "0.4.2"
 rustc-hash = "2.0.0"
 thiserror = "2.0.1"
 htmlescape = "0.3.1"
 fail = { version = "0.5.0", optional = true }
-time = { version = "0.3.47", features = ["serde-well-known"] }
+time = { version = "0.3.35", features = ["serde-well-known"] }
+# TODO: We have integer wrappers with PartialOrd, and a misfeature of
+# `deranged` causes inference to fail in a bunch of cases. See
+# https://github.com/jhpratt/deranged/issues/18#issuecomment-2746844093
+deranged = "=0.4.0"
 smallvec = "1.8.0"
 rayon = "1.5.2"
-lru = "0.16.3"
+lru = "0.12.0"
 fastdivide = "0.4.0"
 itertools = "0.14.0"
 measure_time = "0.9.0"
 arc-swap = "1.5.0"
 bon = "3.3.1"
 
-columnar = { version = "0.7", path = "./columnar", package = "tantivy-columnar" }
-sstable = { version = "0.7", path = "./sstable", package = "tantivy-sstable", optional = true }
-stacker = { version = "0.7", path = "./stacker", package = "tantivy-stacker" }
-query-grammar = { version = "0.26.0", path = "./query-grammar", package = "tantivy-query-grammar" }
-tantivy-bitpacker = { version = "0.10", path = "./bitpacker" }
-common = { version = "0.11", path = "./common/", package = "tantivy-common" }
-tokenizer-api = { version = "0.7", path = "./tokenizer-api", package = "tantivy-tokenizer-api" }
-sketches-ddsketch = { version = "0.4", features = ["use_serde"] }
-datasketches = { version = "0.3.0", features = ["hll"] }
+columnar = { version = "0.6", path = "./columnar", package = "tantivy-columnar" }
+sstable = { version = "0.6", path = "./sstable", package = "tantivy-sstable", optional = true }
+stacker = { version = "0.6", path = "./stacker", package = "tantivy-stacker" }
+query-grammar = { version = "0.25.0", path = "./query-grammar", package = "tantivy-query-grammar" }
+tantivy-bitpacker = { version = "0.9", path = "./bitpacker" }
+common = { version = "0.10", path = "./common/", package = "tantivy-common" }
+tokenizer-api = { version = "0.6", path = "./tokenizer-api", package = "tantivy-tokenizer-api" }
+sketches-ddsketch = { version = "0.3.0", features = ["use_serde"] }
+hyperloglogplus = { version = "0.4.1", features = ["const-loop"] }
 futures-util = { version = "0.3.28", optional = true }
 futures-channel = { version = "0.3.28", optional = true }
 fnv = "1.0.7"
+parking_lot = "0.12.4"
 typetag = "0.2.21"
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"
 
 [dev-dependencies]
-binggan = "0.17.0"
-rand = "0.9"
+binggan = "0.14.0"
+rand = "0.8.5"
 maplit = "1.0.2"
 matches = "0.1.9"
 pretty_assertions = "1.2.1"
-proptest = "1.7.0"
+proptest = "1.0.0"
 test-log = "0.2.10"
 futures = "0.3.21"
 paste = "1.0.11"
 more-asserts = "0.3.1"
-rand_distr = "0.5"
-time = { version = "0.3.47", features = ["serde-well-known", "macros"] }
+rand_distr = "0.4.3"
+time = { version = "0.3.10", features = ["serde-well-known", "macros"] }
 postcard = { version = "1.0.4", features = [
-    "use-std",
+  "use-std",
 ], default-features = false }
 
 [target.'cfg(not(windows))'.dev-dependencies]
-criterion = { version = "0.8", default-features = false }
+criterion = { version = "0.5", default-features = false }
 
 [dev-dependencies.fail]
 version = "0.5.0"
@@ -113,8 +119,7 @@ debug-assertions = true
 overflow-checks = true
 
 [features]
-default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression", "stemmer"]
-stemmer = ["rust-stemmers"]
+default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression"]
 mmap = ["fs4", "tempfile", "memmap2"]
 stopwords = []
 
@@ -136,14 +141,14 @@ compare_hash_only = ["stacker/compare_hash_only"]
 
 [workspace]
 members = [
-    "query-grammar",
-    "bitpacker",
-    "common",
-    "ownedbytes",
-    "stacker",
-    "sstable",
-    "tokenizer-api",
-    "columnar",
+  "query-grammar",
+  "bitpacker",
+  "common",
+  "ownedbytes",
+  "stacker",
+  "sstable",
+  "tokenizer-api",
+  "columnar",
 ]
 
 # Following the "fail" crate best practises, we isolate
@@ -174,38 +179,6 @@ harness = false
 name = "exists_json"
 harness = false
 
-[[bench]]
-name = "range_query"
-harness = false
-
 [[bench]]
 name = "and_or_queries"
 harness = false
-
-[[bench]]
-name = "range_queries"
-harness = false
-
-[[bench]]
-name = "bool_queries_with_range"
-harness = false
-
-[[bench]]
-name = "str_search_and_get"
-harness = false
-
-[[bench]]
-name = "merge_segments"
-harness = false
-
-[[bench]]
-name = "regex_all_terms"
-harness = false
-
-[[bench]]
-name = "query_parser_nested"
-harness = false
-
-[[bench]]
-name = "intersection_bench"
-harness = false

README.md

@@ -1,7 +1,6 @@
 [![Docs](https://docs.rs/tantivy/badge.svg)](https://docs.rs/crate/tantivy/)
 [![Build Status](https://github.com/quickwit-oss/tantivy/actions/workflows/test.yml/badge.svg)](https://github.com/quickwit-oss/tantivy/actions/workflows/test.yml)
 [![codecov](https://codecov.io/gh/quickwit-oss/tantivy/branch/main/graph/badge.svg)](https://codecov.io/gh/quickwit-oss/tantivy)
-[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/quickwit-oss/tantivy/badge)](https://scorecard.dev/viewer/?uri=github.com/quickwit-oss/tantivy)
 [![Join the chat at https://discord.gg/MT27AG5EVE](https://shields.io/discord/908281611840282624?label=chat%20on%20discord)](https://discord.gg/MT27AG5EVE)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Crates.io](https://img.shields.io/crates/v/tantivy.svg)](https://crates.io/crates/tantivy)

benches/agg_bench.rs

@@ -1,8 +1,8 @@
 use binggan::plugins::PeakMemAllocPlugin;
 use binggan::{black_box, InputGroup, PeakMemAlloc, INSTRUMENTED_SYSTEM};
-use rand::distr::weighted::WeightedIndex;
+use rand::distributions::WeightedIndex;
+use rand::prelude::SliceRandom;
 use rand::rngs::StdRng;
-use rand::seq::IndexedRandom;
 use rand::{Rng, SeedableRng};
 use rand_distr::Distribution;
 use serde_json::json;
@@ -10,7 +10,7 @@ use tantivy::aggregation::agg_req::Aggregations;
 use tantivy::aggregation::AggregationCollector;
 use tantivy::query::{AllQuery, TermQuery};
 use tantivy::schema::{IndexRecordOption, Schema, TextFieldIndexing, FAST, STRING};
-use tantivy::{doc, DateTime, Index, Term};
+use tantivy::{doc, Index, Term};
 
 #[global_allocator]
 pub static GLOBAL: &PeakMemAlloc<std::alloc::System> = &INSTRUMENTED_SYSTEM;
@@ -54,46 +54,33 @@ fn bench_agg(mut group: InputGroup<Index>) {
     register!(group, stats_f64);
     register!(group, extendedstats_f64);
     register!(group, percentiles_f64);
-    register!(group, terms_7);
+    register!(group, terms_few);
     register!(group, terms_all_unique);
-    register!(group, terms_150_000);
+    register!(group, terms_many);
     register!(group, terms_many_top_1000);
     register!(group, terms_many_order_by_term);
     register!(group, terms_many_with_top_hits);
     register!(group, terms_all_unique_with_avg_sub_agg);
     register!(group, terms_many_with_avg_sub_agg);
+    register!(group, terms_few_with_avg_sub_agg);
     register!(group, terms_status_with_avg_sub_agg);
-    register!(group, terms_status_with_terms_zipf_1000_sub_agg);
-    register!(group, terms_zipf_1000_with_terms_status_sub_agg);
+    register!(group, terms_status);
+    register!(group, terms_few_with_histogram);
     register!(group, terms_status_with_histogram);
-    register!(group, terms_zipf_1000);
-    register!(group, terms_zipf_1000_with_histogram);
-    register!(group, terms_zipf_1000_with_avg_sub_agg);
 
     register!(group, terms_many_json_mixed_type_with_avg_sub_agg);
 
-    register!(group, composite_term_many_page_1000);
-    register!(group, composite_term_many_page_1000_with_avg_sub_agg);
-    register!(group, composite_term_few);
-    register!(group, composite_histogram);
-    register!(group, composite_histogram_calendar);
-
     register!(group, cardinality_agg);
-    register!(group, cardinality_agg_high_card);
-    register!(group, cardinality_agg_low_card);
-    register!(group, terms_status_with_cardinality_agg);
-    register!(group, terms_100_buckets_with_cardinality_agg);
-    register!(group, terms_many_with_single_term_order_by_card);
-    register!(group, terms_many_with_single_term_2_order_by_card);
+    register!(group, terms_few_with_cardinality_agg);
 
     register!(group, range_agg);
     register!(group, range_agg_with_avg_sub_agg);
-    register!(group, range_agg_with_term_agg_status);
+    register!(group, range_agg_with_term_agg_few);
     register!(group, range_agg_with_term_agg_many);
     register!(group, histogram);
     register!(group, histogram_hard_bounds);
     register!(group, histogram_with_avg_sub_agg);
-    register!(group, histogram_with_term_agg_status);
+    register!(group, histogram_with_term_agg_few);
     register!(group, avg_and_range_with_avg_sub_agg);
 
     // Filter aggregation benchmarks
@@ -172,52 +159,10 @@ fn cardinality_agg(index: &Index) {
     });
     execute_agg(index, agg_req);
 }
-// Full-scan cardinality on a near-1M-cardinality string field.
-// Hits the dense (PagedBitset) path: every doc has a unique term,
-// so the bucket promotes from FxHashSet shortly into the scan.
-fn cardinality_agg_high_card(index: &Index) {
-    let agg_req = json!({
-        "cardinality": {
-            "cardinality": {
-                "field": "text_all_unique_terms"
-            },
-        }
-    });
-    execute_agg(index, agg_req);
-}
-// Full-scan cardinality on a tiny-cardinality string field (7 distinct
-// values). Stays on the FxHashSet path — the promotion threshold is
-// never crossed. Validates no regression on the sparse path.
-fn cardinality_agg_low_card(index: &Index) {
-    let agg_req = json!({
-        "cardinality": {
-            "cardinality": {
-                "field": "text_few_terms_status"
-            },
-        }
-    });
-    execute_agg(index, agg_req);
-}
-fn terms_status_with_cardinality_agg(index: &Index) {
+fn terms_few_with_cardinality_agg(index: &Index) {
     let agg_req = json!({
         "my_texts": {
-            "terms": { "field": "text_few_terms_status" },
-            "aggs": {
-                "cardinality": {
-                    "cardinality": {
-                        "field": "text_few_terms_status"
-                    },
-                }
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-
-fn terms_100_buckets_with_cardinality_agg(index: &Index) {
-    let agg_req = json!({
-        "my_texts": {
-            "terms": { "field": "text_1000_terms_zipf", "size": 100 },
+            "terms": { "field": "text_few_terms" },
             "aggs": {
                 "cardinality": {
                     "cardinality": {
@@ -230,59 +175,13 @@ fn terms_100_buckets_with_cardinality_agg(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn terms_many_with_single_term_order_by_card(index: &Index) {
+fn terms_few(index: &Index) {
     let agg_req = json!({
-        "my_texts": {
-            "terms": { "field": "text_many_terms" },
-            "aggs": {
-                "nested_terms": {
-                    "terms": {
-                        "field": "single_term",
-                        "order": { "cardinality": "desc" }
-                    },
-                    "aggs": {
-                        "cardinality": {
-                            "cardinality": { "field": "text_few_terms" }
-                        }
-                    }
-                }
-            }
-        },
+        "my_texts": { "terms": { "field": "text_few_terms" } },
     });
     execute_agg(index, agg_req);
 }
-
-// Two-level terms ordered by cardinality at each level: a high-card outer terms
-// (text_many_terms) ordered by a cardinality sub-agg, with a nested low-card terms
-// (text_few_terms_status) also ordered by a cardinality sub-agg, plus an avg.
-fn terms_many_with_single_term_2_order_by_card(index: &Index) {
-    let agg_req = json!({
-        "by_ip": {
-            "terms": {
-                "field": "text_many_terms",
-                "order": { "card_few_terms": "desc" }
-            },
-            "aggs": {
-                "card_few_terms": {
-                    "cardinality": { "field": "text_few_terms" }
-                },
-                "nested_terms": {
-                    "terms": {
-                        "field": " single_term",
-                        "order": { "distinct_path2": "desc" }
-                    },
-                    "aggs": {
-                        "avg_botscore": { "avg": { "field": "score" } },
-                        "distinct_path2": { "cardinality": { "field": "text_few_terms" } }
-                    }
-                }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
-
-fn terms_7(index: &Index) {
+fn terms_status(index: &Index) {
     let agg_req = json!({
         "my_texts": { "terms": { "field": "text_few_terms_status" } },
     });
@@ -295,7 +194,7 @@ fn terms_all_unique(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn terms_150_000(index: &Index) {
+fn terms_many(index: &Index) {
     let agg_req = json!({
         "my_texts": { "terms": { "field": "text_many_terms" } },
     });
@@ -354,30 +253,17 @@ fn terms_all_unique_with_avg_sub_agg(index: &Index) {
     });
     execute_agg(index, agg_req);
 }
-fn terms_status_with_terms_zipf_1000_sub_agg(index: &Index) {
+fn terms_few_with_histogram(index: &Index) {
     let agg_req = json!({
         "my_texts": {
-            "terms": { "field": "text_few_terms_status" },
+            "terms": { "field": "text_few_terms" },
             "aggs": {
-                "nested_terms": { "terms": { "field": "text_1000_terms_zipf" } }
+                "histo": {"histogram": { "field": "score_f64", "interval": 10 }}
             }
         }
     });
     execute_agg(index, agg_req);
 }
-
-fn terms_zipf_1000_with_terms_status_sub_agg(index: &Index) {
-    let agg_req = json!({
-        "my_texts": {
-            "terms": { "field": "text_1000_terms_zipf" },
-            "aggs": {
-                "nested_terms": { "terms": { "field": "text_few_terms_status" } }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
-
 fn terms_status_with_histogram(index: &Index) {
     let agg_req = json!({
         "my_texts": {
@@ -390,18 +276,17 @@ fn terms_status_with_histogram(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn terms_zipf_1000_with_histogram(index: &Index) {
+fn terms_few_with_avg_sub_agg(index: &Index) {
     let agg_req = json!({
         "my_texts": {
-            "terms": { "field": "text_1000_terms_zipf" },
+            "terms": { "field": "text_few_terms" },
             "aggs": {
-                "histo": {"histogram": { "field": "score_f64", "interval": 10 }}
+                "average_f64": { "avg": { "field": "score_f64" } }
             }
-        }
+        },
     });
     execute_agg(index, agg_req);
 }
-
 fn terms_status_with_avg_sub_agg(index: &Index) {
     let agg_req = json!({
         "my_texts": {
@@ -414,25 +299,6 @@ fn terms_status_with_avg_sub_agg(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn terms_zipf_1000_with_avg_sub_agg(index: &Index) {
-    let agg_req = json!({
-        "my_texts": {
-            "terms": { "field": "text_1000_terms_zipf" },
-            "aggs": {
-                "average_f64": { "avg": { "field": "score_f64" } }
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-
-fn terms_zipf_1000(index: &Index) {
-    let agg_req = json!({
-        "my_texts": { "terms": { "field": "text_1000_terms_zipf" } },
-    });
-    execute_agg(index, agg_req);
-}
-
 fn terms_many_json_mixed_type_with_avg_sub_agg(index: &Index) {
     let agg_req = json!({
         "my_texts": {
@@ -445,75 +311,6 @@ fn terms_many_json_mixed_type_with_avg_sub_agg(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn composite_term_few(index: &Index) {
-    let agg_req = json!({
-        "my_ctf": {
-            "composite": {
-                "sources": [
-                    { "text_few_terms": { "terms": { "field": "text_few_terms" } } }
-                ],
-                "size": 1000
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-fn composite_term_many_page_1000(index: &Index) {
-    let agg_req = json!({
-        "my_ctmp1000": {
-            "composite": {
-                "sources": [
-                    { "text_many_terms": { "terms": { "field": "text_many_terms" } } }
-                ],
-                "size": 1000
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-fn composite_term_many_page_1000_with_avg_sub_agg(index: &Index) {
-    let agg_req = json!({
-        "my_ctmp1000wasa": {
-            "composite": {
-                "sources": [
-                    { "text_many_terms": { "terms": { "field": "text_many_terms" } } }
-                ],
-                "size": 1000,
-            },
-            "aggs": {
-                "average_f64": { "avg": { "field": "score_f64" } }
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-fn composite_histogram(index: &Index) {
-    let agg_req = json!({
-        "my_ch": {
-            "composite": {
-                "sources": [
-                    { "f64_histogram": { "histogram": { "field": "score_f64", "interval": 1 } } }
-                ],
-                "size": 1000
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-fn composite_histogram_calendar(index: &Index) {
-    let agg_req = json!({
-        "my_chc": {
-            "composite": {
-                "sources": [
-                    { "time_histogram": { "date_histogram": { "field": "timestamp", "calendar_interval": "month" } } }
-                ],
-                "size": 1000
-            }
-        },
-    });
-    execute_agg(index, agg_req);
-}
-
 fn execute_agg(index: &Index, agg_req: serde_json::Value) {
     let agg_req: Aggregations = serde_json::from_value(agg_req).unwrap();
     let collector = get_collector(agg_req);
@@ -557,7 +354,7 @@ fn range_agg_with_avg_sub_agg(index: &Index) {
     execute_agg(index, agg_req);
 }
 
-fn range_agg_with_term_agg_status(index: &Index) {
+fn range_agg_with_term_agg_few(index: &Index) {
     let agg_req = json!({
         "rangef64": {
             "range": {
@@ -572,7 +369,7 @@ fn range_agg_with_term_agg_status(index: &Index) {
                 ]
             },
             "aggs": {
-                "my_texts": { "terms": { "field": "text_few_terms_status" } },
+                "my_texts": { "terms": { "field": "text_few_terms" } },
             }
         },
     });
@@ -628,12 +425,12 @@ fn histogram_with_avg_sub_agg(index: &Index) {
     });
     execute_agg(index, agg_req);
 }
-fn histogram_with_term_agg_status(index: &Index) {
+fn histogram_with_term_agg_few(index: &Index) {
     let agg_req = json!({
         "rangef64": {
             "histogram": { "field": "score_f64", "interval": 10 },
             "aggs": {
-                "my_texts": { "terms": { "field": "text_few_terms_status" } }
+                "my_texts": { "terms": { "field": "text_few_terms" } }
             }
         }
     });
@@ -678,66 +475,35 @@ fn get_collector(agg_req: Aggregations) -> AggregationCollector {
 }
 
 fn get_test_index_bench(cardinality: Cardinality) -> tantivy::Result<Index> {
-    // Flag to use existing index
-    let reuse_index = std::env::var("REUSE_AGG_BENCH_INDEX").is_ok();
-    if reuse_index && std::path::Path::new("agg_bench").exists() {
-        return Index::open_in_dir("agg_bench");
-    }
-    // crreate dir
-    std::fs::create_dir_all("agg_bench")?;
     let mut schema_builder = Schema::builder();
     let text_fieldtype = tantivy::schema::TextOptions::default()
         .set_indexing_options(
             TextFieldIndexing::default().set_index_option(IndexRecordOption::WithFreqs),
         )
         .set_stored();
-    let text_field = schema_builder.add_text_field("text", text_fieldtype.clone());
-    let single_term = schema_builder.add_text_field("single_term", FAST);
+    let text_field = schema_builder.add_text_field("text", text_fieldtype);
     let json_field = schema_builder.add_json_field("json", FAST);
     let text_field_all_unique_terms =
         schema_builder.add_text_field("text_all_unique_terms", STRING | FAST);
     let text_field_many_terms = schema_builder.add_text_field("text_many_terms", STRING | FAST);
+    let text_field_many_terms = schema_builder.add_text_field("text_many_terms", STRING | FAST);
     let text_field_few_terms = schema_builder.add_text_field("text_few_terms", STRING | FAST);
     let text_field_few_terms_status =
         schema_builder.add_text_field("text_few_terms_status", STRING | FAST);
-    let text_field_1000_terms_zipf =
-        schema_builder.add_text_field("text_1000_terms_zipf", STRING | FAST);
     let score_fieldtype = tantivy::schema::NumericOptions::default().set_fast();
     let score_field = schema_builder.add_u64_field("score", score_fieldtype.clone());
     let score_field_f64 = schema_builder.add_f64_field("score_f64", score_fieldtype.clone());
     let score_field_i64 = schema_builder.add_i64_field("score_i64", score_fieldtype);
-    let date_field = schema_builder.add_date_field("timestamp", FAST);
-    // use tmp dir
-    let index = if reuse_index {
-        Index::create_in_dir("agg_bench", schema_builder.build())?
-    } else {
-        Index::create_from_tempdir(schema_builder.build())?
-    };
-    // Approximate log proportions
-    let status_field_data = [
-        ("INFO", 8000),
-        ("ERROR", 300),
-        ("WARN", 1200),
-        ("DEBUG", 500),
-        ("OK", 500),
-        ("CRITICAL", 20),
-        ("EMERGENCY", 1),
-    ];
-    let log_level_distribution =
-        WeightedIndex::new(status_field_data.iter().map(|item| item.1)).unwrap();
-
+    let index = Index::create_from_tempdir(schema_builder.build())?;
     let few_terms_data = ["INFO", "ERROR", "WARN", "DEBUG"];
+    // Approximate production log proportions: INFO dominant, WARN and DEBUG occasional, ERROR rare.
+    let log_level_distribution = WeightedIndex::new([80u32, 3, 12, 5]).unwrap();
+
     let lg_norm = rand_distr::LogNormal::new(2.996f64, 0.979f64).unwrap();
 
     let many_terms_data = (0..150_000)
         .map(|num| format!("author{num}"))
         .collect::<Vec<_>>();
-
-    // Prepare 1000 unique terms sampled using a Zipf distribution.
-    // Exponent ~1.1 approximates top-20 terms covering around ~20%.
-    let terms_1000: Vec<String> = (1..=1000).map(|i| format!("term_{i}")).collect();
-    let zipf_1000 = rand_distr::Zipf::new(1000.0, 1.1f64).unwrap();
-
     {
         let mut rng = StdRng::from_seed([1u8; 32]);
         let mut index_writer = index.writer_with_num_threads(1, 200_000_000)?;
@@ -747,17 +513,11 @@ fn get_test_index_bench(cardinality: Cardinality) -> tantivy::Result<Index> {
             index_writer.add_document(doc!())?;
         }
         if cardinality == Cardinality::Multivalued {
-            let log_level_sample_a = status_field_data[log_level_distribution.sample(&mut rng)].0;
-            let log_level_sample_b = status_field_data[log_level_distribution.sample(&mut rng)].0;
-            let idx_a = zipf_1000.sample(&mut rng) as usize - 1;
-            let idx_b = zipf_1000.sample(&mut rng) as usize - 1;
-            let term_1000_a = &terms_1000[idx_a];
-            let term_1000_b = &terms_1000[idx_b];
+            let log_level_sample_a = few_terms_data[log_level_distribution.sample(&mut rng)];
+            let log_level_sample_b = few_terms_data[log_level_distribution.sample(&mut rng)];
             index_writer.add_document(doc!(
                 json_field => json!({"mixed_type": 10.0}),
                 json_field => json!({"mixed_type": 10.0}),
-                single_term => "single_term",
-                single_term => "single_term",
                 text_field => "cool",
                 text_field => "cool",
                 text_field_all_unique_terms => "cool",
@@ -768,8 +528,6 @@ fn get_test_index_bench(cardinality: Cardinality) -> tantivy::Result<Index> {
                 text_field_few_terms => "cool",
                 text_field_few_terms_status => log_level_sample_a,
                 text_field_few_terms_status => log_level_sample_b,
-                text_field_1000_terms_zipf => term_1000_a.as_str(),
-                text_field_1000_terms_zipf => term_1000_b.as_str(),
                 score_field => 1u64,
                 score_field => 1u64,
                 score_field_f64 => lg_norm.sample(&mut rng),
@@ -784,26 +542,23 @@ fn get_test_index_bench(cardinality: Cardinality) -> tantivy::Result<Index> {
         }
         let _val_max = 1_000_000.0;
         for _ in 0..doc_with_value {
-            let val: f64 = rng.random_range(0.0..1_000_000.0);
-            let json = if rng.random_bool(0.1) {
+            let val: f64 = rng.gen_range(0.0..1_000_000.0);
+            let json = if rng.gen_bool(0.1) {
                 // 10% are numeric values
                 json!({ "mixed_type": val })
             } else {
                 json!({"mixed_type": many_terms_data.choose(&mut rng).unwrap().to_string()})
             };
             index_writer.add_document(doc!(
-                single_term => "single_term",
                 text_field => "cool",
                 json_field => json,
-                text_field_all_unique_terms => format!("unique_term_{}", rng.random::<u64>()),
+                text_field_all_unique_terms => format!("unique_term_{}", rng.gen::<u64>()),
                 text_field_many_terms => many_terms_data.choose(&mut rng).unwrap().to_string(),
                 text_field_few_terms => few_terms_data.choose(&mut rng).unwrap().to_string(),
-                text_field_few_terms_status => status_field_data[log_level_distribution.sample(&mut rng)].0,
-                text_field_1000_terms_zipf => terms_1000[zipf_1000.sample(&mut rng) as usize - 1].as_str(),
+                text_field_few_terms_status => few_terms_data[log_level_distribution.sample(&mut rng)],
                 score_field => val as u64,
                 score_field_f64 => lg_norm.sample(&mut rng),
                 score_field_i64 => val as i64,
-                date_field => DateTime::from_timestamp_millis((val * 1_000_000.) as i64),
             ))?;
             if cardinality == Cardinality::OptionalSparse {
                 for _ in 0..20 {
@@ -852,7 +607,7 @@ fn filter_agg_all_query_with_sub_aggs(index: &Index) {
                 "avg_score": { "avg": { "field": "score" } },
                 "stats_score": { "stats": { "field": "score_f64" } },
                 "terms_text": {
-                    "terms": { "field": "text_few_terms_status" }
+                    "terms": { "field": "text_few_terms" }
                 }
             }
         }
@@ -868,7 +623,7 @@ fn filter_agg_term_query_with_sub_aggs(index: &Index) {
                 "avg_score": { "avg": { "field": "score" } },
                 "stats_score": { "stats": { "field": "score_f64" } },
                 "terms_text": {
-                    "terms": { "field": "text_few_terms_status" }
+                    "terms": { "field": "text_few_terms" }
                 }
             }
         }

benches/and_or_queries.rs

@@ -22,7 +22,7 @@ use rand::rngs::StdRng;
 use rand::SeedableRng;
 use tantivy::collector::sort_key::SortByStaticFastValue;
 use tantivy::collector::{Collector, Count, TopDocs};
-use tantivy::query::QueryParser;
+use tantivy::query::{Query, QueryParser};
 use tantivy::schema::{Schema, FAST, TEXT};
 use tantivy::{doc, Index, Order, ReloadPolicy, Searcher};
 
@@ -38,7 +38,7 @@ struct BenchIndex {
 /// return two BenchIndex views:
 /// - single_field: QueryParser defaults to only "body"
 /// - multi_field:  QueryParser defaults to ["title", "body"]
-fn build_index(num_docs: usize, terms: &[(&str, f32)]) -> (BenchIndex, BenchIndex) {
+fn build_shared_indices(num_docs: usize, p_a: f32, p_b: f32, p_c: f32) -> (BenchIndex, BenchIndex) {
     // Unified schema (two text fields)
     let mut schema_builder = Schema::builder();
     let f_title = schema_builder.add_text_field("title", TEXT);
@@ -55,17 +55,32 @@ fn build_index(num_docs: usize, terms: &[(&str, f32)]) -> (BenchIndex, BenchInde
     {
         let mut writer = index.writer_with_num_threads(1, 500_000_000).unwrap();
         for _ in 0..num_docs {
-            let score = rng.random_range(0u64..100u64);
-            let score2 = rng.random_range(0u64..100_000u64);
+            let has_a = rng.gen_bool(p_a as f64);
+            let has_b = rng.gen_bool(p_b as f64);
+            let has_c = rng.gen_bool(p_c as f64);
+            let score = rng.gen_range(0u64..100u64);
+            let score2 = rng.gen_range(0u64..100_000u64);
             let mut title_tokens: Vec<&str> = Vec::new();
             let mut body_tokens: Vec<&str> = Vec::new();
-            for &(tok, prob) in terms {
-                if rng.random_bool(prob as f64) {
-                    if rng.random_bool(0.1) {
-                        title_tokens.push(tok);
-                    } else {
-                        body_tokens.push(tok);
-                    }
+            if has_a {
+                if rng.gen_bool(0.1) {
+                    title_tokens.push("a");
+                } else {
+                    body_tokens.push("a");
+                }
+            }
+            if has_b {
+                if rng.gen_bool(0.1) {
+                    title_tokens.push("b");
+                } else {
+                    body_tokens.push("b");
+                }
+            }
+            if has_c {
+                if rng.gen_bool(0.1) {
+                    title_tokens.push("c");
+                } else {
+                    body_tokens.push("c");
                 }
             }
             if title_tokens.is_empty() && body_tokens.is_empty() {
@@ -95,97 +110,59 @@ fn build_index(num_docs: usize, terms: &[(&str, f32)]) -> (BenchIndex, BenchInde
     let qp_single = QueryParser::for_index(&index, vec![f_body]);
     let qp_multi = QueryParser::for_index(&index, vec![f_title, f_body]);
 
-    let only_title = BenchIndex {
+    let single_view = BenchIndex {
         index: index.clone(),
         searcher: searcher.clone(),
         query_parser: qp_single,
     };
-    let title_and_body = BenchIndex {
+    let multi_view = BenchIndex {
         index,
         searcher,
         query_parser: qp_multi,
     };
-    (only_title, title_and_body)
-}
-
-fn format_pct(p: f32) -> String {
-    let pct = (p as f64) * 100.0;
-    let rounded = (pct * 1_000_000.0).round() / 1_000_000.0;
-    if rounded.fract() <= 0.001 {
-        format!("{}%", rounded as u64)
-    } else {
-        format!("{}%", rounded)
-    }
-}
-
-fn query_label(query_str: &str, term_pcts: &[(&str, String)]) -> String {
-    let mut label = query_str.to_string();
-    for (term, pct) in term_pcts {
-        label = label.replace(term, pct);
-    }
-    label.replace(' ', "_")
+    (single_view, multi_view)
 }
 
 fn main() {
-    // terms with varying selectivity, ordered from rarest to most common.
-    // With 1M docs, we expect:
-    // a: 0.01% (100), b: 1% (10k), c: 5% (50k), d: 15% (150k), e: 30% (300k)
-    let num_docs = 1_000_000;
-    let terms: &[(&str, f32)] = &[
-        ("a", 0.0001),
-        ("b", 0.01),
-        ("c", 0.05),
-        ("d", 0.15),
-        ("e", 0.30),
+    // Prepare corpora with varying selectivity. Build one index per corpus
+    // and derive two views (single-field vs multi-field) from it.
+    let scenarios = vec![
+        (
+            "N=1M, p(a)=5%, p(b)=1%, p(c)=15%".to_string(),
+            1_000_000,
+            0.05,
+            0.01,
+            0.15,
+        ),
+        (
+            "N=1M, p(a)=1%, p(b)=1%, p(c)=15%".to_string(),
+            1_000_000,
+            0.01,
+            0.01,
+            0.15,
+        ),
     ];
 
-    let queries: &[(&str, &[&str])] = &[
-        (
-            "only_union",
-            &["c OR b", "c OR b OR d", "c OR e", "e OR a"] as &[&str],
-        ),
-        (
-            "only_intersection",
-            &["+c +b", "+c +b +d", "+c +e", "+e +a"] as &[&str],
-        ),
-        (
-            "union_intersection",
-            &["+c +(b OR d)", "+e +(c OR a)", "+(c OR b) +(d OR e)"] as &[&str],
-        ),
-    ];
+    let queries = &["a", "+a +b", "+a +b +c", "a OR b", "a OR b OR c"];
 
     let mut runner = BenchRunner::new();
-    let (only_title, title_and_body) = build_index(num_docs, terms);
-    let term_pcts: Vec<(&str, String)> = terms
-        .iter()
-        .map(|&(term, p)| (term, format_pct(p)))
-        .collect();
+    for (label, n, pa, pb, pc) in scenarios {
+        let (single_view, multi_view) = build_shared_indices(n, pa, pb, pc);
 
-    for (view_name, bench_index) in [
-        ("single_field", only_title),
-        ("multi_field", title_and_body),
-    ] {
-        for (category_name, category_queries) in queries {
-            for query_str in *category_queries {
-                let mut group = runner.new_group();
-                let query_label = query_label(query_str, &term_pcts);
-                group.set_name(format!("{}_{}_{}", view_name, category_name, query_label));
+        for (view_name, bench_index) in [("single_field", single_view), ("multi_field", multi_view)]
+        {
+            // Single-field group: default field is body only
+            let mut group = runner.new_group();
+            group.set_name(format!("{} — {}", view_name, label));
+            for query_str in queries {
                 add_bench_task(&mut group, &bench_index, query_str, Count, "count");
                 add_bench_task(
                     &mut group,
                     &bench_index,
                     query_str,
                     TopDocs::with_limit(10).order_by_score(),
-                    "top10_inv_idx",
+                    "top10",
                 );
-                add_bench_task(
-                    &mut group,
-                    &bench_index,
-                    query_str,
-                    (Count, TopDocs::with_limit(10).order_by_score()),
-                    "count+top10",
-                );
-
                 add_bench_task(
                     &mut group,
                     &bench_index,
@@ -203,47 +180,39 @@ fn main() {
                     )),
                     "top10_by_2ff",
                 );
-
-                group.run();
             }
+            group.run();
         }
     }
 }
 
-trait FruitCount {
-    fn count(&self) -> usize;
-}
-
-impl FruitCount for usize {
-    fn count(&self) -> usize {
-        *self
-    }
-}
-
-impl<T> FruitCount for Vec<T> {
-    fn count(&self) -> usize {
-        self.len()
-    }
-}
-
-impl<A: FruitCount, B> FruitCount for (A, B) {
-    fn count(&self) -> usize {
-        self.0.count()
-    }
-}
-
 fn add_bench_task<C: Collector + 'static>(
     bench_group: &mut BenchGroup,
     bench_index: &BenchIndex,
     query_str: &str,
     collector: C,
     collector_name: &str,
-) where
-    C::Fruit: FruitCount,
-{
+) {
+    let task_name = format!("{}_{}", query_str.replace(" ", "_"), collector_name);
     let query = bench_index.query_parser.parse_query(query_str).unwrap();
-    let searcher = bench_index.searcher.clone();
-    bench_group.register(collector_name.to_string(), move |_| {
-        black_box(searcher.search(&query, &collector).unwrap().count())
-    });
+    let search_task = SearchTask {
+        searcher: bench_index.searcher.clone(),
+        collector,
+        query,
+    };
+    bench_group.register(task_name, move |_| black_box(search_task.run()));
+}
+
+struct SearchTask<C: Collector> {
+    searcher: Searcher,
+    collector: C,
+    query: Box<dyn Query>,
+}
+
+impl<C: Collector> SearchTask<C> {
+    #[inline(never)]
+    pub fn run(&self) -> usize {
+        self.searcher.search(&self.query, &self.collector).unwrap();
+        1
+    }
 }

benches/bool_queries_with_range.rs

@@ -1,288 +0,0 @@
-use binggan::{black_box, BenchGroup, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::collector::{Collector, Count, DocSetCollector, TopDocs};
-use tantivy::query::{Query, QueryParser};
-use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
-use tantivy::{doc, Index, Order, ReloadPolicy, Searcher};
-
-#[derive(Clone)]
-struct BenchIndex {
-    #[allow(dead_code)]
-    index: Index,
-    searcher: Searcher,
-    query_parser: QueryParser,
-}
-
-fn build_shared_indices(num_docs: usize, p_title_a: f32, distribution: &str) -> BenchIndex {
-    // Unified schema
-    let mut schema_builder = Schema::builder();
-    let f_title = schema_builder.add_text_field("title", TEXT);
-    let f_num_rand = schema_builder.add_u64_field("num_rand", INDEXED);
-    let f_num_asc = schema_builder.add_u64_field("num_asc", INDEXED);
-    let f_num_rand_fast = schema_builder.add_u64_field("num_rand_fast", INDEXED | FAST);
-    let f_num_asc_fast = schema_builder.add_u64_field("num_asc_fast", INDEXED | FAST);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema.clone());
-
-    // Populate index with stable RNG for reproducibility.
-    let mut rng = StdRng::from_seed([7u8; 32]);
-
-    {
-        let mut writer = index.writer_with_num_threads(1, 4_000_000_000).unwrap();
-
-        match distribution {
-            "dense" => {
-                for doc_id in 0..num_docs {
-                    // Always add title to avoid empty documents
-                    let title_token = if rng.random_bool(p_title_a as f64) {
-                        "a"
-                    } else {
-                        "b"
-                    };
-
-                    let num_rand = rng.random_range(0u64..1000u64);
-
-                    let num_asc = (doc_id / 10000) as u64;
-
-                    writer
-                        .add_document(doc!(
-                            f_title=>title_token,
-                            f_num_rand=>num_rand,
-                            f_num_asc=>num_asc,
-                            f_num_rand_fast=>num_rand,
-                            f_num_asc_fast=>num_asc,
-                        ))
-                        .unwrap();
-                }
-            }
-            "sparse" => {
-                for doc_id in 0..num_docs {
-                    // Always add title to avoid empty documents
-                    let title_token = if rng.random_bool(p_title_a as f64) {
-                        "a"
-                    } else {
-                        "b"
-                    };
-
-                    let num_rand = rng.random_range(0u64..10000000u64);
-
-                    let num_asc = doc_id as u64;
-
-                    writer
-                        .add_document(doc!(
-                            f_title=>title_token,
-                            f_num_rand=>num_rand,
-                            f_num_asc=>num_asc,
-                            f_num_rand_fast=>num_rand,
-                            f_num_asc_fast=>num_asc,
-                        ))
-                        .unwrap();
-                }
-            }
-            _ => {
-                panic!("Unsupported distribution type");
-            }
-        }
-        writer.commit().unwrap();
-    }
-
-    // Prepare reader/searcher once.
-    let reader = index
-        .reader_builder()
-        .reload_policy(ReloadPolicy::Manual)
-        .try_into()
-        .unwrap();
-    let searcher = reader.searcher();
-
-    // Build query parser for title field
-    let qp_title = QueryParser::for_index(&index, vec![f_title]);
-
-    BenchIndex {
-        index,
-        searcher,
-        query_parser: qp_title,
-    }
-}
-
-fn main() {
-    // Prepare corpora with varying scenarios
-    let scenarios = vec![
-        (
-            "dense and 99% a".to_string(),
-            10_000_000,
-            0.99,
-            "dense",
-            0,
-            9,
-        ),
-        (
-            "dense and 99% a".to_string(),
-            10_000_000,
-            0.99,
-            "dense",
-            990,
-            999,
-        ),
-        (
-            "sparse and 99% a".to_string(),
-            10_000_000,
-            0.99,
-            "sparse",
-            0,
-            9,
-        ),
-        (
-            "sparse and 99% a".to_string(),
-            10_000_000,
-            0.99,
-            "sparse",
-            9_999_990,
-            9_999_999,
-        ),
-    ];
-
-    let mut runner = BenchRunner::new();
-    for (scenario_id, n, p_title_a, num_rand_distribution, range_low, range_high) in scenarios {
-        // Build index for this scenario
-        let bench_index = build_shared_indices(n, p_title_a, num_rand_distribution);
-
-        // Create benchmark group
-        let mut group = runner.new_group();
-
-        // Now set the name (this moves scenario_id)
-        group.set_name(scenario_id);
-
-        // Define all four field types
-        let field_names = ["num_rand", "num_asc", "num_rand_fast", "num_asc_fast"];
-
-        // Define the three terms we want to test with
-        let terms = ["a", "b", "z"];
-
-        // Generate all combinations of terms and field names
-        let mut queries = Vec::new();
-        for &term in &terms {
-            for &field_name in &field_names {
-                let query_str = format!(
-                    "{} AND {}:[{} TO {}]",
-                    term, field_name, range_low, range_high
-                );
-                queries.push((query_str, field_name.to_string()));
-            }
-        }
-
-        let query_str = format!(
-            "{}:[{} TO {}] AND {}:[{} TO {}]",
-            "num_rand_fast", range_low, range_high, "num_asc_fast", range_low, range_high
-        );
-        queries.push((query_str, "num_asc_fast".to_string()));
-
-        // Run all benchmark tasks for each query and its corresponding field name
-        for (query_str, field_name) in queries {
-            run_benchmark_tasks(&mut group, &bench_index, &query_str, &field_name);
-        }
-
-        group.run();
-    }
-}
-
-/// Run all benchmark tasks for a given query string and field name
-fn run_benchmark_tasks(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query_str: &str,
-    field_name: &str,
-) {
-    // Test count
-    add_bench_task(bench_group, bench_index, query_str, Count, "count");
-
-    // Test all results
-    add_bench_task(
-        bench_group,
-        bench_index,
-        query_str,
-        DocSetCollector,
-        "all results",
-    );
-
-    // Test top 100 by the field (if it's a FAST field)
-    if field_name.ends_with("_fast") {
-        // Ascending order
-        {
-            let collector_name = format!("top100_by_{}_asc", field_name);
-            let field_name_owned = field_name.to_string();
-            add_bench_task(
-                bench_group,
-                bench_index,
-                query_str,
-                TopDocs::with_limit(100).order_by_fast_field::<u64>(field_name_owned, Order::Asc),
-                &collector_name,
-            );
-        }
-
-        // Descending order
-        {
-            let collector_name = format!("top100_by_{}_desc", field_name);
-            let field_name_owned = field_name.to_string();
-            add_bench_task(
-                bench_group,
-                bench_index,
-                query_str,
-                TopDocs::with_limit(100).order_by_fast_field::<u64>(field_name_owned, Order::Desc),
-                &collector_name,
-            );
-        }
-    }
-}
-
-fn add_bench_task<C: Collector + 'static>(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query_str: &str,
-    collector: C,
-    collector_name: &str,
-) {
-    let task_name = format!("{}_{}", query_str.replace(" ", "_"), collector_name);
-    let query = bench_index.query_parser.parse_query(query_str).unwrap();
-    let search_task = SearchTask {
-        searcher: bench_index.searcher.clone(),
-        collector,
-        query,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-struct SearchTask<C: Collector> {
-    searcher: Searcher,
-    collector: C,
-    query: Box<dyn Query>,
-}
-
-impl<C: Collector> SearchTask<C> {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        let result = self.searcher.search(&self.query, &self.collector).unwrap();
-        if let Some(count) = (&result as &dyn std::any::Any).downcast_ref::<usize>() {
-            *count
-        } else if let Some(top_docs) = (&result as &dyn std::any::Any)
-            .downcast_ref::<Vec<(Option<u64>, tantivy::DocAddress)>>()
-        {
-            top_docs.len()
-        } else if let Some(top_docs) =
-            (&result as &dyn std::any::Any).downcast_ref::<Vec<(u64, tantivy::DocAddress)>>()
-        {
-            top_docs.len()
-        } else if let Some(doc_set) = (&result as &dyn std::any::Any)
-            .downcast_ref::<std::collections::HashSet<tantivy::DocAddress>>()
-        {
-            doc_set.len()
-        } else {
-            eprintln!(
-                "Unknown collector result type: {:?}",
-                std::any::type_name::<C::Fruit>()
-            );
-            0
-        }
-    }
-}

benches/intersection_bench.rs

@@ -1,149 +0,0 @@
-// Benchmarks top-K intersection of term scorers (block_wand_intersection).
-//
-// What's measured:
-// - Conjunctive queries (+a +b, +a +b +c) with top-10 by score
-// - Varying doc-frequency balance between terms (balanced, skewed, very skewed)
-// - Realistic term frequencies (geometric distribution, mostly low)
-// - 1M-doc single segment
-//
-// Run with: cargo bench --bench intersection_bench
-
-use binggan::{black_box, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::collector::TopDocs;
-use tantivy::query::QueryParser;
-use tantivy::schema::{Schema, TEXT};
-use tantivy::{doc, Index, ReloadPolicy, Searcher};
-
-const NUM_DOCS: usize = 1_000_000;
-
-struct BenchIndex {
-    searcher: Searcher,
-    query_parser: QueryParser,
-}
-
-/// Generate term frequency from a geometric-like distribution.
-/// Most values are 1, a few are 2-3, rarely higher.
-/// p controls the decay: higher p → more weight on tf=1.
-fn random_term_freq(rng: &mut StdRng, p: f64) -> u32 {
-    let mut tf = 1u32;
-    while tf < 10 && rng.random_bool(1.0 - p) {
-        tf += 1;
-    }
-    tf
-}
-
-/// Build an index with three terms (a, b, c) with given doc-frequency probabilities.
-/// Each term occurrence has a realistic term frequency (geometric distribution).
-/// Field length is padded with filler tokens to create varied fieldnorms.
-fn build_index(p_a: f64, p_b: f64, p_c: f64) -> BenchIndex {
-    let mut schema_builder = Schema::builder();
-    let body = schema_builder.add_text_field("body", TEXT);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema);
-
-    let mut rng = StdRng::from_seed([42u8; 32]);
-
-    {
-        let mut writer = index.writer_with_num_threads(1, 500_000_000).unwrap();
-        for _ in 0..NUM_DOCS {
-            let mut tokens: Vec<String> = Vec::new();
-
-            if rng.random_bool(p_a) {
-                let tf = random_term_freq(&mut rng, 0.7);
-                for _ in 0..tf {
-                    tokens.push("aaa".to_string());
-                }
-            }
-            if rng.random_bool(p_b) {
-                let tf = random_term_freq(&mut rng, 0.7);
-                for _ in 0..tf {
-                    tokens.push("bbb".to_string());
-                }
-            }
-            if rng.random_bool(p_c) {
-                let tf = random_term_freq(&mut rng, 0.7);
-                for _ in 0..tf {
-                    tokens.push("ccc".to_string());
-                }
-            }
-
-            // Pad with filler to create varied field lengths (5-30 tokens).
-            let filler_count = rng.random_range(5u32..30u32);
-            for _ in 0..filler_count {
-                tokens.push("filler".to_string());
-            }
-
-            let text = tokens.join(" ");
-            writer.add_document(doc!(body => text)).unwrap();
-        }
-        writer.commit().unwrap();
-    }
-
-    let reader = index
-        .reader_builder()
-        .reload_policy(ReloadPolicy::Manual)
-        .try_into()
-        .unwrap();
-    let searcher = reader.searcher();
-    let query_parser = QueryParser::for_index(&index, vec![body]);
-
-    BenchIndex {
-        searcher,
-        query_parser,
-    }
-}
-
-fn main() {
-    // Scenarios: (label, p_a, p_b, p_c)
-    //
-    // "balanced":    all terms ~10% → intersection ~1% of docs
-    // "skewed":      one common (50%), one rare (2%) → intersection ~1%
-    // "very_skewed": one very common (80%), one very rare (0.5%) → intersection ~0.4%
-    // "three_balanced": three terms ~20% each → intersection ~0.8%
-    // "three_skewed":   50% / 10% / 2% → intersection ~0.1%
-    let scenarios: Vec<(&str, f64, f64, f64)> = vec![
-        ("balanced_10%_10%", 0.10, 0.10, 0.0),
-        ("skewed_50%_2%", 0.50, 0.02, 0.0),
-        ("very_skewed_80%_0.5%", 0.80, 0.005, 0.0),
-        ("three_balanced_20%_20%_20%", 0.20, 0.20, 0.20),
-        ("three_skewed_50%_10%_2%", 0.50, 0.10, 0.02),
-    ];
-
-    let mut runner = BenchRunner::new();
-
-    for (label, p_a, p_b, p_c) in &scenarios {
-        let bench_index = build_index(*p_a, *p_b, *p_c);
-
-        let mut group = runner.new_group();
-        group.set_name(format!("intersection — {label}"));
-
-        // Two-term intersection
-        if *p_a > 0.0 && *p_b > 0.0 {
-            let query_str = "+aaa +bbb";
-            let query = bench_index.query_parser.parse_query(query_str).unwrap();
-            let searcher = bench_index.searcher.clone();
-            group.register(format!("{query_str} top10"), move |_| {
-                let collector = TopDocs::with_limit(10).order_by_score();
-                black_box(searcher.search(&query, &collector).unwrap());
-                1usize
-            });
-        }
-
-        // Three-term intersection
-        if *p_c > 0.0 {
-            let query_str = "+aaa +bbb +ccc";
-            let query = bench_index.query_parser.parse_query(query_str).unwrap();
-            let searcher = bench_index.searcher.clone();
-            group.register(format!("{query_str} top10"), move |_| {
-                let collector = TopDocs::with_limit(10).order_by_score();
-                black_box(searcher.search(&query, &collector).unwrap());
-                1usize
-            });
-        }
-
-        group.run();
-    }
-}

benches/merge_segments.rs

@@ -1,224 +0,0 @@
-// Benchmarks segment merging
-//
-// Notes:
-// - Input segments are kept intact (no deletes / no IndexWriter merge).
-// - Output is written to a `NullDirectory` that discards all files except
-//  fieldnorms (needed for merging).
-
-use std::collections::HashMap;
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, RwLock};
-
-use binggan::{black_box, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::directory::error::{DeleteError, OpenReadError, OpenWriteError};
-use tantivy::directory::{
-    AntiCallToken, Directory, FileHandle, OwnedBytes, TerminatingWrite, WatchCallback, WatchHandle,
-    WritePtr,
-};
-use tantivy::indexer::{merge_filtered_segments, NoMergePolicy};
-use tantivy::schema::{Schema, TEXT};
-use tantivy::{doc, HasLen, Index, IndexSettings, Segment};
-
-#[derive(Clone, Default, Debug)]
-struct NullDirectory {
-    blobs: Arc<RwLock<HashMap<PathBuf, OwnedBytes>>>,
-}
-
-struct NullWriter;
-
-impl Write for NullWriter {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl TerminatingWrite for NullWriter {
-    fn terminate_ref(&mut self, _token: AntiCallToken) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-struct InMemoryWriter {
-    path: PathBuf,
-    buffer: Vec<u8>,
-    blobs: Arc<RwLock<HashMap<PathBuf, OwnedBytes>>>,
-}
-
-impl Write for InMemoryWriter {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.buffer.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl TerminatingWrite for InMemoryWriter {
-    fn terminate_ref(&mut self, _token: AntiCallToken) -> io::Result<()> {
-        let bytes = OwnedBytes::new(std::mem::take(&mut self.buffer));
-        self.blobs.write().unwrap().insert(self.path.clone(), bytes);
-        Ok(())
-    }
-}
-
-#[derive(Debug, Default)]
-struct NullFileHandle;
-impl HasLen for NullFileHandle {
-    fn len(&self) -> usize {
-        0
-    }
-}
-impl FileHandle for NullFileHandle {
-    fn read_bytes(&self, _range: std::ops::Range<usize>) -> io::Result<OwnedBytes> {
-        unimplemented!()
-    }
-}
-
-impl Directory for NullDirectory {
-    fn get_file_handle(&self, path: &Path) -> Result<Arc<dyn FileHandle>, OpenReadError> {
-        if let Some(bytes) = self.blobs.read().unwrap().get(path) {
-            return Ok(Arc::new(bytes.clone()));
-        }
-        Ok(Arc::new(NullFileHandle))
-    }
-
-    fn delete(&self, _path: &Path) -> Result<(), DeleteError> {
-        Ok(())
-    }
-
-    fn exists(&self, _path: &Path) -> Result<bool, OpenReadError> {
-        Ok(true)
-    }
-
-    fn open_write(&self, path: &Path) -> Result<WritePtr, OpenWriteError> {
-        let path_buf = path.to_path_buf();
-        if path.to_string_lossy().ends_with(".fieldnorm") {
-            let writer = InMemoryWriter {
-                path: path_buf,
-                buffer: Vec::new(),
-                blobs: Arc::clone(&self.blobs),
-            };
-            Ok(io::BufWriter::new(Box::new(writer)))
-        } else {
-            Ok(io::BufWriter::new(Box::new(NullWriter)))
-        }
-    }
-
-    fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError> {
-        if let Some(bytes) = self.blobs.read().unwrap().get(path) {
-            return Ok(bytes.as_slice().to_vec());
-        }
-        Err(OpenReadError::FileDoesNotExist(path.to_path_buf()))
-    }
-
-    fn atomic_write(&self, _path: &Path, _data: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn sync_directory(&self) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn watch(&self, _watch_callback: WatchCallback) -> tantivy::Result<WatchHandle> {
-        Ok(WatchHandle::empty())
-    }
-}
-
-struct MergeScenario {
-    #[allow(dead_code)]
-    index: Index,
-    segments: Vec<Segment>,
-    settings: IndexSettings,
-    label: String,
-}
-
-fn build_index(
-    num_segments: usize,
-    docs_per_segment: usize,
-    tokens_per_doc: usize,
-    vocab_size: usize,
-) -> MergeScenario {
-    let mut schema_builder = Schema::builder();
-    let body = schema_builder.add_text_field("body", TEXT);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema.clone());
-
-    assert!(vocab_size > 0);
-    let total_tokens = num_segments * docs_per_segment * tokens_per_doc;
-    let use_unique_terms = vocab_size >= total_tokens;
-    let mut rng = StdRng::from_seed([7u8; 32]);
-    let mut next_token_id: u64 = 0;
-
-    {
-        let mut writer = index.writer_with_num_threads(1, 256_000_000).unwrap();
-        writer.set_merge_policy(Box::new(NoMergePolicy));
-        for _ in 0..num_segments {
-            for _ in 0..docs_per_segment {
-                let mut tokens = Vec::with_capacity(tokens_per_doc);
-                for _ in 0..tokens_per_doc {
-                    let token_id = if use_unique_terms {
-                        let id = next_token_id;
-                        next_token_id += 1;
-                        id
-                    } else {
-                        rng.random_range(0..vocab_size as u64)
-                    };
-                    tokens.push(format!("term_{token_id}"));
-                }
-                writer.add_document(doc!(body => tokens.join(" "))).unwrap();
-            }
-            writer.commit().unwrap();
-        }
-    }
-
-    let segments = index.searchable_segments().unwrap();
-    let settings = index.settings().clone();
-    let label = format!(
-        "segments={}, docs/seg={}, tokens/doc={}, vocab={}",
-        num_segments, docs_per_segment, tokens_per_doc, vocab_size
-    );
-
-    MergeScenario {
-        index,
-        segments,
-        settings,
-        label,
-    }
-}
-
-fn main() {
-    let scenarios = vec![
-        build_index(8, 50_000, 12, 8),
-        build_index(16, 50_000, 12, 8),
-        build_index(16, 100_000, 12, 8),
-        build_index(8, 50_000, 8, 8 * 50_000 * 8),
-    ];
-
-    let mut runner = BenchRunner::new();
-    for scenario in scenarios {
-        let mut group = runner.new_group();
-        group.set_name(format!("merge_segments inv_index — {}", scenario.label));
-        let segments = scenario.segments.clone();
-        let settings = scenario.settings.clone();
-        group.register("merge", move |_| {
-            let output_dir = NullDirectory::default();
-            let filter_doc_ids = vec![None; segments.len()];
-            let merged_index =
-                merge_filtered_segments(&segments, settings.clone(), filter_doc_ids, output_dir)
-                    .unwrap();
-            black_box(merged_index);
-        });
-
-        group.run();
-    }
-}

benches/query_parser_nested.rs

@@ -1,35 +0,0 @@
-// Benchmark for the query grammar parsing deeply nested queries.
-//
-// Regression guard for https://github.com/quickwit-oss/tantivy/issues/2498:
-// at depth 20/21 the old parser took 0.87 s / 1.72 s respectively because
-// `ast()` retried `occur_leaf` on backtrack, giving O(2^n) time. With the
-// fix parsing is linear and completes in microseconds.
-//
-// Run with: `cargo bench --bench query_parser_nested`.
-
-use binggan::{black_box, BenchRunner};
-use tantivy::query_grammar::parse_query;
-
-fn nested_query(depth: usize, leading_plus: bool) -> String {
-    let leading = "(".repeat(depth);
-    let trailing = ")".repeat(depth);
-    let prefix = if leading_plus { "+" } else { "" };
-    format!("{prefix}{leading}title:test{trailing}")
-}
-
-fn main() {
-    let mut runner = BenchRunner::new();
-
-    for depth in [20, 21] {
-        for leading_plus in [false, true] {
-            let query = nested_query(depth, leading_plus);
-            let label = format!(
-                "parse_nested_depth_{depth}_{}",
-                if leading_plus { "plus" } else { "plain" },
-            );
-            runner.bench_function(&label, move |_| {
-                black_box(parse_query(black_box(&query)).unwrap());
-            });
-        }
-    }
-}

benches/range_queries.rs

@@ -1,365 +0,0 @@
-use std::ops::Bound;
-
-use binggan::{black_box, BenchGroup, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::collector::{Count, DocSetCollector, TopDocs};
-use tantivy::query::RangeQuery;
-use tantivy::schema::{Schema, FAST, INDEXED};
-use tantivy::{doc, Index, Order, ReloadPolicy, Searcher, Term};
-
-#[derive(Clone)]
-struct BenchIndex {
-    #[allow(dead_code)]
-    index: Index,
-    searcher: Searcher,
-}
-
-fn build_shared_indices(num_docs: usize, distribution: &str) -> BenchIndex {
-    // Schema with fast fields only
-    let mut schema_builder = Schema::builder();
-    let f_num_rand_fast = schema_builder.add_u64_field("num_rand_fast", INDEXED | FAST);
-    let f_num_asc_fast = schema_builder.add_u64_field("num_asc_fast", INDEXED | FAST);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema.clone());
-
-    // Populate index with stable RNG for reproducibility.
-    let mut rng = StdRng::from_seed([7u8; 32]);
-
-    {
-        let mut writer = index.writer_with_num_threads(1, 4_000_000_000).unwrap();
-
-        match distribution {
-            "dense" => {
-                for doc_id in 0..num_docs {
-                    let num_rand = rng.random_range(0u64..1000u64);
-                    let num_asc = (doc_id / 10000) as u64;
-
-                    writer
-                        .add_document(doc!(
-                            f_num_rand_fast=>num_rand,
-                            f_num_asc_fast=>num_asc,
-                        ))
-                        .unwrap();
-                }
-            }
-            "sparse" => {
-                for doc_id in 0..num_docs {
-                    let num_rand = rng.random_range(0u64..10000000u64);
-                    let num_asc = doc_id as u64;
-
-                    writer
-                        .add_document(doc!(
-                            f_num_rand_fast=>num_rand,
-                            f_num_asc_fast=>num_asc,
-                        ))
-                        .unwrap();
-                }
-            }
-            _ => {
-                panic!("Unsupported distribution type");
-            }
-        }
-        writer.commit().unwrap();
-    }
-
-    // Prepare reader/searcher once.
-    let reader = index
-        .reader_builder()
-        .reload_policy(ReloadPolicy::Manual)
-        .try_into()
-        .unwrap();
-    let searcher = reader.searcher();
-
-    BenchIndex { index, searcher }
-}
-
-fn main() {
-    // Prepare corpora with varying scenarios
-    let scenarios = vec![
-        // Dense distribution - random values in small range (0-999)
-        (
-            "dense_values_search_low_value_range".to_string(),
-            10_000_000,
-            "dense",
-            0,
-            9,
-        ),
-        (
-            "dense_values_search_high_value_range".to_string(),
-            10_000_000,
-            "dense",
-            990,
-            999,
-        ),
-        (
-            "dense_values_search_out_of_range".to_string(),
-            10_000_000,
-            "dense",
-            1000,
-            1002,
-        ),
-        (
-            "sparse_values_search_low_value_range".to_string(),
-            10_000_000,
-            "sparse",
-            0,
-            9,
-        ),
-        (
-            "sparse_values_search_high_value_range".to_string(),
-            10_000_000,
-            "sparse",
-            9_999_990,
-            9_999_999,
-        ),
-        (
-            "sparse_values_search_out_of_range".to_string(),
-            10_000_000,
-            "sparse",
-            10_000_000,
-            10_000_002,
-        ),
-    ];
-
-    let mut runner = BenchRunner::new();
-    for (scenario_id, n, num_rand_distribution, range_low, range_high) in scenarios {
-        // Build index for this scenario
-        let bench_index = build_shared_indices(n, num_rand_distribution);
-
-        // Create benchmark group
-        let mut group = runner.new_group();
-
-        // Now set the name (this moves scenario_id)
-        group.set_name(scenario_id);
-
-        // Define fast field types
-        let field_names = ["num_rand_fast", "num_asc_fast"];
-
-        // Generate range queries for fast fields
-        for &field_name in &field_names {
-            // Create the range query
-            let field = bench_index.searcher.schema().get_field(field_name).unwrap();
-            let lower_term = Term::from_field_u64(field, range_low);
-            let upper_term = Term::from_field_u64(field, range_high);
-
-            let query = RangeQuery::new(Bound::Included(lower_term), Bound::Included(upper_term));
-
-            run_benchmark_tasks(
-                &mut group,
-                &bench_index,
-                query,
-                field_name,
-                range_low,
-                range_high,
-            );
-        }
-
-        group.run();
-    }
-}
-
-/// Run all benchmark tasks for a given range query and field name
-fn run_benchmark_tasks(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    field_name: &str,
-    range_low: u64,
-    range_high: u64,
-) {
-    // Test count
-    add_bench_task_count(
-        bench_group,
-        bench_index,
-        query.clone(),
-        "count",
-        field_name,
-        range_low,
-        range_high,
-    );
-
-    // Test top 100 by the field (ascending order)
-    {
-        let collector_name = format!("top100_by_{}_asc", field_name);
-        let field_name_owned = field_name.to_string();
-        add_bench_task_top100_asc(
-            bench_group,
-            bench_index,
-            query.clone(),
-            &collector_name,
-            field_name,
-            range_low,
-            range_high,
-            field_name_owned,
-        );
-    }
-
-    // Test top 100 by the field (descending order)
-    {
-        let collector_name = format!("top100_by_{}_desc", field_name);
-        let field_name_owned = field_name.to_string();
-        add_bench_task_top100_desc(
-            bench_group,
-            bench_index,
-            query,
-            &collector_name,
-            field_name,
-            range_low,
-            range_high,
-            field_name_owned,
-        );
-    }
-}
-
-fn add_bench_task_count(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    collector_name: &str,
-    field_name: &str,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!(
-        "range_{}_[{} TO {}]_{}",
-        field_name, range_low, range_high, collector_name
-    );
-
-    let search_task = CountSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-fn add_bench_task_docset(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    collector_name: &str,
-    field_name: &str,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!(
-        "range_{}_[{} TO {}]_{}",
-        field_name, range_low, range_high, collector_name
-    );
-
-    let search_task = DocSetSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-fn add_bench_task_top100_asc(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    collector_name: &str,
-    field_name: &str,
-    range_low: u64,
-    range_high: u64,
-    field_name_owned: String,
-) {
-    let task_name = format!(
-        "range_{}_[{} TO {}]_{}",
-        field_name, range_low, range_high, collector_name
-    );
-
-    let search_task = Top100AscSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-        field_name: field_name_owned,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-fn add_bench_task_top100_desc(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    collector_name: &str,
-    field_name: &str,
-    range_low: u64,
-    range_high: u64,
-    field_name_owned: String,
-) {
-    let task_name = format!(
-        "range_{}_[{} TO {}]_{}",
-        field_name, range_low, range_high, collector_name
-    );
-
-    let search_task = Top100DescSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-        field_name: field_name_owned,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-struct CountSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl CountSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        self.searcher.search(&self.query, &Count).unwrap()
-    }
-}
-
-struct DocSetSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl DocSetSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        let result = self.searcher.search(&self.query, &DocSetCollector).unwrap();
-        result.len()
-    }
-}
-
-struct Top100AscSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-    field_name: String,
-}
-
-impl Top100AscSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        let collector =
-            TopDocs::with_limit(100).order_by_fast_field::<u64>(&self.field_name, Order::Asc);
-        let result = self.searcher.search(&self.query, &collector).unwrap();
-        for (_score, doc_address) in &result {
-            let _doc: tantivy::TantivyDocument = self.searcher.doc(*doc_address).unwrap();
-        }
-        result.len()
-    }
-}
-
-struct Top100DescSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-    field_name: String,
-}
-
-impl Top100DescSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        let collector =
-            TopDocs::with_limit(100).order_by_fast_field::<u64>(&self.field_name, Order::Desc);
-        let result = self.searcher.search(&self.query, &collector).unwrap();
-        for (_score, doc_address) in &result {
-            let _doc: tantivy::TantivyDocument = self.searcher.doc(*doc_address).unwrap();
-        }
-        result.len()
-    }
-}

benches/range_query.rs

@@ -1,260 +0,0 @@
-use std::fmt::Display;
-use std::net::Ipv6Addr;
-use std::ops::RangeInclusive;
-
-use binggan::plugins::PeakMemAllocPlugin;
-use binggan::{black_box, BenchRunner, OutputValue, PeakMemAlloc, INSTRUMENTED_SYSTEM};
-use columnar::MonotonicallyMappableToU128;
-use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
-use tantivy::collector::{Count, TopDocs};
-use tantivy::query::QueryParser;
-use tantivy::schema::*;
-use tantivy::{doc, Index};
-
-#[global_allocator]
-pub static GLOBAL: &PeakMemAlloc<std::alloc::System> = &INSTRUMENTED_SYSTEM;
-
-fn main() {
-    bench_range_query();
-}
-
-fn bench_range_query() {
-    let index = get_index_0_to_100();
-    let mut runner = BenchRunner::new();
-    runner.add_plugin(PeakMemAllocPlugin::new(GLOBAL));
-
-    runner.set_name("range_query on u64");
-    let field_name_and_descr: Vec<_> = vec![
-        ("id", "Single Valued Range Field"),
-        ("ids", "Multi Valued Range Field"),
-    ];
-    let range_num_hits = vec![
-        ("90_percent", get_90_percent()),
-        ("10_percent", get_10_percent()),
-        ("1_percent", get_1_percent()),
-    ];
-
-    test_range(&mut runner, &index, &field_name_and_descr, range_num_hits);
-
-    runner.set_name("range_query on ip");
-    let field_name_and_descr: Vec<_> = vec![
-        ("ip", "Single Valued Range Field"),
-        ("ips", "Multi Valued Range Field"),
-    ];
-    let range_num_hits = vec![
-        ("90_percent", get_90_percent_ip()),
-        ("10_percent", get_10_percent_ip()),
-        ("1_percent", get_1_percent_ip()),
-    ];
-
-    test_range(&mut runner, &index, &field_name_and_descr, range_num_hits);
-}
-
-fn test_range<T: Display>(
-    runner: &mut BenchRunner,
-    index: &Index,
-    field_name_and_descr: &[(&str, &str)],
-    range_num_hits: Vec<(&str, RangeInclusive<T>)>,
-) {
-    for (field, suffix) in field_name_and_descr {
-        let term_num_hits = vec![
-            ("", ""),
-            ("1_percent", "veryfew"),
-            ("10_percent", "few"),
-            ("90_percent", "most"),
-        ];
-        let mut group = runner.new_group();
-        group.set_name(suffix);
-        // all intersect combinations
-        for (range_name, range) in &range_num_hits {
-            for (term_name, term) in &term_num_hits {
-                let index = &index;
-                let test_name = if term_name.is_empty() {
-                    format!("id_range_hit_{}", range_name)
-                } else {
-                    format!(
-                        "id_range_hit_{}_intersect_with_term_{}",
-                        range_name, term_name
-                    )
-                };
-                group.register(test_name, move |_| {
-                    let query = if term_name.is_empty() {
-                        "".to_string()
-                    } else {
-                        format!("AND id_name:{}", term)
-                    };
-                    black_box(execute_query(field, range, &query, index));
-                });
-            }
-        }
-        group.run();
-    }
-}
-
-fn get_index_0_to_100() -> Index {
-    let mut rng = StdRng::from_seed([1u8; 32]);
-    let num_vals = 100_000;
-    let docs: Vec<_> = (0..num_vals)
-        .map(|_i| {
-            let id_name = if rng.random_bool(0.01) {
-                "veryfew".to_string() // 1%
-            } else if rng.random_bool(0.1) {
-                "few".to_string() // 9%
-            } else {
-                "most".to_string() // 90%
-            };
-            Doc {
-                id_name,
-                id: rng.random_range(0..100),
-                // Multiply by 1000, so that we create most buckets in the compact space
-                // The benches depend on this range to select n-percent of elements with the
-                // methods below.
-                ip: Ipv6Addr::from_u128(rng.random_range(0..100) * 1000),
-            }
-        })
-        .collect();
-
-    create_index_from_docs(&docs)
-}
-
-#[derive(Clone, Debug)]
-pub struct Doc {
-    pub id_name: String,
-    pub id: u64,
-    pub ip: Ipv6Addr,
-}
-
-pub fn create_index_from_docs(docs: &[Doc]) -> Index {
-    let mut schema_builder = Schema::builder();
-    let id_u64_field = schema_builder.add_u64_field("id", INDEXED | STORED | FAST);
-    let ids_u64_field =
-        schema_builder.add_u64_field("ids", NumericOptions::default().set_fast().set_indexed());
-
-    let id_f64_field = schema_builder.add_f64_field("id_f64", INDEXED | STORED | FAST);
-    let ids_f64_field = schema_builder.add_f64_field(
-        "ids_f64",
-        NumericOptions::default().set_fast().set_indexed(),
-    );
-
-    let id_i64_field = schema_builder.add_i64_field("id_i64", INDEXED | STORED | FAST);
-    let ids_i64_field = schema_builder.add_i64_field(
-        "ids_i64",
-        NumericOptions::default().set_fast().set_indexed(),
-    );
-
-    let text_field = schema_builder.add_text_field("id_name", STRING | STORED);
-    let text_field2 = schema_builder.add_text_field("id_name_fast", STRING | STORED | FAST);
-
-    let ip_field = schema_builder.add_ip_addr_field("ip", FAST);
-    let ips_field = schema_builder.add_ip_addr_field("ips", FAST);
-
-    let schema = schema_builder.build();
-
-    let index = Index::create_in_ram(schema);
-
-    {
-        let mut index_writer = index.writer_with_num_threads(1, 50_000_000).unwrap();
-        for doc in docs.iter() {
-            index_writer
-                .add_document(doc!(
-                    ids_i64_field => doc.id as i64,
-                    ids_i64_field => doc.id as i64,
-                    ids_f64_field => doc.id as f64,
-                    ids_f64_field => doc.id as f64,
-                    ids_u64_field => doc.id,
-                    ids_u64_field => doc.id,
-                    id_u64_field => doc.id,
-                    id_f64_field => doc.id as f64,
-                    id_i64_field => doc.id as i64,
-                    text_field => doc.id_name.to_string(),
-                    text_field2 => doc.id_name.to_string(),
-                    ips_field => doc.ip,
-                    ips_field => doc.ip,
-                    ip_field => doc.ip,
-                ))
-                .unwrap();
-        }
-
-        index_writer.commit().unwrap();
-    }
-    index
-}
-
-fn get_90_percent() -> RangeInclusive<u64> {
-    0..=90
-}
-
-fn get_10_percent() -> RangeInclusive<u64> {
-    0..=10
-}
-
-fn get_1_percent() -> RangeInclusive<u64> {
-    10..=10
-}
-
-fn get_90_percent_ip() -> RangeInclusive<Ipv6Addr> {
-    let start = Ipv6Addr::from_u128(0);
-    let end = Ipv6Addr::from_u128(90 * 1000);
-    start..=end
-}
-
-fn get_10_percent_ip() -> RangeInclusive<Ipv6Addr> {
-    let start = Ipv6Addr::from_u128(0);
-    let end = Ipv6Addr::from_u128(10 * 1000);
-    start..=end
-}
-
-fn get_1_percent_ip() -> RangeInclusive<Ipv6Addr> {
-    let start = Ipv6Addr::from_u128(10 * 1000);
-    let end = Ipv6Addr::from_u128(10 * 1000);
-    start..=end
-}
-
-struct NumHits {
-    count: usize,
-}
-impl OutputValue for NumHits {
-    fn column_title() -> &'static str {
-        "NumHits"
-    }
-    fn format(&self) -> Option<String> {
-        Some(self.count.to_string())
-    }
-}
-
-fn execute_query<T: Display>(
-    field: &str,
-    id_range: &RangeInclusive<T>,
-    suffix: &str,
-    index: &Index,
-) -> NumHits {
-    let gen_query_inclusive = |from: &T, to: &T| {
-        format!(
-            "{}:[{} TO {}] {}",
-            field,
-            &from.to_string(),
-            &to.to_string(),
-            suffix
-        )
-    };
-
-    let query = gen_query_inclusive(id_range.start(), id_range.end());
-    execute_query_(&query, index)
-}
-
-fn execute_query_(query: &str, index: &Index) -> NumHits {
-    let query_from_text = |text: &str| {
-        QueryParser::for_index(index, vec![])
-            .parse_query(text)
-            .unwrap()
-    };
-    let query = query_from_text(query);
-    let reader = index.reader().unwrap();
-    let searcher = reader.searcher();
-    let num_hits = searcher
-        .search(&query, &(TopDocs::with_limit(10).order_by_score(), Count))
-        .unwrap()
-        .1;
-    NumHits { count: num_hits }
-}

benches/regex_all_terms.rs

@@ -1,113 +0,0 @@
-// Benchmarks regex query that matches all terms in a synthetic index.
-//
-// Corpus model:
-// - N unique terms: t000000, t000001, ...
-// - M docs
-// - K tokens per doc: doc i gets terms derived from (i, token_index)
-//
-// Query:
-// - Regex "t.*" to match all terms
-//
-// Run with:
-// - cargo bench --bench regex_all_terms
-//
-
-use std::fmt::Write;
-
-use binggan::{black_box, BenchRunner};
-use tantivy::collector::Count;
-use tantivy::query::RegexQuery;
-use tantivy::schema::{Schema, TEXT};
-use tantivy::{doc, Index, ReloadPolicy};
-
-const HEAP_SIZE_BYTES: usize = 200_000_000;
-
-#[derive(Clone, Copy)]
-struct BenchConfig {
-    num_terms: usize,
-    num_docs: usize,
-    tokens_per_doc: usize,
-}
-
-fn main() {
-    let configs = default_configs();
-
-    let mut runner = BenchRunner::new();
-    for config in configs {
-        let (index, text_field) = build_index(config, HEAP_SIZE_BYTES);
-        let reader = index
-            .reader_builder()
-            .reload_policy(ReloadPolicy::Manual)
-            .try_into()
-            .expect("reader");
-        let searcher = reader.searcher();
-        let query = RegexQuery::from_pattern("t.*", text_field).expect("regex query");
-
-        let mut group = runner.new_group();
-        group.set_name(format!(
-            "regex_all_terms_t{}_d{}_k{}",
-            config.num_terms, config.num_docs, config.tokens_per_doc
-        ));
-        group.register("regex_count", move |_| {
-            let count = searcher.search(&query, &Count).expect("search");
-            black_box(count);
-        });
-        group.run();
-    }
-}
-
-fn default_configs() -> Vec<BenchConfig> {
-    vec![
-        BenchConfig {
-            num_terms: 10_000,
-            num_docs: 100_000,
-            tokens_per_doc: 1,
-        },
-        BenchConfig {
-            num_terms: 10_000,
-            num_docs: 100_000,
-            tokens_per_doc: 8,
-        },
-        BenchConfig {
-            num_terms: 100_000,
-            num_docs: 100_000,
-            tokens_per_doc: 1,
-        },
-        BenchConfig {
-            num_terms: 100_000,
-            num_docs: 100_000,
-            tokens_per_doc: 8,
-        },
-    ]
-}
-
-fn build_index(config: BenchConfig, heap_size_bytes: usize) -> (Index, tantivy::schema::Field) {
-    let mut schema_builder = Schema::builder();
-    let text_field = schema_builder.add_text_field("text", TEXT);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema);
-
-    let term_width = config.num_terms.to_string().len();
-    {
-        let mut writer = index
-            .writer_with_num_threads(1, heap_size_bytes)
-            .expect("writer");
-        let mut buffer = String::new();
-        for doc_id in 0..config.num_docs {
-            buffer.clear();
-            for token_idx in 0..config.tokens_per_doc {
-                if token_idx > 0 {
-                    buffer.push(' ');
-                }
-                let term_id = (doc_id * config.tokens_per_doc + token_idx) % config.num_terms;
-                write!(&mut buffer, "t{term_id:0term_width$}").expect("write token");
-            }
-            writer
-                .add_document(doc!(text_field => buffer.as_str()))
-                .expect("add_document");
-        }
-        writer.commit().expect("commit");
-    }
-
-    (index, text_field)
-}

benches/str_search_and_get.rs

@@ -1,421 +0,0 @@
-// This benchmark compares different approaches for retrieving string values:
-//
-// 1. Fast Field Approach: retrieves string values via term_ords() and ord_to_str()
-//
-// 2. Doc Store Approach: retrieves string values via searcher.doc() and field extraction
-//
-// The benchmark includes various data distributions:
-// - Dense Sequential: Sequential document IDs with dense data
-// - Dense Random: Random document IDs with dense data
-// - Sparse Sequential: Sequential document IDs with sparse data
-// - Sparse Random: Random document IDs with sparse data
-use std::ops::Bound;
-
-use binggan::{black_box, BenchGroup, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::collector::{Count, DocSetCollector};
-use tantivy::query::RangeQuery;
-use tantivy::schema::document::TantivyDocument;
-use tantivy::schema::{Schema, Value, FAST, STORED, STRING};
-use tantivy::{doc, Index, ReloadPolicy, Searcher, Term};
-
-#[derive(Clone)]
-struct BenchIndex {
-    #[allow(dead_code)]
-    index: Index,
-    searcher: Searcher,
-}
-
-fn build_shared_indices(num_docs: usize, distribution: &str) -> BenchIndex {
-    // Schema with string fast field and stored field for doc access
-    let mut schema_builder = Schema::builder();
-    let f_str_fast = schema_builder.add_text_field("str_fast", STRING | STORED | FAST);
-    let f_str_stored = schema_builder.add_text_field("str_stored", STRING | STORED);
-    let schema = schema_builder.build();
-    let index = Index::create_in_ram(schema.clone());
-
-    // Populate index with stable RNG for reproducibility.
-    let mut rng = StdRng::from_seed([7u8; 32]);
-
-    {
-        let mut writer = index.writer_with_num_threads(1, 4_000_000_000).unwrap();
-
-        match distribution {
-            "dense_random" => {
-                for _doc_id in 0..num_docs {
-                    let suffix = rng.random_range(0u64..1000u64);
-                    let str_val = format!("str_{:03}", suffix);
-
-                    writer
-                        .add_document(doc!(
-                            f_str_fast=>str_val.clone(),
-                            f_str_stored=>str_val,
-                        ))
-                        .unwrap();
-                }
-            }
-            "dense_sequential" => {
-                for doc_id in 0..num_docs {
-                    let suffix = doc_id as u64 % 1000;
-                    let str_val = format!("str_{:03}", suffix);
-
-                    writer
-                        .add_document(doc!(
-                            f_str_fast=>str_val.clone(),
-                            f_str_stored=>str_val,
-                        ))
-                        .unwrap();
-                }
-            }
-            "sparse_random" => {
-                for _doc_id in 0..num_docs {
-                    let suffix = rng.random_range(0u64..1000000u64);
-                    let str_val = format!("str_{:07}", suffix);
-
-                    writer
-                        .add_document(doc!(
-                            f_str_fast=>str_val.clone(),
-                            f_str_stored=>str_val,
-                        ))
-                        .unwrap();
-                }
-            }
-            "sparse_sequential" => {
-                for doc_id in 0..num_docs {
-                    let suffix = doc_id as u64;
-                    let str_val = format!("str_{:07}", suffix);
-
-                    writer
-                        .add_document(doc!(
-                            f_str_fast=>str_val.clone(),
-                            f_str_stored=>str_val,
-                        ))
-                        .unwrap();
-                }
-            }
-            _ => {
-                panic!("Unsupported distribution type");
-            }
-        }
-        writer.commit().unwrap();
-    }
-
-    // Prepare reader/searcher once.
-    let reader = index
-        .reader_builder()
-        .reload_policy(ReloadPolicy::Manual)
-        .try_into()
-        .unwrap();
-    let searcher = reader.searcher();
-
-    BenchIndex { index, searcher }
-}
-
-fn main() {
-    // Prepare corpora with varying scenarios
-    let scenarios = vec![
-        (
-            "dense_random_search_low_range".to_string(),
-            1_000_000,
-            "dense_random",
-            0,
-            9,
-        ),
-        (
-            "dense_random_search_high_range".to_string(),
-            1_000_000,
-            "dense_random",
-            990,
-            999,
-        ),
-        (
-            "dense_sequential_search_low_range".to_string(),
-            1_000_000,
-            "dense_sequential",
-            0,
-            9,
-        ),
-        (
-            "dense_sequential_search_high_range".to_string(),
-            1_000_000,
-            "dense_sequential",
-            990,
-            999,
-        ),
-        (
-            "sparse_random_search_low_range".to_string(),
-            1_000_000,
-            "sparse_random",
-            0,
-            9999,
-        ),
-        (
-            "sparse_random_search_high_range".to_string(),
-            1_000_000,
-            "sparse_random",
-            990_000,
-            999_999,
-        ),
-        (
-            "sparse_sequential_search_low_range".to_string(),
-            1_000_000,
-            "sparse_sequential",
-            0,
-            9999,
-        ),
-        (
-            "sparse_sequential_search_high_range".to_string(),
-            1_000_000,
-            "sparse_sequential",
-            990_000,
-            999_999,
-        ),
-    ];
-
-    let mut runner = BenchRunner::new();
-    for (scenario_id, n, distribution, range_low, range_high) in scenarios {
-        let bench_index = build_shared_indices(n, distribution);
-        let mut group = runner.new_group();
-        group.set_name(scenario_id);
-
-        let field = bench_index.searcher.schema().get_field("str_fast").unwrap();
-
-        let (lower_str, upper_str) =
-            if distribution == "dense_sequential" || distribution == "dense_random" {
-                (
-                    format!("str_{:03}", range_low),
-                    format!("str_{:03}", range_high),
-                )
-            } else {
-                (
-                    format!("str_{:07}", range_low),
-                    format!("str_{:07}", range_high),
-                )
-            };
-
-        let lower_term = Term::from_field_text(field, &lower_str);
-        let upper_term = Term::from_field_text(field, &upper_str);
-
-        let query = RangeQuery::new(Bound::Included(lower_term), Bound::Included(upper_term));
-
-        run_benchmark_tasks(&mut group, &bench_index, query, range_low, range_high);
-
-        group.run();
-    }
-}
-
-/// Run all benchmark tasks for a given range query
-fn run_benchmark_tasks(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    range_low: u64,
-    range_high: u64,
-) {
-    // Test count of matching documents
-    add_bench_task_count(
-        bench_group,
-        bench_index,
-        query.clone(),
-        range_low,
-        range_high,
-    );
-
-    // Test fetching all DocIds of matching documents
-    add_bench_task_docset(
-        bench_group,
-        bench_index,
-        query.clone(),
-        range_low,
-        range_high,
-    );
-
-    // Test fetching all string fast field values of matching documents
-    add_bench_task_fetch_all_strings(
-        bench_group,
-        bench_index,
-        query.clone(),
-        range_low,
-        range_high,
-    );
-
-    // Test fetching all string values of matching documents through doc() method
-    add_bench_task_fetch_all_strings_from_doc(
-        bench_group,
-        bench_index,
-        query,
-        range_low,
-        range_high,
-    );
-}
-
-fn add_bench_task_count(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!("string_search_count_[{}-{}]", range_low, range_high);
-
-    let search_task = CountSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-fn add_bench_task_docset(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!("string_fetch_all_docset_[{}-{}]", range_low, range_high);
-
-    let search_task = DocSetSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-    bench_group.register(task_name, move |_| black_box(search_task.run()));
-}
-
-fn add_bench_task_fetch_all_strings(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!(
-        "string_fastfield_fetch_all_strings_[{}-{}]",
-        range_low, range_high
-    );
-
-    let search_task = FetchAllStringsSearchTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-
-    bench_group.register(task_name, move |_| {
-        let result = black_box(search_task.run());
-        result.len()
-    });
-}
-
-fn add_bench_task_fetch_all_strings_from_doc(
-    bench_group: &mut BenchGroup,
-    bench_index: &BenchIndex,
-    query: RangeQuery,
-    range_low: u64,
-    range_high: u64,
-) {
-    let task_name = format!(
-        "string_doc_fetch_all_strings_[{}-{}]",
-        range_low, range_high
-    );
-
-    let search_task = FetchAllStringsFromDocTask {
-        searcher: bench_index.searcher.clone(),
-        query,
-    };
-
-    bench_group.register(task_name, move |_| {
-        let result = black_box(search_task.run());
-        result.len()
-    });
-}
-
-struct CountSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl CountSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        self.searcher.search(&self.query, &Count).unwrap()
-    }
-}
-
-struct DocSetSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl DocSetSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> usize {
-        let result = self.searcher.search(&self.query, &DocSetCollector).unwrap();
-        result.len()
-    }
-}
-
-struct FetchAllStringsSearchTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl FetchAllStringsSearchTask {
-    #[inline(never)]
-    pub fn run(&self) -> Vec<String> {
-        let doc_addresses = self.searcher.search(&self.query, &DocSetCollector).unwrap();
-        let mut docs = doc_addresses.into_iter().collect::<Vec<_>>();
-        docs.sort();
-        let mut strings = Vec::with_capacity(docs.len());
-
-        for doc_address in docs {
-            let segment_reader = &self.searcher.segment_readers()[doc_address.segment_ord as usize];
-            let str_column_opt = segment_reader.fast_fields().str("str_fast");
-
-            if let Ok(Some(str_column)) = str_column_opt {
-                let doc_id = doc_address.doc_id;
-                let term_ord = str_column.term_ords(doc_id).next().unwrap();
-                let mut str_buffer = String::new();
-                if str_column.ord_to_str(term_ord, &mut str_buffer).is_ok() {
-                    strings.push(str_buffer);
-                }
-            }
-        }
-
-        strings
-    }
-}
-
-struct FetchAllStringsFromDocTask {
-    searcher: Searcher,
-    query: RangeQuery,
-}
-
-impl FetchAllStringsFromDocTask {
-    #[inline(never)]
-    pub fn run(&self) -> Vec<String> {
-        let doc_addresses = self.searcher.search(&self.query, &DocSetCollector).unwrap();
-        let mut docs = doc_addresses.into_iter().collect::<Vec<_>>();
-        docs.sort();
-        let mut strings = Vec::with_capacity(docs.len());
-
-        let str_stored_field = self
-            .searcher
-            .schema()
-            .get_field("str_stored")
-            .expect("str_stored field should exist");
-
-        for doc_address in docs {
-            // Get the document from the doc store (row store access)
-            if let Ok(doc) = self.searcher.doc::<TantivyDocument>(doc_address) {
-                // Extract string values from the stored field
-                if let Some(field_value) = doc.get_first(str_stored_field) {
-                    if let Some(text) = field_value.as_value().as_str() {
-                        strings.push(text.to_string());
-                    }
-                }
-            }
-        }
-
-        strings
-    }
-}

bitpacker/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-bitpacker"
-version = "0.10.0"
+version = "0.9.0"
 edition = "2024"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
@@ -11,12 +11,9 @@ keywords = []
 documentation = "https://docs.rs/tantivy-bitpacker/latest/tantivy_bitpacker"
 homepage = "https://github.com/quickwit-oss/tantivy"
 
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 bitpacking = { version = "0.9.2", default-features = false, features = ["bitpacker1x"] }
 
 [dev-dependencies]
-rand = "0.9"
+rand = "0.8"
 proptest = "1"

bitpacker/benches/bench.rs

@@ -4,8 +4,8 @@ extern crate test;
 
 #[cfg(test)]
 mod tests {
-    use rand::rng;
     use rand::seq::IteratorRandom;
+    use rand::thread_rng;
     use tantivy_bitpacker::{BitPacker, BitUnpacker, BlockedBitpacker};
     use test::Bencher;
 
@@ -27,7 +27,7 @@ mod tests {
         let num_els = 1_000_000u32;
         let bit_unpacker = BitUnpacker::new(bit_width);
         let data = create_bitpacked_data(bit_width, num_els);
-        let idxs: Vec<u32> = (0..num_els).choose_multiple(&mut rng(), 100_000);
+        let idxs: Vec<u32> = (0..num_els).choose_multiple(&mut thread_rng(), 100_000);
         b.iter(|| {
             let mut out = 0u64;
             for &idx in &idxs {

bitpacker/src/bitpacker.rs

@@ -48,7 +48,7 @@ impl BitPacker {
 
     pub fn flush<TWrite: io::Write + ?Sized>(&mut self, output: &mut TWrite) -> io::Result<()> {
         if self.mini_buffer_written > 0 {
-            let num_bytes = self.mini_buffer_written.div_ceil(8);
+            let num_bytes = (self.mini_buffer_written + 7) / 8;
             let bytes = self.mini_buffer.to_le_bytes();
             output.write_all(&bytes[..num_bytes])?;
             self.mini_buffer_written = 0;
@@ -65,10 +65,16 @@ impl BitPacker {
 
 #[derive(Clone, Debug, Default, Copy)]
 pub struct BitUnpacker {
-    num_bits: usize,
+    num_bits: u32,
     mask: u64,
 }
 
+pub type BlockNumber = usize;
+
+// 16k
+const BLOCK_SIZE_MIN_POW: u8 = 14;
+const BLOCK_SIZE_MIN: usize = 2 << BLOCK_SIZE_MIN_POW;
+
 impl BitUnpacker {
     /// Creates a bit unpacker, that assumes the same bitwidth for all values.
     ///
@@ -82,8 +88,9 @@ impl BitUnpacker {
         } else {
             (1u64 << num_bits) - 1u64
         };
+
         BitUnpacker {
-            num_bits: usize::from(num_bits),
+            num_bits: u32::from(num_bits),
             mask,
         }
     }
@@ -92,16 +99,69 @@ impl BitUnpacker {
         self.num_bits as u8
     }
 
+    /// Calculates a block number for the given `idx`.
+    #[inline]
+    pub fn block_num(&self, idx: u32) -> BlockNumber {
+        // Find the address in bits of the index.
+        let addr_in_bits = (idx * self.num_bits) as usize;
+
+        // Then round down to the nearest byte.
+        let addr_in_bytes = addr_in_bits >> 3;
+
+        // And compute the containing BlockNumber.
+        addr_in_bytes >> (BLOCK_SIZE_MIN_POW + 1)
+    }
+
+    /// Given a block number and dataset length, calculates a data Range for the block.
+    pub fn block(&self, block: BlockNumber, data_len: usize) -> Range<usize> {
+        let block_addr = block << (BLOCK_SIZE_MIN_POW + 1);
+        // We extend the end of the block by a constant factor, so that it overlaps the next
+        // block. That ensures that we never need to read on a block boundary.
+        block_addr..(std::cmp::min(block_addr + BLOCK_SIZE_MIN + 8, data_len))
+    }
+
+    /// Calculates the number of blocks for the given data_len.
+    ///
+    /// Usually only called at startup to pre-allocate structures.
+    pub fn block_count(&self, data_len: usize) -> usize {
+        let block_count = data_len / (BLOCK_SIZE_MIN as usize);
+        if data_len % (BLOCK_SIZE_MIN as usize) == 0 {
+            block_count
+        } else {
+            block_count + 1
+        }
+    }
+
+    /// Returns a range within the data which covers the given id_range.
+    ///
+    /// NOTE: This method is used for batch reads which bypass blocks to avoid dealing with block
+    /// boundaries.
+    #[inline]
+    pub fn block_oblivious_range(&self, id_range: Range<u32>, data_len: usize) -> Range<usize> {
+        let start_in_bits = id_range.start * self.num_bits;
+        let start = (start_in_bits >> 3) as usize;
+        let end_in_bits = id_range.end * self.num_bits;
+        let end = (end_in_bits >> 3) as usize;
+        // TODO: We fetch more than we need and then truncate.
+        start..(std::cmp::min(end + 8, data_len))
+    }
+
     #[inline]
     pub fn get(&self, idx: u32, data: &[u8]) -> u64 {
-        let addr_in_bits = idx as usize * self.num_bits;
-        let addr = addr_in_bits >> 3;
+        self.get_from_subset(idx, 0, data)
+    }
+
+    /// Get the value at the given idx, which must exist within the given subset of the data.
+    #[inline]
+    pub fn get_from_subset(&self, idx: u32, data_offset: usize, data: &[u8]) -> u64 {
+        let addr_in_bits = idx * self.num_bits;
+        let addr = (addr_in_bits >> 3) as usize - data_offset;
         if addr + 8 > data.len() {
             if self.num_bits == 0 {
                 return 0;
             }
             let bit_shift = addr_in_bits & 7;
-            return self.get_slow_path(addr, bit_shift as u32, data);
+            return self.get_slow_path(addr, bit_shift, data);
         }
         let bit_shift = addr_in_bits & 7;
         let bytes: [u8; 8] = (&data[addr..addr + 8]).try_into().unwrap();
@@ -113,6 +173,7 @@ impl BitUnpacker {
     #[inline(never)]
     fn get_slow_path(&self, addr: usize, bit_shift: u32, data: &[u8]) -> u64 {
         let mut bytes: [u8; 8] = [0u8; 8];
+
         let available_bytes = data.len() - addr;
         // This function is meant to only be called if we did not have 8 bytes to load.
         debug_assert!(available_bytes < 8);
@@ -128,26 +189,25 @@ impl BitUnpacker {
     // #Panics
     //
     // This methods panics if `num_bits` is > 32.
-    fn get_batch_u32s(&self, start_idx: u32, data: &[u8], output: &mut [u32]) {
+    fn get_batch_u32s(&self, start_idx: u32, data_offset: usize, data: &[u8], output: &mut [u32]) {
         assert!(
             self.bit_width() <= 32,
             "Bitwidth must be <= 32 to use this method."
         );
 
-        let end_idx: u32 = start_idx + output.len() as u32;
+        let end_idx = start_idx + output.len() as u32;
 
-        // We use `usize` here to avoid overflow issues.
-        let end_bit_read = (end_idx as usize) * self.num_bits;
-        let end_byte_read = end_bit_read.div_ceil(8);
+        let end_bit_read = end_idx * self.num_bits;
+        let end_byte_read = (end_bit_read + 7) / 8;
         assert!(
-            end_byte_read <= data.len(),
+            end_byte_read as usize <= data_offset + data.len(),
             "Requested index is out of bounds."
         );
 
         // Simple slow implementation of get_batch_u32s, to deal with our ramps.
         let get_batch_ramp = |start_idx: u32, output: &mut [u32]| {
             for (out, idx) in output.iter_mut().zip(start_idx..) {
-                *out = self.get(idx, data) as u32;
+                *out = self.get_from_subset(idx, data_offset, data) as u32;
             }
         };
 
@@ -160,24 +220,24 @@ impl BitUnpacker {
         // We want the start of the fast track to start align with bytes.
         // A sufficient condition is to start with an idx that is a multiple of 8,
         // so highway start is the closest multiple of 8 that is >= start_idx.
-        let entrance_ramp_len: u32 = 8 - (start_idx % 8) % 8;
+        let entrance_ramp_len = 8 - (start_idx % 8) % 8;
 
         let highway_start: u32 = start_idx + entrance_ramp_len;
 
-        if highway_start + (BitPacker1x::BLOCK_LEN as u32) > end_idx {
+        if highway_start + BitPacker1x::BLOCK_LEN as u32 > end_idx {
             // We don't have enough values to have even a single block of highway.
             // Let's just supply the values the simple way.
             get_batch_ramp(start_idx, output);
             return;
         }
 
-        let num_blocks: usize = (end_idx - highway_start) as usize / BitPacker1x::BLOCK_LEN;
+        let num_blocks: u32 = (end_idx - highway_start) / BitPacker1x::BLOCK_LEN as u32;
 
         // Entrance ramp
         get_batch_ramp(start_idx, &mut output[..entrance_ramp_len as usize]);
 
         // Highway
-        let mut offset = (highway_start as usize * self.num_bits) / 8;
+        let mut offset = ((highway_start * self.num_bits) as usize / 8) - data_offset;
         let mut output_cursor = (highway_start - start_idx) as usize;
         for _ in 0..num_blocks {
             offset += BitPacker1x.decompress(
@@ -189,7 +249,7 @@ impl BitUnpacker {
         }
 
         // Exit ramp
-        let highway_end: u32 = highway_start + (num_blocks * BitPacker1x::BLOCK_LEN) as u32;
+        let highway_end = highway_start + num_blocks * BitPacker1x::BLOCK_LEN as u32;
         get_batch_ramp(highway_end, &mut output[output_cursor..]);
     }
 
@@ -199,16 +259,27 @@ impl BitUnpacker {
         id_range: Range<u32>,
         data: &[u8],
         positions: &mut Vec<u32>,
+    ) {
+        self.get_ids_for_value_range_from_subset(range, id_range, 0, data, positions)
+    }
+
+    pub fn get_ids_for_value_range_from_subset(
+        &self,
+        range: RangeInclusive<u64>,
+        id_range: Range<u32>,
+        data_offset: usize,
+        data: &[u8],
+        positions: &mut Vec<u32>,
     ) {
         if self.bit_width() > 32 {
-            self.get_ids_for_value_range_slow(range, id_range, data, positions)
+            self.get_ids_for_value_range_slow(range, id_range, data_offset, data, positions)
         } else {
             if *range.start() > u32::MAX as u64 {
                 positions.clear();
                 return;
             }
             let range_u32 = (*range.start() as u32)..=(*range.end()).min(u32::MAX as u64) as u32;
-            self.get_ids_for_value_range_fast(range_u32, id_range, data, positions)
+            self.get_ids_for_value_range_fast(range_u32, id_range, data_offset, data, positions)
         }
     }
 
@@ -216,6 +287,7 @@ impl BitUnpacker {
         &self,
         range: RangeInclusive<u64>,
         id_range: Range<u32>,
+        data_offset: usize,
         data: &[u8],
         positions: &mut Vec<u32>,
     ) {
@@ -223,7 +295,7 @@ impl BitUnpacker {
         for i in id_range {
             // If we cared we could make this branchless, but the slow implementation should rarely
             // kick in.
-            let val = self.get(i, data);
+            let val = self.get_from_subset(i, data_offset, data);
             if range.contains(&val) {
                 positions.push(i);
             }
@@ -234,11 +306,12 @@ impl BitUnpacker {
         &self,
         value_range: RangeInclusive<u32>,
         id_range: Range<u32>,
+        data_offset: usize,
         data: &[u8],
         positions: &mut Vec<u32>,
     ) {
         positions.resize(id_range.len(), 0u32);
-        self.get_batch_u32s(id_range.start, data, positions);
+        self.get_batch_u32s(id_range.start, data_offset, data, positions);
         crate::filter_vec::filter_vec_in_place(value_range, id_range.start, positions)
     }
 }
@@ -329,14 +402,14 @@ mod test {
     fn test_get_batch_panics_over_32_bits() {
         let bitunpacker = BitUnpacker::new(33);
         let mut output: [u32; 1] = [0u32];
-        bitunpacker.get_batch_u32s(0, &[0, 0, 0, 0, 0, 0, 0, 0], &mut output[..]);
+        bitunpacker.get_batch_u32s(0, 0, &[0, 0, 0, 0, 0, 0, 0, 0], &mut output[..]);
     }
 
     #[test]
     fn test_get_batch_limit() {
         let bitunpacker = BitUnpacker::new(1);
         let mut output: [u32; 3] = [0u32, 0u32, 0u32];
-        bitunpacker.get_batch_u32s(8 * 4 - 3, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
+        bitunpacker.get_batch_u32s(8 * 4 - 3, 0, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
     }
 
     #[test]
@@ -345,7 +418,7 @@ mod test {
         let bitunpacker = BitUnpacker::new(1);
         let mut output: [u32; 3] = [0u32, 0u32, 0u32];
         // We are missing exactly one bit.
-        bitunpacker.get_batch_u32s(8 * 4 - 2, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
+        bitunpacker.get_batch_u32s(8 * 4 - 2, 0, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
     }
 
     proptest::proptest! {
@@ -368,7 +441,7 @@ mod test {
             for len in [0, 1, 2, 32, 33, 34, 64] {
                 for start_idx in 0u32..32u32 {
                     output.resize(len, 0);
-                    bitunpacker.get_batch_u32s(start_idx, &buffer, &mut output);
+                    bitunpacker.get_batch_u32s(start_idx, 0, &buffer, &mut output);
                     for (i, output_byte) in output.iter().enumerate() {
                         let expected = (start_idx + i as u32) & mask;
                         assert_eq!(*output_byte, expected);

columnar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-columnar"
-version = "0.7.0"
+version = "0.6.0"
 edition = "2024"
 license = "MIT"
 homepage = "https://github.com/quickwit-oss/tantivy"
@@ -12,18 +12,18 @@ categories = ["database-implementations", "data-structures", "compression"]
 itertools = "0.14.0"
 fastdivide = "0.4.0"
 
-stacker = { version= "0.7", path = "../stacker", package="tantivy-stacker"}
-sstable = { version= "0.7", path = "../sstable", package = "tantivy-sstable" }
-common = { version= "0.11", path = "../common", package = "tantivy-common" }
-tantivy-bitpacker = { version= "0.10", path = "../bitpacker/" }
-serde = "1.0.152"
+stacker = { version= "0.6", path = "../stacker", package="tantivy-stacker"}
+sstable = { version= "0.6", path = "../sstable", package = "tantivy-sstable" }
+common = { version= "0.10", path = "../common", package = "tantivy-common" }
+tantivy-bitpacker = { version= "0.9", path = "../bitpacker/" }
+serde = { version = "1.0.152", features = ["derive"] }
 downcast-rs = "2.0.1"
 
 [dev-dependencies]
 proptest = "1"
 more-asserts = "0.3.1"
-rand = "0.9"
-binggan = "0.17.0"
+rand = "0.8"
+binggan = "0.14.0"
 
 [[bench]]
 name = "bench_merge"

columnar/benches/bench_access.rs

@@ -1,6 +1,6 @@
 use binggan::{InputGroup, black_box};
 use common::*;
-use tantivy_columnar::Column;
+use tantivy_columnar::{Column, ValueRange};
 
 pub mod common;
 
@@ -46,16 +46,16 @@ fn bench_group(mut runner: InputGroup<Column>) {
     runner.register("access_first_vals", |column| {
         let mut sum = 0;
         const BLOCK_SIZE: usize = 32;
-        let mut docs = vec![0; BLOCK_SIZE];
-        let mut buffer = vec![None; BLOCK_SIZE];
+        let mut docs = Vec::with_capacity(BLOCK_SIZE);
+        let mut buffer = Vec::with_capacity(BLOCK_SIZE);
         for i in (0..NUM_DOCS).step_by(BLOCK_SIZE) {
-            // fill docs
-            #[allow(clippy::needless_range_loop)]
+            docs.clear();
             for idx in 0..BLOCK_SIZE {
-                docs[idx] = idx as u32 + i;
+                docs.push(idx as u32 + i);
             }
 
-            column.first_vals(&docs, &mut buffer);
+            buffer.clear();
+            column.first_vals_in_value_range(&mut docs, &mut buffer, ValueRange::All);
             for val in buffer.iter() {
                 let Some(val) = val else { continue };
                 sum += *val;

columnar/benches/bench_column_values_get.rs

@@ -9,7 +9,7 @@ use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_co
 fn get_data() -> Vec<u64> {
     let mut rng = StdRng::seed_from_u64(2u64);
     let mut data: Vec<_> = (100..55_000_u64)
-        .map(|num| num + rng.random::<u8>() as u64)
+        .map(|num| num + rng.r#gen::<u8>() as u64)
         .collect();
     data.push(99_000);
     data.insert(1000, 2000);

columnar/benches/bench_create_column_values.rs

@@ -6,7 +6,7 @@ use tantivy_columnar::column_values::{CodecType, serialize_u64_based_column_valu
 fn get_data() -> Vec<u64> {
     let mut rng = StdRng::seed_from_u64(2u64);
     let mut data: Vec<_> = (100..55_000_u64)
-        .map(|num| num + rng.random::<u8>() as u64)
+        .map(|num| num + rng.r#gen::<u8>() as u64)
         .collect();
     data.push(99_000);
     data.insert(1000, 2000);

columnar/benches/bench_merge.rs

@@ -40,7 +40,14 @@ fn main() {
                 let columnar_readers = columnar_readers.iter().collect::<Vec<_>>();
                 let merge_row_order = StackMergeOrder::stack(&columnar_readers[..]);
 
-                merge_columnar(&columnar_readers, &[], merge_row_order.into(), &mut out).unwrap();
+                merge_columnar(
+                    &columnar_readers,
+                    &[],
+                    merge_row_order.into(),
+                    &mut out,
+                    || false,
+                )
+                .unwrap();
                 Some(out.len() as u64)
             },
         );

columnar/benches/bench_optional_index.rs

@@ -8,7 +8,7 @@ const TOTAL_NUM_VALUES: u32 = 1_000_000;
 fn gen_optional_index(fill_ratio: f64) -> OptionalIndex {
     let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
     let vals: Vec<u32> = (0..TOTAL_NUM_VALUES)
-        .map(|_| rng.random_bool(fill_ratio))
+        .map(|_| rng.gen_bool(fill_ratio))
         .enumerate()
         .filter(|(_pos, val)| *val)
         .map(|(pos, _)| pos as u32)
@@ -25,7 +25,7 @@ fn random_range_iterator(
     let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
     let mut current = start;
     std::iter::from_fn(move || {
-        current += rng.random_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+        current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
         if current >= end { None } else { Some(current) }
     })
 }

columnar/benches/bench_values_u128.rs

@@ -39,7 +39,7 @@ fn get_data_50percent_item() -> Vec<u128> {
 
     let mut data = vec![];
     for _ in 0..300_000 {
-        let val = rng.random_range(1..=100);
+        let val = rng.gen_range(1..=100);
         data.push(val);
     }
     data.push(SINGLE_ITEM);

columnar/benches/bench_values_u64.rs

@@ -34,7 +34,7 @@ fn get_data_50percent_item() -> Vec<u128> {
 
     let mut data = vec![];
     for _ in 0..300_000 {
-        let val = rng.random_range(1..=100);
+        let val = rng.gen_range(1..=100);
         data.push(val);
     }
     data.push(SINGLE_ITEM);

columnar/src/block_accessor.rs

@@ -29,20 +29,12 @@ impl<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
         }
     }
     #[inline]
-    pub fn fetch_block_with_missing(
-        &mut self,
-        docs: &[u32],
-        accessor: &Column<T>,
-        missing_opt: Option<T>,
-    ) {
+    pub fn fetch_block_with_missing(&mut self, docs: &[u32], accessor: &Column<T>, missing: T) {
         self.fetch_block(docs, accessor);
         // no missing values
         if accessor.index.get_cardinality().is_full() {
             return;
         }
-        let Some(missing) = missing_opt else {
-            return;
-        };
 
         // We can compare docid_cache length with docs to find missing docs
         // For multi value columns we can't rely on the length and always need to scan
@@ -58,78 +50,6 @@ impl<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
         }
     }
 
-    /// Like `fetch_block_with_missing`, but deduplicates (doc_id, value) pairs
-    /// so that each unique value per document is returned only once.
-    ///
-    /// This is necessary for correct document counting in aggregations,
-    /// where multi-valued fields can produce duplicate entries that inflate counts.
-    #[inline]
-    pub fn fetch_block_with_missing_unique_per_doc(
-        &mut self,
-        docs: &[u32],
-        accessor: &Column<T>,
-        missing: Option<T>,
-    ) where
-        T: Ord,
-    {
-        self.fetch_block_with_missing(docs, accessor, missing);
-        if accessor.index.get_cardinality().is_multivalue() {
-            self.dedup_docid_val_pairs();
-        }
-    }
-
-    /// Removes duplicate (doc_id, value) pairs from the caches.
-    ///
-    /// After `fetch_block`, entries are sorted by doc_id, but values within
-    /// the same doc may not be sorted (e.g. `(0,1), (0,2), (0,1)`).
-    /// We group consecutive entries by doc_id, sort values within each group
-    /// if it has more than 2 elements, then deduplicate adjacent pairs.
-    ///
-    /// Skips entirely if no doc_id appears more than once in the block.
-    fn dedup_docid_val_pairs(&mut self)
-    where T: Ord {
-        if self.docid_cache.len() <= 1 {
-            return;
-        }
-
-        // Quick check: if no consecutive doc_ids are equal, no dedup needed.
-        let has_multivalue = self.docid_cache.windows(2).any(|w| w[0] == w[1]);
-        if !has_multivalue {
-            return;
-        }
-
-        // Sort values within each doc_id group so duplicates become adjacent.
-        let mut start = 0;
-        while start < self.docid_cache.len() {
-            let doc = self.docid_cache[start];
-            let mut end = start + 1;
-            while end < self.docid_cache.len() && self.docid_cache[end] == doc {
-                end += 1;
-            }
-            if end - start > 2 {
-                self.val_cache[start..end].sort();
-            }
-            start = end;
-        }
-
-        // Now duplicates are adjacent — deduplicate in place.
-        let mut write = 0;
-        for read in 1..self.docid_cache.len() {
-            if self.docid_cache[read] != self.docid_cache[write]
-                || self.val_cache[read] != self.val_cache[write]
-            {
-                write += 1;
-                if write != read {
-                    self.docid_cache[write] = self.docid_cache[read];
-                    self.val_cache[write] = self.val_cache[read];
-                }
-            }
-        }
-        let new_len = write + 1;
-        self.docid_cache.truncate(new_len);
-        self.val_cache.truncate(new_len);
-    }
-
     #[inline]
     pub fn iter_vals(&self) -> impl Iterator<Item = T> + '_ {
         self.val_cache.iter().cloned()
@@ -191,7 +111,6 @@ where F: FnMut(u32) {
 }
 
 #[cfg(test)]
-#[allow(clippy::field_reassign_with_default)]
 mod tests {
     use super::*;
 
@@ -236,56 +155,4 @@ mod tests {
 
         assert_eq!(missing_docs, vec![1, 2, 3, 4, 5]);
     }
-
-    #[test]
-    fn test_dedup_docid_val_pairs_consecutive() {
-        let mut accessor = ColumnBlockAccessor::<u64>::default();
-        accessor.docid_cache = vec![0, 0, 2, 3];
-        accessor.val_cache = vec![10, 10, 10, 10];
-        accessor.dedup_docid_val_pairs();
-        assert_eq!(accessor.docid_cache, vec![0, 2, 3]);
-        assert_eq!(accessor.val_cache, vec![10, 10, 10]);
-    }
-
-    #[test]
-    fn test_dedup_docid_val_pairs_non_consecutive() {
-        // (0,1), (0,2), (0,1) — duplicate value not adjacent
-        let mut accessor = ColumnBlockAccessor::<u64>::default();
-        accessor.docid_cache = vec![0, 0, 0];
-        accessor.val_cache = vec![1, 2, 1];
-        accessor.dedup_docid_val_pairs();
-        assert_eq!(accessor.docid_cache, vec![0, 0]);
-        assert_eq!(accessor.val_cache, vec![1, 2]);
-    }
-
-    #[test]
-    fn test_dedup_docid_val_pairs_multi_doc() {
-        // doc 0: values [3, 1, 3], doc 1: values [5, 5]
-        let mut accessor = ColumnBlockAccessor::<u64>::default();
-        accessor.docid_cache = vec![0, 0, 0, 1, 1];
-        accessor.val_cache = vec![3, 1, 3, 5, 5];
-        accessor.dedup_docid_val_pairs();
-        assert_eq!(accessor.docid_cache, vec![0, 0, 1]);
-        assert_eq!(accessor.val_cache, vec![1, 3, 5]);
-    }
-
-    #[test]
-    fn test_dedup_docid_val_pairs_no_duplicates() {
-        let mut accessor = ColumnBlockAccessor::<u64>::default();
-        accessor.docid_cache = vec![0, 0, 1];
-        accessor.val_cache = vec![1, 2, 3];
-        accessor.dedup_docid_val_pairs();
-        assert_eq!(accessor.docid_cache, vec![0, 0, 1]);
-        assert_eq!(accessor.val_cache, vec![1, 2, 3]);
-    }
-
-    #[test]
-    fn test_dedup_docid_val_pairs_single_element() {
-        let mut accessor = ColumnBlockAccessor::<u64>::default();
-        accessor.docid_cache = vec![0];
-        accessor.val_cache = vec![1];
-        accessor.dedup_docid_val_pairs();
-        assert_eq!(accessor.docid_cache, vec![0]);
-        assert_eq!(accessor.val_cache, vec![1]);
-    }
 }

columnar/src/column/mod.rs

@@ -1,6 +1,7 @@
 mod dictionary_encoded;
 mod serialize;
 
+use std::cell::RefCell;
 use std::fmt::{self, Debug};
 use std::io::Write;
 use std::ops::{Range, RangeInclusive};
@@ -19,6 +20,11 @@ use crate::column_values::monotonic_mapping::StrictlyMonotonicMappingToInternal;
 use crate::column_values::{ColumnValues, monotonic_map_column};
 use crate::{Cardinality, DocId, EmptyColumnValues, MonotonicallyMappableToU64, RowId};
 
+thread_local! {
+    static ROWS: RefCell<Vec<RowId>> = const { RefCell::new(Vec::new()) };
+    static DOCS: RefCell<Vec<DocId>> = const { RefCell::new(Vec::new()) };
+}
+
 #[derive(Clone)]
 pub struct Column<T = u64> {
     pub index: ColumnIndex,
@@ -85,33 +91,8 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
     }
 
     #[inline]
-    pub fn first(&self, doc_id: DocId) -> Option<T> {
-        self.values_for_doc(doc_id).next()
-    }
-
-    /// Load the first value for each docid in the provided slice.
-    #[inline]
-    pub fn first_vals(&self, docids: &[DocId], output: &mut [Option<T>]) {
-        match &self.index {
-            ColumnIndex::Empty { .. } => {}
-            ColumnIndex::Full => self.values.get_vals_opt(docids, output),
-            ColumnIndex::Optional(optional_index) => {
-                for (i, docid) in docids.iter().enumerate() {
-                    output[i] = optional_index
-                        .rank_if_exists(*docid)
-                        .map(|rowid| self.values.get_val(rowid));
-                }
-            }
-            ColumnIndex::Multivalued(multivalued_index) => {
-                for (i, docid) in docids.iter().enumerate() {
-                    let range = multivalued_index.range(*docid);
-                    let is_empty = range.start == range.end;
-                    if !is_empty {
-                        output[i] = Some(self.values.get_val(range.start));
-                    }
-                }
-            }
-        }
+    pub fn first(&self, row_id: RowId) -> Option<T> {
+        self.values_for_doc(row_id).next()
     }
 
     /// Translates a block of docids to row_ids.
@@ -143,7 +124,7 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
     #[inline]
     pub fn get_docids_for_value_range(
         &self,
-        value_range: RangeInclusive<T>,
+        value_range: ValueRange<T>,
         selected_docid_range: Range<u32>,
         doc_ids: &mut Vec<u32>,
     ) {
@@ -168,6 +149,181 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
     }
 }
 
+// Separate impl block for methods requiring `Default` for `T`.
+impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static + Default> Column<T> {
+    /// Load the first value for each docid in the provided slice.
+    ///
+    /// The `docids` vector is mutated: documents that do not match the `value_range` are removed.
+    /// The `values` vector is populated with the values of the remaining documents.
+    #[inline]
+    pub fn first_vals_in_value_range(
+        &self,
+        input_docs: &[DocId],
+        output: &mut Vec<crate::ComparableDoc<Option<T>, DocId>>,
+        value_range: ValueRange<T>,
+    ) {
+        match (&self.index, value_range) {
+            (ColumnIndex::Empty { .. }, value_range) => {
+                let nulls_match = match &value_range {
+                    ValueRange::All => true,
+                    ValueRange::Inclusive(_) => false,
+                    ValueRange::GreaterThan(_, nulls_match) => *nulls_match,
+                    ValueRange::GreaterThanOrEqual(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThan(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThanOrEqual(_, nulls_match) => *nulls_match,
+                };
+                if nulls_match {
+                    for &doc in input_docs {
+                        output.push(crate::ComparableDoc {
+                            doc,
+                            sort_key: None,
+                        });
+                    }
+                }
+            }
+            (ColumnIndex::Full, value_range) => {
+                self.values
+                    .get_vals_in_value_range(input_docs, input_docs, output, value_range);
+            }
+            (ColumnIndex::Optional(optional_index), value_range) => {
+                let nulls_match = match &value_range {
+                    ValueRange::All => true,
+                    ValueRange::Inclusive(_) => false,
+                    ValueRange::GreaterThan(_, nulls_match) => *nulls_match,
+                    ValueRange::GreaterThanOrEqual(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThan(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThanOrEqual(_, nulls_match) => *nulls_match,
+                };
+
+                let fallback_needed = ROWS.with(|rows_cell| {
+                    DOCS.with(|docs_cell| {
+                        let mut rows = rows_cell.borrow_mut();
+                        let mut docs = docs_cell.borrow_mut();
+                        rows.clear();
+                        docs.clear();
+
+                        let mut has_nulls = false;
+
+                        for &doc_id in input_docs {
+                            if let Some(row_id) = optional_index.rank_if_exists(doc_id) {
+                                rows.push(row_id);
+                                docs.push(doc_id);
+                            } else {
+                                has_nulls = true;
+                                if nulls_match {
+                                    break;
+                                }
+                            }
+                        }
+
+                        if !has_nulls || !nulls_match {
+                            self.values.get_vals_in_value_range(
+                                &rows,
+                                &docs,
+                                output,
+                                value_range.clone(),
+                            );
+                            return false;
+                        }
+                        true
+                    })
+                });
+
+                if fallback_needed {
+                    for &doc_id in input_docs {
+                        if let Some(row_id) = optional_index.rank_if_exists(doc_id) {
+                            let val = self.values.get_val(row_id);
+                            let value_matches = match &value_range {
+                                ValueRange::All => true,
+                                ValueRange::Inclusive(r) => r.contains(&val),
+                                ValueRange::GreaterThan(t, _) => val > *t,
+                                ValueRange::GreaterThanOrEqual(t, _) => val >= *t,
+                                ValueRange::LessThan(t, _) => val < *t,
+                                ValueRange::LessThanOrEqual(t, _) => val <= *t,
+                            };
+
+                            if value_matches {
+                                output.push(crate::ComparableDoc {
+                                    doc: doc_id,
+                                    sort_key: Some(val),
+                                });
+                            }
+                        } else if nulls_match {
+                            output.push(crate::ComparableDoc {
+                                doc: doc_id,
+                                sort_key: None,
+                            });
+                        }
+                    }
+                }
+            }
+            (ColumnIndex::Multivalued(multivalued_index), value_range) => {
+                let nulls_match = match &value_range {
+                    ValueRange::All => true,
+                    ValueRange::Inclusive(_) => false,
+                    ValueRange::GreaterThan(_, nulls_match) => *nulls_match,
+                    ValueRange::GreaterThanOrEqual(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThan(_, nulls_match) => *nulls_match,
+                    ValueRange::LessThanOrEqual(_, nulls_match) => *nulls_match,
+                };
+                for i in 0..input_docs.len() {
+                    let docid = input_docs[i];
+                    let row_range = multivalued_index.range(docid);
+                    let is_empty = row_range.start == row_range.end;
+                    if !is_empty {
+                        let val = self.values.get_val(row_range.start);
+                        let matches = match &value_range {
+                            ValueRange::All => true,
+                            ValueRange::Inclusive(r) => r.contains(&val),
+                            ValueRange::GreaterThan(t, _) => val > *t,
+                            ValueRange::GreaterThanOrEqual(t, _) => val >= *t,
+                            ValueRange::LessThan(t, _) => val < *t,
+                            ValueRange::LessThanOrEqual(t, _) => val <= *t,
+                        };
+                        if matches {
+                            output.push(crate::ComparableDoc {
+                                doc: docid,
+                                sort_key: Some(val),
+                            });
+                        }
+                    } else if nulls_match {
+                        output.push(crate::ComparableDoc {
+                            doc: docid,
+                            sort_key: None,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// A range of values.
+///
+/// This type is intended to be used in batch APIs, where the cost of unpacking the enum
+/// is outweighed by the time spent processing a batch.
+///
+/// Implementers should pattern match on the variants to use optimized loops for each case.
+#[derive(Clone, Debug)]
+pub enum ValueRange<T> {
+    /// A range that includes both start and end.
+    Inclusive(RangeInclusive<T>),
+    /// A range that matches all values.
+    All,
+    /// A range that matches all values greater than the threshold.
+    /// The boolean flag indicates if null values should be included.
+    GreaterThan(T, bool),
+    /// A range that matches all values greater than or equal to the threshold.
+    /// The boolean flag indicates if null values should be included.
+    GreaterThanOrEqual(T, bool),
+    /// A range that matches all values less than the threshold.
+    /// The boolean flag indicates if null values should be included.
+    LessThan(T, bool),
+    /// A range that matches all values less than or equal to the threshold.
+    /// The boolean flag indicates if null values should be included.
+    LessThanOrEqual(T, bool),
+}
+
 impl BinarySerializable for Cardinality {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> std::io::Result<()> {
         self.to_code().serialize(writer)

columnar/src/column/serialize.rs

@@ -2,7 +2,7 @@ use std::io;
 use std::io::Write;
 use std::sync::Arc;
 
-use common::OwnedBytes;
+use common::file_slice::FileSlice;
 use sstable::Dictionary;
 
 use crate::column::{BytesColumn, Column};
@@ -41,12 +41,13 @@ pub fn serialize_column_mappable_to_u64<T: MonotonicallyMappableToU64>(
 }
 
 pub fn open_column_u64<T: MonotonicallyMappableToU64>(
-    bytes: OwnedBytes,
+    file_slice: FileSlice,
     format_version: Version,
 ) -> io::Result<Column<T>> {
-    let (body, column_index_num_bytes_payload) = bytes.rsplit(4);
+    let (body, column_index_num_bytes_payload) = file_slice.split_from_end(4);
     let column_index_num_bytes = u32::from_le_bytes(
         column_index_num_bytes_payload
+            .read_bytes()?
             .as_slice()
             .try_into()
             .unwrap(),
@@ -61,12 +62,13 @@ pub fn open_column_u64<T: MonotonicallyMappableToU64>(
 }
 
 pub fn open_column_u128<T: MonotonicallyMappableToU128>(
-    bytes: OwnedBytes,
+    file_slice: FileSlice,
     format_version: Version,
 ) -> io::Result<Column<T>> {
-    let (body, column_index_num_bytes_payload) = bytes.rsplit(4);
+    let (body, column_index_num_bytes_payload) = file_slice.split_from_end(4);
     let column_index_num_bytes = u32::from_le_bytes(
         column_index_num_bytes_payload
+            .read_bytes()?
             .as_slice()
             .try_into()
             .unwrap(),
@@ -84,12 +86,13 @@ pub fn open_column_u128<T: MonotonicallyMappableToU128>(
 ///
 /// See [`open_u128_as_compact_u64`] for more details.
 pub fn open_column_u128_as_compact_u64(
-    bytes: OwnedBytes,
+    file_slice: FileSlice,
     format_version: Version,
 ) -> io::Result<Column<u64>> {
-    let (body, column_index_num_bytes_payload) = bytes.rsplit(4);
+    let (body, column_index_num_bytes_payload) = file_slice.split_from_end(4);
     let column_index_num_bytes = u32::from_le_bytes(
         column_index_num_bytes_payload
+            .read_bytes()?
             .as_slice()
             .try_into()
             .unwrap(),
@@ -103,11 +106,21 @@ pub fn open_column_u128_as_compact_u64(
     })
 }
 
-pub fn open_column_bytes(data: OwnedBytes, format_version: Version) -> io::Result<BytesColumn> {
-    let (body, dictionary_len_bytes) = data.rsplit(4);
-    let dictionary_len = u32::from_le_bytes(dictionary_len_bytes.as_slice().try_into().unwrap());
+pub fn open_column_bytes(
+    file_slice: FileSlice,
+    format_version: Version,
+) -> io::Result<BytesColumn> {
+    let (body, dictionary_len_bytes) = file_slice.split_from_end(4);
+    let dictionary_len = u32::from_le_bytes(
+        dictionary_len_bytes
+            .read_bytes()?
+            .as_slice()
+            .try_into()
+            .unwrap(),
+    );
     let (dictionary_bytes, column_bytes) = body.split(dictionary_len as usize);
-    let dictionary = Arc::new(Dictionary::from_bytes(dictionary_bytes)?);
+
+    let dictionary = Arc::new(Dictionary::open(dictionary_bytes)?);
     let term_ord_column = crate::column::open_column_u64::<u64>(column_bytes, format_version)?;
     Ok(BytesColumn {
         dictionary,
@@ -115,7 +128,7 @@ pub fn open_column_bytes(data: OwnedBytes, format_version: Version) -> io::Resul
     })
 }
 
-pub fn open_column_str(data: OwnedBytes, format_version: Version) -> io::Result<StrColumn> {
-    let bytes_column = open_column_bytes(data, format_version)?;
+pub fn open_column_str(file_slice: FileSlice, format_version: Version) -> io::Result<StrColumn> {
+    let bytes_column = open_column_bytes(file_slice, format_version)?;
     Ok(StrColumn::wrap(bytes_column))
 }

columnar/src/column_index/merge/mod.rs

@@ -95,7 +95,7 @@ pub fn merge_column_index<'a>(
 
 #[cfg(test)]
 mod tests {
-    use common::OwnedBytes;
+    use common::file_slice::FileSlice;
 
     use crate::column_index::merge::detect_cardinality;
     use crate::column_index::multivalued_index::{
@@ -178,7 +178,7 @@ mod tests {
         let mut output = Vec::new();
         serialize_multivalued_index(&start_index_iterable, &mut output).unwrap();
         let multivalue =
-            open_multivalued_index(OwnedBytes::new(output), crate::Version::V2).unwrap();
+            open_multivalued_index(FileSlice::from(output), crate::Version::V2).unwrap();
         let start_indexes: Vec<RowId> = multivalue.get_start_index_column().iter().collect();
         assert_eq!(&start_indexes, &[0, 3, 5]);
     }
@@ -216,7 +216,7 @@ mod tests {
         let mut output = Vec::new();
         serialize_multivalued_index(&start_index_iterable, &mut output).unwrap();
         let multivalue =
-            open_multivalued_index(OwnedBytes::new(output), crate::Version::V2).unwrap();
+            open_multivalued_index(FileSlice::from(output), crate::Version::V2).unwrap();
         let start_indexes: Vec<RowId> = multivalue.get_start_index_column().iter().collect();
         assert_eq!(&start_indexes, &[0, 3, 5, 6]);
     }

columnar/src/column_index/multivalued_index.rs

@@ -3,7 +3,8 @@ use std::io::Write;
 use std::ops::Range;
 use std::sync::Arc;
 
-use common::{CountingWriter, OwnedBytes};
+use common::CountingWriter;
+use common::file_slice::FileSlice;
 
 use super::optional_index::{open_optional_index, serialize_optional_index};
 use super::{OptionalIndex, SerializableOptionalIndex, Set};
@@ -44,21 +45,26 @@ pub fn serialize_multivalued_index(
 }
 
 pub fn open_multivalued_index(
-    bytes: OwnedBytes,
+    file_slice: FileSlice,
     format_version: Version,
 ) -> io::Result<MultiValueIndex> {
     match format_version {
         Version::V1 => {
             let start_index_column: Arc<dyn ColumnValues<RowId>> =
-                load_u64_based_column_values(bytes)?;
+                load_u64_based_column_values(file_slice)?;
             Ok(MultiValueIndex::MultiValueIndexV1(MultiValueIndexV1 {
                 start_index_column,
             }))
         }
         Version::V2 => {
-            let (body_bytes, optional_index_len) = bytes.rsplit(4);
-            let optional_index_len =
-                u32::from_le_bytes(optional_index_len.as_slice().try_into().unwrap());
+            let (body_bytes, optional_index_len) = file_slice.split_from_end(4);
+            let optional_index_len = u32::from_le_bytes(
+                optional_index_len
+                    .read_bytes()?
+                    .as_slice()
+                    .try_into()
+                    .unwrap(),
+            );
             let (optional_index_bytes, start_index_bytes) =
                 body_bytes.split(optional_index_len as usize);
             let optional_index = open_optional_index(optional_index_bytes)?;
@@ -185,8 +191,8 @@ impl MultiValueIndex {
         };
         let mut buffer = Vec::new();
         serialize_multivalued_index(&serializable_multivalued_index, &mut buffer).unwrap();
-        let bytes = OwnedBytes::new(buffer);
-        open_multivalued_index(bytes, Version::V2).unwrap()
+        let file_slice = FileSlice::from(buffer);
+        open_multivalued_index(file_slice, Version::V2).unwrap()
     }
 
     pub fn get_start_index_column(&self) -> &Arc<dyn crate::ColumnValues<RowId>> {
@@ -333,7 +339,7 @@ mod tests {
     use std::ops::Range;
 
     use super::MultiValueIndex;
-    use crate::{ColumnarReader, DynamicColumn};
+    use crate::{ColumnarReader, DynamicColumn, ValueRange};
 
     fn index_to_pos_helper(
         index: &MultiValueIndex,
@@ -413,7 +419,7 @@ mod tests {
         assert_eq!(row_id_range, 0..4);
 
         let check = |range, expected| {
-            let full_range = 0..=u64::MAX;
+            let full_range = ValueRange::All;
             let mut docids = Vec::new();
             column.get_docids_for_value_range(full_range, range, &mut docids);
             assert_eq!(docids, expected);

columnar/src/column_index/optional_index/mod.rs

@@ -4,6 +4,7 @@ use std::sync::Arc;
 mod set;
 mod set_block;
 
+use common::file_slice::FileSlice;
 use common::{BinarySerializable, OwnedBytes, VInt};
 pub use set::{SelectCursor, Set, SetCodec};
 use set_block::{
@@ -268,8 +269,8 @@ impl OptionalIndex {
         );
         let mut buffer = Vec::new();
         serialize_optional_index(&row_ids, num_rows, &mut buffer).unwrap();
-        let bytes = OwnedBytes::new(buffer);
-        open_optional_index(bytes).unwrap()
+        let file_slice = FileSlice::from(buffer);
+        open_optional_index(file_slice).unwrap()
     }
 
     pub fn num_docs(&self) -> RowId {
@@ -486,10 +487,17 @@ fn deserialize_optional_index_block_metadatas(
     (block_metas.into_boxed_slice(), non_null_rows_before_block)
 }
 
-pub fn open_optional_index(bytes: OwnedBytes) -> io::Result<OptionalIndex> {
-    let (mut bytes, num_non_empty_blocks_bytes) = bytes.rsplit(2);
-    let num_non_empty_block_bytes =
-        u16::from_le_bytes(num_non_empty_blocks_bytes.as_slice().try_into().unwrap());
+pub fn open_optional_index(file_slice: FileSlice) -> io::Result<OptionalIndex> {
+    let (bytes, num_non_empty_blocks_bytes) = file_slice.split_from_end(2);
+    let num_non_empty_block_bytes = u16::from_le_bytes(
+        num_non_empty_blocks_bytes
+            .read_bytes()?
+            .as_slice()
+            .try_into()
+            .unwrap(),
+    );
+
+    let mut bytes = bytes.read_bytes()?;
     let num_docs = VInt::deserialize_u64(&mut bytes)? as u32;
     let block_metas_num_bytes =
         num_non_empty_block_bytes as usize * SERIALIZED_BLOCK_META_NUM_BYTES;

columnar/src/column_index/optional_index/tests.rs

@@ -59,7 +59,7 @@ fn test_with_random_sets_simple() {
     let vals = 10..ELEMENTS_PER_BLOCK * 2;
     let mut out: Vec<u8> = Vec::new();
     serialize_optional_index(&vals, 100, &mut out).unwrap();
-    let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
+    let null_index = open_optional_index(FileSlice::from(out)).unwrap();
     let ranks: Vec<u32> = (65_472u32..65_473u32).collect();
     let els: Vec<u32> = ranks.iter().copied().map(|rank| rank + 10).collect();
     let mut select_cursor = null_index.select_cursor();
@@ -102,7 +102,7 @@ impl<'a> Iterable<RowId> for &'a [bool] {
 fn test_null_index(data: &[bool]) {
     let mut out: Vec<u8> = Vec::new();
     serialize_optional_index(&data, data.len() as RowId, &mut out).unwrap();
-    let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
+    let null_index = open_optional_index(FileSlice::from(out)).unwrap();
     let orig_idx_with_value: Vec<u32> = data
         .iter()
         .enumerate()
@@ -223,3 +223,170 @@ fn test_optional_index_for_tests() {
     assert!(!optional_index.contains(3));
     assert_eq!(optional_index.num_docs(), 4);
 }
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+    use test::Bencher;
+
+    use super::*;
+
+    const TOTAL_NUM_VALUES: u32 = 1_000_000;
+    fn gen_bools(fill_ratio: f64) -> OptionalIndex {
+        let mut out = Vec::new();
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        let vals: Vec<RowId> = (0..TOTAL_NUM_VALUES)
+            .map(|_| rng.gen_bool(fill_ratio))
+            .enumerate()
+            .filter(|(_pos, val)| *val)
+            .map(|(pos, _)| pos as RowId)
+            .collect();
+        serialize_optional_index(&&vals[..], TOTAL_NUM_VALUES, &mut out).unwrap();
+
+        open_optional_index(FileSlice::from(out)).unwrap()
+    }
+
+    fn random_range_iterator(
+        start: u32,
+        end: u32,
+        avg_step_size: u32,
+        avg_deviation: u32,
+    ) -> impl Iterator<Item = u32> {
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        let mut current = start;
+        std::iter::from_fn(move || {
+            current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+            if current >= end { None } else { Some(current) }
+        })
+    }
+
+    fn n_percent_step_iterator(percent: f32, num_values: u32) -> impl Iterator<Item = u32> {
+        let ratio = percent / 100.0;
+        let step_size = (1f32 / ratio) as u32;
+        let deviation = step_size - 1;
+        random_range_iterator(0, num_values, step_size, deviation)
+    }
+
+    fn walk_over_data(codec: &OptionalIndex, avg_step_size: u32) -> Option<u32> {
+        walk_over_data_from_positions(
+            codec,
+            random_range_iterator(0, TOTAL_NUM_VALUES, avg_step_size, 0),
+        )
+    }
+
+    fn walk_over_data_from_positions(
+        codec: &OptionalIndex,
+        positions: impl Iterator<Item = u32>,
+    ) -> Option<u32> {
+        let mut dense_idx: Option<u32> = None;
+        for idx in positions {
+            dense_idx = dense_idx.or(codec.rank_if_exists(idx));
+        }
+        dense_idx
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 1000));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_1percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_10percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_90percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_10percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_50percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.5f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_90percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.01f64, 0.005f32, bench);
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_10percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.1f64, 0.005f32, bench);
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.01f64, 10f32, bench);
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.01f64, 100f32, bench);
+    }
+
+    fn bench_translate_codec_to_orig_util(
+        percent_filled: f64,
+        percent_hit: f32,
+        bench: &mut Bencher,
+    ) {
+        let codec = gen_bools(percent_filled);
+        let num_non_nulls = codec.num_non_nulls();
+        let idxs: Vec<u32> = if percent_hit == 100.0f32 {
+            (0..num_non_nulls).collect()
+        } else {
+            n_percent_step_iterator(percent_hit, num_non_nulls).collect()
+        };
+        let mut output = vec![0u32; idxs.len()];
+        bench.iter(|| {
+            output.copy_from_slice(&idxs[..]);
+            codec.select_batch(&mut output);
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.9f64, 0.005, bench);
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
+        bench_translate_codec_to_orig_util(0.9f64, 100.0f32, bench);
+    }
+}

columnar/src/column_index/serialize.rs

@@ -1,7 +1,8 @@
 use std::io;
 use std::io::Write;
 
-use common::{CountingWriter, OwnedBytes};
+use common::file_slice::FileSlice;
+use common::{CountingWriter, HasLen};
 
 use super::OptionalIndex;
 use super::multivalued_index::SerializableMultivalueIndex;
@@ -65,27 +66,28 @@ pub fn serialize_column_index(
 
 /// Open a serialized column index.
 pub fn open_column_index(
-    mut bytes: OwnedBytes,
+    file_slice: FileSlice,
     format_version: Version,
 ) -> io::Result<ColumnIndex> {
-    if bytes.is_empty() {
+    if file_slice.len() == 0 {
         return Err(io::Error::new(
             io::ErrorKind::UnexpectedEof,
             "Failed to deserialize column index. Empty buffer.",
         ));
     }
-    let cardinality_code = bytes[0];
+    let (header, body) = file_slice.split(1);
+    let cardinality_code = header.read_bytes()?.as_slice()[0];
     let cardinality = Cardinality::try_from_code(cardinality_code)?;
-    bytes.advance(1);
+
     match cardinality {
         Cardinality::Full => Ok(ColumnIndex::Full),
         Cardinality::Optional => {
-            let optional_index = super::optional_index::open_optional_index(bytes)?;
+            let optional_index = super::optional_index::open_optional_index(body)?;
             Ok(ColumnIndex::Optional(optional_index))
         }
         Cardinality::Multivalued => {
             let multivalue_index =
-                super::multivalued_index::open_multivalued_index(bytes, format_version)?;
+                super::multivalued_index::open_multivalued_index(body, format_version)?;
             Ok(ColumnIndex::Multivalued(multivalue_index))
         }
     }

columnar/src/column_values/mod.rs

@@ -7,13 +7,15 @@
 //! - Monotonically map values to u64/u128
 
 use std::fmt::Debug;
-use std::ops::{Range, RangeInclusive};
+use std::ops::Range;
 use std::sync::Arc;
 
 use downcast_rs::DowncastSync;
 pub use monotonic_mapping::{MonotonicallyMappableToU64, StrictlyMonotonicFn};
 pub use monotonic_mapping_u128::MonotonicallyMappableToU128;
 
+use crate::column::ValueRange;
+
 mod merge;
 pub(crate) mod monotonic_mapping;
 pub(crate) mod monotonic_mapping_u128;
@@ -27,11 +29,10 @@ mod monotonic_column;
 pub(crate) use merge::MergedColumnValues;
 pub use stats::ColumnStats;
 pub use u64_based::{
-    ALL_U64_CODEC_TYPES, CodecType, load_u64_based_column_values,
-    serialize_and_load_u64_based_column_values, serialize_u64_based_column_values,
+    ALL_U64_CODEC_TYPES, CodecType, load_u64_based_column_values, serialize_u64_based_column_values,
 };
 pub use u128_based::{
-    CompactHit, CompactSpaceU64Accessor, open_u128_as_compact_u64, open_u128_mapped,
+    CompactSpaceU64Accessor, open_u128_as_compact_u64, open_u128_mapped,
     serialize_column_values_u128,
 };
 pub use vec_column::VecColumn;
@@ -109,6 +110,307 @@ pub trait ColumnValues<T: PartialOrd = u64>: Send + Sync + DowncastSync {
         }
     }
 
+    /// Load the values for the provided docids.
+    ///
+    /// The values are filtered by the provided value range.
+    fn get_vals_in_value_range(
+        &self,
+        input_indexes: &[u32],
+        input_doc_ids: &[u32],
+        output: &mut Vec<crate::ComparableDoc<Option<T>, crate::DocId>>,
+        value_range: ValueRange<T>,
+    ) {
+        let len = input_indexes.len();
+        let mut read_head = 0;
+
+        match value_range {
+            ValueRange::All => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    output.push(crate::ComparableDoc {
+                        doc: doc0,
+                        sort_key: Some(val0),
+                    });
+                    output.push(crate::ComparableDoc {
+                        doc: doc1,
+                        sort_key: Some(val1),
+                    });
+                    output.push(crate::ComparableDoc {
+                        doc: doc2,
+                        sort_key: Some(val2),
+                    });
+                    output.push(crate::ComparableDoc {
+                        doc: doc3,
+                        sort_key: Some(val3),
+                    });
+
+                    read_head += 4;
+                }
+            }
+            ValueRange::Inclusive(ref range) => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    if range.contains(&val0) {
+                        output.push(crate::ComparableDoc {
+                            doc: doc0,
+                            sort_key: Some(val0),
+                        });
+                    }
+                    if range.contains(&val1) {
+                        output.push(crate::ComparableDoc {
+                            doc: doc1,
+                            sort_key: Some(val1),
+                        });
+                    }
+                    if range.contains(&val2) {
+                        output.push(crate::ComparableDoc {
+                            doc: doc2,
+                            sort_key: Some(val2),
+                        });
+                    }
+                    if range.contains(&val3) {
+                        output.push(crate::ComparableDoc {
+                            doc: doc3,
+                            sort_key: Some(val3),
+                        });
+                    }
+
+                    read_head += 4;
+                }
+            }
+            ValueRange::GreaterThan(ref threshold, _) => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    if val0 > *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc0,
+                            sort_key: Some(val0),
+                        });
+                    }
+                    if val1 > *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc1,
+                            sort_key: Some(val1),
+                        });
+                    }
+                    if val2 > *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc2,
+                            sort_key: Some(val2),
+                        });
+                    }
+                    if val3 > *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc3,
+                            sort_key: Some(val3),
+                        });
+                    }
+
+                    read_head += 4;
+                }
+            }
+            ValueRange::GreaterThanOrEqual(ref threshold, _) => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    if val0 >= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc0,
+                            sort_key: Some(val0),
+                        });
+                    }
+                    if val1 >= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc1,
+                            sort_key: Some(val1),
+                        });
+                    }
+                    if val2 >= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc2,
+                            sort_key: Some(val2),
+                        });
+                    }
+                    if val3 >= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc3,
+                            sort_key: Some(val3),
+                        });
+                    }
+
+                    read_head += 4;
+                }
+            }
+            ValueRange::LessThan(ref threshold, _) => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    if val0 < *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc0,
+                            sort_key: Some(val0),
+                        });
+                    }
+                    if val1 < *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc1,
+                            sort_key: Some(val1),
+                        });
+                    }
+                    if val2 < *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc2,
+                            sort_key: Some(val2),
+                        });
+                    }
+                    if val3 < *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc3,
+                            sort_key: Some(val3),
+                        });
+                    }
+
+                    read_head += 4;
+                }
+            }
+            ValueRange::LessThanOrEqual(ref threshold, _) => {
+                while read_head + 3 < len {
+                    let idx0 = input_indexes[read_head];
+                    let idx1 = input_indexes[read_head + 1];
+                    let idx2 = input_indexes[read_head + 2];
+                    let idx3 = input_indexes[read_head + 3];
+
+                    let doc0 = input_doc_ids[read_head];
+                    let doc1 = input_doc_ids[read_head + 1];
+                    let doc2 = input_doc_ids[read_head + 2];
+                    let doc3 = input_doc_ids[read_head + 3];
+
+                    let val0 = self.get_val(idx0);
+                    let val1 = self.get_val(idx1);
+                    let val2 = self.get_val(idx2);
+                    let val3 = self.get_val(idx3);
+
+                    if val0 <= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc0,
+                            sort_key: Some(val0),
+                        });
+                    }
+                    if val1 <= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc1,
+                            sort_key: Some(val1),
+                        });
+                    }
+                    if val2 <= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc2,
+                            sort_key: Some(val2),
+                        });
+                    }
+                    if val3 <= *threshold {
+                        output.push(crate::ComparableDoc {
+                            doc: doc3,
+                            sort_key: Some(val3),
+                        });
+                    }
+
+                    read_head += 4;
+                }
+            }
+        }
+        // Process remaining elements (0 to 3)
+        while read_head < len {
+            let idx = input_indexes[read_head];
+            let doc = input_doc_ids[read_head];
+            let val = self.get_val(idx);
+            let matches = match value_range {
+                // 'value_range' is still moved here. This is the outer `value_range`
+                ValueRange::All => true,
+                ValueRange::Inclusive(ref r) => r.contains(&val),
+                ValueRange::GreaterThan(ref t, _) => val > *t,
+                ValueRange::GreaterThanOrEqual(ref t, _) => val >= *t,
+                ValueRange::LessThan(ref t, _) => val < *t,
+                ValueRange::LessThanOrEqual(ref t, _) => val <= *t,
+            };
+            if matches {
+                output.push(crate::ComparableDoc {
+                    doc,
+                    sort_key: Some(val),
+                });
+            }
+            read_head += 1;
+        }
+    }
+
     /// Fills an output buffer with the fast field values
     /// associated with the `DocId` going from
     /// `start` to `start + output.len()`.
@@ -129,15 +431,54 @@ pub trait ColumnValues<T: PartialOrd = u64>: Send + Sync + DowncastSync {
     /// Note that position == docid for single value fast fields
     fn get_row_ids_for_value_range(
         &self,
-        value_range: RangeInclusive<T>,
+        value_range: ValueRange<T>,
         row_id_range: Range<RowId>,
         row_id_hits: &mut Vec<RowId>,
     ) {
         let row_id_range = row_id_range.start..row_id_range.end.min(self.num_vals());
-        for idx in row_id_range {
-            let val = self.get_val(idx);
-            if value_range.contains(&val) {
-                row_id_hits.push(idx);
+        match value_range {
+            ValueRange::Inclusive(range) => {
+                for idx in row_id_range {
+                    let val = self.get_val(idx);
+                    if range.contains(&val) {
+                        row_id_hits.push(idx);
+                    }
+                }
+            }
+            ValueRange::GreaterThan(threshold, _) => {
+                for idx in row_id_range {
+                    let val = self.get_val(idx);
+                    if val > threshold {
+                        row_id_hits.push(idx);
+                    }
+                }
+            }
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                for idx in row_id_range {
+                    let val = self.get_val(idx);
+                    if val >= threshold {
+                        row_id_hits.push(idx);
+                    }
+                }
+            }
+            ValueRange::LessThan(threshold, _) => {
+                for idx in row_id_range {
+                    let val = self.get_val(idx);
+                    if val < threshold {
+                        row_id_hits.push(idx);
+                    }
+                }
+            }
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                for idx in row_id_range {
+                    let val = self.get_val(idx);
+                    if val <= threshold {
+                        row_id_hits.push(idx);
+                    }
+                }
+            }
+            ValueRange::All => {
+                row_id_hits.extend(row_id_range);
             }
         }
     }
@@ -193,6 +534,17 @@ impl<T: PartialOrd + Default> ColumnValues<T> for EmptyColumnValues {
     fn num_vals(&self) -> u32 {
         0
     }
+
+    fn get_vals_in_value_range(
+        &self,
+        input_indexes: &[u32],
+        input_doc_ids: &[u32],
+        output: &mut Vec<crate::ComparableDoc<Option<T>, crate::DocId>>,
+        value_range: ValueRange<T>,
+    ) {
+        let _ = (input_indexes, input_doc_ids, output, value_range);
+        panic!("Internal Error: Called get_vals_in_value_range of empty column.")
+    }
 }
 
 impl<T: Copy + PartialOrd + Debug + 'static> ColumnValues<T> for Arc<dyn ColumnValues<T>> {
@@ -206,6 +558,18 @@ impl<T: Copy + PartialOrd + Debug + 'static> ColumnValues<T> for Arc<dyn ColumnV
         self.as_ref().get_vals_opt(indexes, output)
     }
 
+    #[inline(always)]
+    fn get_vals_in_value_range(
+        &self,
+        input_indexes: &[u32],
+        input_doc_ids: &[u32],
+        output: &mut Vec<crate::ComparableDoc<Option<T>, crate::DocId>>,
+        value_range: ValueRange<T>,
+    ) {
+        self.as_ref()
+            .get_vals_in_value_range(input_indexes, input_doc_ids, output, value_range)
+    }
+
     #[inline(always)]
     fn min_value(&self) -> T {
         self.as_ref().min_value()
@@ -234,7 +598,7 @@ impl<T: Copy + PartialOrd + Debug + 'static> ColumnValues<T> for Arc<dyn ColumnV
     #[inline(always)]
     fn get_row_ids_for_value_range(
         &self,
-        range: RangeInclusive<T>,
+        range: ValueRange<T>,
         doc_id_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {

columnar/src/column_values/monotonic_column.rs

@@ -1,8 +1,9 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
-use std::ops::{Range, RangeInclusive};
+use std::ops::Range;
 
 use crate::ColumnValues;
+use crate::column::ValueRange;
 use crate::column_values::monotonic_mapping::StrictlyMonotonicFn;
 
 struct MonotonicMappingColumn<C, T, Input> {
@@ -80,16 +81,52 @@ where
 
     fn get_row_ids_for_value_range(
         &self,
-        range: RangeInclusive<Output>,
+        range: ValueRange<Output>,
         doc_id_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {
-        self.from_column.get_row_ids_for_value_range(
-            self.monotonic_mapping.inverse(range.start().clone())
-                ..=self.monotonic_mapping.inverse(range.end().clone()),
-            doc_id_range,
-            positions,
-        )
+        match range {
+            ValueRange::Inclusive(range) => self.from_column.get_row_ids_for_value_range(
+                ValueRange::Inclusive(
+                    self.monotonic_mapping.inverse(range.start().clone())
+                        ..=self.monotonic_mapping.inverse(range.end().clone()),
+                ),
+                doc_id_range,
+                positions,
+            ),
+            ValueRange::All => self.from_column.get_row_ids_for_value_range(
+                ValueRange::All,
+                doc_id_range,
+                positions,
+            ),
+            ValueRange::GreaterThan(threshold, _) => self.from_column.get_row_ids_for_value_range(
+                ValueRange::GreaterThan(self.monotonic_mapping.inverse(threshold), false),
+                doc_id_range,
+                positions,
+            ),
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                self.from_column.get_row_ids_for_value_range(
+                    ValueRange::GreaterThanOrEqual(
+                        self.monotonic_mapping.inverse(threshold),
+                        false,
+                    ),
+                    doc_id_range,
+                    positions,
+                )
+            }
+            ValueRange::LessThan(threshold, _) => self.from_column.get_row_ids_for_value_range(
+                ValueRange::LessThan(self.monotonic_mapping.inverse(threshold), false),
+                doc_id_range,
+                positions,
+            ),
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                self.from_column.get_row_ids_for_value_range(
+                    ValueRange::LessThanOrEqual(self.monotonic_mapping.inverse(threshold), false),
+                    doc_id_range,
+                    positions,
+                )
+            }
+        }
     }
 
     // We voluntarily do not implement get_range as it yields a regression,

columnar/src/column_values/stats.rs

@@ -2,7 +2,8 @@ use std::io;
 use std::io::Write;
 use std::num::NonZeroU64;
 
-use common::{BinarySerializable, VInt};
+use common::file_slice::FileSlice;
+use common::{BinarySerializable, HasLen, VInt};
 
 use crate::RowId;
 
@@ -27,6 +28,55 @@ impl ColumnStats {
     }
 }
 
+impl ColumnStats {
+    /// Deserialize from the tail of the given FileSlice, and return the stats and remaining prefix
+    /// FileSlice.
+    pub fn deserialize_from_tail(file_slice: FileSlice) -> io::Result<(Self, FileSlice)> {
+        // [`deserialize_with_size`] deserializes 4 variable-width encoded u64s, which
+        // could end up being, in the worst case, 9 bytes each. this is where the 36 comes from
+        let (stats, _) = file_slice.clone().split(36.min(file_slice.len())); // hope that's enough bytes
+        let mut stats = stats.read_bytes()?;
+        let (stats, stats_nbytes) = ColumnStats::deserialize_with_size(&mut stats)?;
+        let (_, remainder) = file_slice.split(stats_nbytes);
+        Ok((stats, remainder))
+    }
+
+    /// Same as [`BinarySeerializable::deserialize`] but also returns the number of bytes
+    /// consumed from the reader `R`
+    fn deserialize_with_size<R: io::Read>(reader: &mut R) -> io::Result<(Self, usize)> {
+        let mut nbytes = 0;
+
+        let (min_value, len) = VInt::deserialize_with_size(reader)?;
+        let min_value = min_value.0;
+        nbytes += len;
+
+        let (gcd, len) = VInt::deserialize_with_size(reader)?;
+        let gcd = gcd.0;
+        let gcd = NonZeroU64::new(gcd)
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "GCD of 0 is forbidden"))?;
+        nbytes += len;
+
+        let (amplitude, len) = VInt::deserialize_with_size(reader)?;
+        let amplitude = amplitude.0 * gcd.get();
+        let max_value = min_value + amplitude;
+        nbytes += len;
+
+        let (num_rows, len) = VInt::deserialize_with_size(reader)?;
+        let num_rows = num_rows.0 as RowId;
+        nbytes += len;
+
+        Ok((
+            ColumnStats {
+                min_value,
+                max_value,
+                num_rows,
+                gcd,
+            },
+            nbytes,
+        ))
+    }
+}
+
 impl BinarySerializable for ColumnStats {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         VInt(self.min_value).serialize(writer)?;

columnar/src/column_values/u128_based/compact_space/mod.rs

@@ -25,6 +25,7 @@ use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt, VIntU128};
 use tantivy_bitpacker::{BitPacker, BitUnpacker};
 
 use crate::RowId;
+use crate::column::ValueRange;
 use crate::column_values::ColumnValues;
 
 /// The cost per blank is quite hard actually, since blanks are delta encoded, the actual cost of
@@ -292,19 +293,6 @@ impl BinarySerializable for IPCodecParams {
     }
 }
 
-/// Represents the result of looking up a u128 value in the compact space.
-///
-/// If a value is outside the compact space, the next compact value is returned.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CompactHit {
-    /// The value exists in the compact space
-    Exact(u32),
-    /// The value does not exist in the compact space, but the next higher value does
-    Next(u32),
-    /// The value is greater than the maximum compact value
-    AfterLast,
-}
-
 /// Exposes the compact space compressed values as u64.
 ///
 /// This allows faster access to the values, as u64 is faster to work with than u128.
@@ -322,11 +310,6 @@ impl CompactSpaceU64Accessor {
     pub fn compact_to_u128(&self, compact: u32) -> u128 {
         self.0.compact_to_u128(compact)
     }
-
-    /// Finds the next compact space value for a given u128 value.
-    pub fn u128_to_next_compact(&self, value: u128) -> CompactHit {
-        self.0.u128_to_next_compact(value)
-    }
 }
 
 impl ColumnValues<u64> for CompactSpaceU64Accessor {
@@ -356,14 +339,48 @@ impl ColumnValues<u64> for CompactSpaceU64Accessor {
     #[inline]
     fn get_row_ids_for_value_range(
         &self,
-        value_range: RangeInclusive<u64>,
+        value_range: ValueRange<u64>,
         position_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {
-        let value_range = self.0.compact_to_u128(*value_range.start() as u32)
-            ..=self.0.compact_to_u128(*value_range.end() as u32);
-        self.0
-            .get_row_ids_for_value_range(value_range, position_range, positions)
+        match value_range {
+            ValueRange::Inclusive(value_range) => {
+                let value_range = ValueRange::Inclusive(
+                    self.0.compact_to_u128(*value_range.start() as u32)
+                        ..=self.0.compact_to_u128(*value_range.end() as u32),
+                );
+                self.0
+                    .get_row_ids_for_value_range(value_range, position_range, positions)
+            }
+            ValueRange::All => {
+                let position_range = position_range.start..position_range.end.min(self.num_vals());
+                positions.extend(position_range);
+            }
+            ValueRange::GreaterThan(threshold, _) => {
+                let value_range =
+                    ValueRange::GreaterThan(self.0.compact_to_u128(threshold as u32), false);
+                self.0
+                    .get_row_ids_for_value_range(value_range, position_range, positions)
+            }
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                let value_range =
+                    ValueRange::GreaterThanOrEqual(self.0.compact_to_u128(threshold as u32), false);
+                self.0
+                    .get_row_ids_for_value_range(value_range, position_range, positions)
+            }
+            ValueRange::LessThan(threshold, _) => {
+                let value_range =
+                    ValueRange::LessThan(self.0.compact_to_u128(threshold as u32), false);
+                self.0
+                    .get_row_ids_for_value_range(value_range, position_range, positions)
+            }
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                let value_range =
+                    ValueRange::LessThanOrEqual(self.0.compact_to_u128(threshold as u32), false);
+                self.0
+                    .get_row_ids_for_value_range(value_range, position_range, positions)
+            }
+        }
     }
 }
 
@@ -393,10 +410,47 @@ impl ColumnValues<u128> for CompactSpaceDecompressor {
     #[inline]
     fn get_row_ids_for_value_range(
         &self,
-        value_range: RangeInclusive<u128>,
+        value_range: ValueRange<u128>,
         position_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {
+        let value_range = match value_range {
+            ValueRange::Inclusive(value_range) => value_range,
+            ValueRange::All => {
+                let position_range = position_range.start..position_range.end.min(self.num_vals());
+                positions.extend(position_range);
+                return;
+            }
+            ValueRange::GreaterThan(threshold, _) => {
+                let max = self.max_value();
+                if threshold >= max {
+                    return;
+                }
+                (threshold + 1)..=max
+            }
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                let max = self.max_value();
+                if threshold > max {
+                    return;
+                }
+                threshold..=max
+            }
+            ValueRange::LessThan(threshold, _) => {
+                let min = self.min_value();
+                if threshold <= min {
+                    return;
+                }
+                min..=(threshold - 1)
+            }
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                let min = self.min_value();
+                if threshold < min {
+                    return;
+                }
+                min..=threshold
+            }
+        };
+
         if value_range.start() > value_range.end() {
             return;
         }
@@ -459,21 +513,6 @@ impl CompactSpaceDecompressor {
         self.params.compact_space.u128_to_compact(value)
     }
 
-    /// Finds the next compact space value for a given u128 value.
-    pub fn u128_to_next_compact(&self, value: u128) -> CompactHit {
-        match self.u128_to_compact(value) {
-            Ok(compact) => CompactHit::Exact(compact),
-            Err(pos) => {
-                if pos >= self.params.compact_space.ranges_mapping.len() {
-                    CompactHit::AfterLast
-                } else {
-                    let next_range = &self.params.compact_space.ranges_mapping[pos];
-                    CompactHit::Next(next_range.compact_start)
-                }
-            }
-        }
-    }
-
     fn compact_to_u128(&self, compact: u32) -> u128 {
         self.params.compact_space.compact_to_u128(compact)
     }
@@ -593,7 +632,7 @@ mod tests {
                     .collect::<Vec<_>>();
                 let mut positions = Vec::new();
                 decompressor.get_row_ids_for_value_range(
-                    range,
+                    ValueRange::Inclusive(range),
                     0..decompressor.num_vals(),
                     &mut positions,
                 );
@@ -637,7 +676,11 @@ mod tests {
             let val = *val;
             let pos = pos as u32;
             let mut positions = Vec::new();
-            decomp.get_row_ids_for_value_range(val..=val, pos..pos + 1, &mut positions);
+            decomp.get_row_ids_for_value_range(
+                ValueRange::Inclusive(val..=val),
+                pos..pos + 1,
+                &mut positions,
+            );
             assert_eq!(positions, vec![pos]);
         }
 
@@ -779,7 +822,11 @@ mod tests {
         doc_id_range: Range<u32>,
     ) -> Vec<u32> {
         let mut positions = Vec::new();
-        column.get_row_ids_for_value_range(value_range, doc_id_range, &mut positions);
+        column.get_row_ids_for_value_range(
+            ValueRange::Inclusive(value_range),
+            doc_id_range,
+            &mut positions,
+        );
         positions
     }
 
@@ -802,7 +849,7 @@ mod tests {
         ];
         let mut out = Vec::new();
         serialize_column_values_u128(&&vals[..], &mut out).unwrap();
-        let decomp = open_u128_mapped(OwnedBytes::new(out)).unwrap();
+        let decomp = open_u128_mapped(FileSlice::from(out)).unwrap();
         let complete_range = 0..vals.len() as u32;
 
         assert_eq!(
@@ -856,41 +903,7 @@ mod tests {
         let _data = test_aux_vals(vals);
     }
 
-    #[test]
-    fn test_u128_to_next_compact() {
-        let vals = &[100u128, 200u128, 1_000_000_000u128, 1_000_000_100u128];
-        let mut data = test_aux_vals(vals);
-
-        let _header = U128Header::deserialize(&mut data);
-        let decomp = CompactSpaceDecompressor::open(data).unwrap();
-
-        // Test value that's already in a range
-        let compact_100 = decomp.u128_to_compact(100).unwrap();
-        assert_eq!(
-            decomp.u128_to_next_compact(100),
-            CompactHit::Exact(compact_100)
-        );
-
-        // Test value between two ranges
-        let compact_million = decomp.u128_to_compact(1_000_000_000).unwrap();
-        assert_eq!(
-            decomp.u128_to_next_compact(250),
-            CompactHit::Next(compact_million)
-        );
-
-        // Test value before the first range
-        assert_eq!(
-            decomp.u128_to_next_compact(50),
-            CompactHit::Next(compact_100)
-        );
-
-        // Test value after the last range
-        assert_eq!(
-            decomp.u128_to_next_compact(10_000_000_000),
-            CompactHit::AfterLast
-        );
-    }
-
+    use common::file_slice::FileSlice;
     use proptest::prelude::*;
 
     fn num_strategy() -> impl Strategy<Value = u128> {

columnar/src/column_values/u128_based/mod.rs

@@ -5,9 +5,10 @@ use std::sync::Arc;
 
 mod compact_space;
 
-use common::{BinarySerializable, OwnedBytes, VInt};
+use common::file_slice::FileSlice;
+use common::{BinarySerializable, VInt};
 pub use compact_space::{
-    CompactHit, CompactSpaceCompressor, CompactSpaceDecompressor, CompactSpaceU64Accessor,
+    CompactSpaceCompressor, CompactSpaceDecompressor, CompactSpaceU64Accessor,
 };
 
 use crate::column_values::monotonic_map_column;
@@ -101,8 +102,9 @@ impl U128FastFieldCodecType {
 
 /// Returns the correct codec reader wrapped in the `Arc` for the data.
 pub fn open_u128_mapped<T: MonotonicallyMappableToU128 + Debug>(
-    mut bytes: OwnedBytes,
+    file_slice: FileSlice,
 ) -> io::Result<Arc<dyn ColumnValues<T>>> {
+    let mut bytes = file_slice.read_bytes()?;
     let header = U128Header::deserialize(&mut bytes)?;
     assert_eq!(header.codec_type, U128FastFieldCodecType::CompactSpace);
     let reader = CompactSpaceDecompressor::open(bytes)?;
@@ -120,7 +122,8 @@ pub fn open_u128_mapped<T: MonotonicallyMappableToU128 + Debug>(
 /// # Notice
 /// In case there are new codecs added, check for usages of `CompactSpaceDecompressorU64` and
 /// also handle the new codecs.
-pub fn open_u128_as_compact_u64(mut bytes: OwnedBytes) -> io::Result<Arc<dyn ColumnValues<u64>>> {
+pub fn open_u128_as_compact_u64(file_slice: FileSlice) -> io::Result<Arc<dyn ColumnValues<u64>>> {
+    let mut bytes = file_slice.read_bytes()?;
     let header = U128Header::deserialize(&mut bytes)?;
     assert_eq!(header.codec_type, U128FastFieldCodecType::CompactSpace);
     let reader = CompactSpaceU64Accessor::open(bytes)?;

columnar/src/column_values/u64_based/bitpacked.rs

@@ -1,11 +1,14 @@
 use std::io::{self, Write};
 use std::num::NonZeroU64;
 use std::ops::{Range, RangeInclusive};
+use std::sync::{Arc, OnceLock};
 
-use common::{BinarySerializable, OwnedBytes};
+use common::file_slice::FileSlice;
+use common::{BinarySerializable, HasLen, OwnedBytes};
 use fastdivide::DividerU64;
 use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
 
+use crate::column::ValueRange;
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
 use crate::{ColumnValues, RowId};
 
@@ -13,9 +16,40 @@ use crate::{ColumnValues, RowId};
 /// fast field is required.
 #[derive(Clone)]
 pub struct BitpackedReader {
-    data: OwnedBytes,
+    data: FileSlice,
     bit_unpacker: BitUnpacker,
     stats: ColumnStats,
+    blocks: Arc<[OnceLock<Block>]>,
+}
+
+impl BitpackedReader {
+    #[inline(always)]
+    fn unpack_val(&self, doc: u32) -> u64 {
+        let block_num = self.bit_unpacker.block_num(doc);
+
+        if block_num == 0 && self.blocks.len() == 0 {
+            return 0;
+        }
+
+        let block = self.blocks[block_num].get_or_init(|| {
+            let block_range = self.bit_unpacker.block(block_num, self.data.len());
+            let offset = block_range.start;
+            let data = self
+                .data
+                .slice(block_range)
+                .read_bytes()
+                .expect("Failed to read column values.");
+            Block { offset, data }
+        });
+
+        self.bit_unpacker
+            .get_from_subset(doc, block.offset, &block.data)
+    }
+}
+
+struct Block {
+    offset: usize,
+    data: OwnedBytes,
 }
 
 #[inline(always)]
@@ -41,6 +75,12 @@ fn transform_range_before_linear_transformation(
     if range.is_empty() {
         return None;
     }
+    if stats.min_value > *range.end() {
+        return None;
+    }
+    if stats.max_value < *range.start() {
+        return None;
+    }
     let shifted_range =
         range.start().saturating_sub(stats.min_value)..=range.end().saturating_sub(stats.min_value);
     let start_before_gcd_multiplication: u64 = div_ceil(*shifted_range.start(), stats.gcd);
@@ -51,8 +91,9 @@ fn transform_range_before_linear_transformation(
 impl ColumnValues for BitpackedReader {
     #[inline(always)]
     fn get_val(&self, doc: u32) -> u64 {
-        self.stats.min_value + self.stats.gcd.get() * self.bit_unpacker.get(doc, &self.data)
+        self.stats.min_value + self.stats.gcd.get() * self.unpack_val(doc)
     }
+
     #[inline]
     fn min_value(&self) -> u64 {
         self.stats.min_value
@@ -66,24 +107,329 @@ impl ColumnValues for BitpackedReader {
         self.stats.num_rows
     }
 
+    fn get_vals_in_value_range(
+        &self,
+        input_indexes: &[u32],
+        input_doc_ids: &[u32],
+        output: &mut Vec<crate::ComparableDoc<Option<u64>, crate::DocId>>,
+        value_range: ValueRange<u64>,
+    ) {
+        match value_range {
+            ValueRange::All => {
+                for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                    output.push(crate::ComparableDoc {
+                        doc,
+                        sort_key: Some(self.get_val(idx)),
+                    });
+                }
+            }
+            ValueRange::Inclusive(range) => {
+                if let Some(transformed_range) =
+                    transform_range_before_linear_transformation(&self.stats, range)
+                {
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        let raw_val = self.unpack_val(idx);
+                        if transformed_range.contains(&raw_val) {
+                            output.push(crate::ComparableDoc {
+                                doc,
+                                sort_key: Some(
+                                    self.stats.min_value + self.stats.gcd.get() * raw_val,
+                                ),
+                            });
+                        }
+                    }
+                }
+            }
+            ValueRange::GreaterThan(threshold, _) => {
+                if threshold < self.stats.min_value {
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        output.push(crate::ComparableDoc {
+                            doc,
+                            sort_key: Some(self.get_val(idx)),
+                        });
+                    }
+                } else if threshold >= self.stats.max_value {
+                    // All filtered out
+                } else {
+                    let raw_threshold = (threshold - self.stats.min_value) / self.stats.gcd.get();
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        let raw_val = self.unpack_val(idx);
+                        if raw_val > raw_threshold {
+                            output.push(crate::ComparableDoc {
+                                doc,
+                                sort_key: Some(
+                                    self.stats.min_value + self.stats.gcd.get() * raw_val,
+                                ),
+                            });
+                        }
+                    }
+                }
+            }
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                if threshold <= self.stats.min_value {
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        output.push(crate::ComparableDoc {
+                            doc,
+                            sort_key: Some(self.get_val(idx)),
+                        });
+                    }
+                } else if threshold > self.stats.max_value {
+                    // All filtered out
+                } else {
+                    let diff = threshold - self.stats.min_value;
+                    let gcd = self.stats.gcd.get();
+                    let raw_threshold = (diff + gcd - 1) / gcd;
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        let raw_val = self.unpack_val(idx);
+                        if raw_val >= raw_threshold {
+                            output.push(crate::ComparableDoc {
+                                doc,
+                                sort_key: Some(
+                                    self.stats.min_value + self.stats.gcd.get() * raw_val,
+                                ),
+                            });
+                        }
+                    }
+                }
+            }
+            ValueRange::LessThan(threshold, _) => {
+                if threshold > self.stats.max_value {
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        output.push(crate::ComparableDoc {
+                            doc,
+                            sort_key: Some(self.get_val(idx)),
+                        });
+                    }
+                } else if threshold <= self.stats.min_value {
+                    // All filtered out
+                } else {
+                    let diff = threshold - self.stats.min_value;
+                    let gcd = self.stats.gcd.get();
+                    let raw_threshold = if diff % gcd == 0 {
+                        diff / gcd
+                    } else {
+                        diff / gcd + 1
+                    };
+
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        let raw_val = self.unpack_val(idx);
+                        if raw_val < raw_threshold {
+                            output.push(crate::ComparableDoc {
+                                doc,
+                                sort_key: Some(
+                                    self.stats.min_value + self.stats.gcd.get() * raw_val,
+                                ),
+                            });
+                        }
+                    }
+                }
+            }
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                if threshold >= self.stats.max_value {
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        output.push(crate::ComparableDoc {
+                            doc,
+                            sort_key: Some(self.get_val(idx)),
+                        });
+                    }
+                } else if threshold < self.stats.min_value {
+                    // All filtered out
+                } else {
+                    let diff = threshold - self.stats.min_value;
+                    let gcd = self.stats.gcd.get();
+                    let raw_threshold = diff / gcd;
+
+                    for (&idx, &doc) in input_indexes.iter().zip(input_doc_ids.iter()) {
+                        let raw_val = self.unpack_val(idx);
+                        if raw_val <= raw_threshold {
+                            output.push(crate::ComparableDoc {
+                                doc,
+                                sort_key: Some(
+                                    self.stats.min_value + self.stats.gcd.get() * raw_val,
+                                ),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
     fn get_row_ids_for_value_range(
         &self,
-        range: RangeInclusive<u64>,
+        range: ValueRange<u64>,
         doc_id_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {
-        let Some(transformed_range) =
-            transform_range_before_linear_transformation(&self.stats, range)
-        else {
-            positions.clear();
-            return;
-        };
-        self.bit_unpacker.get_ids_for_value_range(
-            transformed_range,
-            doc_id_range,
-            &self.data,
-            positions,
-        );
+        match range {
+            ValueRange::All => {
+                positions.extend(doc_id_range);
+                return;
+            }
+            ValueRange::Inclusive(range) => {
+                let Some(transformed_range) =
+                    transform_range_before_linear_transformation(&self.stats, range)
+                else {
+                    positions.clear();
+                    return;
+                };
+                // TODO: This does not use the `self.blocks` cache, because callers are usually
+                // already doing sequential, and fairly dense reads. Fix it to
+                // iterate over blocks if that assumption turns out to be incorrect!
+                let data_range = self
+                    .bit_unpacker
+                    .block_oblivious_range(doc_id_range.clone(), self.data.len());
+                let data_offset = data_range.start;
+                let data_subset = self
+                    .data
+                    .slice(data_range)
+                    .read_bytes()
+                    .expect("Failed to read column values.");
+                self.bit_unpacker.get_ids_for_value_range_from_subset(
+                    transformed_range,
+                    doc_id_range,
+                    data_offset,
+                    &data_subset,
+                    positions,
+                );
+            }
+            ValueRange::GreaterThan(threshold, _) => {
+                if threshold < self.stats.min_value {
+                    positions.extend(doc_id_range);
+                    return;
+                }
+                if threshold >= self.stats.max_value {
+                    return;
+                }
+                let raw_threshold = (threshold - self.stats.min_value) / self.stats.gcd.get();
+                // We want raw > raw_threshold.
+                // bit_unpacker.get_ids_for_value_range_from_subset takes a RangeInclusive.
+                // We can construct a RangeInclusive: (raw_threshold + 1) ..= u64::MAX
+                // But max raw value is known? (max_value - min_value) / gcd.
+                let max_raw = (self.stats.max_value - self.stats.min_value) / self.stats.gcd.get();
+                let transformed_range = (raw_threshold + 1)..=max_raw;
+
+                let data_range = self
+                    .bit_unpacker
+                    .block_oblivious_range(doc_id_range.clone(), self.data.len());
+                let data_offset = data_range.start;
+                let data_subset = self
+                    .data
+                    .slice(data_range)
+                    .read_bytes()
+                    .expect("Failed to read column values.");
+                self.bit_unpacker.get_ids_for_value_range_from_subset(
+                    transformed_range,
+                    doc_id_range,
+                    data_offset,
+                    &data_subset,
+                    positions,
+                );
+            }
+            ValueRange::GreaterThanOrEqual(threshold, _) => {
+                if threshold <= self.stats.min_value {
+                    positions.extend(doc_id_range);
+                    return;
+                }
+                if threshold > self.stats.max_value {
+                    return;
+                }
+                let diff = threshold - self.stats.min_value;
+                let gcd = self.stats.gcd.get();
+                let raw_threshold = (diff + gcd - 1) / gcd;
+                // We want raw >= raw_threshold.
+                let max_raw = (self.stats.max_value - self.stats.min_value) / self.stats.gcd.get();
+                let transformed_range = raw_threshold..=max_raw;
+
+                let data_range = self
+                    .bit_unpacker
+                    .block_oblivious_range(doc_id_range.clone(), self.data.len());
+                let data_offset = data_range.start;
+                let data_subset = self
+                    .data
+                    .slice(data_range)
+                    .read_bytes()
+                    .expect("Failed to read column values.");
+                self.bit_unpacker.get_ids_for_value_range_from_subset(
+                    transformed_range,
+                    doc_id_range,
+                    data_offset,
+                    &data_subset,
+                    positions,
+                );
+            }
+            ValueRange::LessThan(threshold, _) => {
+                if threshold > self.stats.max_value {
+                    positions.extend(doc_id_range);
+                    return;
+                }
+                if threshold <= self.stats.min_value {
+                    return;
+                }
+
+                let diff = threshold - self.stats.min_value;
+                let gcd = self.stats.gcd.get();
+                // We want raw < raw_threshold_limit
+                // raw <= raw_threshold_limit - 1
+                let raw_threshold_limit = if diff % gcd == 0 {
+                    diff / gcd
+                } else {
+                    diff / gcd + 1
+                };
+
+                if raw_threshold_limit == 0 {
+                    return;
+                }
+                let transformed_range = 0..=(raw_threshold_limit - 1);
+
+                let data_range = self
+                    .bit_unpacker
+                    .block_oblivious_range(doc_id_range.clone(), self.data.len());
+                let data_offset = data_range.start;
+                let data_subset = self
+                    .data
+                    .slice(data_range)
+                    .read_bytes()
+                    .expect("Failed to read column values.");
+                self.bit_unpacker.get_ids_for_value_range_from_subset(
+                    transformed_range,
+                    doc_id_range,
+                    data_offset,
+                    &data_subset,
+                    positions,
+                );
+            }
+            ValueRange::LessThanOrEqual(threshold, _) => {
+                if threshold >= self.stats.max_value {
+                    positions.extend(doc_id_range);
+                    return;
+                }
+                if threshold < self.stats.min_value {
+                    return;
+                }
+                let diff = threshold - self.stats.min_value;
+                let gcd = self.stats.gcd.get();
+                // We want raw <= raw_threshold.
+                let raw_threshold = diff / gcd;
+                let transformed_range = 0..=raw_threshold;
+
+                let data_range = self
+                    .bit_unpacker
+                    .block_oblivious_range(doc_id_range.clone(), self.data.len());
+                let data_offset = data_range.start;
+                let data_subset = self
+                    .data
+                    .slice(data_range)
+                    .read_bytes()
+                    .expect("Failed to read column values.");
+                self.bit_unpacker.get_ids_for_value_range_from_subset(
+                    transformed_range,
+                    doc_id_range,
+                    data_offset,
+                    &data_subset,
+                    positions,
+                );
+            }
+        }
     }
 }
 
@@ -127,14 +473,20 @@ impl ColumnCodec for BitpackedCodec {
     type Estimator = BitpackedCodecEstimator;
 
     /// Opens a fast field given a file.
-    fn load(mut data: OwnedBytes) -> io::Result<Self::ColumnValues> {
-        let stats = ColumnStats::deserialize(&mut data)?;
+    fn load(file_slice: FileSlice) -> io::Result<Self::ColumnValues> {
+        let (stats, data) = ColumnStats::deserialize_from_tail(file_slice)?;
+
         let num_bits = num_bits(&stats);
         let bit_unpacker = BitUnpacker::new(num_bits);
+        let block_count = bit_unpacker.block_count(data.len());
         Ok(BitpackedReader {
             data,
             bit_unpacker,
             stats,
+            blocks: (0..block_count)
+                .into_iter()
+                .map(|_| OnceLock::new())
+                .collect(),
         })
     }
 }

columnar/src/column_values/u64_based/blockwise_linear.rs

@@ -1,8 +1,10 @@
+use std::io;
 use std::io::Write;
-use std::sync::Arc;
-use std::{io, iter};
+use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, OnceLock};
 
-use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
+use common::file_slice::FileSlice;
+use common::{BinarySerializable, CountingWriter, DeserializeFrom, HasLen, OwnedBytes};
 use fastdivide::DividerU64;
 use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
 
@@ -172,32 +174,63 @@ impl ColumnCodec<u64> for BlockwiseLinearCodec {
 
     type Estimator = BlockwiseLinearEstimator;
 
-    fn load(mut bytes: OwnedBytes) -> io::Result<Self::ColumnValues> {
-        let stats = ColumnStats::deserialize(&mut bytes)?;
-        let footer_len: u32 = (&bytes[bytes.len() - 4..]).deserialize()?;
-        let footer_offset = bytes.len() - 4 - footer_len as usize;
-        let (data, mut footer) = bytes.split(footer_offset);
+    fn load(file_slice: FileSlice) -> io::Result<Self::ColumnValues> {
+        let (stats, body) = ColumnStats::deserialize_from_tail(file_slice)?;
+
+        let (_, footer) = body.clone().split_from_end(4);
+
+        let footer_len: u32 = footer.read_bytes()?.as_slice().deserialize()?;
+        let (data, footer) = body.split_from_end(footer_len as usize + 4);
+
+        let mut footer = footer.read_bytes()?;
         let num_blocks = compute_num_blocks(stats.num_rows);
-        let mut blocks: Vec<Block> = iter::repeat_with(|| Block::deserialize(&mut footer))
-            .take(num_blocks as usize)
-            .collect::<io::Result<_>>()?;
+
         let mut start_offset = 0;
-        for block in &mut blocks {
+        let mut blocks = Vec::with_capacity(num_blocks as usize);
+
+        for _ in 0..num_blocks {
+            let mut block = Block::deserialize(&mut footer)?;
+            let len = (block.bit_unpacker.bit_width() as usize) * BLOCK_SIZE as usize / 8;
+
             block.data_start_offset = start_offset;
-            start_offset += (block.bit_unpacker.bit_width() as usize) * BLOCK_SIZE as usize / 8;
+            blocks.push(BlockWithData {
+                block,
+                file_slice: data.slice(start_offset..(start_offset + len).min(data.len())),
+                data: Default::default(),
+            });
+
+            start_offset += len;
         }
         Ok(BlockwiseLinearReader {
             blocks: blocks.into_boxed_slice().into(),
-            data,
             stats,
         })
     }
 }
 
+struct BlockWithData {
+    block: Block,
+    file_slice: FileSlice,
+    data: OnceLock<OwnedBytes>,
+}
+
+impl Deref for BlockWithData {
+    type Target = Block;
+
+    fn deref(&self) -> &Self::Target {
+        &self.block
+    }
+}
+
+impl DerefMut for BlockWithData {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.block
+    }
+}
+
 #[derive(Clone)]
 pub struct BlockwiseLinearReader {
-    blocks: Arc<[Block]>,
-    data: OwnedBytes,
+    blocks: Arc<[BlockWithData]>,
     stats: ColumnStats,
 }
 
@@ -208,7 +241,9 @@ impl ColumnValues for BlockwiseLinearReader {
         let idx_within_block = idx % BLOCK_SIZE;
         let block = &self.blocks[block_id];
         let interpoled_val: u64 = block.line.eval(idx_within_block);
-        let block_bytes = &self.data[block.data_start_offset..];
+        let block_bytes = block
+            .data
+            .get_or_init(|| block.file_slice.read_bytes().unwrap());
         let bitpacked_diff = block.bit_unpacker.get(idx_within_block, block_bytes);
         // TODO optimize me! the line parameters could be tweaked to include the multiplication and
         // remove the dependency.

columnar/src/column_values/u64_based/linear.rs

@@ -1,5 +1,6 @@
 use std::io;
 
+use common::file_slice::FileSlice;
 use common::{BinarySerializable, OwnedBytes};
 use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
 
@@ -190,7 +191,8 @@ impl ColumnCodec for LinearCodec {
 
     type Estimator = LinearCodecEstimator;
 
-    fn load(mut data: OwnedBytes) -> io::Result<Self::ColumnValues> {
+    fn load(file_slice: FileSlice) -> io::Result<Self::ColumnValues> {
+        let mut data = file_slice.read_bytes()?;
         let stats = ColumnStats::deserialize(&mut data)?;
         let linear_params = LinearParams::deserialize(&mut data)?;
         Ok(LinearReader {
@@ -268,7 +270,7 @@ mod tests {
 
     #[test]
     fn linear_interpol_fast_field_rand() {
-        let mut rng = rand::rng();
+        let mut rng = rand::thread_rng();
         for _ in 0..50 {
             let mut data = (0..10_000).map(|_| rng.next_u64()).collect::<Vec<_>>();
             create_and_validate::<LinearCodec>(&data, "random");

columnar/src/column_values/u64_based/mod.rs

@@ -8,7 +8,8 @@ use std::io;
 use std::io::Write;
 use std::sync::Arc;
 
-use common::{BinarySerializable, OwnedBytes};
+use common::BinarySerializable;
+use common::file_slice::FileSlice;
 
 use crate::column_values::monotonic_mapping::{
     StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
@@ -60,7 +61,7 @@ pub trait ColumnCodec<T: PartialOrd = u64> {
     type Estimator: ColumnCodecEstimator + Default;
 
     /// Loads a column that has been serialized using this codec.
-    fn load(bytes: OwnedBytes) -> io::Result<Self::ColumnValues>;
+    fn load(file_slice: FileSlice) -> io::Result<Self::ColumnValues>;
 
     /// Returns an estimator.
     fn estimator() -> Self::Estimator {
@@ -111,20 +112,22 @@ impl CodecType {
 
     fn load<T: MonotonicallyMappableToU64>(
         &self,
-        bytes: OwnedBytes,
+        file_slice: FileSlice,
     ) -> io::Result<Arc<dyn ColumnValues<T>>> {
         match self {
-            CodecType::Bitpacked => load_specific_codec::<BitpackedCodec, T>(bytes),
-            CodecType::Linear => load_specific_codec::<LinearCodec, T>(bytes),
-            CodecType::BlockwiseLinear => load_specific_codec::<BlockwiseLinearCodec, T>(bytes),
+            CodecType::Bitpacked => load_specific_codec::<BitpackedCodec, T>(file_slice),
+            CodecType::Linear => load_specific_codec::<LinearCodec, T>(file_slice),
+            CodecType::BlockwiseLinear => {
+                load_specific_codec::<BlockwiseLinearCodec, T>(file_slice)
+            }
         }
     }
 }
 
 fn load_specific_codec<C: ColumnCodec, T: MonotonicallyMappableToU64>(
-    bytes: OwnedBytes,
+    file_slice: FileSlice,
 ) -> io::Result<Arc<dyn ColumnValues<T>>> {
-    let reader = C::load(bytes)?;
+    let reader = C::load(file_slice)?;
     let reader_typed = monotonic_map_column(
         reader,
         StrictlyMonotonicMappingInverter::from(StrictlyMonotonicMappingToInternal::<T>::new()),
@@ -189,25 +192,28 @@ pub fn serialize_u64_based_column_values<T: MonotonicallyMappableToU64>(
 ///
 /// This method first identifies the codec off the first byte.
 pub fn load_u64_based_column_values<T: MonotonicallyMappableToU64>(
-    mut bytes: OwnedBytes,
+    file_slice: FileSlice,
 ) -> io::Result<Arc<dyn ColumnValues<T>>> {
-    let codec_type: CodecType = bytes
-        .first()
-        .copied()
+    let (header, body) = file_slice.split(1);
+    let codec_type: CodecType = header
+        .read_bytes()?
+        .as_slice()
+        .get(0)
+        .cloned()
         .and_then(CodecType::try_from_code)
         .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "Failed to read codec type"))?;
-    bytes.advance(1);
-    codec_type.load(bytes)
+    codec_type.load(body)
 }
 
 /// Helper function to serialize a column (autodetect from all codecs) and then open it
+#[cfg(test)]
 pub fn serialize_and_load_u64_based_column_values<T: MonotonicallyMappableToU64>(
     vals: &dyn Iterable,
     codec_types: &[CodecType],
 ) -> Arc<dyn ColumnValues<T>> {
     let mut buffer = Vec::new();
     serialize_u64_based_column_values(vals, codec_types, &mut buffer).unwrap();
-    load_u64_based_column_values::<T>(OwnedBytes::new(buffer)).unwrap()
+    load_u64_based_column_values::<T>(FileSlice::from(buffer)).unwrap()
 }
 
 #[cfg(test)]

columnar/src/column_values/u64_based/tests.rs

@@ -1,3 +1,4 @@
+use common::HasLen;
 use proptest::prelude::*;
 use proptest::{prop_oneof, proptest};
 use rand::Rng;
@@ -13,7 +14,7 @@ fn test_serialize_and_load_simple() {
     )
     .unwrap();
     assert_eq!(buffer.len(), 7);
-    let col = load_u64_based_column_values::<u64>(OwnedBytes::new(buffer)).unwrap();
+    let col = load_u64_based_column_values::<u64>(FileSlice::from(buffer)).unwrap();
     assert_eq!(col.num_vals(), 3);
     assert_eq!(col.get_val(0), 1);
     assert_eq!(col.get_val(1), 2);
@@ -30,7 +31,7 @@ fn test_empty_column_i64() {
             continue;
         }
         num_acceptable_codecs += 1;
-        let col = load_u64_based_column_values::<i64>(OwnedBytes::new(buffer)).unwrap();
+        let col = load_u64_based_column_values::<i64>(FileSlice::from(buffer)).unwrap();
         assert_eq!(col.num_vals(), 0);
         assert_eq!(col.min_value(), i64::MIN);
         assert_eq!(col.max_value(), i64::MIN);
@@ -48,7 +49,7 @@ fn test_empty_column_u64() {
             continue;
         }
         num_acceptable_codecs += 1;
-        let col = load_u64_based_column_values::<u64>(OwnedBytes::new(buffer)).unwrap();
+        let col = load_u64_based_column_values::<u64>(FileSlice::from(buffer)).unwrap();
         assert_eq!(col.num_vals(), 0);
         assert_eq!(col.min_value(), u64::MIN);
         assert_eq!(col.max_value(), u64::MIN);
@@ -66,7 +67,7 @@ fn test_empty_column_f64() {
             continue;
         }
         num_acceptable_codecs += 1;
-        let col = load_u64_based_column_values::<f64>(OwnedBytes::new(buffer)).unwrap();
+        let col = load_u64_based_column_values::<f64>(FileSlice::from(buffer)).unwrap();
         assert_eq!(col.num_vals(), 0);
         // FIXME. f64::MIN would be better!
         assert!(col.min_value().is_nan());
@@ -97,7 +98,7 @@ pub(crate) fn create_and_validate<TColumnCodec: ColumnCodec>(
 
     let actual_compression = buffer.len() as u64;
 
-    let reader = TColumnCodec::load(OwnedBytes::new(buffer)).unwrap();
+    let reader = TColumnCodec::load(FileSlice::from(buffer)).unwrap();
     assert_eq!(reader.num_vals(), vals.len() as u32);
     let mut buffer = Vec::new();
     for (doc, orig_val) in vals.iter().copied().enumerate() {
@@ -122,7 +123,7 @@ pub(crate) fn create_and_validate<TColumnCodec: ColumnCodec>(
     assert_eq!(vals, buffer);
 
     if !vals.is_empty() {
-        let test_rand_idx = rand::rng().random_range(0..=vals.len() - 1);
+        let test_rand_idx = rand::thread_rng().gen_range(0..=vals.len() - 1);
         let expected_positions: Vec<u32> = vals
             .iter()
             .enumerate()
@@ -131,7 +132,7 @@ pub(crate) fn create_and_validate<TColumnCodec: ColumnCodec>(
             .collect();
         let mut positions = Vec::new();
         reader.get_row_ids_for_value_range(
-            vals[test_rand_idx]..=vals[test_rand_idx],
+            crate::column::ValueRange::Inclusive(vals[test_rand_idx]..=vals[test_rand_idx]),
             0..vals.len() as u32,
             &mut positions,
         );
@@ -326,7 +327,7 @@ fn test_fastfield_gcd_i64_with_codec(codec_type: CodecType, num_vals: usize) ->
         &[codec_type],
         &mut buffer,
     )?;
-    let buffer = OwnedBytes::new(buffer);
+    let buffer = FileSlice::from(buffer);
     let column = crate::column_values::load_u64_based_column_values::<i64>(buffer.clone())?;
     assert_eq!(column.get_val(0), -4000i64);
     assert_eq!(column.get_val(1), -3000i64);
@@ -343,7 +344,7 @@ fn test_fastfield_gcd_i64_with_codec(codec_type: CodecType, num_vals: usize) ->
         &[codec_type],
         &mut buffer_without_gcd,
     )?;
-    let buffer_without_gcd = OwnedBytes::new(buffer_without_gcd);
+    let buffer_without_gcd = FileSlice::from(buffer_without_gcd);
     assert!(buffer_without_gcd.len() > buffer.len());
 
     Ok(())
@@ -369,7 +370,7 @@ fn test_fastfield_gcd_u64_with_codec(codec_type: CodecType, num_vals: usize) ->
         &[codec_type],
         &mut buffer,
     )?;
-    let buffer = OwnedBytes::new(buffer);
+    let buffer = FileSlice::from(buffer);
     let column = crate::column_values::load_u64_based_column_values::<u64>(buffer.clone())?;
     assert_eq!(column.get_val(0), 1000u64);
     assert_eq!(column.get_val(1), 2000u64);
@@ -386,7 +387,7 @@ fn test_fastfield_gcd_u64_with_codec(codec_type: CodecType, num_vals: usize) ->
         &[codec_type],
         &mut buffer_without_gcd,
     )?;
-    let buffer_without_gcd = OwnedBytes::new(buffer_without_gcd);
+    let buffer_without_gcd = FileSlice::from(buffer_without_gcd);
     assert!(buffer_without_gcd.len() > buffer.len());
     Ok(())
 }
@@ -405,7 +406,7 @@ fn test_fastfield_gcd_u64() -> io::Result<()> {
 
 #[test]
 pub fn test_fastfield2() {
-    let test_fastfield = crate::column_values::serialize_and_load_u64_based_column_values::<u64>(
+    let test_fastfield = serialize_and_load_u64_based_column_values::<u64>(
         &&[100u64, 200u64, 300u64][..],
         &ALL_U64_CODEC_TYPES,
     );

columnar/src/columnar/merge/mod.rs

@@ -4,6 +4,7 @@ mod term_merger;
 
 use std::collections::{BTreeMap, HashSet};
 use std::io;
+use std::io::ErrorKind;
 use std::net::Ipv6Addr;
 use std::sync::Arc;
 
@@ -78,6 +79,7 @@ pub fn merge_columnar(
     required_columns: &[(String, ColumnType)],
     merge_row_order: MergeRowOrder,
     output: &mut impl io::Write,
+    cancel: impl Fn() -> bool,
 ) -> io::Result<()> {
     let mut serializer = ColumnarSerializer::new(output);
     let num_docs_per_columnar = columnar_readers
@@ -87,6 +89,9 @@ pub fn merge_columnar(
 
     let columns_to_merge = group_columns_for_merge(columnar_readers, required_columns)?;
     for res in columns_to_merge {
+        if cancel() {
+            return Err(io::Error::new(ErrorKind::Interrupted, "Merge cancelled"));
+        }
         let ((column_name, _column_type_category), grouped_columns) = res;
         let grouped_columns = grouped_columns.open(&merge_row_order)?;
         if grouped_columns.is_empty() {

columnar/src/columnar/merge/tests.rs

@@ -205,6 +205,7 @@ fn test_merge_columnar_numbers() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -233,6 +234,7 @@ fn test_merge_columnar_texts() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -282,6 +284,7 @@ fn test_merge_columnar_byte() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -338,6 +341,7 @@ fn test_merge_columnar_byte_with_missing() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -390,6 +394,7 @@ fn test_merge_columnar_different_types() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -455,6 +460,7 @@ fn test_merge_columnar_different_empty_cardinality() {
         &[],
         MergeRowOrder::Stack(stack_merge_order),
         &mut buffer,
+        || false,
     )
     .unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
@@ -565,6 +571,7 @@ proptest! {
             &[],
             MergeRowOrder::Stack(stack_merge_order),
             &mut out,
+            || false,
         ).unwrap();
 
         let merged_reader = ColumnarReader::open(out).unwrap();
@@ -582,6 +589,7 @@ proptest! {
             &[],
             MergeRowOrder::Stack(stack_merge_order),
             &mut out,
+            || false,
         ).unwrap();
 
     }

columnar/src/compat_tests.rs

@@ -71,7 +71,14 @@ fn test_format(path: &str) {
     let columnar_readers = vec![&reader, &reader2];
     let merge_row_order = StackMergeOrder::stack(&columnar_readers[..]);
     let mut out = Vec::new();
-    merge_columnar(&columnar_readers, &[], merge_row_order.into(), &mut out).unwrap();
+    merge_columnar(
+        &columnar_readers,
+        &[],
+        merge_row_order.into(),
+        &mut out,
+        || false,
+    )
+    .unwrap();
     let reader = ColumnarReader::open(out).unwrap();
     check_columns(&reader);
 }

columnar/src/dynamic_column.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use std::{fmt, io};
 
 use common::file_slice::FileSlice;
-use common::{ByteCount, DateTime, OwnedBytes};
+use common::{ByteCount, DateTime};
 use serde::{Deserialize, Serialize};
 
 use crate::column::{BytesColumn, Column, StrColumn};
@@ -239,8 +239,7 @@ pub struct DynamicColumnHandle {
 impl DynamicColumnHandle {
     // TODO rename load
     pub fn open(&self) -> io::Result<DynamicColumn> {
-        let column_bytes: OwnedBytes = self.file_slice.read_bytes()?;
-        self.open_internal(column_bytes)
+        self.open_internal(self.file_slice.clone())
     }
 
     #[doc(hidden)]
@@ -259,16 +258,15 @@ impl DynamicColumnHandle {
     /// If not, the fastfield reader will returns the u64-value associated with the original
     /// FastValue.
     pub fn open_u64_lenient(&self) -> io::Result<Option<Column<u64>>> {
-        let column_bytes = self.file_slice.read_bytes()?;
         match self.column_type {
             ColumnType::Str | ColumnType::Bytes => {
                 let column: BytesColumn =
-                    crate::column::open_column_bytes(column_bytes, self.format_version)?;
+                    crate::column::open_column_bytes(self.file_slice.clone(), self.format_version)?;
                 Ok(Some(column.term_ord_column))
             }
             ColumnType::IpAddr => {
                 let column = crate::column::open_column_u128_as_compact_u64(
-                    column_bytes,
+                    self.file_slice.clone(),
                     self.format_version,
                 )?;
                 Ok(Some(column))
@@ -278,40 +276,40 @@ impl DynamicColumnHandle {
             | ColumnType::U64
             | ColumnType::F64
             | ColumnType::DateTime => {
-                let column =
-                    crate::column::open_column_u64::<u64>(column_bytes, self.format_version)?;
+                let column = crate::column::open_column_u64::<u64>(
+                    self.file_slice.clone(),
+                    self.format_version,
+                )?;
                 Ok(Some(column))
             }
         }
     }
 
-    fn open_internal(&self, column_bytes: OwnedBytes) -> io::Result<DynamicColumn> {
+    fn open_internal(&self, file_slice: FileSlice) -> io::Result<DynamicColumn> {
         let dynamic_column: DynamicColumn = match self.column_type {
             ColumnType::Bytes => {
-                crate::column::open_column_bytes(column_bytes, self.format_version)?.into()
+                crate::column::open_column_bytes(file_slice, self.format_version)?.into()
             }
             ColumnType::Str => {
-                crate::column::open_column_str(column_bytes, self.format_version)?.into()
+                crate::column::open_column_str(file_slice, self.format_version)?.into()
             }
             ColumnType::I64 => {
-                crate::column::open_column_u64::<i64>(column_bytes, self.format_version)?.into()
+                crate::column::open_column_u64::<i64>(file_slice, self.format_version)?.into()
             }
             ColumnType::U64 => {
-                crate::column::open_column_u64::<u64>(column_bytes, self.format_version)?.into()
+                crate::column::open_column_u64::<u64>(file_slice, self.format_version)?.into()
             }
             ColumnType::F64 => {
-                crate::column::open_column_u64::<f64>(column_bytes, self.format_version)?.into()
+                crate::column::open_column_u64::<f64>(file_slice, self.format_version)?.into()
             }
             ColumnType::Bool => {
-                crate::column::open_column_u64::<bool>(column_bytes, self.format_version)?.into()
+                crate::column::open_column_u64::<bool>(file_slice, self.format_version)?.into()
             }
             ColumnType::IpAddr => {
-                crate::column::open_column_u128::<Ipv6Addr>(column_bytes, self.format_version)?
-                    .into()
+                crate::column::open_column_u128::<Ipv6Addr>(file_slice, self.format_version)?.into()
             }
             ColumnType::DateTime => {
-                crate::column::open_column_u64::<DateTime>(column_bytes, self.format_version)?
-                    .into()
+                crate::column::open_column_u64::<DateTime>(file_slice, self.format_version)?.into()
             }
         };
         Ok(dynamic_column)

columnar/src/lib.rs

@@ -29,6 +29,7 @@ mod column;
 pub mod column_index;
 pub mod column_values;
 mod columnar;
+mod comparable_doc;
 mod dictionary;
 mod dynamic_column;
 mod iterable;
@@ -36,7 +37,7 @@ pub(crate) mod utils;
 mod value;
 
 pub use block_accessor::ColumnBlockAccessor;
-pub use column::{BytesColumn, Column, StrColumn};
+pub use column::{BytesColumn, Column, StrColumn, ValueRange};
 pub use column_index::ColumnIndex;
 pub use column_values::{
     ColumnValues, EmptyColumnValues, MonotonicallyMappableToU64, MonotonicallyMappableToU128,
@@ -45,6 +46,7 @@ pub use columnar::{
     CURRENT_VERSION, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
     MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, Version, merge_columnar,
 };
+pub use comparable_doc::ComparableDoc;
 use sstable::VoidSSTable;
 pub use value::{NumericalType, NumericalValue};
 
@@ -59,7 +61,7 @@ pub struct RowAddr {
     pub row_id: RowId,
 }
 
-pub use sstable::{Dictionary, TermOrdHit};
+pub use sstable::Dictionary;
 pub type Streamer<'a> = sstable::Streamer<'a, VoidSSTable>;
 
 pub use common::DateTime;

columnar/src/tests.rs

@@ -60,7 +60,7 @@ fn test_dataframe_writer_bool() {
     let DynamicColumn::Bool(bool_col) = dyn_bool_col else {
         panic!();
     };
-    let vals: Vec<Option<bool>> = (0..5).map(|doc_id| bool_col.first(doc_id)).collect();
+    let vals: Vec<Option<bool>> = (0..5).map(|row_id| bool_col.first(row_id)).collect();
     assert_eq!(&vals, &[None, Some(false), None, Some(true), None,]);
 }
 
@@ -108,7 +108,7 @@ fn test_dataframe_writer_ip_addr() {
     let DynamicColumn::IpAddr(ip_col) = dyn_bool_col else {
         panic!();
     };
-    let vals: Vec<Option<Ipv6Addr>> = (0..5).map(|doc_id| ip_col.first(doc_id)).collect();
+    let vals: Vec<Option<Ipv6Addr>> = (0..5).map(|row_id| ip_col.first(row_id)).collect();
     assert_eq!(
         &vals,
         &[
@@ -169,7 +169,7 @@ fn test_dictionary_encoded_str() {
     let DynamicColumn::Str(str_col) = col_handles[0].open().unwrap() else {
         panic!();
     };
-    let index: Vec<Option<u64>> = (0..5).map(|doc_id| str_col.ords().first(doc_id)).collect();
+    let index: Vec<Option<u64>> = (0..5).map(|row_id| str_col.ords().first(row_id)).collect();
     assert_eq!(index, &[None, Some(0), None, Some(2), Some(1)]);
     assert_eq!(str_col.num_rows(), 5);
     let mut term_buffer = String::new();
@@ -204,7 +204,7 @@ fn test_dictionary_encoded_bytes() {
         panic!();
     };
     let index: Vec<Option<u64>> = (0..5)
-        .map(|doc_id| bytes_col.ords().first(doc_id))
+        .map(|row_id| bytes_col.ords().first(row_id))
         .collect();
     assert_eq!(index, &[None, Some(0), None, Some(2), Some(1)]);
     assert_eq!(bytes_col.num_rows(), 5);
@@ -641,7 +641,7 @@ proptest! {
         let columnar_readers_arr: Vec<&ColumnarReader> = columnar_readers.iter().collect();
         let mut output: Vec<u8> = Vec::new();
         let stack_merge_order = StackMergeOrder::stack(&columnar_readers_arr[..]).into();
-        crate::merge_columnar(&columnar_readers_arr[..], &[], stack_merge_order, &mut output).unwrap();
+        crate::merge_columnar(&columnar_readers_arr[..], &[], stack_merge_order, &mut output, || false,).unwrap();
         let merged_columnar = ColumnarReader::open(output).unwrap();
         let concat_rows: Vec<Vec<(&'static str, ColumnValue)>> = columnar_docs.iter().flatten().cloned().collect();
         let expected_merged_columnar = build_columnar(&concat_rows[..]);
@@ -665,6 +665,7 @@ fn test_columnar_merging_empty_columnar() {
         &[],
         crate::MergeRowOrder::Stack(stack_merge_order),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();
@@ -702,6 +703,7 @@ fn test_columnar_merging_number_columns() {
         &[],
         crate::MergeRowOrder::Stack(stack_merge_order),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();
@@ -775,6 +777,7 @@ fn test_columnar_merge_and_remap(
         &[],
         shuffle_merge_order.into(),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();
@@ -817,6 +820,7 @@ fn test_columnar_merge_empty() {
         &[],
         shuffle_merge_order.into(),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();
@@ -843,6 +847,7 @@ fn test_columnar_merge_single_str_column() {
         &[],
         shuffle_merge_order.into(),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();
@@ -875,6 +880,7 @@ fn test_delete_decrease_cardinality() {
         &[],
         shuffle_merge_order.into(),
         &mut output,
+        || false,
     )
     .unwrap();
     let merged_columnar = ColumnarReader::open(output).unwrap();

common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-common"
-version = "0.11.0"
+version = "0.10.0"
 authors = ["Paul Masurel <paul@quickwit.io>", "Pascal Seitz <pascal@quickwit.io>"]
 license = "MIT"
 edition = "2024"
@@ -15,10 +15,11 @@ repository = "https://github.com/quickwit-oss/tantivy"
 byteorder = "1.4.3"
 ownedbytes = { version= "0.9", path="../ownedbytes" }
 async-trait = "0.1"
-time = { version = "0.3.47", features = ["serde-well-known"] }
+time = { version = "0.3.10", features = ["serde-well-known"] }
 serde = { version = "1.0.136", features = ["derive"] }
 
 [dev-dependencies]
-binggan = "0.17.0"
+binggan = "0.14.0"
 proptest = "1.0.0"
-rand = "0.9"
+rand = "0.8.4"
+

common/benches/bench.rs

@@ -1,6 +1,6 @@
 use binggan::{BenchRunner, black_box};
-use rand::rng;
 use rand::seq::IteratorRandom;
+use rand::thread_rng;
 use tantivy_common::{BitSet, TinySet, serialize_vint_u32};
 
 fn bench_vint() {
@@ -17,7 +17,7 @@ fn bench_vint() {
         black_box(out);
     });
 
-    let vals: Vec<u32> = (0..20_000).choose_multiple(&mut rng(), 100_000);
+    let vals: Vec<u32> = (0..20_000).choose_multiple(&mut thread_rng(), 100_000);
     runner.bench_function("bench_vint_rand", move |_| {
         let mut out = 0u64;
         for val in vals.iter().cloned() {

common/src/bitset.rs

@@ -47,9 +47,6 @@ impl TinySet {
         TinySet(val)
     }
 
-    /// An empty `TinySet` constant.
-    pub const EMPTY: TinySet = TinySet(0u64);
-
     /// Returns an empty `TinySet`.
     #[inline]
     pub fn empty() -> TinySet {
@@ -156,22 +153,7 @@ impl TinySet {
             None
         } else {
             let lowest = self.0.trailing_zeros();
-            // Kernighan's trick: `n &= n - 1` clears the lowest set bit
-            // without depending on `lowest`. This lets the CPU execute
-            // `trailing_zeros` and the bit-clear in parallel instead of
-            // serializing them.
-            //
-            // The previous form `self.0 ^= 1 << lowest` needs the result of
-            // `trailing_zeros` before it can shift, creating a dependency chain:
-            //   ARM64: rbit → clz → lsl → eor
-            //   x86:   tzcnt → btc
-            //
-            // With Kernighan's trick the clear path is independent of the count:
-            //   ARM64: sub → and  (trailing_zeros runs in parallel)
-            //   x86:   blsr       (tzcnt runs in parallel)
-            //
-            // https://godbolt.org/z/fnfrP1T5f
-            self.0 &= self.0 - 1;
+            self.0 ^= TinySet::singleton(lowest).0;
             Some(lowest)
         }
     }
@@ -199,14 +181,6 @@ pub struct BitSet {
     len: u64,
     max_value: u32,
 }
-impl std::fmt::Debug for BitSet {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BitSet")
-            .field("len", &self.len)
-            .field("max_value", &self.max_value)
-            .finish()
-    }
-}
 
 fn num_buckets(max_val: u32) -> u32 {
     max_val.div_ceil(64u32)
@@ -434,7 +408,7 @@ mod tests {
     use std::collections::HashSet;
 
     use ownedbytes::OwnedBytes;
-    use rand::distr::Bernoulli;
+    use rand::distributions::Bernoulli;
     use rand::rngs::StdRng;
     use rand::{Rng, SeedableRng};
 

common/src/buffered_file_slice.rs

@@ -0,0 +1,106 @@
+use std::cell::RefCell;
+use std::cmp::min;
+use std::io;
+use std::ops::Range;
+
+use super::file_slice::FileSlice;
+use super::{HasLen, OwnedBytes};
+
+const DEFAULT_BUFFER_MAX_SIZE: usize = 512 * 1024; // 512K
+
+/// A buffered reader for a FileSlice.
+///
+/// Reads the underlying `FileSlice` in large, sequential chunks to amortize
+/// the cost of `read_bytes` calls, while keeping peak memory usage under control.
+///
+/// TODO: Rather than wrapping a `FileSlice` in buffering, it will usually be better to adjust a
+/// `FileHandle` to directly handle buffering itself.
+/// TODO: See: https://github.com/paradedb/paradedb/issues/3374
+pub struct BufferedFileSlice {
+    file_slice: FileSlice,
+    buffer: RefCell<OwnedBytes>,
+    buffer_range: RefCell<Range<u64>>,
+    buffer_max_size: usize,
+}
+
+impl BufferedFileSlice {
+    /// Creates a new `BufferedFileSlice`.
+    ///
+    /// The `buffer_max_size` is the amount of data that will be read from the
+    /// `FileSlice` on a buffer miss.
+    pub fn new(file_slice: FileSlice, buffer_max_size: usize) -> Self {
+        Self {
+            file_slice,
+            buffer: RefCell::new(OwnedBytes::empty()),
+            buffer_range: RefCell::new(0..0),
+            buffer_max_size,
+        }
+    }
+
+    /// Creates a new `BufferedFileSlice` with a default buffer max size.
+    pub fn new_with_default_buffer_size(file_slice: FileSlice) -> Self {
+        Self::new(file_slice, DEFAULT_BUFFER_MAX_SIZE)
+    }
+
+    /// Creates an empty `BufferedFileSlice`.
+    pub fn empty() -> Self {
+        Self::new(FileSlice::empty(), 0)
+    }
+
+    /// Returns an `OwnedBytes` corresponding to the given `required_range`.
+    ///
+    /// If the requested range is not in the buffer, this will trigger a read
+    /// from the underlying `FileSlice`.
+    ///
+    /// If the requested range is larger than the buffer_max_size, it will be read directly from the
+    /// source without buffering.
+    ///
+    /// # Errors
+    ///
+    /// Returns an `io::Error` if the underlying read fails or the range is
+    /// out of bounds.
+    pub fn get_bytes(&self, required_range: Range<u64>) -> io::Result<OwnedBytes> {
+        let buffer_range = self.buffer_range.borrow();
+
+        // Cache miss condition: the required range is not fully contained in the current buffer.
+        if required_range.start < buffer_range.start || required_range.end > buffer_range.end {
+            drop(buffer_range); // release borrow before mutating
+
+            if required_range.end > self.file_slice.len() as u64 {
+                return Err(io::Error::new(
+                    io::ErrorKind::UnexpectedEof,
+                    "Requested range extends beyond the end of the file slice.",
+                ));
+            }
+
+            if (required_range.end - required_range.start) as usize > self.buffer_max_size {
+                // This read is larger than our buffer max size.
+                // Read it directly and bypass the buffer to avoid churning.
+                return self
+                    .file_slice
+                    .read_bytes_slice(required_range.start as usize..required_range.end as usize);
+            }
+
+            let new_buffer_start = required_range.start;
+            let new_buffer_end = min(
+                new_buffer_start + self.buffer_max_size as u64,
+                self.file_slice.len() as u64,
+            );
+            let read_range = new_buffer_start..new_buffer_end;
+
+            let new_buffer = self
+                .file_slice
+                .read_bytes_slice(read_range.start as usize..read_range.end as usize)?;
+
+            self.buffer.replace(new_buffer);
+            self.buffer_range.replace(read_range);
+        }
+
+        // Now the data is guaranteed to be in the buffer.
+        let buffer = self.buffer.borrow();
+        let buffer_range = self.buffer_range.borrow();
+        let local_start = (required_range.start - buffer_range.start) as usize;
+        let local_end = (required_range.end - buffer_range.start) as usize;
+        Ok(buffer.slice(local_start..local_end))
+    }
+}

common/src/file_slice.rs

@@ -1,7 +1,7 @@
 use std::fs::File;
 use std::ops::{Deref, Range, RangeBounds};
 use std::path::Path;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 use std::{fmt, io};
 
 use async_trait::async_trait;
@@ -339,6 +339,27 @@ impl FileHandle for OwnedBytes {
     }
 }
 
+pub struct DeferredFileSlice {
+    opener: Arc<dyn Fn() -> io::Result<FileSlice> + Send + Sync + 'static>,
+    file_slice: OnceLock<std::io::Result<FileSlice>>,
+}
+
+impl DeferredFileSlice {
+    pub fn new(opener: impl Fn() -> io::Result<FileSlice> + Send + Sync + 'static) -> Self {
+        DeferredFileSlice {
+            opener: Arc::new(opener),
+            file_slice: OnceLock::default(),
+        }
+    }
+
+    pub fn open(&self) -> io::Result<&FileSlice> {
+        match self.file_slice.get_or_init(|| (self.opener)()) {
+            Ok(file_slice) => Ok(file_slice),
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e.to_string())),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::io;

common/src/lib.rs

@@ -6,6 +6,7 @@ pub use byteorder::LittleEndian as Endianness;
 
 mod bitset;
 pub mod bounds;
+pub mod buffered_file_slice;
 mod byte_count;
 mod datetime;
 pub mod file_slice;

common/src/vint.rs

@@ -58,6 +58,33 @@ impl BinarySerializable for VIntU128 {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct VInt(pub u64);
 
+impl VInt {
+    pub fn deserialize_with_size<R: Read>(reader: &mut R) -> io::Result<(Self, usize)> {
+        let mut nbytes = 0;
+        let mut bytes = reader.bytes();
+        let mut result = 0u64;
+        let mut shift = 0u64;
+        loop {
+            match bytes.next() {
+                Some(Ok(b)) => {
+                    nbytes += 1;
+                    result |= u64::from(b % 128u8) << shift;
+                    if b >= STOP_BIT {
+                        return Ok((VInt(result), nbytes));
+                    }
+                    shift += 7;
+                }
+                _ => {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "Reach end of buffer while reading VInt",
+                    ));
+                }
+            }
+        }
+    }
+}
+
 const STOP_BIT: u8 = 128;
 
 #[inline]
@@ -225,7 +252,6 @@ impl BinarySerializable for VInt {
 
 #[cfg(test)]
 mod tests {
-
     use super::{BinarySerializable, VInt, serialize_vint_u32};
 
     fn aux_test_vint(val: u64) {

common/src/writer.rs

@@ -62,9 +62,7 @@ impl<W: TerminatingWrite> TerminatingWrite for CountingWriter<W> {
 pub struct AntiCallToken(());
 
 /// Trait used to indicate when no more write need to be done on a writer
-///
-/// Thread-safety is enforced at the call sites that require it.
-pub trait TerminatingWrite: Write {
+pub trait TerminatingWrite: Write + Send + Sync {
     /// Indicate that the writer will no longer be used. Internally call terminate_ref.
     fn terminate(mut self) -> io::Result<()>
     where Self: Sized {

doc/src/json.md

@@ -60,7 +60,7 @@ At indexing, tantivy will try to interpret number and strings as different type
 priority order.
 
 Numbers will be interpreted as u64, i64 and f64 in that order.
-Strings will be interpreted as rfc3339 dates or simple strings.
+Strings will be interpreted as rfc3999 dates or simple strings.
 
 The first working type is picked and is the only term that is emitted for indexing.
 Note this interpretation happens on a per-document basis, and there is no effort to try to sniff
@@ -81,7 +81,7 @@ Will be interpreted as
 (my_path.my_segment, String, 233) or (my_path.my_segment, u64, 233)
 ```
 
-Likewise, we need to emit two tokens if the query contains an rfc3339 date.
+Likewise, we need to emit two tokens if the query contains an rfc3999 date.
 Indeed the date could have been actually a single token inside the text of a document at ingestion time. Generally speaking, we will always at least emit a string token in query parsing, and sometimes more.
 
 If one more json field is defined, things get even more complicated.

examples/multiple_snippets.rs

@@ -0,0 +1,86 @@
+// # Multiple Snippets Example
+//
+// This example demonstrates how to return multiple text fragments
+// from a document, useful for long documents with matches in different locations.
+
+use tantivy::collector::TopDocs;
+use tantivy::query::QueryParser;
+use tantivy::schema::*;
+use tantivy::snippet::SnippetGenerator;
+use tantivy::{doc, Index, IndexWriter};
+use tempfile::TempDir;
+
+fn main() -> tantivy::Result<()> {
+    let index_path = TempDir::new()?;
+
+    // Define the schema
+    let mut schema_builder = Schema::builder();
+    let title = schema_builder.add_text_field("title", TEXT | STORED);
+    let body = schema_builder.add_text_field("body", TEXT | STORED);
+    let schema = schema_builder.build();
+
+    // Create the index
+    let index = Index::create_in_dir(&index_path, schema)?;
+    let mut index_writer: IndexWriter = index.writer(50_000_000)?;
+
+    // Index a long document with multiple occurrences of "rust"
+    index_writer.add_document(doc!(
+        title => "The Rust Programming Language",
+        body => "Rust is a systems programming language that runs blazingly fast, prevents \
+                 segfaults, and guarantees thread safety. Lorem ipsum dolor sit amet, \
+                 consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore. \
+                 Rust empowers everyone to build reliable and efficient software. More filler \
+                 text to create distance between matches. Ut enim ad minim veniam, quis nostrud \
+                 exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. \
+                 The Rust compiler is known for its helpful error messages. Duis aute irure \
+                 dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \
+                 pariatur. Rust has a strong type system and ownership model."
+    ))?;
+
+    index_writer.commit()?;
+
+    let reader = index.reader()?;
+    let searcher = reader.searcher();
+    let query_parser = QueryParser::for_index(&index, vec![title, body]);
+    let query = query_parser.parse_query("rust")?;
+
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
+
+    // Create snippet generator
+    let mut snippet_generator = SnippetGenerator::create(&searcher, &*query, body)?;
+
+    println!("=== Single Snippet (Default Behavior) ===\n");
+    for (score, doc_address) in &top_docs {
+        let doc = searcher.doc::<TantivyDocument>(*doc_address)?;
+        let snippet = snippet_generator.snippet_from_doc(&doc);
+        println!("Document score: {}", score);
+        println!("Title: {}", doc.get_first(title).unwrap().as_str().unwrap());
+        println!("Single snippet: {}\n", snippet.to_html());
+    }
+
+    println!("\n=== Multiple Snippets (New Feature) ===\n");
+
+    // Configure to return multiple snippets
+    // Get up to 3 snippets
+    snippet_generator.set_snippets_limit(3);
+    // Smaller fragments
+    snippet_generator.set_max_num_chars(80);
+    // By default, multiple snippets are sorted by score. You can change this to sort by position.
+    // snippet_generator.set_sort_order(SnippetSortOrder::Position);
+
+    for (score, doc_address) in top_docs {
+        let doc = searcher.doc::<TantivyDocument>(doc_address)?;
+        let snippets = snippet_generator.snippets_from_doc(&doc);
+
+        println!("Document score: {}", score);
+        println!("Title: {}", doc.get_first(title).unwrap().as_str().unwrap());
+        println!("Found {} snippets:", snippets.len());
+
+        for (i, snippet) in snippets.iter().enumerate() {
+            println!("  Snippet {}: {}", i + 1, snippet.to_html());
+        }
+        println!();
+    }
+
+    Ok(())
+}

query-grammar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-query-grammar"
-version = "0.26.0"
+version = "0.25.0"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = ["database-implementations", "data-structures"]

query-grammar/src/query_grammar.rs

@@ -560,7 +560,7 @@ fn range_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
             (
                 (
                     value((), tag(">=")),
-                    map(word_infallible(")", false), |(bound, err)| {
+                    map(word_infallible("", false), |(bound, err)| {
                         (
                             (
                                 bound
@@ -574,7 +574,7 @@ fn range_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
                 ),
                 (
                     value((), tag("<=")),
-                    map(word_infallible(")", false), |(bound, err)| {
+                    map(word_infallible("", false), |(bound, err)| {
                         (
                             (
                                 UserInputBound::Unbounded,
@@ -588,7 +588,7 @@ fn range_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
                 ),
                 (
                     value((), tag(">")),
-                    map(word_infallible(")", false), |(bound, err)| {
+                    map(word_infallible("", false), |(bound, err)| {
                         (
                             (
                                 bound
@@ -602,7 +602,7 @@ fn range_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
                 ),
                 (
                     value((), tag("<")),
-                    map(word_infallible(")", false), |(bound, err)| {
+                    map(word_infallible("", false), |(bound, err)| {
                         (
                             (
                                 UserInputBound::Unbounded,
@@ -704,11 +704,7 @@ fn regex(inp: &str) -> IResult<&str, UserInputLeaf> {
                 many1(alt((preceded(char('\\'), char('/')), none_of("/")))),
                 char('/'),
             ),
-            peek(alt((
-                value((), multispace1),
-                value((), char(')')),
-                value((), eof),
-            ))),
+            peek(alt((multispace1, eof))),
         ),
         |elements| UserInputLeaf::Regex {
             field: None,
@@ -725,12 +721,8 @@ fn regex_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
             opt_i_err(char('/'), "missing delimiter /"),
         ),
         opt_i_err(
-            peek(alt((
-                value((), multispace1),
-                value((), char(')')),
-                value((), eof),
-            ))),
-            "expected whitespace, closing parenthesis, or end of input",
+            peek(alt((multispace1, eof))),
+            "expected whitespace or end of input",
         ),
     )(inp)
     {
@@ -1045,43 +1037,18 @@ fn operand_leaf(inp: &str) -> IResult<&str, (Option<BinaryOperand>, Option<Occur
 }
 
 fn ast(inp: &str) -> IResult<&str, UserInputAst> {
-    // Parse `occur_leaf` once, then conditionally extend into a boolean
-    // expression. The previous implementation used `alt((boolean_expr,
-    // single_leaf))` which, when the input was a single leaf with no
-    // following operand, would parse `occur_leaf` once for `boolean_expr`,
-    // fail at `multispace1`, backtrack, then re-parse `occur_leaf` for
-    // `single_leaf`. With recursively-nested groups like `(+(+(+a)))`, that
-    // doubling at every level produced O(2^n) parse time. Parsing once and
-    // peeking ahead for the operand keeps it O(n).
-    delimited(
-        multispace0,
-        |inp| {
-            let (rest, first) = occur_leaf(inp)?;
-            // Only fall back on `Err::Error` (recoverable), mirroring
-            // `alt`'s behaviour. `Err::Failure` and `Err::Incomplete`
-            // must propagate so cut points and streaming needs are not
-            // accidentally swallowed if they are ever introduced in the
-            // operand parsers.
-            match preceded(multispace1, many1(operand_leaf))(rest) {
-                Ok((rest, more)) => {
-                    let combined = aggregate_binary_expressions(first, more)
-                        .map_err(|_| nom::Err::Error(Error::new(inp, ErrorKind::MapRes)))?;
-                    Ok((rest, combined))
-                }
-                Err(nom::Err::Error(_)) => {
-                    let (occur, ast) = first;
-                    let single = if occur == Some(Occur::MustNot) {
-                        ast.unary(Occur::MustNot)
-                    } else {
-                        ast
-                    };
-                    Ok((rest, single))
-                }
-                Err(e) => Err(e),
-            }
-        },
-        multispace0,
-    )(inp)
+    let boolean_expr = map_res(
+        separated_pair(occur_leaf, multispace1, many1(operand_leaf)),
+        |(left, right)| aggregate_binary_expressions(left, right),
+    );
+    let single_leaf = map(occur_leaf, |(occur, ast)| {
+        if occur == Some(Occur::MustNot) {
+            ast.unary(Occur::MustNot)
+        } else {
+            ast
+        }
+    });
+    delimited(multispace0, alt((boolean_expr, single_leaf)), multispace0)(inp)
 }
 
 fn ast_infallible(inp: &str) -> JResult<&str, UserInputAst> {
@@ -1356,14 +1323,6 @@ mod test {
         test_parse_query_to_ast_helper("<a", "{\"*\" TO \"a\"}");
         test_parse_query_to_ast_helper("<=a", "{\"*\" TO \"a\"]");
         test_parse_query_to_ast_helper("<=bsd", "{\"*\" TO \"bsd\"]");
-
-        test_parse_query_to_ast_helper("(<=42)", "{\"*\" TO \"42\"]");
-        test_parse_query_to_ast_helper("(<=42 )", "{\"*\" TO \"42\"]");
-        test_parse_query_to_ast_helper("(age:>5)", "\"age\":{\"5\" TO \"*\"}");
-        test_parse_query_to_ast_helper(
-            "(title:bar AND age:>12)",
-            "(+\"title\":bar +\"age\":{\"12\" TO \"*\"})",
-        );
     }
 
     #[test]
@@ -1740,10 +1699,6 @@ mod test {
         test_parse_query_to_ast_helper("foo:(A OR B)", "(?\"foo\":A ?\"foo\":B)");
         test_parse_query_to_ast_helper("foo:(A* OR B*)", "(?\"foo\":A* ?\"foo\":B*)");
         test_parse_query_to_ast_helper("foo:(*A OR *B)", "(?\"foo\":*A ?\"foo\":*B)");
-
-        // Regexes between parentheses
-        test_parse_query_to_ast_helper("foo:(/A.*/)", "\"foo\":/A.*/");
-        test_parse_query_to_ast_helper("foo:(/A.*/ OR /B.*/)", "(?\"foo\":/A.*/ ?\"foo\":/B.*/)");
     }
 
     #[test]
@@ -1916,23 +1871,4 @@ mod test {
             r#"(+"field":'happy tax payer' +"other_field":1)"#,
         );
     }
-
-    // Regression test for https://github.com/quickwit-oss/tantivy/issues/2498:
-    // deeply nested parenthesized queries used to take O(2^n) time because the
-    // top-level `ast()` parser tried `boolean_expr` first and re-parsed the
-    // inner `occur_leaf` when it backtracked to `single_leaf`. Depth 60 would
-    // take ~10^18 operations under the regression; with the fix it parses
-    // instantly. We use `test_parse_query_to_ast_helper` so this test would
-    // never finish if the regression returned.
-    #[test]
-    fn test_parse_deeply_nested_query() {
-        let depth = 60;
-        let leading: String = "(".repeat(depth);
-        let trailing: String = ")".repeat(depth);
-        let query = format!("{leading}title:test{trailing}");
-        test_parse_query_to_ast_helper(&query, r#""title":test"#);
-
-        let query_with_plus = format!("+{leading}title:test{trailing}");
-        test_parse_query_to_ast_helper(&query_with_plus, r#""title":test"#);
-    }
 }

query-grammar/src/user_input_ast.rs

@@ -66,7 +66,6 @@ impl UserInputLeaf {
             }
             UserInputLeaf::Range { field, .. } if field.is_none() => *field = Some(default_field),
             UserInputLeaf::Set { field, .. } if field.is_none() => *field = Some(default_field),
-            UserInputLeaf::Regex { field, .. } if field.is_none() => *field = Some(default_field),
             _ => (), // field was already set, do nothing
         }
     }

runtests.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+cargo +stable nextest run --features quickwit,mmap,stopwords,lz4-compression,zstd-compression,failpoints --verbose --workspace

src/aggregation/agg_data.rs

@@ -1,4 +1,4 @@
-use columnar::{Column, ColumnBlockAccessor, ColumnType, StrColumn};
+use columnar::{Column, ColumnType, StrColumn};
 use common::BitSet;
 use rustc_hash::FxHashSet;
 use serde::Serialize;
@@ -10,18 +10,17 @@ use crate::aggregation::accessor_helpers::{
 };
 use crate::aggregation::agg_req::{Aggregation, AggregationVariants, Aggregations};
 use crate::aggregation::bucket::{
-    build_segment_filter_collector, build_segment_range_collector, CompositeAggReqData,
-    CompositeAggregation, CompositeSourceAccessors, FilterAggReqData, HistogramAggReqData,
-    HistogramBounds, IncludeExcludeParam, MissingTermAggReqData, RangeAggReqData,
-    SegmentHistogramCollector, TermMissingAgg, TermsAggReqData, TermsAggregation,
+    FilterAggReqData, HistogramAggReqData, HistogramBounds, IncludeExcludeParam,
+    MissingTermAggReqData, RangeAggReqData, SegmentFilterCollector, SegmentHistogramCollector,
+    SegmentRangeCollector, TermMissingAgg, TermsAggReqData, TermsAggregation,
     TermsAggregationInternal,
 };
 use crate::aggregation::metric::{
-    build_segment_stats_collector, AverageAggregation, CardinalityAggReqData,
-    CardinalityAggregationReq, CountAggregation, ExtendedStatsAggregation, MaxAggregation,
-    MetricAggReqData, MinAggregation, SegmentCardinalityCollector, SegmentExtendedStatsCollector,
-    SegmentPercentilesCollector, StatsAggregation, StatsType, SumAggregation, TermOrdSet,
-    TopHitsAggReqData, TopHitsSegmentCollector, BITSET_MAX_TERM_ORD,
+    AverageAggregation, CardinalityAggReqData, CardinalityAggregationReq, CountAggregation,
+    ExtendedStatsAggregation, MaxAggregation, MetricAggReqData, MinAggregation,
+    SegmentCardinalityCollector, SegmentExtendedStatsCollector, SegmentPercentilesCollector,
+    SegmentStatsCollector, StatsAggregation, StatsType, SumAggregation, TopHitsAggReqData,
+    TopHitsSegmentCollector,
 };
 use crate::aggregation::segment_agg_result::{
     GenericSegmentAggregationResultsCollector, SegmentAggregationCollector,
@@ -36,7 +35,6 @@ pub struct AggregationsSegmentCtx {
     /// Request data for each aggregation type.
     pub per_request: PerRequestAggSegCtx,
     pub context: AggContextParams,
-    pub column_block_accessor: ColumnBlockAccessor<u64>,
 }
 
 impl AggregationsSegmentCtx {
@@ -74,12 +72,6 @@ impl AggregationsSegmentCtx {
         self.per_request.filter_req_data.push(Some(Box::new(data)));
         self.per_request.filter_req_data.len() - 1
     }
-    pub(crate) fn push_composite_req_data(&mut self, data: CompositeAggReqData) -> usize {
-        self.per_request
-            .composite_req_data
-            .push(Some(Box::new(data)));
-        self.per_request.composite_req_data.len() - 1
-    }
 
     #[inline]
     pub(crate) fn get_term_req_data(&self, idx: usize) -> &TermsAggReqData {
@@ -116,19 +108,20 @@ impl AggregationsSegmentCtx {
             .expect("range_req_data slot is empty (taken)")
     }
     #[inline]
-    pub(crate) fn get_composite_req_data(&self, idx: usize) -> &CompositeAggReqData {
-        self.per_request.composite_req_data[idx]
+    pub(crate) fn get_filter_req_data(&self, idx: usize) -> &FilterAggReqData {
+        self.per_request.filter_req_data[idx]
             .as_deref()
-            .expect("composite_req_data slot is empty (taken)")
+            .expect("filter_req_data slot is empty (taken)")
     }
 
     // ---------- mutable getters ----------
 
     #[inline]
-    pub(crate) fn get_metric_req_data_mut(&mut self, idx: usize) -> &mut MetricAggReqData {
-        &mut self.per_request.stats_metric_req_data[idx]
+    pub(crate) fn get_term_req_data_mut(&mut self, idx: usize) -> &mut TermsAggReqData {
+        self.per_request.term_req_data[idx]
+            .as_deref_mut()
+            .expect("term_req_data slot is empty (taken)")
     }
-
     #[inline]
     pub(crate) fn get_cardinality_req_data_mut(
         &mut self,
@@ -136,7 +129,10 @@ impl AggregationsSegmentCtx {
     ) -> &mut CardinalityAggReqData {
         &mut self.per_request.cardinality_req_data[idx]
     }
-
+    #[inline]
+    pub(crate) fn get_metric_req_data_mut(&mut self, idx: usize) -> &mut MetricAggReqData {
+        &mut self.per_request.stats_metric_req_data[idx]
+    }
     #[inline]
     pub(crate) fn get_histogram_req_data_mut(&mut self, idx: usize) -> &mut HistogramAggReqData {
         self.per_request.histogram_req_data[idx]
@@ -146,6 +142,21 @@ impl AggregationsSegmentCtx {
 
     // ---------- take / put (terms, histogram, range) ----------
 
+    /// Move out the boxed Terms request at `idx`, leaving `None`.
+    #[inline]
+    pub(crate) fn take_term_req_data(&mut self, idx: usize) -> Box<TermsAggReqData> {
+        self.per_request.term_req_data[idx]
+            .take()
+            .expect("term_req_data slot is empty (taken)")
+    }
+
+    /// Put back a Terms request into an empty slot at `idx`.
+    #[inline]
+    pub(crate) fn put_back_term_req_data(&mut self, idx: usize, value: Box<TermsAggReqData>) {
+        debug_assert!(self.per_request.term_req_data[idx].is_none());
+        self.per_request.term_req_data[idx] = Some(value);
+    }
+
     /// Move out the boxed Histogram request at `idx`, leaving `None`.
     #[inline]
     pub(crate) fn take_histogram_req_data(&mut self, idx: usize) -> Box<HistogramAggReqData> {
@@ -194,25 +205,6 @@ impl AggregationsSegmentCtx {
         debug_assert!(self.per_request.filter_req_data[idx].is_none());
         self.per_request.filter_req_data[idx] = Some(value);
     }
-
-    /// Move out the Composite request at `idx`.
-    #[inline]
-    pub(crate) fn take_composite_req_data(&mut self, idx: usize) -> Box<CompositeAggReqData> {
-        self.per_request.composite_req_data[idx]
-            .take()
-            .expect("composite_req_data slot is empty (taken)")
-    }
-
-    /// Put back a Composite request into an empty slot at `idx`.
-    #[inline]
-    pub(crate) fn put_back_composite_req_data(
-        &mut self,
-        idx: usize,
-        value: Box<CompositeAggReqData>,
-    ) {
-        debug_assert!(self.per_request.composite_req_data[idx].is_none());
-        self.per_request.composite_req_data[idx] = Some(value);
-    }
 }
 
 /// Each type of aggregation has its own request data struct. This struct holds
@@ -240,8 +232,6 @@ pub struct PerRequestAggSegCtx {
     pub top_hits_req_data: Vec<TopHitsAggReqData>,
     /// MissingTermAggReqData contains the request data for a missing term aggregation.
     pub missing_term_req_data: Vec<MissingTermAggReqData>,
-    /// CompositeAggReqData contains the request data for a composite aggregation.
-    pub composite_req_data: Vec<Option<Box<CompositeAggReqData>>>,
 
     /// Request tree used to build collectors.
     pub agg_tree: Vec<AggRefNode>,
@@ -289,11 +279,6 @@ impl PerRequestAggSegCtx {
                 .iter()
                 .map(|t| t.get_memory_consumption())
                 .sum::<usize>()
-            + self
-                .composite_req_data
-                .iter()
-                .map(|b| b.as_ref().map(|d| d.get_memory_consumption()).unwrap_or(0))
-                .sum::<usize>()
             + self.agg_tree.len() * std::mem::size_of::<AggRefNode>()
     }
 
@@ -330,17 +315,11 @@ impl PerRequestAggSegCtx {
                 .expect("filter_req_data slot is empty (taken)")
                 .name
                 .as_str(),
-            AggKind::Composite => self.composite_req_data[idx]
-                .as_deref()
-                .expect("composite_req_data slot is empty (taken)")
-                .name
-                .as_str(),
         }
     }
 
     /// Convert the aggregation tree into a serializable struct representation.
     /// Each node contains: { name, kind, children }.
-    #[allow(dead_code)]
     pub fn get_view_tree(&self) -> Vec<AggTreeViewNode> {
         fn node_to_view(node: &AggRefNode, pr: &PerRequestAggSegCtx) -> AggTreeViewNode {
             let mut children: Vec<AggTreeViewNode> =
@@ -366,19 +345,12 @@ impl PerRequestAggSegCtx {
 pub(crate) fn build_segment_agg_collectors_root(
     req: &mut AggregationsSegmentCtx,
 ) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
-    build_segment_agg_collectors_generic(req, &req.per_request.agg_tree.clone())
+    build_segment_agg_collectors(req, &req.per_request.agg_tree.clone())
 }
 
 pub(crate) fn build_segment_agg_collectors(
     req: &mut AggregationsSegmentCtx,
     nodes: &[AggRefNode],
-) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
-    build_segment_agg_collectors_generic(req, nodes)
-}
-
-fn build_segment_agg_collectors_generic(
-    req: &mut AggregationsSegmentCtx,
-    nodes: &[AggRefNode],
 ) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
     let mut collectors = Vec::new();
     for node in nodes.iter() {
@@ -413,38 +385,10 @@ pub(crate) fn build_segment_agg_collector(
         }
         AggKind::Cardinality => {
             let req_data = &mut req.get_cardinality_req_data_mut(node.idx_in_req_data);
-            // For str columns, choose the per-bucket entries representation
-            // based on the segment's column.max_value():
-            //   * small (< BITSET_MAX_TERM_ORD): `BitSet`, pre-allocated, no promotion machinery.
-            //   * large: `TermOrdSet` (sparse FxHashSet that promotes to a paged bitset).
-            // For non-str columns the `entries` field is unused (values go
-            // straight into the HLL sketch); we still pick `TermOrdSet`
-            // because its empty Sparse(FxHashSet) costs nothing.
-            let is_str = req_data.column_type == ColumnType::Str;
-            let max_term_ord_inclusive = if is_str {
-                req_data.accessor.max_value()
-            } else {
-                0
-            };
-            let collector: Box<dyn SegmentAggregationCollector> =
-                if is_str && max_term_ord_inclusive < BITSET_MAX_TERM_ORD {
-                    Box::new(SegmentCardinalityCollector::<BitSet>::from_req(
-                        req_data.column_type,
-                        node.idx_in_req_data,
-                        req_data.accessor.clone(),
-                        req_data.missing_value_for_accessor,
-                        max_term_ord_inclusive,
-                    ))
-                } else {
-                    Box::new(SegmentCardinalityCollector::<TermOrdSet>::from_req(
-                        req_data.column_type,
-                        node.idx_in_req_data,
-                        req_data.accessor.clone(),
-                        req_data.missing_value_for_accessor,
-                        max_term_ord_inclusive,
-                    ))
-                };
-            Ok(collector)
+            Ok(Box::new(SegmentCardinalityCollector::from_req(
+                req_data.column_type,
+                node.idx_in_req_data,
+            )))
         }
         AggKind::StatsKind(stats_type) => {
             let req_data = &mut req.per_request.stats_metric_req_data[node.idx_in_req_data];
@@ -454,21 +398,20 @@ pub(crate) fn build_segment_agg_collector(
                 | StatsType::Count
                 | StatsType::Max
                 | StatsType::Min
-                | StatsType::Stats => build_segment_stats_collector(req_data),
-                StatsType::ExtendedStats(sigma) => Ok(Box::new(
-                    SegmentExtendedStatsCollector::from_req(req_data, sigma),
-                )),
-                StatsType::Percentiles => {
-                    let req_data = req.get_metric_req_data_mut(node.idx_in_req_data);
-                    Ok(Box::new(
-                        SegmentPercentilesCollector::from_req_and_validate(
-                            req_data.field_type,
-                            req_data.missing_u64,
-                            req_data.accessor.clone(),
-                            node.idx_in_req_data,
-                        ),
-                    ))
+                | StatsType::Stats => Ok(Box::new(SegmentStatsCollector::from_req(
+                    node.idx_in_req_data,
+                ))),
+                StatsType::ExtendedStats(sigma) => {
+                    Ok(Box::new(SegmentExtendedStatsCollector::from_req(
+                        req_data.field_type,
+                        sigma,
+                        node.idx_in_req_data,
+                        req_data.missing,
+                    )))
                 }
+                StatsType::Percentiles => Ok(Box::new(
+                    SegmentPercentilesCollector::from_req_and_validate(node.idx_in_req_data)?,
+                )),
             }
         }
         AggKind::TopHits => {
@@ -485,13 +428,12 @@ pub(crate) fn build_segment_agg_collector(
         AggKind::DateHistogram => Ok(Box::new(SegmentHistogramCollector::from_req_and_validate(
             req, node,
         )?)),
-        AggKind::Range => Ok(build_segment_range_collector(req, node)?),
-        AggKind::Filter => build_segment_filter_collector(req, node),
-        AggKind::Composite => Ok(Box::new(
-            crate::aggregation::bucket::SegmentCompositeCollector::from_req_and_validate(
-                req, node,
-            )?,
-        )),
+        AggKind::Range => Ok(Box::new(SegmentRangeCollector::from_req_and_validate(
+            req, node,
+        )?)),
+        AggKind::Filter => Ok(Box::new(SegmentFilterCollector::from_req_and_validate(
+            req, node,
+        )?)),
     }
 }
 
@@ -522,7 +464,6 @@ pub enum AggKind {
     DateHistogram,
     Range,
     Filter,
-    Composite,
 }
 
 impl AggKind {
@@ -538,7 +479,6 @@ impl AggKind {
             AggKind::DateHistogram => "DateHistogram",
             AggKind::Range => "Range",
             AggKind::Filter => "Filter",
-            AggKind::Composite => "Composite",
         }
     }
 }
@@ -553,7 +493,6 @@ pub(crate) fn build_aggregations_data_from_req(
     let mut data = AggregationsSegmentCtx {
         per_request: Default::default(),
         context,
-        column_block_accessor: ColumnBlockAccessor::default(),
     };
 
     for (name, agg) in aggs.iter() {
@@ -582,9 +521,9 @@ fn build_nodes(
             let idx_in_req_data = data.push_range_req_data(RangeAggReqData {
                 accessor,
                 field_type,
+                column_block_accessor: Default::default(),
                 name: agg_name.to_string(),
                 req: range_req.clone(),
-                is_top_level,
             });
             let children = build_children(&req.sub_aggregation, reader, segment_ordinal, data)?;
             Ok(vec![AggRefNode {
@@ -602,7 +541,9 @@ fn build_nodes(
             let idx_in_req_data = data.push_histogram_req_data(HistogramAggReqData {
                 accessor,
                 field_type,
+                column_block_accessor: Default::default(),
                 name: agg_name.to_string(),
+                sub_aggregation_blueprint: None,
                 req: histo_req.clone(),
                 is_date_histogram: false,
                 bounds: HistogramBounds {
@@ -627,7 +568,9 @@ fn build_nodes(
             let idx_in_req_data = data.push_histogram_req_data(HistogramAggReqData {
                 accessor,
                 field_type,
+                column_block_accessor: Default::default(),
                 name: agg_name.to_string(),
+                sub_aggregation_blueprint: None,
                 req: histo_req,
                 is_date_histogram: true,
                 bounds: HistogramBounds {
@@ -707,6 +650,7 @@ fn build_nodes(
             let idx_in_req_data = data.push_metric_req_data(MetricAggReqData {
                 accessor,
                 field_type,
+                column_block_accessor: Default::default(),
                 name: agg_name.to_string(),
                 collecting_for,
                 missing: *missing,
@@ -734,6 +678,7 @@ fn build_nodes(
             let idx_in_req_data = data.push_metric_req_data(MetricAggReqData {
                 accessor,
                 field_type,
+                column_block_accessor: Default::default(),
                 name: agg_name.to_string(),
                 collecting_for: StatsType::Percentiles,
                 missing: percentiles_req.missing,
@@ -786,14 +731,6 @@ fn build_nodes(
                 children,
             }])
         }
-        AggregationVariants::Composite(composite_req) => Ok(vec![build_composite_node(
-            agg_name,
-            reader,
-            segment_ordinal,
-            data,
-            &req.sub_aggregation,
-            composite_req,
-        )?]),
         AggregationVariants::Filter(filter_req) => {
             // Build the query and evaluator upfront
             let schema = reader.schema();
@@ -816,7 +753,6 @@ fn build_nodes(
                 segment_reader: reader.clone(),
                 evaluator,
                 matching_docs_buffer,
-                is_top_level,
             });
             let children = build_children(&req.sub_aggregation, reader, segment_ordinal, data)?;
             Ok(vec![AggRefNode {
@@ -828,35 +764,6 @@ fn build_nodes(
     }
 }
 
-fn build_composite_node(
-    agg_name: &str,
-    reader: &SegmentReader,
-    _segment_ordinal: SegmentOrdinal,
-    data: &mut AggregationsSegmentCtx,
-    sub_aggs: &Aggregations,
-    req: &CompositeAggregation,
-) -> crate::Result<AggRefNode> {
-    let mut composite_accessors = Vec::with_capacity(req.sources.len());
-    for source in &req.sources {
-        let source_after_key_opt = req.after.get(source.name()).map(|k| &k.0);
-        let source_accessor =
-            CompositeSourceAccessors::build_for_source(reader, source, source_after_key_opt)?;
-        composite_accessors.push(source_accessor);
-    }
-    let agg = CompositeAggReqData {
-        name: agg_name.to_string(),
-        req: req.clone(),
-        composite_accessors,
-    };
-    let idx = data.push_composite_req_data(agg);
-    let children = build_children(sub_aggs, reader, _segment_ordinal, data)?;
-    Ok(AggRefNode {
-        kind: AggKind::Composite,
-        idx_in_req_data: idx,
-        children,
-    })
-}
-
 fn build_children(
     aggs: &Aggregations,
     reader: &SegmentReader,
@@ -988,7 +895,7 @@ fn build_terms_or_cardinality_nodes(
         });
     }
 
-    // Add one node per accessor
+    // Add one node per accessor to mirror previous behavior and allow per-type missing handling.
     for (accessor, column_type) in column_and_types {
         let missing_value_for_accessor = if use_special_missing_agg {
             None
@@ -1011,20 +918,19 @@ fn build_terms_or_cardinality_nodes(
                     let str_col = str_dict_column
                         .as_ref()
                         .expect("str_dict_column must exist for string column");
-                    allowed_term_ids = build_allowed_term_ids_for_str(
-                        str_col,
-                        &req.include,
-                        &req.exclude,
-                        missing.is_some(),
-                    )?;
+                    allowed_term_ids =
+                        build_allowed_term_ids_for_str(str_col, &req.include, &req.exclude)?;
                 };
                 let idx_in_req_data = data.push_term_req_data(TermsAggReqData {
                     accessor,
                     column_type,
                     str_dict_column: str_dict_column.clone(),
                     missing_value_for_accessor,
+                    column_block_accessor: Default::default(),
                     name: agg_name.to_string(),
                     req: TermsAggregationInternal::from_req(req),
+                    // Will be filled later when building collectors
+                    sub_aggregation_blueprint: None,
                     sug_aggregations: sub_aggs.clone(),
                     allowed_term_ids,
                     is_top_level,
@@ -1032,21 +938,12 @@ fn build_terms_or_cardinality_nodes(
                 (idx_in_req_data, AggKind::Terms)
             }
             TermsOrCardinalityRequest::Cardinality(ref req) => {
-                // `str_dict_column` is computed once per field; for JSON paths
-                // with mixed types it's `Some` even on the numeric req_data.
-                // Cardinality only consults it for the str column path, so
-                // gate by column_type to avoid driving non-str collectors
-                // through the coupon-cache path.
-                let str_dict_column_for_req = if column_type == ColumnType::Str {
-                    str_dict_column.clone()
-                } else {
-                    None
-                };
                 let idx_in_req_data = data.push_cardinality_req_data(CardinalityAggReqData {
                     accessor,
                     column_type,
-                    str_dict_column: str_dict_column_for_req,
+                    str_dict_column: str_dict_column.clone(),
                     missing_value_for_accessor,
+                    column_block_accessor: Default::default(),
                     name: agg_name.to_string(),
                     req: req.clone(),
                 });
@@ -1065,21 +962,16 @@ fn build_terms_or_cardinality_nodes(
 
 /// Builds a single BitSet of allowed term ordinals for a string dictionary column according to
 /// include/exclude parameters.
-///
-/// When `reserve_missing_sentinel` is true, the bitset will have 1 additional slot for the missing
-/// term ordinal
 fn build_allowed_term_ids_for_str(
     str_col: &StrColumn,
     include: &Option<IncludeExcludeParam>,
     exclude: &Option<IncludeExcludeParam>,
-    reserve_missing_sentinel: bool,
 ) -> crate::Result<Option<BitSet>> {
     let mut allowed: Option<BitSet> = None;
-    let missing_sentinel_adjustment = if reserve_missing_sentinel { 1 } else { 0 };
-    let allowed_capacity = str_col.dictionary().num_terms() as u32 + missing_sentinel_adjustment;
+    let num_terms = str_col.dictionary().num_terms() as u32;
     if let Some(include) = include {
         // add matches
-        allowed = Some(BitSet::with_max_value(allowed_capacity));
+        allowed = Some(BitSet::with_max_value(num_terms));
         let allowed = allowed.as_mut().unwrap();
         for_each_matching_term_ord(str_col, include, |ord| allowed.insert(ord))?;
     };
@@ -1087,7 +979,7 @@ fn build_allowed_term_ids_for_str(
     if let Some(exclude) = exclude {
         if allowed.is_none() {
             // Start with all terms allowed
-            allowed = Some(BitSet::with_max_value_and_full(allowed_capacity));
+            allowed = Some(BitSet::with_max_value_and_full(num_terms));
         }
         let allowed = allowed.as_mut().unwrap();
         for_each_matching_term_ord(str_col, exclude, |ord| allowed.remove(ord))?;

src/aggregation/agg_req.rs

@@ -32,8 +32,8 @@ use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 use super::bucket::{
-    CompositeAggregation, DateHistogramAggregationReq, FilterAggregation, HistogramAggregation,
-    RangeAggregation, TermsAggregation,
+    DateHistogramAggregationReq, FilterAggregation, HistogramAggregation, RangeAggregation,
+    TermsAggregation,
 };
 use super::metric::{
     AverageAggregation, CardinalityAggregationReq, CountAggregation, ExtendedStatsAggregation,
@@ -115,71 +115,6 @@ pub fn get_fast_field_names(aggs: &Aggregations) -> HashSet<String> {
     fast_field_names
 }
 
-/// Validates that all fields referenced in the aggregation request exist in the schema
-/// and are configured as fast fields.
-///
-/// This is a convenience function for upfront validation before executing aggregations.
-/// Returns an error if any field doesn't exist or is not a fast field.
-///
-/// Validation is intentionally opt-in rather than baked into aggregation execution: the
-/// default lenient behavior (returning empty results for missing fields) supports
-/// schema evolution and federated queries where the same request runs against segments
-/// or indices with different schemas.
-///
-/// # Example
-/// ```
-/// use tantivy::aggregation::agg_req::{Aggregations, validate_aggregation_fields_exist};
-/// use tantivy::schema::{Schema, FAST};
-/// use tantivy::Index;
-///
-/// # fn main() -> tantivy::Result<()> {
-/// // Create a simple index
-/// let mut schema_builder = Schema::builder();
-/// schema_builder.add_f64_field("price", FAST);
-/// let schema = schema_builder.build();
-/// let index = Index::create_in_ram(schema);
-///
-/// // Parse aggregation request
-/// let agg_req: Aggregations = serde_json::from_str(r#"{
-///     "avg_price": { "avg": { "field": "price" } }
-/// }"#)?;
-///
-/// let reader = index.reader()?;
-/// let searcher = reader.searcher();
-///
-/// // Validate fields before executing
-/// for segment_reader in searcher.segment_readers() {
-///     validate_aggregation_fields_exist(&agg_req, segment_reader)?;
-/// }
-/// # Ok(())
-/// # }
-/// ```
-pub fn validate_aggregation_fields_exist(
-    aggs: &Aggregations,
-    reader: &crate::SegmentReader,
-) -> crate::Result<()> {
-    let field_names = get_fast_field_names(aggs);
-    let schema = reader.schema();
-
-    for field_name in field_names {
-        // Check if the field is either directly in the schema or could be part of a json field
-        // present in the schema, and verify it's a fast field.
-        if let Some((field, _path)) = schema.find_field(&field_name) {
-            let field_type = schema.get_field_entry(field).field_type();
-            if !field_type.is_fast() {
-                return Err(crate::TantivyError::SchemaError(format!(
-                    "Field '{}' is not a fast field. Aggregations require fast fields.",
-                    field_name
-                )));
-            }
-        } else {
-            return Err(crate::TantivyError::FieldNotFound(field_name));
-        }
-    }
-
-    Ok(())
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 /// All aggregation types.
 pub enum AggregationVariants {
@@ -199,9 +134,6 @@ pub enum AggregationVariants {
     /// Filter documents into a single bucket.
     #[serde(rename = "filter")]
     Filter(FilterAggregation),
-    /// Multi-dimensional, paginable bucket aggregation.
-    #[serde(rename = "composite")]
-    Composite(CompositeAggregation),
 
     // Metric aggregation types
     /// Computes the average of the extracted values.
@@ -248,11 +180,6 @@ impl AggregationVariants {
             AggregationVariants::Histogram(histogram) => vec![histogram.field.as_str()],
             AggregationVariants::DateHistogram(histogram) => vec![histogram.field.as_str()],
             AggregationVariants::Filter(filter) => filter.get_fast_field_names(),
-            AggregationVariants::Composite(composite) => composite
-                .sources
-                .iter()
-                .map(|source| source.field())
-                .collect(),
             AggregationVariants::Average(avg) => vec![avg.field_name()],
             AggregationVariants::Count(count) => vec![count.field_name()],
             AggregationVariants::Max(max) => vec![max.field_name()],
@@ -287,12 +214,6 @@ impl AggregationVariants {
             _ => None,
         }
     }
-    pub(crate) fn as_composite(&self) -> Option<&CompositeAggregation> {
-        match &self {
-            AggregationVariants::Composite(composite) => Some(composite),
-            _ => None,
-        }
-    }
     pub(crate) fn as_percentile(&self) -> Option<&PercentilesAggregationReq> {
         match &self {
             AggregationVariants::Percentiles(percentile_req) => Some(percentile_req),

src/aggregation/agg_result.rs

@@ -9,12 +9,10 @@ use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 use super::bucket::GetDocCount;
-use super::intermediate_agg_result::CompositeIntermediateKey;
 use super::metric::{
     ExtendedStats, PercentilesMetricResult, SingleMetricResult, Stats, TopHitsMetricResult,
 };
 use super::{AggregationError, Key};
-use crate::aggregation::bucket::AfterKey;
 use crate::TantivyError;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
@@ -160,14 +158,6 @@ pub enum BucketResult {
     },
     /// This is the filter result - a single bucket with sub-aggregations
     Filter(FilterBucketResult),
-    /// This is the composite result
-    Composite {
-        /// The buckets
-        buckets: Vec<CompositeBucketEntry>,
-        /// The key to start after when paginating
-        #[serde(skip_serializing_if = "FxHashMap::is_empty")]
-        after_key: FxHashMap<String, AfterKey>,
-    },
 }
 
 impl BucketResult {
@@ -189,9 +179,6 @@ impl BucketResult {
                 // Only count sub-aggregation buckets
                 filter_result.sub_aggregations.get_bucket_count()
             }
-            BucketResult::Composite { buckets, .. } => {
-                buckets.iter().map(|bucket| bucket.get_bucket_count()).sum()
-            }
         }
     }
 }
@@ -208,8 +195,7 @@ pub enum BucketEntries<T> {
 }
 
 impl<T> BucketEntries<T> {
-    /// Iterate over all bucket entries.
-    pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a T> + 'a> {
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a T> + 'a> {
         match self {
             BucketEntries::Vec(vec) => Box::new(vec.iter()),
             BucketEntries::HashMap(map) => Box::new(map.values()),
@@ -351,87 +337,3 @@ pub struct FilterBucketResult {
     #[serde(flatten)]
     pub sub_aggregations: AggregationResults,
 }
-
-/// Note the type information loss compared to `CompositeIntermediateKey`.
-/// Pagination is performed using `AfterKey`, which encodes type information.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum CompositeKey {
-    /// Boolean key
-    Bool(bool),
-    /// String key
-    Str(String),
-    /// `i64` key
-    I64(i64),
-    /// `u64` key
-    U64(u64),
-    /// `f64` key
-    F64(f64),
-    /// Null key
-    Null,
-}
-impl Eq for CompositeKey {}
-impl std::hash::Hash for CompositeKey {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        core::mem::discriminant(self).hash(state);
-        match self {
-            Self::Bool(val) => val.hash(state),
-            Self::Str(text) => text.hash(state),
-            Self::F64(val) => val.to_bits().hash(state),
-            Self::U64(val) => val.hash(state),
-            Self::I64(val) => val.hash(state),
-            Self::Null => {}
-        }
-    }
-}
-impl PartialEq for CompositeKey {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Bool(l), Self::Bool(r)) => l == r,
-            (Self::Str(l), Self::Str(r)) => l == r,
-            (Self::F64(l), Self::F64(r)) => l.to_bits() == r.to_bits(),
-            (Self::I64(l), Self::I64(r)) => l == r,
-            (Self::U64(l), Self::U64(r)) => l == r,
-            (Self::Null, Self::Null) => true,
-            _ => false,
-        }
-    }
-}
-impl From<CompositeIntermediateKey> for CompositeKey {
-    fn from(value: CompositeIntermediateKey) -> Self {
-        match value {
-            CompositeIntermediateKey::Str(s) => Self::Str(s),
-            CompositeIntermediateKey::IpAddr(s) => {
-                if let Some(ip) = s.to_ipv4_mapped() {
-                    Self::Str(ip.to_string())
-                } else {
-                    Self::Str(s.to_string())
-                }
-            }
-            CompositeIntermediateKey::F64(f) => Self::F64(f),
-            CompositeIntermediateKey::Bool(f) => Self::Bool(f),
-            CompositeIntermediateKey::U64(f) => Self::U64(f),
-            CompositeIntermediateKey::I64(f) => Self::I64(f),
-            CompositeIntermediateKey::DateTime(f) => Self::I64(f / 1_000_000), // ns to ms
-            CompositeIntermediateKey::Null => Self::Null,
-        }
-    }
-}
-
-/// Composite bucket entry with a multi-dimensional key.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct CompositeBucketEntry {
-    /// The identifier of the bucket.
-    pub key: FxHashMap<String, CompositeKey>,
-    /// Number of documents in the bucket.
-    pub doc_count: u64,
-    #[serde(flatten)]
-    /// Sub-aggregations in this bucket.
-    pub sub_aggregation: AggregationResults,
-}
-
-impl CompositeBucketEntry {
-    pub(crate) fn get_bucket_count(&self) -> u64 {
-        1 + self.sub_aggregation.get_bucket_count()
-    }
-}

src/aggregation/agg_tests.rs

@@ -2,441 +2,15 @@ use serde_json::Value;
 
 use crate::aggregation::agg_req::{Aggregation, Aggregations};
 use crate::aggregation::agg_result::AggregationResults;
+use crate::aggregation::buf_collector::DOC_BLOCK_SIZE;
 use crate::aggregation::collector::AggregationCollector;
 use crate::aggregation::intermediate_agg_result::IntermediateAggregationResults;
 use crate::aggregation::tests::{get_test_index_2_segments, get_test_index_from_values_and_terms};
 use crate::aggregation::DistributedAggregationCollector;
-use crate::docset::COLLECT_BLOCK_BUFFER_LEN;
 use crate::query::{AllQuery, TermQuery};
 use crate::schema::{IndexRecordOption, Schema, FAST};
 use crate::{Index, IndexWriter, Term};
 
-// The following tests ensure that each bucket aggregation type correctly functions as a
-// sub-aggregation of another bucket aggregation in two scenarios:
-// 1) The parent has more buckets than the child sub-aggregation
-// 2) The child sub-aggregation has more buckets than the parent
-//
-// These scenarios exercise the bucket id mapping and sub-aggregation routing logic.
-
-#[test]
-fn test_terms_as_subagg_parent_more_vs_child_more() -> crate::Result<()> {
-    let index = get_test_index_2_segments(false)?;
-
-    // Case A: parent has more buckets than child
-    // Parent: range with 4 buckets
-    // Child: terms on text -> 2 buckets
-    let agg_parent_more: Aggregations = serde_json::from_value(json!({
-        "parent_range": {
-            "range": {
-                "field": "score",
-                "ranges": [
-                    {"to": 3.0},
-                    {"from": 3.0, "to": 7.0},
-                    {"from": 7.0, "to": 20.0},
-                    {"from": 20.0}
-                ]
-            },
-            "aggs": {
-                "child_terms": {"terms": {"field": "text", "order": {"_key": "asc"}}}
-            }
-        }
-    }))
-    .unwrap();
-
-    let res = crate::aggregation::tests::exec_request(agg_parent_more, &index)?;
-    // Exact expected structure and counts
-    assert_eq!(
-        res["parent_range"]["buckets"],
-        json!([
-            {
-                "key": "*-3",
-                "doc_count": 1,
-                "to": 3.0,
-                "child_terms": {
-                    "buckets": [
-                        {"doc_count": 1, "key": "cool"}
-                    ],
-                    "sum_other_doc_count": 0
-                }
-            },
-            {
-                "key": "3-7",
-                "doc_count": 3,
-                "from": 3.0,
-                "to": 7.0,
-                "child_terms": {
-                    "buckets": [
-                        {"doc_count": 2, "key": "cool"},
-                        {"doc_count": 1, "key": "nohit"}
-                    ],
-                    "sum_other_doc_count": 0
-                }
-            },
-            {
-                "key": "7-20",
-                "doc_count": 3,
-                "from": 7.0,
-                "to": 20.0,
-                "child_terms": {
-                    "buckets": [
-                        {"doc_count": 3, "key": "cool"}
-                    ],
-                    "sum_other_doc_count": 0
-                }
-            },
-            {
-                "key": "20-*",
-                "doc_count": 2,
-                "from": 20.0,
-                "child_terms": {
-                    "buckets": [
-                        {"doc_count": 1, "key": "cool"},
-                        {"doc_count": 1, "key": "nohit"}
-                    ],
-                    "sum_other_doc_count": 0
-                }
-            }
-        ])
-    );
-
-    // Case B: child has more buckets than parent
-    // Parent: histogram on score with large interval -> 1 bucket
-    // Child: terms on text -> 2 buckets (cool/nohit)
-    let agg_child_more: Aggregations = serde_json::from_value(json!({
-        "parent_hist": {
-            "histogram": {"field": "score", "interval": 100.0},
-            "aggs": {
-                "child_terms": {"terms": {"field": "text", "order": {"_key": "asc"}}}
-            }
-        }
-    }))
-    .unwrap();
-
-    let res = crate::aggregation::tests::exec_request(agg_child_more, &index)?;
-    assert_eq!(
-        res["parent_hist"],
-        json!({
-            "buckets": [
-                {
-                    "key": 0.0,
-                    "doc_count": 9,
-                    "child_terms": {
-                        "buckets": [
-                            {"doc_count": 7, "key": "cool"},
-                            {"doc_count": 2, "key": "nohit"}
-                        ],
-                        "sum_other_doc_count": 0
-                    }
-                }
-            ]
-        })
-    );
-
-    Ok(())
-}
-
-#[test]
-fn test_range_as_subagg_parent_more_vs_child_more() -> crate::Result<()> {
-    let index = get_test_index_2_segments(false)?;
-
-    // Case A: parent has more buckets than child
-    // Parent: range with 5 buckets
-    // Child: coarse range with 3 buckets
-    let agg_parent_more: Aggregations = serde_json::from_value(json!({
-        "parent_range": {
-            "range": {
-                "field": "score",
-                "ranges": [
-                    {"to": 3.0},
-                    {"from": 3.0, "to": 7.0},
-                    {"from": 7.0, "to": 11.0},
-                    {"from": 11.0, "to": 20.0},
-                    {"from": 20.0}
-                ]
-            },
-            "aggs": {
-                "child_range": {
-                    "range": {
-                        "field": "score",
-                        "ranges": [
-                            {"to": 3.0},
-                            {"from": 3.0, "to": 20.0}
-                        ]
-                    }
-                }
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_parent_more, &index)?;
-    assert_eq!(
-        res["parent_range"]["buckets"],
-        json!([
-            {"key": "*-3", "doc_count": 1, "to": 3.0,
-                "child_range": {"buckets": [
-                    {"key": "*-3", "doc_count": 1, "to": 3.0},
-                    {"key": "3-20", "doc_count": 0, "from": 3.0, "to": 20.0},
-                    {"key": "20-*", "doc_count": 0, "from": 20.0}
-                ]}
-            },
-            {"key": "3-7", "doc_count": 3, "from": 3.0, "to": 7.0,
-                "child_range": {"buckets": [
-                    {"key": "*-3", "doc_count": 0, "to": 3.0},
-                    {"key": "3-20", "doc_count": 3, "from": 3.0, "to": 20.0},
-                    {"key": "20-*", "doc_count": 0, "from": 20.0}
-                ]}
-            },
-            {"key": "7-11", "doc_count": 1, "from": 7.0, "to": 11.0,
-                "child_range": {"buckets": [
-                    {"key": "*-3", "doc_count": 0, "to": 3.0},
-                    {"key": "3-20", "doc_count": 1, "from": 3.0, "to": 20.0},
-                    {"key": "20-*", "doc_count": 0, "from": 20.0}
-                ]}
-            },
-            {"key": "11-20", "doc_count": 2, "from": 11.0, "to": 20.0,
-                "child_range": {"buckets": [
-                    {"key": "*-3", "doc_count": 0, "to": 3.0},
-                    {"key": "3-20", "doc_count": 2, "from": 3.0, "to": 20.0},
-                    {"key": "20-*", "doc_count": 0, "from": 20.0}
-                ]}
-            },
-            {"key": "20-*", "doc_count": 2, "from": 20.0,
-                "child_range": {"buckets": [
-                    {"key": "*-3", "doc_count": 0, "to": 3.0},
-                    {"key": "3-20", "doc_count": 0, "from": 3.0, "to": 20.0},
-                    {"key": "20-*", "doc_count": 2, "from": 20.0}
-                ]}
-            }
-        ])
-    );
-
-    // Case B: child has more buckets than parent
-    // Parent: terms on text (2 buckets)
-    // Child: range with 4 buckets
-    let agg_child_more: Aggregations = serde_json::from_value(json!({
-        "parent_terms": {
-            "terms": {"field": "text"},
-            "aggs": {
-                "child_range": {
-                    "range": {
-                        "field": "score",
-                        "ranges": [
-                            {"to": 3.0},
-                            {"from": 3.0, "to": 7.0},
-                            {"from": 7.0, "to": 20.0}
-                        ]
-                    }
-                }
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_child_more, &index)?;
-
-    assert_eq!(
-        res["parent_terms"],
-        json!({
-            "buckets": [
-                {
-                    "key": "cool",
-                    "doc_count": 7,
-                    "child_range": {
-                        "buckets": [
-                            {"key": "*-3", "doc_count": 1, "to": 3.0},
-                            {"key": "3-7", "doc_count": 2, "from": 3.0, "to": 7.0},
-                            {"key": "7-20", "doc_count": 3, "from": 7.0, "to": 20.0},
-                            {"key": "20-*", "doc_count": 1, "from": 20.0}
-                        ]
-                    }
-                },
-                {
-                    "key": "nohit",
-                    "doc_count": 2,
-                    "child_range": {
-                        "buckets": [
-                            {"key": "*-3", "doc_count": 0, "to": 3.0},
-                            {"key": "3-7", "doc_count": 1, "from": 3.0, "to": 7.0},
-                            {"key": "7-20", "doc_count": 0, "from": 7.0, "to": 20.0},
-                            {"key": "20-*", "doc_count": 1, "from": 20.0}
-                        ]
-                    }
-                }
-            ],
-            "doc_count_error_upper_bound": 0,
-            "sum_other_doc_count": 0
-        })
-    );
-
-    Ok(())
-}
-
-#[test]
-fn test_histogram_as_subagg_parent_more_vs_child_more() -> crate::Result<()> {
-    let index = get_test_index_2_segments(false)?;
-
-    // Case A: parent has more buckets than child
-    // Parent: range with several ranges
-    // Child: histogram with large interval (single bucket per parent)
-    let agg_parent_more: Aggregations = serde_json::from_value(json!({
-        "parent_range": {
-            "range": {
-                "field": "score",
-                "ranges": [
-                    {"to": 3.0},
-                    {"from": 3.0, "to": 7.0},
-                    {"from": 7.0, "to": 11.0},
-                    {"from": 11.0, "to": 20.0},
-                    {"from": 20.0}
-                ]
-            },
-            "aggs": {
-                "child_hist": {"histogram": {"field": "score", "interval": 100.0}}
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_parent_more, &index)?;
-    assert_eq!(
-        res["parent_range"]["buckets"],
-        json!([
-            {"key": "*-3", "doc_count": 1, "to": 3.0,
-                "child_hist": {"buckets": [ {"key": 0.0, "doc_count": 1} ]}
-            },
-            {"key": "3-7", "doc_count": 3, "from": 3.0, "to": 7.0,
-                "child_hist": {"buckets": [ {"key": 0.0, "doc_count": 3} ]}
-            },
-            {"key": "7-11", "doc_count": 1, "from": 7.0, "to": 11.0,
-                "child_hist": {"buckets": [ {"key": 0.0, "doc_count": 1} ]}
-            },
-            {"key": "11-20", "doc_count": 2, "from": 11.0, "to": 20.0,
-                "child_hist": {"buckets": [ {"key": 0.0, "doc_count": 2} ]}
-            },
-            {"key": "20-*", "doc_count": 2, "from": 20.0,
-                "child_hist": {"buckets": [ {"key": 0.0, "doc_count": 2} ]}
-            }
-        ])
-    );
-
-    // Case B: child has more buckets than parent
-    // Parent: terms on text -> 2 buckets
-    // Child: histogram with small interval -> multiple buckets including empties
-    let agg_child_more: Aggregations = serde_json::from_value(json!({
-        "parent_terms": {
-            "terms": {"field": "text"},
-            "aggs": {
-                "child_hist": {"histogram": {"field": "score", "interval": 10.0}}
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_child_more, &index)?;
-    assert_eq!(
-        res["parent_terms"],
-        json!({
-            "buckets": [
-                {
-                    "key": "cool",
-                    "doc_count": 7,
-                    "child_hist": {
-                        "buckets": [
-                            {"key": 0.0, "doc_count": 4},
-                            {"key": 10.0, "doc_count": 2},
-                            {"key": 20.0, "doc_count": 0},
-                            {"key": 30.0, "doc_count": 0},
-                            {"key": 40.0, "doc_count": 1}
-                        ]
-                    }
-                },
-                {
-                    "key": "nohit",
-                    "doc_count": 2,
-                    "child_hist": {
-                        "buckets": [
-                            {"key": 0.0, "doc_count": 1},
-                            {"key": 10.0, "doc_count": 0},
-                            {"key": 20.0, "doc_count": 0},
-                            {"key": 30.0, "doc_count": 0},
-                            {"key": 40.0, "doc_count": 1}
-                        ]
-                    }
-                }
-            ],
-            "doc_count_error_upper_bound": 0,
-            "sum_other_doc_count": 0
-        })
-    );
-
-    Ok(())
-}
-
-#[test]
-fn test_date_histogram_as_subagg_parent_more_vs_child_more() -> crate::Result<()> {
-    let index = get_test_index_2_segments(false)?;
-
-    // Case A: parent has more buckets than child
-    // Parent: range with several buckets
-    // Child: date_histogram with 30d -> single bucket per parent
-    let agg_parent_more: Aggregations = serde_json::from_value(json!({
-        "parent_range": {
-            "range": {
-                "field": "score",
-                "ranges": [
-                    {"to": 3.0},
-                    {"from": 3.0, "to": 7.0},
-                    {"from": 7.0, "to": 11.0},
-                    {"from": 11.0, "to": 20.0},
-                    {"from": 20.0}
-                ]
-            },
-            "aggs": {
-                "child_date_hist": {"date_histogram": {"field": "date", "fixed_interval": "30d"}}
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_parent_more, &index)?;
-    let buckets = res["parent_range"]["buckets"].as_array().unwrap();
-    // Verify each parent bucket has exactly one child date bucket with matching doc_count
-    for bucket in buckets {
-        let parent_count = bucket["doc_count"].as_u64().unwrap();
-        let child_buckets = bucket["child_date_hist"]["buckets"].as_array().unwrap();
-        assert_eq!(child_buckets.len(), 1);
-        assert_eq!(child_buckets[0]["doc_count"], parent_count);
-    }
-
-    // Case B: child has more buckets than parent
-    // Parent: terms on text (2 buckets)
-    // Child: date_histogram with 1d -> multiple buckets
-    let agg_child_more: Aggregations = serde_json::from_value(json!({
-        "parent_terms": {
-            "terms": {"field": "text"},
-            "aggs": {
-                "child_date_hist": {"date_histogram": {"field": "date", "fixed_interval": "1d"}}
-            }
-        }
-    }))
-    .unwrap();
-    let res = crate::aggregation::tests::exec_request(agg_child_more, &index)?;
-    let buckets = res["parent_terms"]["buckets"].as_array().unwrap();
-
-    // cool bucket
-    assert_eq!(buckets[0]["key"], "cool");
-    let cool_buckets = buckets[0]["child_date_hist"]["buckets"].as_array().unwrap();
-    assert_eq!(cool_buckets.len(), 3);
-    assert_eq!(cool_buckets[0]["doc_count"], 1); // day 0
-    assert_eq!(cool_buckets[1]["doc_count"], 4); // day 1
-    assert_eq!(cool_buckets[2]["doc_count"], 2); // day 2
-
-    // nohit bucket
-    assert_eq!(buckets[1]["key"], "nohit");
-    let nohit_buckets = buckets[1]["child_date_hist"]["buckets"].as_array().unwrap();
-    assert_eq!(nohit_buckets.len(), 2);
-    assert_eq!(nohit_buckets[0]["doc_count"], 1); // day 1
-    assert_eq!(nohit_buckets[1]["doc_count"], 1); // day 2
-
-    Ok(())
-}
-
 fn get_avg_req(field_name: &str) -> Aggregation {
     serde_json::from_value(json!({
         "avg": {
@@ -451,10 +25,6 @@ fn get_collector(agg_req: Aggregations) -> AggregationCollector {
 }
 
 // *** EVERY BUCKET-TYPE SHOULD BE TESTED HERE ***
-// Note: The flushng part of these  tests are outdated, since the buffering change after converting
-// the collection into one collector per request instead of per bucket.
-//
-// However they are useful as they test a complex aggregation requests.
 fn test_aggregation_flushing(
     merge_segments: bool,
     use_distributed_collector: bool,
@@ -467,9 +37,8 @@ fn test_aggregation_flushing(
 
     let reader = index.reader()?;
 
-    assert_eq!(COLLECT_BLOCK_BUFFER_LEN, 64);
-    // In the tree we cache documents of COLLECT_BLOCK_BUFFER_LEN before passing them down as one
-    // block.
+    assert_eq!(DOC_BLOCK_SIZE, 64);
+    // In the tree we cache Documents of DOC_BLOCK_SIZE, before passing them down as one block.
     //
     // Build a request so that on the first level we have one full cache, which is then flushed.
     // The same cache should have some residue docs at the end, which are flushed (Range 0-70)
@@ -1436,46 +1005,3 @@ fn test_aggregation_on_json_object_mixed_numerical_segments() {
         )
     );
 }
-
-#[test]
-fn test_aggregation_field_validation_helper() {
-    // Test the standalone validation helper function for field validation
-    let index = get_test_index_2_segments(false).unwrap();
-    let reader = index.reader().unwrap();
-    let searcher = reader.searcher();
-    let segment_reader = searcher.segment_reader(0);
-
-    // Test with invalid field
-    let agg_req: Aggregations = serde_json::from_str(
-        r#"{
-        "avg_test": {
-            "avg": { "field": "nonexistent_field" }
-        }
-    }"#,
-    )
-    .unwrap();
-
-    let result =
-        crate::aggregation::agg_req::validate_aggregation_fields_exist(&agg_req, segment_reader);
-    assert!(result.is_err());
-    match result {
-        Err(crate::TantivyError::FieldNotFound(field_name)) => {
-            assert_eq!(field_name, "nonexistent_field");
-        }
-        _ => panic!("Expected FieldNotFound error, got: {:?}", result),
-    }
-
-    // Test with valid field
-    let agg_req: Aggregations = serde_json::from_str(
-        r#"{
-        "avg_test": {
-            "avg": { "field": "score" }
-        }
-    }"#,
-    )
-    .unwrap();
-
-    let result =
-        crate::aggregation::agg_req::validate_aggregation_fields_exist(&agg_req, segment_reader);
-    assert!(result.is_ok());
-}

src/aggregation/bucket/composite/accessors.rs

@@ -1,518 +0,0 @@
-use std::net::Ipv6Addr;
-
-use columnar::column_values::{CompactHit, CompactSpaceU64Accessor};
-use columnar::{Column, ColumnType, MonotonicallyMappableToU64, StrColumn, TermOrdHit};
-
-use crate::aggregation::accessor_helpers::get_numeric_or_date_column_types;
-use crate::aggregation::bucket::composite::numeric_types::num_proj;
-use crate::aggregation::bucket::composite::numeric_types::num_proj::ProjectedNumber;
-use crate::aggregation::bucket::composite::ToTypePaginationOrder;
-use crate::aggregation::bucket::{
-    parse_into_milliseconds, CalendarInterval, CompositeAggregation, CompositeAggregationSource,
-    MissingOrder, Order,
-};
-use crate::aggregation::intermediate_agg_result::CompositeIntermediateKey;
-use crate::{SegmentReader, TantivyError};
-
-/// Contains all information required by the SegmentCompositeCollector to perform the
-/// composite aggregation on a segment.
-pub struct CompositeAggReqData {
-    /// The name of the aggregation.
-    pub name: String,
-    /// The normalized term aggregation request.
-    pub req: CompositeAggregation,
-    /// Accessors for each source, each source can have multiple accessors (columns).
-    pub composite_accessors: Vec<CompositeSourceAccessors>,
-}
-
-impl CompositeAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-            + self.composite_accessors.len() * std::mem::size_of::<CompositeSourceAccessors>()
-    }
-}
-
-/// Accessors for a single column in a composite source.
-pub struct CompositeAccessor {
-    /// The fast field column
-    pub column: Column<u64>,
-    /// The column type
-    pub column_type: ColumnType,
-    /// Term dictionary if the column type is Str
-    ///
-    /// Only used by term sources
-    pub str_dict_column: Option<StrColumn>,
-    /// Parsed date interval for date histogram sources
-    pub date_histogram_interval: PrecomputedDateInterval,
-}
-
-/// Accessors to all the columns that belong to the field of a composite source.
-pub struct CompositeSourceAccessors {
-    /// The accessors for this source
-    pub accessors: Vec<CompositeAccessor>,
-    /// The key after which to start collecting results. Applies to the first
-    /// column of the source.
-    pub after_key: PrecomputedAfterKey,
-
-    /// The column index the after_key applies to. The after_key only applies to
-    /// one column. Columns before should be skipped. Columns after should be
-    /// kept without comparison to the after_key.
-    pub after_key_accessor_idx: usize,
-
-    /// Whether to skip missing values because of the after_key. Skipping only
-    /// applies if the value for previous columns were exactly equal to the
-    /// corresponding after keys (is_on_after_key).
-    pub skip_missing: bool,
-
-    /// The after key was set to null to indicate that the last collected key
-    /// was a missing value.
-    pub is_after_key_explicit_missing: bool,
-}
-
-impl CompositeSourceAccessors {
-    /// Creates a new set of accessors for the composite source.
-    ///
-    /// Precomputes some values to make collection faster.
-    pub fn build_for_source(
-        reader: &SegmentReader,
-        source: &CompositeAggregationSource,
-        // First option is None when no after key was set in the query, the
-        // second option is None when the after key was set but its value for
-        // this source was set to `null`
-        source_after_key_opt: Option<&CompositeIntermediateKey>,
-    ) -> crate::Result<Self> {
-        let is_after_key_explicit_missing = source_after_key_opt
-            .map(|after_key| matches!(after_key, CompositeIntermediateKey::Null))
-            .unwrap_or(false);
-        let mut skip_missing = false;
-        if let Some(CompositeIntermediateKey::Null) = source_after_key_opt {
-            if !source.missing_bucket() {
-                return Err(TantivyError::InvalidArgument(
-                    "the 'after' key for a source cannot be null when 'missing_bucket' is false"
-                        .to_string(),
-                ));
-            }
-        } else if source_after_key_opt.is_some() {
-            // if missing buckets come first and we have a non null after key, we skip missing
-            if MissingOrder::First == source.missing_order() {
-                skip_missing = true;
-            }
-            if MissingOrder::Default == source.missing_order() && Order::Asc == source.order() {
-                skip_missing = true;
-            }
-        };
-
-        match source {
-            CompositeAggregationSource::Terms(source) => {
-                let allowed_column_types = [
-                    ColumnType::I64,
-                    ColumnType::U64,
-                    ColumnType::F64,
-                    ColumnType::Str,
-                    ColumnType::DateTime,
-                    ColumnType::Bool,
-                    ColumnType::IpAddr,
-                    // ColumnType::Bytes Unsupported
-                ];
-                let mut columns_and_types = reader
-                    .fast_fields()
-                    .u64_lenient_for_type_all(Some(&allowed_column_types), &source.field)?;
-
-                // Sort columns by their pagination order and determine which to skip
-                columns_and_types.sort_by_key(|(_, col_type): &(Column, ColumnType)| {
-                    col_type.column_pagination_order()
-                });
-                if source.order == Order::Desc {
-                    columns_and_types.reverse();
-                }
-                let after_key_accessor_idx = find_first_column_to_collect(
-                    &columns_and_types,
-                    source_after_key_opt,
-                    source.missing_order,
-                    source.order,
-                )?;
-
-                let source_collectors: Vec<CompositeAccessor> = columns_and_types
-                    .into_iter()
-                    .map(|(column, column_type)| {
-                        Ok(CompositeAccessor {
-                            column,
-                            column_type,
-                            str_dict_column: reader.fast_fields().str(&source.field)?,
-                            date_histogram_interval: PrecomputedDateInterval::NotApplicable,
-                        })
-                    })
-                    .collect::<crate::Result<_>>()?;
-
-                let after_key = if let Some(first_col) =
-                    source_collectors.get(after_key_accessor_idx)
-                {
-                    match source_after_key_opt {
-                        Some(after_key) => PrecomputedAfterKey::precompute(
-                            first_col,
-                            after_key,
-                            &source.field,
-                            source.missing_order,
-                            source.order,
-                        )?,
-                        None => {
-                            precompute_missing_after_key(false, source.missing_order, source.order)
-                        }
-                    }
-                } else {
-                    // if no columns, we don't care about the after_key
-                    PrecomputedAfterKey::Next(0)
-                };
-
-                Ok(CompositeSourceAccessors {
-                    accessors: source_collectors,
-                    is_after_key_explicit_missing,
-                    skip_missing,
-                    after_key,
-                    after_key_accessor_idx,
-                })
-            }
-            CompositeAggregationSource::Histogram(source) => {
-                let column_and_types: Vec<(Column, ColumnType)> =
-                    reader.fast_fields().u64_lenient_for_type_all(
-                        Some(get_numeric_or_date_column_types()),
-                        &source.field,
-                    )?;
-                let source_collectors: Vec<CompositeAccessor> = column_and_types
-                    .into_iter()
-                    .map(|(column, column_type)| {
-                        Ok(CompositeAccessor {
-                            column,
-                            column_type,
-                            str_dict_column: None,
-                            date_histogram_interval: PrecomputedDateInterval::NotApplicable,
-                        })
-                    })
-                    .collect::<crate::Result<_>>()?;
-                let after_key = match source_after_key_opt {
-                    Some(CompositeIntermediateKey::F64(key)) => {
-                        let normalized_key = *key / source.interval;
-                        num_proj::f64_to_i64(normalized_key).into()
-                    }
-                    Some(CompositeIntermediateKey::Null) => {
-                        precompute_missing_after_key(true, source.missing_order, source.order)
-                    }
-                    None => precompute_missing_after_key(true, source.missing_order, source.order),
-                    _ => {
-                        return Err(crate::TantivyError::InvalidArgument(
-                            "After key type invalid for interval composite source".to_string(),
-                        ));
-                    }
-                };
-                Ok(CompositeSourceAccessors {
-                    accessors: source_collectors,
-                    is_after_key_explicit_missing,
-                    skip_missing,
-                    after_key,
-                    after_key_accessor_idx: 0,
-                })
-            }
-            CompositeAggregationSource::DateHistogram(source) => {
-                let column_and_types = reader
-                    .fast_fields()
-                    .u64_lenient_for_type_all(Some(&[ColumnType::DateTime]), &source.field)?;
-                let date_histogram_interval =
-                    PrecomputedDateInterval::from_date_histogram_source_intervals(
-                        &source.fixed_interval,
-                        source.calendar_interval,
-                    )?;
-                let source_collectors: Vec<CompositeAccessor> = column_and_types
-                    .into_iter()
-                    .map(|(column, column_type)| {
-                        Ok(CompositeAccessor {
-                            column,
-                            column_type,
-                            str_dict_column: None,
-                            date_histogram_interval,
-                        })
-                    })
-                    .collect::<crate::Result<_>>()?;
-                let after_key = match source_after_key_opt {
-                    Some(CompositeIntermediateKey::DateTime(key)) => {
-                        PrecomputedAfterKey::Exact(key.to_u64())
-                    }
-                    Some(CompositeIntermediateKey::Null) => {
-                        precompute_missing_after_key(true, source.missing_order, source.order)
-                    }
-                    None => precompute_missing_after_key(true, source.missing_order, source.order),
-                    _ => {
-                        return Err(crate::TantivyError::InvalidArgument(
-                            "After key type invalid for interval composite source".to_string(),
-                        ));
-                    }
-                };
-                Ok(CompositeSourceAccessors {
-                    accessors: source_collectors,
-                    is_after_key_explicit_missing,
-                    skip_missing,
-                    after_key,
-                    after_key_accessor_idx: 0,
-                })
-            }
-        }
-    }
-}
-
-/// Finds the index of the first column we should start collecting from to
-/// resume the pagination from the after_key.
-fn find_first_column_to_collect<T>(
-    sorted_columns: &[(T, ColumnType)],
-    after_key_opt: Option<&CompositeIntermediateKey>,
-    missing_order: MissingOrder,
-    order: Order,
-) -> crate::Result<usize> {
-    let after_key = match after_key_opt {
-        None => return Ok(0), // No pagination, start from beginning
-        Some(key) => key,
-    };
-    // Handle null after_key (we were on a missing value last time)
-    if matches!(after_key, CompositeIntermediateKey::Null) {
-        return match (missing_order, order) {
-            // Missing values come first, so all columns remain
-            (MissingOrder::First, _) | (MissingOrder::Default, Order::Asc) => Ok(0),
-            // Missing values come last, so all columns are done
-            (MissingOrder::Last, _) | (MissingOrder::Default, Order::Desc) => {
-                Ok(sorted_columns.len())
-            }
-        };
-    }
-    // Find the first column whose type order matches or follows the after_key's
-    // type in the pagination sequence
-    let after_key_column_order = after_key.column_pagination_order();
-    for (idx, (_, col_type)) in sorted_columns.iter().enumerate() {
-        let col_order = col_type.column_pagination_order();
-        let is_first_to_collect = match order {
-            Order::Asc => col_order >= after_key_column_order,
-            Order::Desc => col_order <= after_key_column_order,
-        };
-        if is_first_to_collect {
-            return Ok(idx);
-        }
-    }
-    // All columns are before the after_key, nothing left to collect
-    Ok(sorted_columns.len())
-}
-
-fn precompute_missing_after_key(
-    is_after_key_explicit_missing: bool,
-    missing_order: MissingOrder,
-    order: Order,
-) -> PrecomputedAfterKey {
-    let after_last = PrecomputedAfterKey::AfterLast;
-    let before_first = PrecomputedAfterKey::Next(0);
-    match (is_after_key_explicit_missing, missing_order, order) {
-        (true, MissingOrder::First, Order::Asc) => before_first,
-        (true, MissingOrder::First, Order::Desc) => after_last,
-        (true, MissingOrder::Last, Order::Asc) => after_last,
-        (true, MissingOrder::Last, Order::Desc) => before_first,
-        (true, MissingOrder::Default, Order::Asc) => before_first,
-        (true, MissingOrder::Default, Order::Desc) => after_last,
-        (false, _, Order::Asc) => before_first,
-        (false, _, Order::Desc) => after_last,
-    }
-}
-
-/// A parsed representation of the date interval for date histogram sources
-#[derive(Clone, Copy, Debug)]
-pub enum PrecomputedDateInterval {
-    /// This is not a date histogram source
-    NotApplicable,
-    /// Source was configured with a fixed interval
-    FixedNanoseconds(i64),
-    /// Source was configured with a calendar interval
-    Calendar(CalendarInterval),
-}
-
-impl PrecomputedDateInterval {
-    /// Validates the date histogram source interval fields and parses a date interval from them.
-    pub fn from_date_histogram_source_intervals(
-        fixed_interval: &Option<String>,
-        calendar_interval: Option<CalendarInterval>,
-    ) -> crate::Result<Self> {
-        match (fixed_interval, calendar_interval) {
-            (Some(_), Some(_)) | (None, None) => Err(TantivyError::InvalidArgument(
-                "date histogram source must one and only one of fixed_interval or \
-                 calendar_interval set"
-                    .to_string(),
-            )),
-            (Some(fixed_interval), None) => {
-                let fixed_interval_ms = parse_into_milliseconds(fixed_interval)?;
-                Ok(PrecomputedDateInterval::FixedNanoseconds(
-                    fixed_interval_ms * 1_000_000,
-                ))
-            }
-            (None, Some(calendar_interval)) => {
-                Ok(PrecomputedDateInterval::Calendar(calendar_interval))
-            }
-        }
-    }
-}
-
-/// The after key projected to the u64 column space
-///
-/// Some column types (term, IP) might not have an exact representation of the
-/// specified after key
-#[derive(Debug)]
-pub enum PrecomputedAfterKey {
-    /// The after key could be exactly represented in the column space.
-    Exact(u64),
-    /// The after key could not be exactly represented exactly represented, so
-    /// this is the next closest one.
-    Next(u64),
-    /// The after key could not be represented in the column space, it is
-    /// greater than all value
-    AfterLast,
-}
-
-impl From<CompactHit> for PrecomputedAfterKey {
-    fn from(hit: CompactHit) -> Self {
-        match hit {
-            CompactHit::Exact(ord) => PrecomputedAfterKey::Exact(ord as u64),
-            CompactHit::Next(ord) => PrecomputedAfterKey::Next(ord as u64),
-            CompactHit::AfterLast => PrecomputedAfterKey::AfterLast,
-        }
-    }
-}
-
-impl From<TermOrdHit> for PrecomputedAfterKey {
-    fn from(hit: TermOrdHit) -> Self {
-        match hit {
-            TermOrdHit::Exact(ord) => PrecomputedAfterKey::Exact(ord),
-            // TermOrdHit represents AfterLast as Next(u64::MAX), we keep it as is
-            TermOrdHit::Next(ord) => PrecomputedAfterKey::Next(ord),
-        }
-    }
-}
-
-impl<T: MonotonicallyMappableToU64> From<ProjectedNumber<T>> for PrecomputedAfterKey {
-    fn from(num: ProjectedNumber<T>) -> Self {
-        match num {
-            ProjectedNumber::Exact(number) => PrecomputedAfterKey::Exact(number.to_u64()),
-            ProjectedNumber::Next(number) => PrecomputedAfterKey::Next(number.to_u64()),
-            ProjectedNumber::AfterLast => PrecomputedAfterKey::AfterLast,
-        }
-    }
-}
-
-// /!\ These operators only makes sense if both values are in the same column space
-impl PrecomputedAfterKey {
-    pub fn equals(&self, column_value: u64) -> bool {
-        match self {
-            PrecomputedAfterKey::Exact(v) => *v == column_value,
-            PrecomputedAfterKey::Next(_) => false,
-            PrecomputedAfterKey::AfterLast => false,
-        }
-    }
-
-    pub fn gt(&self, column_value: u64) -> bool {
-        match self {
-            PrecomputedAfterKey::Exact(v) => *v > column_value,
-            PrecomputedAfterKey::Next(v) => *v > column_value,
-            PrecomputedAfterKey::AfterLast => true,
-        }
-    }
-
-    pub fn lt(&self, column_value: u64) -> bool {
-        match self {
-            PrecomputedAfterKey::Exact(v) => *v < column_value,
-            // a value equal to the next is greater than the after key
-            PrecomputedAfterKey::Next(v) => *v <= column_value,
-            PrecomputedAfterKey::AfterLast => false,
-        }
-    }
-
-    fn precompute_ip_addr(column: &Column<u64>, key: &Ipv6Addr) -> crate::Result<Self> {
-        let compact_space_accessor = column
-            .values
-            .clone()
-            .downcast_arc::<CompactSpaceU64Accessor>()
-            .map_err(|_| {
-                TantivyError::AggregationError(crate::aggregation::AggregationError::InternalError(
-                    "type mismatch: could not downcast to CompactSpaceU64Accessor".to_string(),
-                ))
-            })?;
-        let ip_u128 = key.to_bits();
-        let ip_next_compact = compact_space_accessor.u128_to_next_compact(ip_u128);
-        Ok(ip_next_compact.into())
-    }
-
-    fn precompute_term_ord(
-        str_dict_column: &Option<StrColumn>,
-        key: &str,
-        field: &str,
-    ) -> crate::Result<Self> {
-        let dict = str_dict_column
-            .as_ref()
-            .expect("dictionary missing for str accessor")
-            .dictionary();
-        let next_ord = dict.term_ord_or_next(key).map_err(|_| {
-            TantivyError::InvalidArgument(format!(
-                "failed to lookup after_key '{}' for field '{}'",
-                key, field
-            ))
-        })?;
-        Ok(next_ord.into())
-    }
-
-    /// Projects the after key into the column space of the given accessor.
-    ///
-    /// The computed after key will not take care of skipping entire columns
-    /// when the after key type is ordered after the accessor's type, that
-    /// should be performed earlier.
-    pub fn precompute(
-        composite_accessor: &CompositeAccessor,
-        source_after_key: &CompositeIntermediateKey,
-        field: &str,
-        missing_order: MissingOrder,
-        order: Order,
-    ) -> crate::Result<Self> {
-        use CompositeIntermediateKey as CIKey;
-        let precomputed_key = match (composite_accessor.column_type, source_after_key) {
-            (ColumnType::Bytes, _) => panic!("unsupported"),
-            // null after key
-            (_, CIKey::Null) => precompute_missing_after_key(false, missing_order, order),
-            // numerical
-            (ColumnType::I64, CIKey::I64(k)) => PrecomputedAfterKey::Exact(k.to_u64()),
-            (ColumnType::I64, CIKey::U64(k)) => num_proj::u64_to_i64(*k).into(),
-            (ColumnType::I64, CIKey::F64(k)) => num_proj::f64_to_i64(*k).into(),
-            (ColumnType::U64, CIKey::I64(k)) => num_proj::i64_to_u64(*k).into(),
-            (ColumnType::U64, CIKey::U64(k)) => PrecomputedAfterKey::Exact(*k),
-            (ColumnType::U64, CIKey::F64(k)) => num_proj::f64_to_u64(*k).into(),
-            (ColumnType::F64, CIKey::I64(k)) => num_proj::i64_to_f64(*k).into(),
-            (ColumnType::F64, CIKey::U64(k)) => num_proj::u64_to_f64(*k).into(),
-            (ColumnType::F64, CIKey::F64(k)) => PrecomputedAfterKey::Exact(k.to_u64()),
-            // boolean
-            (ColumnType::Bool, CIKey::Bool(key)) => PrecomputedAfterKey::Exact(key.to_u64()),
-            // string
-            (ColumnType::Str, CIKey::Str(key)) => PrecomputedAfterKey::precompute_term_ord(
-                &composite_accessor.str_dict_column,
-                key,
-                field,
-            )?,
-            // date time
-            (ColumnType::DateTime, CIKey::DateTime(key)) => {
-                PrecomputedAfterKey::Exact(key.to_u64())
-            }
-            // ip address
-            (ColumnType::IpAddr, CIKey::IpAddr(key)) => {
-                PrecomputedAfterKey::precompute_ip_addr(&composite_accessor.column, key)?
-            }
-            // assume the column's type is ordered after the after_key's type
-            _ => PrecomputedAfterKey::keep_all(order),
-        };
-        Ok(precomputed_key)
-    }
-
-    fn keep_all(order: Order) -> Self {
-        match order {
-            Order::Asc => PrecomputedAfterKey::Next(0),
-            Order::Desc => PrecomputedAfterKey::Next(u64::MAX),
-        }
-    }
-}

src/aggregation/bucket/composite/calendar_interval.rs

@@ -1,136 +0,0 @@
-use time::convert::{Day, Nanosecond};
-use time::{Time, UtcDateTime};
-
-const NS_IN_DAY: i64 = Nanosecond::per_t::<i128>(Day) as i64;
-
-/// Computes the timestamp in nanoseconds corresponding to the beginning of the
-/// year (January 1st at midnight UTC).
-pub(super) fn try_year_bucket(timestamp_ns: i64) -> crate::Result<i64> {
-    year_bucket_using_time_crate(timestamp_ns).map_err(|e| {
-        crate::TantivyError::InvalidArgument(format!(
-            "Failed to compute year bucket for timestamp {}: {e}",
-            timestamp_ns
-        ))
-    })
-}
-
-/// Computes the timestamp in nanoseconds corresponding to the beginning of the
-/// month (1st at midnight UTC).
-pub(super) fn try_month_bucket(timestamp_ns: i64) -> crate::Result<i64> {
-    month_bucket_using_time_crate(timestamp_ns).map_err(|e| {
-        crate::TantivyError::InvalidArgument(format!(
-            "Failed to compute month bucket for timestamp {}: {e}",
-            timestamp_ns
-        ))
-    })
-}
-
-/// Computes the timestamp in nanoseconds corresponding to the beginning of the
-/// week (Monday at midnight UTC).
-pub(super) fn week_bucket(timestamp_ns: i64) -> i64 {
-    // 1970-01-01 was a Thursday (weekday = 4)
-    let days_since_epoch = timestamp_ns.div_euclid(NS_IN_DAY);
-    // Find the weekday: 0=Monday, ..., 6=Sunday
-    let weekday = (days_since_epoch + 3).rem_euclid(7);
-    let monday_days_since_epoch = days_since_epoch - weekday;
-    monday_days_since_epoch * NS_IN_DAY
-}
-
-fn year_bucket_using_time_crate(timestamp_ns: i64) -> Result<i64, time::Error> {
-    let timestamp_ns = UtcDateTime::from_unix_timestamp_nanos(timestamp_ns as i128)?
-        .replace_ordinal(1)?
-        .replace_time(Time::MIDNIGHT)
-        .unix_timestamp_nanos();
-    Ok(timestamp_ns as i64)
-}
-
-fn month_bucket_using_time_crate(timestamp_ns: i64) -> Result<i64, time::Error> {
-    let timestamp_ns = UtcDateTime::from_unix_timestamp_nanos(timestamp_ns as i128)?
-        .replace_day(1)?
-        .replace_time(Time::MIDNIGHT)
-        .unix_timestamp_nanos();
-    Ok(timestamp_ns as i64)
-}
-
-#[cfg(test)]
-mod tests {
-    use time::format_description::well_known::Iso8601;
-    use time::UtcDateTime;
-
-    use super::*;
-
-    fn ts_ns(iso: &str) -> i64 {
-        UtcDateTime::parse(iso, &Iso8601::DEFAULT)
-            .unwrap()
-            .unix_timestamp_nanos() as i64
-    }
-
-    #[test]
-    fn test_year_bucket() {
-        let ts = ts_ns("1970-01-01T00:00:00Z");
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("1970-01-01T00:00:00Z"));
-
-        let ts = ts_ns("1970-06-01T10:00:01.010Z");
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("1970-01-01T00:00:00Z"));
-
-        let ts = ts_ns("2008-12-31T23:59:59.999999999Z"); // leap year
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("2008-01-01T00:00:00Z"));
-
-        let ts = ts_ns("2008-01-01T00:00:00Z"); // leap year
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("2008-01-01T00:00:00Z"));
-
-        let ts = ts_ns("2010-12-31T23:59:59.999999999Z");
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("2010-01-01T00:00:00Z"));
-
-        let ts = ts_ns("1972-06-01T00:10:00Z");
-        let res = try_year_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("1972-01-01T00:00:00Z"));
-    }
-
-    #[test]
-    fn test_month_bucket() {
-        let ts = ts_ns("1970-01-15T00:00:00Z");
-        let res = try_month_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("1970-01-01T00:00:00Z"));
-
-        let ts = ts_ns("1970-02-01T00:00:00Z");
-        let res = try_month_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("1970-02-01T00:00:00Z"));
-
-        let ts = ts_ns("2000-01-31T23:59:59.999999999Z");
-        let res = try_month_bucket(ts).unwrap();
-        assert_eq!(res, ts_ns("2000-01-01T00:00:00Z"));
-    }
-
-    #[test]
-    fn test_week_bucket() {
-        let ts = ts_ns("1970-01-05T00:00:00Z"); // Monday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("1970-01-05T00:00:00Z"));
-
-        let ts = ts_ns("1970-01-05T23:59:59Z"); // Monday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("1970-01-05T00:00:00Z"));
-
-        let ts = ts_ns("1970-01-07T01:13:00Z"); // Wednesday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("1970-01-05T00:00:00Z"));
-
-        let ts = ts_ns("1970-01-11T23:59:59.999999999Z"); // Sunday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("1970-01-05T00:00:00Z"));
-
-        let ts = ts_ns("2025-10-16T10:41:59.010Z"); // Thursday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("2025-10-13T00:00:00Z"));
-
-        let ts = ts_ns("1970-01-01T00:00:00Z"); // Thursday
-        let res = week_bucket(ts);
-        assert_eq!(res, ts_ns("1969-12-29T00:00:00Z")); // Negative
-    }
-}

src/aggregation/bucket/composite/collector.rs

@@ -1,660 +0,0 @@
-use std::fmt::Debug;
-use std::mem;
-use std::net::Ipv6Addr;
-
-use columnar::column_values::CompactSpaceU64Accessor;
-use columnar::{
-    Column, ColumnType, Dictionary, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
-    NumericalValue, StrColumn,
-};
-use rustc_hash::FxHashMap;
-use smallvec::SmallVec;
-
-use crate::aggregation::agg_data::{
-    build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
-};
-use crate::aggregation::bucket::composite::accessors::{
-    CompositeAccessor, CompositeAggReqData, PrecomputedDateInterval,
-};
-use crate::aggregation::bucket::composite::calendar_interval;
-use crate::aggregation::bucket::composite::map::{DynArrayHeapMap, MAX_DYN_ARRAY_SIZE};
-use crate::aggregation::bucket::{
-    CalendarInterval, CompositeAggregationSource, MissingOrder, Order,
-};
-use crate::aggregation::buffered_sub_aggs::{BufferedSubAggs, HighCardSubAggBuffer};
-use crate::aggregation::intermediate_agg_result::{
-    CompositeIntermediateKey, IntermediateAggregationResult, IntermediateAggregationResults,
-    IntermediateBucketResult, IntermediateCompositeBucketEntry, IntermediateCompositeBucketResult,
-};
-use crate::aggregation::segment_agg_result::{BucketIdProvider, SegmentAggregationCollector};
-use crate::aggregation::BucketId;
-use crate::TantivyError;
-
-#[derive(Clone, Debug)]
-struct CompositeBucketCollector {
-    count: u32,
-    bucket_id: BucketId,
-}
-
-/// Compact sortable representation of a single source value within a composite key.
-///
-/// The struct encodes both the column identity and the fast field value in a way
-/// that preserves the desired sort order via the derived `Ord` implementation
-/// (fields are compared top-to-bottom: `sort_key` first, then `encoded_value`).
-///
-/// ## `sort_key` encoding
-/// - `0` — missing value, sorted first
-/// - `1..=254` — present value; the original accessor index is `sort_key - 1`
-/// - `u8::MAX` (255) — missing value, sorted last
-///
-/// ## `encoded_value` encoding
-/// - `0` when the field is missing
-/// - The raw u64 fast-field representation when order is ascending
-/// - Bitwise NOT of the raw u64 when order is descending
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
-struct InternalValueRepr {
-    /// Column index biased by +1 (so 0 and u8::MAX are reserved for missing sentinels).
-    sort_key: u8,
-    /// Fast field value, possibly bit-flipped for descending order.
-    encoded_value: u64,
-}
-
-impl InternalValueRepr {
-    #[inline]
-    fn new_term(raw: u64, accessor_idx: u8, order: Order) -> Self {
-        let encoded_value = match order {
-            Order::Asc => raw,
-            Order::Desc => !raw,
-        };
-        InternalValueRepr {
-            sort_key: accessor_idx + 1,
-            encoded_value,
-        }
-    }
-
-    /// For histogram sources the column index is irrelevant (always 1).
-    #[inline]
-    fn new_histogram(raw: u64, order: Order) -> Self {
-        let encoded_value = match order {
-            Order::Asc => raw,
-            Order::Desc => !raw,
-        };
-        InternalValueRepr {
-            sort_key: 1,
-            encoded_value,
-        }
-    }
-
-    #[inline]
-    fn new_missing(order: Order, missing_order: MissingOrder) -> Self {
-        let sort_key = match (missing_order, order) {
-            (MissingOrder::First, _) | (MissingOrder::Default, Order::Asc) => 0,
-            (MissingOrder::Last, _) | (MissingOrder::Default, Order::Desc) => u8::MAX,
-        };
-        InternalValueRepr {
-            sort_key,
-            encoded_value: 0,
-        }
-    }
-
-    /// Decode back to `(accessor_idx, raw_value)`.
-    /// Returns `None` when the value represents a missing field.
-    #[inline]
-    fn decode(self, order: Order) -> Option<(u8, u64)> {
-        if self.sort_key == 0 || self.sort_key == u8::MAX {
-            return None;
-        }
-        let raw = match order {
-            Order::Asc => self.encoded_value,
-            Order::Desc => !self.encoded_value,
-        };
-        Some((self.sort_key - 1, raw))
-    }
-}
-
-/// The collector puts values from the fast field into the correct buckets and
-/// does a conversion to the correct datatype.
-#[derive(Debug)]
-pub struct SegmentCompositeCollector {
-    /// One DynArrayHeapMap per parent bucket.
-    parent_buckets: Vec<DynArrayHeapMap<InternalValueRepr, CompositeBucketCollector>>,
-    accessor_idx: usize,
-    sub_agg: Option<BufferedSubAggs<HighCardSubAggBuffer>>,
-    bucket_id_provider: BucketIdProvider,
-    /// Number of sources, needed when creating new DynArrayHeapMaps.
-    num_sources: usize,
-}
-
-impl SegmentAggregationCollector for SegmentCompositeCollector {
-    fn add_intermediate_aggregation_result(
-        &mut self,
-        agg_data: &AggregationsSegmentCtx,
-        results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
-    ) -> crate::Result<()> {
-        let name = agg_data
-            .get_composite_req_data(self.accessor_idx)
-            .name
-            .clone();
-
-        let buckets = self.add_intermediate_bucket_result(agg_data, parent_bucket_id)?;
-        results.push(
-            name,
-            IntermediateAggregationResult::Bucket(IntermediateBucketResult::Composite { buckets }),
-        )?;
-
-        Ok(())
-    }
-
-    fn collect(
-        &mut self,
-        parent_bucket_id: BucketId,
-        docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        let mem_pre = self.get_memory_consumption(parent_bucket_id);
-        let composite_agg_data = agg_data.take_composite_req_data(self.accessor_idx);
-
-        for doc in docs {
-            let mut visitor = CompositeKeyVisitor {
-                doc_id: *doc,
-                composite_agg_data: &composite_agg_data,
-                buckets: &mut self.parent_buckets[parent_bucket_id as usize],
-                sub_agg: &mut self.sub_agg,
-                bucket_id_provider: &mut self.bucket_id_provider,
-                sub_level_values: SmallVec::new(),
-            };
-            visitor.visit(0, true)?;
-        }
-        agg_data.put_back_composite_req_data(self.accessor_idx, composite_agg_data);
-
-        if let Some(sub_agg) = &mut self.sub_agg {
-            sub_agg.check_flush_local(agg_data)?;
-        }
-
-        let mem_delta = self.get_memory_consumption(parent_bucket_id) - mem_pre;
-        if mem_delta > 0 {
-            agg_data.context.limits.add_memory_consumed(mem_delta)?;
-        }
-
-        Ok(())
-    }
-
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        if let Some(sub_agg) = &mut self.sub_agg {
-            sub_agg.flush(agg_data)?;
-        }
-        Ok(())
-    }
-
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        let required_len = max_bucket as usize + 1;
-        while self.parent_buckets.len() < required_len {
-            let map = DynArrayHeapMap::try_new(self.num_sources)?;
-            self.parent_buckets.push(map);
-        }
-        Ok(())
-    }
-
-    fn compute_metric_value(
-        &self,
-        _bucket_id: BucketId,
-        _sub_agg_name: &str,
-        _sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        // Composite is a multi-bucket agg with no single value to extract.
-        None
-    }
-}
-
-impl SegmentCompositeCollector {
-    fn get_memory_consumption(&self, parent_bucket_id: BucketId) -> u64 {
-        self.parent_buckets[parent_bucket_id as usize].memory_consumption()
-    }
-
-    pub(crate) fn from_req_and_validate(
-        req_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
-    ) -> crate::Result<Self> {
-        validate_req(req_data, node.idx_in_req_data)?;
-
-        let has_sub_aggregations = !node.children.is_empty();
-        let sub_agg = if has_sub_aggregations {
-            let sub_agg_collector = build_segment_agg_collectors(req_data, &node.children)?;
-            Some(BufferedSubAggs::new(sub_agg_collector))
-        } else {
-            None
-        };
-
-        let composite_req_data = req_data.get_composite_req_data(node.idx_in_req_data);
-        let num_sources = composite_req_data.req.sources.len();
-
-        Ok(SegmentCompositeCollector {
-            parent_buckets: vec![DynArrayHeapMap::try_new(num_sources)?],
-            accessor_idx: node.idx_in_req_data,
-            sub_agg,
-            bucket_id_provider: BucketIdProvider::default(),
-            num_sources,
-        })
-    }
-
-    #[inline]
-    fn add_intermediate_bucket_result(
-        &mut self,
-        agg_data: &AggregationsSegmentCtx,
-        parent_bucket_id: BucketId,
-    ) -> crate::Result<IntermediateCompositeBucketResult> {
-        let empty_map = DynArrayHeapMap::try_new(self.num_sources)?;
-        let heap_map = mem::replace(
-            &mut self.parent_buckets[parent_bucket_id as usize],
-            empty_map,
-        );
-
-        let mut dict: FxHashMap<Vec<CompositeIntermediateKey>, IntermediateCompositeBucketEntry> =
-            Default::default();
-        dict.reserve(heap_map.size());
-        let composite_data = agg_data.get_composite_req_data(self.accessor_idx);
-        for (key_internal_repr, agg) in heap_map.into_iter() {
-            let key = resolve_key(&key_internal_repr, composite_data)?;
-            let mut sub_aggregation_res = IntermediateAggregationResults::default();
-            if let Some(sub_agg) = &mut self.sub_agg {
-                sub_agg
-                    .get_sub_agg_collector()
-                    .add_intermediate_aggregation_result(
-                        agg_data,
-                        &mut sub_aggregation_res,
-                        agg.bucket_id,
-                    )?;
-            }
-
-            dict.insert(
-                key,
-                IntermediateCompositeBucketEntry {
-                    doc_count: agg.count,
-                    sub_aggregation: sub_aggregation_res,
-                },
-            );
-        }
-
-        Ok(IntermediateCompositeBucketResult {
-            entries: dict,
-            target_size: composite_data.req.size,
-            orders: composite_data
-                .req
-                .sources
-                .iter()
-                .map(|source| match source {
-                    CompositeAggregationSource::Terms(t) => (t.order, t.missing_order),
-                    CompositeAggregationSource::Histogram(h) => (h.order, h.missing_order),
-                    CompositeAggregationSource::DateHistogram(d) => (d.order, d.missing_order),
-                })
-                .collect(),
-        })
-    }
-}
-
-fn validate_req(req_data: &mut AggregationsSegmentCtx, accessor_idx: usize) -> crate::Result<()> {
-    let composite_data = req_data.get_composite_req_data(accessor_idx);
-    let req = &composite_data.req;
-    if req.sources.is_empty() {
-        return Err(TantivyError::InvalidArgument(
-            "composite aggregation must have at least one source".to_string(),
-        ));
-    }
-    if req.size == 0 {
-        return Err(TantivyError::InvalidArgument(
-            "composite aggregation 'size' must be > 0".to_string(),
-        ));
-    }
-
-    if composite_data.composite_accessors.len() > MAX_DYN_ARRAY_SIZE {
-        return Err(TantivyError::InvalidArgument(format!(
-            "composite aggregation source supports maximum {MAX_DYN_ARRAY_SIZE} sources",
-        )));
-    }
-
-    let column_types_for_sources = composite_data.composite_accessors.iter().map(|item| {
-        item.accessors
-            .iter()
-            .map(|a| a.column_type)
-            .collect::<Vec<_>>()
-    });
-
-    for column_types in column_types_for_sources {
-        if column_types.contains(&ColumnType::Bytes) {
-            return Err(TantivyError::InvalidArgument(
-                "composite aggregation does not support 'bytes' field type".to_string(),
-            ));
-        }
-    }
-    Ok(())
-}
-
-fn collect_bucket_with_limit(
-    doc_id: crate::DocId,
-    limit_num_buckets: usize,
-    buckets: &mut DynArrayHeapMap<InternalValueRepr, CompositeBucketCollector>,
-    key: &[InternalValueRepr],
-    sub_agg: &mut Option<BufferedSubAggs<HighCardSubAggBuffer>>,
-    bucket_id_provider: &mut BucketIdProvider,
-) {
-    let mut record_in_bucket = |bucket: &mut CompositeBucketCollector| {
-        bucket.count += 1;
-        if let Some(sub_agg) = sub_agg {
-            sub_agg.push(bucket.bucket_id, doc_id);
-        }
-    };
-
-    // We still have room for buckets, just insert
-    if buckets.size() < limit_num_buckets {
-        let bucket = buckets.get_or_insert_with(key, || CompositeBucketCollector {
-            count: 0,
-            bucket_id: bucket_id_provider.next_bucket_id(),
-        });
-        record_in_bucket(bucket);
-        return;
-    }
-
-    // Map is full, but we can still update the bucket if it already exists
-    if let Some(bucket) = buckets.get_mut(key) {
-        record_in_bucket(bucket);
-        return;
-    }
-
-    // Check if the item qualifies to enter the top-k, and evict the highest if it does
-    if let Some(highest_key) = buckets.peek_highest() {
-        if key < highest_key {
-            buckets.evict_highest();
-            let bucket = buckets.get_or_insert_with(key, || CompositeBucketCollector {
-                count: 0,
-                bucket_id: bucket_id_provider.next_bucket_id(),
-            });
-            record_in_bucket(bucket);
-        }
-    }
-}
-
-/// Converts the composite key from its internal column space representation
-/// (segment specific) into its intermediate form.
-fn resolve_key(
-    internal_key: &[InternalValueRepr],
-    agg_data: &CompositeAggReqData,
-) -> crate::Result<Vec<CompositeIntermediateKey>> {
-    internal_key
-        .iter()
-        .enumerate()
-        .map(|(idx, val)| {
-            resolve_internal_value_repr(
-                *val,
-                &agg_data.req.sources[idx],
-                &agg_data.composite_accessors[idx].accessors,
-            )
-        })
-        .collect()
-}
-
-fn resolve_internal_value_repr(
-    internal_value_repr: InternalValueRepr,
-    source: &CompositeAggregationSource,
-    composite_accessors: &[CompositeAccessor],
-) -> crate::Result<CompositeIntermediateKey> {
-    let decoded_value_opt = match source {
-        CompositeAggregationSource::Terms(source) => internal_value_repr.decode(source.order),
-        CompositeAggregationSource::Histogram(source) => internal_value_repr.decode(source.order),
-        CompositeAggregationSource::DateHistogram(source) => {
-            internal_value_repr.decode(source.order)
-        }
-    };
-    let Some((decoded_accessor_idx, val)) = decoded_value_opt else {
-        return Ok(CompositeIntermediateKey::Null);
-    };
-    let key = match source {
-        CompositeAggregationSource::Terms(_) => {
-            let CompositeAccessor {
-                column_type,
-                str_dict_column,
-                column,
-                ..
-            } = &composite_accessors[decoded_accessor_idx as usize];
-            resolve_term(val, column_type, str_dict_column, column)?
-        }
-        CompositeAggregationSource::Histogram(source) => {
-            CompositeIntermediateKey::F64(i64::from_u64(val) as f64 * source.interval)
-        }
-        CompositeAggregationSource::DateHistogram(_) => {
-            CompositeIntermediateKey::DateTime(i64::from_u64(val))
-        }
-    };
-
-    Ok(key)
-}
-
-fn resolve_term(
-    val: u64,
-    column_type: &ColumnType,
-    str_dict_column: &Option<StrColumn>,
-    column: &Column,
-) -> crate::Result<CompositeIntermediateKey> {
-    let key = if *column_type == ColumnType::Str {
-        let fallback_dict = Dictionary::empty();
-        let term_dict = str_dict_column
-            .as_ref()
-            .map(|el| el.dictionary())
-            .unwrap_or_else(|| &fallback_dict);
-
-        let mut buffer = Vec::new();
-        term_dict.ord_to_term(val, &mut buffer)?;
-        CompositeIntermediateKey::Str(
-            String::from_utf8(buffer.to_vec()).expect("could not convert to String"),
-        )
-    } else if *column_type == ColumnType::DateTime {
-        let val = i64::from_u64(val);
-        CompositeIntermediateKey::DateTime(val)
-    } else if *column_type == ColumnType::Bool {
-        let val = bool::from_u64(val);
-        CompositeIntermediateKey::Bool(val)
-    } else if *column_type == ColumnType::IpAddr {
-        let compact_space_accessor = column
-            .values
-            .clone()
-            .downcast_arc::<CompactSpaceU64Accessor>()
-            .map_err(|_| {
-                TantivyError::AggregationError(crate::aggregation::AggregationError::InternalError(
-                    "Type mismatch: Could not downcast to CompactSpaceU64Accessor".to_string(),
-                ))
-            })?;
-        let val: u128 = compact_space_accessor.compact_to_u128(val as u32);
-        let val = Ipv6Addr::from_u128(val);
-        CompositeIntermediateKey::IpAddr(val)
-    } else if *column_type == ColumnType::U64 {
-        CompositeIntermediateKey::U64(val)
-    } else if *column_type == ColumnType::I64 {
-        CompositeIntermediateKey::I64(i64::from_u64(val))
-    } else {
-        let val = f64::from_u64(val);
-        let val: NumericalValue = val.into();
-
-        match val.normalize() {
-            NumericalValue::U64(val) => CompositeIntermediateKey::U64(val),
-            NumericalValue::I64(val) => CompositeIntermediateKey::I64(val),
-            NumericalValue::F64(val) => CompositeIntermediateKey::F64(val),
-        }
-    };
-    Ok(key)
-}
-
-/// Browse through the cardinal product obtained by the different values of the doc composite key
-/// sources.
-///
-/// For each of those tuple-key, that are after the limit key, we call collect_bucket_with_limit.
-struct CompositeKeyVisitor<'a> {
-    doc_id: crate::DocId,
-    composite_agg_data: &'a CompositeAggReqData,
-    buckets: &'a mut DynArrayHeapMap<InternalValueRepr, CompositeBucketCollector>,
-    sub_agg: &'a mut Option<BufferedSubAggs<HighCardSubAggBuffer>>,
-    bucket_id_provider: &'a mut BucketIdProvider,
-    sub_level_values: SmallVec<[InternalValueRepr; MAX_DYN_ARRAY_SIZE]>,
-}
-
-impl CompositeKeyVisitor<'_> {
-    /// Depth-first walk of the accessors to build the composite key combinations
-    /// and update the buckets.
-    ///
-    /// `source_idx` is the current source index in the recursion.
-    /// `is_on_after_key` tracks whether we still need to consider the after_key
-    /// for pruning at this level and below.
-    fn visit(&mut self, source_idx: usize, is_on_after_key: bool) -> crate::Result<()> {
-        if source_idx == self.composite_agg_data.req.sources.len() {
-            if !is_on_after_key {
-                collect_bucket_with_limit(
-                    self.doc_id,
-                    self.composite_agg_data.req.size as usize,
-                    self.buckets,
-                    &self.sub_level_values,
-                    self.sub_agg,
-                    self.bucket_id_provider,
-                );
-            }
-            return Ok(());
-        }
-
-        let current_level_accessors = &self.composite_agg_data.composite_accessors[source_idx];
-        let current_level_source = &self.composite_agg_data.req.sources[source_idx];
-        let mut missing = true;
-        for (accessor_idx, accessor) in current_level_accessors.accessors.iter().enumerate() {
-            let values = accessor.column.values_for_doc(self.doc_id);
-            for value in values {
-                missing = false;
-                match current_level_source {
-                    CompositeAggregationSource::Terms(_) => {
-                        let preceeds_after_key_type =
-                            accessor_idx < current_level_accessors.after_key_accessor_idx;
-                        if is_on_after_key && preceeds_after_key_type {
-                            break;
-                        }
-                        let matches_after_key_type =
-                            accessor_idx == current_level_accessors.after_key_accessor_idx;
-
-                        if matches_after_key_type && is_on_after_key {
-                            let should_skip = match current_level_source.order() {
-                                Order::Asc => current_level_accessors.after_key.gt(value),
-                                Order::Desc => current_level_accessors.after_key.lt(value),
-                            };
-                            if should_skip {
-                                continue;
-                            }
-                        }
-                        self.sub_level_values.push(InternalValueRepr::new_term(
-                            value,
-                            accessor_idx as u8,
-                            current_level_source.order(),
-                        ));
-                        let still_on_after_key = matches_after_key_type
-                            && current_level_accessors.after_key.equals(value);
-                        self.visit(source_idx + 1, is_on_after_key && still_on_after_key)?;
-                        self.sub_level_values.pop();
-                    }
-                    CompositeAggregationSource::Histogram(source) => {
-                        let float_value = match accessor.column_type {
-                            ColumnType::U64 => value as f64,
-                            ColumnType::I64 => i64::from_u64(value) as f64,
-                            ColumnType::DateTime => i64::from_u64(value) as f64 / 1_000_000.,
-                            ColumnType::F64 => f64::from_u64(value),
-                            _ => {
-                                panic!(
-                                    "unexpected type {:?}. This should not happen",
-                                    accessor.column_type
-                                )
-                            }
-                        };
-                        let bucket_index = (float_value / source.interval).floor() as i64;
-                        let bucket_value = i64::to_u64(bucket_index);
-                        if is_on_after_key {
-                            let should_skip = match current_level_source.order() {
-                                Order::Asc => current_level_accessors.after_key.gt(bucket_value),
-                                Order::Desc => current_level_accessors.after_key.lt(bucket_value),
-                            };
-                            if should_skip {
-                                continue;
-                            }
-                        }
-                        self.sub_level_values.push(InternalValueRepr::new_histogram(
-                            bucket_value,
-                            current_level_source.order(),
-                        ));
-                        let still_on_after_key =
-                            current_level_accessors.after_key.equals(bucket_value);
-                        self.visit(source_idx + 1, is_on_after_key && still_on_after_key)?;
-                        self.sub_level_values.pop();
-                    }
-                    CompositeAggregationSource::DateHistogram(_) => {
-                        let value_ns = match accessor.column_type {
-                            ColumnType::DateTime => i64::from_u64(value),
-                            _ => {
-                                panic!(
-                                    "unexpected type {:?}. This should not happen",
-                                    accessor.column_type
-                                )
-                            }
-                        };
-                        let bucket_index = match accessor.date_histogram_interval {
-                            PrecomputedDateInterval::FixedNanoseconds(fixed_interval_ns) => {
-                                (value_ns / fixed_interval_ns) * fixed_interval_ns
-                            }
-                            PrecomputedDateInterval::Calendar(CalendarInterval::Year) => {
-                                calendar_interval::try_year_bucket(value_ns)?
-                            }
-                            PrecomputedDateInterval::Calendar(CalendarInterval::Month) => {
-                                calendar_interval::try_month_bucket(value_ns)?
-                            }
-                            PrecomputedDateInterval::Calendar(CalendarInterval::Week) => {
-                                calendar_interval::week_bucket(value_ns)
-                            }
-                            PrecomputedDateInterval::NotApplicable => {
-                                panic!("interval not precomputed for date histogram source")
-                            }
-                        };
-                        let bucket_value = i64::to_u64(bucket_index);
-                        if is_on_after_key {
-                            let should_skip = match current_level_source.order() {
-                                Order::Asc => current_level_accessors.after_key.gt(bucket_value),
-                                Order::Desc => current_level_accessors.after_key.lt(bucket_value),
-                            };
-                            if should_skip {
-                                continue;
-                            }
-                        }
-                        self.sub_level_values.push(InternalValueRepr::new_histogram(
-                            bucket_value,
-                            current_level_source.order(),
-                        ));
-                        let still_on_after_key =
-                            current_level_accessors.after_key.equals(bucket_value);
-                        self.visit(source_idx + 1, is_on_after_key && still_on_after_key)?;
-                        self.sub_level_values.pop();
-                    }
-                };
-            }
-        }
-        if missing && current_level_source.missing_bucket() {
-            if is_on_after_key && current_level_accessors.skip_missing {
-                return Ok(());
-            }
-            self.sub_level_values.push(InternalValueRepr::new_missing(
-                current_level_source.order(),
-                current_level_source.missing_order(),
-            ));
-            self.visit(
-                source_idx + 1,
-                is_on_after_key && current_level_accessors.is_after_key_explicit_missing,
-            )?;
-            self.sub_level_values.pop();
-        }
-        Ok(())
-    }
-}

src/aggregation/bucket/composite/map.rs

@@ -1,329 +0,0 @@
-use std::collections::BinaryHeap;
-use std::fmt::Debug;
-use std::hash::Hash;
-
-use rustc_hash::FxHashMap;
-use smallvec::SmallVec;
-
-use crate::TantivyError;
-
-/// Map backed by a hash map for fast access and a binary heap to track the
-/// highest key. The key is an array of fixed size S.
-#[derive(Clone, Debug)]
-struct ArrayHeapMap<K: Ord, V, const S: usize> {
-    pub(crate) buckets: FxHashMap<[K; S], V>,
-    pub(crate) heap: BinaryHeap<[K; S]>,
-}
-
-impl<K: Ord, V, const S: usize> Default for ArrayHeapMap<K, V, S> {
-    fn default() -> Self {
-        ArrayHeapMap {
-            buckets: FxHashMap::default(),
-            heap: BinaryHeap::default(),
-        }
-    }
-}
-
-impl<K: Eq + Hash + Clone + Ord, V, const S: usize> ArrayHeapMap<K, V, S> {
-    /// Panics if the length of `key` is not S.
-    fn get_or_insert_with<F: FnOnce() -> V>(&mut self, key: &[K], f: F) -> &mut V {
-        let key_array: &[K; S] = key.try_into().expect("Key length mismatch");
-        self.buckets.entry(key_array.clone()).or_insert_with(|| {
-            self.heap.push(key_array.clone());
-            f()
-        })
-    }
-
-    /// Panics if the length of `key` is not S.
-    fn get_mut(&mut self, key: &[K]) -> Option<&mut V> {
-        let key_array: &[K; S] = key.try_into().expect("Key length mismatch");
-        self.buckets.get_mut(key_array)
-    }
-
-    fn peek_highest(&self) -> Option<&[K]> {
-        self.heap.peek().map(|k_array| k_array.as_slice())
-    }
-
-    fn evict_highest(&mut self) {
-        if let Some(highest) = self.heap.pop() {
-            self.buckets.remove(&highest);
-        }
-    }
-
-    fn memory_consumption(&self) -> u64 {
-        let key_size = std::mem::size_of::<[K; S]>();
-        let map_size = (key_size + std::mem::size_of::<V>()) * self.buckets.capacity();
-        let heap_size = key_size * self.heap.capacity();
-        (map_size + heap_size) as u64
-    }
-}
-
-impl<K: Copy + Ord + Clone + 'static, V: 'static, const S: usize> ArrayHeapMap<K, V, S> {
-    fn into_iter(self) -> Box<dyn Iterator<Item = (SmallVec<[K; MAX_DYN_ARRAY_SIZE]>, V)>> {
-        Box::new(
-            self.buckets
-                .into_iter()
-                .map(|(k, v)| (SmallVec::from_slice(&k), v)),
-        )
-    }
-}
-
-pub(super) const MAX_DYN_ARRAY_SIZE: usize = 16;
-const MAX_DYN_ARRAY_SIZE_PLUS_ONE: usize = MAX_DYN_ARRAY_SIZE + 1;
-
-/// A map optimized for memory footprint, fast access and efficient eviction of
-/// the highest key.
-///
-/// Keys are inlined arrays of size 1 to [MAX_DYN_ARRAY_SIZE] but for a given
-/// instance the key size is fixed. This allows to avoid heap allocations for the
-/// keys.
-#[derive(Clone, Debug)]
-pub(super) struct DynArrayHeapMap<K: Ord, V>(DynArrayHeapMapInner<K, V>);
-
-/// Wrapper around ArrayHeapMap to dynamically dispatch on the array size.
-#[derive(Clone, Debug)]
-enum DynArrayHeapMapInner<K: Ord, V> {
-    Dim1(ArrayHeapMap<K, V, 1>),
-    Dim2(ArrayHeapMap<K, V, 2>),
-    Dim3(ArrayHeapMap<K, V, 3>),
-    Dim4(ArrayHeapMap<K, V, 4>),
-    Dim5(ArrayHeapMap<K, V, 5>),
-    Dim6(ArrayHeapMap<K, V, 6>),
-    Dim7(ArrayHeapMap<K, V, 7>),
-    Dim8(ArrayHeapMap<K, V, 8>),
-    Dim9(ArrayHeapMap<K, V, 9>),
-    Dim10(ArrayHeapMap<K, V, 10>),
-    Dim11(ArrayHeapMap<K, V, 11>),
-    Dim12(ArrayHeapMap<K, V, 12>),
-    Dim13(ArrayHeapMap<K, V, 13>),
-    Dim14(ArrayHeapMap<K, V, 14>),
-    Dim15(ArrayHeapMap<K, V, 15>),
-    Dim16(ArrayHeapMap<K, V, 16>),
-}
-
-impl<K: Ord, V> DynArrayHeapMap<K, V> {
-    /// Creates a new heap map with dynamic array keys of size `key_dimension`.
-    pub(super) fn try_new(key_dimension: usize) -> crate::Result<Self> {
-        let inner = match key_dimension {
-            0 => {
-                return Err(TantivyError::InvalidArgument(
-                    "DynArrayHeapMap dimension must be at least 1".to_string(),
-                ))
-            }
-            1 => DynArrayHeapMapInner::Dim1(ArrayHeapMap::default()),
-            2 => DynArrayHeapMapInner::Dim2(ArrayHeapMap::default()),
-            3 => DynArrayHeapMapInner::Dim3(ArrayHeapMap::default()),
-            4 => DynArrayHeapMapInner::Dim4(ArrayHeapMap::default()),
-            5 => DynArrayHeapMapInner::Dim5(ArrayHeapMap::default()),
-            6 => DynArrayHeapMapInner::Dim6(ArrayHeapMap::default()),
-            7 => DynArrayHeapMapInner::Dim7(ArrayHeapMap::default()),
-            8 => DynArrayHeapMapInner::Dim8(ArrayHeapMap::default()),
-            9 => DynArrayHeapMapInner::Dim9(ArrayHeapMap::default()),
-            10 => DynArrayHeapMapInner::Dim10(ArrayHeapMap::default()),
-            11 => DynArrayHeapMapInner::Dim11(ArrayHeapMap::default()),
-            12 => DynArrayHeapMapInner::Dim12(ArrayHeapMap::default()),
-            13 => DynArrayHeapMapInner::Dim13(ArrayHeapMap::default()),
-            14 => DynArrayHeapMapInner::Dim14(ArrayHeapMap::default()),
-            15 => DynArrayHeapMapInner::Dim15(ArrayHeapMap::default()),
-            16 => DynArrayHeapMapInner::Dim16(ArrayHeapMap::default()),
-            MAX_DYN_ARRAY_SIZE_PLUS_ONE.. => {
-                return Err(TantivyError::InvalidArgument(format!(
-                    "DynArrayHeapMap supports maximum {MAX_DYN_ARRAY_SIZE} dimensions, got \
-                     {key_dimension}",
-                )))
-            }
-        };
-        Ok(DynArrayHeapMap(inner))
-    }
-
-    /// Number of elements in the map. This is not the dimension of the keys.
-    pub(super) fn size(&self) -> usize {
-        match &self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim2(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim3(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim4(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim5(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim6(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim7(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim8(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim9(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim10(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim11(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim12(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim13(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim14(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim15(map) => map.buckets.len(),
-            DynArrayHeapMapInner::Dim16(map) => map.buckets.len(),
-        }
-    }
-}
-
-impl<K: Ord + Hash + Clone, V> DynArrayHeapMap<K, V> {
-    /// Get a mutable reference to the value corresponding to `key` or inserts a new
-    /// value created by calling `f`.
-    ///
-    /// Panics if the length of `key` does not match the key dimension of the map.
-    pub(super) fn get_or_insert_with<F: FnOnce() -> V>(&mut self, key: &[K], f: F) -> &mut V {
-        match &mut self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim2(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim3(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim4(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim5(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim6(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim7(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim8(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim9(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim10(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim11(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim12(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim13(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim14(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim15(map) => map.get_or_insert_with(key, f),
-            DynArrayHeapMapInner::Dim16(map) => map.get_or_insert_with(key, f),
-        }
-    }
-
-    /// Returns a mutable reference to the value corresponding to `key`.
-    ///
-    /// Panics if the length of `key` does not match the key dimension of the map.
-    pub fn get_mut(&mut self, key: &[K]) -> Option<&mut V> {
-        match &mut self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim2(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim3(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim4(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim5(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim6(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim7(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim8(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim9(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim10(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim11(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim12(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim13(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim14(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim15(map) => map.get_mut(key),
-            DynArrayHeapMapInner::Dim16(map) => map.get_mut(key),
-        }
-    }
-
-    /// Returns a reference to the highest key in the map.
-    pub(super) fn peek_highest(&self) -> Option<&[K]> {
-        match &self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim2(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim3(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim4(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim5(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim6(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim7(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim8(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim9(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim10(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim11(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim12(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim13(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim14(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim15(map) => map.peek_highest(),
-            DynArrayHeapMapInner::Dim16(map) => map.peek_highest(),
-        }
-    }
-
-    /// Removes the entry with the highest key from the map.
-    pub(super) fn evict_highest(&mut self) {
-        match &mut self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim2(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim3(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim4(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim5(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim6(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim7(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim8(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim9(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim10(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim11(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim12(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim13(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim14(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim15(map) => map.evict_highest(),
-            DynArrayHeapMapInner::Dim16(map) => map.evict_highest(),
-        }
-    }
-
-    pub(crate) fn memory_consumption(&self) -> u64 {
-        match &self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim2(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim3(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim4(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim5(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim6(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim7(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim8(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim9(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim10(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim11(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim12(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim13(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim14(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim15(map) => map.memory_consumption(),
-            DynArrayHeapMapInner::Dim16(map) => map.memory_consumption(),
-        }
-    }
-}
-
-impl<K: Ord + Clone + Copy + 'static, V: 'static> DynArrayHeapMap<K, V> {
-    /// Turns this map into an iterator over key-value pairs.
-    pub fn into_iter(self) -> impl Iterator<Item = (SmallVec<[K; MAX_DYN_ARRAY_SIZE]>, V)> {
-        match self.0 {
-            DynArrayHeapMapInner::Dim1(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim2(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim3(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim4(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim5(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim6(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim7(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim8(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim9(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim10(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim11(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim12(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim13(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim14(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim15(map) => map.into_iter(),
-            DynArrayHeapMapInner::Dim16(map) => map.into_iter(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_dyn_array_heap_map() {
-        let mut map = DynArrayHeapMap::<u32, &str>::try_new(2).unwrap();
-        // insert
-        let key1 = [1u32, 2u32];
-        let key2 = [2u32, 1u32];
-        map.get_or_insert_with(&key1, || "a");
-        map.get_or_insert_with(&key2, || "b");
-        assert_eq!(map.size(), 2);
-
-        // evict highest
-        assert_eq!(map.peek_highest(), Some(&key2[..]));
-        map.evict_highest();
-        assert_eq!(map.size(), 1);
-        assert_eq!(map.peek_highest(), Some(&key1[..]));
-
-        // into_iter
-        let mut iter = map.into_iter();
-        let (k, v) = iter.next().unwrap();
-        assert_eq!(k.as_slice(), &key1);
-        assert_eq!(v, "a");
-        assert_eq!(iter.next(), None);
-    }
-}

src/aggregation/bucket/composite/numeric_types.rs

@@ -1,460 +0,0 @@
-/// This module helps comparing numerical values of different types (i64, u64
-/// and f64).
-pub(super) mod num_cmp {
-    use std::cmp::Ordering;
-
-    use crate::TantivyError;
-
-    pub fn cmp_i64_f64(left_i: i64, right_f: f64) -> crate::Result<Ordering> {
-        if right_f.is_nan() {
-            return Err(TantivyError::InvalidArgument(
-                "NaN comparison is not supported".to_string(),
-            ));
-        }
-
-        // If right_f is < i64::MIN then left_i > right_f (i64::MIN=-2^63 can be
-        // exactly represented as f64)
-        if right_f < i64::MIN as f64 {
-            return Ok(Ordering::Greater);
-        }
-        // If right_f is >= i64::MAX then left_i < right_f (i64::MAX=2^63-1 cannot
-        // be exactly represented as f64)
-        if right_f >= i64::MAX as f64 {
-            return Ok(Ordering::Less);
-        }
-
-        // Now right_f is in (i64::MIN, i64::MAX), so `right_f as i64` is
-        // well-defined (truncation toward 0)
-        let right_as_i = right_f as i64;
-
-        let result = match left_i.cmp(&right_as_i) {
-            Ordering::Less => Ordering::Less,
-            Ordering::Greater => Ordering::Greater,
-            Ordering::Equal => {
-                // they have the same integer part, compare the fraction
-                let rem = right_f - (right_as_i as f64);
-                if rem == 0.0 {
-                    Ordering::Equal
-                } else if right_f > 0.0 {
-                    Ordering::Less
-                } else {
-                    Ordering::Greater
-                }
-            }
-        };
-        Ok(result)
-    }
-
-    pub fn cmp_u64_f64(left_u: u64, right_f: f64) -> crate::Result<Ordering> {
-        if right_f.is_nan() {
-            return Err(TantivyError::InvalidArgument(
-                "NaN comparison is not supported".to_string(),
-            ));
-        }
-
-        // Negative floats are always less than any u64 >= 0
-        if right_f < 0.0 {
-            return Ok(Ordering::Greater);
-        }
-
-        // If right_f is >= u64::MAX then left_u < right_f (u64::MAX=2^64-1 cannot be exactly)
-        let max_as_f = u64::MAX as f64;
-        if right_f > max_as_f {
-            return Ok(Ordering::Less);
-        }
-
-        // Now right_f is in (0, u64::MAX), so `right_f as u64` is well-defined
-        // (truncation toward 0)
-        let right_as_u = right_f as u64;
-
-        let result = match left_u.cmp(&right_as_u) {
-            Ordering::Less => Ordering::Less,
-            Ordering::Greater => Ordering::Greater,
-            Ordering::Equal => {
-                // they have the same integer part, compare the fraction
-                let rem = right_f - (right_as_u as f64);
-                if rem == 0.0 {
-                    Ordering::Equal
-                } else {
-                    Ordering::Less
-                }
-            }
-        };
-        Ok(result)
-    }
-
-    pub fn cmp_i64_u64(left_i: i64, right_u: u64) -> Ordering {
-        if left_i < 0 {
-            Ordering::Less
-        } else {
-            let left_as_u = left_i as u64;
-            left_as_u.cmp(&right_u)
-        }
-    }
-}
-
-/// This module helps projecting numerical values to other numerical types.
-/// When the target value space cannot exactly represent the source value, the
-/// next representable value is returned (or AfterLast if the source value is
-/// larger than the largest representable value).
-///
-/// All functions in this module assume that f64 values are not NaN.
-pub(super) mod num_proj {
-    #[derive(Debug, PartialEq)]
-    pub enum ProjectedNumber<T> {
-        Exact(T),
-        Next(T),
-        AfterLast,
-    }
-
-    pub fn i64_to_u64(value: i64) -> ProjectedNumber<u64> {
-        if value < 0 {
-            ProjectedNumber::Next(0)
-        } else {
-            ProjectedNumber::Exact(value as u64)
-        }
-    }
-
-    pub fn u64_to_i64(value: u64) -> ProjectedNumber<i64> {
-        if value > i64::MAX as u64 {
-            ProjectedNumber::AfterLast
-        } else {
-            ProjectedNumber::Exact(value as i64)
-        }
-    }
-
-    pub fn f64_to_u64(value: f64) -> ProjectedNumber<u64> {
-        if value < 0.0 {
-            ProjectedNumber::Next(0)
-        } else if value > u64::MAX as f64 {
-            ProjectedNumber::AfterLast
-        } else if value.fract() == 0.0 {
-            ProjectedNumber::Exact(value as u64)
-        } else {
-            // casting f64 to u64 truncates toward zero
-            ProjectedNumber::Next(value as u64 + 1)
-        }
-    }
-
-    pub fn f64_to_i64(value: f64) -> ProjectedNumber<i64> {
-        if value < (i64::MIN as f64) {
-            ProjectedNumber::Next(i64::MIN)
-        } else if value >= (i64::MAX as f64) {
-            ProjectedNumber::AfterLast
-        } else if value.fract() == 0.0 {
-            ProjectedNumber::Exact(value as i64)
-        } else if value > 0.0 {
-            // casting f64 to i64 truncates toward zero
-            ProjectedNumber::Next(value as i64 + 1)
-        } else {
-            ProjectedNumber::Next(value as i64)
-        }
-    }
-
-    pub fn i64_to_f64(value: i64) -> ProjectedNumber<f64> {
-        let value_f = value as f64;
-        let k_roundtrip = value_f as i64;
-        if k_roundtrip == value {
-            // between -2^53 and 2^53 all i64 are exactly represented as f64
-            ProjectedNumber::Exact(value_f)
-        } else {
-            // for very large/small i64 values, it is approximated to the closest f64
-            if k_roundtrip > value {
-                ProjectedNumber::Next(value_f)
-            } else {
-                ProjectedNumber::Next(value_f.next_up())
-            }
-        }
-    }
-
-    pub fn u64_to_f64(value: u64) -> ProjectedNumber<f64> {
-        let value_f = value as f64;
-        let k_roundtrip = value_f as u64;
-        if k_roundtrip == value {
-            // between 0 and 2^53 all u64 are exactly represented as f64
-            ProjectedNumber::Exact(value_f)
-        } else if k_roundtrip > value {
-            ProjectedNumber::Next(value_f)
-        } else {
-            ProjectedNumber::Next(value_f.next_up())
-        }
-    }
-}
-
-#[cfg(test)]
-mod num_cmp_tests {
-    use std::cmp::Ordering;
-
-    use super::num_cmp::*;
-
-    #[test]
-    fn test_cmp_u64_f64() {
-        // Basic comparisons
-        assert_eq!(cmp_u64_f64(5, 5.0).unwrap(), Ordering::Equal);
-        assert_eq!(cmp_u64_f64(5, 6.0).unwrap(), Ordering::Less);
-        assert_eq!(cmp_u64_f64(6, 5.0).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_u64_f64(0, 0.0).unwrap(), Ordering::Equal);
-        assert_eq!(cmp_u64_f64(0, 0.1).unwrap(), Ordering::Less);
-
-        // Negative float values should always be less than any u64
-        assert_eq!(cmp_u64_f64(0, -0.1).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_u64_f64(5, -5.0).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_u64_f64(u64::MAX, -1e20).unwrap(), Ordering::Greater);
-
-        // Tests with extreme values
-        assert_eq!(cmp_u64_f64(u64::MAX, 1e20).unwrap(), Ordering::Less);
-
-        // Precision edge cases: large u64 that loses precision when converted to f64
-        // => 2^54, exactly represented as f64
-        let large_f64 = 18_014_398_509_481_984.0;
-        let large_u64 = 18_014_398_509_481_984;
-        // prove that large_u64 is exactly represented as f64
-        assert_eq!(large_u64 as f64, large_f64);
-        assert_eq!(cmp_u64_f64(large_u64, large_f64).unwrap(), Ordering::Equal);
-        // => (2^54 + 1) cannot be exactly represented in f64
-        let large_u64_plus_1 = 18_014_398_509_481_985;
-        // prove that it is represented as f64 by large_f64
-        assert_eq!(large_u64_plus_1 as f64, large_f64);
-        assert_eq!(
-            cmp_u64_f64(large_u64_plus_1, large_f64).unwrap(),
-            Ordering::Greater
-        );
-        // => (2^54 - 1) cannot be exactly represented in f64
-        let large_u64_minus_1 = 18_014_398_509_481_983;
-        // prove that it is also represented as f64 by large_f64
-        assert_eq!(large_u64_minus_1 as f64, large_f64);
-        assert_eq!(
-            cmp_u64_f64(large_u64_minus_1, large_f64).unwrap(),
-            Ordering::Less
-        );
-
-        // NaN comparison results in an error
-        assert!(cmp_u64_f64(0, f64::NAN).is_err());
-    }
-
-    #[test]
-    fn test_cmp_i64_f64() {
-        // Basic comparisons
-        assert_eq!(cmp_i64_f64(5, 5.0).unwrap(), Ordering::Equal);
-        assert_eq!(cmp_i64_f64(5, 6.0).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(6, 5.0).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_i64_f64(-5, -5.0).unwrap(), Ordering::Equal);
-        assert_eq!(cmp_i64_f64(-5, -4.0).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(-4, -5.0).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_i64_f64(-5, 5.0).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(5, -5.0).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_i64_f64(0, -0.1).unwrap(), Ordering::Greater);
-        assert_eq!(cmp_i64_f64(0, 0.1).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(-1, -0.5).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(-1, 0.0).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(0, 0.0).unwrap(), Ordering::Equal);
-
-        // Tests with extreme values
-        assert_eq!(cmp_i64_f64(i64::MAX, 1e20).unwrap(), Ordering::Less);
-        assert_eq!(cmp_i64_f64(i64::MIN, -1e20).unwrap(), Ordering::Greater);
-
-        // Precision edge cases: large i64 that loses precision when converted to f64
-        // => 2^54, exactly represented as f64
-        let large_f64 = 18_014_398_509_481_984.0;
-        let large_i64 = 18_014_398_509_481_984;
-        // prove that large_i64 is exactly represented as f64
-        assert_eq!(large_i64 as f64, large_f64);
-        assert_eq!(cmp_i64_f64(large_i64, large_f64).unwrap(), Ordering::Equal);
-        // => (1_i64 << 54) + 1 cannot be exactly represented in f64
-        let large_i64_plus_1 = 18_014_398_509_481_985;
-        // prove that it is represented as f64 by large_f64
-        assert_eq!(large_i64_plus_1 as f64, large_f64);
-        assert_eq!(
-            cmp_i64_f64(large_i64_plus_1, large_f64).unwrap(),
-            Ordering::Greater
-        );
-        // => (1_i64 << 54) - 1 cannot be exactly represented in f64
-        let large_i64_minus_1 = 18_014_398_509_481_983;
-        // prove that it is also represented as f64 by large_f64
-        assert_eq!(large_i64_minus_1 as f64, large_f64);
-        assert_eq!(
-            cmp_i64_f64(large_i64_minus_1, large_f64).unwrap(),
-            Ordering::Less
-        );
-
-        // Same precision edge case but with negative values
-        // => -2^54, exactly represented as f64
-        let large_neg_f64 = -18_014_398_509_481_984.0;
-        let large_neg_i64 = -18_014_398_509_481_984;
-        // prove that large_neg_i64 is exactly represented as f64
-        assert_eq!(large_neg_i64 as f64, large_neg_f64);
-        assert_eq!(
-            cmp_i64_f64(large_neg_i64, large_neg_f64).unwrap(),
-            Ordering::Equal
-        );
-        // => (-2^54 + 1) cannot be exactly represented in f64
-        let large_neg_i64_plus_1 = -18_014_398_509_481_985;
-        // prove that it is represented as f64 by large_neg_f64
-        assert_eq!(large_neg_i64_plus_1 as f64, large_neg_f64);
-        assert_eq!(
-            cmp_i64_f64(large_neg_i64_plus_1, large_neg_f64).unwrap(),
-            Ordering::Less
-        );
-        // => (-2^54 - 1) cannot be exactly represented in f64
-        let large_neg_i64_minus_1 = -18_014_398_509_481_983;
-        // prove that it is also represented as f64 by large_neg_f64
-        assert_eq!(large_neg_i64_minus_1 as f64, large_neg_f64);
-        assert_eq!(
-            cmp_i64_f64(large_neg_i64_minus_1, large_neg_f64).unwrap(),
-            Ordering::Greater
-        );
-
-        // NaN comparison results in an error
-        assert!(cmp_i64_f64(0, f64::NAN).is_err());
-    }
-
-    #[test]
-    fn test_cmp_i64_u64() {
-        // Test with negative i64 values (should always be less than any u64)
-        assert_eq!(cmp_i64_u64(-1, 0), Ordering::Less);
-        assert_eq!(cmp_i64_u64(i64::MIN, 0), Ordering::Less);
-        assert_eq!(cmp_i64_u64(i64::MIN, u64::MAX), Ordering::Less);
-
-        // Test with positive i64 values
-        assert_eq!(cmp_i64_u64(0, 0), Ordering::Equal);
-        assert_eq!(cmp_i64_u64(1, 0), Ordering::Greater);
-        assert_eq!(cmp_i64_u64(1, 1), Ordering::Equal);
-        assert_eq!(cmp_i64_u64(0, 1), Ordering::Less);
-        assert_eq!(cmp_i64_u64(5, 10), Ordering::Less);
-        assert_eq!(cmp_i64_u64(10, 5), Ordering::Greater);
-
-        // Test with values near i64::MAX and u64 conversion
-        assert_eq!(cmp_i64_u64(i64::MAX, i64::MAX as u64), Ordering::Equal);
-        assert_eq!(cmp_i64_u64(i64::MAX, (i64::MAX as u64) + 1), Ordering::Less);
-        assert_eq!(cmp_i64_u64(i64::MAX, u64::MAX), Ordering::Less);
-    }
-}
-
-#[cfg(test)]
-mod num_proj_tests {
-    use super::num_proj::{self, ProjectedNumber};
-
-    #[test]
-    fn test_i64_to_u64() {
-        assert_eq!(num_proj::i64_to_u64(-1), ProjectedNumber::Next(0));
-        assert_eq!(num_proj::i64_to_u64(i64::MIN), ProjectedNumber::Next(0));
-        assert_eq!(num_proj::i64_to_u64(0), ProjectedNumber::Exact(0));
-        assert_eq!(num_proj::i64_to_u64(42), ProjectedNumber::Exact(42));
-        assert_eq!(
-            num_proj::i64_to_u64(i64::MAX),
-            ProjectedNumber::Exact(i64::MAX as u64)
-        );
-    }
-
-    #[test]
-    fn test_u64_to_i64() {
-        assert_eq!(num_proj::u64_to_i64(0), ProjectedNumber::Exact(0));
-        assert_eq!(num_proj::u64_to_i64(42), ProjectedNumber::Exact(42));
-        assert_eq!(
-            num_proj::u64_to_i64(i64::MAX as u64),
-            ProjectedNumber::Exact(i64::MAX)
-        );
-        assert_eq!(
-            num_proj::u64_to_i64((i64::MAX as u64) + 1),
-            ProjectedNumber::AfterLast
-        );
-        assert_eq!(num_proj::u64_to_i64(u64::MAX), ProjectedNumber::AfterLast);
-    }
-
-    #[test]
-    fn test_f64_to_u64() {
-        assert_eq!(num_proj::f64_to_u64(-1e25), ProjectedNumber::Next(0));
-        assert_eq!(num_proj::f64_to_u64(-0.1), ProjectedNumber::Next(0));
-        assert_eq!(num_proj::f64_to_u64(1e20), ProjectedNumber::AfterLast);
-        assert_eq!(
-            num_proj::f64_to_u64(f64::INFINITY),
-            ProjectedNumber::AfterLast
-        );
-        assert_eq!(num_proj::f64_to_u64(0.0), ProjectedNumber::Exact(0));
-        assert_eq!(num_proj::f64_to_u64(42.0), ProjectedNumber::Exact(42));
-        assert_eq!(num_proj::f64_to_u64(0.5), ProjectedNumber::Next(1));
-        assert_eq!(num_proj::f64_to_u64(42.1), ProjectedNumber::Next(43));
-    }
-
-    #[test]
-    fn test_f64_to_i64() {
-        assert_eq!(num_proj::f64_to_i64(-1e20), ProjectedNumber::Next(i64::MIN));
-        assert_eq!(
-            num_proj::f64_to_i64(f64::NEG_INFINITY),
-            ProjectedNumber::Next(i64::MIN)
-        );
-        assert_eq!(num_proj::f64_to_i64(1e20), ProjectedNumber::AfterLast);
-        assert_eq!(
-            num_proj::f64_to_i64(f64::INFINITY),
-            ProjectedNumber::AfterLast
-        );
-        assert_eq!(num_proj::f64_to_i64(0.0), ProjectedNumber::Exact(0));
-        assert_eq!(num_proj::f64_to_i64(42.0), ProjectedNumber::Exact(42));
-        assert_eq!(num_proj::f64_to_i64(-42.0), ProjectedNumber::Exact(-42));
-        assert_eq!(num_proj::f64_to_i64(0.5), ProjectedNumber::Next(1));
-        assert_eq!(num_proj::f64_to_i64(42.1), ProjectedNumber::Next(43));
-        assert_eq!(num_proj::f64_to_i64(-0.5), ProjectedNumber::Next(0));
-        assert_eq!(num_proj::f64_to_i64(-42.1), ProjectedNumber::Next(-42));
-    }
-
-    #[test]
-    fn test_i64_to_f64() {
-        assert_eq!(num_proj::i64_to_f64(0), ProjectedNumber::Exact(0.0));
-        assert_eq!(num_proj::i64_to_f64(42), ProjectedNumber::Exact(42.0));
-        assert_eq!(num_proj::i64_to_f64(-42), ProjectedNumber::Exact(-42.0));
-
-        let max_exact = 9_007_199_254_740_992; // 2^53
-        assert_eq!(
-            num_proj::i64_to_f64(max_exact),
-            ProjectedNumber::Exact(max_exact as f64)
-        );
-
-        // Test values that cannot be exactly represented as f64 (integers above 2^53)
-        let large_i64 = 9_007_199_254_740_993; // 2^53 + 1
-        let closest_f64 = 9_007_199_254_740_992.0;
-        assert_eq!(large_i64 as f64, closest_f64);
-        if let ProjectedNumber::Next(val) = num_proj::i64_to_f64(large_i64) {
-            // Verify that the returned float is different from the direct cast
-            assert!(val > closest_f64);
-            assert!(val - closest_f64 < 2. * f64::EPSILON * closest_f64);
-        } else {
-            panic!("Expected ProjectedNumber::Next for large_i64");
-        }
-
-        // Test with very large negative value
-        let large_neg_i64 = -9_007_199_254_740_993; // -(2^53 + 1)
-        let closest_neg_f64 = -9_007_199_254_740_992.0;
-        assert_eq!(large_neg_i64 as f64, closest_neg_f64);
-        if let ProjectedNumber::Next(val) = num_proj::i64_to_f64(large_neg_i64) {
-            // Verify that the returned float is the closest representable f64
-            assert_eq!(val, closest_neg_f64);
-        } else {
-            panic!("Expected ProjectedNumber::Next for large_neg_i64");
-        }
-    }
-
-    #[test]
-    fn test_u64_to_f64() {
-        assert_eq!(num_proj::u64_to_f64(0), ProjectedNumber::Exact(0.0));
-        assert_eq!(num_proj::u64_to_f64(42), ProjectedNumber::Exact(42.0));
-
-        // Test the largest u64 value that can be exactly represented as f64 (2^53)
-        let max_exact = 9_007_199_254_740_992; // 2^53
-        assert_eq!(
-            num_proj::u64_to_f64(max_exact),
-            ProjectedNumber::Exact(max_exact as f64)
-        );
-
-        // Test values that cannot be exactly represented as f64 (integers above 2^53)
-        let large_u64 = 9_007_199_254_740_993; // 2^53 + 1
-        let closest_f64 = 9_007_199_254_740_992.0;
-        assert_eq!(large_u64 as f64, closest_f64);
-        if let ProjectedNumber::Next(val) = num_proj::u64_to_f64(large_u64) {
-            // Verify that the returned float is different from the direct cast
-            assert!(val > closest_f64);
-            assert!(val - closest_f64 < 2. * f64::EPSILON * closest_f64);
-        } else {
-            panic!("Expected ProjectedNumber::Next for large_u64");
-        }
-    }
-}

src/aggregation/bucket/filter.rs

@@ -6,14 +6,10 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use crate::aggregation::agg_data::{
     build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
 };
-use crate::aggregation::buffered_sub_aggs::{
-    BufferedSubAggs, HighCardSubAggBuffer, LowCardSubAggBuffer, SubAggBuffer,
-};
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
 };
-use crate::aggregation::segment_agg_result::{BucketIdProvider, SegmentAggregationCollector};
-use crate::aggregation::BucketId;
+use crate::aggregation::segment_agg_result::{CollectorClone, SegmentAggregationCollector};
 use crate::docset::DocSet;
 use crate::query::{AllQuery, EnableScoring, Query, QueryParser};
 use crate::schema::Schema;
@@ -408,18 +404,15 @@ pub struct FilterAggReqData {
     pub evaluator: DocumentQueryEvaluator,
     /// Reusable buffer for matching documents to minimize allocations during collection
     pub matching_docs_buffer: Vec<DocId>,
-    /// True if this filter aggregation is at the top level of the aggregation tree (not nested).
-    pub is_top_level: bool,
 }
 
 impl FilterAggReqData {
     pub(crate) fn get_memory_consumption(&self) -> usize {
         // Estimate: name + segment reader reference + bitset + buffer capacity
         self.name.len()
-        + std::mem::size_of::<SegmentReader>()
-        + self.evaluator.bitset.len() / 8 // BitSet memory (bits to bytes)
-        + self.matching_docs_buffer.capacity() * std::mem::size_of::<DocId>()
-        + std::mem::size_of::<bool>()
+            + std::mem::size_of::<SegmentReader>()
+            + self.evaluator.bitset.len() / 8 // BitSet memory (bits to bytes)
+            + self.matching_docs_buffer.capacity() * std::mem::size_of::<DocId>()
     }
 }
 
@@ -496,24 +489,17 @@ impl Debug for DocumentQueryEvaluator {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Copy)]
-struct DocCount {
-    doc_count: u64,
-    bucket_id: BucketId,
-}
-
 /// Segment collector for filter aggregation
-pub struct SegmentFilterCollector<B: SubAggBuffer> {
-    /// Document counts per parent bucket
-    parent_buckets: Vec<DocCount>,
+pub struct SegmentFilterCollector {
+    /// Document count in this bucket
+    doc_count: u64,
     /// Sub-aggregation collectors
-    sub_aggregations: Option<BufferedSubAggs<B>>,
-    bucket_id_provider: BucketIdProvider,
+    sub_aggregations: Option<Box<dyn SegmentAggregationCollector>>,
     /// Accessor index for this filter aggregation (to access FilterAggReqData)
     accessor_idx: usize,
 }
 
-impl<B: SubAggBuffer> SegmentFilterCollector<B> {
+impl SegmentFilterCollector {
     /// Create a new filter segment collector following the new agg_data pattern
     pub(crate) fn from_req_and_validate(
         req: &mut AggregationsSegmentCtx,
@@ -525,75 +511,47 @@ impl<B: SubAggBuffer> SegmentFilterCollector<B> {
         } else {
             None
         };
-        let sub_agg_collector = sub_agg_collector.map(BufferedSubAggs::new);
 
         Ok(SegmentFilterCollector {
-            parent_buckets: Vec::new(),
+            doc_count: 0,
             sub_aggregations: sub_agg_collector,
             accessor_idx: node.idx_in_req_data,
-            bucket_id_provider: BucketIdProvider::default(),
         })
     }
 }
 
-pub(crate) fn build_segment_filter_collector(
-    req: &mut AggregationsSegmentCtx,
-    node: &AggRefNode,
-) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
-    let is_top_level = req.per_request.filter_req_data[node.idx_in_req_data]
-        .as_ref()
-        .expect("filter_req_data slot is empty")
-        .is_top_level;
-
-    if is_top_level {
-        Ok(Box::new(
-            SegmentFilterCollector::<LowCardSubAggBuffer>::from_req_and_validate(req, node)?,
-        ))
-    } else {
-        Ok(Box::new(
-            SegmentFilterCollector::<HighCardSubAggBuffer>::from_req_and_validate(req, node)?,
-        ))
-    }
-}
-
-impl<B: SubAggBuffer> Debug for SegmentFilterCollector<B> {
+impl Debug for SegmentFilterCollector {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SegmentFilterCollector")
-            .field("buckets", &self.parent_buckets)
+            .field("doc_count", &self.doc_count)
             .field("has_sub_aggs", &self.sub_aggregations.is_some())
             .field("accessor_idx", &self.accessor_idx)
             .finish()
     }
 }
 
-impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentFilterCollector<B> {
+impl CollectorClone for SegmentFilterCollector {
+    fn clone_box(&self) -> Box<dyn SegmentAggregationCollector> {
+        // For now, panic - this needs proper implementation with weight recreation
+        panic!("SegmentFilterCollector cloning not yet implemented - requires weight recreation")
+    }
+}
+
+impl SegmentAggregationCollector for SegmentFilterCollector {
     fn add_intermediate_aggregation_result(
-        &mut self,
+        self: Box<Self>,
         agg_data: &AggregationsSegmentCtx,
         results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
     ) -> crate::Result<()> {
         let mut sub_results = IntermediateAggregationResults::default();
-        let bucket_opt = self.parent_buckets.get(parent_bucket_id as usize);
 
-        if let Some(sub_aggs) = &mut self.sub_aggregations {
-            sub_aggs
-                .get_sub_agg_collector()
-                .add_intermediate_aggregation_result(
-                    agg_data,
-                    &mut sub_results,
-                    // Here we create a new bucket ID for sub-aggregations if the bucket doesn't
-                    // exist, so that sub-aggregations can still produce results (e.g., zero doc
-                    // count)
-                    bucket_opt
-                        .map(|bucket| bucket.bucket_id)
-                        .unwrap_or(self.bucket_id_provider.next_bucket_id()),
-                )?;
+        if let Some(sub_aggs) = self.sub_aggregations {
+            sub_aggs.add_intermediate_aggregation_result(agg_data, &mut sub_results)?;
         }
 
         // Create the filter bucket result
         let filter_bucket_result = IntermediateBucketResult::Filter {
-            doc_count: bucket_opt.map(|b| b.doc_count).unwrap_or(0),
+            doc_count: self.doc_count,
             sub_aggregations: sub_results,
         };
 
@@ -612,17 +570,32 @@ impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentFilterCollector<B>
         Ok(())
     }
 
-    fn collect(
+    fn collect(&mut self, doc: DocId, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+        // Access the evaluator from FilterAggReqData
+        let req_data = agg_data.get_filter_req_data(self.accessor_idx);
+
+        // O(1) BitSet lookup to check if document matches filter
+        if req_data.evaluator.matches_document(doc) {
+            self.doc_count += 1;
+
+            // If we have sub-aggregations, collect on them for this filtered document
+            if let Some(sub_aggs) = &mut self.sub_aggregations {
+                sub_aggs.collect(doc, agg_data)?;
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn collect_block(
         &mut self,
-        parent_bucket_id: BucketId,
-        docs: &[crate::DocId],
+        docs: &[DocId],
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
         if docs.is_empty() {
             return Ok(());
         }
 
-        let mut bucket = self.parent_buckets[parent_bucket_id as usize];
         // Take the request data to avoid borrow checker issues with sub-aggregations
         let mut req = agg_data.take_filter_req_data(self.accessor_idx);
 
@@ -631,24 +604,18 @@ impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentFilterCollector<B>
         req.evaluator
             .filter_batch(docs, &mut req.matching_docs_buffer);
 
-        bucket.doc_count += req.matching_docs_buffer.len() as u64;
+        self.doc_count += req.matching_docs_buffer.len() as u64;
 
         // Batch process sub-aggregations if we have matches
         if !req.matching_docs_buffer.is_empty() {
             if let Some(sub_aggs) = &mut self.sub_aggregations {
-                for &doc_id in &req.matching_docs_buffer {
-                    sub_aggs.push(bucket.bucket_id, doc_id);
-                }
+                // Use collect_block for better sub-aggregation performance
+                sub_aggs.collect_block(&req.matching_docs_buffer, agg_data)?;
             }
         }
 
         // Put the request data back
         agg_data.put_back_filter_req_data(self.accessor_idx, req);
-        if let Some(sub_aggs) = &mut self.sub_aggregations {
-            sub_aggs.check_flush_local(agg_data)?;
-        }
-        // put back bucket
-        self.parent_buckets[parent_bucket_id as usize] = bucket;
 
         Ok(())
     }
@@ -659,32 +626,6 @@ impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentFilterCollector<B>
         }
         Ok(())
     }
-
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        while self.parent_buckets.len() <= max_bucket as usize {
-            let bucket_id = self.bucket_id_provider.next_bucket_id();
-            self.parent_buckets.push(DocCount {
-                doc_count: 0,
-                bucket_id,
-            });
-        }
-        Ok(())
-    }
-
-    fn compute_metric_value(
-        &self,
-        _bucket_id: BucketId,
-        _sub_agg_name: &str,
-        _sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        // TODO: forward into the inner `sub_agg` for nested order paths (`filter.metric`).
-        None
-    }
 }
 
 /// Intermediate result for filter aggregation
@@ -1578,9 +1519,9 @@ mod tests {
         let searcher = reader.searcher();
 
         let agg = json!({
-                "test": {
-                    "filter": deserialized,
-                    "aggs": { "count": { "value_count": { "field": "brand" } } }
+            "test": {
+                "filter": deserialized,
+                "aggs": { "count": { "value_count": { "field": "brand" } } }
             }
         });
 

src/aggregation/bucket/histogram/date_histogram.rs

@@ -207,7 +207,7 @@ fn parse_offset_into_milliseconds(input: &str) -> Result<i64, AggregationError>
     }
 }
 
-pub(crate) fn parse_into_milliseconds(input: &str) -> Result<i64, AggregationError> {
+fn parse_into_milliseconds(input: &str) -> Result<i64, AggregationError> {
     let split_boundary = input
         .as_bytes()
         .iter()

src/aggregation/bucket/histogram/histogram.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 
-use columnar::{Column, ColumnType};
+use columnar::{Column, ColumnBlockAccessor, ColumnType};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use tantivy_bitpacker::minmax;
@@ -8,14 +8,14 @@ use tantivy_bitpacker::minmax;
 use crate::aggregation::agg_data::{
     build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
 };
+use crate::aggregation::agg_limits::MemoryConsumption;
 use crate::aggregation::agg_req::Aggregations;
 use crate::aggregation::agg_result::BucketEntry;
-use crate::aggregation::buffered_sub_aggs::{BufferedSubAggs, HighCardBufferedSubAggs};
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateHistogramBucketEntry,
 };
-use crate::aggregation::segment_agg_result::{BucketIdProvider, SegmentAggregationCollector};
+use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
 use crate::aggregation::*;
 use crate::TantivyError;
 
@@ -26,8 +26,13 @@ pub struct HistogramAggReqData {
     pub accessor: Column<u64>,
     /// The field type of the fast field.
     pub field_type: ColumnType,
+    /// The column block accessor to access the fast field values.
+    pub column_block_accessor: ColumnBlockAccessor<u64>,
     /// The name of the aggregation.
     pub name: String,
+    /// The sub aggregation blueprint, used to create sub aggregations for each bucket.
+    /// Will be filled during initialization of the collector.
+    pub sub_aggregation_blueprint: Option<Box<dyn SegmentAggregationCollector>>,
     /// The histogram aggregation request.
     pub req: HistogramAggregation,
     /// True if this is a date_histogram aggregation.
@@ -252,24 +257,18 @@ impl HistogramBounds {
 pub(crate) struct SegmentHistogramBucketEntry {
     pub key: f64,
     pub doc_count: u64,
-    pub bucket_id: BucketId,
 }
 
 impl SegmentHistogramBucketEntry {
     pub(crate) fn into_intermediate_bucket_entry(
         self,
-        sub_aggregation: &mut Option<HighCardBufferedSubAggs>,
+        sub_aggregation: Option<Box<dyn SegmentAggregationCollector>>,
         agg_data: &AggregationsSegmentCtx,
     ) -> crate::Result<IntermediateHistogramBucketEntry> {
         let mut sub_aggregation_res = IntermediateAggregationResults::default();
         if let Some(sub_aggregation) = sub_aggregation {
             sub_aggregation
-                .get_sub_agg_collector()
-                .add_intermediate_aggregation_result(
-                    agg_data,
-                    &mut sub_aggregation_res,
-                    self.bucket_id,
-                )?;
+                .add_intermediate_aggregation_result(agg_data, &mut sub_aggregation_res)?;
         }
         Ok(IntermediateHistogramBucketEntry {
             key: self.key,
@@ -279,43 +278,27 @@ impl SegmentHistogramBucketEntry {
     }
 }
 
-#[derive(Clone, Debug, Default)]
-struct HistogramBuckets {
-    pub buckets: FxHashMap<i64, SegmentHistogramBucketEntry>,
-}
-impl HistogramBuckets {
-    fn memory_consumption(&self) -> u64 {
-        self.buckets.capacity() as u64 * std::mem::size_of::<SegmentHistogramBucketEntry>() as u64
-    }
-}
-
 /// The collector puts values from the fast field into the correct buckets and does a conversion to
 /// the correct datatype.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct SegmentHistogramCollector {
     /// The buckets containing the aggregation data.
-    /// One Histogram bucket per parent bucket id.
-    parent_buckets: Vec<HistogramBuckets>,
-    sub_agg: Option<HighCardBufferedSubAggs>,
+    buckets: FxHashMap<i64, SegmentHistogramBucketEntry>,
+    sub_aggregations: FxHashMap<i64, Box<dyn SegmentAggregationCollector>>,
     accessor_idx: usize,
-    bucket_id_provider: BucketIdProvider,
 }
 
 impl SegmentAggregationCollector for SegmentHistogramCollector {
     fn add_intermediate_aggregation_result(
-        &mut self,
+        self: Box<Self>,
         agg_data: &AggregationsSegmentCtx,
         results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
     ) -> crate::Result<()> {
         let name = agg_data
             .get_histogram_req_data(self.accessor_idx)
             .name
             .clone();
-        // TODO: avoid prepare_max_bucket here and handle empty buckets.
-        self.prepare_max_bucket(parent_bucket_id, agg_data)?;
-        let histogram = std::mem::take(&mut self.parent_buckets[parent_bucket_id as usize]);
-        let bucket = self.add_intermediate_bucket_result(agg_data, histogram)?;
+        let bucket = self.into_intermediate_bucket_result(agg_data)?;
         results.push(name, IntermediateAggregationResult::Bucket(bucket))?;
 
         Ok(())
@@ -324,104 +307,88 @@ impl SegmentAggregationCollector for SegmentHistogramCollector {
     #[inline]
     fn collect(
         &mut self,
-        parent_bucket_id: BucketId,
+        doc: crate::DocId,
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        self.collect_block(&[doc], agg_data)
+    }
+
+    #[inline]
+    fn collect_block(
+        &mut self,
         docs: &[crate::DocId],
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
-        let req = agg_data.take_histogram_req_data(self.accessor_idx);
-        let mem_pre = self.get_memory_consumption(parent_bucket_id);
-        let buckets = &mut self.parent_buckets[parent_bucket_id as usize].buckets;
+        let mut req = agg_data.take_histogram_req_data(self.accessor_idx);
+        let mem_pre = self.get_memory_consumption();
 
         let bounds = req.bounds;
         let interval = req.req.interval;
         let offset = req.offset;
         let get_bucket_pos = |val| get_bucket_pos_f64(val, interval, offset) as i64;
 
-        agg_data
-            .column_block_accessor
-            .fetch_block(docs, &req.accessor);
-        for (doc, val) in agg_data
+        req.column_block_accessor.fetch_block(docs, &req.accessor);
+        for (doc, val) in req
             .column_block_accessor
             .iter_docid_vals(docs, &req.accessor)
         {
-            let val = f64_from_fastfield_u64(val, req.field_type);
+            let val = f64_from_fastfield_u64(val, &req.field_type);
             let bucket_pos = get_bucket_pos(val);
             if bounds.contains(val) {
-                let bucket = buckets.entry(bucket_pos).or_insert_with(|| {
+                let bucket = self.buckets.entry(bucket_pos).or_insert_with(|| {
                     let key = get_bucket_key_from_pos(bucket_pos as f64, interval, offset);
-                    SegmentHistogramBucketEntry {
-                        key,
-                        doc_count: 0,
-                        bucket_id: self.bucket_id_provider.next_bucket_id(),
-                    }
+                    SegmentHistogramBucketEntry { key, doc_count: 0 }
                 });
                 bucket.doc_count += 1;
-                if let Some(sub_agg) = &mut self.sub_agg {
-                    sub_agg.push(bucket.bucket_id, doc);
+                if let Some(sub_aggregation_blueprint) = req.sub_aggregation_blueprint.as_ref() {
+                    self.sub_aggregations
+                        .entry(bucket_pos)
+                        .or_insert_with(|| sub_aggregation_blueprint.clone())
+                        .collect(doc, agg_data)?;
                 }
             }
         }
         agg_data.put_back_histogram_req_data(self.accessor_idx, req);
 
-        let mem_delta = self.get_memory_consumption(parent_bucket_id) - mem_pre;
+        let mem_delta = self.get_memory_consumption() - mem_pre;
         if mem_delta > 0 {
-            agg_data.context.limits.add_memory_consumed(mem_delta)?;
-        }
-
-        if let Some(sub_agg) = &mut self.sub_agg {
-            sub_agg.check_flush_local(agg_data)?;
+            agg_data
+                .context
+                .limits
+                .add_memory_consumed(mem_delta as u64)?;
         }
 
         Ok(())
     }
 
     fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        if let Some(sub_aggregation) = &mut self.sub_agg {
+        for sub_aggregation in self.sub_aggregations.values_mut() {
             sub_aggregation.flush(agg_data)?;
         }
-        Ok(())
-    }
 
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        while self.parent_buckets.len() <= max_bucket as usize {
-            self.parent_buckets.push(HistogramBuckets {
-                buckets: FxHashMap::default(),
-            });
-        }
         Ok(())
     }
-
-    fn compute_metric_value(
-        &self,
-        _bucket_id: BucketId,
-        _sub_agg_name: &str,
-        _sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        // Histogram is a multi-bucket agg with no single value to extract.
-        None
-    }
 }
 
 impl SegmentHistogramCollector {
-    fn get_memory_consumption(&self, parent_bucket_id: BucketId) -> u64 {
-        self.parent_buckets[parent_bucket_id as usize].memory_consumption()
+    fn get_memory_consumption(&self) -> usize {
+        let self_mem = std::mem::size_of::<Self>();
+        let sub_aggs_mem = self.sub_aggregations.memory_consumption();
+        let buckets_mem = self.buckets.memory_consumption();
+        self_mem + sub_aggs_mem + buckets_mem
     }
-
     /// Converts the collector result into a intermediate bucket result.
-    fn add_intermediate_bucket_result(
-        &mut self,
+    pub fn into_intermediate_bucket_result(
+        self,
         agg_data: &AggregationsSegmentCtx,
-        histogram: HistogramBuckets,
     ) -> crate::Result<IntermediateBucketResult> {
-        let mut buckets = Vec::with_capacity(histogram.buckets.len());
+        let mut buckets = Vec::with_capacity(self.buckets.len());
 
-        for bucket in histogram.buckets.into_values() {
-            let bucket_res = bucket.into_intermediate_bucket_entry(&mut self.sub_agg, agg_data);
+        for (bucket_pos, bucket) in self.buckets {
+            let bucket_res = bucket.into_intermediate_bucket_entry(
+                self.sub_aggregations.get(&bucket_pos).cloned(),
+                agg_data,
+            );
 
             buckets.push(bucket_res?);
         }
@@ -441,7 +408,7 @@ impl SegmentHistogramCollector {
         agg_data: &mut AggregationsSegmentCtx,
         node: &AggRefNode,
     ) -> crate::Result<Self> {
-        let sub_agg = if !node.children.is_empty() {
+        let blueprint = if !node.children.is_empty() {
             Some(build_segment_agg_collectors(agg_data, &node.children)?)
         } else {
             None
@@ -456,13 +423,13 @@ impl SegmentHistogramCollector {
             max: f64::MAX,
         });
         req_data.offset = req_data.req.offset.unwrap_or(0.0);
-        let sub_agg = sub_agg.map(BufferedSubAggs::new);
+
+        req_data.sub_aggregation_blueprint = blueprint;
 
         Ok(Self {
-            parent_buckets: Default::default(),
-            sub_agg,
+            buckets: Default::default(),
+            sub_aggregations: Default::default(),
             accessor_idx: node.idx_in_req_data,
-            bucket_id_provider: BucketIdProvider::default(),
         })
     }
 }

src/aggregation/bucket/mod.rs

@@ -22,7 +22,6 @@
 //! - [Range](RangeAggregation)
 //! - [Terms](TermsAggregation)
 
-mod composite;
 mod filter;
 mod histogram;
 mod range;
@@ -32,7 +31,6 @@ mod term_missing_agg;
 use std::collections::HashMap;
 use std::fmt;
 
-pub use composite::*;
 pub use filter::*;
 pub use histogram::*;
 pub use range::*;

src/aggregation/bucket/range.rs

@@ -1,23 +1,18 @@
 use std::fmt::Debug;
 use std::ops::Range;
 
-use columnar::{Column, ColumnType};
+use columnar::{Column, ColumnBlockAccessor, ColumnType};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::aggregation::agg_data::{
     build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
 };
-use crate::aggregation::agg_limits::AggregationLimitsGuard;
-use crate::aggregation::buffered_sub_aggs::{
-    BufferedSubAggs, HighCardSubAggBuffer, LowCardBufferedSubAggs, LowCardSubAggBuffer,
-    SubAggBuffer,
-};
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateRangeBucketEntry, IntermediateRangeBucketResult,
 };
-use crate::aggregation::segment_agg_result::{BucketIdProvider, SegmentAggregationCollector};
+use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
 use crate::aggregation::*;
 use crate::TantivyError;
 
@@ -28,12 +23,12 @@ pub struct RangeAggReqData {
     pub accessor: Column<u64>,
     /// The type of the fast field.
     pub field_type: ColumnType,
+    /// The column block accessor to access the fast field values.
+    pub column_block_accessor: ColumnBlockAccessor<u64>,
     /// The range aggregation request.
     pub req: RangeAggregation,
     /// The name of the aggregation.
     pub name: String,
-    /// Whether this is a top-level aggregation.
-    pub is_top_level: bool,
 }
 
 impl RangeAggReqData {
@@ -156,47 +151,19 @@ pub(crate) struct SegmentRangeAndBucketEntry {
 
 /// The collector puts values from the fast field into the correct buckets and does a conversion to
 /// the correct datatype.
-pub struct SegmentRangeCollector<B: SubAggBuffer> {
+#[derive(Clone, Debug)]
+pub struct SegmentRangeCollector {
     /// The buckets containing the aggregation data.
-    /// One for each ParentBucketId
-    parent_buckets: Vec<Vec<SegmentRangeAndBucketEntry>>,
+    buckets: Vec<SegmentRangeAndBucketEntry>,
     column_type: ColumnType,
     pub(crate) accessor_idx: usize,
-    sub_agg: Option<BufferedSubAggs<B>>,
-    /// Here things get a bit weird. We need to assign unique bucket ids across all
-    /// parent buckets. So we keep track of the next available bucket id here.
-    /// This allows a kind of flattening of the bucket ids across all parent buckets.
-    /// E.g. in nested aggregations:
-    /// Term Agg -> Range aggregation -> Stats aggregation
-    /// E.g. the Term Agg creates 3 buckets ["INFO", "ERROR", "WARN"], each of these has a Range
-    /// aggregation with 4 buckets. The Range aggregation will create buckets with ids:
-    /// - INFO: 0,1,2,3
-    /// - ERROR: 4,5,6,7
-    /// - WARN: 8,9,10,11
-    ///
-    /// This allows the Stats aggregation to have unique bucket ids to refer to.
-    bucket_id_provider: BucketIdProvider,
-    limits: AggregationLimitsGuard,
 }
 
-impl<B: SubAggBuffer> Debug for SegmentRangeCollector<B> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SegmentRangeCollector")
-            .field("parent_buckets_len", &self.parent_buckets.len())
-            .field("column_type", &self.column_type)
-            .field("accessor_idx", &self.accessor_idx)
-            .field("has_sub_agg", &self.sub_agg.is_some())
-            .finish()
-    }
-}
-
-/// TODO: Bad naming, there's also SegmentRangeAndBucketEntry
 #[derive(Clone)]
 pub(crate) struct SegmentRangeBucketEntry {
     pub key: Key,
     pub doc_count: u64,
-    // pub sub_aggregation: Option<Box<dyn SegmentAggregationCollector>>,
-    pub bucket_id: BucketId,
+    pub sub_aggregation: Option<Box<dyn SegmentAggregationCollector>>,
     /// The from range of the bucket. Equals `f64::MIN` when `None`.
     pub from: Option<f64>,
     /// The to range of the bucket. Equals `f64::MAX` when `None`. Open interval, `to` is not
@@ -217,50 +184,48 @@ impl Debug for SegmentRangeBucketEntry {
 impl SegmentRangeBucketEntry {
     pub(crate) fn into_intermediate_bucket_entry(
         self,
+        agg_data: &AggregationsSegmentCtx,
     ) -> crate::Result<IntermediateRangeBucketEntry> {
-        let sub_aggregation = IntermediateAggregationResults::default();
+        let mut sub_aggregation_res = IntermediateAggregationResults::default();
+        if let Some(sub_aggregation) = self.sub_aggregation {
+            sub_aggregation
+                .add_intermediate_aggregation_result(agg_data, &mut sub_aggregation_res)?
+        } else {
+            Default::default()
+        };
 
         Ok(IntermediateRangeBucketEntry {
             key: self.key.into(),
             doc_count: self.doc_count,
-            sub_aggregation_res: sub_aggregation,
+            sub_aggregation: sub_aggregation_res,
             from: self.from,
             to: self.to,
         })
     }
 }
 
-impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentRangeCollector<B> {
+impl SegmentAggregationCollector for SegmentRangeCollector {
     fn add_intermediate_aggregation_result(
-        &mut self,
+        self: Box<Self>,
         agg_data: &AggregationsSegmentCtx,
         results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
     ) -> crate::Result<()> {
-        self.prepare_max_bucket(parent_bucket_id, agg_data)?;
         let field_type = self.column_type;
         let name = agg_data
             .get_range_req_data(self.accessor_idx)
             .name
             .to_string();
 
-        let buckets = std::mem::take(&mut self.parent_buckets[parent_bucket_id as usize]);
-
-        let buckets: FxHashMap<SerializedKey, IntermediateRangeBucketEntry> = buckets
+        let buckets: FxHashMap<SerializedKey, IntermediateRangeBucketEntry> = self
+            .buckets
             .into_iter()
-            .map(|range_bucket| {
-                let bucket_id = range_bucket.bucket.bucket_id;
-                let mut agg = range_bucket.bucket.into_intermediate_bucket_entry()?;
-                if let Some(sub_aggregation) = &mut self.sub_agg {
-                    sub_aggregation
-                        .get_sub_agg_collector()
-                        .add_intermediate_aggregation_result(
-                            agg_data,
-                            &mut agg.sub_aggregation_res,
-                            bucket_id,
-                        )?;
-                }
-                Ok((range_to_string(&range_bucket.range, &field_type)?, agg))
+            .map(move |range_bucket| {
+                Ok((
+                    range_to_string(&range_bucket.range, &field_type)?,
+                    range_bucket
+                        .bucket
+                        .into_intermediate_bucket_entry(agg_data)?,
+                ))
             })
             .collect::<crate::Result<_>>()?;
 
@@ -277,125 +242,73 @@ impl<B: SubAggBuffer> SegmentAggregationCollector for SegmentRangeCollector<B> {
     #[inline]
     fn collect(
         &mut self,
-        parent_bucket_id: BucketId,
+        doc: crate::DocId,
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        self.collect_block(&[doc], agg_data)
+    }
+
+    #[inline]
+    fn collect_block(
+        &mut self,
         docs: &[crate::DocId],
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
-        let req = agg_data.take_range_req_data(self.accessor_idx);
+        // Take request data to avoid borrow conflicts during sub-aggregation
+        let mut req = agg_data.take_range_req_data(self.accessor_idx);
 
-        agg_data
-            .column_block_accessor
-            .fetch_block(docs, &req.accessor);
+        req.column_block_accessor.fetch_block(docs, &req.accessor);
 
-        let buckets = &mut self.parent_buckets[parent_bucket_id as usize];
-
-        for (doc, val) in agg_data
+        for (doc, val) in req
             .column_block_accessor
             .iter_docid_vals(docs, &req.accessor)
         {
-            let bucket_pos = get_bucket_pos(val, buckets);
-            let bucket = &mut buckets[bucket_pos];
+            let bucket_pos = self.get_bucket_pos(val);
+            let bucket = &mut self.buckets[bucket_pos];
             bucket.bucket.doc_count += 1;
-            if let Some(sub_agg) = self.sub_agg.as_mut() {
-                sub_agg.push(bucket.bucket.bucket_id, doc);
+            if let Some(sub_agg) = bucket.bucket.sub_aggregation.as_mut() {
+                sub_agg.collect(doc, agg_data)?;
             }
         }
 
         agg_data.put_back_range_req_data(self.accessor_idx, req);
-        if let Some(sub_agg) = self.sub_agg.as_mut() {
-            sub_agg.check_flush_local(agg_data)?;
-        }
 
         Ok(())
     }
 
     fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        if let Some(sub_agg) = self.sub_agg.as_mut() {
-            sub_agg.flush(agg_data)?;
+        for bucket in self.buckets.iter_mut() {
+            if let Some(sub_agg) = bucket.bucket.sub_aggregation.as_mut() {
+                sub_agg.flush(agg_data)?;
+            }
         }
         Ok(())
     }
-
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        while self.parent_buckets.len() <= max_bucket as usize {
-            let new_buckets = self.create_new_buckets(agg_data)?;
-            self.parent_buckets.push(new_buckets);
-        }
-
-        Ok(())
-    }
-
-    fn compute_metric_value(
-        &self,
-        _bucket_id: BucketId,
-        _sub_agg_name: &str,
-        _sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        // Range is a multi-bucket agg with no single value to extract.
-        None
-    }
-}
-/// Build a concrete `SegmentRangeCollector` with either a Vec- or HashMap-backed
-/// bucket storage, depending on the column type and aggregation level.
-pub(crate) fn build_segment_range_collector(
-    agg_data: &mut AggregationsSegmentCtx,
-    node: &AggRefNode,
-) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
-    let accessor_idx = node.idx_in_req_data;
-    let req_data = agg_data.get_range_req_data(node.idx_in_req_data);
-    let field_type = req_data.field_type;
-
-    // TODO: A better metric instead of is_top_level would be the number of buckets expected.
-    // E.g. If range agg is not top level, but the parent is a bucket agg with less than 10 buckets,
-    // we can are still in low cardinality territory.
-    let is_low_card = req_data.is_top_level && req_data.req.ranges.len() <= 64;
-
-    let sub_agg = if !node.children.is_empty() {
-        Some(build_segment_agg_collectors(agg_data, &node.children)?)
-    } else {
-        None
-    };
-
-    if is_low_card {
-        Ok(Box::new(SegmentRangeCollector::<LowCardSubAggBuffer> {
-            sub_agg: sub_agg.map(LowCardBufferedSubAggs::new),
-            column_type: field_type,
-            accessor_idx,
-            parent_buckets: Vec::new(),
-            bucket_id_provider: BucketIdProvider::default(),
-            limits: agg_data.context.limits.clone(),
-        }))
-    } else {
-        Ok(Box::new(SegmentRangeCollector::<HighCardSubAggBuffer> {
-            sub_agg: sub_agg.map(BufferedSubAggs::new),
-            column_type: field_type,
-            accessor_idx,
-            parent_buckets: Vec::new(),
-            bucket_id_provider: BucketIdProvider::default(),
-            limits: agg_data.context.limits.clone(),
-        }))
-    }
 }
 
-impl<B: SubAggBuffer> SegmentRangeCollector<B> {
-    pub(crate) fn create_new_buckets(
-        &mut self,
-        agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<Vec<SegmentRangeAndBucketEntry>> {
-        let field_type = self.column_type;
-        let req_data = agg_data.get_range_req_data(self.accessor_idx);
+impl SegmentRangeCollector {
+    pub(crate) fn from_req_and_validate(
+        req_data: &mut AggregationsSegmentCtx,
+        node: &AggRefNode,
+    ) -> crate::Result<Self> {
+        let accessor_idx = node.idx_in_req_data;
+        let (field_type, ranges) = {
+            let req_view = req_data.get_range_req_data(node.idx_in_req_data);
+            (req_view.field_type, req_view.req.ranges.clone())
+        };
+
         // The range input on the request is f64.
         // We need to convert to u64 ranges, because we read the values as u64.
         // The mapping from the conversion is monotonic so ordering is preserved.
-        let buckets: Vec<_> = extend_validate_ranges(&req_data.req.ranges, &field_type)?
+        let sub_agg_prototype = if !node.children.is_empty() {
+            Some(build_segment_agg_collectors(req_data, &node.children)?)
+        } else {
+            None
+        };
+
+        let buckets: Vec<_> = extend_validate_ranges(&ranges, &field_type)?
             .iter()
             .map(|range| {
-                let bucket_id = self.bucket_id_provider.next_bucket_id();
                 let key = range
                     .key
                     .clone()
@@ -404,20 +317,20 @@ impl<B: SubAggBuffer> SegmentRangeCollector<B> {
                 let to = if range.range.end == u64::MAX {
                     None
                 } else {
-                    Some(f64_from_fastfield_u64(range.range.end, field_type))
+                    Some(f64_from_fastfield_u64(range.range.end, &field_type))
                 };
                 let from = if range.range.start == u64::MIN {
                     None
                 } else {
-                    Some(f64_from_fastfield_u64(range.range.start, field_type))
+                    Some(f64_from_fastfield_u64(range.range.start, &field_type))
                 };
-                // let sub_aggregation = sub_agg_prototype.clone();
+                let sub_aggregation = sub_agg_prototype.clone();
 
                 Ok(SegmentRangeAndBucketEntry {
                     range: range.range.clone(),
                     bucket: SegmentRangeBucketEntry {
                         doc_count: 0,
-                        bucket_id,
+                        sub_aggregation,
                         key,
                         from,
                         to,
@@ -426,19 +339,26 @@ impl<B: SubAggBuffer> SegmentRangeCollector<B> {
             })
             .collect::<crate::Result<_>>()?;
 
-        self.limits.add_memory_consumed(
+        req_data.context.limits.add_memory_consumed(
             buckets.len() as u64 * std::mem::size_of::<SegmentRangeAndBucketEntry>() as u64,
         )?;
-        Ok(buckets)
+
+        Ok(SegmentRangeCollector {
+            buckets,
+            column_type: field_type,
+            accessor_idx,
+        })
+    }
+
+    #[inline]
+    fn get_bucket_pos(&self, val: u64) -> usize {
+        let pos = self
+            .buckets
+            .binary_search_by_key(&val, |probe| probe.range.start)
+            .unwrap_or_else(|pos| pos - 1);
+        debug_assert!(self.buckets[pos].range.contains(&val));
+        pos
     }
-}
-#[inline]
-fn get_bucket_pos(val: u64, buckets: &[SegmentRangeAndBucketEntry]) -> usize {
-    let pos = buckets
-        .binary_search_by_key(&val, |probe| probe.range.start)
-        .unwrap_or_else(|pos| pos - 1);
-    debug_assert!(buckets[pos].range.contains(&val));
-    pos
 }
 
 /// Converts the user provided f64 range value to fast field value space.
@@ -536,7 +456,7 @@ pub(crate) fn range_to_string(
             let val = i64::from_u64(val);
             format_date(val)
         } else {
-            Ok(f64_from_fastfield_u64(val, *field_type).to_string())
+            Ok(f64_from_fastfield_u64(val, field_type).to_string())
         }
     };
 
@@ -566,7 +486,7 @@ mod tests {
     pub fn get_collector_from_ranges(
         ranges: Vec<RangeAggregationRange>,
         field_type: ColumnType,
-    ) -> SegmentRangeCollector<HighCardSubAggBuffer> {
+    ) -> SegmentRangeCollector {
         let req = RangeAggregation {
             field: "dummy".to_string(),
             ranges,
@@ -586,33 +506,30 @@ mod tests {
                 let to = if range.range.end == u64::MAX {
                     None
                 } else {
-                    Some(f64_from_fastfield_u64(range.range.end, field_type))
+                    Some(f64_from_fastfield_u64(range.range.end, &field_type))
                 };
                 let from = if range.range.start == u64::MIN {
                     None
                 } else {
-                    Some(f64_from_fastfield_u64(range.range.start, field_type))
+                    Some(f64_from_fastfield_u64(range.range.start, &field_type))
                 };
                 SegmentRangeAndBucketEntry {
                     range: range.range.clone(),
                     bucket: SegmentRangeBucketEntry {
                         doc_count: 0,
+                        sub_aggregation: None,
                         key,
                         from,
                         to,
-                        bucket_id: 0,
                     },
                 }
             })
             .collect();
 
         SegmentRangeCollector {
-            parent_buckets: vec![buckets],
+            buckets,
             column_type: field_type,
             accessor_idx: 0,
-            sub_agg: None,
-            bucket_id_provider: Default::default(),
-            limits: AggregationLimitsGuard::default(),
         }
     }
 
@@ -859,7 +776,7 @@ mod tests {
         let buckets = vec![(10f64..20f64).into(), (30f64..40f64).into()];
         let collector = get_collector_from_ranges(buckets, ColumnType::F64);
 
-        let buckets = collector.parent_buckets[0].clone();
+        let buckets = collector.buckets;
         assert_eq!(buckets[0].range.start, u64::MIN);
         assert_eq!(buckets[0].range.end, 10f64.to_u64());
         assert_eq!(buckets[1].range.start, 10f64.to_u64());
@@ -882,7 +799,7 @@ mod tests {
         ];
         let collector = get_collector_from_ranges(buckets, ColumnType::F64);
 
-        let buckets = collector.parent_buckets[0].clone();
+        let buckets = collector.buckets;
         assert_eq!(buckets[0].range.start, u64::MIN);
         assert_eq!(buckets[0].range.end, 10f64.to_u64());
         assert_eq!(buckets[1].range.start, 10f64.to_u64());
@@ -897,7 +814,7 @@ mod tests {
         let buckets = vec![(-10f64..-1f64).into()];
         let collector = get_collector_from_ranges(buckets, ColumnType::F64);
 
-        let buckets = collector.parent_buckets[0].clone();
+        let buckets = collector.buckets;
         assert_eq!(&buckets[0].bucket.key.to_string(), "*--10");
         assert_eq!(&buckets[buckets.len() - 1].bucket.key.to_string(), "-1-*");
     }
@@ -906,7 +823,7 @@ mod tests {
         let buckets = vec![(0f64..10f64).into()];
         let collector = get_collector_from_ranges(buckets, ColumnType::F64);
 
-        let buckets = collector.parent_buckets[0].clone();
+        let buckets = collector.buckets;
         assert_eq!(&buckets[0].bucket.key.to_string(), "*-0");
         assert_eq!(&buckets[buckets.len() - 1].bucket.key.to_string(), "10-*");
     }
@@ -915,7 +832,7 @@ mod tests {
     fn range_binary_search_test_u64() {
         let check_ranges = |ranges: Vec<RangeAggregationRange>| {
             let collector = get_collector_from_ranges(ranges, ColumnType::U64);
-            let search = |val: u64| get_bucket_pos(val, &collector.parent_buckets[0]);
+            let search = |val: u64| collector.get_bucket_pos(val);
 
             assert_eq!(search(u64::MIN), 0);
             assert_eq!(search(9), 0);
@@ -961,7 +878,7 @@ mod tests {
         let ranges = vec![(10.0..100.0).into()];
 
         let collector = get_collector_from_ranges(ranges, ColumnType::F64);
-        let search = |val: u64| get_bucket_pos(val, &collector.parent_buckets[0]);
+        let search = |val: u64| collector.get_bucket_pos(val);
 
         assert_eq!(search(u64::MIN), 0);
         assert_eq!(search(9f64.to_u64()), 0);
@@ -973,3 +890,63 @@ mod tests {
                                              // the max value
     }
 }
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+
+    use itertools::Itertools;
+    use rand::seq::SliceRandom;
+    use rand::thread_rng;
+
+    use super::*;
+    use crate::aggregation::bucket::range::tests::get_collector_from_ranges;
+
+    const TOTAL_DOCS: u64 = 1_000_000u64;
+    const NUM_DOCS: u64 = 50_000u64;
+
+    fn get_collector_with_buckets(num_buckets: u64, num_docs: u64) -> SegmentRangeCollector {
+        let bucket_size = num_docs / num_buckets;
+        let mut buckets: Vec<RangeAggregationRange> = vec![];
+        for i in 0..num_buckets {
+            let bucket_start = (i * bucket_size) as f64;
+            buckets.push((bucket_start..bucket_start + bucket_size as f64).into())
+        }
+
+        get_collector_from_ranges(buckets, ColumnType::U64)
+    }
+
+    fn get_rand_docs(total_docs: u64, num_docs_returned: u64) -> Vec<u64> {
+        let mut rng = thread_rng();
+
+        let all_docs = (0..total_docs - 1).collect_vec();
+        let mut vals = all_docs
+            .as_slice()
+            .choose_multiple(&mut rng, num_docs_returned as usize)
+            .cloned()
+            .collect_vec();
+        vals.sort();
+        vals
+    }
+
+    fn bench_range_binary_search(b: &mut test::Bencher, num_buckets: u64) {
+        let collector = get_collector_with_buckets(num_buckets, TOTAL_DOCS);
+        let vals = get_rand_docs(TOTAL_DOCS, NUM_DOCS);
+        b.iter(|| {
+            let mut bucket_pos = 0;
+            for val in &vals {
+                bucket_pos = collector.get_bucket_pos(*val);
+            }
+            bucket_pos
+        })
+    }
+
+    #[bench]
+    fn bench_range_100_buckets(b: &mut test::Bencher) {
+        bench_range_binary_search(b, 100)
+    }
+
+    #[bench]
+    fn bench_range_10_buckets(b: &mut test::Bencher) {
+        bench_range_binary_search(b, 10)
+    }
+}

src/aggregation/bucket/term_missing_agg.rs

@@ -5,13 +5,11 @@ use crate::aggregation::agg_data::{
     build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
 };
 use crate::aggregation::bucket::term_agg::TermsAggregation;
-use crate::aggregation::buffered_sub_aggs::{BufferedSubAggs, HighCardBufferedSubAggs};
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateKey, IntermediateTermBucketEntry, IntermediateTermBucketResult,
 };
-use crate::aggregation::segment_agg_result::{BucketIdProvider, SegmentAggregationCollector};
-use crate::aggregation::BucketId;
+use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
 
 /// Special aggregation to handle missing values for term aggregations.
 /// This missing aggregation will check multiple columns for existence.
@@ -37,55 +35,41 @@ impl MissingTermAggReqData {
     }
 }
 
-#[derive(Default, Debug, Clone)]
-struct MissingCount {
-    missing_count: u32,
-    bucket_id: BucketId,
-}
-
 /// The specialized missing term aggregation.
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub struct TermMissingAgg {
+    missing_count: u32,
     accessor_idx: usize,
-    sub_agg: Option<HighCardBufferedSubAggs>,
-    /// Idx = parent bucket id, Value = missing count for that bucket
-    missing_count_per_bucket: Vec<MissingCount>,
-    bucket_id_provider: BucketIdProvider,
+    sub_agg: Option<Box<dyn SegmentAggregationCollector>>,
 }
 impl TermMissingAgg {
     pub(crate) fn new(
-        agg_data: &mut AggregationsSegmentCtx,
+        req_data: &mut AggregationsSegmentCtx,
         node: &AggRefNode,
     ) -> crate::Result<Self> {
         let has_sub_aggregations = !node.children.is_empty();
         let accessor_idx = node.idx_in_req_data;
         let sub_agg = if has_sub_aggregations {
-            let sub_aggregation = build_segment_agg_collectors(agg_data, &node.children)?;
+            let sub_aggregation = build_segment_agg_collectors(req_data, &node.children)?;
             Some(sub_aggregation)
         } else {
             None
         };
 
-        let sub_agg = sub_agg.map(BufferedSubAggs::new);
-        let bucket_id_provider = BucketIdProvider::default();
-
         Ok(Self {
             accessor_idx,
             sub_agg,
-            missing_count_per_bucket: Vec::new(),
-            bucket_id_provider,
+            ..Default::default()
         })
     }
 }
 
 impl SegmentAggregationCollector for TermMissingAgg {
     fn add_intermediate_aggregation_result(
-        &mut self,
+        self: Box<Self>,
         agg_data: &AggregationsSegmentCtx,
         results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
     ) -> crate::Result<()> {
-        self.prepare_max_bucket(parent_bucket_id, agg_data)?;
         let req_data = agg_data.get_missing_term_req_data(self.accessor_idx);
         let term_agg = &req_data.req;
         let missing = term_agg
@@ -96,16 +80,13 @@ impl SegmentAggregationCollector for TermMissingAgg {
         let mut entries: FxHashMap<IntermediateKey, IntermediateTermBucketEntry> =
             Default::default();
 
-        let missing_count = &self.missing_count_per_bucket[parent_bucket_id as usize];
         let mut missing_entry = IntermediateTermBucketEntry {
-            doc_count: missing_count.missing_count,
+            doc_count: self.missing_count,
             sub_aggregation: Default::default(),
         };
-        if let Some(sub_agg) = &mut self.sub_agg {
+        if let Some(sub_agg) = self.sub_agg {
             let mut res = IntermediateAggregationResults::default();
-            sub_agg
-                .get_sub_agg_collector()
-                .add_intermediate_aggregation_result(agg_data, &mut res, missing_count.bucket_id)?;
+            sub_agg.add_intermediate_aggregation_result(agg_data, &mut res)?;
             missing_entry.sub_aggregation = res;
         }
         entries.insert(missing.into(), missing_entry);
@@ -128,66 +109,33 @@ impl SegmentAggregationCollector for TermMissingAgg {
 
     fn collect(
         &mut self,
-        parent_bucket_id: BucketId,
+        doc: crate::DocId,
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        let req_data = agg_data.get_missing_term_req_data(self.accessor_idx);
+        let has_value = req_data
+            .accessors
+            .iter()
+            .any(|(acc, _)| acc.index.has_value(doc));
+        if !has_value {
+            self.missing_count += 1;
+            if let Some(sub_agg) = self.sub_agg.as_mut() {
+                sub_agg.collect(doc, agg_data)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn collect_block(
+        &mut self,
         docs: &[crate::DocId],
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
-        let bucket = &mut self.missing_count_per_bucket[parent_bucket_id as usize];
-        let req_data = agg_data.get_missing_term_req_data(self.accessor_idx);
-
         for doc in docs {
-            let doc = *doc;
-            let has_value = req_data
-                .accessors
-                .iter()
-                .any(|(acc, _)| acc.index.has_value(doc));
-            if !has_value {
-                bucket.missing_count += 1;
-
-                if let Some(sub_agg) = self.sub_agg.as_mut() {
-                    sub_agg.push(bucket.bucket_id, doc);
-                }
-            }
-        }
-
-        if let Some(sub_agg) = self.sub_agg.as_mut() {
-            sub_agg.check_flush_local(agg_data)?;
+            self.collect(*doc, agg_data)?;
         }
         Ok(())
     }
-
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        while self.missing_count_per_bucket.len() <= max_bucket as usize {
-            let bucket_id = self.bucket_id_provider.next_bucket_id();
-            self.missing_count_per_bucket.push(MissingCount {
-                missing_count: 0,
-                bucket_id,
-            });
-        }
-        Ok(())
-    }
-
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        if let Some(sub_agg) = self.sub_agg.as_mut() {
-            sub_agg.flush(agg_data)?;
-        }
-        Ok(())
-    }
-
-    fn compute_metric_value(
-        &self,
-        _bucket_id: BucketId,
-        _sub_agg_name: &str,
-        _sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        // TODO: forward to `sub_agg` for nested order paths (`missing_agg>metric`).
-        None
-    }
 }
 
 #[cfg(test)]

src/aggregation/buf_collector.rs

@@ -0,0 +1,87 @@
+use super::intermediate_agg_result::IntermediateAggregationResults;
+use super::segment_agg_result::SegmentAggregationCollector;
+use crate::aggregation::agg_data::AggregationsSegmentCtx;
+use crate::DocId;
+
+#[cfg(test)]
+pub(crate) const DOC_BLOCK_SIZE: usize = 64;
+
+#[cfg(not(test))]
+pub(crate) const DOC_BLOCK_SIZE: usize = 256;
+
+pub(crate) type DocBlock = [DocId; DOC_BLOCK_SIZE];
+
+/// BufAggregationCollector buffers documents before calling collect_block().
+#[derive(Clone)]
+pub(crate) struct BufAggregationCollector {
+    pub(crate) collector: Box<dyn SegmentAggregationCollector>,
+    staged_docs: DocBlock,
+    num_staged_docs: usize,
+}
+
+impl std::fmt::Debug for BufAggregationCollector {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("SegmentAggregationResultsCollector")
+            .field("staged_docs", &&self.staged_docs[..self.num_staged_docs])
+            .field("num_staged_docs", &self.num_staged_docs)
+            .finish()
+    }
+}
+
+impl BufAggregationCollector {
+    pub fn new(collector: Box<dyn SegmentAggregationCollector>) -> Self {
+        Self {
+            collector,
+            num_staged_docs: 0,
+            staged_docs: [0; DOC_BLOCK_SIZE],
+        }
+    }
+}
+
+impl SegmentAggregationCollector for BufAggregationCollector {
+    #[inline]
+    fn add_intermediate_aggregation_result(
+        self: Box<Self>,
+        agg_data: &AggregationsSegmentCtx,
+        results: &mut IntermediateAggregationResults,
+    ) -> crate::Result<()> {
+        Box::new(self.collector).add_intermediate_aggregation_result(agg_data, results)
+    }
+
+    #[inline]
+    fn collect(
+        &mut self,
+        doc: crate::DocId,
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        self.staged_docs[self.num_staged_docs] = doc;
+        self.num_staged_docs += 1;
+        if self.num_staged_docs == self.staged_docs.len() {
+            self.collector
+                .collect_block(&self.staged_docs[..self.num_staged_docs], agg_data)?;
+            self.num_staged_docs = 0;
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn collect_block(
+        &mut self,
+        docs: &[crate::DocId],
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        self.collector.collect_block(docs, agg_data)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+        self.collector
+            .collect_block(&self.staged_docs[..self.num_staged_docs], agg_data)?;
+        self.num_staged_docs = 0;
+
+        self.collector.flush(agg_data)?;
+
+        Ok(())
+    }
+}

src/aggregation/buffered_sub_aggs.rs

@@ -1,245 +0,0 @@
-use std::fmt::Debug;
-
-use super::segment_agg_result::SegmentAggregationCollector;
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
-use crate::aggregation::bucket::MAX_NUM_TERMS_FOR_VEC;
-use crate::aggregation::BucketId;
-use crate::DocId;
-
-/// A buffer for sub-aggregations, storing doc ids per bucket id.
-/// Depending on the cardinality of the parent aggregation, we use different
-/// storage strategies.
-///
-/// ## Low Cardinality
-/// Cardinality here refers to the number of unique flattened buckets that can be created
-/// by the parent aggregation.
-/// Flattened buckets are the result of combining all buckets per collector
-/// into a single list of buckets, where each bucket is identified by its BucketId.
-///
-/// ## Usage
-/// Since this is caching for sub-aggregations, it is only used by bucket
-/// aggregations.
-///
-/// TODO: consider using a more advanced data structure for high cardinality
-/// aggregations.
-/// What this datastructure does in general is to group docs by bucket id.
-#[derive(Debug)]
-pub(crate) struct BufferedSubAggs<B: SubAggBuffer> {
-    buffer: B,
-    sub_agg_collector: Box<dyn SegmentAggregationCollector>,
-    num_docs: usize,
-}
-
-pub type LowCardBufferedSubAggs = BufferedSubAggs<LowCardSubAggBuffer>;
-pub type HighCardBufferedSubAggs = BufferedSubAggs<HighCardSubAggBuffer>;
-
-const FLUSH_THRESHOLD: usize = 2048;
-
-/// A trait for buffering sub-aggregation doc ids per bucket id.
-/// Different implementations can be used depending on the cardinality
-/// of the parent aggregation.
-pub trait SubAggBuffer: Debug {
-    fn new() -> Self;
-    fn push(&mut self, bucket_id: BucketId, doc_id: DocId);
-    fn flush_local(
-        &mut self,
-        sub_agg: &mut Box<dyn SegmentAggregationCollector>,
-        agg_data: &mut AggregationsSegmentCtx,
-        force: bool,
-    ) -> crate::Result<()>;
-}
-
-impl<Backend: SubAggBuffer + Debug> BufferedSubAggs<Backend> {
-    pub fn new(sub_agg: Box<dyn SegmentAggregationCollector>) -> Self {
-        Self {
-            buffer: Backend::new(),
-            sub_agg_collector: sub_agg,
-            num_docs: 0,
-        }
-    }
-
-    pub fn get_sub_agg_collector(&mut self) -> &mut dyn SegmentAggregationCollector {
-        &mut *self.sub_agg_collector
-    }
-
-    #[inline]
-    pub fn push(&mut self, bucket_id: BucketId, doc_id: DocId) {
-        self.buffer.push(bucket_id, doc_id);
-        self.num_docs += 1;
-    }
-
-    /// Check if we need to flush based on the number of documents cached.
-    /// If so, flushes the cache to the provided aggregation collector.
-    pub fn check_flush_local(
-        &mut self,
-        agg_data: &mut AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        if self.num_docs >= FLUSH_THRESHOLD {
-            self.buffer
-                .flush_local(&mut self.sub_agg_collector, agg_data, false)?;
-            self.num_docs = 0;
-        }
-        Ok(())
-    }
-
-    /// Note: this _does_ flush the sub aggregations.
-    pub fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        if self.num_docs != 0 {
-            self.buffer
-                .flush_local(&mut self.sub_agg_collector, agg_data, true)?;
-            self.num_docs = 0;
-        }
-        self.sub_agg_collector.flush(agg_data)?;
-        Ok(())
-    }
-}
-
-/// Number of partitions for high cardinality sub-aggregation buffer.
-const NUM_PARTITIONS: usize = 16;
-
-#[derive(Debug)]
-pub(crate) struct HighCardSubAggBuffer {
-    /// This weird partitioning is used to do some cheap grouping on the bucket ids.
-    /// bucket ids are dense, e.g. when we don't detect the cardinality as low cardinality,
-    /// but there are just 16 bucket ids, each bucket id will go to its own partition.
-    ///
-    /// We want to keep this cheap, because high cardinality aggregations can have a lot of
-    /// buckets, and there may be nothing to group.
-    partitions: Box<[PartitionEntry; NUM_PARTITIONS]>,
-}
-
-impl HighCardSubAggBuffer {
-    #[inline]
-    fn clear(&mut self) {
-        for partition in self.partitions.iter_mut() {
-            partition.clear();
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-struct PartitionEntry {
-    bucket_ids: Vec<BucketId>,
-    docs: Vec<DocId>,
-}
-
-impl PartitionEntry {
-    #[inline]
-    fn clear(&mut self) {
-        self.bucket_ids.clear();
-        self.docs.clear();
-    }
-}
-
-impl SubAggBuffer for HighCardSubAggBuffer {
-    fn new() -> Self {
-        Self {
-            partitions: Box::new(core::array::from_fn(|_| PartitionEntry::default())),
-        }
-    }
-
-    fn push(&mut self, bucket_id: BucketId, doc_id: DocId) {
-        let idx = bucket_id % NUM_PARTITIONS as u32;
-        let slot = &mut self.partitions[idx as usize];
-        slot.bucket_ids.push(bucket_id);
-        slot.docs.push(doc_id);
-    }
-
-    fn flush_local(
-        &mut self,
-        sub_agg: &mut Box<dyn SegmentAggregationCollector>,
-        agg_data: &mut AggregationsSegmentCtx,
-        _force: bool,
-    ) -> crate::Result<()> {
-        let mut max_bucket = 0u32;
-        for partition in self.partitions.iter() {
-            if let Some(&local_max) = partition.bucket_ids.iter().max() {
-                max_bucket = max_bucket.max(local_max);
-            }
-        }
-
-        sub_agg.prepare_max_bucket(max_bucket, agg_data)?;
-
-        for slot in self.partitions.iter() {
-            if !slot.bucket_ids.is_empty() {
-                // Reduce dynamic dispatch overhead by collecting a full partition in one call.
-                sub_agg.collect_multiple(&slot.bucket_ids, &slot.docs, agg_data)?;
-            }
-        }
-
-        self.clear();
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct LowCardSubAggBuffer {
-    /// Buffer doc ids per bucket for sub-aggregations.
-    ///
-    /// The outer Vec is indexed by BucketId.
-    per_bucket_docs: Vec<Vec<DocId>>,
-}
-
-impl LowCardSubAggBuffer {
-    #[inline]
-    fn clear(&mut self) {
-        for v in &mut self.per_bucket_docs {
-            v.clear();
-        }
-    }
-}
-
-impl SubAggBuffer for LowCardSubAggBuffer {
-    fn new() -> Self {
-        Self {
-            per_bucket_docs: Vec::new(),
-        }
-    }
-
-    fn push(&mut self, bucket_id: BucketId, doc_id: DocId) {
-        let idx = bucket_id as usize;
-        if self.per_bucket_docs.len() <= idx {
-            self.per_bucket_docs.resize_with(idx + 1, Vec::new);
-        }
-        self.per_bucket_docs[idx].push(doc_id);
-    }
-
-    fn flush_local(
-        &mut self,
-        sub_agg: &mut Box<dyn SegmentAggregationCollector>,
-        agg_data: &mut AggregationsSegmentCtx,
-        force: bool,
-    ) -> crate::Result<()> {
-        // Pre-aggregated: call collect per bucket.
-        let max_bucket = (self.per_bucket_docs.len() as BucketId).saturating_sub(1);
-        sub_agg.prepare_max_bucket(max_bucket, agg_data)?;
-        // The threshold above which we flush buckets individually.
-        // Note: We need to make sure that we don't lock ourselves into a situation where we hit
-        // the FLUSH_THRESHOLD, but never flush any buckets. (except the final flush)
-        let mut bucket_treshold = FLUSH_THRESHOLD / (self.per_bucket_docs.len().max(1) * 2);
-        const _: () = {
-            // MAX_NUM_TERMS_FOR_VEC threshold is used for term aggregations
-            // Note: There may be other flexible values, for other aggregations, but we can use the
-            // const value here as a upper bound. (better than nothing)
-            let bucket_treshold_limit = FLUSH_THRESHOLD / (MAX_NUM_TERMS_FOR_VEC as usize * 2);
-            assert!(
-                bucket_treshold_limit > 0,
-                "Bucket threshold must be greater than 0"
-            );
-        };
-        if force {
-            bucket_treshold = 0;
-        }
-        for (bucket_id, docs) in self
-            .per_bucket_docs
-            .iter()
-            .enumerate()
-            .filter(|(_, docs)| docs.len() > bucket_treshold)
-        {
-            sub_agg.collect(bucket_id as BucketId, docs, agg_data)?;
-        }
-
-        self.clear();
-        Ok(())
-    }
-}

src/aggregation/collector.rs

@@ -1,9 +1,9 @@
 use super::agg_req::Aggregations;
 use super::agg_result::AggregationResults;
-use super::buffered_sub_aggs::LowCardBufferedSubAggs;
+use super::buf_collector::BufAggregationCollector;
 use super::intermediate_agg_result::IntermediateAggregationResults;
+use super::segment_agg_result::SegmentAggregationCollector;
 use super::AggContextParams;
-// group buffering strategy is chosen explicitly by callers; no need to hash-group on the fly.
 use crate::aggregation::agg_data::{
     build_aggregations_data_from_req, build_segment_agg_collectors_root, AggregationsSegmentCtx,
 };
@@ -136,7 +136,7 @@ fn merge_fruits(
 /// `AggregationSegmentCollector` does the aggregation collection on a segment.
 pub struct AggregationSegmentCollector {
     aggs_with_accessor: AggregationsSegmentCtx,
-    agg_collector: LowCardBufferedSubAggs,
+    agg_collector: BufAggregationCollector,
     error: Option<TantivyError>,
 }
 
@@ -151,11 +151,8 @@ impl AggregationSegmentCollector {
     ) -> crate::Result<Self> {
         let mut agg_data =
             build_aggregations_data_from_req(agg, reader, segment_ordinal, context.clone())?;
-        let mut result =
-            LowCardBufferedSubAggs::new(build_segment_agg_collectors_root(&mut agg_data)?);
-        result
-            .get_sub_agg_collector()
-            .prepare_max_bucket(0, &agg_data)?; // prepare for bucket zero
+        let result =
+            BufAggregationCollector::new(build_segment_agg_collectors_root(&mut agg_data)?);
 
         Ok(AggregationSegmentCollector {
             aggs_with_accessor: agg_data,
@@ -173,31 +170,26 @@ impl SegmentCollector for AggregationSegmentCollector {
         if self.error.is_some() {
             return;
         }
-        self.agg_collector.push(0, doc);
-        match self
+        if let Err(err) = self
             .agg_collector
-            .check_flush_local(&mut self.aggs_with_accessor)
+            .collect(doc, &mut self.aggs_with_accessor)
         {
-            Ok(_) => {}
-            Err(e) => {
-                self.error = Some(e);
-            }
+            self.error = Some(err);
         }
     }
+
+    /// The query pushes the documents to the collector via this method.
+    ///
+    /// Only valid for Collectors that ignore docs
     fn collect_block(&mut self, docs: &[DocId]) {
         if self.error.is_some() {
             return;
         }
-
-        match self.agg_collector.get_sub_agg_collector().collect(
-            0,
-            docs,
-            &mut self.aggs_with_accessor,
-        ) {
-            Ok(_) => {}
-            Err(e) => {
-                self.error = Some(e);
-            }
+        if let Err(err) = self
+            .agg_collector
+            .collect_block(docs, &mut self.aggs_with_accessor)
+        {
+            self.error = Some(err);
         }
     }
 
@@ -208,13 +200,10 @@ impl SegmentCollector for AggregationSegmentCollector {
         self.agg_collector.flush(&mut self.aggs_with_accessor)?;
 
         let mut sub_aggregation_res = IntermediateAggregationResults::default();
-        self.agg_collector
-            .get_sub_agg_collector()
-            .add_intermediate_aggregation_result(
-                &self.aggs_with_accessor,
-                &mut sub_aggregation_res,
-                0,
-            )?;
+        Box::new(self.agg_collector).add_intermediate_aggregation_result(
+            &self.aggs_with_accessor,
+            &mut sub_aggregation_res,
+        )?;
 
         Ok(sub_aggregation_res)
     }

src/aggregation/intermediate_agg_result.rs

@@ -15,9 +15,8 @@ use serde::{Deserialize, Serialize};
 use super::agg_req::{Aggregation, AggregationVariants, Aggregations};
 use super::agg_result::{AggregationResult, BucketResult, MetricResult, RangeBucketEntry};
 use super::bucket::{
-    composite_intermediate_key_ordering, cut_off_buckets, get_agg_name_and_property,
-    intermediate_histogram_buckets_to_final_buckets, CompositeAggregation, GetDocCount,
-    MissingOrder, Order, OrderTarget, RangeAggregation, TermsAggregation,
+    cut_off_buckets, get_agg_name_and_property, intermediate_histogram_buckets_to_final_buckets,
+    GetDocCount, Order, OrderTarget, RangeAggregation, TermsAggregation,
 };
 use super::metric::{
     IntermediateAverage, IntermediateCount, IntermediateExtendedStats, IntermediateMax,
@@ -26,7 +25,7 @@ use super::metric::{
 use super::segment_agg_result::AggregationLimitsGuard;
 use super::{format_date, AggregationError, Key, SerializedKey};
 use crate::aggregation::agg_result::{
-    AggregationResults, BucketEntries, BucketEntry, CompositeBucketEntry, FilterBucketResult,
+    AggregationResults, BucketEntries, BucketEntry, FilterBucketResult,
 };
 use crate::aggregation::bucket::TermsAggregationInternal;
 use crate::aggregation::metric::CardinalityCollector;
@@ -91,19 +90,6 @@ impl From<IntermediateKey> for Key {
 
 impl Eq for IntermediateKey {}
 
-impl std::fmt::Display for IntermediateKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            IntermediateKey::Str(val) => f.write_str(val),
-            IntermediateKey::F64(val) => f.write_str(&val.to_string()),
-            IntermediateKey::U64(val) => f.write_str(&val.to_string()),
-            IntermediateKey::I64(val) => f.write_str(&val.to_string()),
-            IntermediateKey::Bool(val) => f.write_str(&val.to_string()),
-            IntermediateKey::IpAddr(val) => f.write_str(&val.to_string()),
-        }
-    }
-}
-
 impl std::hash::Hash for IntermediateKey {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         core::mem::discriminant(self).hash(state);
@@ -119,21 +105,6 @@ impl std::hash::Hash for IntermediateKey {
 }
 
 impl IntermediateAggregationResults {
-    /// Returns a reference to the intermediate aggregation result for the given key.
-    pub fn get(&self, key: &str) -> Option<&IntermediateAggregationResult> {
-        self.aggs_res.get(key)
-    }
-
-    /// Removes and returns the intermediate aggregation result for the given key.
-    pub fn remove(&mut self, key: &str) -> Option<IntermediateAggregationResult> {
-        self.aggs_res.remove(key)
-    }
-
-    /// Returns an iterator over the keys in the intermediate aggregation results.
-    pub fn keys(&self) -> impl Iterator<Item = &String> {
-        self.aggs_res.keys()
-    }
-
     /// Add a result
     pub fn push(&mut self, key: String, value: IntermediateAggregationResult) -> crate::Result<()> {
         let entry = self.aggs_res.entry(key);
@@ -281,11 +252,6 @@ pub(crate) fn empty_from_req(req: &Aggregation) -> IntermediateAggregationResult
             doc_count: 0,
             sub_aggregations: IntermediateAggregationResults::default(),
         }),
-        Composite(_) => {
-            IntermediateAggregationResult::Bucket(IntermediateBucketResult::Composite {
-                buckets: IntermediateCompositeBucketResult::default(),
-            })
-        }
     }
 }
 
@@ -479,11 +445,6 @@ pub enum IntermediateBucketResult {
         /// Sub-aggregation results
         sub_aggregations: IntermediateAggregationResults,
     },
-    /// Composite aggregation
-    Composite {
-        /// The composite buckets
-        buckets: IntermediateCompositeBucketResult,
-    },
 }
 
 impl IntermediateBucketResult {
@@ -579,13 +540,6 @@ impl IntermediateBucketResult {
                     sub_aggregations: final_sub_aggregations,
                 }))
             }
-            IntermediateBucketResult::Composite { buckets } => {
-                let composite_req = req
-                    .agg
-                    .as_composite()
-                    .expect("unexpected aggregation, expected composite aggregation");
-                buckets.into_final_result(composite_req, req.sub_aggregation(), limits)
-            }
         }
     }
 
@@ -652,16 +606,6 @@ impl IntermediateBucketResult {
                 *doc_count_left += doc_count_right;
                 sub_aggs_left.merge_fruits(sub_aggs_right)?;
             }
-            (
-                IntermediateBucketResult::Composite {
-                    buckets: composite_left,
-                },
-                IntermediateBucketResult::Composite {
-                    buckets: composite_right,
-                },
-            ) => {
-                composite_left.merge_fruits(composite_right)?;
-            }
             (IntermediateBucketResult::Range(_), _) => {
                 panic!("try merge on different types")
             }
@@ -674,9 +618,6 @@ impl IntermediateBucketResult {
             (IntermediateBucketResult::Filter { .. }, _) => {
                 panic!("try merge on different types")
             }
-            (IntermediateBucketResult::Composite { .. }, _) => {
-                panic!("try merge on different types")
-            }
         }
         Ok(())
     }
@@ -698,21 +639,6 @@ pub struct IntermediateTermBucketResult {
 }
 
 impl IntermediateTermBucketResult {
-    /// Returns a reference to the map of bucket entries keyed by [`IntermediateKey`].
-    pub fn entries(&self) -> &FxHashMap<IntermediateKey, IntermediateTermBucketEntry> {
-        &self.entries
-    }
-
-    /// Returns the count of documents not included in the returned buckets.
-    pub fn sum_other_doc_count(&self) -> u64 {
-        self.sum_other_doc_count
-    }
-
-    /// Returns the upper bound of the error on document counts in the returned buckets.
-    pub fn doc_count_error_upper_bound(&self) -> u64 {
-        self.doc_count_error_upper_bound
-    }
-
     pub(crate) fn into_final_result(
         self,
         req: &TermsAggregation,
@@ -866,7 +792,7 @@ pub struct IntermediateRangeBucketEntry {
     /// The number of documents in the bucket.
     pub doc_count: u64,
     /// The sub_aggregation in this bucket.
-    pub sub_aggregation_res: IntermediateAggregationResults,
+    pub sub_aggregation: IntermediateAggregationResults,
     /// The from range of the bucket. Equals `f64::MIN` when `None`.
     pub from: Option<f64>,
     /// The to range of the bucket. Equals `f64::MAX` when `None`.
@@ -885,7 +811,7 @@ impl IntermediateRangeBucketEntry {
             key: self.key.into(),
             doc_count: self.doc_count,
             sub_aggregation: self
-                .sub_aggregation_res
+                .sub_aggregation
                 .into_final_result_internal(req, limits)?,
             to: self.to,
             from: self.from,
@@ -894,7 +820,7 @@ impl IntermediateRangeBucketEntry {
         };
 
         // If we have a date type on the histogram buckets, we add the `key_as_string` field as
-        // rfc3339
+        // rfc339
         if column_type == Some(ColumnType::DateTime) {
             if let Some(val) = range_bucket_entry.to {
                 let key_as_string = format_date(val as i64)?;
@@ -931,8 +857,7 @@ impl MergeFruits for IntermediateTermBucketEntry {
 impl MergeFruits for IntermediateRangeBucketEntry {
     fn merge_fruits(&mut self, other: IntermediateRangeBucketEntry) -> crate::Result<()> {
         self.doc_count += other.doc_count;
-        self.sub_aggregation_res
-            .merge_fruits(other.sub_aggregation_res)?;
+        self.sub_aggregation.merge_fruits(other.sub_aggregation)?;
         Ok(())
     }
 }
@@ -945,172 +870,6 @@ impl MergeFruits for IntermediateHistogramBucketEntry {
     }
 }
 
-/// Entry for the composite bucket.
-pub type IntermediateCompositeBucketEntry = IntermediateTermBucketEntry;
-
-/// The fully typed key for composite aggregation
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum CompositeIntermediateKey {
-    /// Bool key
-    Bool(bool),
-    /// String key
-    Str(String),
-    /// Float key
-    F64(f64),
-    /// Signed integer key
-    I64(i64),
-    /// Unsigned integer key
-    U64(u64),
-    /// DateTime key, nanoseconds since epoch
-    DateTime(i64),
-    /// IP Address key
-    IpAddr(Ipv6Addr),
-    /// Missing value key
-    Null,
-}
-
-impl Eq for CompositeIntermediateKey {}
-
-impl std::hash::Hash for CompositeIntermediateKey {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        core::mem::discriminant(self).hash(state);
-        match self {
-            CompositeIntermediateKey::Bool(val) => val.hash(state),
-            CompositeIntermediateKey::Str(text) => text.hash(state),
-            CompositeIntermediateKey::F64(val) => val.to_bits().hash(state),
-            CompositeIntermediateKey::U64(val) => val.hash(state),
-            CompositeIntermediateKey::I64(val) => val.hash(state),
-            CompositeIntermediateKey::DateTime(val) => val.hash(state),
-            CompositeIntermediateKey::IpAddr(val) => val.hash(state),
-            CompositeIntermediateKey::Null => {}
-        }
-    }
-}
-
-/// Composite aggregation page.
-#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct IntermediateCompositeBucketResult {
-    pub(crate) entries: FxHashMap<Vec<CompositeIntermediateKey>, IntermediateCompositeBucketEntry>,
-    pub(crate) target_size: u32,
-    pub(crate) orders: Vec<(Order, MissingOrder)>,
-}
-
-impl IntermediateCompositeBucketResult {
-    pub(crate) fn into_final_result(
-        self,
-        req: &CompositeAggregation,
-        sub_aggregation_req: &Aggregations,
-        limits: &mut AggregationLimitsGuard,
-    ) -> crate::Result<BucketResult> {
-        let trimmed_entry_vec =
-            trim_composite_buckets(self.entries, &self.orders, self.target_size)?;
-        let after_key = trimmed_entry_vec
-            .last()
-            .map(|bucket| {
-                let (intermediate_key, _entry) = bucket;
-                intermediate_key
-                    .iter()
-                    .enumerate()
-                    .map(|(idx, intermediate_key)| {
-                        let source = &req.sources[idx];
-                        (source.name().to_string(), intermediate_key.clone().into())
-                    })
-                    .collect()
-            })
-            .unwrap_or_default();
-
-        let buckets = trimmed_entry_vec
-            .into_iter()
-            .map(|(intermediate_key, entry)| {
-                let key = intermediate_key
-                    .into_iter()
-                    .enumerate()
-                    .map(|(idx, intermediate_key)| {
-                        let source = &req.sources[idx];
-                        (source.name().to_string(), intermediate_key.into())
-                    })
-                    .collect();
-                Ok(CompositeBucketEntry {
-                    key,
-                    doc_count: entry.doc_count as u64,
-                    sub_aggregation: entry
-                        .sub_aggregation
-                        .into_final_result_internal(sub_aggregation_req, limits)?,
-                })
-            })
-            .collect::<crate::Result<Vec<_>>>()?;
-
-        Ok(BucketResult::Composite { after_key, buckets })
-    }
-
-    fn merge_fruits(&mut self, other: IntermediateCompositeBucketResult) -> crate::Result<()> {
-        merge_maps(&mut self.entries, other.entries)?;
-        if self.entries.len() as u32 > 2 * self.target_size {
-            self.trim()?;
-        }
-        Ok(())
-    }
-
-    /// Trim the composite buckets to the target size, according to the ordering.
-    pub(crate) fn trim(&mut self) -> crate::Result<()> {
-        if self.entries.len() as u32 <= self.target_size {
-            return Ok(());
-        }
-
-        let sorted_entries = trim_composite_buckets(
-            std::mem::take(&mut self.entries),
-            &self.orders,
-            self.target_size,
-        )?;
-
-        self.entries = sorted_entries.into_iter().collect();
-        Ok(())
-    }
-}
-
-fn trim_composite_buckets(
-    entries: FxHashMap<Vec<CompositeIntermediateKey>, IntermediateCompositeBucketEntry>,
-    orders: &[(Order, MissingOrder)],
-    target_size: u32,
-) -> crate::Result<
-    Vec<(
-        Vec<CompositeIntermediateKey>,
-        IntermediateCompositeBucketEntry,
-    )>,
-> {
-    let mut entries: Vec<_> = entries.into_iter().collect();
-    let mut sort_error: Option<TantivyError> = None;
-    entries.sort_by(|(left_key, _), (right_key, _)| {
-        if sort_error.is_some() {
-            return Ordering::Equal;
-        }
-
-        for idx in 0..orders.len() {
-            match composite_intermediate_key_ordering(
-                &left_key[idx],
-                &right_key[idx],
-                orders[idx].0,
-                orders[idx].1,
-            ) {
-                Ok(ordering) if ordering != Ordering::Equal => return ordering,
-                Ok(_) => continue,
-                Err(err) => {
-                    sort_error = Some(err);
-                    break;
-                }
-            }
-        }
-        Ordering::Equal
-    });
-
-    if let Some(err) = sort_error {
-        return Err(err);
-    }
-
-    entries.truncate(target_size as usize);
-    Ok(entries)
-}
-
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;
@@ -1128,7 +887,7 @@ mod tests {
                 IntermediateRangeBucketEntry {
                     key: IntermediateKey::Str(key.to_string()),
                     doc_count: *doc_count,
-                    sub_aggregation_res: Default::default(),
+                    sub_aggregation: Default::default(),
                     from: None,
                     to: None,
                 },
@@ -1161,7 +920,7 @@ mod tests {
                     doc_count: *doc_count,
                     from: None,
                     to: None,
-                    sub_aggregation_res: get_sub_test_tree(&[(
+                    sub_aggregation: get_sub_test_tree(&[(
                         sub_aggregation_key.to_string(),
                         *sub_aggregation_count,
                     )]),

src/aggregation/metric/average.rs

@@ -52,15 +52,11 @@ pub struct IntermediateAverage {
 
 impl IntermediateAverage {
     /// Creates a new [`IntermediateAverage`] instance from a [`SegmentStatsCollector`].
-    pub(crate) fn from_stats(stats: IntermediateStats) -> Self {
-        Self { stats }
+    pub(crate) fn from_collector(collector: SegmentStatsCollector) -> Self {
+        Self {
+            stats: collector.stats,
+        }
     }
-
-    /// Returns a reference to the underlying [`IntermediateStats`].
-    pub fn stats(&self) -> &IntermediateStats {
-        &self.stats
-    }
-
     /// Merges the other intermediate result into self.
     pub fn merge_fruits(&mut self, other: IntermediateAverage) {
         self.stats.merge_fruits(other.stats);

src/aggregation/metric/count.rs

@@ -52,8 +52,10 @@ pub struct IntermediateCount {
 
 impl IntermediateCount {
     /// Creates a new [`IntermediateCount`] instance from a [`SegmentStatsCollector`].
-    pub(crate) fn from_stats(stats: IntermediateStats) -> Self {
-        Self { stats }
+    pub(crate) fn from_collector(collector: SegmentStatsCollector) -> Self {
+        Self {
+            stats: collector.stats,
+        }
     }
     /// Merges the other intermediate result into self.
     pub fn merge_fruits(&mut self, other: IntermediateCount) {

src/aggregation/metric/extended_stats.rs

@@ -8,9 +8,10 @@ use crate::aggregation::agg_data::AggregationsSegmentCtx;
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateMetricResult,
 };
+use crate::aggregation::metric::MetricAggReqData;
 use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
 use crate::aggregation::*;
-use crate::TantivyError;
+use crate::{DocId, TantivyError};
 
 /// A multi-value metric aggregation that computes a collection of extended statistics
 /// on numeric values that are extracted
@@ -317,28 +318,51 @@ impl IntermediateExtendedStats {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub(crate) struct SegmentExtendedStatsCollector {
-    name: String,
     missing: Option<u64>,
     field_type: ColumnType,
-    accessor: columnar::Column<u64>,
-    buckets: Vec<IntermediateExtendedStats>,
-    sigma: Option<f64>,
+    pub(crate) extended_stats: IntermediateExtendedStats,
+    pub(crate) accessor_idx: usize,
+    val_cache: Vec<u64>,
 }
 
 impl SegmentExtendedStatsCollector {
-    pub fn from_req(req: &MetricAggReqData, sigma: Option<f64>) -> Self {
-        let missing = req
-            .missing
-            .and_then(|val| f64_to_fastfield_u64(val, &req.field_type));
+    pub fn from_req(
+        field_type: ColumnType,
+        sigma: Option<f64>,
+        accessor_idx: usize,
+        missing: Option<f64>,
+    ) -> Self {
+        let missing = missing.and_then(|val| f64_to_fastfield_u64(val, &field_type));
         Self {
-            name: req.name.clone(),
-            field_type: req.field_type,
-            accessor: req.accessor.clone(),
+            field_type,
+            extended_stats: IntermediateExtendedStats::with_sigma(sigma),
+            accessor_idx,
             missing,
-            buckets: vec![IntermediateExtendedStats::with_sigma(sigma); 16],
-            sigma,
+            val_cache: Default::default(),
+        }
+    }
+    #[inline]
+    pub(crate) fn collect_block_with_field(
+        &mut self,
+        docs: &[DocId],
+        req_data: &mut MetricAggReqData,
+    ) {
+        if let Some(missing) = self.missing.as_ref() {
+            req_data.column_block_accessor.fetch_block_with_missing(
+                docs,
+                &req_data.accessor,
+                *missing,
+            );
+        } else {
+            req_data
+                .column_block_accessor
+                .fetch_block(docs, &req_data.accessor);
+        }
+        for val in req_data.column_block_accessor.iter_vals() {
+            let val1 = f64_from_fastfield_u64(val, &self.field_type);
+            self.extended_stats.collect(val1);
         }
     }
 }
@@ -346,18 +370,15 @@ impl SegmentExtendedStatsCollector {
 impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
     #[inline]
     fn add_intermediate_aggregation_result(
-        &mut self,
+        self: Box<Self>,
         agg_data: &AggregationsSegmentCtx,
         results: &mut IntermediateAggregationResults,
-        parent_bucket_id: BucketId,
     ) -> crate::Result<()> {
-        let name = self.name.clone();
-        self.prepare_max_bucket(parent_bucket_id, agg_data)?;
-        let extended_stats = std::mem::take(&mut self.buckets[parent_bucket_id as usize]);
+        let name = agg_data.get_metric_req_data(self.accessor_idx).name.clone();
         results.push(
             name,
             IntermediateAggregationResult::Metric(IntermediateMetricResult::ExtendedStats(
-                extended_stats,
+                self.extended_stats,
             )),
         )?;
 
@@ -367,58 +388,41 @@ impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
     #[inline]
     fn collect(
         &mut self,
-        parent_bucket_id: BucketId,
+        doc: crate::DocId,
+        agg_data: &mut AggregationsSegmentCtx,
+    ) -> crate::Result<()> {
+        let req_data = agg_data.get_metric_req_data(self.accessor_idx);
+        if let Some(missing) = self.missing {
+            let mut has_val = false;
+            for val in req_data.accessor.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
+                self.extended_stats.collect(val1);
+                has_val = true;
+            }
+            if !has_val {
+                self.extended_stats
+                    .collect(f64_from_fastfield_u64(missing, &self.field_type));
+            }
+        } else {
+            for val in req_data.accessor.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
+                self.extended_stats.collect(val1);
+            }
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn collect_block(
+        &mut self,
         docs: &[crate::DocId],
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
-        let mut extended_stats = self.buckets[parent_bucket_id as usize].clone();
-
-        agg_data
-            .column_block_accessor
-            .fetch_block_with_missing(docs, &self.accessor, self.missing);
-        for val in agg_data.column_block_accessor.iter_vals() {
-            let val1 = f64_from_fastfield_u64(val, self.field_type);
-            extended_stats.collect(val1);
-        }
-
-        // store back
-        self.buckets[parent_bucket_id as usize] = extended_stats;
-
+        let req_data = agg_data.get_metric_req_data_mut(self.accessor_idx);
+        self.collect_block_with_field(docs, req_data);
         Ok(())
     }
-
-    fn prepare_max_bucket(
-        &mut self,
-        max_bucket: BucketId,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        if self.buckets.len() <= max_bucket as usize {
-            self.buckets.resize_with(max_bucket as usize + 1, || {
-                IntermediateExtendedStats::with_sigma(self.sigma)
-            });
-        }
-        Ok(())
-    }
-
-    fn compute_metric_value(
-        &self,
-        bucket_id: BucketId,
-        sub_agg_name: &str,
-        sub_agg_property: &str,
-        _agg_data: &AggregationsSegmentCtx,
-    ) -> Option<f64> {
-        if self.name != sub_agg_name {
-            return None;
-        }
-        let extended = self.buckets.get(bucket_id as usize)?;
-        // Finalize is a pure read of accumulators — calling it here for the cutoff sort
-        // doesn't disturb the eventual intermediate result.
-        extended
-            .finalize()
-            .get_value(sub_agg_property)
-            .ok()
-            .flatten()
-    }
 }
 
 #[cfg(test)]

src/aggregation/metric/max.rs

@@ -52,8 +52,10 @@ pub struct IntermediateMax {
 
 impl IntermediateMax {
     /// Creates a new [`IntermediateMax`] instance from a [`SegmentStatsCollector`].
-    pub(crate) fn from_stats(stats: IntermediateStats) -> Self {
-        Self { stats }
+    pub(crate) fn from_collector(collector: SegmentStatsCollector) -> Self {
+        Self {
+            stats: collector.stats,
+        }
     }
     /// Merges the other intermediate result into self.
     pub fn merge_fruits(&mut self, other: IntermediateMax) {

src/aggregation/metric/min.rs

@@ -52,8 +52,10 @@ pub struct IntermediateMin {
 
 impl IntermediateMin {
     /// Creates a new [`IntermediateMin`] instance from a [`SegmentStatsCollector`].
-    pub(crate) fn from_stats(stats: IntermediateStats) -> Self {
-        Self { stats }
+    pub(crate) fn from_collector(collector: SegmentStatsCollector) -> Self {
+        Self {
+            stats: collector.stats,
+        }
     }
     /// Merges the other intermediate result into self.
     pub fn merge_fruits(&mut self, other: IntermediateMin) {