chore: Release

CHANGELOG.md

@@ -1,34 +1,6 @@
-Tantivy 0.25
+Tantivy 0.23 - Unreleased
 ================================
-
-## Bugfixes
-- fix union performance regression in tantivy 0.24 [#2663](https://github.com/quickwit-oss/tantivy/pull/2663)(@PSeitz)
-- make zstd optional in sstable [#2633](https://github.com/quickwit-oss/tantivy/pull/2633)(@Parth)
-- Fix TopDocs::order_by_string_fast_field for asc order [#2672](https://github.com/quickwit-oss/tantivy/pull/2672)(@stuhood @PSeitz)
-
-## Features/Improvements
-- add docs/example and Vec<u32> values to sstable [#2660](https://github.com/quickwit-oss/tantivy/pull/2660)(@PSeitz)
-- Add string fast field support to `TopDocs`. [#2642](https://github.com/quickwit-oss/tantivy/pull/2642)(@stuhood)
-- update edition to 2024 [#2620](https://github.com/quickwit-oss/tantivy/pull/2620)(@PSeitz)
-- Allow optional spaces between the field name and the value in the query parser [#2678](https://github.com/quickwit-oss/tantivy/pull/2678)(@Darkheir)
-- Support mixed field types in query parser [#2676](https://github.com/quickwit-oss/tantivy/pull/2676)(@trinity-1686a)
-- Add per-field size details [#2679](https://github.com/quickwit-oss/tantivy/pull/2679)(@fulmicoton)
-
-Tantivy 0.24.2
-================================
-- Fix TopNComputer for reverse order. [#2672](https://github.com/quickwit-oss/tantivy/pull/2672)(@stuhood @PSeitz) 
-
-Affected queries are [order_by_fast_field](https://docs.rs/tantivy/latest/tantivy/collector/struct.TopDocs.html#method.order_by_fast_field) and
-[order_by_u64_field](https://docs.rs/tantivy/latest/tantivy/collector/struct.TopDocs.html#method.order_by_u64_field)
-for `Order::Asc`
-
-Tantivy 0.24.1
-================================
-- Fix: bump required rust version to 1.81
-  
-Tantivy 0.24
-================================
-Tantivy 0.24 will be backwards compatible with indices created with v0.22 and v0.21. The new minimum rust version will be 1.75. Tantivy 0.23 will be skipped.
+Tantivy 0.23 will be backwards compatible with indices created with v0.22 and v0.21. The new minimum rust version will be 1.75.
 
 #### Bugfixes
 - fix potential endless loop in merge [#2457](https://github.com/quickwit-oss/tantivy/pull/2457)(@PSeitz)
@@ -108,14 +80,6 @@ This will slightly increase space and access time. [#2439](https://github.com/qu
 - Fix trait bound of StoreReader::iter [#2360](https://github.com/quickwit-oss/tantivy/pull/2360)(@adamreichold)
 - remove read_postings_no_deletes [#2526](https://github.com/quickwit-oss/tantivy/pull/2526)(@PSeitz)
 
-Tantivy 0.22.1
-================================
-- Fix TopNComputer for reverse order. [#2672](https://github.com/quickwit-oss/tantivy/pull/2672)(@stuhood @PSeitz) 
-
-Affected queries are [order_by_fast_field](https://docs.rs/tantivy/latest/tantivy/collector/struct.TopDocs.html#method.order_by_fast_field) and
-[order_by_u64_field](https://docs.rs/tantivy/latest/tantivy/collector/struct.TopDocs.html#method.order_by_u64_field)
-for `Order::Asc`
-
 Tantivy 0.22
 ================================
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy"
-version = "0.25.0"
+version = "0.24.0"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = ["database-implementations", "data-structures"]
@@ -11,7 +11,7 @@ repository = "https://github.com/quickwit-oss/tantivy"
 readme = "README.md"
 keywords = ["search", "information", "retrieval"]
 edition = "2021"
-rust-version = "1.85"
+rust-version = "1.75"
 exclude = ["benches/*.json", "benches/*.txt"]
 
 [dependencies]
@@ -33,7 +33,7 @@ tempfile = { version = "3.12.0", optional = true }
 log = "0.4.16"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
-fs4 = { version = "0.13.1", optional = true }
+fs4 = { version = "0.8.0", optional = true }
 levenshtein_automata = "0.2.1"
 uuid = { version = "1.0.0", features = ["v4", "serde"] }
 crossbeam-channel = "0.5.4"
@@ -57,19 +57,18 @@ measure_time = "0.9.0"
 arc-swap = "1.5.0"
 bon = "3.3.1"
 
-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" }
+columnar = { version = "0.5", path = "./columnar", package = "tantivy-columnar" }
+sstable = { version = "0.5", path = "./sstable", package = "tantivy-sstable", optional = true }
+stacker = { version = "0.5", path = "./stacker", package = "tantivy-stacker" }
+query-grammar = { version = "0.24.0", path = "./query-grammar", package = "tantivy-query-grammar" }
+tantivy-bitpacker = { version = "0.8", path = "./bitpacker" }
+common = { version = "0.9", path = "./common/", package = "tantivy-common" }
+tokenizer-api = { version = "0.5", 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"
-typetag = "0.2.21"
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"
@@ -88,7 +87,7 @@ more-asserts = "0.3.1"
 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]
@@ -113,16 +112,13 @@ debug-assertions = true
 overflow-checks = true
 
 [features]
-default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression"]
+default = ["mmap", "stopwords", "lz4-compression"]
 mmap = ["fs4", "tempfile", "memmap2"]
 stopwords = []
 
 lz4-compression = ["lz4_flex"]
 zstd-compression = ["zstd"]
 
-# enable zstd-compression in columnar (and sstable)
-columnar-zstd-compression = ["columnar/zstd-compression"]
-
 failpoints = ["fail", "fail/failpoints"]
 unstable = []                            # useful for benches.
 
@@ -168,11 +164,3 @@ harness = false
 [[bench]]
 name = "agg_bench"
 harness = false
-
-[[bench]]
-name = "exists_json"
-harness = false
-
-[[bench]]
-name = "and_or_queries"
-harness = false

README.md

@@ -23,6 +23,8 @@ performance for different types of queries/collections.
 
 Your mileage WILL vary depending on the nature of queries and their load.
 
+<img src="doc/assets/images/searchbenchmark.png">
+
 Details about the benchmark can be found at this [repository](https://github.com/quickwit-oss/search-benchmark-game).
 
 ## Features

RELEASE.md

@@ -1,4 +1,4 @@
-# Releasing a new Tantivy Version
+# Release a new Tantivy Version
 
 ## Steps
 
@@ -10,29 +10,12 @@
 6. Set git tag with new version
 
 
-[`cargo-release`](https://github.com/crate-ci/cargo-release) will help us with steps 1-5:
+In conjucation with `cargo-release` Steps 1-4 (I'm not sure if the change detection works):
+Set new packages to version 0.0.0
 
 Replace prev-tag-name
 ```bash
-cargo release --workspace --no-publish -v --prev-tag-name 0.24 --push-remote origin minor --no-tag
+cargo release --workspace --no-publish -v --prev-tag-name 0.19 --push-remote origin minor --no-tag --execute
 ```
 
-`no-tag` or it will create tags for all the subpackages
-
-cargo release will _not_ ignore unchanged packages, but it will print warnings for them.
-e.g. "warning: updating ownedbytes to 0.10.0 despite no changes made since tag 0.24"
-
-We need to manually ignore these unchanged packages
-```bash
-cargo release --workspace --no-publish -v --prev-tag-name 0.24 --push-remote origin minor --no-tag --exclude tokenizer-api
-```
-
-Add `--execute` to actually publish the packages, otherwise it will only print the commands that would be run.
-
-### Tag Version
-```bash
-git tag 0.25.0
-git push upstream tag 0.25.0
-```
-
-
+no-tag or it will create tags for all the subpackages

benches/agg_bench.rs

@@ -71,15 +71,8 @@ fn bench_agg(mut group: InputGroup<Index>) {
     register!(group, histogram);
     register!(group, histogram_hard_bounds);
     register!(group, histogram_with_avg_sub_agg);
-    register!(group, histogram_with_term_agg_few);
     register!(group, avg_and_range_with_avg_sub_agg);
 
-    // Filter aggregation benchmarks
-    register!(group, filter_agg_all_query_count_agg);
-    register!(group, filter_agg_term_query_count_agg);
-    register!(group, filter_agg_all_query_with_sub_aggs);
-    register!(group, filter_agg_term_query_with_sub_aggs);
-
     group.run();
 }
 
@@ -346,17 +339,6 @@ fn histogram_with_avg_sub_agg(index: &Index) {
     });
     execute_agg(index, agg_req);
 }
-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" } }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
 fn avg_and_range_with_avg_sub_agg(index: &Index) {
     let agg_req = json!({
         "rangef64": {
@@ -478,61 +460,3 @@ fn get_test_index_bench(cardinality: Cardinality) -> tantivy::Result<Index> {
 
     Ok(index)
 }
-
-// Filter aggregation benchmarks
-
-fn filter_agg_all_query_count_agg(index: &Index) {
-    let agg_req = json!({
-        "filtered": {
-            "filter": "*",
-            "aggs": {
-                "count": { "value_count": { "field": "score" } }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
-
-fn filter_agg_term_query_count_agg(index: &Index) {
-    let agg_req = json!({
-        "filtered": {
-            "filter": "text:cool",
-            "aggs": {
-                "count": { "value_count": { "field": "score" } }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
-
-fn filter_agg_all_query_with_sub_aggs(index: &Index) {
-    let agg_req = json!({
-        "filtered": {
-            "filter": "*",
-            "aggs": {
-                "avg_score": { "avg": { "field": "score" } },
-                "stats_score": { "stats": { "field": "score_f64" } },
-                "terms_text": {
-                    "terms": { "field": "text_few_terms" }
-                }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}
-
-fn filter_agg_term_query_with_sub_aggs(index: &Index) {
-    let agg_req = json!({
-        "filtered": {
-            "filter": "text:cool",
-            "aggs": {
-                "avg_score": { "avg": { "field": "score" } },
-                "stats_score": { "stats": { "field": "score_f64" } },
-                "terms_text": {
-                    "terms": { "field": "text_few_terms" }
-                }
-            }
-        }
-    });
-    execute_agg(index, agg_req);
-}

benches/and_or_queries.rs

@@ -1,224 +0,0 @@
-// Benchmarks boolean conjunction queries using binggan.
-//
-// What’s measured:
-// - Or and And queries with varying selectivity (only `Term` queries for now on leafs)
-// - Nested AND/OR combinations (on multiple fields)
-// - No-scoring path using the Count collector (focus on iterator/skip performance)
-// - Top-K retrieval (k=10) using the TopDocs collector
-//
-// Corpus model:
-// - Synthetic docs; each token a/b/c is independently included per doc
-// - If none of a/b/c are included, emit a neutral filler token to keep doc length similar
-//
-// Notes:
-// - After optimization, when scoring is disabled Tantivy reads doc-only postings
-//   (IndexRecordOption::Basic), avoiding frequency decoding overhead.
-// - This bench isolates boolean iteration speed and intersection/union cost.
-// - Use `cargo bench --bench boolean_conjunction` to run.
-
-use binggan::{black_box, BenchRunner};
-use rand::prelude::*;
-use rand::rngs::StdRng;
-use rand::SeedableRng;
-use tantivy::collector::{Count, TopDocs};
-use tantivy::query::QueryParser;
-use tantivy::schema::{Schema, TEXT};
-use tantivy::{doc, Index, ReloadPolicy, Searcher};
-
-#[derive(Clone)]
-struct BenchIndex {
-    #[allow(dead_code)]
-    index: Index,
-    searcher: Searcher,
-    query_parser: QueryParser,
-}
-
-impl BenchIndex {
-    #[inline(always)]
-    fn count_query(&self, query_str: &str) -> usize {
-        let query = self.query_parser.parse_query(query_str).unwrap();
-        self.searcher.search(&query, &Count).unwrap()
-    }
-
-    #[inline(always)]
-    fn topk_len(&self, query_str: &str, k: usize) -> usize {
-        let query = self.query_parser.parse_query(query_str).unwrap();
-        self.searcher
-            .search(&query, &TopDocs::with_limit(k))
-            .unwrap()
-            .len()
-    }
-}
-
-/// Build a single index containing both fields (title, body) and
-/// return two BenchIndex views:
-/// - single_field: QueryParser defaults to only "body"
-/// - multi_field:  QueryParser defaults to ["title", "body"]
-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);
-    let f_body = schema_builder.add_text_field("body", TEXT);
-    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]);
-
-    // Populate: spread each present token 90/10 to body/title
-    {
-        let mut writer = index.writer(500_000_000).unwrap();
-        for _ in 0..num_docs {
-            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 mut title_tokens: Vec<&str> = Vec::new();
-            let mut body_tokens: Vec<&str> = Vec::new();
-            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() {
-                body_tokens.push("z");
-            }
-            writer
-                .add_document(doc!(
-                    f_title=>title_tokens.join(" "),
-                    f_body=>body_tokens.join(" ")
-                ))
-                .unwrap();
-        }
-        writer.commit().unwrap();
-    }
-
-    // Prepare reader/searcher once.
-    let reader = index
-        .reader_builder()
-        .reload_policy(ReloadPolicy::Manual)
-        .try_into()
-        .unwrap();
-    let searcher = reader.searcher();
-
-    // Build two query parsers with different default fields.
-    let qp_single = QueryParser::for_index(&index, vec![f_body]);
-    let qp_multi = QueryParser::for_index(&index, vec![f_title, f_body]);
-
-    let single_view = BenchIndex {
-        index: index.clone(),
-        searcher: searcher.clone(),
-        query_parser: qp_single,
-    };
-    let multi_view = BenchIndex {
-        index,
-        searcher,
-        query_parser: qp_multi,
-    };
-    (single_view, multi_view)
-}
-
-fn main() {
-    // 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 mut runner = BenchRunner::new();
-    for (label, n, pa, pb, pc) in scenarios {
-        let (single_view, multi_view) = build_shared_indices(n, pa, pb, pc);
-
-        // Single-field group: default field is body only
-        {
-            let mut group = runner.new_group();
-            group.set_name(format!("single_field — {}", label));
-            group.register_with_input("+a_+b_count", &single_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("+a +b"))
-            });
-            group.register_with_input("+a_+b_+c_count", &single_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("+a +b +c"))
-            });
-            group.register_with_input("+a_+b_top10", &single_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("+a +b", 10))
-            });
-            group.register_with_input("+a_+b_+c_top10", &single_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("+a +b +c", 10))
-            });
-            // OR queries
-            group.register_with_input("a_OR_b_count", &single_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("a OR b"))
-            });
-            group.register_with_input("a_OR_b_OR_c_count", &single_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("a OR b OR c"))
-            });
-            group.register_with_input("a_OR_b_top10", &single_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("a OR b", 10))
-            });
-            group.register_with_input("a_OR_b_OR_c_top10", &single_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("a OR b OR c", 10))
-            });
-            group.run();
-        }
-
-        // Multi-field group: default fields are [title, body]
-        {
-            let mut group = runner.new_group();
-            group.set_name(format!("multi_field — {}", label));
-            group.register_with_input("+a_+b_count", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("+a +b"))
-            });
-            group.register_with_input("+a_+b_+c_count", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("+a +b +c"))
-            });
-            group.register_with_input("+a_+b_top10", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("+a +b", 10))
-            });
-            group.register_with_input("+a_+b_+c_top10", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("+a +b +c", 10))
-            });
-            // OR queries
-            group.register_with_input("a_OR_b_count", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("a OR b"))
-            });
-            group.register_with_input("a_OR_b_OR_c_count", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.count_query("a OR b OR c"))
-            });
-            group.register_with_input("a_OR_b_top10", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("a OR b", 10))
-            });
-            group.register_with_input("a_OR_b_OR_c_top10", &multi_view, |benv: &BenchIndex| {
-                black_box(benv.topk_len("a OR b OR c", 10))
-            });
-            group.run();
-        }
-    }
-}

benches/exists_json.rs

@@ -1,69 +0,0 @@
-use binggan::plugins::PeakMemAllocPlugin;
-use binggan::{black_box, InputGroup, PeakMemAlloc, INSTRUMENTED_SYSTEM};
-use serde_json::json;
-use tantivy::collector::Count;
-use tantivy::query::ExistsQuery;
-use tantivy::schema::{Schema, FAST, TEXT};
-use tantivy::{doc, Index};
-
-#[global_allocator]
-pub static GLOBAL: &PeakMemAlloc<std::alloc::System> = &INSTRUMENTED_SYSTEM;
-
-fn main() {
-    let doc_count: usize = 500_000;
-    let subfield_counts: &[usize] = &[1, 2, 3, 4, 5, 6, 7, 8, 16, 256, 4096, 65536, 262144];
-
-    let indices: Vec<(String, Index)> = subfield_counts
-        .iter()
-        .map(|&sub_fields| {
-            (
-                format!("subfields={sub_fields}"),
-                build_index_with_json_subfields(doc_count, sub_fields),
-            )
-        })
-        .collect();
-
-    let mut group = InputGroup::new_with_inputs(indices);
-    group.add_plugin(PeakMemAllocPlugin::new(GLOBAL));
-
-    group.config().num_iter_group = Some(1);
-    group.config().num_iter_bench = Some(1);
-    group.register("exists_json", exists_json_union);
-
-    group.run();
-}
-
-fn exists_json_union(index: &Index) {
-    let reader = index.reader().expect("reader");
-    let searcher = reader.searcher();
-    let query = ExistsQuery::new("json".to_string(), true);
-    let count = searcher.search(&query, &Count).expect("exists search");
-    // Prevents optimizer from eliding the search
-    black_box(count);
-}
-
-fn build_index_with_json_subfields(num_docs: usize, num_subfields: usize) -> Index {
-    // Schema: single JSON field stored as FAST to support ExistsQuery.
-    let mut schema_builder = Schema::builder();
-    let json_field = schema_builder.add_json_field("json", TEXT | FAST);
-    let schema = schema_builder.build();
-
-    let index = Index::create_from_tempdir(schema).expect("create index");
-    {
-        let mut index_writer = index
-            .writer_with_num_threads(1, 200_000_000)
-            .expect("writer");
-        for i in 0..num_docs {
-            let sub = i % num_subfields;
-            // Only one subpath set per document; rotate subpaths so that
-            // no single subpath is full, but the union covers all docs.
-            let v = json!({ format!("field_{sub}"): i as u64 });
-            index_writer
-                .add_document(doc!(json_field => v))
-                .expect("add_document");
-        }
-        index_writer.commit().expect("commit");
-    }
-
-    index
-}

bitpacker/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tantivy-bitpacker"
-version = "0.9.0"
-edition = "2024"
+version = "0.8.0"
+edition = "2021"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = []

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;
@@ -138,7 +138,7 @@ impl BitUnpacker {
 
         // 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_byte_read = (end_bit_read + 7) / 8;
         assert!(
             end_byte_read <= data.len(),
             "Requested index is out of bounds."

bitpacker/src/blocked_bitpacker.rs

@@ -1,6 +1,6 @@
 use super::bitpacker::BitPacker;
 use super::compute_num_bits;
-use crate::{BitUnpacker, minmax};
+use crate::{minmax, BitUnpacker};
 
 const BLOCK_SIZE: usize = 128;
 
@@ -140,10 +140,10 @@ impl BlockedBitpacker {
     pub fn iter(&self) -> impl Iterator<Item = u64> + '_ {
         // todo performance: we could decompress a whole block and cache it instead
         let bitpacked_elems = self.offset_and_bits.len() * BLOCK_SIZE;
-
-        (0..bitpacked_elems)
+        let iter = (0..bitpacked_elems)
             .map(move |idx| self.get(idx))
-            .chain(self.buffer.iter().cloned())
+            .chain(self.buffer.iter().cloned());
+        iter
     }
 }
 

bitpacker/src/lib.rs

@@ -33,7 +33,11 @@ pub use crate::blocked_bitpacker::BlockedBitpacker;
 /// number of bits.
 pub fn compute_num_bits(n: u64) -> u8 {
     let amplitude = (64u32 - n.leading_zeros()) as u8;
-    if amplitude <= 64 - 8 { amplitude } else { 64 }
+    if amplitude <= 64 - 8 {
+        amplitude
+    } else {
+        64
+    }
 }
 
 /// Computes the (min, max) of an iterator of `PartialOrd` values.

columnar/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tantivy-columnar"
-version = "0.6.0"
-edition = "2024"
+version = "0.5.0"
+edition = "2021"
 license = "MIT"
 homepage = "https://github.com/quickwit-oss/tantivy"
 repository = "https://github.com/quickwit-oss/tantivy"
@@ -12,10 +12,10 @@ categories = ["database-implementations", "data-structures", "compression"]
 itertools = "0.14.0"
 fastdivide = "0.4.0"
 
-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/" }
+stacker = { version= "0.5", path = "../stacker", package="tantivy-stacker"}
+sstable = { version= "0.5", path = "../sstable", package = "tantivy-sstable" }
+common = { version= "0.9", path = "../common", package = "tantivy-common" }
+tantivy-bitpacker = { version= "0.8", path = "../bitpacker/" }
 serde = "1.0.152"
 downcast-rs = "2.0.1"
 
@@ -33,29 +33,6 @@ harness = false
 name = "bench_access"
 harness = false
 
-[[bench]]
-name = "bench_first_vals"
-harness = false
-
-[[bench]]
-name = "bench_values_u64"
-harness = false
-
-[[bench]]
-name = "bench_values_u128"
-harness = false
-
-[[bench]]
-name = "bench_create_column_values"
-harness = false
-
-[[bench]]
-name = "bench_column_values_get"
-harness = false
-
-[[bench]]
-name = "bench_optional_index"
-harness = false
 
 [features]
-zstd-compression = ["sstable/zstd-compression"]
+unstable = []

columnar/benches/bench_access.rs

@@ -1,4 +1,4 @@
-use binggan::{InputGroup, black_box};
+use binggan::{black_box, InputGroup};
 use common::*;
 use tantivy_columnar::Column;
 
@@ -19,7 +19,7 @@ fn main() {
 
     let mut add_card = |card1: Card| {
         inputs.push((
-            card1.to_string(),
+            format!("{card1}"),
             generate_columnar_and_open(card1, NUM_DOCS),
         ));
     };
@@ -50,7 +50,6 @@ fn bench_group(mut runner: InputGroup<Column>) {
         let mut buffer = vec![None; BLOCK_SIZE];
         for i in (0..NUM_DOCS).step_by(BLOCK_SIZE) {
             // fill docs
-            #[allow(clippy::needless_range_loop)]
             for idx in 0..BLOCK_SIZE {
                 docs[idx] = idx as u32 + i;
             }

columnar/benches/bench_column_values_get.rs

@@ -1,61 +0,0 @@
-use std::sync::Arc;
-
-use binggan::{InputGroup, black_box};
-use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
-use tantivy_columnar::ColumnValues;
-use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_column_values};
-
-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.r#gen::<u8>() as u64)
-        .collect();
-    data.push(99_000);
-    data.insert(1000, 2000);
-    data.insert(2000, 100);
-    data.insert(3000, 4100);
-    data.insert(4000, 100);
-    data.insert(5000, 800);
-    data
-}
-
-#[inline(never)]
-fn value_iter() -> impl Iterator<Item = u64> {
-    0..20_000
-}
-
-type Col = Arc<dyn ColumnValues<u64>>;
-
-fn main() {
-    let data = get_data();
-    let inputs: Vec<(String, Col)> = vec![
-        (
-            "bitpacked".to_string(),
-            serialize_and_load_u64_based_column_values(&data.as_slice(), &[CodecType::Bitpacked]),
-        ),
-        (
-            "linear".to_string(),
-            serialize_and_load_u64_based_column_values(&data.as_slice(), &[CodecType::Linear]),
-        ),
-        (
-            "blockwise_linear".to_string(),
-            serialize_and_load_u64_based_column_values(
-                &data.as_slice(),
-                &[CodecType::BlockwiseLinear],
-            ),
-        ),
-    ];
-
-    let mut group: InputGroup<Col> = InputGroup::new_with_inputs(inputs);
-
-    group.register("fastfield_get", |col: &Col| {
-        let mut sum = 0u64;
-        for pos in value_iter() {
-            sum = sum.wrapping_add(col.get_val(pos as u32));
-        }
-        black_box(sum);
-    });
-
-    group.run();
-}

columnar/benches/bench_create_column_values.rs

@@ -1,44 +0,0 @@
-use binggan::{InputGroup, black_box};
-use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
-use tantivy_columnar::column_values::{CodecType, serialize_u64_based_column_values};
-
-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.r#gen::<u8>() as u64)
-        .collect();
-    data.push(99_000);
-    data.insert(1000, 2000);
-    data.insert(2000, 100);
-    data.insert(3000, 4100);
-    data.insert(4000, 100);
-    data.insert(5000, 800);
-    data
-}
-
-fn main() {
-    let data = get_data();
-    let mut group: InputGroup<(CodecType, Vec<u64>)> = InputGroup::new_with_inputs(vec![
-        (
-            "bitpacked codec".to_string(),
-            (CodecType::Bitpacked, data.clone()),
-        ),
-        (
-            "linear codec".to_string(),
-            (CodecType::Linear, data.clone()),
-        ),
-        (
-            "blockwise linear codec".to_string(),
-            (CodecType::BlockwiseLinear, data.clone()),
-        ),
-    ]);
-
-    group.register("serialize column_values", |data| {
-        let mut buffer = Vec::new();
-        serialize_u64_based_column_values(&data.1.as_slice(), &[data.0], &mut buffer).unwrap();
-        black_box(buffer.len());
-    });
-
-    group.run();
-}

columnar/benches/bench_first_vals.rs

@@ -1,9 +1,12 @@
+#![feature(test)]
+extern crate test;
+
 use std::sync::Arc;
 
-use binggan::{InputGroup, black_box};
 use rand::prelude::*;
-use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_column_values};
+use tantivy_columnar::column_values::{serialize_and_load_u64_based_column_values, CodecType};
 use tantivy_columnar::*;
+use test::{black_box, Bencher};
 
 struct Columns {
     pub optional: Column,
@@ -65,45 +68,88 @@ pub fn serialize_and_load(column: &[u64], codec_type: CodecType) -> Arc<dyn Colu
     serialize_and_load_u64_based_column_values(&column, &[codec_type])
 }
 
-fn main() {
-    let Columns {
-        optional,
-        full,
-        multi,
-    } = get_test_columns();
-
-    let inputs = vec![
-        ("full".to_string(), full),
-        ("optional".to_string(), optional),
-        ("multi".to_string(), multi),
-    ];
-
-    let mut group = InputGroup::new_with_inputs(inputs);
-
-    group.register("first_full_scan", |column| {
+fn run_bench_on_column_full_scan(b: &mut Bencher, column: Column) {
+    let num_iter = black_box(NUM_VALUES);
+    b.iter(|| {
         let mut sum = 0u64;
-        for i in 0..NUM_VALUES as u32 {
+        for i in 0..num_iter as u32 {
             let val = column.first(i);
             sum += val.unwrap_or(0);
         }
-        black_box(sum);
+        sum
     });
-
-    group.register("first_block_fetch", |column| {
-        let mut block: Vec<Option<u64>> = vec![None; 64];
-        let fetch_docids = (0..64).collect::<Vec<_>>();
+}
+fn run_bench_on_column_block_fetch(b: &mut Bencher, column: Column) {
+    let mut block: Vec<Option<u64>> = vec![None; 64];
+    let fetch_docids = (0..64).collect::<Vec<_>>();
+    b.iter(move || {
         column.first_vals(&fetch_docids, &mut block);
-        black_box(block[0]);
+        block[0]
     });
-
-    group.register("first_block_single_calls", |column| {
-        let mut block: Vec<Option<u64>> = vec![None; 64];
-        let fetch_docids = (0..64).collect::<Vec<_>>();
+}
+fn run_bench_on_column_block_single_calls(b: &mut Bencher, column: Column) {
+    let mut block: Vec<Option<u64>> = vec![None; 64];
+    let fetch_docids = (0..64).collect::<Vec<_>>();
+    b.iter(move || {
         for i in 0..fetch_docids.len() {
             block[i] = column.first(fetch_docids[i]);
         }
-        black_box(block[0]);
+        block[0]
     });
-
-    group.run();
+}
+
+/// Column first method
+#[bench]
+fn bench_get_first_on_full_column_full_scan(b: &mut Bencher) {
+    let column = get_test_columns().full;
+    run_bench_on_column_full_scan(b, column);
+}
+
+#[bench]
+fn bench_get_first_on_optional_column_full_scan(b: &mut Bencher) {
+    let column = get_test_columns().optional;
+    run_bench_on_column_full_scan(b, column);
+}
+
+#[bench]
+fn bench_get_first_on_multi_column_full_scan(b: &mut Bencher) {
+    let column = get_test_columns().multi;
+    run_bench_on_column_full_scan(b, column);
+}
+
+/// Block fetch column accessor
+#[bench]
+fn bench_get_block_first_on_optional_column(b: &mut Bencher) {
+    let column = get_test_columns().optional;
+    run_bench_on_column_block_fetch(b, column);
+}
+
+#[bench]
+fn bench_get_block_first_on_multi_column(b: &mut Bencher) {
+    let column = get_test_columns().multi;
+    run_bench_on_column_block_fetch(b, column);
+}
+
+#[bench]
+fn bench_get_block_first_on_full_column(b: &mut Bencher) {
+    let column = get_test_columns().full;
+    run_bench_on_column_block_fetch(b, column);
+}
+
+#[bench]
+fn bench_get_block_first_on_optional_column_single_calls(b: &mut Bencher) {
+    let column = get_test_columns().optional;
+    run_bench_on_column_block_single_calls(b, column);
+}
+
+#[bench]
+fn bench_get_block_first_on_multi_column_single_calls(b: &mut Bencher) {
+    let column = get_test_columns().multi;
+    run_bench_on_column_block_single_calls(b, column);
+}
+
+#[bench]
+fn bench_get_block_first_on_full_column_single_calls(b: &mut Bencher) {
+    let column = get_test_columns().full;
+    run_bench_on_column_block_single_calls(b, column);
 }

columnar/benches/bench_merge.rs

@@ -1,7 +1,7 @@
 pub mod common;
 
 use binggan::BenchRunner;
-use common::{Card, generate_columnar_with_name};
+use common::{generate_columnar_with_name, Card};
 use tantivy_columnar::*;
 
 const NUM_DOCS: u32 = 100_000;

columnar/benches/bench_optional_index.rs

@@ -1,106 +0,0 @@
-use binggan::{InputGroup, black_box};
-use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
-use tantivy_columnar::column_index::{OptionalIndex, Set};
-
-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.gen_bool(fill_ratio))
-        .enumerate()
-        .filter(|(_pos, val)| *val)
-        .map(|(pos, _)| pos as u32)
-        .collect();
-    OptionalIndex::for_test(TOTAL_NUM_VALUES, &vals)
-}
-
-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
-}
-
-fn main() {
-    // Build separate inputs for each fill ratio.
-    let inputs: Vec<(String, OptionalIndex)> = vec![
-        ("fill=1%".to_string(), gen_optional_index(0.01)),
-        ("fill=5%".to_string(), gen_optional_index(0.05)),
-        ("fill=10%".to_string(), gen_optional_index(0.10)),
-        ("fill=50%".to_string(), gen_optional_index(0.50)),
-        ("fill=90%".to_string(), gen_optional_index(0.90)),
-    ];
-
-    let mut group: InputGroup<OptionalIndex> = InputGroup::new_with_inputs(inputs);
-
-    // Translate orig->codec (rank_if_exists) with sampling
-    group.register("orig_to_codec_10pct_hit", |codec: &OptionalIndex| {
-        black_box(walk_over_data(codec, 100));
-    });
-    group.register("orig_to_codec_1pct_hit", |codec: &OptionalIndex| {
-        black_box(walk_over_data(codec, 1000));
-    });
-    group.register("orig_to_codec_full_scan", |codec: &OptionalIndex| {
-        black_box(walk_over_data_from_positions(codec, 0..TOTAL_NUM_VALUES));
-    });
-
-    // Translate codec->orig (select/select_batch) on sampled ranks
-    fn bench_translate_codec_to_orig_util(codec: &OptionalIndex, percent_hit: f32) {
-        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()];
-        output.copy_from_slice(&idxs[..]);
-        codec.select_batch(&mut output);
-        black_box(output);
-    }
-
-    group.register("codec_to_orig_0.005pct_hit", |codec: &OptionalIndex| {
-        bench_translate_codec_to_orig_util(codec, 0.005);
-    });
-    group.register("codec_to_orig_10pct_hit", |codec: &OptionalIndex| {
-        bench_translate_codec_to_orig_util(codec, 10.0);
-    });
-    group.register("codec_to_orig_full_scan", |codec: &OptionalIndex| {
-        bench_translate_codec_to_orig_util(codec, 100.0);
-    });
-
-    group.run();
-}

columnar/benches/bench_values_u128.rs

@@ -1,12 +1,15 @@
+#![feature(test)]
+
 use std::ops::RangeInclusive;
 use std::sync::Arc;
 
-use binggan::{InputGroup, black_box};
 use common::OwnedBytes;
 use rand::rngs::StdRng;
 use rand::seq::SliceRandom;
-use rand::{Rng, SeedableRng, random};
+use rand::{random, Rng, SeedableRng};
 use tantivy_columnar::ColumnValues;
+use test::Bencher;
+extern crate test;
 
 // TODO does this make sense for IPv6 ?
 fn generate_random() -> Vec<u64> {
@@ -44,77 +47,78 @@ fn get_data_50percent_item() -> Vec<u128> {
     }
     data.push(SINGLE_ITEM);
     data.shuffle(&mut rng);
-    data.iter().map(|el| *el as u128).collect::<Vec<_>>()
+    let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
+    data
 }
 
-fn main() {
+#[bench]
+fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
     let data = get_data_50percent_item();
-    let column_range = get_u128_column_from_data(&data);
-    let column_random = get_u128_column_random();
+    let column = get_u128_column_from_data(&data);
 
-    struct Inputs {
-        data: Vec<u128>,
-        column_range: Arc<dyn ColumnValues<u128>>,
-        column_random: Arc<dyn ColumnValues<u128>>,
-    }
-
-    let inputs = Inputs {
-        data,
-        column_range,
-        column_random,
-    };
-    let mut group: InputGroup<Inputs> =
-        InputGroup::new_with_inputs(vec![("u128 benches".to_string(), inputs)]);
-
-    group.register(
-        "intfastfield_getrange_u128_50percent_hit",
-        |inp: &Inputs| {
-            let mut positions = Vec::new();
-            inp.column_range.get_row_ids_for_value_range(
-                *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
-                0..inp.data.len() as u32,
-                &mut positions,
-            );
-            black_box(positions.len());
-        },
-    );
-
-    group.register("intfastfield_getrange_u128_single_hit", |inp: &Inputs| {
+    b.iter(|| {
         let mut positions = Vec::new();
-        inp.column_range.get_row_ids_for_value_range(
+        column.get_row_ids_for_value_range(
+            *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let column = get_u128_column_from_data(&data);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_row_ids_for_value_range(
             *SINGLE_ITEM_RANGE.start() as u128..=*SINGLE_ITEM_RANGE.end() as u128,
-            0..inp.data.len() as u32,
+            0..data.len() as u32,
             &mut positions,
         );
-        black_box(positions.len());
+        positions
     });
+}
 
-    group.register("intfastfield_getrange_u128_hit_all", |inp: &Inputs| {
+#[bench]
+fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let column = get_u128_column_from_data(&data);
+
+    b.iter(|| {
         let mut positions = Vec::new();
-        inp.column_range.get_row_ids_for_value_range(
-            0..=u128::MAX,
-            0..inp.data.len() as u32,
-            &mut positions,
-        );
-        black_box(positions.len());
+        column.get_row_ids_for_value_range(0..=u128::MAX, 0..data.len() as u32, &mut positions);
+        positions
     });
+}
+// U128 RANGE END
 
-    group.register("intfastfield_scan_all_fflookup_u128", |inp: &Inputs| {
+#[bench]
+fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {
+    let column = get_u128_column_random();
+
+    b.iter(|| {
         let mut a = 0u128;
-        for i in 0u64..inp.column_random.num_vals() as u64 {
-            a += inp.column_random.get_val(i as u32);
+        for i in 0u64..column.num_vals() as u64 {
+            a += column.get_val(i as u32);
         }
-        black_box(a);
+        a
     });
+}
 
-    group.register("intfastfield_jumpy_stride5_u128", |inp: &Inputs| {
-        let n = inp.column_random.num_vals();
+#[bench]
+fn bench_intfastfield_jumpy_stride5_u128(b: &mut Bencher) {
+    let column = get_u128_column_random();
+
+    b.iter(|| {
+        let n = column.num_vals();
         let mut a = 0u128;
         for i in (0..n / 5).map(|val| val * 5) {
-            a += inp.column_random.get_val(i);
+            a += column.get_val(i);
         }
-        black_box(a);
+        a
     });
-
-    group.run();
 }

columnar/benches/bench_values_u64.rs

@@ -1,10 +1,13 @@
+#![feature(test)]
+extern crate test;
+
 use std::ops::RangeInclusive;
 use std::sync::Arc;
 
-use binggan::{InputGroup, black_box};
 use rand::prelude::*;
-use tantivy_columnar::column_values::{CodecType, serialize_and_load_u64_based_column_values};
+use tantivy_columnar::column_values::{serialize_and_load_u64_based_column_values, CodecType};
 use tantivy_columnar::*;
+use test::Bencher;
 
 // Warning: this generates the same permutation at each call
 fn generate_permutation() -> Vec<u64> {
@@ -24,11 +27,37 @@ pub fn serialize_and_load(column: &[u64], codec_type: CodecType) -> Arc<dyn Colu
     serialize_and_load_u64_based_column_values(&column, &[codec_type])
 }
 
+#[bench]
+fn bench_intfastfield_jumpy_veclookup(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    b.iter(|| {
+        let mut a = 0u64;
+        for _ in 0..n {
+            a = permutation[a as usize];
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_jumpy_fflookup_bitpacked(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut a = 0u64;
+        for _ in 0..n {
+            a = column.get_val(a as u32);
+        }
+        a
+    });
+}
+
 const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
 const SINGLE_ITEM: u64 = 90;
 const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
 const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
-
 fn get_data_50percent_item() -> Vec<u128> {
     let mut rng = StdRng::from_seed([1u8; 32]);
 
@@ -40,122 +69,135 @@ fn get_data_50percent_item() -> Vec<u128> {
     data.push(SINGLE_ITEM);
 
     data.shuffle(&mut rng);
-    data.iter().map(|el| *el as u128).collect::<Vec<_>>()
+    let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
+    data
 }
 
-type VecCol = (Vec<u64>, Arc<dyn ColumnValues<u64>>);
+// U64 RANGE START
+#[bench]
+fn bench_intfastfield_getrange_u64_50percent_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_row_ids_for_value_range(
+            FIFTY_PERCENT_RANGE,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
 
-fn bench_access() {
+#[bench]
+fn bench_intfastfield_getrange_u64_1percent_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_row_ids_for_value_range(
+            ONE_PERCENT_ITEM_RANGE,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u64_single_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_row_ids_for_value_range(SINGLE_ITEM_RANGE, 0..data.len() as u32, &mut positions);
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u64_hit_all(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_row_ids_for_value_range(0..=u64::MAX, 0..data.len() as u32, &mut positions);
+        positions
+    });
+}
+// U64 RANGE END
+
+#[bench]
+fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
     let permutation = generate_permutation();
-    let column_perm: Arc<dyn ColumnValues<u64>> =
-        serialize_and_load(&permutation, CodecType::Bitpacked);
-
-    let permutation_gcd = generate_permutation_gcd();
-    let column_perm_gcd: Arc<dyn ColumnValues<u64>> =
-        serialize_and_load(&permutation_gcd, CodecType::Bitpacked);
-
-    let mut group: InputGroup<VecCol> = InputGroup::new_with_inputs(vec![
-        (
-            "access".to_string(),
-            (permutation.clone(), column_perm.clone()),
-        ),
-        (
-            "access_gcd".to_string(),
-            (permutation_gcd.clone(), column_perm_gcd.clone()),
-        ),
-    ]);
-
-    group.register("stride7_vec", |inp: &VecCol| {
-        let n = inp.0.len();
+    let n = permutation.len();
+    b.iter(|| {
         let mut a = 0u64;
         for i in (0..n / 7).map(|val| val * 7) {
-            a += inp.0[i];
+            a += permutation[i as usize];
         }
-        black_box(a);
+        a
     });
+}
 
-    group.register("fullscan_vec", |inp: &VecCol| {
-        let mut a = 0u64;
-        for i in 0..inp.0.len() {
-            a += inp.0[i];
-        }
-        black_box(a);
-    });
-
-    group.register("stride7_column_values", |inp: &VecCol| {
-        let n = inp.1.num_vals() as usize;
-        let mut a = 0u64;
+#[bench]
+fn bench_intfastfield_stride7_fflookup(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut a = 0;
         for i in (0..n / 7).map(|val| val * 7) {
-            a += inp.1.get_val(i as u32);
+            a += column.get_val(i as u32);
         }
-        black_box(a);
+        a
     });
+}
 
-    group.register("fullscan_column_values", |inp: &VecCol| {
+#[bench]
+fn bench_intfastfield_scan_all_fflookup(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    let column_ref = column.as_ref();
+    b.iter(|| {
+        let mut a = 0u64;
+        for i in 0u32..n as u32 {
+            a += column_ref.get_val(i);
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_scan_all_fflookup_gcd(b: &mut Bencher) {
+    let permutation = generate_permutation_gcd();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
         let mut a = 0u64;
-        let n = inp.1.num_vals() as usize;
         for i in 0..n {
-            a += inp.1.get_val(i as u32);
+            a += column.get_val(i as u32);
         }
-        black_box(a);
+        a
     });
-
-    group.run();
 }
 
-fn bench_range() {
-    let data_50 = get_data_50percent_item();
-    let data_u64 = data_50.iter().map(|el| *el as u64).collect::<Vec<_>>();
-    let column_data: Arc<dyn ColumnValues<u64>> =
-        serialize_and_load(&data_u64, CodecType::Bitpacked);
-
-    let mut group: InputGroup<Arc<dyn ColumnValues<u64>>> =
-        InputGroup::new_with_inputs(vec![("dist_50pct_item".to_string(), column_data.clone())]);
-
-    group.register(
-        "fastfield_getrange_u64_50percent_hit",
-        |col: &Arc<dyn ColumnValues<u64>>| {
-            let mut positions = Vec::new();
-            col.get_row_ids_for_value_range(FIFTY_PERCENT_RANGE, 0..col.num_vals(), &mut positions);
-            black_box(positions.len());
-        },
-    );
-
-    group.register(
-        "fastfield_getrange_u64_1percent_hit",
-        |col: &Arc<dyn ColumnValues<u64>>| {
-            let mut positions = Vec::new();
-            col.get_row_ids_for_value_range(
-                ONE_PERCENT_ITEM_RANGE,
-                0..col.num_vals(),
-                &mut positions,
-            );
-            black_box(positions.len());
-        },
-    );
-
-    group.register(
-        "fastfield_getrange_u64_single_hit",
-        |col: &Arc<dyn ColumnValues<u64>>| {
-            let mut positions = Vec::new();
-            col.get_row_ids_for_value_range(SINGLE_ITEM_RANGE, 0..col.num_vals(), &mut positions);
-            black_box(positions.len());
-        },
-    );
-
-    group.register(
-        "fastfield_getrange_u64_hit_all",
-        |col: &Arc<dyn ColumnValues<u64>>| {
-            let mut positions = Vec::new();
-            col.get_row_ids_for_value_range(0..=u64::MAX, 0..col.num_vals(), &mut positions);
-            black_box(positions.len());
-        },
-    );
-
-    group.run();
-}
-
-fn main() {
-    bench_access();
-    bench_range();
+#[bench]
+fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    b.iter(|| {
+        let mut a = 0u64;
+        for i in 0..permutation.len() {
+            a += permutation[i as usize] as u64;
+        }
+        a
+    });
 }

columnar/src/block_accessor.rs

@@ -66,7 +66,7 @@ impl<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
         &'a self,
         docs: &'a [u32],
         accessor: &Column<T>,
-    ) -> impl Iterator<Item = (DocId, T)> + 'a + use<'a, T> {
+    ) -> impl Iterator<Item = (DocId, T)> + 'a {
         if accessor.index.get_cardinality().is_full() {
             docs.iter().cloned().zip(self.val_cache.iter().cloned())
         } else {

columnar/src/column/dictionary_encoded.rs

@@ -4,8 +4,8 @@ use std::{fmt, io};
 
 use sstable::{Dictionary, VoidSSTable};
 
-use crate::RowId;
 use crate::column::Column;
+use crate::RowId;
 
 /// Dictionary encoded column.
 ///

columnar/src/column/mod.rs

@@ -9,14 +9,13 @@ use std::sync::Arc;
 use common::BinarySerializable;
 pub use dictionary_encoded::{BytesColumn, StrColumn};
 pub use serialize::{
-    open_column_bytes, open_column_str, open_column_u64, open_column_u128,
-    open_column_u128_as_compact_u64, serialize_column_mappable_to_u64,
-    serialize_column_mappable_to_u128,
+    open_column_bytes, open_column_str, open_column_u128, open_column_u128_as_compact_u64,
+    open_column_u64, serialize_column_mappable_to_u128, serialize_column_mappable_to_u64,
 };
 
 use crate::column_index::{ColumnIndex, Set};
 use crate::column_values::monotonic_mapping::StrictlyMonotonicMappingToInternal;
-use crate::column_values::{ColumnValues, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, ColumnValues};
 use crate::{Cardinality, DocId, EmptyColumnValues, MonotonicallyMappableToU64, RowId};
 
 #[derive(Clone)]
@@ -114,7 +113,7 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
         }
     }
 
-    /// Translates a block of docids to row_ids.
+    /// Translates a block of docis to row_ids.
     ///
     /// returns the row_ids and the matching docids on the same index
     /// e.g.

columnar/src/column/serialize.rs

@@ -6,10 +6,10 @@ use common::OwnedBytes;
 use sstable::Dictionary;
 
 use crate::column::{BytesColumn, Column};
-use crate::column_index::{SerializableColumnIndex, serialize_column_index};
+use crate::column_index::{serialize_column_index, SerializableColumnIndex};
 use crate::column_values::{
-    CodecType, MonotonicallyMappableToU64, MonotonicallyMappableToU128,
     load_u64_based_column_values, serialize_column_values_u128, serialize_u64_based_column_values,
+    CodecType, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
 };
 use crate::iterable::Iterable;
 use crate::{StrColumn, Version};

columnar/src/column_index/merge/mod.rs

@@ -99,9 +99,9 @@ mod tests {
 
     use crate::column_index::merge::detect_cardinality;
     use crate::column_index::multivalued_index::{
-        MultiValueIndex, open_multivalued_index, serialize_multivalued_index,
+        open_multivalued_index, serialize_multivalued_index, MultiValueIndex,
     };
-    use crate::column_index::{OptionalIndex, SerializableColumnIndex, merge_column_index};
+    use crate::column_index::{merge_column_index, OptionalIndex, SerializableColumnIndex};
     use crate::{
         Cardinality, ColumnIndex, MergeRowOrder, RowAddr, RowId, ShuffleMergeOrder, StackMergeOrder,
     };

columnar/src/column_index/merge/shuffled.rs

@@ -137,8 +137,8 @@ impl Iterable<u32> for ShuffledMultivaluedIndex<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::RowAddr;
     use crate::column_index::OptionalIndex;
+    use crate::RowAddr;
 
     #[test]
     fn test_integrate_num_vals_empty() {

columnar/src/column_index/merge/stacked.rs

@@ -1,8 +1,8 @@
 use std::ops::Range;
 
-use crate::column_index::SerializableColumnIndex;
 use crate::column_index::multivalued_index::{MultiValueIndex, SerializableMultivalueIndex};
 use crate::column_index::serialize::SerializableOptionalIndex;
+use crate::column_index::SerializableColumnIndex;
 use crate::iterable::Iterable;
 use crate::{Cardinality, ColumnIndex, RowId, StackMergeOrder};
 
@@ -56,7 +56,7 @@ fn get_doc_ids_with_values<'a>(
         ColumnIndex::Full => Box::new(doc_range),
         ColumnIndex::Optional(optional_index) => Box::new(
             optional_index
-                .iter_non_null_docs()
+                .iter_docs()
                 .map(move |row| row + doc_range.start),
         ),
         ColumnIndex::Multivalued(multivalued_index) => match multivalued_index {
@@ -73,7 +73,7 @@ fn get_doc_ids_with_values<'a>(
             MultiValueIndex::MultiValueIndexV2(multivalued_index) => Box::new(
                 multivalued_index
                     .optional_index
-                    .iter_non_null_docs()
+                    .iter_docs()
                     .map(move |row| row + doc_range.start),
             ),
         },
@@ -105,11 +105,10 @@ fn get_num_values_iterator<'a>(
 ) -> Box<dyn Iterator<Item = u32> + 'a> {
     match column_index {
         ColumnIndex::Empty { .. } => Box::new(std::iter::empty()),
-        ColumnIndex::Full => Box::new(std::iter::repeat_n(1u32, num_docs as usize)),
-        ColumnIndex::Optional(optional_index) => Box::new(std::iter::repeat_n(
-            1u32,
-            optional_index.num_non_nulls() as usize,
-        )),
+        ColumnIndex::Full => Box::new(std::iter::repeat(1u32).take(num_docs as usize)),
+        ColumnIndex::Optional(optional_index) => {
+            Box::new(std::iter::repeat(1u32).take(optional_index.num_non_nulls() as usize))
+        }
         ColumnIndex::Multivalued(multivalued_index) => Box::new(
             multivalued_index
                 .get_start_index_column()
@@ -178,7 +177,7 @@ impl<'a> Iterable<RowId> for StackedOptionalIndex<'a> {
                         ColumnIndex::Full => Box::new(columnar_row_range),
                         ColumnIndex::Optional(optional_index) => Box::new(
                             optional_index
-                                .iter_non_null_docs()
+                                .iter_docs()
                                 .map(move |row_id: RowId| columnar_row_range.start + row_id),
                         ),
                         ColumnIndex::Multivalued(_) => {

columnar/src/column_index/mod.rs

@@ -14,7 +14,7 @@ pub use merge::merge_column_index;
 pub(crate) use multivalued_index::SerializableMultivalueIndex;
 pub use optional_index::{OptionalIndex, Set};
 pub use serialize::{
-    SerializableColumnIndex, SerializableOptionalIndex, open_column_index, serialize_column_index,
+    open_column_index, serialize_column_index, SerializableColumnIndex, SerializableOptionalIndex,
 };
 
 use crate::column_index::multivalued_index::MultiValueIndex;

columnar/src/column_index/multivalued_index.rs

@@ -8,7 +8,7 @@ use common::{CountingWriter, OwnedBytes};
 use super::optional_index::{open_optional_index, serialize_optional_index};
 use super::{OptionalIndex, SerializableOptionalIndex, Set};
 use crate::column_values::{
-    CodecType, ColumnValues, load_u64_based_column_values, serialize_u64_based_column_values,
+    load_u64_based_column_values, serialize_u64_based_column_values, CodecType, ColumnValues,
 };
 use crate::iterable::Iterable;
 use crate::{DocId, RowId, Version};
@@ -215,32 +215,6 @@ impl MultiValueIndex {
         }
     }
 
-    /// Returns an iterator over document ids that have at least one value.
-    pub fn iter_non_null_docs(&self) -> Box<dyn Iterator<Item = DocId> + '_> {
-        match self {
-            MultiValueIndex::MultiValueIndexV1(idx) => {
-                let mut doc: DocId = 0u32;
-                let num_docs = idx.num_docs();
-                Box::new(std::iter::from_fn(move || {
-                    // This is not the most efficient way to do this, but it's legacy code.
-                    while doc < num_docs {
-                        let cur = doc;
-                        doc += 1;
-                        let start = idx.start_index_column.get_val(cur);
-                        let end = idx.start_index_column.get_val(cur + 1);
-                        if end > start {
-                            return Some(cur);
-                        }
-                    }
-                    None
-                }))
-            }
-            MultiValueIndex::MultiValueIndexV2(idx) => {
-                Box::new(idx.optional_index.iter_non_null_docs())
-            }
-        }
-    }
-
     /// Converts a list of ranks (row ids of values) in a 1:n index to the corresponding list of
     /// docids. Positions are converted inplace to docids.
     ///

columnar/src/column_index/optional_index/mod.rs

@@ -1,4 +1,4 @@
-use std::io;
+use std::io::{self, Write};
 use std::sync::Arc;
 
 mod set;
@@ -7,11 +7,11 @@ mod set_block;
 use common::{BinarySerializable, OwnedBytes, VInt};
 pub use set::{SelectCursor, Set, SetCodec};
 use set_block::{
-    DENSE_BLOCK_NUM_BYTES, DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec,
+    DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec, DENSE_BLOCK_NUM_BYTES,
 };
 
 use crate::iterable::Iterable;
-use crate::{DocId, RowId};
+use crate::{DocId, InvalidData, RowId};
 
 /// The threshold for for number of elements after which we switch to dense block encoding.
 ///
@@ -88,7 +88,7 @@ pub struct OptionalIndex {
 
 impl Iterable<u32> for &OptionalIndex {
     fn boxed_iter(&self) -> Box<dyn Iterator<Item = u32> + '_> {
-        Box::new(self.iter_non_null_docs())
+        Box::new(self.iter_docs())
     }
 }
 
@@ -259,13 +259,11 @@ impl Set<RowId> for OptionalIndex {
 
 impl OptionalIndex {
     pub fn for_test(num_rows: RowId, row_ids: &[RowId]) -> OptionalIndex {
-        assert!(
-            row_ids
-                .last()
-                .copied()
-                .map(|last_row_id| last_row_id < num_rows)
-                .unwrap_or(true)
-        );
+        assert!(row_ids
+            .last()
+            .copied()
+            .map(|last_row_id| last_row_id < num_rows)
+            .unwrap_or(true));
         let mut buffer = Vec::new();
         serialize_optional_index(&row_ids, num_rows, &mut buffer).unwrap();
         let bytes = OwnedBytes::new(buffer);
@@ -280,9 +278,8 @@ impl OptionalIndex {
         self.num_non_null_docs
     }
 
-    pub fn iter_non_null_docs(&self) -> impl Iterator<Item = RowId> + '_ {
-        // TODO optimize. We could iterate over the blocks directly.
-        // We use the dense value ids and retrieve the doc ids via select.
+    pub fn iter_docs(&self) -> impl Iterator<Item = RowId> + '_ {
+        // TODO optimize
         let mut select_batch = self.select_cursor();
         (0..self.num_non_null_docs).map(move |rank| select_batch.select(rank))
     }
@@ -335,6 +332,38 @@ enum Block<'a> {
     Sparse(SparseBlock<'a>),
 }
 
+#[derive(Debug, Copy, Clone)]
+enum OptionalIndexCodec {
+    Dense = 0,
+    Sparse = 1,
+}
+
+impl OptionalIndexCodec {
+    fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    fn try_from_code(code: u8) -> Result<Self, InvalidData> {
+        match code {
+            0 => Ok(Self::Dense),
+            1 => Ok(Self::Sparse),
+            _ => Err(InvalidData),
+        }
+    }
+}
+
+impl BinarySerializable for OptionalIndexCodec {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
+        writer.write_all(&[self.to_code()])
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let optional_codec_code = u8::deserialize(reader)?;
+        let optional_codec = Self::try_from_code(optional_codec_code)?;
+        Ok(optional_codec)
+    }
+}
+
 fn serialize_optional_index_block(block_els: &[u16], out: &mut impl io::Write) -> io::Result<()> {
     let is_sparse = is_sparse(block_els.len() as u32);
     if is_sparse {

columnar/src/column_index/optional_index/set_block/dense.rs

@@ -2,7 +2,7 @@ use std::io::{self, Write};
 
 use common::BinarySerializable;
 
-use crate::column_index::optional_index::{ELEMENTS_PER_BLOCK, SelectCursor, Set, SetCodec};
+use crate::column_index::optional_index::{SelectCursor, Set, SetCodec, ELEMENTS_PER_BLOCK};
 
 #[inline(always)]
 fn get_bit_at(input: u64, n: u16) -> bool {

columnar/src/column_index/optional_index/set_block/mod.rs

@@ -1,7 +1,7 @@
 mod dense;
 mod sparse;
 
-pub use dense::{DENSE_BLOCK_NUM_BYTES, DenseBlock, DenseBlockCodec};
+pub use dense::{DenseBlock, DenseBlockCodec, DENSE_BLOCK_NUM_BYTES};
 pub use sparse::{SparseBlock, SparseBlockCodec};
 
 #[cfg(test)]

columnar/src/column_index/optional_index/tests.rs

@@ -164,11 +164,7 @@ fn test_optional_index_large() {
 fn test_optional_index_iter_aux(row_ids: &[RowId], num_rows: RowId) {
     let optional_index = OptionalIndex::for_test(num_rows, row_ids);
     assert_eq!(optional_index.num_docs(), num_rows);
-    assert!(
-        optional_index
-            .iter_non_null_docs()
-            .eq(row_ids.iter().copied())
-    );
+    assert!(optional_index.iter_docs().eq(row_ids.iter().copied()));
 }
 
 #[test]
@@ -223,3 +219,174 @@ 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(OwnedBytes::new(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

@@ -3,11 +3,11 @@ use std::io::Write;
 
 use common::{CountingWriter, OwnedBytes};
 
-use super::OptionalIndex;
 use super::multivalued_index::SerializableMultivalueIndex;
-use crate::column_index::ColumnIndex;
+use super::OptionalIndex;
 use crate::column_index::multivalued_index::serialize_multivalued_index;
 use crate::column_index::optional_index::serialize_optional_index;
+use crate::column_index::ColumnIndex;
 use crate::iterable::Iterable;
 use crate::{Cardinality, RowId, Version};
 

columnar/src/column_values/bench.rs

@@ -0,0 +1,139 @@
+use std::sync::Arc;
+
+use common::OwnedBytes;
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use test::{self, Bencher};
+
+use super::*;
+use crate::column_values::u64_based::*;
+
+fn get_data() -> Vec<u64> {
+    let mut rng = StdRng::seed_from_u64(2u64);
+    let mut data: Vec<_> = (100..55000_u64)
+        .map(|num| num + rng.gen::<u8>() as u64)
+        .collect();
+    data.push(99_000);
+    data.insert(1000, 2000);
+    data.insert(2000, 100);
+    data.insert(3000, 4100);
+    data.insert(4000, 100);
+    data.insert(5000, 800);
+    data
+}
+
+fn compute_stats(vals: impl Iterator<Item = u64>) -> ColumnStats {
+    let mut stats_collector = StatsCollector::default();
+    for val in vals {
+        stats_collector.collect(val);
+    }
+    stats_collector.stats()
+}
+
+#[inline(never)]
+fn value_iter() -> impl Iterator<Item = u64> {
+    0..20_000
+}
+
+fn get_reader_for_bench<Codec: ColumnCodec>(data: &[u64]) -> Codec::ColumnValues {
+    let mut bytes = Vec::new();
+    let stats = compute_stats(data.iter().cloned());
+    let mut codec_serializer = Codec::estimator();
+    for val in data {
+        codec_serializer.collect(*val);
+    }
+    codec_serializer
+        .serialize(&stats, Box::new(data.iter().copied()).as_mut(), &mut bytes)
+        .unwrap();
+
+    Codec::load(OwnedBytes::new(bytes)).unwrap()
+}
+
+fn bench_get<Codec: ColumnCodec>(b: &mut Bencher, data: &[u64]) {
+    let col = get_reader_for_bench::<Codec>(data);
+    b.iter(|| {
+        let mut sum = 0u64;
+        for pos in value_iter() {
+            let val = col.get_val(pos as u32);
+            sum = sum.wrapping_add(val);
+        }
+        sum
+    });
+}
+
+#[inline(never)]
+fn bench_get_dynamic_helper(b: &mut Bencher, col: Arc<dyn ColumnValues>) {
+    b.iter(|| {
+        let mut sum = 0u64;
+        for pos in value_iter() {
+            let val = col.get_val(pos as u32);
+            sum = sum.wrapping_add(val);
+        }
+        sum
+    });
+}
+
+fn bench_get_dynamic<Codec: ColumnCodec>(b: &mut Bencher, data: &[u64]) {
+    let col = Arc::new(get_reader_for_bench::<Codec>(data));
+    bench_get_dynamic_helper(b, col);
+}
+fn bench_create<Codec: ColumnCodec>(b: &mut Bencher, data: &[u64]) {
+    let stats = compute_stats(data.iter().cloned());
+
+    let mut bytes = Vec::new();
+    b.iter(|| {
+        bytes.clear();
+        let mut codec_serializer = Codec::estimator();
+        for val in data.iter().take(1024) {
+            codec_serializer.collect(*val);
+        }
+
+        codec_serializer.serialize(&stats, Box::new(data.iter().copied()).as_mut(), &mut bytes)
+    });
+}
+
+#[bench]
+fn bench_fastfield_bitpack_create(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_create::<BitpackedCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_linearinterpol_create(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_create::<LinearCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_multilinearinterpol_create(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_create::<BlockwiseLinearCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_bitpack_get(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get::<BitpackedCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_bitpack_get_dynamic(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get_dynamic::<BitpackedCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_linearinterpol_get(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get::<LinearCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_linearinterpol_get_dynamic(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get_dynamic::<LinearCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_multilinearinterpol_get(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get::<BlockwiseLinearCodec>(b, &data);
+}
+#[bench]
+fn bench_fastfield_multilinearinterpol_get_dynamic(b: &mut Bencher) {
+    let data: Vec<_> = get_data();
+    bench_get_dynamic::<BlockwiseLinearCodec>(b, &data);
+}

columnar/src/column_values/mod.rs

@@ -26,13 +26,13 @@ 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,
-};
 pub use u128_based::{
-    CompactSpaceU64Accessor, open_u128_as_compact_u64, open_u128_mapped,
-    serialize_column_values_u128,
+    open_u128_as_compact_u64, open_u128_mapped, serialize_column_values_u128,
+    CompactSpaceU64Accessor,
+};
+pub use u64_based::{
+    load_u64_based_column_values, serialize_and_load_u64_based_column_values,
+    serialize_u64_based_column_values, CodecType, ALL_U64_CODEC_TYPES,
 };
 pub use vec_column::VecColumn;
 
@@ -242,3 +242,6 @@ impl<T: Copy + PartialOrd + Debug + 'static> ColumnValues<T> for Arc<dyn ColumnV
             .get_row_ids_for_value_range(range, doc_id_range, positions)
     }
 }
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench;

columnar/src/column_values/monotonic_column.rs

@@ -2,8 +2,8 @@ use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Range, RangeInclusive};
 
-use crate::ColumnValues;
 use crate::column_values::monotonic_mapping::StrictlyMonotonicFn;
+use crate::ColumnValues;
 
 struct MonotonicMappingColumn<C, T, Input> {
     from_column: C,
@@ -99,10 +99,10 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::column_values::VecColumn;
     use crate::column_values::monotonic_mapping::{
         StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
     };
+    use crate::column_values::VecColumn;
 
     #[test]
     fn test_monotonic_mapping_iter() {

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

@@ -185,10 +185,10 @@ impl CompactSpaceBuilder {
         let mut covered_space = Vec::with_capacity(self.blanks.len());
 
         // beginning of the blanks
-        if let Some(first_blank_start) = self.blanks.first().map(RangeInclusive::start)
-            && *first_blank_start != 0
-        {
-            covered_space.push(0..=first_blank_start - 1);
+        if let Some(first_blank_start) = self.blanks.first().map(RangeInclusive::start) {
+            if *first_blank_start != 0 {
+                covered_space.push(0..=first_blank_start - 1);
+            }
         }
 
         // Between the blanks
@@ -202,10 +202,10 @@ impl CompactSpaceBuilder {
         covered_space.extend(between_blanks);
 
         // end of the blanks
-        if let Some(last_blank_end) = self.blanks.last().map(RangeInclusive::end)
-            && *last_blank_end != u128::MAX
-        {
-            covered_space.push(last_blank_end + 1..=u128::MAX);
+        if let Some(last_blank_end) = self.blanks.last().map(RangeInclusive::end) {
+            if *last_blank_end != u128::MAX {
+                covered_space.push(last_blank_end + 1..=u128::MAX);
+            }
         }
 
         if covered_space.is_empty() {

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

@@ -24,8 +24,8 @@ use build_compact_space::get_compact_space;
 use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt, VIntU128};
 use tantivy_bitpacker::{BitPacker, BitUnpacker};
 
-use crate::RowId;
 use crate::column_values::ColumnValues;
+use crate::RowId;
 
 /// The cost per blank is quite hard actually, since blanks are delta encoded, the actual cost of
 /// blanks depends on the number of blanks.
@@ -653,14 +653,12 @@ mod tests {
             ),
             &[3]
         );
-        assert!(
-            get_positions_for_value_range_helper(
-                &decomp,
-                99998u128..=99998u128,
-                complete_range.clone()
-            )
-            .is_empty()
-        );
+        assert!(get_positions_for_value_range_helper(
+            &decomp,
+            99998u128..=99998u128,
+            complete_range.clone()
+        )
+        .is_empty());
         assert_eq!(
             &get_positions_for_value_range_helper(
                 &decomp,

columnar/src/column_values/u128_based/mod.rs

@@ -130,11 +130,11 @@ pub fn open_u128_as_compact_u64(mut bytes: OwnedBytes) -> io::Result<Arc<dyn Col
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-    use crate::column_values::CodecType;
     use crate::column_values::u64_based::{
-        ALL_U64_CODEC_TYPES, serialize_and_load_u64_based_column_values,
-        serialize_u64_based_column_values,
+        serialize_and_load_u64_based_column_values, serialize_u64_based_column_values,
+        ALL_U64_CODEC_TYPES,
     };
+    use crate::column_values::CodecType;
 
     #[test]
     fn test_serialize_deserialize_u128_header() {

columnar/src/column_values/u64_based/bitpacked.rs

@@ -4,7 +4,7 @@ use std::ops::{Range, RangeInclusive};
 
 use common::{BinarySerializable, OwnedBytes};
 use fastdivide::DividerU64;
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
 use crate::{ColumnValues, RowId};
@@ -23,7 +23,11 @@ const fn div_ceil(n: u64, q: NonZeroU64) -> u64 {
     // copied from unstable rust standard library.
     let d = n / q.get();
     let r = n % q.get();
-    if r > 0 { d + 1 } else { d }
+    if r > 0 {
+        d + 1
+    } else {
+        d
+    }
 }
 
 // The bitpacked codec applies a linear transformation `f` over data that are bitpacked.
@@ -105,7 +109,7 @@ impl ColumnCodecEstimator for BitpackedCodecEstimator {
 
     fn estimate(&self, stats: &ColumnStats) -> Option<u64> {
         let num_bits_per_value = num_bits(stats);
-        Some(stats.num_bytes() + (stats.num_rows as u64 * (num_bits_per_value as u64)).div_ceil(8))
+        Some(stats.num_bytes() + (stats.num_rows as u64 * (num_bits_per_value as u64) + 7) / 8)
     }
 
     fn serialize(

columnar/src/column_values/u64_based/blockwise_linear.rs

@@ -4,12 +4,12 @@ use std::{io, iter};
 
 use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
 use fastdivide::DividerU64;
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use crate::MonotonicallyMappableToU64;
 use crate::column_values::u64_based::line::Line;
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
 use crate::column_values::{ColumnValues, VecColumn};
+use crate::MonotonicallyMappableToU64;
 
 const BLOCK_SIZE: u32 = 512u32;
 

columnar/src/column_values/u64_based/linear.rs

@@ -1,13 +1,13 @@
 use std::io;
 
 use common::{BinarySerializable, OwnedBytes};
-use tantivy_bitpacker::{BitPacker, BitUnpacker, compute_num_bits};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use super::ColumnValues;
 use super::line::Line;
-use crate::RowId;
-use crate::column_values::VecColumn;
+use super::ColumnValues;
 use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, ColumnStats};
+use crate::column_values::VecColumn;
+use crate::RowId;
 
 const HALF_SPACE: u64 = u64::MAX / 2;
 const LINE_ESTIMATION_BLOCK_LEN: usize = 512;
@@ -117,7 +117,7 @@ impl ColumnCodecEstimator for LinearCodecEstimator {
         Some(
             stats.num_bytes()
                 + linear_params.num_bytes()
-                + (num_bits as u64 * stats.num_rows as u64).div_ceil(8),
+                + (num_bits as u64 * stats.num_rows as u64 + 7) / 8,
         )
     }
 

columnar/src/column_values/u64_based/mod.rs

@@ -17,7 +17,7 @@ pub use crate::column_values::u64_based::bitpacked::BitpackedCodec;
 pub use crate::column_values::u64_based::blockwise_linear::BlockwiseLinearCodec;
 pub use crate::column_values::u64_based::linear::LinearCodec;
 pub use crate::column_values::u64_based::stats_collector::StatsCollector;
-use crate::column_values::{ColumnStats, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, ColumnStats};
 use crate::iterable::Iterable;
 use crate::{ColumnValues, MonotonicallyMappableToU64};
 

columnar/src/column_values/u64_based/stats_collector.rs

@@ -2,8 +2,8 @@ use std::num::NonZeroU64;
 
 use fastdivide::DividerU64;
 
-use crate::RowId;
 use crate::column_values::ColumnStats;
+use crate::RowId;
 
 /// Compute the gcd of two non null numbers.
 ///
@@ -96,8 +96,8 @@ impl StatsCollector {
 mod tests {
     use std::num::NonZeroU64;
 
+    use crate::column_values::u64_based::stats_collector::{compute_gcd, StatsCollector};
     use crate::column_values::u64_based::ColumnStats;
-    use crate::column_values::u64_based::stats_collector::{StatsCollector, compute_gcd};
 
     fn compute_stats(vals: impl Iterator<Item = u64>) -> ColumnStats {
         let mut stats_collector = StatsCollector::default();

columnar/src/column_values/u64_based/tests.rs

@@ -1,6 +1,5 @@
 use proptest::prelude::*;
 use proptest::{prop_oneof, proptest};
-use rand::Rng;
 
 #[test]
 fn test_serialize_and_load_simple() {

columnar/src/columnar/column_type.rs

@@ -4,8 +4,8 @@ use std::net::Ipv6Addr;
 
 use serde::{Deserialize, Serialize};
 
-use crate::InvalidData;
 use crate::value::NumericalType;
+use crate::InvalidData;
 
 /// The column type represents the column type.
 /// Any changes need to be propagated to `COLUMN_TYPES`.

columnar/src/columnar/merge/mod.rs

@@ -10,11 +10,11 @@ use std::sync::Arc;
 pub use merge_mapping::{MergeRowOrder, ShuffleMergeOrder, StackMergeOrder};
 
 use super::writer::ColumnarSerializer;
-use crate::column::{serialize_column_mappable_to_u64, serialize_column_mappable_to_u128};
+use crate::column::{serialize_column_mappable_to_u128, serialize_column_mappable_to_u64};
 use crate::column_values::MergedColumnValues;
-use crate::columnar::ColumnarReader;
 use crate::columnar::merge::merge_dict_column::merge_bytes_or_str_column;
 use crate::columnar::writer::CompatibleNumericalTypes;
+use crate::columnar::ColumnarReader;
 use crate::dynamic_column::DynamicColumn;
 use crate::{
     BytesColumn, Column, ColumnIndex, ColumnType, ColumnValues, DynamicColumnHandle, NumericalType,
@@ -144,17 +144,16 @@ fn merge_column(
             let mut column_values: Vec<Option<Arc<dyn ColumnValues>>> =
                 Vec::with_capacity(columns_to_merge.len());
             for (i, dynamic_column_opt) in columns_to_merge.into_iter().enumerate() {
-                match dynamic_column_opt.and_then(dynamic_column_to_u64_monotonic) {
-                    Some(Column { index: idx, values }) => {
-                        column_indexes.push(idx);
-                        column_values.push(Some(values));
-                    }
-                    None => {
-                        column_indexes.push(ColumnIndex::Empty {
-                            num_docs: num_docs_per_column[i],
-                        });
-                        column_values.push(None);
-                    }
+                if let Some(Column { index: idx, values }) =
+                    dynamic_column_opt.and_then(dynamic_column_to_u64_monotonic)
+                {
+                    column_indexes.push(idx);
+                    column_values.push(Some(values));
+                } else {
+                    column_indexes.push(ColumnIndex::Empty {
+                        num_docs: num_docs_per_column[i],
+                    });
+                    column_values.push(None);
                 }
             }
             let merged_column_index =
@@ -254,13 +253,11 @@ impl GroupedColumns {
         }
         // At the moment, only the numerical column type category has more than one possible
         // column type.
-        assert!(
-            self.columns
-                .iter()
-                .flatten()
-                .all(|el| ColumnTypeCategory::from(el.column_type())
-                    == ColumnTypeCategory::Numerical)
-        );
+        assert!(self
+            .columns
+            .iter()
+            .flatten()
+            .all(|el| ColumnTypeCategory::from(el.column_type()) == ColumnTypeCategory::Numerical));
         merged_numerical_columns_type(self.columns.iter().flatten()).into()
     }
 }
@@ -367,7 +364,7 @@ fn is_empty_after_merge(
                     ColumnIndex::Empty { .. } => true,
                     ColumnIndex::Full => alive_bitset.len() == 0,
                     ColumnIndex::Optional(optional_index) => {
-                        for doc in optional_index.iter_non_null_docs() {
+                        for doc in optional_index.iter_docs() {
                             if alive_bitset.contains(doc) {
                                 return false;
                             }

columnar/src/columnar/merge/term_merger.rs

@@ -74,19 +74,18 @@ impl<'a> TermMerger<'a> {
     /// False if there is none.
     pub fn advance(&mut self) -> bool {
         self.advance_segments();
-        match self.heap.pop() {
-            Some(head) => {
-                self.term_streams_with_segment.push(head);
-                while let Some(next_streamer) = self.heap.peek() {
-                    if self.term_streams_with_segment[0].terms.key() != next_streamer.terms.key() {
-                        break;
-                    }
-                    let next_heap_it = self.heap.pop().unwrap(); // safe : we peeked beforehand
-                    self.term_streams_with_segment.push(next_heap_it);
+        if let Some(head) = self.heap.pop() {
+            self.term_streams_with_segment.push(head);
+            while let Some(next_streamer) = self.heap.peek() {
+                if self.term_streams_with_segment[0].terms.key() != next_streamer.terms.key() {
+                    break;
                 }
-                true
+                let next_heap_it = self.heap.pop().unwrap(); // safe : we peeked beforehand
+                self.term_streams_with_segment.push(next_heap_it);
             }
-            _ => false,
+            true
+        } else {
+            false
         }
     }
 

columnar/src/columnar/merge/tests.rs

@@ -3,7 +3,7 @@ use proptest::collection::vec;
 use proptest::prelude::*;
 
 use super::*;
-use crate::columnar::{ColumnarReader, MergeRowOrder, StackMergeOrder, merge_columnar};
+use crate::columnar::{merge_columnar, ColumnarReader, MergeRowOrder, StackMergeOrder};
 use crate::{Cardinality, ColumnarWriter, DynamicColumn, HasAssociatedColumnType, RowId};
 
 fn make_columnar<T: Into<NumericalValue> + HasAssociatedColumnType + Copy>(

columnar/src/columnar/mod.rs

@@ -5,9 +5,9 @@ mod reader;
 mod writer;
 
 pub use column_type::{ColumnType, HasAssociatedColumnType};
-pub use format_version::{CURRENT_VERSION, Version};
+pub use format_version::{Version, CURRENT_VERSION};
 #[cfg(test)]
 pub(crate) use merge::ColumnTypeCategory;
-pub use merge::{MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, merge_columnar};
+pub use merge::{merge_columnar, MergeRowOrder, ShuffleMergeOrder, StackMergeOrder};
 pub use reader::ColumnarReader;
 pub use writer::ColumnarWriter;

columnar/src/columnar/reader/mod.rs

@@ -1,11 +1,11 @@
 use std::{fmt, io, mem};
 
-use common::BinarySerializable;
 use common::file_slice::FileSlice;
 use common::json_path_writer::JSON_PATH_SEGMENT_SEP;
+use common::BinarySerializable;
 use sstable::{Dictionary, RangeSSTable};
 
-use crate::columnar::{ColumnType, format_version};
+use crate::columnar::{format_version, ColumnType};
 use crate::dynamic_column::DynamicColumnHandle;
 use crate::{RowId, Version};
 

columnar/src/columnar/writer/column_operation.rs

@@ -244,7 +244,7 @@ impl SymbolValue for UnorderedId {
 
 fn compute_num_bytes_for_u64(val: u64) -> usize {
     let msb = (64u32 - val.leading_zeros()) as usize;
-    msb.div_ceil(8)
+    (msb + 7) / 8
 }
 
 fn encode_zig_zag(n: i64) -> u64 {

columnar/src/columnar/writer/column_writers.rs

@@ -42,7 +42,7 @@ impl ColumnWriter {
         &self,
         arena: &MemoryArena,
         buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a + use<'a, V> {
+    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a {
         buffer.clear();
         self.values.read_to_end(arena, buffer);
         let mut cursor: &[u8] = &buffer[..];
@@ -104,10 +104,9 @@ pub(crate) struct NumericalColumnWriter {
 
 impl NumericalColumnWriter {
     pub fn force_numerical_type(&mut self, numerical_type: NumericalType) {
-        assert!(
-            self.compatible_numerical_types
-                .is_type_accepted(numerical_type)
-        );
+        assert!(self
+            .compatible_numerical_types
+            .is_type_accepted(numerical_type));
         self.compatible_numerical_types = CompatibleNumericalTypes::StaticType(numerical_type);
     }
 }
@@ -212,7 +211,7 @@ impl NumericalColumnWriter {
         self,
         arena: &MemoryArena,
         buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<NumericalValue>> + 'a + use<'a> {
+    ) -> impl Iterator<Item = ColumnOperation<NumericalValue>> + 'a {
         self.column_writer.operation_iterator(arena, buffer)
     }
 }
@@ -256,7 +255,7 @@ impl StrOrBytesColumnWriter {
         &self,
         arena: &MemoryArena,
         byte_buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<UnorderedId>> + 'a + use<'a> {
+    ) -> impl Iterator<Item = ColumnOperation<UnorderedId>> + 'a {
         self.column_writer.operation_iterator(arena, byte_buffer)
     }
 }

columnar/src/columnar/writer/mod.rs

@@ -8,13 +8,13 @@ use std::net::Ipv6Addr;
 
 use column_operation::ColumnOperation;
 pub(crate) use column_writers::CompatibleNumericalTypes;
-use common::CountingWriter;
 use common::json_path_writer::JSON_END_OF_PATH;
+use common::CountingWriter;
 pub(crate) use serializer::ColumnarSerializer;
 use stacker::{Addr, ArenaHashMap, MemoryArena};
 
 use crate::column_index::{SerializableColumnIndex, SerializableOptionalIndex};
-use crate::column_values::{MonotonicallyMappableToU64, MonotonicallyMappableToU128};
+use crate::column_values::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
 use crate::columnar::column_type::ColumnType;
 use crate::columnar::writer::column_writers::{
     ColumnWriter, NumericalColumnWriter, StrOrBytesColumnWriter,

columnar/src/columnar/writer/serializer.rs

@@ -3,11 +3,11 @@ use std::io::Write;
 
 use common::json_path_writer::JSON_END_OF_PATH;
 use common::{BinarySerializable, CountingWriter};
-use sstable::RangeSSTable;
 use sstable::value::RangeValueWriter;
+use sstable::RangeSSTable;
 
-use crate::RowId;
 use crate::columnar::ColumnType;
+use crate::RowId;
 
 pub struct ColumnarSerializer<W: io::Write> {
     wrt: CountingWriter<W>,

columnar/src/columnar/writer/value_index.rs

@@ -1,6 +1,6 @@
-use crate::RowId;
 use crate::column_index::{SerializableMultivalueIndex, SerializableOptionalIndex};
 use crate::iterable::Iterable;
+use crate::RowId;
 
 /// The `IndexBuilder` interprets a sequence of
 /// calls of the form:
@@ -31,13 +31,12 @@ pub struct OptionalIndexBuilder {
 
 impl OptionalIndexBuilder {
     pub fn finish(&mut self, num_rows: RowId) -> impl Iterable<RowId> + '_ {
-        debug_assert!(
-            self.docs
-                .last()
-                .copied()
-                .map(|last_doc| last_doc < num_rows)
-                .unwrap_or(true)
-        );
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|last_doc| last_doc < num_rows)
+            .unwrap_or(true));
         &self.docs[..]
     }
 
@@ -49,13 +48,12 @@ impl OptionalIndexBuilder {
 impl IndexBuilder for OptionalIndexBuilder {
     #[inline(always)]
     fn record_row(&mut self, doc: RowId) {
-        debug_assert!(
-            self.docs
-                .last()
-                .copied()
-                .map(|prev_doc| doc > prev_doc)
-                .unwrap_or(true)
-        );
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|prev_doc| doc > prev_doc)
+            .unwrap_or(true));
         self.docs.push(doc);
     }
 }

columnar/src/compat_tests.rs

@@ -3,8 +3,8 @@ use std::path::PathBuf;
 use itertools::Itertools;
 
 use crate::{
-    CURRENT_VERSION, Cardinality, Column, ColumnarReader, DynamicColumn, StackMergeOrder,
-    merge_columnar,
+    merge_columnar, Cardinality, Column, ColumnarReader, DynamicColumn, StackMergeOrder,
+    CURRENT_VERSION,
 };
 
 const NUM_DOCS: u32 = u16::MAX as u32;

columnar/src/dynamic_column.rs

@@ -6,7 +6,7 @@ use common::file_slice::FileSlice;
 use common::{ByteCount, DateTime, HasLen, OwnedBytes};
 
 use crate::column::{BytesColumn, Column, StrColumn};
-use crate::column_values::{StrictlyMonotonicFn, monotonic_map_column};
+use crate::column_values::{monotonic_map_column, StrictlyMonotonicFn};
 use crate::columnar::ColumnType;
 use crate::{Cardinality, ColumnIndex, ColumnValues, NumericalType, Version};
 

columnar/src/lib.rs

@@ -17,10 +17,15 @@
 //!       column.
 //!     - [column_values]: Stores the values of a column in a dense format.
 
+#![cfg_attr(all(feature = "unstable", test), feature(test))]
+
 #[cfg(test)]
 #[macro_use]
 extern crate more_asserts;
 
+#[cfg(all(test, feature = "unstable"))]
+extern crate test;
+
 use std::fmt::Display;
 use std::io;
 
@@ -39,11 +44,11 @@ pub use block_accessor::ColumnBlockAccessor;
 pub use column::{BytesColumn, Column, StrColumn};
 pub use column_index::ColumnIndex;
 pub use column_values::{
-    ColumnValues, EmptyColumnValues, MonotonicallyMappableToU64, MonotonicallyMappableToU128,
+    ColumnValues, EmptyColumnValues, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
 };
 pub use columnar::{
-    CURRENT_VERSION, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
-    MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, Version, merge_columnar,
+    merge_columnar, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
+    MergeRowOrder, ShuffleMergeOrder, StackMergeOrder, Version, CURRENT_VERSION,
 };
 use sstable::VoidSSTable;
 pub use value::{NumericalType, NumericalValue};

columnar/src/tests.rs

@@ -716,8 +716,8 @@ fn test_columnar_merging_number_columns() {
 // TODO document edge case: required_columns incompatible with values.
 
 #[allow(clippy::type_complexity)]
-fn columnar_docs_and_remap()
--> impl Strategy<Value = (Vec<Vec<Vec<(&'static str, ColumnValue)>>>, Vec<RowAddr>)> {
+fn columnar_docs_and_remap(
+) -> impl Strategy<Value = (Vec<Vec<Vec<(&'static str, ColumnValue)>>>, Vec<RowAddr>)> {
     proptest::collection::vec(columnar_docs_strategy(), 2..=3).prop_flat_map(
         |columnars_docs: Vec<Vec<Vec<(&str, ColumnValue)>>>| {
             let row_addrs: Vec<RowAddr> = columnars_docs

columnar/src/value.rs

@@ -1,5 +1,3 @@
-use std::str::FromStr;
-
 use common::DateTime;
 
 use crate::InvalidData;
@@ -11,23 +9,6 @@ pub enum NumericalValue {
     F64(f64),
 }
 
-impl FromStr for NumericalValue {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, ()> {
-        if let Ok(val_i64) = s.parse::<i64>() {
-            return Ok(val_i64.into());
-        }
-        if let Ok(val_u64) = s.parse::<u64>() {
-            return Ok(val_u64.into());
-        }
-        if let Ok(val_f64) = s.parse::<f64>() {
-            return Ok(NumericalValue::from(val_f64).normalize());
-        }
-        Err(())
-    }
-}
-
 impl NumericalValue {
     pub fn numerical_type(&self) -> NumericalType {
         match self {
@@ -45,7 +26,7 @@ impl NumericalValue {
                 if val <= i64::MAX as u64 {
                     NumericalValue::I64(val as i64)
                 } else {
-                    NumericalValue::U64(val)
+                    NumericalValue::F64(val as f64)
                 }
             }
             NumericalValue::I64(val) => NumericalValue::I64(val),
@@ -160,7 +141,6 @@ impl Coerce for DateTime {
 #[cfg(test)]
 mod tests {
     use super::NumericalType;
-    use crate::NumericalValue;
 
     #[test]
     fn test_numerical_type_code() {
@@ -173,58 +153,4 @@ mod tests {
         }
         assert_eq!(num_numerical_type, 3);
     }
-
-    #[test]
-    fn test_parse_numerical() {
-        assert_eq!(
-            "123".parse::<NumericalValue>().unwrap(),
-            NumericalValue::I64(123)
-        );
-        assert_eq!(
-            "18446744073709551615".parse::<NumericalValue>().unwrap(),
-            NumericalValue::U64(18446744073709551615u64)
-        );
-        assert_eq!(
-            "1.0".parse::<NumericalValue>().unwrap(),
-            NumericalValue::I64(1i64)
-        );
-        assert_eq!(
-            "1.1".parse::<NumericalValue>().unwrap(),
-            NumericalValue::F64(1.1f64)
-        );
-        assert_eq!(
-            "-1.0".parse::<NumericalValue>().unwrap(),
-            NumericalValue::I64(-1i64)
-        );
-    }
-
-    #[test]
-    fn test_normalize_numerical() {
-        assert_eq!(
-            NumericalValue::from(1u64).normalize(),
-            NumericalValue::I64(1i64),
-        );
-        let limit_val = i64::MAX as u64 + 1u64;
-        assert_eq!(
-            NumericalValue::from(limit_val).normalize(),
-            NumericalValue::U64(limit_val),
-        );
-        assert_eq!(
-            NumericalValue::from(-1i64).normalize(),
-            NumericalValue::I64(-1i64),
-        );
-        assert_eq!(
-            NumericalValue::from(-2.0f64).normalize(),
-            NumericalValue::I64(-2i64),
-        );
-        assert_eq!(
-            NumericalValue::from(-2.1f64).normalize(),
-            NumericalValue::F64(-2.1f64),
-        );
-        let large_float = 2.0f64.powf(70.0f64);
-        assert_eq!(
-            NumericalValue::from(large_float).normalize(),
-            NumericalValue::F64(large_float),
-        );
-    }
 }

common/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "tantivy-common"
-version = "0.10.0"
+version = "0.9.0"
 authors = ["Paul Masurel <paul@quickwit.io>", "Pascal Seitz <pascal@quickwit.io>"]
 license = "MIT"
-edition = "2024"
+edition = "2021"
 description = "common traits and utility functions used by multiple tantivy subcrates"
 documentation = "https://docs.rs/tantivy_common/"
 homepage = "https://github.com/quickwit-oss/tantivy"

common/benches/bench.rs

@@ -1,7 +1,7 @@
-use binggan::{BenchRunner, black_box};
+use binggan::{black_box, BenchRunner};
 use rand::seq::IteratorRandom;
 use rand::thread_rng;
-use tantivy_common::{BitSet, TinySet, serialize_vint_u32};
+use tantivy_common::{serialize_vint_u32, BitSet, TinySet};
 
 fn bench_vint() {
     let mut runner = BenchRunner::new();

common/src/bitset.rs

@@ -183,7 +183,7 @@ pub struct BitSet {
 }
 
 fn num_buckets(max_val: u32) -> u32 {
-    max_val.div_ceil(64u32)
+    (max_val + 63u32) / 64u32
 }
 
 impl BitSet {

common/src/bounds.rs

@@ -65,11 +65,11 @@ pub fn transform_bound_inner_res<TFrom, TTo>(
 ) -> io::Result<Bound<TTo>> {
     use self::Bound::*;
     Ok(match bound {
-        Excluded(from_val) => match transform(from_val)? {
+        Excluded(ref from_val) => match transform(from_val)? {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Excluded(new_val),
         },
-        Included(from_val) => match transform(from_val)? {
+        Included(ref from_val) => match transform(from_val)? {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Included(new_val),
         },
@@ -85,11 +85,11 @@ pub fn transform_bound_inner<TFrom, TTo>(
 ) -> Bound<TTo> {
     use self::Bound::*;
     match bound {
-        Excluded(from_val) => match transform(from_val) {
+        Excluded(ref from_val) => match transform(from_val) {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Excluded(new_val),
         },
-        Included(from_val) => match transform(from_val) {
+        Included(ref from_val) => match transform(from_val) {
             TransformBound::NewBound(new_val) => new_val,
             TransformBound::Existing(new_val) => Included(new_val),
         },
@@ -111,8 +111,8 @@ pub fn map_bound<TFrom, TTo>(
 ) -> Bound<TTo> {
     use self::Bound::*;
     match bound {
-        Excluded(from_val) => Bound::Excluded(transform(from_val)),
-        Included(from_val) => Bound::Included(transform(from_val)),
+        Excluded(ref from_val) => Bound::Excluded(transform(from_val)),
+        Included(ref from_val) => Bound::Included(transform(from_val)),
         Unbounded => Unbounded,
     }
 }
@@ -123,8 +123,8 @@ pub fn map_bound_res<TFrom, TTo, Err>(
 ) -> Result<Bound<TTo>, Err> {
     use self::Bound::*;
     Ok(match bound {
-        Excluded(from_val) => Excluded(transform(from_val)?),
-        Included(from_val) => Included(transform(from_val)?),
+        Excluded(ref from_val) => Excluded(transform(from_val)?),
+        Included(ref from_val) => Included(transform(from_val)?),
         Unbounded => Unbounded,
     })
 }

common/src/file_slice.rs

@@ -74,7 +74,7 @@ impl FileHandle for WrapFile {
         {
             use std::io::{Read, Seek};
             let mut file = self.file.try_clone()?; // Clone the file to read from it separately
-            // Seek to the start position in the file
+                                                   // Seek to the start position in the file
             file.seek(io::SeekFrom::Start(start as u64))?;
             // Read the data into the buffer
             file.read_exact(&mut buffer)?;
@@ -346,8 +346,8 @@ mod tests {
     use std::sync::Arc;
 
     use super::{FileHandle, FileSlice};
-    use crate::HasLen;
     use crate::file_slice::combine_ranges;
+    use crate::HasLen;
 
     #[test]
     fn test_file_slice() -> io::Result<()> {

common/src/lib.rs

@@ -22,7 +22,7 @@ pub use json_path_writer::JsonPathWriter;
 pub use ownedbytes::{OwnedBytes, StableDeref};
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
 pub use vint::{
-    VInt, VIntU128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u32, write_u32_vint,
+    read_u32_vint, read_u32_vint_no_advance, serialize_vint_u32, write_u32_vint, VInt, VIntU128,
 };
 pub use writer::{AntiCallToken, CountingWriter, TerminatingWrite};
 
@@ -177,10 +177,8 @@ pub(crate) mod test {
 
     #[test]
     fn test_f64_order() {
-        assert!(
-            !(f64_to_u64(f64::NEG_INFINITY)..f64_to_u64(f64::INFINITY))
-                .contains(&f64_to_u64(f64::NAN))
-        ); // nan is not a number
+        assert!(!(f64_to_u64(f64::NEG_INFINITY)..f64_to_u64(f64::INFINITY))
+            .contains(&f64_to_u64(f64::NAN))); // nan is not a number
         assert!(f64_to_u64(1.5) > f64_to_u64(1.0)); // same exponent, different mantissa
         assert!(f64_to_u64(2.0) > f64_to_u64(1.0)); // same mantissa, different exponent
         assert!(f64_to_u64(2.0) > f64_to_u64(1.5)); // different exponent and mantissa

common/src/vint.rs

@@ -222,7 +222,7 @@ impl BinarySerializable for VInt {
 #[cfg(test)]
 mod tests {
 
-    use super::{BinarySerializable, VInt, serialize_vint_u32};
+    use super::{serialize_vint_u32, BinarySerializable, VInt};
 
     fn aux_test_vint(val: u64) {
         let mut v = [14u8; 10];

examples/basic_search.rs

@@ -51,7 +51,7 @@ fn main() -> tantivy::Result<()> {
 
     // Our second field is body.
     // We want full-text search for it, but we do not
-    // need to be able to retrieve it
+    // need to be able to be able to retrieve it
     // for our application.
     //
     // We can make our index lighter by omitting the `STORED` flag.

examples/filter_aggregation.rs

@@ -1,212 +0,0 @@
-// # Filter Aggregation Example
-//
-// This example demonstrates filter aggregations - creating buckets of documents
-// matching specific queries, with nested aggregations computed on each bucket.
-//
-// Filter aggregations are useful for computing metrics on different subsets of
-// your data in a single query, like "average price overall + average price for
-// electronics + count of in-stock items".
-
-use serde_json::json;
-use tantivy::aggregation::agg_req::Aggregations;
-use tantivy::aggregation::AggregationCollector;
-use tantivy::query::AllQuery;
-use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
-use tantivy::{doc, Index};
-
-fn main() -> tantivy::Result<()> {
-    // Create a simple product schema
-    let mut schema_builder = Schema::builder();
-    schema_builder.add_text_field("category", TEXT | FAST);
-    schema_builder.add_text_field("brand", TEXT | FAST);
-    schema_builder.add_u64_field("price", FAST);
-    schema_builder.add_f64_field("rating", FAST);
-    schema_builder.add_bool_field("in_stock", FAST | INDEXED);
-    let schema = schema_builder.build();
-
-    // Create index and add sample products
-    let index = Index::create_in_ram(schema.clone());
-    let mut writer = index.writer(50_000_000)?;
-
-    writer.add_document(doc!(
-        schema.get_field("category")? => "electronics",
-        schema.get_field("brand")? => "apple",
-        schema.get_field("price")? => 999u64,
-        schema.get_field("rating")? => 4.5f64,
-        schema.get_field("in_stock")? => true
-    ))?;
-    writer.add_document(doc!(
-        schema.get_field("category")? => "electronics",
-        schema.get_field("brand")? => "samsung",
-        schema.get_field("price")? => 799u64,
-        schema.get_field("rating")? => 4.2f64,
-        schema.get_field("in_stock")? => true
-    ))?;
-    writer.add_document(doc!(
-        schema.get_field("category")? => "clothing",
-        schema.get_field("brand")? => "nike",
-        schema.get_field("price")? => 120u64,
-        schema.get_field("rating")? => 4.1f64,
-        schema.get_field("in_stock")? => false
-    ))?;
-    writer.add_document(doc!(
-        schema.get_field("category")? => "books",
-        schema.get_field("brand")? => "penguin",
-        schema.get_field("price")? => 25u64,
-        schema.get_field("rating")? => 4.8f64,
-        schema.get_field("in_stock")? => true
-    ))?;
-
-    writer.commit()?;
-
-    let reader = index.reader()?;
-    let searcher = reader.searcher();
-
-    // Example 1: Basic filter with metric aggregation
-    println!("=== Example 1: Electronics average price ===");
-    let agg_req = json!({
-        "electronics": {
-            "filter": "category:electronics",
-            "aggs": {
-                "avg_price": { "avg": { "field": "price" } }
-            }
-        }
-    });
-
-    let agg: Aggregations = serde_json::from_value(agg_req)?;
-    let collector = AggregationCollector::from_aggs(agg, Default::default());
-    let result = searcher.search(&AllQuery, &collector)?;
-
-    let expected = json!({
-        "electronics": {
-            "doc_count": 2,
-            "avg_price": { "value": 899.0 }
-        }
-    });
-    assert_eq!(serde_json::to_value(&result)?, expected);
-    println!("{}\n", serde_json::to_string_pretty(&result)?);
-
-    // Example 2: Multiple independent filters
-    println!("=== Example 2: Multiple filters in one query ===");
-    let agg_req = json!({
-        "electronics": {
-            "filter": "category:electronics",
-            "aggs": { "avg_price": { "avg": { "field": "price" } } }
-        },
-        "in_stock": {
-            "filter": "in_stock:true",
-            "aggs": { "count": { "value_count": { "field": "brand" } } }
-        },
-        "high_rated": {
-            "filter": "rating:[4.5 TO *]",
-            "aggs": { "count": { "value_count": { "field": "brand" } } }
-        }
-    });
-
-    let agg: Aggregations = serde_json::from_value(agg_req)?;
-    let collector = AggregationCollector::from_aggs(agg, Default::default());
-    let result = searcher.search(&AllQuery, &collector)?;
-
-    let expected = json!({
-        "electronics": {
-            "doc_count": 2,
-            "avg_price": { "value": 899.0 }
-        },
-        "in_stock": {
-            "doc_count": 3,
-            "count": { "value": 3.0 }
-        },
-        "high_rated": {
-            "doc_count": 2,
-            "count": { "value": 2.0 }
-        }
-    });
-    assert_eq!(serde_json::to_value(&result)?, expected);
-    println!("{}\n", serde_json::to_string_pretty(&result)?);
-
-    // Example 3: Nested filters - progressive refinement
-    println!("=== Example 3: Nested filters ===");
-    let agg_req = json!({
-        "in_stock": {
-            "filter": "in_stock:true",
-            "aggs": {
-                "electronics": {
-                    "filter": "category:electronics",
-                    "aggs": {
-                        "expensive": {
-                            "filter": "price:[800 TO *]",
-                            "aggs": {
-                                "avg_rating": { "avg": { "field": "rating" } }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-
-    let agg: Aggregations = serde_json::from_value(agg_req)?;
-    let collector = AggregationCollector::from_aggs(agg, Default::default());
-    let result = searcher.search(&AllQuery, &collector)?;
-
-    let expected = json!({
-        "in_stock": {
-            "doc_count": 3,  // apple, samsung, penguin
-            "electronics": {
-                "doc_count": 2,  // apple, samsung
-                "expensive": {
-                    "doc_count": 1,  // only apple (999)
-                    "avg_rating": { "value": 4.5 }
-                }
-            }
-        }
-    });
-    assert_eq!(serde_json::to_value(&result)?, expected);
-    println!("{}\n", serde_json::to_string_pretty(&result)?);
-
-    // Example 4: Filter with sub-aggregation (terms)
-    println!("=== Example 4: Filter with terms sub-aggregation ===");
-    let agg_req = json!({
-        "electronics": {
-            "filter": "category:electronics",
-            "aggs": {
-                "by_brand": {
-                    "terms": { "field": "brand" },
-                    "aggs": {
-                        "avg_price": { "avg": { "field": "price" } }
-                    }
-                }
-            }
-        }
-    });
-
-    let agg: Aggregations = serde_json::from_value(agg_req)?;
-    let collector = AggregationCollector::from_aggs(agg, Default::default());
-    let result = searcher.search(&AllQuery, &collector)?;
-
-    let expected = json!({
-        "electronics": {
-            "doc_count": 2,
-            "by_brand": {
-                "buckets": [
-                    {
-                        "key": "samsung",
-                        "doc_count": 1,
-                        "avg_price": { "value": 799.0 }
-                    },
-                    {
-                        "key": "apple",
-                        "doc_count": 1,
-                        "avg_price": { "value": 999.0 }
-                    }
-                ],
-                "sum_other_doc_count": 0,
-                "doc_count_error_upper_bound": 0
-            }
-        }
-    });
-    assert_eq!(serde_json::to_value(&result)?, expected);
-    println!("{}", serde_json::to_string_pretty(&result)?);
-
-    Ok(())
-}

examples/fuzzy_search.rs

@@ -85,6 +85,7 @@ fn main() -> tantivy::Result<()> {
     index_writer.add_document(doc!(
         title => "The Diary of a Young Girl",
     ))?;
+    index_writer.commit()?;
 
     // ### Committing
     //

query-grammar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-query-grammar"
-version = "0.25.0"
+version = "0.24.0"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = ["database-implementations", "data-structures"]
@@ -9,11 +9,9 @@ homepage = "https://github.com/quickwit-oss/tantivy"
 repository = "https://github.com/quickwit-oss/tantivy"
 readme = "README.md"
 keywords = ["search", "information", "retrieval"]
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 nom = "7"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
-ordered-float = "5.0.0"
-fnv = "1.0.7"

query-grammar/src/infallible.rs

@@ -117,22 +117,6 @@ where F: nom::Parser<I, (O, ErrorList), Infallible> {
     }
 }
 
-pub(crate) fn terminated_infallible<I, O1, O2, F, G>(
-    mut first: F,
-    mut second: G,
-) -> impl FnMut(I) -> JResult<I, O1>
-where
-    F: nom::Parser<I, (O1, ErrorList), Infallible>,
-    G: nom::Parser<I, (O2, ErrorList), Infallible>,
-{
-    move |input: I| {
-        let (input, (o1, mut err)) = first.parse(input)?;
-        let (input, (_, mut err2)) = second.parse(input)?;
-        err.append(&mut err2);
-        Ok((input, (o1, err)))
-    }
-}
-
 pub(crate) fn delimited_infallible<I, O1, O2, O3, F, G, H>(
     mut first: F,
     mut second: G,
@@ -202,19 +186,19 @@ macro_rules! tuple_trait_impl(
 );
 
 macro_rules! tuple_trait_inner(
-  ($it:tt, $self:expr_2021, $input:expr_2021, (), $error_list:expr_2021, $head:ident $($id:ident)+) => ({
+  ($it:tt, $self:expr, $input:expr, (), $error_list:expr, $head:ident $($id:ident)+) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
     succ!($it, tuple_trait_inner!($self, i, ( o ), $error_list, $($id)+))
   });
-  ($it:tt, $self:expr_2021, $input:expr_2021, ($($parsed:tt)*), $error_list:expr_2021, $head:ident $($id:ident)+) => ({
+  ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $error_list:expr, $head:ident $($id:ident)+) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
     succ!($it, tuple_trait_inner!($self, i, ($($parsed)* , o), $error_list, $($id)+))
   });
-  ($it:tt, $self:expr_2021, $input:expr_2021, ($($parsed:tt)*), $error_list:expr_2021, $head:ident) => ({
+  ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $error_list:expr, $head:ident) => ({
     let (i, (o, mut err)) = $self.$it.parse($input.clone())?;
     $error_list.append(&mut err);
 
@@ -344,13 +328,13 @@ macro_rules! alt_trait_impl(
 );
 
 macro_rules! alt_trait_inner(
-  ($it:tt, $self:expr_2021, $input:expr_2021, $head_cond:ident $head:ident, $($id_cond:ident $id:ident),+) => (
+  ($it:tt, $self:expr, $input:expr, $head_cond:ident $head:ident, $($id_cond:ident $id:ident),+) => (
     match $self.$it.0.parse($input.clone()) {
       Err(_) => succ!($it, alt_trait_inner!($self, $input, $($id_cond $id),+)),
       Ok((input_left, _)) => Some($self.$it.1.parse(input_left)),
     }
   );
-  ($it:tt, $self:expr_2021, $input:expr_2021, $head_cond:ident $head:ident) => (
+  ($it:tt, $self:expr, $input:expr, $head_cond:ident $head:ident) => (
     None
   );
 );

query-grammar/src/lib.rs

@@ -31,17 +31,7 @@ pub fn parse_query_lenient(query: &str) -> (UserInputAst, Vec<LenientError>) {
 
 #[cfg(test)]
 mod tests {
-    use crate::{UserInputAst, parse_query, parse_query_lenient};
-
-    #[test]
-    fn test_deduplication() {
-        let ast: UserInputAst = parse_query("a a").unwrap();
-        let json = serde_json::to_string(&ast).unwrap();
-        assert_eq!(
-            json,
-            r#"{"type":"bool","clauses":[[null,{"type":"literal","field_name":null,"phrase":"a","delimiter":"none","slop":0,"prefix":false}]]}"#
-        );
-    }
+    use crate::{parse_query, parse_query_lenient};
 
     #[test]
     fn test_parse_query_serialization() {

query-grammar/src/query_grammar.rs

@@ -1,8 +1,6 @@
 use std::borrow::Cow;
 use std::iter::once;
 
-use fnv::FnvHashSet;
-use nom::IResult;
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::{
@@ -12,11 +10,12 @@ use nom::combinator::{eof, map, map_res, opt, peek, recognize, value, verify};
 use nom::error::{Error, ErrorKind};
 use nom::multi::{many0, many1, separated_list0};
 use nom::sequence::{delimited, preceded, separated_pair, terminated, tuple};
+use nom::IResult;
 
 use super::user_input_ast::{UserInputAst, UserInputBound, UserInputLeaf, UserInputLiteral};
-use crate::Occur;
 use crate::infallible::*;
 use crate::user_input_ast::Delimiter;
+use crate::Occur;
 
 // Note: '-' char is only forbidden at the beginning of a field name, would be clearer to add it to
 // special characters.
@@ -37,7 +36,7 @@ fn field_name(inp: &str) -> IResult<&str, String> {
                 alt((first_char, escape_sequence())),
                 many0(alt((simple_char, escape_sequence(), char('\\')))),
             )),
-            tuple((multispace0, char(':'), multispace0)),
+            char(':'),
         ),
         |(first_char, next)| once(first_char).chain(next).collect(),
     )(inp)
@@ -69,7 +68,7 @@ fn interpret_escape(source: &str) -> String {
 
 /// Consume a word outside of any context.
 // TODO should support escape sequences
-fn word(inp: &str) -> IResult<&str, Cow<'_, str>> {
+fn word(inp: &str) -> IResult<&str, Cow<str>> {
     map_res(
         recognize(tuple((
             alt((
@@ -306,14 +305,15 @@ fn term_group_infallible(inp: &str) -> JResult<&str, UserInputAst> {
     let (inp, (field_name, _, _, _)) =
         tuple((field_name, multispace0, char('('), multispace0))(inp).expect("precondition failed");
 
-    delimited_infallible(
+    let res = delimited_infallible(
         nothing,
         map(ast_infallible, |(mut ast, errors)| {
             ast.set_default_field(field_name.to_string());
             (ast, errors)
         }),
         opt_i_err(char(')'), "expected ')'"),
-    )(inp)
+    )(inp);
+    res
 }
 
 fn exists(inp: &str) -> IResult<&str, UserInputLeaf> {
@@ -367,10 +367,7 @@ fn literal(inp: &str) -> IResult<&str, UserInputAst> {
     // something (a field name) got parsed before
     alt((
         map(
-            tuple((
-                opt(field_name),
-                alt((range, set, exists, regex, term_or_phrase)),
-            )),
+            tuple((opt(field_name), alt((range, set, exists, term_or_phrase)))),
             |(field_name, leaf): (Option<String>, UserInputLeaf)| leaf.set_field(field_name).into(),
         ),
         term_group,
@@ -392,10 +389,6 @@ fn literal_no_group_infallible(inp: &str) -> JResult<&str, Option<UserInputAst>>
                         value((), peek(one_of("{[><"))),
                         map(range_infallible, |(range, errs)| (Some(range), errs)),
                     ),
-                    (
-                        value((), peek(one_of("/"))),
-                        map(regex_infallible, |(regex, errs)| (Some(regex), errs)),
-                    ),
                 ),
                 delimited_infallible(space0_infallible, term_or_phrase_infallible, nothing),
             ),
@@ -696,61 +689,6 @@ fn set_infallible(mut inp: &str) -> JResult<&str, UserInputLeaf> {
     }
 }
 
-fn regex(inp: &str) -> IResult<&str, UserInputLeaf> {
-    map(
-        terminated(
-            delimited(
-                char('/'),
-                many1(alt((preceded(char('\\'), char('/')), none_of("/")))),
-                char('/'),
-            ),
-            peek(alt((multispace1, eof))),
-        ),
-        |elements| UserInputLeaf::Regex {
-            field: None,
-            pattern: elements.into_iter().collect::<String>(),
-        },
-    )(inp)
-}
-
-fn regex_infallible(inp: &str) -> JResult<&str, UserInputLeaf> {
-    match terminated_infallible(
-        delimited_infallible(
-            opt_i_err(char('/'), "missing delimiter /"),
-            opt_i(many1(alt((preceded(char('\\'), char('/')), none_of("/"))))),
-            opt_i_err(char('/'), "missing delimiter /"),
-        ),
-        opt_i_err(
-            peek(alt((multispace1, eof))),
-            "expected whitespace or end of input",
-        ),
-    )(inp)
-    {
-        Ok((rest, (elements_part, errors))) => {
-            let pattern = match elements_part {
-                Some(elements_part) => elements_part.into_iter().collect(),
-                None => String::new(),
-            };
-            let res = UserInputLeaf::Regex {
-                field: None,
-                pattern,
-            };
-            Ok((rest, (res, errors)))
-        }
-        Err(e) => {
-            let errs = vec![LenientErrorInternal {
-                pos: inp.len(),
-                message: e.to_string(),
-            }];
-            let res = UserInputLeaf::Regex {
-                field: None,
-                pattern: String::new(),
-            };
-            Ok((inp, (res, errs)))
-        }
-    }
-}
-
 fn negate(expr: UserInputAst) -> UserInputAst {
     expr.unary(Occur::MustNot)
 }
@@ -815,7 +753,7 @@ fn boosted_leaf(inp: &str) -> IResult<&str, UserInputAst> {
         tuple((leaf, fallible(boost))),
         |(leaf, boost_opt)| match boost_opt {
             Some(boost) if (boost - 1.0).abs() > f64::EPSILON => {
-                UserInputAst::Boost(Box::new(leaf), boost.into())
+                UserInputAst::Boost(Box::new(leaf), boost)
             }
             _ => leaf,
         },
@@ -827,7 +765,7 @@ fn boosted_leaf_infallible(inp: &str) -> JResult<&str, Option<UserInputAst>> {
         tuple_infallible((leaf_infallible, boost)),
         |((leaf, boost_opt), error)| match boost_opt {
             Some(boost) if (boost - 1.0).abs() > f64::EPSILON => (
-                leaf.map(|leaf| UserInputAst::Boost(Box::new(leaf), boost.into())),
+                leaf.map(|leaf| UserInputAst::Boost(Box::new(leaf), boost)),
                 error,
             ),
             _ => (leaf, error),
@@ -1078,25 +1016,12 @@ pub fn parse_to_ast_lenient(query_str: &str) -> (UserInputAst, Vec<LenientError>
     (rewrite_ast(res), errors)
 }
 
+/// Removes unnecessary children clauses in AST
+///
+/// Motivated by [issue #1433](https://github.com/quickwit-oss/tantivy/issues/1433)
 fn rewrite_ast(mut input: UserInputAst) -> UserInputAst {
-    if let UserInputAst::Clause(sub_clauses) = &mut input {
-        // call rewrite_ast recursively on children clauses if applicable
-        let mut new_clauses = Vec::with_capacity(sub_clauses.len());
-        for (occur, clause) in sub_clauses.drain(..) {
-            let rewritten_clause = rewrite_ast(clause);
-            new_clauses.push((occur, rewritten_clause));
-        }
-        *sub_clauses = new_clauses;
-
-        // remove duplicate child clauses
-        // e.g. (+a +b) OR (+c +d) OR (+a +b)  => (+a +b) OR (+c +d)
-        let mut seen = FnvHashSet::default();
-        sub_clauses.retain(|term| seen.insert(term.clone()));
-
-        // Removes unnecessary children clauses in AST
-        //
-        // Motivated by [issue #1433](https://github.com/quickwit-oss/tantivy/issues/1433)
-        for term in sub_clauses {
+    if let UserInputAst::Clause(terms) = &mut input {
+        for term in terms {
             rewrite_ast_clause(term);
         }
     }
@@ -1105,7 +1030,7 @@ fn rewrite_ast(mut input: UserInputAst) -> UserInputAst {
 
 fn rewrite_ast_clause(input: &mut (Option<Occur>, UserInputAst)) {
     match input {
-        (None, UserInputAst::Clause(clauses)) if clauses.len() == 1 => {
+        (None, UserInputAst::Clause(ref mut clauses)) if clauses.len() == 1 => {
             *input = clauses.pop().unwrap(); // safe because clauses.len() == 1
         }
         _ => {}
@@ -1358,10 +1283,6 @@ mod test {
             super::field_name("~my~field:a"),
             Ok(("a", "~my~field".to_string()))
         );
-        assert_eq!(
-            super::field_name(".my.field.name : a"),
-            Ok(("a", ".my.field.name".to_string()))
-        );
         for special_char in SPECIAL_CHARS.iter() {
             let query = &format!("\\{special_char}my\\{special_char}field:a");
             assert_eq!(
@@ -1455,7 +1376,7 @@ mod test {
 
     #[test]
     fn test_range_parser_lenient() {
-        let literal = |query| literal_infallible(query).unwrap().1.0.unwrap();
+        let literal = |query| literal_infallible(query).unwrap().1 .0.unwrap();
 
         // same tests as non-lenient
         let res = literal("title: <hello");
@@ -1768,72 +1689,4 @@ mod test {
     fn test_invalid_field() {
         test_is_parse_err(r#"!bc:def"#, "!bc:def");
     }
-
-    #[test]
-    fn test_regex_parser() {
-        let r = parse_to_ast(r#"a:/joh?n(ath[oa]n)/"#);
-        assert!(r.is_ok(), "Failed to parse custom query: {r:?}");
-        let (_, input) = r.unwrap();
-        match input {
-            UserInputAst::Leaf(leaf) => match leaf.as_ref() {
-                UserInputLeaf::Regex { field, pattern } => {
-                    assert_eq!(field, &Some("a".to_string()));
-                    assert_eq!(pattern, "joh?n(ath[oa]n)");
-                }
-                _ => panic!("Expected a regex leaf, got {leaf:?}"),
-            },
-            _ => panic!("Expected a leaf"),
-        }
-        let r = parse_to_ast(r#"a:/\\/cgi-bin\\/luci.*/"#);
-        assert!(r.is_ok(), "Failed to parse custom query: {r:?}");
-        let (_, input) = r.unwrap();
-        match input {
-            UserInputAst::Leaf(leaf) => match leaf.as_ref() {
-                UserInputLeaf::Regex { field, pattern } => {
-                    assert_eq!(field, &Some("a".to_string()));
-                    assert_eq!(pattern, "\\/cgi-bin\\/luci.*");
-                }
-                _ => panic!("Expected a regex leaf, got {leaf:?}"),
-            },
-            _ => panic!("Expected a leaf"),
-        }
-    }
-
-    #[test]
-    fn test_regex_parser_lenient() {
-        let literal = |query| literal_infallible(query).unwrap().1;
-
-        let (res, errs) = literal(r#"a:/joh?n(ath[oa]n)/"#);
-        let expected = UserInputLeaf::Regex {
-            field: Some("a".to_string()),
-            pattern: "joh?n(ath[oa]n)".to_string(),
-        }
-        .into();
-        assert_eq!(res.unwrap(), expected);
-        assert!(errs.is_empty(), "Expected no errors, got: {errs:?}");
-
-        let (res, errs) = literal("title:/joh?n(ath[oa]n)");
-        let expected = UserInputLeaf::Regex {
-            field: Some("title".to_string()),
-            pattern: "joh?n(ath[oa]n)".to_string(),
-        }
-        .into();
-        assert_eq!(res.unwrap(), expected);
-        assert_eq!(errs.len(), 1, "Expected 1 error, got: {errs:?}");
-        assert_eq!(
-            errs[0].message, "missing delimiter /",
-            "Unexpected error message",
-        );
-    }
-
-    #[test]
-    fn test_space_before_value() {
-        test_parse_query_to_ast_helper("field : a", r#""field":a"#);
-        test_parse_query_to_ast_helper("field:    a", r#""field":a"#);
-        test_parse_query_to_ast_helper("field         :a", r#""field":a"#);
-        test_parse_query_to_ast_helper(
-            "field : 'happy tax payer' AND other_field  : 1",
-            r#"(+"field":'happy tax payer' +"other_field":1)"#,
-        );
-    }
 }

query-grammar/src/user_input_ast.rs

@@ -5,7 +5,7 @@ use serde::Serialize;
 
 use crate::Occur;
 
-#[derive(PartialEq, Eq, Hash, Clone, Serialize)]
+#[derive(PartialEq, Clone, Serialize)]
 #[serde(tag = "type")]
 #[serde(rename_all = "snake_case")]
 pub enum UserInputLeaf {
@@ -23,10 +23,6 @@ pub enum UserInputLeaf {
     Exists {
         field: String,
     },
-    Regex {
-        field: Option<String>,
-        pattern: String,
-    },
 }
 
 impl UserInputLeaf {
@@ -50,13 +46,12 @@ impl UserInputLeaf {
             UserInputLeaf::Exists { field: _ } => UserInputLeaf::Exists {
                 field: field.expect("Exist query without a field isn't allowed"),
             },
-            UserInputLeaf::Regex { field: _, pattern } => UserInputLeaf::Regex { field, pattern },
         }
     }
 
     pub(crate) fn set_default_field(&mut self, default_field: String) {
         match self {
-            UserInputLeaf::Literal(literal) if literal.field_name.is_none() => {
+            UserInputLeaf::Literal(ref mut literal) if literal.field_name.is_none() => {
                 literal.field_name = Some(default_field)
             }
             UserInputLeaf::All => {
@@ -64,8 +59,12 @@ impl UserInputLeaf {
                     field: default_field,
                 }
             }
-            UserInputLeaf::Range { field, .. } if field.is_none() => *field = Some(default_field),
-            UserInputLeaf::Set { field, .. } if field.is_none() => *field = Some(default_field),
+            UserInputLeaf::Range { ref mut field, .. } if field.is_none() => {
+                *field = Some(default_field)
+            }
+            UserInputLeaf::Set { ref mut field, .. } if field.is_none() => {
+                *field = Some(default_field)
+            }
             _ => (), // field was already set, do nothing
         }
     }
@@ -76,11 +75,11 @@ impl Debug for UserInputLeaf {
         match self {
             UserInputLeaf::Literal(literal) => literal.fmt(formatter),
             UserInputLeaf::Range {
-                field,
-                lower,
-                upper,
+                ref field,
+                ref lower,
+                ref upper,
             } => {
-                if let Some(field) = field {
+                if let Some(ref field) = field {
                     // TODO properly escape field (in case of \")
                     write!(formatter, "\"{field}\":")?;
                 }
@@ -90,7 +89,7 @@ impl Debug for UserInputLeaf {
                 Ok(())
             }
             UserInputLeaf::Set { field, elements } => {
-                if let Some(field) = field {
+                if let Some(ref field) = field {
                     // TODO properly escape field (in case of \")
                     write!(formatter, "\"{field}\": ")?;
                 }
@@ -108,19 +107,11 @@ impl Debug for UserInputLeaf {
             UserInputLeaf::Exists { field } => {
                 write!(formatter, "$exists(\"{field}\")")
             }
-            UserInputLeaf::Regex { field, pattern } => {
-                if let Some(field) = field {
-                    // TODO properly escape field (in case of \")
-                    write!(formatter, "\"{field}\":")?;
-                }
-                // TODO properly escape pattern (in case of \")
-                write!(formatter, "/{pattern}/")
-            }
         }
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Serialize)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Delimiter {
     SingleQuotes,
@@ -128,7 +119,7 @@ pub enum Delimiter {
     None,
 }
 
-#[derive(PartialEq, Eq, Hash, Clone, Serialize)]
+#[derive(PartialEq, Clone, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub struct UserInputLiteral {
     pub field_name: Option<String>,
@@ -167,7 +158,7 @@ impl fmt::Debug for UserInputLiteral {
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize)]
+#[derive(PartialEq, Debug, Clone, Serialize)]
 #[serde(tag = "type", content = "value")]
 #[serde(rename_all = "snake_case")]
 pub enum UserInputBound {
@@ -204,11 +195,11 @@ impl UserInputBound {
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Clone, Serialize)]
+#[derive(PartialEq, Clone, Serialize)]
 #[serde(into = "UserInputAstSerde")]
 pub enum UserInputAst {
     Clause(Vec<(Option<Occur>, UserInputAst)>),
-    Boost(Box<UserInputAst>, ordered_float::OrderedFloat<f64>),
+    Boost(Box<UserInputAst>, f64),
     Leaf(Box<UserInputLeaf>),
 }
 
@@ -230,10 +221,9 @@ impl From<UserInputAst> for UserInputAstSerde {
     fn from(ast: UserInputAst) -> Self {
         match ast {
             UserInputAst::Clause(clause) => UserInputAstSerde::Bool { clauses: clause },
-            UserInputAst::Boost(underlying, boost) => UserInputAstSerde::Boost {
-                underlying,
-                boost: boost.into_inner(),
-            },
+            UserInputAst::Boost(underlying, boost) => {
+                UserInputAstSerde::Boost { underlying, boost }
+            }
             UserInputAst::Leaf(leaf) => UserInputAstSerde::Leaf(leaf),
         }
     }
@@ -277,7 +267,7 @@ impl UserInputAst {
                 .iter_mut()
                 .for_each(|(_, ast)| ast.set_default_field(field.clone())),
             UserInputAst::Leaf(leaf) => leaf.set_default_field(field),
-            UserInputAst::Boost(ast, _) => ast.set_default_field(field),
+            UserInputAst::Boost(ref mut ast, _) => ast.set_default_field(field),
         }
     }
 }
@@ -392,7 +382,7 @@ mod tests {
     #[test]
     fn test_boost_serialization() {
         let inner_ast = UserInputAst::Leaf(Box::new(UserInputLeaf::All));
-        let boost_ast = UserInputAst::Boost(Box::new(inner_ast), 2.5.into());
+        let boost_ast = UserInputAst::Boost(Box::new(inner_ast), 2.5);
         let json = serde_json::to_string(&boost_ast).unwrap();
         assert_eq!(
             json,
@@ -419,7 +409,7 @@ mod tests {
                     }))),
                 ),
             ])),
-            2.5.into(),
+            2.5,
         );
         let json = serde_json::to_string(&boost_ast).unwrap();
         assert_eq!(

src/aggregation/README.md

@@ -20,16 +20,17 @@ Contains all metric aggregations, like average aggregation. Metric aggregations
 #### agg_req
 agg_req contains the users aggregation request. Deserialization from json is compatible with elasticsearch aggregation requests.
 
-#### agg_data
-agg_data contains the users aggregation request enriched with fast field accessors etc, which are
+#### agg_req_with_accessor
+agg_req_with_accessor contains the users aggregation request enriched with fast field accessors etc, which are
 used during collection.
 
 #### segment_agg_result
 segment_agg_result contains the aggregation result tree, which is used for collection of a segment.
-agg_data is passed during collection.
+The tree from agg_req_with_accessor is passed during collection.
 
 #### intermediate_agg_result
 intermediate_agg_result contains the aggregation tree for merging with other trees.
 
 #### agg_result
 agg_result contains the final aggregation tree.
+

src/aggregation/accessor_helpers.rs

@@ -1,104 +0,0 @@
-//! This will enhance the request tree with access to the fastfield and metadata.
-
-use std::io;
-
-use columnar::{Column, ColumnType};
-
-use crate::aggregation::{f64_to_fastfield_u64, Key};
-use crate::index::SegmentReader;
-
-/// Get the missing value as internal u64 representation
-///
-/// For terms we use u64::MAX as sentinel value
-/// For numerical data we convert the value into the representation
-/// we would get from the fast field, when we open it as u64_lenient_for_type.
-///
-/// That way we can use it the same way as if it would come from the fastfield.
-pub(crate) fn get_missing_val_as_u64_lenient(
-    column_type: ColumnType,
-    missing: &Key,
-    field_name: &str,
-) -> crate::Result<Option<u64>> {
-    let missing_val = match missing {
-        Key::Str(_) if column_type == ColumnType::Str => Some(u64::MAX),
-        // Allow fallback to number on text fields
-        Key::F64(_) if column_type == ColumnType::Str => Some(u64::MAX),
-        Key::U64(_) if column_type == ColumnType::Str => Some(u64::MAX),
-        Key::I64(_) if column_type == ColumnType::Str => Some(u64::MAX),
-        Key::F64(val) if column_type.numerical_type().is_some() => {
-            f64_to_fastfield_u64(*val, &column_type)
-        }
-        // NOTE: We may loose precision of the passed missing value by casting i64 and u64 to f64.
-        Key::I64(val) if column_type.numerical_type().is_some() => {
-            f64_to_fastfield_u64(*val as f64, &column_type)
-        }
-        Key::U64(val) if column_type.numerical_type().is_some() => {
-            f64_to_fastfield_u64(*val as f64, &column_type)
-        }
-        _ => {
-            return Err(crate::TantivyError::InvalidArgument(format!(
-                "Missing value {missing:?} for field {field_name} is not supported for column \
-                 type {column_type:?}"
-            )));
-        }
-    };
-    Ok(missing_val)
-}
-
-pub(crate) fn get_numeric_or_date_column_types() -> &'static [ColumnType] {
-    &[
-        ColumnType::F64,
-        ColumnType::U64,
-        ColumnType::I64,
-        ColumnType::DateTime,
-    ]
-}
-
-/// Get fast field reader or empty as default.
-pub(crate) fn get_ff_reader(
-    reader: &SegmentReader,
-    field_name: &str,
-    allowed_column_types: Option<&[ColumnType]>,
-) -> crate::Result<(columnar::Column<u64>, ColumnType)> {
-    let ff_fields = reader.fast_fields();
-    let ff_field_with_type = ff_fields
-        .u64_lenient_for_type(allowed_column_types, field_name)?
-        .unwrap_or_else(|| {
-            (
-                Column::build_empty_column(reader.num_docs()),
-                ColumnType::U64,
-            )
-        });
-    Ok(ff_field_with_type)
-}
-
-pub(crate) fn get_dynamic_columns(
-    reader: &SegmentReader,
-    field_name: &str,
-) -> crate::Result<Vec<columnar::DynamicColumn>> {
-    let ff_fields = reader.fast_fields().dynamic_column_handles(field_name)?;
-    let cols = ff_fields
-        .iter()
-        .map(|h| h.open())
-        .collect::<io::Result<_>>()?;
-    assert!(!ff_fields.is_empty(), "field {field_name} not found");
-    Ok(cols)
-}
-
-/// Get all fast field reader or empty as default.
-///
-/// Is guaranteed to return at least one column.
-pub(crate) fn get_all_ff_reader_or_empty(
-    reader: &SegmentReader,
-    field_name: &str,
-    allowed_column_types: Option<&[ColumnType]>,
-    fallback_type: ColumnType,
-) -> crate::Result<Vec<(columnar::Column<u64>, ColumnType)>> {
-    let ff_fields = reader.fast_fields();
-    let mut ff_field_with_type =
-        ff_fields.u64_lenient_for_type_all(allowed_column_types, field_name)?;
-    if ff_field_with_type.is_empty() {
-        ff_field_with_type.push((Column::build_empty_column(reader.num_docs()), fallback_type));
-    }
-    Ok(ff_field_with_type)
-}

src/aggregation/agg_limits.rs

@@ -70,7 +70,7 @@ impl AggregationLimitsGuard {
     /// *memory_limit*
     /// memory_limit is defined in bytes.
     /// Aggregation fails when the estimated memory consumption of the aggregation is higher than
-    /// memory_limit.
+    /// memory_limit.     
     /// memory_limit will default to `DEFAULT_MEMORY_LIMIT` (500MB)
     ///
     /// *bucket_limit*

src/aggregation/agg_req.rs

@@ -26,14 +26,12 @@
 //! let _agg_req: Aggregations = serde_json::from_str(elasticsearch_compatible_json_req).unwrap();
 //! ```
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
-use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 use super::bucket::{
-    DateHistogramAggregationReq, FilterAggregation, HistogramAggregation, RangeAggregation,
-    TermsAggregation,
+    DateHistogramAggregationReq, HistogramAggregation, RangeAggregation, TermsAggregation,
 };
 use super::metric::{
     AverageAggregation, CardinalityAggregationReq, CountAggregation, ExtendedStatsAggregation,
@@ -45,7 +43,7 @@ use super::metric::{
 /// defined names. It is also used in buckets aggregations to define sub-aggregations.
 ///
 /// The key is the user defined name of the aggregation.
-pub type Aggregations = FxHashMap<String, Aggregation>;
+pub type Aggregations = HashMap<String, Aggregation>;
 
 /// Aggregation request.
 ///
@@ -131,9 +129,6 @@ pub enum AggregationVariants {
     /// Put data into buckets of terms.
     #[serde(rename = "terms")]
     Terms(TermsAggregation),
-    /// Filter documents into a single bucket.
-    #[serde(rename = "filter")]
-    Filter(FilterAggregation),
 
     // Metric aggregation types
     /// Computes the average of the extracted values.
@@ -179,7 +174,6 @@ impl AggregationVariants {
             AggregationVariants::Range(range) => vec![range.field.as_str()],
             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::Average(avg) => vec![avg.field_name()],
             AggregationVariants::Count(count) => vec![count.field_name()],
             AggregationVariants::Max(max) => vec![max.field_name()],
@@ -214,6 +208,13 @@ impl AggregationVariants {
             _ => None,
         }
     }
+    pub(crate) fn as_top_hits(&self) -> Option<&TopHitsAggregationReq> {
+        match &self {
+            AggregationVariants::TopHits(top_hits) => Some(top_hits),
+            _ => None,
+        }
+    }
+
     pub(crate) fn as_percentile(&self) -> Option<&PercentilesAggregationReq> {
         match &self {
             AggregationVariants::Percentiles(percentile_req) => Some(percentile_req),

src/aggregation/agg_req_with_accessor.rs

@@ -0,0 +1,471 @@
+//! This will enhance the request tree with access to the fastfield and metadata.
+
+use std::collections::HashMap;
+use std::io;
+
+use columnar::{Column, ColumnBlockAccessor, ColumnType, DynamicColumn, StrColumn};
+
+use super::agg_req::{Aggregation, AggregationVariants, Aggregations};
+use super::bucket::{
+    DateHistogramAggregationReq, HistogramAggregation, RangeAggregation, TermsAggregation,
+};
+use super::metric::{
+    AverageAggregation, CardinalityAggregationReq, CountAggregation, ExtendedStatsAggregation,
+    MaxAggregation, MinAggregation, StatsAggregation, SumAggregation,
+};
+use super::segment_agg_result::AggregationLimitsGuard;
+use super::VecWithNames;
+use crate::aggregation::{f64_to_fastfield_u64, Key};
+use crate::index::SegmentReader;
+use crate::SegmentOrdinal;
+
+#[derive(Default)]
+pub(crate) struct AggregationsWithAccessor {
+    pub aggs: VecWithNames<AggregationWithAccessor>,
+}
+
+impl AggregationsWithAccessor {
+    fn from_data(aggs: VecWithNames<AggregationWithAccessor>) -> Self {
+        Self { aggs }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.aggs.is_empty()
+    }
+}
+
+pub struct AggregationWithAccessor {
+    pub(crate) segment_ordinal: SegmentOrdinal,
+    /// In general there can be buckets without fast field access, e.g. buckets that are created
+    /// based on search terms. That is not that case currently, but eventually this needs to be
+    /// Option or moved.
+    pub(crate) accessor: Column<u64>,
+    /// Load insert u64 for missing use case
+    pub(crate) missing_value_for_accessor: Option<u64>,
+    pub(crate) str_dict_column: Option<StrColumn>,
+    pub(crate) field_type: ColumnType,
+    pub(crate) sub_aggregation: AggregationsWithAccessor,
+    pub(crate) limits: AggregationLimitsGuard,
+    pub(crate) column_block_accessor: ColumnBlockAccessor<u64>,
+    /// Used for missing term aggregation, which checks all columns for existence.
+    /// And also for `top_hits` aggregation, which may sort on multiple fields.
+    /// By convention the missing aggregation is chosen, when this property is set
+    /// (instead bein set in `agg`).
+    /// If this needs to used by other aggregations, we need to refactor this.
+    // NOTE: we can make all other aggregations use this instead of the `accessor` and `field_type`
+    // (making them obsolete) But will it have a performance impact?
+    pub(crate) accessors: Vec<(Column<u64>, ColumnType)>,
+    /// Map field names to all associated column accessors.
+    /// This field is used for `docvalue_fields`, which is currently only supported for `top_hits`.
+    pub(crate) value_accessors: HashMap<String, Vec<DynamicColumn>>,
+    pub(crate) agg: Aggregation,
+}
+
+impl AggregationWithAccessor {
+    /// May return multiple accessors if the aggregation is e.g. on mixed field types.
+    fn try_from_agg(
+        agg: &Aggregation,
+        sub_aggregation: &Aggregations,
+        reader: &SegmentReader,
+        segment_ordinal: SegmentOrdinal,
+        limits: AggregationLimitsGuard,
+    ) -> crate::Result<Vec<AggregationWithAccessor>> {
+        let mut agg = agg.clone();
+
+        let add_agg_with_accessor = |agg: &Aggregation,
+                                     accessor: Column<u64>,
+                                     column_type: ColumnType,
+                                     aggs: &mut Vec<AggregationWithAccessor>|
+         -> crate::Result<()> {
+            let res = AggregationWithAccessor {
+                segment_ordinal,
+                accessor,
+                accessors: Default::default(),
+                value_accessors: Default::default(),
+                field_type: column_type,
+                sub_aggregation: get_aggs_with_segment_accessor_and_validate(
+                    sub_aggregation,
+                    reader,
+                    segment_ordinal,
+                    &limits,
+                )?,
+                agg: agg.clone(),
+                limits: limits.clone(),
+                missing_value_for_accessor: None,
+                str_dict_column: None,
+                column_block_accessor: Default::default(),
+            };
+            aggs.push(res);
+            Ok(())
+        };
+
+        let add_agg_with_accessors = |agg: &Aggregation,
+                                      accessors: Vec<(Column<u64>, ColumnType)>,
+                                      aggs: &mut Vec<AggregationWithAccessor>,
+                                      value_accessors: HashMap<String, Vec<DynamicColumn>>|
+         -> crate::Result<()> {
+            let (accessor, field_type) = accessors.first().expect("at least one accessor");
+            let limits = limits.clone();
+            let res = AggregationWithAccessor {
+                segment_ordinal,
+                // TODO: We should do away with the `accessor` field altogether
+                accessor: accessor.clone(),
+                value_accessors,
+                field_type: *field_type,
+                accessors,
+                sub_aggregation: get_aggs_with_segment_accessor_and_validate(
+                    sub_aggregation,
+                    reader,
+                    segment_ordinal,
+                    &limits,
+                )?,
+                agg: agg.clone(),
+                limits,
+                missing_value_for_accessor: None,
+                str_dict_column: None,
+                column_block_accessor: Default::default(),
+            };
+            aggs.push(res);
+            Ok(())
+        };
+
+        let mut res: Vec<AggregationWithAccessor> = Vec::new();
+        use AggregationVariants::*;
+
+        match agg.agg {
+            Range(RangeAggregation {
+                field: ref field_name,
+                ..
+            }) => {
+                let (accessor, column_type) =
+                    get_ff_reader(reader, field_name, Some(get_numeric_or_date_column_types()))?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            Histogram(HistogramAggregation {
+                field: ref field_name,
+                ..
+            }) => {
+                let (accessor, column_type) =
+                    get_ff_reader(reader, field_name, Some(get_numeric_or_date_column_types()))?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            DateHistogram(DateHistogramAggregationReq {
+                field: ref field_name,
+                ..
+            }) => {
+                let (accessor, column_type) =
+                    // Only DateTime is supported for DateHistogram
+                    get_ff_reader(reader, field_name, Some(&[ColumnType::DateTime]))?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            Terms(TermsAggregation {
+                field: ref field_name,
+                ref missing,
+                ..
+            })
+            | Cardinality(CardinalityAggregationReq {
+                field: ref field_name,
+                ref missing,
+                ..
+            }) => {
+                let str_dict_column = reader.fast_fields().str(field_name)?;
+                let allowed_column_types = [
+                    ColumnType::I64,
+                    ColumnType::U64,
+                    ColumnType::F64,
+                    ColumnType::Str,
+                    ColumnType::DateTime,
+                    ColumnType::Bool,
+                    ColumnType::IpAddr,
+                    // ColumnType::Bytes Unsupported
+                ];
+
+                // In case the column is empty we want the shim column to match the missing type
+                let fallback_type = missing
+                    .as_ref()
+                    .map(|missing| match missing {
+                        Key::Str(_) => ColumnType::Str,
+                        Key::F64(_) => ColumnType::F64,
+                        Key::I64(_) => ColumnType::I64,
+                        Key::U64(_) => ColumnType::U64,
+                    })
+                    .unwrap_or(ColumnType::U64);
+                let column_and_types = get_all_ff_reader_or_empty(
+                    reader,
+                    field_name,
+                    Some(&allowed_column_types),
+                    fallback_type,
+                )?;
+                let missing_and_more_than_one_col = column_and_types.len() > 1 && missing.is_some();
+                let text_on_non_text_col = column_and_types.len() == 1
+                    && column_and_types[0].1.numerical_type().is_some()
+                    && missing
+                        .as_ref()
+                        .map(|m| matches!(m, Key::Str(_)))
+                        .unwrap_or(false);
+
+                // Actually we could convert the text to a number and have the fast path, if it is
+                // provided in Rfc3339 format. But this use case is probably common
+                // enough to justify the effort.
+                let text_on_date_col = column_and_types.len() == 1
+                    && column_and_types[0].1 == ColumnType::DateTime
+                    && missing
+                        .as_ref()
+                        .map(|m| matches!(m, Key::Str(_)))
+                        .unwrap_or(false);
+
+                let use_special_missing_agg =
+                    missing_and_more_than_one_col || text_on_non_text_col || text_on_date_col;
+                if use_special_missing_agg {
+                    let column_and_types =
+                        get_all_ff_reader_or_empty(reader, field_name, None, fallback_type)?;
+
+                    let accessors = column_and_types
+                        .iter()
+                        .map(|c_t| (c_t.0.clone(), c_t.1))
+                        .collect();
+                    add_agg_with_accessors(&agg, accessors, &mut res, Default::default())?;
+                }
+
+                for (accessor, column_type) in column_and_types {
+                    let missing_value_term_agg = if use_special_missing_agg {
+                        None
+                    } else {
+                        missing.clone()
+                    };
+
+                    let missing_value_for_accessor =
+                        if let Some(missing) = missing_value_term_agg.as_ref() {
+                            get_missing_val_as_u64_lenient(
+                                column_type,
+                                missing,
+                                agg.agg.get_fast_field_names()[0],
+                            )?
+                        } else {
+                            None
+                        };
+
+                    let limits = limits.clone();
+                    let agg = AggregationWithAccessor {
+                        segment_ordinal,
+                        missing_value_for_accessor,
+                        accessor,
+                        accessors: Default::default(),
+                        value_accessors: Default::default(),
+                        field_type: column_type,
+                        sub_aggregation: get_aggs_with_segment_accessor_and_validate(
+                            sub_aggregation,
+                            reader,
+                            segment_ordinal,
+                            &limits,
+                        )?,
+                        agg: agg.clone(),
+                        str_dict_column: str_dict_column.clone(),
+                        limits,
+                        column_block_accessor: Default::default(),
+                    };
+                    res.push(agg);
+                }
+            }
+            Average(AverageAggregation {
+                field: ref field_name,
+                ..
+            })
+            | Max(MaxAggregation {
+                field: ref field_name,
+                ..
+            })
+            | Min(MinAggregation {
+                field: ref field_name,
+                ..
+            })
+            | Stats(StatsAggregation {
+                field: ref field_name,
+                ..
+            })
+            | ExtendedStats(ExtendedStatsAggregation {
+                field: ref field_name,
+                ..
+            })
+            | Sum(SumAggregation {
+                field: ref field_name,
+                ..
+            }) => {
+                let (accessor, column_type) =
+                    get_ff_reader(reader, field_name, Some(get_numeric_or_date_column_types()))?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            Count(CountAggregation {
+                field: ref field_name,
+                ..
+            }) => {
+                let allowed_column_types = [
+                    ColumnType::I64,
+                    ColumnType::U64,
+                    ColumnType::F64,
+                    ColumnType::Str,
+                    ColumnType::DateTime,
+                    ColumnType::Bool,
+                    ColumnType::IpAddr,
+                    // ColumnType::Bytes Unsupported
+                ];
+                let (accessor, column_type) =
+                    get_ff_reader(reader, field_name, Some(&allowed_column_types))?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            Percentiles(ref percentiles) => {
+                let (accessor, column_type) = get_ff_reader(
+                    reader,
+                    percentiles.field_name(),
+                    Some(get_numeric_or_date_column_types()),
+                )?;
+                add_agg_with_accessor(&agg, accessor, column_type, &mut res)?;
+            }
+            TopHits(ref mut top_hits) => {
+                top_hits.validate_and_resolve_field_names(reader.fast_fields().columnar())?;
+                let accessors: Vec<(Column<u64>, ColumnType)> = top_hits
+                    .field_names()
+                    .iter()
+                    .map(|field| {
+                        get_ff_reader(reader, field, Some(get_numeric_or_date_column_types()))
+                    })
+                    .collect::<crate::Result<_>>()?;
+
+                let value_accessors = top_hits
+                    .value_field_names()
+                    .iter()
+                    .map(|field_name| {
+                        Ok((
+                            field_name.to_string(),
+                            get_dynamic_columns(reader, field_name)?,
+                        ))
+                    })
+                    .collect::<crate::Result<_>>()?;
+
+                add_agg_with_accessors(&agg, accessors, &mut res, value_accessors)?;
+            }
+        };
+
+        Ok(res)
+    }
+}
+
+/// Get the missing value as internal u64 representation
+///
+/// For terms we use u64::MAX as sentinel value
+/// For numerical data we convert the value into the representation
+/// we would get from the fast field, when we open it as u64_lenient_for_type.
+///
+/// That way we can use it the same way as if it would come from the fastfield.
+fn get_missing_val_as_u64_lenient(
+    column_type: ColumnType,
+    missing: &Key,
+    field_name: &str,
+) -> crate::Result<Option<u64>> {
+    let missing_val = match missing {
+        Key::Str(_) if column_type == ColumnType::Str => Some(u64::MAX),
+        // Allow fallback to number on text fields
+        Key::F64(_) if column_type == ColumnType::Str => Some(u64::MAX),
+        Key::U64(_) if column_type == ColumnType::Str => Some(u64::MAX),
+        Key::I64(_) if column_type == ColumnType::Str => Some(u64::MAX),
+        Key::F64(val) if column_type.numerical_type().is_some() => {
+            f64_to_fastfield_u64(*val, &column_type)
+        }
+        // NOTE: We may loose precision of the passed missing value by casting i64 and u64 to f64.
+        Key::I64(val) if column_type.numerical_type().is_some() => {
+            f64_to_fastfield_u64(*val as f64, &column_type)
+        }
+        Key::U64(val) if column_type.numerical_type().is_some() => {
+            f64_to_fastfield_u64(*val as f64, &column_type)
+        }
+        _ => {
+            return Err(crate::TantivyError::InvalidArgument(format!(
+                "Missing value {missing:?} for field {field_name} is not supported for column \
+                 type {column_type:?}"
+            )));
+        }
+    };
+    Ok(missing_val)
+}
+
+fn get_numeric_or_date_column_types() -> &'static [ColumnType] {
+    &[
+        ColumnType::F64,
+        ColumnType::U64,
+        ColumnType::I64,
+        ColumnType::DateTime,
+    ]
+}
+
+pub(crate) fn get_aggs_with_segment_accessor_and_validate(
+    aggs: &Aggregations,
+    reader: &SegmentReader,
+    segment_ordinal: SegmentOrdinal,
+    limits: &AggregationLimitsGuard,
+) -> crate::Result<AggregationsWithAccessor> {
+    let mut aggss = Vec::new();
+    for (key, agg) in aggs.iter() {
+        let aggs = AggregationWithAccessor::try_from_agg(
+            agg,
+            agg.sub_aggregation(),
+            reader,
+            segment_ordinal,
+            limits.clone(),
+        )?;
+        for agg in aggs {
+            aggss.push((key.to_string(), agg));
+        }
+    }
+    Ok(AggregationsWithAccessor::from_data(
+        VecWithNames::from_entries(aggss),
+    ))
+}
+
+/// Get fast field reader or empty as default.
+fn get_ff_reader(
+    reader: &SegmentReader,
+    field_name: &str,
+    allowed_column_types: Option<&[ColumnType]>,
+) -> crate::Result<(columnar::Column<u64>, ColumnType)> {
+    let ff_fields = reader.fast_fields();
+    let ff_field_with_type = ff_fields
+        .u64_lenient_for_type(allowed_column_types, field_name)?
+        .unwrap_or_else(|| {
+            (
+                Column::build_empty_column(reader.num_docs()),
+                ColumnType::U64,
+            )
+        });
+    Ok(ff_field_with_type)
+}
+
+fn get_dynamic_columns(
+    reader: &SegmentReader,
+    field_name: &str,
+) -> crate::Result<Vec<columnar::DynamicColumn>> {
+    let ff_fields = reader.fast_fields().dynamic_column_handles(field_name)?;
+    let cols = ff_fields
+        .iter()
+        .map(|h| h.open())
+        .collect::<io::Result<_>>()?;
+    assert!(!ff_fields.is_empty(), "field {field_name} not found");
+    Ok(cols)
+}
+
+/// Get all fast field reader or empty as default.
+///
+/// Is guaranteed to return at least one column.
+fn get_all_ff_reader_or_empty(
+    reader: &SegmentReader,
+    field_name: &str,
+    allowed_column_types: Option<&[ColumnType]>,
+    fallback_type: ColumnType,
+) -> crate::Result<Vec<(columnar::Column<u64>, ColumnType)>> {
+    let ff_fields = reader.fast_fields();
+    let mut ff_field_with_type =
+        ff_fields.u64_lenient_for_type_all(allowed_column_types, field_name)?;
+    if ff_field_with_type.is_empty() {
+        ff_field_with_type.push((Column::build_empty_column(reader.num_docs()), fallback_type));
+    }
+    Ok(ff_field_with_type)
+}

src/aggregation/agg_result.rs

@@ -156,8 +156,6 @@ pub enum BucketResult {
         /// The upper bound error for the doc count of each term.
         doc_count_error_upper_bound: Option<u64>,
     },
-    /// This is the filter result - a single bucket with sub-aggregations
-    Filter(FilterBucketResult),
 }
 
 impl BucketResult {
@@ -174,11 +172,6 @@ impl BucketResult {
                 sum_other_doc_count: _,
                 doc_count_error_upper_bound: _,
             } => buckets.iter().map(|bucket| bucket.get_bucket_count()).sum(),
-            BucketResult::Filter(filter_result) => {
-                // Filter doesn't add to bucket count - it's not a user-facing bucket
-                // Only count sub-aggregation buckets
-                filter_result.sub_aggregations.get_bucket_count()
-            }
         }
     }
 }
@@ -315,25 +308,3 @@ impl RangeBucketEntry {
         1 + self.sub_aggregation.get_bucket_count()
     }
 }
-
-/// This is the filter bucket result, which contains the document count and sub-aggregations.
-///
-/// # JSON Format
-/// ```json
-/// {
-///   "electronics_only": {
-///     "doc_count": 2,
-///     "avg_price": {
-///       "value": 150.0
-///     }
-///   }
-/// }
-/// ```
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct FilterBucketResult {
-    /// Number of documents in the filter bucket
-    pub doc_count: u64,
-    /// Sub-aggregation results
-    #[serde(flatten)]
-    pub sub_aggregations: AggregationResults,
-}

src/aggregation/agg_tests.rs

@@ -5,6 +5,7 @@ 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::segment_agg_result::AggregationLimitsGuard;
 use crate::aggregation::tests::{get_test_index_2_segments, get_test_index_from_values_and_terms};
 use crate::aggregation::DistributedAggregationCollector;
 use crate::query::{AllQuery, TermQuery};
@@ -127,8 +128,10 @@ fn test_aggregation_flushing(
             .unwrap();
 
     let agg_res: AggregationResults = if use_distributed_collector {
-        let collector =
-            DistributedAggregationCollector::from_aggs(agg_req.clone(), Default::default());
+        let collector = DistributedAggregationCollector::from_aggs(
+            agg_req.clone(),
+            AggregationLimitsGuard::default(),
+        );
 
         let searcher = reader.searcher();
         let intermediate_agg_result = searcher.search(&AllQuery, &collector).unwrap();

src/aggregation/bucket/histogram/histogram.rs

@@ -1,54 +1,25 @@
 use std::cmp::Ordering;
 
-use columnar::{Column, ColumnBlockAccessor, ColumnType};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 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_req_with_accessor::{
+    AggregationWithAccessor, AggregationsWithAccessor,
+};
 use crate::aggregation::agg_result::BucketEntry;
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateHistogramBucketEntry,
 };
-use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
+use crate::aggregation::segment_agg_result::{
+    build_segment_agg_collector, SegmentAggregationCollector,
+};
 use crate::aggregation::*;
 use crate::TantivyError;
 
-/// Contains all information required by the SegmentHistogramCollector to perform the
-/// histogram or date_histogram aggregation on a segment.
-pub struct HistogramAggReqData {
-    /// The column accessor to access the fast field values.
-    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.
-    pub is_date_histogram: bool,
-    /// The bounds to limit the buckets to.
-    pub bounds: HistogramBounds,
-    /// The offset used to calculate the bucket position.
-    pub offset: f64,
-}
-impl HistogramAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
-
 /// Histogram is a bucket aggregation, where buckets are created dynamically for given `interval`.
 /// Each document value is rounded down to its bucket.
 ///
@@ -263,12 +234,12 @@ impl SegmentHistogramBucketEntry {
     pub(crate) fn into_intermediate_bucket_entry(
         self,
         sub_aggregation: Option<Box<dyn SegmentAggregationCollector>>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
     ) -> crate::Result<IntermediateHistogramBucketEntry> {
         let mut sub_aggregation_res = IntermediateAggregationResults::default();
         if let Some(sub_aggregation) = sub_aggregation {
             sub_aggregation
-                .add_intermediate_aggregation_result(agg_data, &mut sub_aggregation_res)?;
+                .add_intermediate_aggregation_result(agg_with_accessor, &mut sub_aggregation_res)?;
         }
         Ok(IntermediateHistogramBucketEntry {
             key: self.key,
@@ -285,20 +256,24 @@ pub struct SegmentHistogramCollector {
     /// The buckets containing the aggregation data.
     buckets: FxHashMap<i64, SegmentHistogramBucketEntry>,
     sub_aggregations: FxHashMap<i64, Box<dyn SegmentAggregationCollector>>,
+    sub_aggregation_blueprint: Option<Box<dyn SegmentAggregationCollector>>,
+    column_type: ColumnType,
+    interval: f64,
+    offset: f64,
+    bounds: HistogramBounds,
     accessor_idx: usize,
 }
 
 impl SegmentAggregationCollector for SegmentHistogramCollector {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let name = agg_data
-            .get_histogram_req_data(self.accessor_idx)
-            .name
-            .clone();
-        let bucket = self.into_intermediate_bucket_result(agg_data)?;
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
+        let agg_with_accessor = &agg_with_accessor.aggs.values[self.accessor_idx];
+
+        let bucket = self.into_intermediate_bucket_result(agg_with_accessor)?;
         results.push(name, IntermediateAggregationResult::Bucket(bucket))?;
 
         Ok(())
@@ -308,52 +283,56 @@ impl SegmentAggregationCollector for SegmentHistogramCollector {
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        self.collect_block(&[doc], agg_data)
+        self.collect_block(&[doc], agg_with_accessor)
     }
 
     #[inline]
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let mut req = agg_data.take_histogram_req_data(self.accessor_idx);
+        let bucket_agg_accessor = &mut agg_with_accessor.aggs.values[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;
+        let bounds = self.bounds;
+        let interval = self.interval;
+        let offset = self.offset;
+        let get_bucket_pos = |val| (get_bucket_pos_f64(val, interval, offset) as i64);
 
-        req.column_block_accessor.fetch_block(docs, &req.accessor);
-        for (doc, val) in req
+        bucket_agg_accessor
             .column_block_accessor
-            .iter_docid_vals(docs, &req.accessor)
+            .fetch_block(docs, &bucket_agg_accessor.accessor);
+
+        for (doc, val) in bucket_agg_accessor
+            .column_block_accessor
+            .iter_docid_vals(docs, &bucket_agg_accessor.accessor)
         {
-            let val = f64_from_fastfield_u64(val, &req.field_type);
+            let val = self.f64_from_fastfield_u64(val);
+
             let bucket_pos = get_bucket_pos(val);
+
             if bounds.contains(val) {
                 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.doc_count += 1;
-                if let Some(sub_aggregation_blueprint) = req.sub_aggregation_blueprint.as_ref() {
+                if let Some(sub_aggregation_blueprint) = self.sub_aggregation_blueprint.as_mut() {
                     self.sub_aggregations
                         .entry(bucket_pos)
                         .or_insert_with(|| sub_aggregation_blueprint.clone())
-                        .collect(doc, agg_data)?;
+                        .collect(doc, &mut bucket_agg_accessor.sub_aggregation)?;
                 }
             }
         }
-        agg_data.put_back_histogram_req_data(self.accessor_idx, req);
 
         let mem_delta = self.get_memory_consumption() - mem_pre;
         if mem_delta > 0 {
-            agg_data
-                .context
+            bucket_agg_accessor
                 .limits
                 .add_memory_consumed(mem_delta as u64)?;
         }
@@ -361,9 +340,12 @@ impl SegmentAggregationCollector for SegmentHistogramCollector {
         Ok(())
     }
 
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+    fn flush(&mut self, agg_with_accessor: &mut AggregationsWithAccessor) -> crate::Result<()> {
+        let sub_aggregation_accessor =
+            &mut agg_with_accessor.aggs.values[self.accessor_idx].sub_aggregation;
+
         for sub_aggregation in self.sub_aggregations.values_mut() {
-            sub_aggregation.flush(agg_data)?;
+            sub_aggregation.flush(sub_aggregation_accessor)?;
         }
 
         Ok(())
@@ -380,58 +362,65 @@ impl SegmentHistogramCollector {
     /// Converts the collector result into a intermediate bucket result.
     pub fn into_intermediate_bucket_result(
         self,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationWithAccessor,
     ) -> crate::Result<IntermediateBucketResult> {
         let mut buckets = Vec::with_capacity(self.buckets.len());
 
         for (bucket_pos, bucket) in self.buckets {
             let bucket_res = bucket.into_intermediate_bucket_entry(
                 self.sub_aggregations.get(&bucket_pos).cloned(),
-                agg_data,
+                &agg_with_accessor.sub_aggregation,
             );
 
             buckets.push(bucket_res?);
         }
         buckets.sort_unstable_by(|b1, b2| b1.key.total_cmp(&b2.key));
 
-        let is_date_agg = agg_data
-            .get_histogram_req_data(self.accessor_idx)
-            .field_type
-            == ColumnType::DateTime;
         Ok(IntermediateBucketResult::Histogram {
             buckets,
-            is_date_agg,
+            is_date_agg: self.column_type == ColumnType::DateTime,
         })
     }
 
     pub(crate) fn from_req_and_validate(
-        agg_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
+        mut req: HistogramAggregation,
+        sub_aggregation: &mut AggregationsWithAccessor,
+        field_type: ColumnType,
+        accessor_idx: usize,
     ) -> crate::Result<Self> {
-        let blueprint = if !node.children.is_empty() {
-            Some(build_segment_agg_collectors(agg_data, &node.children)?)
-        } else {
-            None
-        };
-        let req_data = agg_data.get_histogram_req_data_mut(node.idx_in_req_data);
-        req_data.req.validate()?;
-        if req_data.field_type == ColumnType::DateTime && !req_data.is_date_histogram {
-            req_data.req.normalize_date_time();
+        req.validate()?;
+        if field_type == ColumnType::DateTime {
+            req.normalize_date_time();
         }
-        req_data.bounds = req_data.req.hard_bounds.unwrap_or(HistogramBounds {
+
+        let sub_aggregation_blueprint = if sub_aggregation.is_empty() {
+            None
+        } else {
+            let sub_aggregation = build_segment_agg_collector(sub_aggregation)?;
+            Some(sub_aggregation)
+        };
+
+        let bounds = req.hard_bounds.unwrap_or(HistogramBounds {
             min: f64::MIN,
             max: f64::MAX,
         });
-        req_data.offset = req_data.req.offset.unwrap_or(0.0);
-
-        req_data.sub_aggregation_blueprint = blueprint;
 
         Ok(Self {
             buckets: Default::default(),
+            column_type: field_type,
+            interval: req.interval,
+            offset: req.offset.unwrap_or(0.0),
+            bounds,
             sub_aggregations: Default::default(),
-            accessor_idx: node.idx_in_req_data,
+            sub_aggregation_blueprint,
+            accessor_idx,
         })
     }
+
+    #[inline]
+    fn f64_from_fastfield_u64(&self, val: u64) -> f64 {
+        f64_from_fastfield_u64(val, &self.column_type)
+    }
 }
 
 #[inline]

src/aggregation/bucket/mod.rs

@@ -22,7 +22,6 @@
 //! - [Range](RangeAggregation)
 //! - [Terms](TermsAggregation)
 
-mod filter;
 mod histogram;
 mod range;
 mod term_agg;
@@ -31,7 +30,6 @@ mod term_missing_agg;
 use std::collections::HashMap;
 use std::fmt;
 
-pub use filter::*;
 pub use histogram::*;
 pub use range::*;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};

src/aggregation/bucket/range.rs

@@ -1,43 +1,20 @@
 use std::fmt::Debug;
 use std::ops::Range;
 
-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_req_with_accessor::AggregationsWithAccessor;
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateRangeBucketEntry, IntermediateRangeBucketResult,
 };
-use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
+use crate::aggregation::segment_agg_result::{
+    build_segment_agg_collector, SegmentAggregationCollector,
+};
 use crate::aggregation::*;
 use crate::TantivyError;
 
-/// Contains all information required by the SegmentRangeCollector to perform the
-/// range aggregation on a segment.
-pub struct RangeAggReqData {
-    /// The column accessor to access the fast field values.
-    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,
-}
-
-impl RangeAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
-
 /// Provide user-defined buckets to aggregate on.
 ///
 /// Two special buckets will automatically be created to cover the whole range of values.
@@ -184,12 +161,12 @@ impl Debug for SegmentRangeBucketEntry {
 impl SegmentRangeBucketEntry {
     pub(crate) fn into_intermediate_bucket_entry(
         self,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
     ) -> crate::Result<IntermediateRangeBucketEntry> {
         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)?
+                .add_intermediate_aggregation_result(agg_with_accessor, &mut sub_aggregation_res)?
         } else {
             Default::default()
         };
@@ -207,14 +184,12 @@ impl SegmentRangeBucketEntry {
 impl SegmentAggregationCollector for SegmentRangeCollector {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
         let field_type = self.column_type;
-        let name = agg_data
-            .get_range_req_data(self.accessor_idx)
-            .name
-            .to_string();
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
+        let sub_agg = &agg_with_accessor.aggs.values[self.accessor_idx].sub_aggregation;
 
         let buckets: FxHashMap<SerializedKey, IntermediateRangeBucketEntry> = self
             .buckets
@@ -224,7 +199,7 @@ impl SegmentAggregationCollector for SegmentRangeCollector {
                     range_to_string(&range_bucket.range, &field_type)?,
                     range_bucket
                         .bucket
-                        .into_intermediate_bucket_entry(agg_data)?,
+                        .into_intermediate_bucket_entry(sub_agg)?,
                 ))
             })
             .collect::<crate::Result<_>>()?;
@@ -243,70 +218,66 @@ impl SegmentAggregationCollector for SegmentRangeCollector {
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        self.collect_block(&[doc], agg_data)
+        self.collect_block(&[doc], agg_with_accessor)
     }
 
     #[inline]
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        // Take request data to avoid borrow conflicts during sub-aggregation
-        let mut req = agg_data.take_range_req_data(self.accessor_idx);
+        let bucket_agg_accessor = &mut agg_with_accessor.aggs.values[self.accessor_idx];
 
-        req.column_block_accessor.fetch_block(docs, &req.accessor);
-
-        for (doc, val) in req
+        bucket_agg_accessor
             .column_block_accessor
-            .iter_docid_vals(docs, &req.accessor)
+            .fetch_block(docs, &bucket_agg_accessor.accessor);
+
+        for (doc, val) in bucket_agg_accessor
+            .column_block_accessor
+            .iter_docid_vals(docs, &bucket_agg_accessor.accessor)
         {
             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) = bucket.bucket.sub_aggregation.as_mut() {
-                sub_agg.collect(doc, agg_data)?;
+            if let Some(sub_aggregation) = &mut bucket.bucket.sub_aggregation {
+                sub_aggregation.collect(doc, &mut bucket_agg_accessor.sub_aggregation)?;
             }
         }
 
-        agg_data.put_back_range_req_data(self.accessor_idx, req);
-
         Ok(())
     }
 
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+    fn flush(&mut self, agg_with_accessor: &mut AggregationsWithAccessor) -> crate::Result<()> {
+        let sub_aggregation_accessor =
+            &mut agg_with_accessor.aggs.values[self.accessor_idx].sub_aggregation;
+
         for bucket in self.buckets.iter_mut() {
             if let Some(sub_agg) = bucket.bucket.sub_aggregation.as_mut() {
-                sub_agg.flush(agg_data)?;
+                sub_agg.flush(sub_aggregation_accessor)?;
             }
         }
+
         Ok(())
     }
 }
 
 impl SegmentRangeCollector {
     pub(crate) fn from_req_and_validate(
-        req_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
+        req: &RangeAggregation,
+        sub_aggregation: &mut AggregationsWithAccessor,
+        limits: &mut AggregationLimitsGuard,
+        field_type: ColumnType,
+        accessor_idx: usize,
     ) -> 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 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)?
+        let buckets: Vec<_> = extend_validate_ranges(&req.ranges, &field_type)?
             .iter()
             .map(|range| {
                 let key = range
@@ -324,7 +295,11 @@ impl SegmentRangeCollector {
                 } else {
                     Some(f64_from_fastfield_u64(range.range.start, &field_type))
                 };
-                let sub_aggregation = sub_agg_prototype.clone();
+                let sub_aggregation = if sub_aggregation.is_empty() {
+                    None
+                } else {
+                    Some(build_segment_agg_collector(sub_aggregation)?)
+                };
 
                 Ok(SegmentRangeAndBucketEntry {
                     range: range.range.clone(),
@@ -339,7 +314,7 @@ impl SegmentRangeCollector {
             })
             .collect::<crate::Result<_>>()?;
 
-        req_data.context.limits.add_memory_consumed(
+        limits.add_memory_consumed(
             buckets.len() as u64 * std::mem::size_of::<SegmentRangeAndBucketEntry>() as u64,
         )?;
 
@@ -492,45 +467,15 @@ mod tests {
             ranges,
             ..Default::default()
         };
-        // Build buckets directly as in from_req_and_validate without AggregationsData
-        let buckets: Vec<_> = extend_validate_ranges(&req.ranges, &field_type)
-            .expect("unexpected error in extend_validate_ranges")
-            .iter()
-            .map(|range| {
-                let key = range
-                    .key
-                    .clone()
-                    .map(|key| Ok(Key::Str(key)))
-                    .unwrap_or_else(|| range_to_key(&range.range, &field_type))
-                    .expect("unexpected error in range_to_key");
-                let to = if range.range.end == u64::MAX {
-                    None
-                } else {
-                    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))
-                };
-                SegmentRangeAndBucketEntry {
-                    range: range.range.clone(),
-                    bucket: SegmentRangeBucketEntry {
-                        doc_count: 0,
-                        sub_aggregation: None,
-                        key,
-                        from,
-                        to,
-                    },
-                }
-            })
-            .collect();
 
-        SegmentRangeCollector {
-            buckets,
-            column_type: field_type,
-            accessor_idx: 0,
-        }
+        SegmentRangeCollector::from_req_and_validate(
+            &req,
+            &mut Default::default(),
+            &mut AggregationLimitsGuard::default(),
+            field_type,
+            0,
+        )
+        .expect("unexpected error")
     }
 
     #[test]

src/aggregation/bucket/term_agg/default_impl.rs

@@ -1,196 +0,0 @@
-use std::fmt::Debug;
-
-use columnar::ColumnType;
-use rustc_hash::FxHashMap;
-
-use super::OrderTarget;
-use crate::aggregation::agg_data::{
-    build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
-};
-use crate::aggregation::agg_limits::MemoryConsumption;
-use crate::aggregation::bucket::get_agg_name_and_property;
-use crate::aggregation::intermediate_agg_result::{
-    IntermediateAggregationResult, IntermediateAggregationResults,
-};
-use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
-use crate::TantivyError;
-
-#[derive(Clone, Debug, Default)]
-/// Container to store term_ids/or u64 values and their buckets.
-struct TermBuckets {
-    pub(crate) entries: FxHashMap<u64, u32>,
-    pub(crate) sub_aggs: FxHashMap<u64, Box<dyn SegmentAggregationCollector>>,
-}
-
-impl TermBuckets {
-    fn get_memory_consumption(&self) -> usize {
-        let sub_aggs_mem = self.sub_aggs.memory_consumption();
-        let buckets_mem = self.entries.memory_consumption();
-        sub_aggs_mem + buckets_mem
-    }
-
-    fn force_flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        for sub_aggregations in &mut self.sub_aggs.values_mut() {
-            sub_aggregations.as_mut().flush(agg_data)?;
-        }
-        Ok(())
-    }
-}
-
-/// The collector puts values from the fast field into the correct buckets and does a conversion to
-/// the correct datatype.
-#[derive(Clone, Debug)]
-pub struct SegmentTermCollector {
-    /// The buckets containing the aggregation data.
-    term_buckets: TermBuckets,
-    accessor_idx: usize,
-}
-
-impl SegmentAggregationCollector for SegmentTermCollector {
-    fn add_intermediate_aggregation_result(
-        self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
-        results: &mut IntermediateAggregationResults,
-    ) -> crate::Result<()> {
-        let name = agg_data.get_term_req_data(self.accessor_idx).name.clone();
-
-        let entries: Vec<(u64, u32)> = self.term_buckets.entries.into_iter().collect();
-        let bucket = super::into_intermediate_bucket_result(
-            self.accessor_idx,
-            entries,
-            self.term_buckets.sub_aggs,
-            agg_data,
-        )?;
-        results.push(name, IntermediateAggregationResult::Bucket(bucket))?;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn collect(
-        &mut self,
-        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 mut req_data = agg_data.take_term_req_data(self.accessor_idx);
-
-        let mem_pre = self.get_memory_consumption();
-
-        if let Some(missing) = req_data.missing_value_for_accessor {
-            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 term_id in req_data.column_block_accessor.iter_vals() {
-            if let Some(allowed_bs) = req_data.allowed_term_ids.as_ref() {
-                if !allowed_bs.contains(term_id as u32) {
-                    continue;
-                }
-            }
-            let entry = self.term_buckets.entries.entry(term_id).or_default();
-            *entry += 1;
-        }
-        // has subagg
-        if let Some(blueprint) = req_data.sub_aggregation_blueprint.as_ref() {
-            for (doc, term_id) in req_data
-                .column_block_accessor
-                .iter_docid_vals(docs, &req_data.accessor)
-            {
-                if let Some(allowed_bs) = req_data.allowed_term_ids.as_ref() {
-                    if !allowed_bs.contains(term_id as u32) {
-                        continue;
-                    }
-                }
-                let sub_aggregations = self
-                    .term_buckets
-                    .sub_aggs
-                    .entry(term_id)
-                    .or_insert_with(|| blueprint.clone());
-                sub_aggregations.collect(doc, agg_data)?;
-            }
-        }
-
-        let mem_delta = self.get_memory_consumption() - mem_pre;
-        if mem_delta > 0 {
-            agg_data
-                .context
-                .limits
-                .add_memory_consumed(mem_delta as u64)?;
-        }
-        agg_data.put_back_term_req_data(self.accessor_idx, req_data);
-
-        Ok(())
-    }
-
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        self.term_buckets.force_flush(agg_data)?;
-        Ok(())
-    }
-}
-
-impl SegmentTermCollector {
-    pub fn from_req_and_validate(
-        req_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
-    ) -> crate::Result<Self> {
-        let terms_req_data = req_data.get_term_req_data(node.idx_in_req_data);
-        let column_type = terms_req_data.column_type;
-        let accessor_idx = node.idx_in_req_data;
-        if column_type == ColumnType::Bytes {
-            return Err(TantivyError::InvalidArgument(format!(
-                "terms aggregation is not supported for column type {column_type:?}"
-            )));
-        }
-        let term_buckets = TermBuckets::default();
-
-        // Validate sub aggregation exists
-        if let OrderTarget::SubAggregation(sub_agg_name) = &terms_req_data.req.order.target {
-            let (agg_name, _agg_property) = get_agg_name_and_property(sub_agg_name);
-
-            node.get_sub_agg(agg_name, &req_data.per_request)
-                .ok_or_else(|| {
-                    TantivyError::InvalidArgument(format!(
-                        "could not find aggregation with name {agg_name} in metric \
-                         sub_aggregations"
-                    ))
-                })?;
-        }
-
-        let has_sub_aggregations = !node.children.is_empty();
-        let blueprint = if has_sub_aggregations {
-            let sub_aggregation = build_segment_agg_collectors(req_data, &node.children)?;
-            Some(sub_aggregation)
-        } else {
-            None
-        };
-        let terms_req_data = req_data.get_term_req_data_mut(node.idx_in_req_data);
-        terms_req_data.sub_aggregation_blueprint = blueprint;
-
-        Ok(SegmentTermCollector {
-            term_buckets,
-            accessor_idx,
-        })
-    }
-
-    fn get_memory_consumption(&self) -> usize {
-        let self_mem = std::mem::size_of::<Self>();
-        let term_buckets_mem = self.term_buckets.get_memory_consumption();
-        self_mem + term_buckets_mem
-    }
-}

src/aggregation/bucket/term_agg/low_cardinality_impl.rs

@@ -1,228 +0,0 @@
-use std::vec;
-
-use rustc_hash::FxHashMap;
-
-use crate::aggregation::agg_data::{
-    build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
-};
-use crate::aggregation::bucket::{get_agg_name_and_property, OrderTarget};
-use crate::aggregation::intermediate_agg_result::{
-    IntermediateAggregationResult, IntermediateAggregationResults,
-};
-use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
-use crate::{DocId, TantivyError};
-
-const MAX_BATCH_SIZE: usize = 1_024;
-
-#[derive(Debug, Clone)]
-struct LowCardTermBuckets {
-    entries: Box<[u32]>,
-    sub_aggs: Vec<Box<dyn SegmentAggregationCollector>>,
-    doc_buffers: Box<[Vec<DocId>]>,
-}
-
-impl LowCardTermBuckets {
-    pub fn with_num_buckets(
-        num_buckets: usize,
-        sub_aggs_blueprint_opt: Option<&Box<dyn SegmentAggregationCollector>>,
-    ) -> Self {
-        let sub_aggs = sub_aggs_blueprint_opt
-            .as_ref()
-            .map(|blueprint| {
-                std::iter::repeat_with(|| blueprint.clone_box())
-                    .take(num_buckets)
-                    .collect::<Vec<_>>()
-            })
-            .unwrap_or_default();
-        Self {
-            entries: vec![0; num_buckets].into_boxed_slice(),
-            sub_aggs,
-            doc_buffers: std::iter::repeat_with(|| Vec::with_capacity(MAX_BATCH_SIZE))
-                .take(num_buckets)
-                .collect::<Vec<_>>()
-                .into_boxed_slice(),
-        }
-    }
-
-    fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-            + self.entries.len() * std::mem::size_of::<u32>()
-            + self.doc_buffers.len()
-                * (std::mem::size_of::<Vec<DocId>>()
-                    + std::mem::size_of::<DocId>() * MAX_BATCH_SIZE)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct LowCardSegmentTermCollector {
-    term_buckets: LowCardTermBuckets,
-    accessor_idx: usize,
-}
-
-impl LowCardSegmentTermCollector {
-    pub fn from_req_and_validate(
-        req_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
-    ) -> crate::Result<Self> {
-        let terms_req_data = req_data.get_term_req_data(node.idx_in_req_data);
-        let accessor_idx = node.idx_in_req_data;
-        let cardinality = terms_req_data
-            .accessor
-            .max_value()
-            .max(terms_req_data.missing_value_for_accessor.unwrap_or(0))
-            + 1;
-        assert!(cardinality <= super::LOW_CARDINALITY_THRESHOLD);
-
-        // Validate sub aggregation exists
-        if let OrderTarget::SubAggregation(sub_agg_name) = &terms_req_data.req.order.target {
-            let (agg_name, _agg_property) = get_agg_name_and_property(sub_agg_name);
-
-            node.get_sub_agg(agg_name, &req_data.per_request)
-                .ok_or_else(|| {
-                    TantivyError::InvalidArgument(format!(
-                        "could not find aggregation with name {agg_name} in metric \
-                         sub_aggregations"
-                    ))
-                })?;
-        }
-
-        let has_sub_aggregations = !node.children.is_empty();
-        let blueprint = if has_sub_aggregations {
-            let sub_aggregation = build_segment_agg_collectors(req_data, &node.children)?;
-            Some(sub_aggregation)
-        } else {
-            None
-        };
-        let terms_req_data = req_data.get_term_req_data_mut(node.idx_in_req_data);
-
-        let term_buckets =
-            LowCardTermBuckets::with_num_buckets(cardinality as usize, blueprint.as_ref());
-
-        terms_req_data.sub_aggregation_blueprint = blueprint;
-
-        Ok(LowCardSegmentTermCollector {
-            term_buckets,
-            accessor_idx,
-        })
-    }
-
-    fn get_memory_consumption(&self) -> usize {
-        let self_mem = std::mem::size_of::<Self>();
-        let term_buckets_mem = self.term_buckets.get_memory_consumption();
-        self_mem + term_buckets_mem
-    }
-}
-
-impl SegmentAggregationCollector for LowCardSegmentTermCollector {
-    fn add_intermediate_aggregation_result(
-        self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
-        results: &mut IntermediateAggregationResults,
-    ) -> crate::Result<()> {
-        let name = agg_data.get_term_req_data(self.accessor_idx).name.clone();
-        let sub_aggs: FxHashMap<u64, Box<dyn SegmentAggregationCollector>> = self
-            .term_buckets
-            .sub_aggs
-            .into_iter()
-            .enumerate()
-            .filter(|(bucket_id, _sub_agg)| self.term_buckets.entries[*bucket_id] > 0)
-            .map(|(bucket_id, sub_agg)| (bucket_id as u64, sub_agg))
-            .collect();
-        let entries: Vec<(u64, u32)> = self
-            .term_buckets
-            .entries
-            .iter()
-            .enumerate()
-            .filter(|(_, count)| **count > 0)
-            .map(|(bucket_id, count)| (bucket_id as u64, *count))
-            .collect();
-
-        let bucket =
-            super::into_intermediate_bucket_result(self.accessor_idx, entries, sub_aggs, agg_data)?;
-        results.push(name, IntermediateAggregationResult::Bucket(bucket))?;
-        Ok(())
-    }
-
-    fn collect_block(
-        &mut self,
-        docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        if docs.len() > MAX_BATCH_SIZE {
-            for batch in docs.chunks(MAX_BATCH_SIZE) {
-                self.collect_block(batch, agg_data)?;
-            }
-        }
-
-        let mut req_data = agg_data.take_term_req_data(self.accessor_idx);
-
-        let mem_pre = self.get_memory_consumption();
-
-        if let Some(missing) = req_data.missing_value_for_accessor {
-            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);
-        }
-
-        // has subagg
-        if req_data.sub_aggregation_blueprint.is_some() {
-            for (doc, term_id) in req_data
-                .column_block_accessor
-                .iter_docid_vals(docs, &req_data.accessor)
-            {
-                if let Some(allowed_bs) = req_data.allowed_term_ids.as_ref() {
-                    if !allowed_bs.contains(term_id as u32) {
-                        continue;
-                    }
-                }
-                self.term_buckets.doc_buffers[term_id as usize].push(doc);
-            }
-            for (bucket_id, docs) in self.term_buckets.doc_buffers.iter_mut().enumerate() {
-                self.term_buckets.entries[bucket_id] += docs.len() as u32;
-                self.term_buckets.sub_aggs[bucket_id].collect_block(&docs[..], agg_data)?;
-                docs.clear();
-            }
-        } else {
-            for term_id in req_data.column_block_accessor.iter_vals() {
-                if let Some(allowed_bs) = req_data.allowed_term_ids.as_ref() {
-                    if !allowed_bs.contains(term_id as u32) {
-                        continue;
-                    }
-                }
-                self.term_buckets.entries[term_id as usize] += 1;
-            }
-        }
-
-        let mem_delta = self.get_memory_consumption() - mem_pre;
-        if mem_delta > 0 {
-            agg_data
-                .context
-                .limits
-                .add_memory_consumed(mem_delta as u64)?;
-        }
-        agg_data.put_back_term_req_data(self.accessor_idx, req_data);
-
-        Ok(())
-    }
-
-    fn collect(
-        &mut self,
-        doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        self.collect_block(&[doc], agg_data)
-    }
-
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
-        for sub_aggregations in &mut self.term_buckets.sub_aggs.iter_mut() {
-            sub_aggregations.as_mut().flush(agg_data)?;
-        }
-        Ok(())
-    }
-}

src/aggregation/bucket/term_missing_agg.rs

@@ -1,39 +1,13 @@
-use columnar::{Column, ColumnType};
 use rustc_hash::FxHashMap;
 
-use crate::aggregation::agg_data::{
-    build_segment_agg_collectors, AggRefNode, AggregationsSegmentCtx,
-};
-use crate::aggregation::bucket::term_agg::TermsAggregation;
+use crate::aggregation::agg_req_with_accessor::AggregationsWithAccessor;
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateBucketResult,
     IntermediateKey, IntermediateTermBucketEntry, IntermediateTermBucketResult,
 };
-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.
-///
-/// This is needed when:
-/// - The field is multi-valued and we therefore have multiple columns
-/// - The field is not text and missing is provided as string (we cannot use the numeric missing
-///   value optimization)
-#[derive(Default)]
-pub struct MissingTermAggReqData {
-    /// The accessors to check for existence of a value.
-    pub accessors: Vec<(Column<u64>, ColumnType)>,
-    /// The name of the aggregation.
-    pub name: String,
-    /// The original terms aggregation request.
-    pub req: TermsAggregation,
-}
-
-impl MissingTermAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
+use crate::aggregation::segment_agg_result::{
+    build_segment_agg_collector, SegmentAggregationCollector,
+};
 
 /// The specialized missing term aggregation.
 #[derive(Default, Debug, Clone)]
@@ -44,13 +18,12 @@ pub struct TermMissingAgg {
 }
 impl TermMissingAgg {
     pub(crate) fn new(
-        req_data: &mut AggregationsSegmentCtx,
-        node: &AggRefNode,
+        accessor_idx: usize,
+        sub_aggregations: &mut AggregationsWithAccessor,
     ) -> crate::Result<Self> {
-        let has_sub_aggregations = !node.children.is_empty();
-        let accessor_idx = node.idx_in_req_data;
+        let has_sub_aggregations = !sub_aggregations.is_empty();
         let sub_agg = if has_sub_aggregations {
-            let sub_aggregation = build_segment_agg_collectors(req_data, &node.children)?;
+            let sub_aggregation = build_segment_agg_collector(sub_aggregations)?;
             Some(sub_aggregation)
         } else {
             None
@@ -67,11 +40,16 @@ impl TermMissingAgg {
 impl SegmentAggregationCollector for TermMissingAgg {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_missing_term_req_data(self.accessor_idx);
-        let term_agg = &req_data.req;
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
+        let agg_with_accessor = &agg_with_accessor.aggs.values[self.accessor_idx];
+        let term_agg = agg_with_accessor
+            .agg
+            .agg
+            .as_term()
+            .expect("TermMissingAgg collector must be term agg req");
         let missing = term_agg
             .missing
             .as_ref()
@@ -86,7 +64,10 @@ impl SegmentAggregationCollector for TermMissingAgg {
         };
         if let Some(sub_agg) = self.sub_agg {
             let mut res = IntermediateAggregationResults::default();
-            sub_agg.add_intermediate_aggregation_result(agg_data, &mut res)?;
+            sub_agg.add_intermediate_aggregation_result(
+                &agg_with_accessor.sub_aggregation,
+                &mut res,
+            )?;
             missing_entry.sub_aggregation = res;
         }
         entries.insert(missing.into(), missing_entry);
@@ -99,10 +80,7 @@ impl SegmentAggregationCollector for TermMissingAgg {
             },
         };
 
-        results.push(
-            req_data.name.to_string(),
-            IntermediateAggregationResult::Bucket(bucket),
-        )?;
+        results.push(name, IntermediateAggregationResult::Bucket(bucket))?;
 
         Ok(())
     }
@@ -110,17 +88,17 @@ impl SegmentAggregationCollector for TermMissingAgg {
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_missing_term_req_data(self.accessor_idx);
-        let has_value = req_data
+        let agg = &mut agg_with_accessor.aggs.values[self.accessor_idx];
+        let has_value = agg
             .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)?;
+                sub_agg.collect(doc, &mut agg.sub_aggregation)?;
             }
         }
         Ok(())
@@ -129,10 +107,10 @@ impl SegmentAggregationCollector for TermMissingAgg {
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
         for doc in docs {
-            self.collect(*doc, agg_data)?;
+            self.collect(*doc, agg_with_accessor)?;
         }
         Ok(())
     }

src/aggregation/buf_collector.rs

@@ -1,6 +1,6 @@
+use super::agg_req_with_accessor::AggregationsWithAccessor;
 use super::intermediate_agg_result::IntermediateAggregationResults;
 use super::segment_agg_result::SegmentAggregationCollector;
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
 use crate::DocId;
 
 pub(crate) const DOC_BLOCK_SIZE: usize = 64;
@@ -37,23 +37,23 @@ impl SegmentAggregationCollector for BufAggregationCollector {
     #[inline]
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        Box::new(self.collector).add_intermediate_aggregation_result(agg_data, results)
+        Box::new(self.collector).add_intermediate_aggregation_result(agg_with_accessor, results)
     }
 
     #[inline]
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> 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)?;
+                .collect_block(&self.staged_docs[..self.num_staged_docs], agg_with_accessor)?;
             self.num_staged_docs = 0;
         }
         Ok(())
@@ -63,20 +63,20 @@ impl SegmentAggregationCollector for BufAggregationCollector {
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        self.collector.collect_block(docs, agg_data)?;
+        self.collector.collect_block(docs, agg_with_accessor)?;
 
         Ok(())
     }
 
     #[inline]
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+    fn flush(&mut self, agg_with_accessor: &mut AggregationsWithAccessor) -> crate::Result<()> {
         self.collector
-            .collect_block(&self.staged_docs[..self.num_staged_docs], agg_data)?;
+            .collect_block(&self.staged_docs[..self.num_staged_docs], agg_with_accessor)?;
         self.num_staged_docs = 0;
 
-        self.collector.flush(agg_data)?;
+        self.collector.flush(agg_with_accessor)?;
 
         Ok(())
     }

src/aggregation/collector.rs

@@ -1,12 +1,12 @@
 use super::agg_req::Aggregations;
+use super::agg_req_with_accessor::AggregationsWithAccessor;
 use super::agg_result::AggregationResults;
 use super::buf_collector::BufAggregationCollector;
 use super::intermediate_agg_result::IntermediateAggregationResults;
-use super::segment_agg_result::SegmentAggregationCollector;
-use super::AggContextParams;
-use crate::aggregation::agg_data::{
-    build_aggregations_data_from_req, build_segment_agg_collectors_root, AggregationsSegmentCtx,
+use super::segment_agg_result::{
+    build_segment_agg_collector, AggregationLimitsGuard, SegmentAggregationCollector,
 };
+use crate::aggregation::agg_req_with_accessor::get_aggs_with_segment_accessor_and_validate;
 use crate::collector::{Collector, SegmentCollector};
 use crate::index::SegmentReader;
 use crate::{DocId, SegmentOrdinal, TantivyError};
@@ -22,7 +22,7 @@ pub const DEFAULT_MEMORY_LIMIT: u64 = 500_000_000;
 /// The collector collects all aggregations by the underlying aggregation request.
 pub struct AggregationCollector {
     agg: Aggregations,
-    context: AggContextParams,
+    limits: AggregationLimitsGuard,
 }
 
 impl AggregationCollector {
@@ -30,8 +30,8 @@ impl AggregationCollector {
     ///
     /// Aggregation fails when the limits in `AggregationLimits` is exceeded. (memory limit and
     /// bucket limit)
-    pub fn from_aggs(agg: Aggregations, context: AggContextParams) -> Self {
-        Self { agg, context }
+    pub fn from_aggs(agg: Aggregations, limits: AggregationLimitsGuard) -> Self {
+        Self { agg, limits }
     }
 }
 
@@ -45,7 +45,7 @@ impl AggregationCollector {
 /// into the final `AggregationResults` via the `into_final_result()` method.
 pub struct DistributedAggregationCollector {
     agg: Aggregations,
-    context: AggContextParams,
+    limits: AggregationLimitsGuard,
 }
 
 impl DistributedAggregationCollector {
@@ -53,8 +53,8 @@ impl DistributedAggregationCollector {
     ///
     /// Aggregation fails when the limits in `AggregationLimits` is exceeded. (memory limit and
     /// bucket limit)
-    pub fn from_aggs(agg: Aggregations, context: AggContextParams) -> Self {
-        Self { agg, context }
+    pub fn from_aggs(agg: Aggregations, limits: AggregationLimitsGuard) -> Self {
+        Self { agg, limits }
     }
 }
 
@@ -72,7 +72,7 @@ impl Collector for DistributedAggregationCollector {
             &self.agg,
             reader,
             segment_local_id,
-            &self.context,
+            &self.limits,
         )
     }
 
@@ -102,7 +102,7 @@ impl Collector for AggregationCollector {
             &self.agg,
             reader,
             segment_local_id,
-            &self.context,
+            &self.limits,
         )
     }
 
@@ -115,7 +115,7 @@ impl Collector for AggregationCollector {
         segment_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>,
     ) -> crate::Result<Self::Fruit> {
         let res = merge_fruits(segment_fruits)?;
-        res.into_final_result(self.agg.clone(), self.context.limits.clone())
+        res.into_final_result(self.agg.clone(), self.limits.clone())
     }
 }
 
@@ -135,7 +135,7 @@ fn merge_fruits(
 
 /// `AggregationSegmentCollector` does the aggregation collection on a segment.
 pub struct AggregationSegmentCollector {
-    aggs_with_accessor: AggregationsSegmentCtx,
+    aggs_with_accessor: AggregationsWithAccessor,
     agg_collector: BufAggregationCollector,
     error: Option<TantivyError>,
 }
@@ -147,15 +147,14 @@ impl AggregationSegmentCollector {
         agg: &Aggregations,
         reader: &SegmentReader,
         segment_ordinal: SegmentOrdinal,
-        context: &AggContextParams,
+        limits: &AggregationLimitsGuard,
     ) -> crate::Result<Self> {
-        let mut agg_data =
-            build_aggregations_data_from_req(agg, reader, segment_ordinal, context.clone())?;
+        let mut aggs_with_accessor =
+            get_aggs_with_segment_accessor_and_validate(agg, reader, segment_ordinal, limits)?;
         let result =
-            BufAggregationCollector::new(build_segment_agg_collectors_root(&mut agg_data)?);
-
+            BufAggregationCollector::new(build_segment_agg_collector(&mut aggs_with_accessor)?);
         Ok(AggregationSegmentCollector {
-            aggs_with_accessor: agg_data,
+            aggs_with_accessor,
             agg_collector: result,
             error: None,
         })

src/aggregation/intermediate_agg_result.rs

@@ -24,9 +24,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, FilterBucketResult,
-};
+use crate::aggregation::agg_result::{AggregationResults, BucketEntries, BucketEntry};
 use crate::aggregation::bucket::TermsAggregationInternal;
 use crate::aggregation::metric::CardinalityCollector;
 use crate::TantivyError;
@@ -181,17 +179,12 @@ impl IntermediateAggregationResults {
     }
 
     /// Merge another intermediate aggregation result into this result.
-    pub fn merge_fruits(&mut self, mut other: IntermediateAggregationResults) -> crate::Result<()> {
-        for (key, left) in self.aggs_res.iter_mut() {
-            if let Some(key) = other.aggs_res.remove(key) {
-                left.merge_fruits(key)?;
-            }
-        }
-        // Move remainder of other aggs_res into self.
-        // Note: Currently we don't expect this to happen, as we create empty intermediate results
-        // via [IntermediateAggregationResults::empty_from_req].
-        for (key, value) in other.aggs_res {
-            self.aggs_res.insert(key, value);
+    ///
+    /// The order of the values need to be the same on both results. This is ensured when the same
+    /// (key values) are present on the underlying `VecWithNames` struct.
+    pub fn merge_fruits(&mut self, other: IntermediateAggregationResults) -> crate::Result<()> {
+        for (left, right) in self.aggs_res.values_mut().zip(other.aggs_res.into_values()) {
+            left.merge_fruits(right)?;
         }
         Ok(())
     }
@@ -248,16 +241,11 @@ pub(crate) fn empty_from_req(req: &Aggregation) -> IntermediateAggregationResult
         Cardinality(_) => IntermediateAggregationResult::Metric(
             IntermediateMetricResult::Cardinality(CardinalityCollector::default()),
         ),
-        Filter(_) => IntermediateAggregationResult::Bucket(IntermediateBucketResult::Filter {
-            doc_count: 0,
-            sub_aggregations: IntermediateAggregationResults::default(),
-        }),
     }
 }
 
 /// An aggregation is either a bucket or a metric.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[allow(clippy::large_enum_variant)]
 pub enum IntermediateAggregationResult {
     /// Bucket variant
     Bucket(IntermediateBucketResult),
@@ -438,13 +426,6 @@ pub enum IntermediateBucketResult {
         /// The term buckets
         buckets: IntermediateTermBucketResult,
     },
-    /// Filter aggregation - a single bucket with sub-aggregations
-    Filter {
-        /// Document count in the filter bucket
-        doc_count: u64,
-        /// Sub-aggregation results
-        sub_aggregations: IntermediateAggregationResults,
-    },
 }
 
 impl IntermediateBucketResult {
@@ -528,18 +509,6 @@ impl IntermediateBucketResult {
                 req.sub_aggregation(),
                 limits,
             ),
-            IntermediateBucketResult::Filter {
-                doc_count,
-                sub_aggregations,
-            } => {
-                // Convert sub-aggregation results to final format
-                let final_sub_aggregations = sub_aggregations
-                    .into_final_result(req.sub_aggregation().clone(), limits.clone())?;
-                Ok(BucketResult::Filter(FilterBucketResult {
-                    doc_count,
-                    sub_aggregations: final_sub_aggregations,
-                }))
-            }
         }
     }
 
@@ -593,19 +562,6 @@ impl IntermediateBucketResult {
 
                 *buckets_left = buckets?;
             }
-            (
-                IntermediateBucketResult::Filter {
-                    doc_count: doc_count_left,
-                    sub_aggregations: sub_aggs_left,
-                },
-                IntermediateBucketResult::Filter {
-                    doc_count: doc_count_right,
-                    sub_aggregations: sub_aggs_right,
-                },
-            ) => {
-                *doc_count_left += doc_count_right;
-                sub_aggs_left.merge_fruits(sub_aggs_right)?;
-            }
             (IntermediateBucketResult::Range(_), _) => {
                 panic!("try merge on different types")
             }
@@ -615,9 +571,6 @@ impl IntermediateBucketResult {
             (IntermediateBucketResult::Terms { .. }, _) => {
                 panic!("try merge on different types")
             }
-            (IntermediateBucketResult::Filter { .. }, _) => {
-                panic!("try merge on different types")
-            }
         }
         Ok(())
     }

src/aggregation/metric/cardinality.rs

@@ -2,13 +2,15 @@ use std::collections::hash_map::DefaultHasher;
 use std::hash::{BuildHasher, Hasher};
 
 use columnar::column_values::CompactSpaceU64Accessor;
-use columnar::{Column, ColumnBlockAccessor, ColumnType, Dictionary, StrColumn};
+use columnar::Dictionary;
 use common::f64_to_u64;
 use hyperloglogplus::{HyperLogLog, HyperLogLogPlus};
 use rustc_hash::FxHashSet;
 use serde::{Deserialize, Serialize};
 
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
+use crate::aggregation::agg_req_with_accessor::{
+    AggregationWithAccessor, AggregationsWithAccessor,
+};
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateAggregationResults, IntermediateMetricResult,
 };
@@ -95,32 +97,6 @@ pub struct CardinalityAggregationReq {
     pub missing: Option<Key>,
 }
 
-/// Contains all information required by the SegmentCardinalityCollector to perform the
-/// cardinality aggregation on a segment.
-pub struct CardinalityAggReqData {
-    /// The column accessor to access the fast field values.
-    pub accessor: Column<u64>,
-    /// The column_type of the field.
-    pub column_type: ColumnType,
-    /// The string dictionary column if the field is of type string.
-    pub str_dict_column: Option<StrColumn>,
-    /// The missing value normalized to the internal u64 representation of the field type.
-    pub missing_value_for_accessor: Option<u64>,
-    /// The column block accessor to access the fast field values.
-    pub(crate) column_block_accessor: ColumnBlockAccessor<u64>,
-    /// The name of the aggregation.
-    pub name: String,
-    /// The aggregation request.
-    pub req: CardinalityAggregationReq,
-}
-
-impl CardinalityAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
-
 impl CardinalityAggregationReq {
     /// Creates a new [`CardinalityAggregationReq`] instance from a field name.
     pub fn from_field_name(field_name: String) -> Self {
@@ -139,44 +115,47 @@ impl CardinalityAggregationReq {
 pub(crate) struct SegmentCardinalityCollector {
     cardinality: CardinalityCollector,
     entries: FxHashSet<u64>,
+    column_type: ColumnType,
     accessor_idx: usize,
+    missing: Option<Key>,
 }
 
 impl SegmentCardinalityCollector {
-    pub fn from_req(column_type: ColumnType, accessor_idx: usize) -> Self {
+    pub fn from_req(column_type: ColumnType, accessor_idx: usize, missing: &Option<Key>) -> Self {
         Self {
             cardinality: CardinalityCollector::new(column_type as u8),
             entries: Default::default(),
+            column_type,
             accessor_idx,
+            missing: missing.clone(),
         }
     }
 
     fn fetch_block_with_field(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut CardinalityAggReqData,
+        agg_accessor: &mut AggregationWithAccessor,
     ) {
-        if let Some(missing) = agg_data.missing_value_for_accessor {
-            agg_data.column_block_accessor.fetch_block_with_missing(
+        if let Some(missing) = agg_accessor.missing_value_for_accessor {
+            agg_accessor.column_block_accessor.fetch_block_with_missing(
                 docs,
-                &agg_data.accessor,
+                &agg_accessor.accessor,
                 missing,
             );
         } else {
-            agg_data
+            agg_accessor
                 .column_block_accessor
-                .fetch_block(docs, &agg_data.accessor);
+                .fetch_block(docs, &agg_accessor.accessor);
         }
     }
 
     fn into_intermediate_metric_result(
         mut self,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationWithAccessor,
     ) -> crate::Result<IntermediateMetricResult> {
-        let req_data = &agg_data.get_cardinality_req_data(self.accessor_idx);
-        if req_data.column_type == ColumnType::Str {
+        if self.column_type == ColumnType::Str {
             let fallback_dict = Dictionary::empty();
-            let dict = req_data
+            let dict = agg_with_accessor
                 .str_dict_column
                 .as_ref()
                 .map(|el| el.dictionary())
@@ -201,10 +180,10 @@ impl SegmentCardinalityCollector {
             })?;
             if has_missing {
                 // Replace missing with the actual value provided
-                let missing_key =
-                    req_data.req.missing.as_ref().expect(
-                        "Found sentinel value u64::MAX for term_ord but `missing` is not set",
-                    );
+                let missing_key = self
+                    .missing
+                    .as_ref()
+                    .expect("Found sentinel value u64::MAX for term_ord but `missing` is not set");
                 match missing_key {
                     Key::Str(missing) => {
                         self.cardinality.sketch.insert_any(&missing);
@@ -230,13 +209,13 @@ impl SegmentCardinalityCollector {
 impl SegmentAggregationCollector for SegmentCardinalityCollector {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let req_data = &agg_data.get_cardinality_req_data(self.accessor_idx);
-        let name = req_data.name.to_string();
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
+        let agg_with_accessor = &agg_with_accessor.aggs.values[self.accessor_idx];
 
-        let intermediate_result = self.into_intermediate_metric_result(agg_data)?;
+        let intermediate_result = self.into_intermediate_metric_result(agg_with_accessor)?;
         results.push(
             name,
             IntermediateAggregationResult::Metric(intermediate_result),
@@ -248,26 +227,26 @@ impl SegmentAggregationCollector for SegmentCardinalityCollector {
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        self.collect_block(&[doc], agg_data)
+        self.collect_block(&[doc], agg_with_accessor)
     }
 
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_cardinality_req_data_mut(self.accessor_idx);
-        self.fetch_block_with_field(docs, req_data);
+        let bucket_agg_accessor = &mut agg_with_accessor.aggs.values[self.accessor_idx];
+        self.fetch_block_with_field(docs, bucket_agg_accessor);
 
-        let col_block_accessor = &req_data.column_block_accessor;
-        if req_data.column_type == ColumnType::Str {
+        let col_block_accessor = &bucket_agg_accessor.column_block_accessor;
+        if self.column_type == ColumnType::Str {
             for term_ord in col_block_accessor.iter_vals() {
                 self.entries.insert(term_ord);
             }
-        } else if req_data.column_type == ColumnType::IpAddr {
-            let compact_space_accessor = req_data
+        } else if self.column_type == ColumnType::IpAddr {
+            let compact_space_accessor = bucket_agg_accessor
                 .accessor
                 .values
                 .clone()

src/aggregation/metric/extended_stats.rs

@@ -4,11 +4,12 @@ use std::mem;
 use serde::{Deserialize, Serialize};
 
 use super::*;
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
+use crate::aggregation::agg_req_with_accessor::{
+    AggregationWithAccessor, AggregationsWithAccessor,
+};
 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::{DocId, TantivyError};
@@ -347,20 +348,20 @@ impl SegmentExtendedStatsCollector {
     pub(crate) fn collect_block_with_field(
         &mut self,
         docs: &[DocId],
-        req_data: &mut MetricAggReqData,
+        agg_accessor: &mut AggregationWithAccessor,
     ) {
         if let Some(missing) = self.missing.as_ref() {
-            req_data.column_block_accessor.fetch_block_with_missing(
+            agg_accessor.column_block_accessor.fetch_block_with_missing(
                 docs,
-                &req_data.accessor,
+                &agg_accessor.accessor,
                 *missing,
             );
         } else {
-            req_data
+            agg_accessor
                 .column_block_accessor
-                .fetch_block(docs, &req_data.accessor);
+                .fetch_block(docs, &agg_accessor.accessor);
         }
-        for val in req_data.column_block_accessor.iter_vals() {
+        for val in agg_accessor.column_block_accessor.iter_vals() {
             let val1 = f64_from_fastfield_u64(val, &self.field_type);
             self.extended_stats.collect(val1);
         }
@@ -371,10 +372,10 @@ impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
     #[inline]
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let name = agg_data.get_metric_req_data(self.accessor_idx).name.clone();
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
         results.push(
             name,
             IntermediateAggregationResult::Metric(IntermediateMetricResult::ExtendedStats(
@@ -389,12 +390,12 @@ impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_metric_req_data(self.accessor_idx);
+        let field = &agg_with_accessor.aggs.values[self.accessor_idx].accessor;
         if let Some(missing) = self.missing {
             let mut has_val = false;
-            for val in req_data.accessor.values_for_doc(doc) {
+            for val in field.values_for_doc(doc) {
                 let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.extended_stats.collect(val1);
                 has_val = true;
@@ -404,7 +405,7 @@ impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
                     .collect(f64_from_fastfield_u64(missing, &self.field_type));
             }
         } else {
-            for val in req_data.accessor.values_for_doc(doc) {
+            for val in field.values_for_doc(doc) {
                 let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.extended_stats.collect(val1);
             }
@@ -417,10 +418,10 @@ impl SegmentAggregationCollector for SegmentExtendedStatsCollector {
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_metric_req_data_mut(self.accessor_idx);
-        self.collect_block_with_field(docs, req_data);
+        let field = &mut agg_with_accessor.aggs.values[self.accessor_idx];
+        self.collect_block_with_field(docs, field);
         Ok(())
     }
 }