chore: Release

CHANGELOG.md

@@ -14,18 +14,6 @@ Tantivy 0.25
 - 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.
@@ -108,14 +96,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

@@ -69,7 +69,6 @@ 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]
@@ -168,11 +167,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/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

@@ -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
     }
 }
 

columnar/src/column_index/merge/stacked.rs

@@ -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/multivalued_index.rs

@@ -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;
@@ -11,7 +11,7 @@ use set_block::{
 };
 
 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())
     }
 }
 
@@ -280,9 +280,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 +334,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/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]

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/u64_based/bitpacked.rs

@@ -105,7 +105,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/linear.rs

@@ -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/columnar/merge/mod.rs

@@ -367,7 +367,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/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/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/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 {

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

@@ -15,5 +15,3 @@ edition = "2024"
 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,

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,7 +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;
@@ -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);
         }
     }
@@ -1769,63 +1694,6 @@ mod test {
         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"#);

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,7 +46,6 @@ 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 },
         }
     }
 
@@ -108,19 +103,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 +115,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 +154,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 +191,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 +217,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),
         }
     }
@@ -392,7 +378,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 +405,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(())
     }
 }

src/aggregation/metric/mod.rs

@@ -31,7 +31,6 @@ use std::collections::HashMap;
 
 pub use average::*;
 pub use cardinality::*;
-use columnar::{Column, ColumnBlockAccessor, ColumnType};
 pub use count::*;
 pub use extended_stats::*;
 pub use max::*;
@@ -45,35 +44,6 @@ pub use top_hits::*;
 
 use crate::schema::OwnedValue;
 
-/// Contains all information required by metric aggregations like avg, min, max, sum, stats,
-/// extended_stats, count, percentiles.
-#[repr(C)]
-pub struct MetricAggReqData {
-    /// True if the field is of number or date type.
-    pub is_number_or_date_type: bool,
-    /// The type of the field.
-    pub field_type: ColumnType,
-    /// The missing value normalized to the internal u64 representation of the field type.
-    pub missing_u64: Option<u64>,
-    /// The column block accessor to access the fast field values.
-    pub column_block_accessor: ColumnBlockAccessor<u64>,
-    /// The column accessor to access the fast field values.
-    pub accessor: Column<u64>,
-    /// Used when converting to intermediate result
-    pub collecting_for: StatsType,
-    /// The missing value
-    pub missing: Option<f64>,
-    /// The name of the aggregation.
-    pub name: String,
-}
-
-impl MetricAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
-
 /// Single-metric aggregations use this common result structure.
 ///
 /// Main reason to wrap it in value is to match elasticsearch output structure.

src/aggregation/metric/percentiles.rs

@@ -3,11 +3,12 @@ use std::fmt::Debug;
 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};
@@ -111,8 +112,7 @@ impl PercentilesAggregationReq {
         &self.field
     }
 
-    /// Validates the request parameters.
-    pub fn validate(&self) -> crate::Result<()> {
+    fn validate(&self) -> crate::Result<()> {
         if let Some(percents) = self.percents.as_ref() {
             let all_in_range = percents
                 .iter()
@@ -133,8 +133,10 @@ impl PercentilesAggregationReq {
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct SegmentPercentilesCollector {
+    field_type: ColumnType,
     pub(crate) percentiles: PercentilesCollector,
     pub(crate) accessor_idx: usize,
+    missing: Option<u64>,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -229,32 +231,43 @@ impl PercentilesCollector {
 }
 
 impl SegmentPercentilesCollector {
-    pub fn from_req_and_validate(accessor_idx: usize) -> crate::Result<Self> {
+    pub fn from_req_and_validate(
+        req: &PercentilesAggregationReq,
+        field_type: ColumnType,
+        accessor_idx: usize,
+    ) -> crate::Result<Self> {
+        req.validate()?;
+        let missing = req
+            .missing
+            .and_then(|val| f64_to_fastfield_u64(val, &field_type));
+
         Ok(Self {
+            field_type,
             percentiles: PercentilesCollector::new(),
             accessor_idx,
+            missing,
         })
     }
     #[inline]
     pub(crate) fn collect_block_with_field(
         &mut self,
         docs: &[DocId],
-        req_data: &mut MetricAggReqData,
+        agg_accessor: &mut AggregationWithAccessor,
     ) {
-        if let Some(missing) = req_data.missing_u64.as_ref() {
-            req_data.column_block_accessor.fetch_block_with_missing(
+        if let Some(missing) = self.missing.as_ref() {
+            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() {
-            let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+        for val in agg_accessor.column_block_accessor.iter_vals() {
+            let val1 = f64_from_fastfield_u64(val, &self.field_type);
             self.percentiles.collect(val1);
         }
     }
@@ -264,10 +277,10 @@ impl SegmentAggregationCollector for SegmentPercentilesCollector {
     #[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();
         let intermediate_metric_result = IntermediateMetricResult::Percentiles(self.percentiles);
 
         results.push(
@@ -282,24 +295,24 @@ impl SegmentAggregationCollector for SegmentPercentilesCollector {
     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) = req_data.missing_u64 {
+        if let Some(missing) = self.missing {
             let mut has_val = false;
-            for val in req_data.accessor.values_for_doc(doc) {
-                let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+            for val in field.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.percentiles.collect(val1);
                 has_val = true;
             }
             if !has_val {
                 self.percentiles
-                    .collect(f64_from_fastfield_u64(missing, &req_data.field_type));
+                    .collect(f64_from_fastfield_u64(missing, &self.field_type));
             }
         } else {
-            for val in req_data.accessor.values_for_doc(doc) {
-                let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+            for val in field.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.percentiles.collect(val1);
             }
         }
@@ -311,10 +324,10 @@ impl SegmentAggregationCollector for SegmentPercentilesCollector {
     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(())
     }
 }

src/aggregation/metric/stats.rs

@@ -3,11 +3,12 @@ use std::fmt::Debug;
 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};
@@ -165,65 +166,74 @@ impl IntermediateStats {
     }
 }
 
-/// The type of stats aggregation to perform.
-/// Note that not all stats types are supported in the stats aggregation.
-#[derive(Clone, Copy, Debug)]
-pub enum StatsType {
-    /// The average of the values.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum SegmentStatsType {
     Average,
-    /// The count of the values.
     Count,
-    /// The maximum value.
     Max,
-    /// The minimum value.
     Min,
-    /// The stats (count, sum, min, max, avg) of the values.
     Stats,
-    /// The extended stats (count, sum, min, max, avg, sum_of_squares, variance, std_deviation,
-    ExtendedStats(Option<f64>), // sigma
-    /// The sum of the values.
     Sum,
-    /// The percentiles of the values.
-    Percentiles,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub(crate) struct SegmentStatsCollector {
+    missing: Option<u64>,
+    field_type: ColumnType,
+    pub(crate) collecting_for: SegmentStatsType,
     pub(crate) stats: IntermediateStats,
     pub(crate) accessor_idx: usize,
+    val_cache: Vec<u64>,
 }
 
 impl SegmentStatsCollector {
-    pub fn from_req(accessor_idx: usize) -> Self {
+    pub fn from_req(
+        field_type: ColumnType,
+        collecting_for: SegmentStatsType,
+        accessor_idx: usize,
+        missing: Option<f64>,
+    ) -> Self {
+        let missing = missing.and_then(|val| f64_to_fastfield_u64(val, &field_type));
         Self {
+            field_type,
+            collecting_for,
             stats: IntermediateStats::default(),
             accessor_idx,
+            missing,
+            val_cache: Default::default(),
         }
     }
     #[inline]
     pub(crate) fn collect_block_with_field(
         &mut self,
         docs: &[DocId],
-        req_data: &mut MetricAggReqData,
+        agg_accessor: &mut AggregationWithAccessor,
     ) {
-        if let Some(missing) = req_data.missing_u64.as_ref() {
-            req_data.column_block_accessor.fetch_block_with_missing(
+        if let Some(missing) = self.missing.as_ref() {
+            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);
         }
-        if req_data.is_number_or_date_type {
-            for val in req_data.column_block_accessor.iter_vals() {
-                let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+        if [
+            ColumnType::I64,
+            ColumnType::U64,
+            ColumnType::F64,
+            ColumnType::DateTime,
+        ]
+        .contains(&self.field_type)
+        {
+            for val in agg_accessor.column_block_accessor.iter_vals() {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.stats.collect(val1);
             }
         } else {
-            for _val in req_data.column_block_accessor.iter_vals() {
+            for _val in agg_accessor.column_block_accessor.iter_vals() {
                 // we ignore the value and simply record that we got something
                 self.stats.collect(0.0);
             }
@@ -235,28 +245,27 @@ impl SegmentAggregationCollector for SegmentStatsCollector {
     #[inline]
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let req = agg_data.get_metric_req_data(self.accessor_idx);
-        let name = req.name.clone();
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
 
-        let intermediate_metric_result = match req.collecting_for {
-            StatsType::Average => {
+        let intermediate_metric_result = match self.collecting_for {
+            SegmentStatsType::Average => {
                 IntermediateMetricResult::Average(IntermediateAverage::from_collector(*self))
             }
-            StatsType::Count => {
+            SegmentStatsType::Count => {
                 IntermediateMetricResult::Count(IntermediateCount::from_collector(*self))
             }
-            StatsType::Max => IntermediateMetricResult::Max(IntermediateMax::from_collector(*self)),
-            StatsType::Min => IntermediateMetricResult::Min(IntermediateMin::from_collector(*self)),
-            StatsType::Stats => IntermediateMetricResult::Stats(self.stats),
-            StatsType::Sum => IntermediateMetricResult::Sum(IntermediateSum::from_collector(*self)),
-            _ => {
-                return Err(TantivyError::InvalidArgument(format!(
-                    "Unsupported stats type for stats aggregation: {:?}",
-                    req.collecting_for
-                )))
+            SegmentStatsType::Max => {
+                IntermediateMetricResult::Max(IntermediateMax::from_collector(*self))
+            }
+            SegmentStatsType::Min => {
+                IntermediateMetricResult::Min(IntermediateMin::from_collector(*self))
+            }
+            SegmentStatsType::Stats => IntermediateMetricResult::Stats(self.stats),
+            SegmentStatsType::Sum => {
+                IntermediateMetricResult::Sum(IntermediateSum::from_collector(*self))
             }
         };
 
@@ -272,23 +281,23 @@ impl SegmentAggregationCollector for SegmentStatsCollector {
     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);
-        if let Some(missing) = req_data.missing_u64 {
+        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) {
-                let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+            for val in field.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.stats.collect(val1);
                 has_val = true;
             }
             if !has_val {
                 self.stats
-                    .collect(f64_from_fastfield_u64(missing, &req_data.field_type));
+                    .collect(f64_from_fastfield_u64(missing, &self.field_type));
             }
         } else {
-            for val in req_data.accessor.values_for_doc(doc) {
-                let val1 = f64_from_fastfield_u64(val, &req_data.field_type);
+            for val in field.values_for_doc(doc) {
+                let val1 = f64_from_fastfield_u64(val, &self.field_type);
                 self.stats.collect(val1);
             }
         }
@@ -300,10 +309,10 @@ impl SegmentAggregationCollector for SegmentStatsCollector {
     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(())
     }
 }

src/aggregation/metric/top_hits.rs

@@ -9,7 +9,6 @@ use serde::ser::SerializeMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use super::{TopHitsMetricResult, TopHitsVecEntry};
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
 use crate::aggregation::bucket::Order;
 use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResult, IntermediateMetricResult,
@@ -19,30 +18,6 @@ use crate::aggregation::AggregationError;
 use crate::collector::TopNComputer;
 use crate::schema::OwnedValue;
 use crate::{DocAddress, DocId, SegmentOrdinal};
-// duplicate import removed; already imported above
-
-/// Contains all information required by the TopHitsSegmentCollector to perform the
-/// top_hits aggregation on a segment.
-#[derive(Default)]
-pub struct TopHitsAggReqData {
-    /// The accessors to access the fast field values.
-    pub accessors: Vec<(Column<u64>, ColumnType)>,
-    /// The accessors to access the fast field values for retrieving document fields.
-    pub value_accessors: HashMap<String, Vec<DynamicColumn>>,
-    /// The ordinal of the segment this request data is for.
-    pub segment_ordinal: SegmentOrdinal,
-    /// The name of the aggregation.
-    pub name: String,
-    /// The top_hits aggregation request.
-    pub req: TopHitsAggregationReq,
-}
-
-impl TopHitsAggReqData {
-    /// Estimate the memory consumption of this struct in bytes.
-    pub fn get_memory_consumption(&self) -> usize {
-        std::mem::size_of::<Self>()
-    }
-}
 
 /// # Top Hits
 ///
@@ -591,18 +566,23 @@ impl TopHitsSegmentCollector {
 impl SegmentAggregationCollector for TopHitsSegmentCollector {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &crate::aggregation::agg_req_with_accessor::AggregationsWithAccessor,
         results: &mut crate::aggregation::intermediate_agg_result::IntermediateAggregationResults,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_top_hits_req_data(self.accessor_idx);
+        let name = agg_with_accessor.aggs.keys[self.accessor_idx].to_string();
 
-        let value_accessors = &req_data.value_accessors;
+        let value_accessors = &agg_with_accessor.aggs.values[self.accessor_idx].value_accessors;
+        let tophits_req = &agg_with_accessor.aggs.values[self.accessor_idx]
+            .agg
+            .agg
+            .as_top_hits()
+            .expect("aggregation request must be of type top hits");
 
         let intermediate_result = IntermediateMetricResult::TopHits(
-            self.into_top_hits_collector(value_accessors, &req_data.req),
+            self.into_top_hits_collector(value_accessors, tophits_req),
         );
         results.push(
-            req_data.name.to_string(),
+            name,
             IntermediateAggregationResult::Metric(intermediate_result),
         )
     }
@@ -611,22 +591,32 @@ impl SegmentAggregationCollector for TopHitsSegmentCollector {
     fn collect(
         &mut self,
         doc_id: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut crate::aggregation::agg_req_with_accessor::AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_top_hits_req_data(self.accessor_idx);
-        self.collect_with(doc_id, &req_data.req, &req_data.accessors)?;
+        let tophits_req = &agg_with_accessor.aggs.values[self.accessor_idx]
+            .agg
+            .agg
+            .as_top_hits()
+            .expect("aggregation request must be of type top hits");
+        let accessors = &agg_with_accessor.aggs.values[self.accessor_idx].accessors;
+        self.collect_with(doc_id, tophits_req, accessors)?;
         Ok(())
     }
 
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut crate::aggregation::agg_req_with_accessor::AggregationsWithAccessor,
     ) -> crate::Result<()> {
-        let req_data = agg_data.get_top_hits_req_data(self.accessor_idx);
+        let tophits_req = &agg_with_accessor.aggs.values[self.accessor_idx]
+            .agg
+            .agg
+            .as_top_hits()
+            .expect("aggregation request must be of type top hits");
+        let accessors = &agg_with_accessor.aggs.values[self.accessor_idx].accessors;
         // TODO: Consider getting fields with the column block accessor.
         for doc in docs {
-            self.collect_with(*doc, &req_data.req, &req_data.accessors)?;
+            self.collect_with(*doc, tophits_req, accessors)?;
         }
         Ok(())
     }

src/aggregation/mod.rs

@@ -127,10 +127,9 @@
 //! [`AggregationResults`](agg_result::AggregationResults) via the
 //! [`into_final_result`](intermediate_agg_result::IntermediateAggregationResults::into_final_result) method.
 
-mod accessor_helpers;
-mod agg_data;
 mod agg_limits;
 pub mod agg_req;
+mod agg_req_with_accessor;
 pub mod agg_result;
 pub mod bucket;
 mod buf_collector;
@@ -141,6 +140,7 @@ pub mod intermediate_agg_result;
 pub mod metric;
 
 mod segment_agg_result;
+use std::collections::HashMap;
 use std::fmt::Display;
 
 #[cfg(test)]
@@ -160,28 +160,6 @@ use itertools::Itertools;
 use serde::de::{self, Visitor};
 use serde::{Deserialize, Deserializer, Serialize};
 
-use crate::tokenizer::TokenizerManager;
-
-/// Context parameters for aggregation execution
-///
-/// This struct holds shared resources needed during aggregation execution:
-/// - `limits`: Memory and bucket limits for the aggregation
-/// - `tokenizers`: TokenizerManager for parsing query strings in filter aggregations
-#[derive(Clone, Default)]
-pub struct AggContextParams {
-    /// Aggregation limits (memory and bucket count)
-    pub limits: AggregationLimitsGuard,
-    /// Tokenizer manager for query string parsing
-    pub tokenizers: TokenizerManager,
-}
-
-impl AggContextParams {
-    /// Create new aggregation context parameters
-    pub fn new(limits: AggregationLimitsGuard, tokenizers: TokenizerManager) -> Self {
-        Self { limits, tokenizers }
-    }
-}
-
 fn parse_str_into_f64<E: de::Error>(value: &str) -> Result<f64, E> {
     let parsed = value
         .parse::<f64>()
@@ -279,6 +257,80 @@ where D: Deserializer<'de> {
     deserializer.deserialize_any(StringOrFloatVisitor)
 }
 
+/// Represents an associative array `(key => values)` in a very efficient manner.
+#[derive(PartialEq, Serialize, Deserialize)]
+pub(crate) struct VecWithNames<T> {
+    pub(crate) values: Vec<T>,
+    keys: Vec<String>,
+}
+
+impl<T: Clone> Clone for VecWithNames<T> {
+    fn clone(&self) -> Self {
+        Self {
+            values: self.values.clone(),
+            keys: self.keys.clone(),
+        }
+    }
+}
+
+impl<T> Default for VecWithNames<T> {
+    fn default() -> Self {
+        Self {
+            values: Default::default(),
+            keys: Default::default(),
+        }
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for VecWithNames<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_map().entries(self.iter()).finish()
+    }
+}
+
+impl<T> From<HashMap<String, T>> for VecWithNames<T> {
+    fn from(map: HashMap<String, T>) -> Self {
+        VecWithNames::from_entries(map.into_iter().collect_vec())
+    }
+}
+
+impl<T> VecWithNames<T> {
+    fn from_entries(mut entries: Vec<(String, T)>) -> Self {
+        // Sort to ensure order of elements match across multiple instances
+        entries.sort_by(|left, right| left.0.cmp(&right.0));
+        let mut data = Vec::with_capacity(entries.len());
+        let mut data_names = Vec::with_capacity(entries.len());
+        for entry in entries {
+            data_names.push(entry.0);
+            data.push(entry.1);
+        }
+        VecWithNames {
+            values: data,
+            keys: data_names,
+        }
+    }
+    fn iter(&self) -> impl Iterator<Item = (&str, &T)> + '_ {
+        self.keys().zip(self.values.iter())
+    }
+    fn keys(&self) -> impl Iterator<Item = &str> + '_ {
+        self.keys.iter().map(|key| key.as_str())
+    }
+    fn values_mut(&mut self) -> impl Iterator<Item = &mut T> + '_ {
+        self.values.iter_mut()
+    }
+    fn is_empty(&self) -> bool {
+        self.keys.is_empty()
+    }
+    fn len(&self) -> usize {
+        self.keys.len()
+    }
+    fn get(&self, name: &str) -> Option<&T> {
+        self.keys()
+            .position(|key| key == name)
+            .map(|pos| &self.values[pos])
+    }
+}
+
 /// The serialized key is used in a `HashMap`.
 pub type SerializedKey = String;
 
@@ -412,10 +464,7 @@ mod tests {
         query: Option<(&str, &str)>,
         limits: AggregationLimitsGuard,
     ) -> crate::Result<Value> {
-        let collector = AggregationCollector::from_aggs(
-            agg_req,
-            AggContextParams::new(limits, index.tokenizers().clone()),
-        );
+        let collector = AggregationCollector::from_aggs(agg_req, limits);
 
         let reader = index.reader()?;
         let searcher = reader.searcher();

src/aggregation/segment_agg_result.rs

@@ -6,41 +6,48 @@
 use std::fmt::Debug;
 
 pub(crate) use super::agg_limits::AggregationLimitsGuard;
+use super::agg_req::AggregationVariants;
+use super::agg_req_with_accessor::{AggregationWithAccessor, AggregationsWithAccessor};
+use super::bucket::{SegmentHistogramCollector, SegmentRangeCollector, SegmentTermCollector};
 use super::intermediate_agg_result::IntermediateAggregationResults;
-use crate::aggregation::agg_data::AggregationsSegmentCtx;
+use super::metric::{
+    AverageAggregation, CountAggregation, ExtendedStatsAggregation, MaxAggregation, MinAggregation,
+    SegmentPercentilesCollector, SegmentStatsCollector, SegmentStatsType, StatsAggregation,
+    SumAggregation,
+};
+use crate::aggregation::bucket::TermMissingAgg;
+use crate::aggregation::metric::{
+    CardinalityAggregationReq, SegmentCardinalityCollector, SegmentExtendedStatsCollector,
+    TopHitsSegmentCollector,
+};
 
-/// A SegmentAggregationCollector is used to collect aggregation results.
-pub trait SegmentAggregationCollector: CollectorClone + Debug {
+pub(crate) trait SegmentAggregationCollector: CollectorClone + Debug {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()>;
 
-    #[inline]
     fn collect(
         &mut self,
         doc: crate::DocId,
-        agg_data: &mut AggregationsSegmentCtx,
-    ) -> crate::Result<()> {
-        self.collect_block(&[doc], agg_data)
-    }
+        agg_with_accessor: &mut AggregationsWithAccessor,
+    ) -> crate::Result<()>;
 
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()>;
 
     /// Finalize method. Some Aggregator collect blocks of docs before calling `collect_block`.
     /// This method ensures those staged docs will be collected.
-    fn flush(&mut self, _agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+    fn flush(&mut self, _agg_with_accessor: &mut AggregationsWithAccessor) -> crate::Result<()> {
         Ok(())
     }
 }
 
-/// A helper trait to enable cloning of Box<dyn SegmentAggregationCollector>
-pub trait CollectorClone {
+pub(crate) trait CollectorClone {
     fn clone_box(&self) -> Box<dyn SegmentAggregationCollector>;
 }
 
@@ -58,6 +65,119 @@ impl Clone for Box<dyn SegmentAggregationCollector> {
     }
 }
 
+pub(crate) fn build_segment_agg_collector(
+    req: &mut AggregationsWithAccessor,
+) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
+    // Single collector special case
+    if req.aggs.len() == 1 {
+        let req = &mut req.aggs.values[0];
+        let accessor_idx = 0;
+        return build_single_agg_segment_collector(req, accessor_idx);
+    }
+
+    let agg = GenericSegmentAggregationResultsCollector::from_req_and_validate(req)?;
+    Ok(Box::new(agg))
+}
+
+pub(crate) fn build_single_agg_segment_collector(
+    req: &mut AggregationWithAccessor,
+    accessor_idx: usize,
+) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
+    use AggregationVariants::*;
+    match &req.agg.agg {
+        Terms(terms_req) => {
+            if req.accessors.is_empty() {
+                Ok(Box::new(SegmentTermCollector::from_req_and_validate(
+                    terms_req,
+                    &mut req.sub_aggregation,
+                    req.field_type,
+                    accessor_idx,
+                )?))
+            } else {
+                Ok(Box::new(TermMissingAgg::new(
+                    accessor_idx,
+                    &mut req.sub_aggregation,
+                )?))
+            }
+        }
+        Range(range_req) => Ok(Box::new(SegmentRangeCollector::from_req_and_validate(
+            range_req,
+            &mut req.sub_aggregation,
+            &mut req.limits,
+            req.field_type,
+            accessor_idx,
+        )?)),
+        Histogram(histogram) => Ok(Box::new(SegmentHistogramCollector::from_req_and_validate(
+            histogram.clone(),
+            &mut req.sub_aggregation,
+            req.field_type,
+            accessor_idx,
+        )?)),
+        DateHistogram(histogram) => Ok(Box::new(SegmentHistogramCollector::from_req_and_validate(
+            histogram.to_histogram_req()?,
+            &mut req.sub_aggregation,
+            req.field_type,
+            accessor_idx,
+        )?)),
+        Average(AverageAggregation { missing, .. }) => {
+            Ok(Box::new(SegmentStatsCollector::from_req(
+                req.field_type,
+                SegmentStatsType::Average,
+                accessor_idx,
+                *missing,
+            )))
+        }
+        Count(CountAggregation { missing, .. }) => Ok(Box::new(SegmentStatsCollector::from_req(
+            req.field_type,
+            SegmentStatsType::Count,
+            accessor_idx,
+            *missing,
+        ))),
+        Max(MaxAggregation { missing, .. }) => Ok(Box::new(SegmentStatsCollector::from_req(
+            req.field_type,
+            SegmentStatsType::Max,
+            accessor_idx,
+            *missing,
+        ))),
+        Min(MinAggregation { missing, .. }) => Ok(Box::new(SegmentStatsCollector::from_req(
+            req.field_type,
+            SegmentStatsType::Min,
+            accessor_idx,
+            *missing,
+        ))),
+        Stats(StatsAggregation { missing, .. }) => Ok(Box::new(SegmentStatsCollector::from_req(
+            req.field_type,
+            SegmentStatsType::Stats,
+            accessor_idx,
+            *missing,
+        ))),
+        ExtendedStats(ExtendedStatsAggregation { missing, sigma, .. }) => Ok(Box::new(
+            SegmentExtendedStatsCollector::from_req(req.field_type, *sigma, accessor_idx, *missing),
+        )),
+        Sum(SumAggregation { missing, .. }) => Ok(Box::new(SegmentStatsCollector::from_req(
+            req.field_type,
+            SegmentStatsType::Sum,
+            accessor_idx,
+            *missing,
+        ))),
+        Percentiles(percentiles_req) => Ok(Box::new(
+            SegmentPercentilesCollector::from_req_and_validate(
+                percentiles_req,
+                req.field_type,
+                accessor_idx,
+            )?,
+        )),
+        TopHits(top_hits_req) => Ok(Box::new(TopHitsSegmentCollector::from_req(
+            top_hits_req,
+            accessor_idx,
+            req.segment_ordinal,
+        ))),
+        Cardinality(CardinalityAggregationReq { missing, .. }) => Ok(Box::new(
+            SegmentCardinalityCollector::from_req(req.field_type, accessor_idx, missing),
+        )),
+    }
+}
+
 #[derive(Clone, Default)]
 /// The GenericSegmentAggregationResultsCollector is the generic version of the collector, which
 /// can handle arbitrary complexity of  sub-aggregations. Ideally we never have to pick this one
@@ -77,11 +197,11 @@ impl Debug for GenericSegmentAggregationResultsCollector {
 impl SegmentAggregationCollector for GenericSegmentAggregationResultsCollector {
     fn add_intermediate_aggregation_result(
         self: Box<Self>,
-        agg_data: &AggregationsSegmentCtx,
+        agg_with_accessor: &AggregationsWithAccessor,
         results: &mut IntermediateAggregationResults,
     ) -> crate::Result<()> {
         for agg in self.aggs {
-            agg.add_intermediate_aggregation_result(agg_data, results)?;
+            agg.add_intermediate_aggregation_result(agg_with_accessor, results)?;
         }
 
         Ok(())
@@ -90,9 +210,9 @@ impl SegmentAggregationCollector for GenericSegmentAggregationResultsCollector {
     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)?;
 
         Ok(())
     }
@@ -100,19 +220,32 @@ impl SegmentAggregationCollector for GenericSegmentAggregationResultsCollector {
     fn collect_block(
         &mut self,
         docs: &[crate::DocId],
-        agg_data: &mut AggregationsSegmentCtx,
+        agg_with_accessor: &mut AggregationsWithAccessor,
     ) -> crate::Result<()> {
         for collector in &mut self.aggs {
-            collector.collect_block(docs, agg_data)?;
+            collector.collect_block(docs, agg_with_accessor)?;
         }
 
         Ok(())
     }
 
-    fn flush(&mut self, agg_data: &mut AggregationsSegmentCtx) -> crate::Result<()> {
+    fn flush(&mut self, agg_with_accessor: &mut AggregationsWithAccessor) -> crate::Result<()> {
         for collector in &mut self.aggs {
-            collector.flush(agg_data)?;
+            collector.flush(agg_with_accessor)?;
         }
         Ok(())
     }
 }
+
+impl GenericSegmentAggregationResultsCollector {
+    pub(crate) fn from_req_and_validate(req: &mut AggregationsWithAccessor) -> crate::Result<Self> {
+        let aggs = req
+            .aggs
+            .values_mut()
+            .enumerate()
+            .map(|(accessor_idx, req)| build_single_agg_segment_collector(req, accessor_idx))
+            .collect::<crate::Result<Vec<Box<dyn SegmentAggregationCollector>>>>()?;
+
+        Ok(GenericSegmentAggregationResultsCollector { aggs })
+    }
+}

src/collector/facet_collector.rs

@@ -484,6 +484,7 @@ impl FacetCounts {
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeSet;
+    use std::iter;
 
     use columnar::Dictionary;
     use rand::distributions::Uniform;

src/core/json_utils.rs

@@ -1,4 +1,3 @@
-use columnar::NumericalValue;
 use common::json_path_writer::{JSON_END_OF_PATH, JSON_PATH_SEGMENT_SEP};
 use common::{replace_in_place, JsonPathWriter};
 use rustc_hash::FxHashMap;
@@ -153,7 +152,7 @@ pub(crate) fn index_json_value<'a, V: Value<'a>>(
                 if let Ok(i64_val) = val.try_into() {
                     term_buffer.append_type_and_fast_value::<i64>(i64_val);
                 } else {
-                    term_buffer.append_type_and_fast_value::<u64>(val);
+                    term_buffer.append_type_and_fast_value(val);
                 }
                 postings_writer.subscribe(doc, 0u32, term_buffer, ctx);
             }
@@ -167,30 +166,12 @@ pub(crate) fn index_json_value<'a, V: Value<'a>>(
                 postings_writer.subscribe(doc, 0u32, term_buffer, ctx);
             }
             ReferenceValueLeaf::F64(val) => {
-                if !val.is_finite() {
-                    return;
-                };
                 set_path_id(
                     term_buffer,
                     ctx.path_to_unordered_id
                         .get_or_allocate_unordered_id(json_path_writer.as_str()),
                 );
-                // Normalize here is important.
-                // In the inverted index, we coerce all numerical values to their canonical
-                // representation.
-                //
-                // (We do the same thing on the query side)
-                match NumericalValue::F64(val).normalize() {
-                    NumericalValue::I64(val_i64) => {
-                        term_buffer.append_type_and_fast_value::<i64>(val_i64);
-                    }
-                    NumericalValue::U64(val_u64) => {
-                        term_buffer.append_type_and_fast_value::<u64>(val_u64);
-                    }
-                    NumericalValue::F64(val_f64) => {
-                        term_buffer.append_type_and_fast_value::<f64>(val_f64);
-                    }
-                }
+                term_buffer.append_type_and_fast_value(val);
                 postings_writer.subscribe(doc, 0u32, term_buffer, ctx);
             }
             ReferenceValueLeaf::Bool(val) => {
@@ -260,8 +241,8 @@ pub(crate) fn index_json_value<'a, V: Value<'a>>(
 ///
 /// The term must be json + JSON path.
 pub fn convert_to_fast_value_and_append_to_json_term(
-    term: &Term,
-    text: &str,
+    mut term: Term,
+    phrase: &str,
     truncate_date_for_search: bool,
 ) -> Option<Term> {
     assert_eq!(
@@ -273,50 +254,31 @@ pub fn convert_to_fast_value_and_append_to_json_term(
         0,
         "JSON value bytes should be empty"
     );
-    try_convert_to_datetime_and_append_to_json_term(term, text, truncate_date_for_search)
-        .or_else(|| try_convert_to_number_and_append_to_json_term(term, text))
-        .or_else(|| try_convert_to_bool_and_append_to_json_term_typed(term, text))
-}
-
-fn try_convert_to_datetime_and_append_to_json_term(
-    term: &Term,
-    text: &str,
-    truncate_date_for_search: bool,
-) -> Option<Term> {
-    let dt = OffsetDateTime::parse(text, &Rfc3339).ok()?;
-    let mut dt = DateTime::from_utc(dt.to_offset(UtcOffset::UTC));
-    if truncate_date_for_search {
-        dt = dt.truncate(DATE_TIME_PRECISION_INDEXED);
+    if let Ok(dt) = OffsetDateTime::parse(phrase, &Rfc3339) {
+        let mut dt = DateTime::from_utc(dt.to_offset(UtcOffset::UTC));
+        if truncate_date_for_search {
+            dt = dt.truncate(DATE_TIME_PRECISION_INDEXED);
+        }
+        term.append_type_and_fast_value(dt);
+        return Some(term);
     }
-    let mut term_clone = term.clone();
-    term_clone.append_type_and_fast_value(dt);
-    Some(term_clone)
-}
-
-fn try_convert_to_number_and_append_to_json_term(term: &Term, text: &str) -> Option<Term> {
-    let numerical_value: NumericalValue = str::parse::<NumericalValue>(text).ok()?;
-    let mut term_clone = term.clone();
-    // Parse is actually returning normalized values already today, but let's not
-    // not rely on that hidden contract.
-    match numerical_value.normalize() {
-        NumericalValue::I64(i64_value) => {
-            term_clone.append_type_and_fast_value::<i64>(i64_value);
-        }
-        NumericalValue::U64(u64_value) => {
-            term_clone.append_type_and_fast_value::<u64>(u64_value);
-        }
-        NumericalValue::F64(f64_value) => {
-            term_clone.append_type_and_fast_value::<f64>(f64_value);
-        }
+    if let Ok(i64_val) = str::parse::<i64>(phrase) {
+        term.append_type_and_fast_value(i64_val);
+        return Some(term);
     }
-    Some(term_clone)
-}
-
-fn try_convert_to_bool_and_append_to_json_term_typed(term: &Term, text: &str) -> Option<Term> {
-    let val = str::parse::<bool>(text).ok()?;
-    let mut term_clone = term.clone();
-    term_clone.append_type_and_fast_value(val);
-    Some(term_clone)
+    if let Ok(u64_val) = str::parse::<u64>(phrase) {
+        term.append_type_and_fast_value(u64_val);
+        return Some(term);
+    }
+    if let Ok(f64_val) = str::parse::<f64>(phrase) {
+        term.append_type_and_fast_value(f64_val);
+        return Some(term);
+    }
+    if let Ok(bool_val) = str::parse::<bool>(phrase) {
+        term.append_type_and_fast_value(bool_val);
+        return Some(term);
+    }
+    None
 }
 
 /// Splits a json path supplied to the query parser in such a way that

src/directory/mmap_directory.rs

@@ -484,8 +484,10 @@ impl Directory for MmapDirectory {
             .map_err(LockError::wrap_io_error)?;
         if lock.is_blocking {
             file.lock_exclusive().map_err(LockError::wrap_io_error)?;
-        } else if !file.try_lock_exclusive().map_err(|_| LockError::LockBusy)? {
-            return Err(LockError::LockBusy);
+        } else {
+            if !file.try_lock_exclusive().map_err(|_| LockError::LockBusy)? {
+                return Err(LockError::LockBusy);
+            }
         }
         // dropping the file handle will release the lock.
         Ok(DirectoryLock::from(Box::new(ReleaseLockFile {

src/docset.rs

@@ -87,17 +87,6 @@ pub trait DocSet: Send {
     /// length of the docset.
     fn size_hint(&self) -> u32;
 
-    /// Returns a best-effort hint of the cost to consume the entire docset.
-    ///
-    /// Consuming means calling advance until [`TERMINATED`] is returned.
-    /// The cost should be relative to the cost of driving a Term query,
-    /// which would be the number of documents in the DocSet.
-    ///
-    /// By default this returns `size_hint()`.
-    fn cost(&self) -> u64 {
-        self.size_hint() as u64
-    }
-
     /// Returns the number documents matching.
     /// Calling this method consumes the `DocSet`.
     fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 {
@@ -145,10 +134,6 @@ impl DocSet for &mut dyn DocSet {
         (**self).size_hint()
     }
 
-    fn cost(&self) -> u64 {
-        (**self).cost()
-    }
-
     fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 {
         (**self).count(alive_bitset)
     }
@@ -184,11 +169,6 @@ impl<TDocSet: DocSet + ?Sized> DocSet for Box<TDocSet> {
         unboxed.size_hint()
     }
 
-    fn cost(&self) -> u64 {
-        let unboxed: &TDocSet = self.borrow();
-        unboxed.cost()
-    }
-
     fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 {
         let unboxed: &mut TDocSet = self.borrow_mut();
         unboxed.count(alive_bitset)

src/index/inverted_index_reader.rs

@@ -146,7 +146,7 @@ impl InvertedIndexReader {
                 positions_size: ByteCount::default(),
                 num_terms: 0u64,
             };
-            field_space.record(term_info);
+            field_space.record(&term_info);
 
             // We include the json type and the json end of path to make sure the prefix check
             // is meaningful.

src/indexer/index_writer.rs

@@ -615,7 +615,7 @@ impl<D: Document> IndexWriter<D> {
     /// It is also possible to add a payload to the `commit`
     /// using this API.
     /// See [`PreparedCommit::set_payload()`].
-    pub fn prepare_commit(&mut self) -> crate::Result<PreparedCommit<'_, D>> {
+    pub fn prepare_commit(&mut self) -> crate::Result<PreparedCommit<D>> {
         // Here, because we join all of the worker threads,
         // all of the segment update for this commit have been
         // sent.

src/lib.rs

@@ -55,7 +55,7 @@
 //! // between indexing threads.
 //! let mut index_writer: IndexWriter = index.writer(100_000_000)?;
 //!
-//! // Let's index a document!
+//! // Let's index one documents!
 //! index_writer.add_document(doc!(
 //!     title => "The Old Man and the Sea",
 //!     body => "He was an old man who fished alone in a skiff in \
@@ -370,8 +370,6 @@ macro_rules! fail_point {
 /// Common test utilities.
 #[cfg(test)]
 pub mod tests {
-    use std::collections::BTreeMap;
-
     use common::{BinarySerializable, FixedSize};
     use query_grammar::{UserInputAst, UserInputLeaf, UserInputLiteral};
     use rand::distributions::{Bernoulli, Uniform};
@@ -384,7 +382,7 @@ pub mod tests {
     use crate::index::SegmentReader;
     use crate::merge_policy::NoMergePolicy;
     use crate::postings::Postings;
-    use crate::query::{BooleanQuery, QueryParser};
+    use crate::query::BooleanQuery;
     use crate::schema::*;
     use crate::{DateTime, DocAddress, Index, IndexWriter, ReloadPolicy};
 
@@ -1225,49 +1223,4 @@ pub mod tests {
         );
         assert_eq!(dt_from_ts_nanos.to_hms_micro(), offset_dt.to_hms_micro());
     }
-
-    #[test]
-    fn test_json_number_ambiguity() {
-        let mut schema_builder = Schema::builder();
-        let json_field = schema_builder.add_json_field("number", crate::schema::TEXT);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests().unwrap();
-        {
-            let mut doc = TantivyDocument::new();
-            let mut obj = BTreeMap::default();
-            obj.insert("key".to_string(), OwnedValue::I64(1i64));
-            doc.add_object(json_field, obj);
-            index_writer.add_document(doc).unwrap();
-        }
-        {
-            let mut doc = TantivyDocument::new();
-            let mut obj = BTreeMap::default();
-            obj.insert("key".to_string(), OwnedValue::U64(1u64));
-            doc.add_object(json_field, obj);
-            index_writer.add_document(doc).unwrap();
-        }
-        {
-            let mut doc = TantivyDocument::new();
-            let mut obj = BTreeMap::default();
-            obj.insert("key".to_string(), OwnedValue::F64(1.0f64));
-            doc.add_object(json_field, obj);
-            index_writer.add_document(doc).unwrap();
-        }
-        index_writer.commit().unwrap();
-        let searcher = index.reader().unwrap().searcher();
-        assert_eq!(searcher.num_docs(), 3);
-        {
-            let parser = QueryParser::for_index(&index, vec![]);
-            let query = parser.parse_query("number.key:1").unwrap();
-            let count = searcher.search(&query, &crate::collector::Count).unwrap();
-            assert_eq!(count, 3);
-        }
-        {
-            let parser = QueryParser::for_index(&index, vec![]);
-            let query = parser.parse_query("number.key:1.0").unwrap();
-            let count = searcher.search(&query, &crate::collector::Count).unwrap();
-            assert_eq!(count, 3);
-        }
-    }
 }

src/positions/mod.rs

@@ -41,6 +41,8 @@ const COMPRESSION_BLOCK_SIZE: usize = BitPacker4x::BLOCK_LEN;
 #[cfg(test)]
 pub(crate) mod tests {
 
+    use std::iter;
+
     use proptest::prelude::*;
     use proptest::sample::select;
 

src/postings/block_segment_postings.rs

@@ -227,6 +227,19 @@ impl BlockSegmentPostings {
         self.doc_decoder.output_array()
     }
 
+    /// Returns a full block, regardless of whether the block is complete or incomplete (
+    /// as it happens for the last block of the posting list).
+    ///
+    /// In the latter case, the block is guaranteed to be padded with the sentinel value:
+    /// `TERMINATED`. The array is also guaranteed to be aligned on 16 bytes = 128 bits.
+    ///
+    /// This method is useful to run SSE2 linear search.
+    #[inline]
+    pub(crate) fn full_block(&self) -> &[DocId; COMPRESSION_BLOCK_SIZE] {
+        debug_assert!(self.block_is_loaded());
+        self.doc_decoder.full_output()
+    }
+
     /// Return the document at index `idx` of the block.
     #[inline]
     pub fn doc(&self, idx: usize) -> u32 {
@@ -262,36 +275,22 @@ impl BlockSegmentPostings {
     ///
     /// If all docs are smaller than target, the block loaded may be empty,
     /// or be the last an incomplete VInt block.
-    pub fn seek(&mut self, target_doc: DocId) -> usize {
-        // Move to the block that might contain our document.
-        self.seek_block(target_doc);
+    pub fn seek(&mut self, target_doc: DocId) {
+        self.shallow_seek(target_doc);
         self.load_block();
-
-        // At this point we are on the block that might contain our document.
-        let doc = self.doc_decoder.seek_within_block(target_doc);
-
-        // The last block is not full and padded with TERMINATED,
-        // so we are guaranteed to have at least one value (real or padding)
-        // that is >= target_doc.
-        debug_assert!(doc < COMPRESSION_BLOCK_SIZE);
-
-        // `doc` is now the first element >= `target_doc`.
-        // If all docs are smaller than target, the current block is incomplete and padded
-        // with TERMINATED. After the search, the cursor points to the first TERMINATED.
-        doc
     }
 
     pub(crate) fn position_offset(&self) -> u64 {
         self.skip_reader.position_offset()
     }
 
-    /// Dangerous API! This calls seeks the next block on the skip list,
+    /// Dangerous API! This calls seek on the skip list,
     /// but does not `.load_block()` afterwards.
     ///
     /// `.load_block()` needs to be called manually afterwards.
     /// If all docs are smaller than target, the block loaded may be empty,
     /// or be the last an incomplete VInt block.
-    pub(crate) fn seek_block(&mut self, target_doc: DocId) {
+    pub(crate) fn shallow_seek(&mut self, target_doc: DocId) {
         if self.skip_reader.seek(target_doc) {
             self.block_max_score_cache = None;
             self.block_loaded = false;

src/postings/compression/mod.rs

@@ -151,11 +151,9 @@ impl BlockDecoder {
         &self.output[..self.output_len]
     }
 
-    /// Return in-block index of first value >= `target`.
-    /// Uses the padded buffer to enable branchless search.
     #[inline]
-    pub(crate) fn seek_within_block(&self, target: u32) -> usize {
-        crate::postings::branchless_binary_search(&self.output, target)
+    pub(crate) fn full_output(&self) -> &[u32; COMPRESSION_BLOCK_SIZE] {
+        &self.output
     }
 
     #[inline]

src/postings/mod.rs

@@ -667,15 +667,12 @@ mod bench {
                 .read_postings(&TERM_D, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
-            let mut intersection = Intersection::new(
-                vec![
-                    segment_postings_a,
-                    segment_postings_b,
-                    segment_postings_c,
-                    segment_postings_d,
-                ],
-                reader.searcher().num_docs() as u32,
-            );
+            let mut intersection = Intersection::new(vec![
+                segment_postings_a,
+                segment_postings_b,
+                segment_postings_c,
+                segment_postings_d,
+            ]);
             while intersection.advance() != TERMINATED {}
         });
     }

src/postings/segment_postings.rs

@@ -4,7 +4,7 @@ use crate::docset::DocSet;
 use crate::fastfield::AliveBitSet;
 use crate::positions::PositionReader;
 use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
-use crate::postings::{BlockSegmentPostings, Postings};
+use crate::postings::{branchless_binary_search, BlockSegmentPostings, Postings};
 use crate::{DocId, TERMINATED};
 
 /// `SegmentPostings` represents the inverted list or postings associated with
@@ -175,11 +175,26 @@ impl DocSet for SegmentPostings {
             return self.doc();
         }
 
-        // Delegate block-local search to BlockSegmentPostings::seek, which returns
-        // the in-block index of the first doc >= target.
-        self.cur = self.block_cursor.seek(target);
-        let doc = self.doc();
+        self.block_cursor.seek(target);
+
+        // At this point we are on the block, that might contain our document.
+        let output = self.block_cursor.full_block();
+        self.cur = branchless_binary_search(output, target);
+
+        // The last block is not full and padded with the value TERMINATED,
+        // so that we are guaranteed to have at least doc in the block (a real one or the padding)
+        // that is greater or equal to the target.
+        debug_assert!(self.cur < COMPRESSION_BLOCK_SIZE);
+
+        // `doc` is now the first element >= `target`
+
+        // If all docs are smaller than target the current block should be incomplemented and padded
+        // with the value `TERMINATED`.
+        //
+        // After the search, the cursor should point to the first value of TERMINATED.
+        let doc = output[self.cur];
         debug_assert!(doc >= target);
+        debug_assert_eq!(doc, self.doc());
         doc
     }
 

src/postings/serializer.rs

@@ -75,7 +75,7 @@ impl InvertedIndexSerializer {
         field: Field,
         total_num_tokens: u64,
         fieldnorm_reader: Option<FieldNormReader>,
-    ) -> io::Result<FieldSerializer<'_>> {
+    ) -> io::Result<FieldSerializer> {
         let field_entry: &FieldEntry = self.schema.get_field_entry(field);
         let term_dictionary_write = self.terms_write.for_field(field);
         let postings_write = self.postings_write.for_field(field);
@@ -126,7 +126,7 @@ impl<'a> FieldSerializer<'a> {
         let term_dictionary_builder = TermDictionaryBuilder::create(term_dictionary_write)?;
         let average_fieldnorm = fieldnorm_reader
             .as_ref()
-            .map(|ff_reader| total_num_tokens as Score / ff_reader.num_docs() as Score)
+            .map(|ff_reader| (total_num_tokens as Score / ff_reader.num_docs() as Score))
             .unwrap_or(0.0);
         let postings_serializer = PostingsSerializer::new(
             postings_write,

src/query/bm25.rs

@@ -1,3 +1,5 @@
+use serde::{Deserialize, Serialize};
+
 use crate::fieldnorm::FieldNormReader;
 use crate::query::Explanation;
 use crate::schema::Field;
@@ -66,6 +68,12 @@ fn compute_tf_cache(average_fieldnorm: Score) -> [Score; 256] {
     cache
 }
 
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+pub struct Bm25Params {
+    pub idf: Score,
+    pub avg_fieldnorm: Score,
+}
+
 /// A struct used for computing BM25 scores.
 #[derive(Clone)]
 pub struct Bm25Weight {

src/query/boolean_query/block_wand.rs

@@ -167,7 +167,7 @@ pub fn block_wand(
         let block_max_score_upperbound: Score = scorers[..pivot_len]
             .iter_mut()
             .map(|scorer| {
-                scorer.seek_block(pivot_doc);
+                scorer.shallow_seek(pivot_doc);
                 scorer.block_max_score()
             })
             .sum();
@@ -234,7 +234,7 @@ pub fn block_wand_single_scorer(
                 return;
             }
             doc = last_doc_in_block + 1;
-            scorer.seek_block(doc);
+            scorer.shallow_seek(doc);
         }
         // Seek will effectively load that block.
         doc = scorer.seek(doc);
@@ -256,7 +256,7 @@ pub fn block_wand_single_scorer(
             }
         }
         doc += 1;
-        scorer.seek_block(doc);
+        scorer.shallow_seek(doc);
     }
 }
 
@@ -302,6 +302,7 @@ fn is_sorted<I: Iterator<Item = DocId>>(mut it: I) -> bool {
 mod tests {
     use std::cmp::Ordering;
     use std::collections::BinaryHeap;
+    use std::iter;
 
     use proptest::prelude::*;
 
@@ -367,14 +368,10 @@ mod tests {
         checkpoints
     }
 
-    fn compute_checkpoints_manual(
-        term_scorers: Vec<TermScorer>,
-        n: usize,
-        max_doc: u32,
-    ) -> Vec<(DocId, Score)> {
+    fn compute_checkpoints_manual(term_scorers: Vec<TermScorer>, n: usize) -> Vec<(DocId, Score)> {
         let mut heap: BinaryHeap<Float> = BinaryHeap::with_capacity(n);
         let mut checkpoints: Vec<(DocId, Score)> = Vec::new();
-        let mut scorer = BufferedUnionScorer::build(term_scorers, SumCombiner::default, max_doc);
+        let mut scorer = BufferedUnionScorer::build(term_scorers, SumCombiner::default);
 
         let mut limit = Score::MIN;
         loop {
@@ -482,8 +479,7 @@ mod tests {
         for top_k in 1..4 {
             let checkpoints_for_each_pruning =
                 compute_checkpoints_for_each_pruning(term_scorers.clone(), top_k);
-            let checkpoints_manual =
-                compute_checkpoints_manual(term_scorers.clone(), top_k, 100_000);
+            let checkpoints_manual = compute_checkpoints_manual(term_scorers.clone(), top_k);
             assert_eq!(checkpoints_for_each_pruning.len(), checkpoints_manual.len());
             for (&(left_doc, left_score), &(right_doc, right_score)) in checkpoints_for_each_pruning
                 .iter()

src/query/boolean_query/boolean_weight.rs

@@ -39,11 +39,9 @@ where
     ))
 }
 
-/// num_docs is the number of documents in the segment.
 fn scorer_union<TScoreCombiner>(
     scorers: Vec<Box<dyn Scorer>>,
     score_combiner_fn: impl Fn() -> TScoreCombiner,
-    num_docs: u32,
 ) -> SpecializedScorer
 where
     TScoreCombiner: ScoreCombiner,
@@ -70,7 +68,6 @@ where
                 return SpecializedScorer::Other(Box::new(BufferedUnionScorer::build(
                     scorers,
                     score_combiner_fn,
-                    num_docs,
                 )));
             }
         }
@@ -78,19 +75,16 @@ where
     SpecializedScorer::Other(Box::new(BufferedUnionScorer::build(
         scorers,
         score_combiner_fn,
-        num_docs,
     )))
 }
 
 fn into_box_scorer<TScoreCombiner: ScoreCombiner>(
     scorer: SpecializedScorer,
     score_combiner_fn: impl Fn() -> TScoreCombiner,
-    num_docs: u32,
 ) -> Box<dyn Scorer> {
     match scorer {
         SpecializedScorer::TermUnion(term_scorers) => {
-            let union_scorer =
-                BufferedUnionScorer::build(term_scorers, score_combiner_fn, num_docs);
+            let union_scorer = BufferedUnionScorer::build(term_scorers, score_combiner_fn);
             Box::new(union_scorer)
         }
         SpecializedScorer::Other(scorer) => scorer,
@@ -157,7 +151,6 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
         boost: Score,
         score_combiner_fn: impl Fn() -> TComplexScoreCombiner,
     ) -> crate::Result<SpecializedScorer> {
-        let num_docs = reader.num_docs();
         let mut per_occur_scorers = self.per_occur_scorers(reader, boost)?;
         // Indicate how should clauses are combined with other clauses.
         enum CombinationMethod {
@@ -174,16 +167,11 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
                 return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)));
             }
             match self.minimum_number_should_match {
-                0 => CombinationMethod::Optional(scorer_union(
-                    should_scorers,
-                    &score_combiner_fn,
-                    num_docs,
-                )),
-                1 => CombinationMethod::Required(scorer_union(
-                    should_scorers,
-                    &score_combiner_fn,
-                    num_docs,
-                )),
+                0 => CombinationMethod::Optional(scorer_union(should_scorers, &score_combiner_fn)),
+                1 => {
+                    let scorer_union = scorer_union(should_scorers, &score_combiner_fn);
+                    CombinationMethod::Required(scorer_union)
+                }
                 n if num_of_should_scorers == n => {
                     // When num_of_should_scorers equals the number of should clauses,
                     // they are no different from must clauses.
@@ -212,21 +200,21 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
         };
         let exclude_scorer_opt: Option<Box<dyn Scorer>> = per_occur_scorers
             .remove(&Occur::MustNot)
-            .map(|scorers| scorer_union(scorers, DoNothingCombiner::default, num_docs))
+            .map(|scorers| scorer_union(scorers, DoNothingCombiner::default))
             .map(|specialized_scorer: SpecializedScorer| {
-                into_box_scorer(specialized_scorer, DoNothingCombiner::default, num_docs)
+                into_box_scorer(specialized_scorer, DoNothingCombiner::default)
             });
         let positive_scorer = match (should_opt, must_scorers) {
             (CombinationMethod::Ignored, Some(must_scorers)) => {
-                SpecializedScorer::Other(intersect_scorers(must_scorers, num_docs))
+                SpecializedScorer::Other(intersect_scorers(must_scorers))
             }
             (CombinationMethod::Optional(should_scorer), Some(must_scorers)) => {
-                let must_scorer = intersect_scorers(must_scorers, num_docs);
+                let must_scorer = intersect_scorers(must_scorers);
                 if self.scoring_enabled {
                     SpecializedScorer::Other(Box::new(
                         RequiredOptionalScorer::<_, _, TScoreCombiner>::new(
                             must_scorer,
-                            into_box_scorer(should_scorer, &score_combiner_fn, num_docs),
+                            into_box_scorer(should_scorer, &score_combiner_fn),
                         ),
                     ))
                 } else {
@@ -234,8 +222,8 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
                 }
             }
             (CombinationMethod::Required(should_scorer), Some(mut must_scorers)) => {
-                must_scorers.push(into_box_scorer(should_scorer, &score_combiner_fn, num_docs));
-                SpecializedScorer::Other(intersect_scorers(must_scorers, num_docs))
+                must_scorers.push(into_box_scorer(should_scorer, &score_combiner_fn));
+                SpecializedScorer::Other(intersect_scorers(must_scorers))
             }
             (CombinationMethod::Ignored, None) => {
                 return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)))
@@ -245,8 +233,7 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
             (CombinationMethod::Optional(should_scorer), None) => should_scorer,
         };
         if let Some(exclude_scorer) = exclude_scorer_opt {
-            let positive_scorer_boxed =
-                into_box_scorer(positive_scorer, &score_combiner_fn, num_docs);
+            let positive_scorer_boxed = into_box_scorer(positive_scorer, &score_combiner_fn);
             Ok(SpecializedScorer::Other(Box::new(Exclude::new(
                 positive_scorer_boxed,
                 exclude_scorer,
@@ -259,7 +246,6 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
 
 impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombiner> {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
-        let num_docs = reader.num_docs();
         if self.weights.is_empty() {
             Ok(Box::new(EmptyScorer))
         } else if self.weights.len() == 1 {
@@ -272,12 +258,12 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         } else if self.scoring_enabled {
             self.complex_scorer(reader, boost, &self.score_combiner_fn)
                 .map(|specialized_scorer| {
-                    into_box_scorer(specialized_scorer, &self.score_combiner_fn, num_docs)
+                    into_box_scorer(specialized_scorer, &self.score_combiner_fn)
                 })
         } else {
             self.complex_scorer(reader, boost, DoNothingCombiner::default)
                 .map(|specialized_scorer| {
-                    into_box_scorer(specialized_scorer, DoNothingCombiner::default, num_docs)
+                    into_box_scorer(specialized_scorer, DoNothingCombiner::default)
                 })
         }
     }
@@ -310,11 +296,8 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn)?;
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
-                let mut union_scorer = BufferedUnionScorer::build(
-                    term_scorers,
-                    &self.score_combiner_fn,
-                    reader.num_docs(),
-                );
+                let mut union_scorer =
+                    BufferedUnionScorer::build(term_scorers, &self.score_combiner_fn);
                 for_each_scorer(&mut union_scorer, callback);
             }
             SpecializedScorer::Other(mut scorer) => {
@@ -334,11 +317,8 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
 
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
-                let mut union_scorer = BufferedUnionScorer::build(
-                    term_scorers,
-                    &self.score_combiner_fn,
-                    reader.num_docs(),
-                );
+                let mut union_scorer =
+                    BufferedUnionScorer::build(term_scorers, &self.score_combiner_fn);
                 for_each_docset_buffered(&mut union_scorer, &mut buffer, callback);
             }
             SpecializedScorer::Other(mut scorer) => {

src/query/boost_query.rs

@@ -117,10 +117,6 @@ impl<S: Scorer> DocSet for BoostScorer<S> {
         self.underlying.size_hint()
     }
 
-    fn cost(&self) -> u64 {
-        self.underlying.cost()
-    }
-
     fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 {
         self.underlying.count(alive_bitset)
     }

src/query/const_score_query.rs

@@ -130,10 +130,6 @@ impl<TDocSet: DocSet> DocSet for ConstScorer<TDocSet> {
     fn size_hint(&self) -> u32 {
         self.docset.size_hint()
     }
-
-    fn cost(&self) -> u64 {
-        self.docset.cost()
-    }
 }
 
 impl<TDocSet: DocSet + 'static> Scorer for ConstScorer<TDocSet> {

src/query/disjunction.rs

@@ -70,10 +70,6 @@ impl<T: Scorer> DocSet for ScorerWrapper<T> {
     fn size_hint(&self) -> u32 {
         self.scorer.size_hint()
     }
-
-    fn cost(&self) -> u64 {
-        self.scorer.cost()
-    }
 }
 
 impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> Disjunction<TScorer, TScoreCombiner> {
@@ -150,14 +146,6 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> DocSet
             .max()
             .unwrap_or(0u32)
     }
-
-    fn cost(&self) -> u64 {
-        self.chains
-            .iter()
-            .map(|docset| docset.cost())
-            .max()
-            .unwrap_or(0u64)
-    }
 }
 
 impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> Scorer

src/query/exist_query.rs

@@ -1,15 +1,12 @@
 use core::fmt::Debug;
 
 use columnar::{ColumnIndex, DynamicColumn};
-use common::BitSet;
 
 use super::{ConstScorer, EmptyScorer};
 use crate::docset::{DocSet, TERMINATED};
 use crate::index::SegmentReader;
-use crate::query::all_query::AllScorer;
-use crate::query::boost_query::BoostScorer;
 use crate::query::explanation::does_not_match;
-use crate::query::{BitSetDocSet, EnableScoring, Explanation, Query, Scorer, Weight};
+use crate::query::{EnableScoring, Explanation, Query, Scorer, Weight};
 use crate::schema::Type;
 use crate::{DocId, Score, TantivyError};
 
@@ -116,49 +113,13 @@ impl Weight for ExistsWeight {
                 non_empty_columns.push(column)
             }
         }
-        if non_empty_columns.is_empty() {
-            return Ok(Box::new(EmptyScorer));
-        }
-
-        // If any column is full, all docs match.
-        let max_doc = reader.max_doc();
-        if non_empty_columns
-            .iter()
-            .any(|col| matches!(col.column_index(), ColumnIndex::Full))
-        {
-            let all_scorer = AllScorer::new(max_doc);
-            return Ok(Box::new(BoostScorer::new(all_scorer, boost)));
-        }
-
-        // If we have a single dynamic column, use ExistsDocSet
-        // NOTE: A lower number may be better for very sparse columns
-        if non_empty_columns.len() < 4 {
+        // TODO: we can optimizer more here since in most cases we will have only one index
+        if !non_empty_columns.is_empty() {
             let docset = ExistsDocSet::new(non_empty_columns, reader.max_doc());
-            return Ok(Box::new(ConstScorer::new(docset, boost)));
+            Ok(Box::new(ConstScorer::new(docset, boost)))
+        } else {
+            Ok(Box::new(EmptyScorer))
         }
-
-        // If we have many dynamic columns, precompute a bitset of matching docs
-        let mut doc_bitset = BitSet::with_max_value(max_doc);
-        for column in &non_empty_columns {
-            match column.column_index() {
-                ColumnIndex::Empty { .. } => {}
-                ColumnIndex::Full => {
-                    // Handled by AllScorer return above.
-                }
-                ColumnIndex::Optional(optional_index) => {
-                    for doc in optional_index.iter_non_null_docs() {
-                        doc_bitset.insert(doc);
-                    }
-                }
-                ColumnIndex::Multivalued(multi_idx) => {
-                    for doc in multi_idx.iter_non_null_docs() {
-                        doc_bitset.insert(doc);
-                    }
-                }
-            }
-        }
-        let docset = BitSetDocSet::from(doc_bitset);
-        Ok(Box::new(ConstScorer::new(docset, boost)))
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
@@ -333,43 +294,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_exists_query_json_union_no_single_full_subpath() -> crate::Result<()> {
-        // Build docs where no single subpath exists for all docs, but the union does.
-        let mut schema_builder = Schema::builder();
-        let json = schema_builder.add_json_field("json", TEXT | FAST);
-        let schema = schema_builder.build();
-
-        let index = Index::create_in_ram(schema);
-        {
-            let mut index_writer = index.writer_for_tests()?;
-            for i in 0u64..100u64 {
-                if i % 2 == 0 {
-                    // only subpath `a`
-                    index_writer.add_document(doc!(json => json!({"a": i})))?;
-                } else {
-                    // only subpath `b`
-                    index_writer.add_document(doc!(json => json!({"b": i})))?;
-                }
-            }
-            index_writer.commit()?;
-        }
-        let reader = index.reader()?;
-        let searcher = reader.searcher();
-
-        // No single subpath is full
-        assert_eq!(count_existing_fields(&searcher, "json.a", false)?, 50);
-        assert_eq!(count_existing_fields(&searcher, "json.b", false)?, 50);
-
-        // Root exists with subpaths disabled is zero
-        assert_eq!(count_existing_fields(&searcher, "json", false)?, 0);
-
-        // Root exists with subpaths enabled should match all docs via union
-        assert_eq!(count_existing_fields(&searcher, "json", true)?, 100);
-
-        Ok(())
-    }
-
     #[test]
     fn test_exists_query_misc_supported_types() -> crate::Result<()> {
         let mut schema_builder = Schema::builder();

src/query/intersection.rs

@@ -1,5 +1,4 @@
 use crate::docset::{DocSet, TERMINATED};
-use crate::query::size_hint::estimate_intersection;
 use crate::query::term_query::TermScorer;
 use crate::query::{EmptyScorer, Scorer};
 use crate::{DocId, Score};
@@ -12,18 +11,14 @@ use crate::{DocId, Score};
 /// For better performance, the function uses a
 /// specialized implementation if the two
 /// shortest scorers are `TermScorer`s.
-pub fn intersect_scorers(
-    mut scorers: Vec<Box<dyn Scorer>>,
-    num_docs_segment: u32,
-) -> Box<dyn Scorer> {
+pub fn intersect_scorers(mut scorers: Vec<Box<dyn Scorer>>) -> Box<dyn Scorer> {
     if scorers.is_empty() {
         return Box::new(EmptyScorer);
     }
     if scorers.len() == 1 {
         return scorers.pop().unwrap();
     }
-    // Order by estimated cost to drive each scorer.
-    scorers.sort_by_key(|scorer| scorer.cost());
+    scorers.sort_by_key(|scorer| scorer.size_hint());
     let doc = go_to_first_doc(&mut scorers[..]);
     if doc == TERMINATED {
         return Box::new(EmptyScorer);
@@ -39,14 +34,12 @@ pub fn intersect_scorers(
             left: *(left.downcast::<TermScorer>().map_err(|_| ()).unwrap()),
             right: *(right.downcast::<TermScorer>().map_err(|_| ()).unwrap()),
             others: scorers,
-            num_docs: num_docs_segment,
         });
     }
     Box::new(Intersection {
         left,
         right,
         others: scorers,
-        num_docs: num_docs_segment,
     })
 }
 
@@ -55,7 +48,6 @@ pub struct Intersection<TDocSet: DocSet, TOtherDocSet: DocSet = Box<dyn Scorer>>
     left: TDocSet,
     right: TDocSet,
     others: Vec<TOtherDocSet>,
-    num_docs: u32,
 }
 
 fn go_to_first_doc<TDocSet: DocSet>(docsets: &mut [TDocSet]) -> DocId {
@@ -74,11 +66,10 @@ fn go_to_first_doc<TDocSet: DocSet>(docsets: &mut [TDocSet]) -> DocId {
 }
 
 impl<TDocSet: DocSet> Intersection<TDocSet, TDocSet> {
-    /// num_docs is the number of documents in the segment.
-    pub(crate) fn new(mut docsets: Vec<TDocSet>, num_docs: u32) -> Intersection<TDocSet, TDocSet> {
+    pub(crate) fn new(mut docsets: Vec<TDocSet>) -> Intersection<TDocSet, TDocSet> {
         let num_docsets = docsets.len();
         assert!(num_docsets >= 2);
-        docsets.sort_by_key(|docset| docset.cost());
+        docsets.sort_by_key(|docset| docset.size_hint());
         go_to_first_doc(&mut docsets);
         let left = docsets.remove(0);
         let right = docsets.remove(0);
@@ -86,7 +77,6 @@ impl<TDocSet: DocSet> Intersection<TDocSet, TDocSet> {
             left,
             right,
             others: docsets,
-            num_docs,
         }
     }
 }
@@ -151,19 +141,7 @@ impl<TDocSet: DocSet, TOtherDocSet: DocSet> DocSet for Intersection<TDocSet, TOt
     }
 
     fn size_hint(&self) -> u32 {
-        estimate_intersection(
-            [self.left.size_hint(), self.right.size_hint()]
-                .into_iter()
-                .chain(self.others.iter().map(DocSet::size_hint)),
-            self.num_docs,
-        )
-    }
-
-    fn cost(&self) -> u64 {
-        // What's the best way to compute the cost of an intersection?
-        // For now we take the cost of the docset driver, which is the first docset.
-        // If there are docsets that are bad at skipping, they should also influence the cost.
-        self.left.cost()
+        self.left.size_hint()
     }
 }
 
@@ -191,7 +169,7 @@ mod tests {
         {
             let left = VecDocSet::from(vec![1, 3, 9]);
             let right = VecDocSet::from(vec![3, 4, 9, 18]);
-            let mut intersection = Intersection::new(vec![left, right], 10);
+            let mut intersection = Intersection::new(vec![left, right]);
             assert_eq!(intersection.doc(), 3);
             assert_eq!(intersection.advance(), 9);
             assert_eq!(intersection.doc(), 9);
@@ -201,7 +179,7 @@ mod tests {
             let a = VecDocSet::from(vec![1, 3, 9]);
             let b = VecDocSet::from(vec![3, 4, 9, 18]);
             let c = VecDocSet::from(vec![1, 5, 9, 111]);
-            let mut intersection = Intersection::new(vec![a, b, c], 10);
+            let mut intersection = Intersection::new(vec![a, b, c]);
             assert_eq!(intersection.doc(), 9);
             assert_eq!(intersection.advance(), TERMINATED);
         }
@@ -211,7 +189,7 @@ mod tests {
     fn test_intersection_zero() {
         let left = VecDocSet::from(vec![0]);
         let right = VecDocSet::from(vec![0]);
-        let mut intersection = Intersection::new(vec![left, right], 10);
+        let mut intersection = Intersection::new(vec![left, right]);
         assert_eq!(intersection.doc(), 0);
         assert_eq!(intersection.advance(), TERMINATED);
     }
@@ -220,7 +198,7 @@ mod tests {
     fn test_intersection_skip() {
         let left = VecDocSet::from(vec![0, 1, 2, 4]);
         let right = VecDocSet::from(vec![2, 5]);
-        let mut intersection = Intersection::new(vec![left, right], 10);
+        let mut intersection = Intersection::new(vec![left, right]);
         assert_eq!(intersection.seek(2), 2);
         assert_eq!(intersection.doc(), 2);
     }
@@ -231,7 +209,7 @@ mod tests {
             || {
                 let left = VecDocSet::from(vec![4]);
                 let right = VecDocSet::from(vec![2, 5]);
-                Box::new(Intersection::new(vec![left, right], 10))
+                Box::new(Intersection::new(vec![left, right]))
             },
             vec![0, 2, 4, 5, 6],
         );
@@ -241,22 +219,19 @@ mod tests {
                 let mut right = VecDocSet::from(vec![2, 5, 10]);
                 left.advance();
                 right.advance();
-                Box::new(Intersection::new(vec![left, right], 10))
+                Box::new(Intersection::new(vec![left, right]))
             },
             vec![0, 1, 2, 3, 4, 5, 6, 7, 10, 11],
         );
         test_skip_against_unoptimized(
             || {
-                Box::new(Intersection::new(
-                    vec![
-                        VecDocSet::from(vec![1, 4, 5, 6]),
-                        VecDocSet::from(vec![1, 2, 5, 6]),
-                        VecDocSet::from(vec![1, 4, 5, 6]),
-                        VecDocSet::from(vec![1, 5, 6]),
-                        VecDocSet::from(vec![2, 4, 5, 7, 8]),
-                    ],
-                    10,
-                ))
+                Box::new(Intersection::new(vec![
+                    VecDocSet::from(vec![1, 4, 5, 6]),
+                    VecDocSet::from(vec![1, 2, 5, 6]),
+                    VecDocSet::from(vec![1, 4, 5, 6]),
+                    VecDocSet::from(vec![1, 5, 6]),
+                    VecDocSet::from(vec![2, 4, 5, 7, 8]),
+                ]))
             },
             vec![0, 1, 2, 3, 4, 5, 6, 7, 10, 11],
         );
@@ -267,7 +242,7 @@ mod tests {
         let a = VecDocSet::from(vec![1, 3]);
         let b = VecDocSet::from(vec![1, 4]);
         let c = VecDocSet::from(vec![3, 9]);
-        let intersection = Intersection::new(vec![a, b, c], 10);
+        let intersection = Intersection::new(vec![a, b, c]);
         assert_eq!(intersection.doc(), TERMINATED);
     }
 }

src/query/mod.rs

@@ -23,7 +23,6 @@ mod regex_query;
 mod reqopt_scorer;
 mod scorer;
 mod set_query;
-mod size_hint;
 mod term_query;
 mod union;
 mod weight;
@@ -105,7 +104,7 @@ mod tests {
             let query = query_parser.parse_query("a a a a a").unwrap();
             let mut terms = Vec::new();
             query.query_terms(&mut |term, pos| terms.push((term, pos)));
-            assert_eq!(vec![(&term_a, false); 1], terms);
+            assert_eq!(vec![(&term_a, false); 5], terms);
         }
         {
             let query = query_parser.parse_query("a -b").unwrap();

src/query/phrase_prefix_query/phrase_prefix_scorer.rs

@@ -200,10 +200,6 @@ impl<TPostings: Postings> DocSet for PhrasePrefixScorer<TPostings> {
     fn size_hint(&self) -> u32 {
         self.phrase_scorer.size_hint()
     }
-
-    fn cost(&self) -> u64 {
-        self.phrase_scorer.cost()
-    }
 }
 
 impl<TPostings: Postings> Scorer for PhrasePrefixScorer<TPostings> {

src/query/phrase_query/phrase_scorer.rs

@@ -368,7 +368,6 @@ impl<TPostings: Postings> PhraseScorer<TPostings> {
         slop: u32,
         offset: usize,
     ) -> PhraseScorer<TPostings> {
-        let num_docs = fieldnorm_reader.num_docs();
         let max_offset = term_postings_with_offset
             .iter()
             .map(|&(offset, _)| offset)
@@ -383,7 +382,7 @@ impl<TPostings: Postings> PhraseScorer<TPostings> {
             })
             .collect::<Vec<_>>();
         let mut scorer = PhraseScorer {
-            intersection_docset: Intersection::new(postings_with_offsets, num_docs),
+            intersection_docset: Intersection::new(postings_with_offsets),
             num_terms: num_docsets,
             left_positions: Vec::with_capacity(100),
             right_positions: Vec::with_capacity(100),
@@ -536,15 +535,6 @@ impl<TPostings: Postings> DocSet for PhraseScorer<TPostings> {
     fn size_hint(&self) -> u32 {
         self.intersection_docset.size_hint()
     }
-
-    /// Returns a best-effort hint of the
-    /// cost to drive the docset.
-    fn cost(&self) -> u64 {
-        // Evaluating phrase matches is generally more expensive than simple term matches,
-        // as it requires loading and comparing positions. Use a conservative multiplier
-        // based on the number of terms.
-        self.intersection_docset.size_hint() as u64 * 10 * self.num_terms as u64
-    }
 }
 
 impl<TPostings: Postings> Scorer for PhraseScorer<TPostings> {

src/query/query_parser/logical_ast.rs

@@ -1,11 +1,8 @@
 use std::fmt;
 use std::ops::Bound;
-use std::sync::Arc;
-
-use tantivy_fst::Regex;
 
 use crate::query::Occur;
-use crate::schema::{Field, Term};
+use crate::schema::Term;
 use crate::Score;
 
 #[derive(Clone)]
@@ -24,10 +21,6 @@ pub enum LogicalLiteral {
         elements: Vec<Term>,
     },
     All,
-    Regex {
-        pattern: Arc<Regex>,
-        field: Field,
-    },
 }
 
 pub enum LogicalAst {
@@ -45,7 +38,6 @@ impl LogicalAst {
         }
     }
 
-    // TODO: Move to rewrite_ast in query_grammar
     pub fn simplify(self) -> LogicalAst {
         match self {
             LogicalAst::Clause(clauses) => {
@@ -155,10 +147,6 @@ impl fmt::Debug for LogicalLiteral {
                 write!(formatter, "]")
             }
             LogicalLiteral::All => write!(formatter, "*"),
-            LogicalLiteral::Regex {
-                ref pattern,
-                ref field,
-            } => write!(formatter, "Regex({field:?}, {pattern:?})"),
         }
     }
 }

src/query/query_parser/query_parser.rs

@@ -2,14 +2,12 @@ use std::net::{AddrParseError, IpAddr};
 use std::num::{ParseFloatError, ParseIntError};
 use std::ops::Bound;
 use std::str::{FromStr, ParseBoolError};
-use std::sync::Arc;
 
 use base64::engine::general_purpose::STANDARD as BASE64;
 use base64::Engine;
 use itertools::Itertools;
 use query_grammar::{UserInputAst, UserInputBound, UserInputLeaf, UserInputLiteral};
 use rustc_hash::FxHashMap;
-use tantivy_fst::Regex;
 
 use super::logical_ast::*;
 use crate::index::Index;
@@ -17,7 +15,7 @@ use crate::json_utils::convert_to_fast_value_and_append_to_json_term;
 use crate::query::range_query::{is_type_valid_for_fastfield_range_query, RangeQuery};
 use crate::query::{
     AllQuery, BooleanQuery, BoostQuery, EmptyQuery, FuzzyTermQuery, Occur, PhrasePrefixQuery,
-    PhraseQuery, Query, RegexQuery, TermQuery, TermSetQuery,
+    PhraseQuery, Query, TermQuery, TermSetQuery,
 };
 use crate::schema::{
     Facet, FacetParseError, Field, FieldType, IndexRecordOption, IntoIpv6Addr, JsonObjectOptions,
@@ -208,7 +206,6 @@ pub struct QueryParser {
     tokenizer_manager: TokenizerManager,
     boost: FxHashMap<Field, Score>,
     fuzzy: FxHashMap<Field, Fuzzy>,
-    regexes_allowed: bool,
 }
 
 #[derive(Clone)]
@@ -263,7 +260,6 @@ impl QueryParser {
             conjunction_by_default: false,
             boost: Default::default(),
             fuzzy: Default::default(),
-            regexes_allowed: false,
         }
     }
 
@@ -324,11 +320,6 @@ impl QueryParser {
         );
     }
 
-    /// Allow regexes in queries
-    pub fn allow_regexes(&mut self) {
-        self.regexes_allowed = true;
-    }
-
     /// Parse a query
     ///
     /// Note that `parse_query` returns an error if the input
@@ -495,17 +486,24 @@ impl QueryParser {
                 Ok(terms.into_iter().next().unwrap())
             }
             FieldType::JsonObject(ref json_options) => {
-                let mut term = Term::from_field_json_path(
-                    field,
-                    json_path,
-                    json_options.is_expand_dots_enabled(),
-                );
+                let get_term_with_path = || {
+                    Term::from_field_json_path(
+                        field,
+                        json_path,
+                        json_options.is_expand_dots_enabled(),
+                    )
+                };
                 if let Some(term) =
                     // Try to convert the phrase to a fast value
-                    convert_to_fast_value_and_append_to_json_term(&term, phrase, false)
+                    convert_to_fast_value_and_append_to_json_term(
+                        get_term_with_path(),
+                        phrase,
+                        false,
+                    )
                 {
                     Ok(term)
                 } else {
+                    let mut term = get_term_with_path();
                     term.append_type_and_str(phrase);
                     Ok(term)
                 }
@@ -672,7 +670,7 @@ impl QueryParser {
             }
             UserInputAst::Boost(ast, boost) => {
                 let (ast, errors) = self.compute_logical_ast_with_occur_lenient(*ast);
-                (ast.boost(boost.into_inner() as Score), errors)
+                (ast.boost(boost as Score), errors)
             }
             UserInputAst::Leaf(leaf) => {
                 let (ast, errors) = self.compute_logical_ast_from_leaf_lenient(*leaf);
@@ -862,51 +860,6 @@ impl QueryParser {
                     "Range query need to target a specific field.".to_string(),
                 )],
             ),
-            UserInputLeaf::Regex { field, pattern } => {
-                if !self.regexes_allowed {
-                    return (
-                        None,
-                        vec![QueryParserError::UnsupportedQuery(
-                            "Regex queries are not allowed.".to_string(),
-                        )],
-                    );
-                }
-                let full_path = try_tuple!(field.ok_or_else(|| {
-                    QueryParserError::UnsupportedQuery(
-                        "Regex query need to target a specific field.".to_string(),
-                    )
-                }));
-                let (field, json_path) = try_tuple!(self
-                    .split_full_path(&full_path)
-                    .ok_or_else(|| QueryParserError::FieldDoesNotExist(full_path.clone())));
-                if !json_path.is_empty() {
-                    return (
-                        None,
-                        vec![QueryParserError::UnsupportedQuery(
-                            "Regex query does not support json paths.".to_string(),
-                        )],
-                    );
-                }
-                if !matches!(
-                    self.schema.get_field_entry(field).field_type(),
-                    FieldType::Str(_)
-                ) {
-                    return (
-                        None,
-                        vec![QueryParserError::UnsupportedQuery(
-                            "Regex query only supported on text fields".to_string(),
-                        )],
-                    );
-                }
-                let pattern = try_tuple!(Regex::new(&pattern).map_err(|e| {
-                    QueryParserError::UnsupportedQuery(format!("Invalid regex: {e}"))
-                }));
-                let logical_ast = LogicalAst::Leaf(Box::new(LogicalLiteral::Regex {
-                    pattern: Arc::new(pattern),
-                    field,
-                }));
-                (Some(logical_ast), Vec::new())
-            }
         }
     }
 }
@@ -949,9 +902,6 @@ fn convert_literal_to_query(
         LogicalLiteral::Range { lower, upper } => Box::new(RangeQuery::new(lower, upper)),
         LogicalLiteral::Set { elements, .. } => Box::new(TermSetQuery::new(elements)),
         LogicalLiteral::All => Box::new(AllQuery),
-        LogicalLiteral::Regex { pattern, field } => {
-            Box::new(RegexQuery::from_regex(pattern, field))
-        }
     }
 }
 
@@ -1021,7 +971,7 @@ fn generate_literals_for_json_object(
 
     // Try to convert the phrase to a fast value
     if let Some(term) =
-        convert_to_fast_value_and_append_to_json_term(&get_term_with_path(), phrase, true)
+        convert_to_fast_value_and_append_to_json_term(get_term_with_path(), phrase, true)
     {
         logical_literals.push(LogicalLiteral::Term(term));
     }
@@ -1150,15 +1100,11 @@ mod test {
         query: &str,
         default_conjunction: bool,
         default_fields: &[&'static str],
-        allow_regexes: bool,
     ) -> Result<LogicalAst, QueryParserError> {
         let mut query_parser = make_query_parser_with_default_fields(default_fields);
         if default_conjunction {
             query_parser.set_conjunction_by_default();
         }
-        if allow_regexes {
-            query_parser.allow_regexes();
-        }
         query_parser.parse_query_to_logical_ast(query)
     }
 
@@ -1170,7 +1116,6 @@ mod test {
             query,
             default_conjunction,
             &["title", "text"],
-            true,
         )
     }
 
@@ -1185,7 +1130,6 @@ mod test {
             query,
             default_conjunction,
             default_fields,
-            true,
         )
         .unwrap();
         let query_str = format!("{query:?}");
@@ -2049,66 +1993,4 @@ mod test {
             Err(QueryParserError::ExpectedInt(_))
         );
     }
-
-    #[test]
-    pub fn test_deduplication() {
-        let query = "be be";
-        test_parse_query_to_logical_ast_helper(
-            query,
-            "(Term(field=0, type=Str, \"be\") Term(field=1, type=Str, \"be\"))",
-            false,
-        );
-    }
-
-    #[test]
-    pub fn test_regex() {
-        let expected_regex = tantivy_fst::Regex::new(r".*b").unwrap();
-        test_parse_query_to_logical_ast_helper(
-            "title:/.*b/",
-            format!("Regex(Field(0), {:#?})", expected_regex).as_str(),
-            false,
-        );
-
-        // Invalid field
-        let err = parse_query_to_logical_ast("float:/.*b/", false).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Unsupported query: Regex query only supported on text fields"
-        );
-
-        // No field specified
-        let err = parse_query_to_logical_ast("/.*b/", false).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Unsupported query: Regex query need to target a specific field."
-        );
-
-        // Regex on a json path
-        let err = parse_query_to_logical_ast("title.subpath:/.*b/", false).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Unsupported query: Regex query does not support json paths."
-        );
-
-        // Invalid regex
-        let err = parse_query_to_logical_ast("title:/[A-Z*b/", false).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Unsupported query: Invalid regex: regex parse error:\n    [A-Z*b\n    ^\nerror: \
-             unclosed character class"
-        );
-
-        // Regexes not allowed
-        let err = parse_query_to_logical_ast_with_default_fields(
-            "title:/.*b/",
-            false,
-            &["title", "text"],
-            false,
-        )
-        .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Unsupported query: Regex queries are not allowed."
-        );
-    }
 }

src/query/range_query/fast_field_range_doc_set.rs

@@ -176,14 +176,6 @@ impl<T: Send + Sync + PartialOrd + Copy + Debug + 'static> DocSet for RangeDocSe
     fn size_hint(&self) -> u32 {
         self.column.num_docs()
     }
-
-    /// Returns a best-effort hint of the
-    /// cost to drive the docset.
-    fn cost(&self) -> u64 {
-        // Advancing the docset is relatively expensive since it scans the column.
-        // Keep cost relative to a term query driver; use num_docs as baseline.
-        self.column.num_docs() as u64
-    }
 }
 
 #[cfg(test)]

src/query/range_query/mod.rs

@@ -12,14 +12,10 @@ pub use self::range_query_fastfield::*;
 // TODO is this correct?
 pub(crate) fn is_type_valid_for_fastfield_range_query(typ: Type) -> bool {
     match typ {
-        Type::Str
-        | Type::U64
-        | Type::I64
-        | Type::F64
-        | Type::Bool
-        | Type::Date
-        | Type::Json
-        | Type::IpAddr => true,
+        Type::Str | Type::U64 | Type::I64 | Type::F64 | Type::Bool | Type::Date | Type::Json => {
+            true
+        }
+        Type::IpAddr => true,
         Type::Facet | Type::Bytes => false,
     }
 }

src/query/range_query/range_query_fastfield.rs

@@ -258,7 +258,7 @@ fn search_on_json_numerical_field(
 
     let bounds = match typ.numerical_type().unwrap() {
         NumericalType::I64 => {
-            let bounds = bounds.map_bound(|term| term.as_i64().unwrap());
+            let bounds = bounds.map_bound(|term| (term.as_i64().unwrap()));
             match actual_column_type {
                 NumericalType::I64 => bounds.map_bound(|&term| term.to_u64()),
                 NumericalType::U64 => {
@@ -282,7 +282,7 @@ fn search_on_json_numerical_field(
             }
         }
         NumericalType::U64 => {
-            let bounds = bounds.map_bound(|term| term.as_u64().unwrap());
+            let bounds = bounds.map_bound(|term| (term.as_u64().unwrap()));
             match actual_column_type {
                 NumericalType::U64 => bounds.map_bound(|&term| term.to_u64()),
                 NumericalType::I64 => {
@@ -306,7 +306,7 @@ fn search_on_json_numerical_field(
             }
         }
         NumericalType::F64 => {
-            let bounds = bounds.map_bound(|term| term.as_f64().unwrap());
+            let bounds = bounds.map_bound(|term| (term.as_f64().unwrap()));
             match actual_column_type {
                 NumericalType::U64 => transform_from_f64_bounds::<u64>(&bounds),
                 NumericalType::I64 => transform_from_f64_bounds::<i64>(&bounds),

src/query/reqopt_scorer.rs

@@ -63,10 +63,6 @@ where
     fn size_hint(&self) -> u32 {
         self.req_scorer.size_hint()
     }
-
-    fn cost(&self) -> u64 {
-        self.req_scorer.cost()
-    }
 }
 
 impl<TReqScorer, TOptScorer, TScoreCombiner> Scorer

src/query/size_hint.rs

@@ -1,141 +0,0 @@
-/// Computes the estimated number of documents in the intersection of multiple docsets
-/// given their sizes.
-///
-/// # Arguments
-/// * `docset_sizes` - An iterator over the sizes of the docsets (number of documents in each set).
-/// * `max_docs` - The maximum number of docs that can hit, usually number of documents in the
-///   segment.
-///
-/// # Returns
-/// The estimated number of documents in the intersection.
-pub fn estimate_intersection<I>(mut docset_sizes: I, max_docs: u32) -> u32
-where I: Iterator<Item = u32> {
-    if max_docs == 0u32 {
-        return 0u32;
-    }
-    // Terms tend to be not really randomly distributed.
-    // This factor is used to adjust the estimate.
-    let mut co_loc_factor: f64 = 1.3;
-
-    let mut intersection_estimate = match docset_sizes.next() {
-        Some(first_size) => first_size as f64,
-        None => return 0, // No docsets provided, so return 0.
-    };
-
-    let mut smallest_docset_size = intersection_estimate;
-    // Assuming random distribution of terms, the probability of a document being in the
-    // intersection
-    for size in docset_sizes {
-        // Diminish the co-location factor for each additional set, or we will overestimate.
-        co_loc_factor = (co_loc_factor - 0.1).max(1.0);
-        intersection_estimate *= (size as f64 / max_docs as f64) * co_loc_factor;
-        smallest_docset_size = smallest_docset_size.min(size as f64);
-    }
-
-    intersection_estimate.round().min(smallest_docset_size) as u32
-}
-
-/// Computes the estimated number of documents in the union of multiple docsets
-/// given their sizes.
-///
-/// # Arguments
-/// * `docset_sizes` - An iterator over the sizes of the docsets (number of documents in each set).
-/// * `max_docs` - The maximum number of docs that can hit, usually number of documents in the
-///   segment.
-///
-/// # Returns
-/// The estimated number of documents in the union.
-pub fn estimate_union<I>(docset_sizes: I, max_docs: u32) -> u32
-where I: Iterator<Item = u32> {
-    // Terms tend to be not really randomly distributed.
-    // This factor is used to adjust the estimate.
-    // Unlike intersection, the co-location reduces the estimate.
-    let co_loc_factor = 0.8;
-
-    // The approach for union is to compute the probability of a document not being in any of the
-    // sets
-    let mut not_in_any_set_prob = 1.0;
-
-    // Assuming random distribution of terms, the probability of a document being in the
-    // union is the complement of the probability of it not being in any of the sets.
-    for size in docset_sizes {
-        let prob_in_set = (size as f64 / max_docs as f64) * co_loc_factor;
-        not_in_any_set_prob *= 1.0 - prob_in_set;
-    }
-
-    let union_estimate = (max_docs as f64 * (1.0 - not_in_any_set_prob)).round();
-
-    union_estimate.min(max_docs as f64) as u32
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_estimate_intersection_small1() {
-        let docset_sizes = &[500, 1000];
-        let n = 10_000;
-        let result = estimate_intersection(docset_sizes.iter().copied(), n);
-        assert_eq!(result, 60);
-    }
-
-    #[test]
-    fn test_estimate_intersection_small2() {
-        let docset_sizes = &[500, 1000, 1500];
-        let n = 10_000;
-        let result = estimate_intersection(docset_sizes.iter().copied(), n);
-        assert_eq!(result, 10);
-    }
-
-    #[test]
-    fn test_estimate_intersection_large_values() {
-        let docset_sizes = &[100_000, 50_000, 30_000];
-        let n = 1_000_000;
-        let result = estimate_intersection(docset_sizes.iter().copied(), n);
-        assert_eq!(result, 198);
-    }
-
-    #[test]
-    fn test_estimate_union_small() {
-        let docset_sizes = &[500, 1000, 1500];
-        let n = 10000;
-        let result = estimate_union(docset_sizes.iter().copied(), n);
-        assert_eq!(result, 2228);
-    }
-
-    #[test]
-    fn test_estimate_union_large_values() {
-        let docset_sizes = &[100000, 50000, 30000];
-        let n = 1000000;
-        let result = estimate_union(docset_sizes.iter().copied(), n);
-        assert_eq!(result, 137997);
-    }
-
-    #[test]
-    fn test_estimate_intersection_large() {
-        let docset_sizes: Vec<_> = (0..10).map(|_| 4_000_000).collect();
-        let n = 5_000_000;
-        let result = estimate_intersection(docset_sizes.iter().copied(), n);
-        // Check that it doesn't overflow and returns a reasonable result
-        assert_eq!(result, 708_670);
-    }
-
-    #[test]
-    fn test_estimate_intersection_overflow_safety() {
-        let docset_sizes: Vec<_> = (0..100).map(|_| 4_000_000).collect();
-        let n = 5_000_000;
-        let result = estimate_intersection(docset_sizes.iter().copied(), n);
-        // Check that it doesn't overflow and returns a reasonable result
-        assert_eq!(result, 0);
-    }
-
-    #[test]
-    fn test_estimate_union_overflow_safety() {
-        let docset_sizes: Vec<_> = (0..100).map(|_| 1_000_000).collect();
-        let n = 20_000_000;
-        let result = estimate_union(docset_sizes.iter().copied(), n);
-        // Check that it doesn't overflow and returns a reasonable result
-        assert_eq!(result, 19_662_594);
-    }
-}

src/query/term_query/mod.rs

@@ -11,7 +11,7 @@ mod tests {
     use crate::docset::DocSet;
     use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
     use crate::query::{EnableScoring, Query, QueryParser, Scorer, TermQuery};
-    use crate::schema::{Field, IndexRecordOption, Schema, FAST, STRING, TEXT};
+    use crate::schema::{Field, IndexRecordOption, Schema, STRING, TEXT};
     use crate::{assert_nearly_equals, DocAddress, Index, IndexWriter, Term, TERMINATED};
 
     #[test]
@@ -212,232 +212,4 @@ mod tests {
         }
         Ok(())
     }
-
-    #[test]
-    fn test_term_query_fallback_to_fastfield() -> crate::Result<()> {
-        use crate::collector::Count;
-        use crate::schema::FAST;
-
-        // Create a FAST-only numeric field (not indexed)
-        let mut schema_builder = Schema::builder();
-        let num_field = schema_builder.add_u64_field("num", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        {
-            let mut index_writer: IndexWriter = index.writer_for_tests()?;
-            index_writer.add_document(doc!(num_field => 10u64))?;
-            index_writer.add_document(doc!(num_field => 20u64))?;
-            index_writer.add_document(doc!(num_field => 10u64))?;
-            index_writer.commit()?;
-        }
-
-        let reader = index.reader()?;
-        let searcher = reader.searcher();
-
-        // TermQuery should fall back to a fastfield range query and match correctly.
-        let tq_10 = TermQuery::new(
-            Term::from_field_u64(num_field, 10u64),
-            IndexRecordOption::Basic,
-        );
-        let tq_20 = TermQuery::new(
-            Term::from_field_u64(num_field, 20u64),
-            IndexRecordOption::Basic,
-        );
-        let tq_30 = TermQuery::new(
-            Term::from_field_u64(num_field, 30u64),
-            IndexRecordOption::Basic,
-        );
-
-        let count_10 = searcher.search(&tq_10, &Count)?;
-        let count_20 = searcher.search(&tq_20, &Count)?;
-        let count_30 = searcher.search(&tq_30, &Count)?;
-
-        assert_eq!(count_10, 2);
-        assert_eq!(count_20, 1);
-        assert_eq!(count_30, 0);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_term_query_fallback_text_fast_only() -> crate::Result<()> {
-        use crate::collector::Count;
-
-        // FAST-only text field (not indexed)
-        let mut schema_builder = Schema::builder();
-        let text_field = schema_builder.add_text_field("text", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        {
-            let mut index_writer: IndexWriter = index.writer_for_tests()?;
-            index_writer.add_document(doc!(text_field => "hello"))?;
-            index_writer.add_document(doc!(text_field => "world"))?;
-            index_writer.add_document(doc!(text_field => "hello"))?;
-            index_writer.commit()?;
-        }
-
-        let searcher = index.reader()?.searcher();
-        let tq_hello = TermQuery::new(
-            Term::from_field_text(text_field, "hello"),
-            IndexRecordOption::Basic,
-        );
-        let tq_world = TermQuery::new(
-            Term::from_field_text(text_field, "world"),
-            IndexRecordOption::Basic,
-        );
-        let tq_missing = TermQuery::new(
-            Term::from_field_text(text_field, "nope"),
-            IndexRecordOption::Basic,
-        );
-
-        assert_eq!(searcher.search(&tq_hello, &Count)?, 2);
-        assert_eq!(searcher.search(&tq_world, &Count)?, 1);
-        assert_eq!(searcher.search(&tq_missing, &Count)?, 0);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_term_query_fallback_json_fast_only() -> crate::Result<()> {
-        use crate::collector::Count;
-        use crate::fastfield::FastValue;
-        use crate::schema::FAST;
-
-        let mut schema_builder = Schema::builder();
-        let json_field = schema_builder.add_json_field("json", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema.clone());
-
-        {
-            let mut index_writer: IndexWriter = index.writer_for_tests()?;
-            index_writer.add_document(doc!(json_field => json!({"a": 10, "b": "x"})))?;
-            index_writer.add_document(doc!(json_field => json!({"a": 20, "b": "y"})))?;
-            index_writer.add_document(doc!(json_field => json!({"a": 10, "b": "z"})))?;
-            index_writer.commit()?;
-        }
-
-        fn json_term_fast<T: FastValue>(field: Field, path: &str, v: T) -> Term {
-            let mut term = Term::from_field_json_path(field, path, true);
-            term.append_type_and_fast_value(v);
-            term
-        }
-        fn json_term_str(field: Field, path: &str, v: &str) -> Term {
-            let mut term = Term::from_field_json_path(field, path, true);
-            term.append_type_and_str(v);
-            term
-        }
-
-        let searcher = index.reader()?.searcher();
-        // numeric path match
-        let tq_a10 = TermQuery::new(
-            json_term_fast(json_field, "a", 10u64),
-            IndexRecordOption::Basic,
-        );
-        let tq_a20 = TermQuery::new(
-            json_term_fast(json_field, "a", 20u64),
-            IndexRecordOption::Basic,
-        );
-        let tq_a30 = TermQuery::new(
-            json_term_fast(json_field, "a", 30u64),
-            IndexRecordOption::Basic,
-        );
-        assert_eq!(searcher.search(&tq_a10, &Count)?, 2);
-        assert_eq!(searcher.search(&tq_a20, &Count)?, 1);
-        assert_eq!(searcher.search(&tq_a30, &Count)?, 0);
-
-        // string path match
-        let tq_bx = TermQuery::new(
-            json_term_str(json_field, "b", "x"),
-            IndexRecordOption::Basic,
-        );
-        let tq_by = TermQuery::new(
-            json_term_str(json_field, "b", "y"),
-            IndexRecordOption::Basic,
-        );
-        let tq_bm = TermQuery::new(
-            json_term_str(json_field, "b", "missing"),
-            IndexRecordOption::Basic,
-        );
-        assert_eq!(searcher.search(&tq_bx, &Count)?, 1);
-        assert_eq!(searcher.search(&tq_by, &Count)?, 1);
-        assert_eq!(searcher.search(&tq_bm, &Count)?, 0);
-        Ok(())
-    }
-
-    #[test]
-    fn test_term_query_fallback_ip_fast_only() -> crate::Result<()> {
-        use std::net::IpAddr;
-        use std::str::FromStr;
-
-        use crate::collector::Count;
-        use crate::schema::{IntoIpv6Addr, FAST};
-
-        let mut schema_builder = Schema::builder();
-        let ip_field = schema_builder.add_ip_addr_field("ip", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        let ip1 = IpAddr::from_str("127.0.0.1").unwrap().into_ipv6_addr();
-        let ip2 = IpAddr::from_str("127.0.0.2").unwrap().into_ipv6_addr();
-        {
-            let mut index_writer: IndexWriter = index.writer_for_tests()?;
-            index_writer.add_document(doc!(ip_field => ip1))?;
-            index_writer.add_document(doc!(ip_field => ip2))?;
-            index_writer.add_document(doc!(ip_field => ip1))?;
-            index_writer.commit()?;
-        }
-
-        let searcher = index.reader()?.searcher();
-        let tq_ip1 = TermQuery::new(
-            Term::from_field_ip_addr(ip_field, ip1),
-            IndexRecordOption::Basic,
-        );
-        let tq_ip2 = TermQuery::new(
-            Term::from_field_ip_addr(ip_field, ip2),
-            IndexRecordOption::Basic,
-        );
-        let ip3 = IpAddr::from_str("127.0.0.3").unwrap().into_ipv6_addr();
-        let tq_ip3 = TermQuery::new(
-            Term::from_field_ip_addr(ip_field, ip3),
-            IndexRecordOption::Basic,
-        );
-
-        assert_eq!(searcher.search(&tq_ip1, &Count)?, 2);
-        assert_eq!(searcher.search(&tq_ip2, &Count)?, 1);
-        assert_eq!(searcher.search(&tq_ip3, &Count)?, 0);
-        Ok(())
-    }
-
-    #[test]
-    fn test_term_query_fallback_fastfield_with_scores_errors() -> crate::Result<()> {
-        use crate::collector::TopDocs;
-
-        // FAST-only numeric field (not indexed) should error when scoring is required
-        let mut schema_builder = Schema::builder();
-        let num_field = schema_builder.add_u64_field("num", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        {
-            let mut index_writer: IndexWriter = index.writer_for_tests()?;
-            index_writer.add_document(doc!(num_field => 10u64))?;
-            index_writer.add_document(doc!(num_field => 20u64))?;
-            index_writer.commit()?;
-        }
-
-        let searcher = index.reader()?.searcher();
-        let tq = TermQuery::new(
-            Term::from_field_u64(num_field, 10u64),
-            IndexRecordOption::Basic,
-        );
-
-        // Using TopDocs requires scoring; since the field is not indexed,
-        // TermQuery cannot score and should return a SchemaError.
-        let res = searcher.search(&tq, &TopDocs::with_limit(1));
-        assert!(matches!(res, Err(crate::TantivyError::SchemaError(_))));
-
-        Ok(())
-    }
 }

src/query/term_query/term_query.rs

@@ -1,10 +1,8 @@
 use std::fmt;
-use std::ops::Bound;
 
 use super::term_weight::TermWeight;
 use crate::query::bm25::Bm25Weight;
-use crate::query::range_query::is_type_valid_for_fastfield_range_query;
-use crate::query::{EnableScoring, Explanation, Query, RangeQuery, Weight};
+use crate::query::{EnableScoring, Explanation, Query, Weight};
 use crate::schema::IndexRecordOption;
 use crate::Term;
 
@@ -124,24 +122,6 @@ impl TermQuery {
 
 impl Query for TermQuery {
     fn weight(&self, enable_scoring: EnableScoring<'_>) -> crate::Result<Box<dyn Weight>> {
-        // If the field is not indexed but is a suitable fast field, fall back to a range query
-        // on the fast field matching exactly this term.
-        //
-        // Note: This is considerable slower since it requires to scan the entire fast field.
-        // TODO: The range query would gain from having a single-value optimization
-        let schema = enable_scoring.schema();
-        let field_entry = schema.get_field_entry(self.term.field());
-        if !field_entry.is_indexed()
-            && field_entry.is_fast()
-            && is_type_valid_for_fastfield_range_query(self.term.typ())
-            && !enable_scoring.is_scoring_enabled()
-        {
-            let range_query = RangeQuery::new(
-                Bound::Included(self.term.clone()),
-                Bound::Included(self.term.clone()),
-            );
-            return range_query.weight(enable_scoring);
-        }
         Ok(Box::new(self.specialized_weight(enable_scoring)?))
     }
     fn query_terms<'a>(&'a self, visitor: &mut dyn FnMut(&'a Term, bool)) {

src/query/term_query/term_scorer.rs

@@ -25,8 +25,8 @@ impl TermScorer {
         }
     }
 
-    pub(crate) fn seek_block(&mut self, target_doc: DocId) {
-        self.postings.block_cursor.seek_block(target_doc);
+    pub(crate) fn shallow_seek(&mut self, target_doc: DocId) {
+        self.postings.block_cursor.shallow_seek(target_doc);
     }
 
     #[cfg(test)]
@@ -175,7 +175,7 @@ mod tests {
         let fieldnorms: Vec<u32> = std::iter::repeat_n(10u32, 3_000).collect();
         let mut term_scorer = TermScorer::create_for_test(&doc_and_tfs, &fieldnorms, bm25_weight);
         assert_eq!(term_scorer.doc(), 0u32);
-        term_scorer.seek_block(1289);
+        term_scorer.shallow_seek(1289);
         assert_eq!(term_scorer.doc(), 0u32);
         term_scorer.seek(1289);
         assert_eq!(term_scorer.doc(), 1290);
@@ -242,9 +242,9 @@ mod tests {
         let bm25_weight = Bm25Weight::for_one_term(10, 129, 20.0);
         let mut docs = TermScorer::create_for_test(&doc_tfs[..], &fieldnorms[..], bm25_weight);
         assert_nearly_equals!(docs.block_max_score(), 2.5161593);
-        docs.seek_block(135);
+        docs.shallow_seek(135);
         assert_nearly_equals!(docs.block_max_score(), 3.4597192);
-        docs.seek_block(256);
+        docs.shallow_seek(256);
         // the block is not loaded yet.
         assert_nearly_equals!(docs.block_max_score(), 5.2971773);
         assert_eq!(256, docs.seek(256));
@@ -275,7 +275,7 @@ mod tests {
             {
                 let mut term_scorer = term_weight.specialized_scorer(reader, 1.0)?;
                 for d in docs {
-                    term_scorer.seek_block(d);
+                    term_scorer.shallow_seek(d);
                     block_max_scores_b.push(term_scorer.block_max_score());
                 }
             }

src/query/union/buffered_union.rs

@@ -2,14 +2,11 @@ use common::TinySet;
 
 use crate::docset::{DocSet, TERMINATED};
 use crate::query::score_combiner::{DoNothingCombiner, ScoreCombiner};
-use crate::query::size_hint::estimate_union;
 use crate::query::Scorer;
 use crate::{DocId, Score};
 
-// The buffered union looks ahead within a fixed-size sliding window
-// of upcoming document IDs (the "horizon").
-const HORIZON_NUM_TINYBITSETS: usize = HORIZON as usize / 64;
-const HORIZON: u32 = 64u32 * 64u32;
+const HORIZON_NUM_TINYBITSETS: usize = 64;
+const HORIZON: u32 = 64u32 * HORIZON_NUM_TINYBITSETS as u32;
 
 // `drain_filter` is not stable yet.
 // This function is similar except that it does is not unstable, and
@@ -30,29 +27,13 @@ where P: FnMut(&mut T) -> bool {
 
 /// Creates a `DocSet` that iterate through the union of two or more `DocSet`s.
 pub struct BufferedUnionScorer<TScorer, TScoreCombiner = DoNothingCombiner> {
-    /// Active scorers (already filtered of `TERMINATED`).
     docsets: Vec<TScorer>,
-    /// Sliding window presence map for upcoming docs.
-    ///
-    /// There are `HORIZON_NUM_TINYBITSETS` buckets, each covering
-    /// a span of 64 doc IDs. Bucket `i` represents the range
-    /// `[window_start_doc + i*64, window_start_doc + (i+1)*64)`.
     bitsets: Box<[TinySet; HORIZON_NUM_TINYBITSETS]>,
-    // Index of the current TinySet bucket within the sliding window.
-    bucket_idx: usize,
-    /// Per-doc score combiners for the current window.
-    ///
-    /// these accumulators merge contributions from all scorers that
-    /// hit the same doc within the buffered window.
     scores: Box<[TScoreCombiner; HORIZON as usize]>,
-    /// Start doc ID (inclusive) of the current sliding window.
-    window_start_doc: DocId,
-    /// Current doc ID of the union.
+    cursor: usize,
+    offset: DocId,
     doc: DocId,
-    /// Combined score for current `doc` as produced by `TScoreCombiner`.
     score: Score,
-    /// Number of documents in the segment.
-    num_docs: u32,
 }
 
 fn refill<TScorer: Scorer, TScoreCombiner: ScoreCombiner>(
@@ -81,11 +62,9 @@ fn refill<TScorer: Scorer, TScoreCombiner: ScoreCombiner>(
 }
 
 impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> BufferedUnionScorer<TScorer, TScoreCombiner> {
-    /// num_docs is the number of documents in the segment.
     pub(crate) fn build(
         docsets: Vec<TScorer>,
         score_combiner_fn: impl FnOnce() -> TScoreCombiner,
-        num_docs: u32,
     ) -> BufferedUnionScorer<TScorer, TScoreCombiner> {
         let non_empty_docsets: Vec<TScorer> = docsets
             .into_iter()
@@ -95,11 +74,10 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> BufferedUnionScorer<TScorer
             docsets: non_empty_docsets,
             bitsets: Box::new([TinySet::empty(); HORIZON_NUM_TINYBITSETS]),
             scores: Box::new([score_combiner_fn(); HORIZON as usize]),
-            bucket_idx: HORIZON_NUM_TINYBITSETS,
-            window_start_doc: 0,
+            cursor: HORIZON_NUM_TINYBITSETS,
+            offset: 0,
             doc: 0,
             score: 0.0,
-            num_docs,
         };
         if union.refill() {
             union.advance();
@@ -111,10 +89,8 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> BufferedUnionScorer<TScorer
 
     fn refill(&mut self) -> bool {
         if let Some(min_doc) = self.docsets.iter().map(DocSet::doc).min() {
-            // Reset the sliding window to start at the smallest doc
-            // across all scorers and prebuffer within the horizon.
-            self.window_start_doc = min_doc;
-            self.bucket_idx = 0;
+            self.offset = min_doc;
+            self.cursor = 0;
             self.doc = min_doc;
             refill(
                 &mut self.docsets,
@@ -129,16 +105,16 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> BufferedUnionScorer<TScorer
     }
 
     fn advance_buffered(&mut self) -> bool {
-        while self.bucket_idx < HORIZON_NUM_TINYBITSETS {
-            if let Some(val) = self.bitsets[self.bucket_idx].pop_lowest() {
-                let delta = val + (self.bucket_idx as u32) * 64;
-                self.doc = self.window_start_doc + delta;
+        while self.cursor < HORIZON_NUM_TINYBITSETS {
+            if let Some(val) = self.bitsets[self.cursor].pop_lowest() {
+                let delta = val + (self.cursor as u32) * 64;
+                self.doc = self.offset + delta;
                 let score_combiner = &mut self.scores[delta as usize];
                 self.score = score_combiner.score();
                 score_combiner.clear();
                 return true;
             } else {
-                self.bucket_idx += 1;
+                self.cursor += 1;
             }
         }
         false
@@ -168,19 +144,19 @@ where
         if self.doc >= target {
             return self.doc;
         }
-        let gap = target - self.window_start_doc;
+        let gap = target - self.offset;
         if gap < HORIZON {
             // Our value is within the buffered horizon.
 
-            // Skipping to corresponding bucket.
-            let new_bucket_idx = gap as usize / 64;
-            for obsolete_tinyset in &mut self.bitsets[self.bucket_idx..new_bucket_idx] {
+            // Skipping to  corresponding bucket.
+            let new_cursor = gap as usize / 64;
+            for obsolete_tinyset in &mut self.bitsets[self.cursor..new_cursor] {
                 obsolete_tinyset.clear();
             }
-            for score_combiner in &mut self.scores[self.bucket_idx * 64..new_bucket_idx * 64] {
+            for score_combiner in &mut self.scores[self.cursor * 64..new_cursor * 64] {
                 score_combiner.clear();
             }
-            self.bucket_idx = new_bucket_idx;
+            self.cursor = new_cursor;
 
             // Advancing until we reach the end of the bucket
             // or we reach a doc greater or equal to the target.
@@ -224,18 +200,18 @@ where
     }
 
     fn size_hint(&self) -> u32 {
-        estimate_union(self.docsets.iter().map(DocSet::size_hint), self.num_docs)
-    }
-
-    fn cost(&self) -> u64 {
-        self.docsets.iter().map(|docset| docset.cost()).sum()
+        self.docsets
+            .iter()
+            .map(|docset| docset.size_hint())
+            .max()
+            .unwrap_or(0u32)
     }
 
     fn count_including_deleted(&mut self) -> u32 {
         if self.doc == TERMINATED {
             return 0;
         }
-        let mut count = self.bitsets[self.bucket_idx..HORIZON_NUM_TINYBITSETS]
+        let mut count = self.bitsets[self.cursor..HORIZON_NUM_TINYBITSETS]
             .iter()
             .map(|bitset| bitset.len())
             .sum::<u32>()
@@ -249,7 +225,7 @@ where
                 bitset.clear();
             }
         }
-        self.bucket_idx = HORIZON_NUM_TINYBITSETS;
+        self.cursor = HORIZON_NUM_TINYBITSETS;
         count
     }
 }

src/query/union/mod.rs

@@ -27,17 +27,11 @@ mod tests {
         docs_list.iter().cloned().map(VecDocSet::from)
     }
     fn union_from_docs_list(docs_list: &[Vec<DocId>]) -> Box<dyn DocSet> {
-        let max_doc = docs_list
-            .iter()
-            .flat_map(|docs| docs.iter().copied())
-            .max()
-            .unwrap_or(0);
         Box::new(BufferedUnionScorer::build(
             vec_doc_set_from_docs_list(docs_list)
                 .map(|docset| ConstScorer::new(docset, 1.0))
                 .collect::<Vec<ConstScorer<VecDocSet>>>(),
             DoNothingCombiner::default,
-            max_doc,
         ))
     }
 
@@ -279,7 +273,6 @@ mod bench {
                     .map(|docset| ConstScorer::new(docset, 1.0))
                     .collect::<Vec<_>>(),
                 DoNothingCombiner::default,
-                100_000,
             );
             while v.doc() != TERMINATED {
                 v.advance();
@@ -301,7 +294,6 @@ mod bench {
                     .map(|docset| ConstScorer::new(docset, 1.0))
                     .collect::<Vec<_>>(),
                 DoNothingCombiner::default,
-                100_000,
             );
             while v.doc() != TERMINATED {
                 v.advance();

src/query/union/simple_union.rs

@@ -99,10 +99,6 @@ impl<TDocSet: DocSet> DocSet for SimpleUnion<TDocSet> {
             .unwrap_or(0u32)
     }
 
-    fn cost(&self) -> u64 {
-        self.docsets.iter().map(|docset| docset.cost()).sum()
-    }
-
     fn count_including_deleted(&mut self) -> u32 {
         if self.doc == TERMINATED {
             return 0u32;

src/schema/document/mod.rs

@@ -80,7 +80,6 @@
 //! }
 //!
 //! /// Our custom iterator just helps us to avoid some messy generics.
-//! #[allow(dead_code)]
 //! pub struct MyCustomIter<'a>(btree_map::Iter<'a, Field, serde_json::Value>);
 //! impl<'a> Iterator for MyCustomIter<'a> {
 //!     // Here we can see our field-value pairs being produced by the iterator.

src/termdict/fst_termdict/term_info_store.rs

@@ -342,7 +342,7 @@ mod tests {
     fn test_pack() -> crate::Result<()> {
         let mut store_writer = TermInfoStoreWriter::new();
         let mut term_infos = vec![];
-        let offset = |i| i * 13 + i * i;
+        let offset = |i| (i * 13 + i * i);
         for i in 0usize..1000usize {
             let term_info = TermInfo {
                 doc_freq: i as u32,

src/tokenizer/ascii_folding_filter.rs

@@ -1561,6 +1561,7 @@ fn to_ascii(text: &str, output: &mut String) {
 
 #[cfg(test)]
 mod tests {
+    use std::iter;
 
     use super::to_ascii;
     use crate::tokenizer::{AsciiFoldingFilter, RawTokenizer, SimpleTokenizer, TextAnalyzer};

sstable/src/dictionary.rs

@@ -308,9 +308,10 @@ impl<TSSTable: SSTable> Dictionary<TSSTable> {
                 }
             }
             _ => {
-                return Err(io::Error::other(format!(
-                    "Unsupported sstable version, expected one of [2, 3], found {version}"
-                )));
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("Unsupported sstable version, expected one of [2, 3], found {version}"),
+                ));
             }
         };
 
@@ -608,12 +609,12 @@ impl<TSSTable: SSTable> Dictionary<TSSTable> {
 
     /// Returns a range builder, to stream all of the terms
     /// within an interval.
-    pub fn range(&self) -> StreamerBuilder<'_, TSSTable> {
+    pub fn range(&self) -> StreamerBuilder<TSSTable> {
         StreamerBuilder::new(self, AlwaysMatch)
     }
 
     /// Returns a range builder filtered with a prefix.
-    pub fn prefix_range<K: AsRef<[u8]>>(&self, prefix: K) -> StreamerBuilder<'_, TSSTable> {
+    pub fn prefix_range<K: AsRef<[u8]>>(&self, prefix: K) -> StreamerBuilder<TSSTable> {
         let lower_bound = prefix.as_ref();
         let mut upper_bound = lower_bound.to_vec();
         for idx in (0..upper_bound.len()).rev() {
@@ -632,7 +633,7 @@ impl<TSSTable: SSTable> Dictionary<TSSTable> {
     }
 
     /// A stream of all the sorted terms.
-    pub fn stream(&self) -> io::Result<Streamer<'_, TSSTable>> {
+    pub fn stream(&self) -> io::Result<Streamer<TSSTable>> {
         self.range().into_stream()
     }
 

sstable/src/merge/heap_merge.rs

@@ -54,14 +54,14 @@ pub fn merge_sstable<SST: SSTable, W: io::Write, M: ValueMerger<SST::Value>>(
             }
         }
         for _ in 0..len - 1 {
-            if let Some(mut head) = heap.peek_mut()
-                && head.0.key() == writer.last_inserted_key()
-            {
-                value_merger.add(head.0.value());
-                if !head.0.advance()? {
-                    PeekMut::pop(head);
+            if let Some(mut head) = heap.peek_mut() {
+                if head.0.key() == writer.last_inserted_key() {
+                    value_merger.add(head.0.value());
+                    if !head.0.advance()? {
+                        PeekMut::pop(head);
+                    }
+                    continue;
                 }
-                continue;
             }
             break;
         }

sstable/src/sstable_index_v3.rs

@@ -394,7 +394,7 @@ impl SSTableIndexBuilder {
 
 fn fst_error_to_io_error(error: tantivy_fst::Error) -> io::Error {
     match error {
-        tantivy_fst::Error::Fst(fst_error) => io::Error::other(fst_error),
+        tantivy_fst::Error::Fst(fst_error) => io::Error::new(io::ErrorKind::Other, fst_error),
         tantivy_fst::Error::Io(ioerror) => ioerror,
     }
 }
@@ -438,7 +438,7 @@ impl BlockAddrBlockMetadata {
         let ordinal_addr = range_start_addr + self.range_start_nbits as usize;
         let range_end_addr = range_start_addr + num_bits;
 
-        if (range_end_addr + self.range_start_nbits as usize).div_ceil(8) > data.len() {
+        if (range_end_addr + self.range_start_nbits as usize + 7) / 8 > data.len() {
             return None;
         }
 

stacker/src/shared_arena_hashmap.rs

@@ -274,12 +274,13 @@ impl SharedArenaHashMap {
             let kv: KeyValue = self.table[bucket];
             if kv.is_empty() {
                 return None;
-            } else if kv.hash == hash
-                && let Some(val_addr) =
+            } else if kv.hash == hash {
+                if let Some(val_addr) =
                     self.get_value_addr_if_key_match(key, kv.key_value_addr, memory_arena)
-            {
-                let v = memory_arena.read(val_addr);
-                return Some(v);
+                {
+                    let v = memory_arena.read(val_addr);
+                    return Some(v);
+                }
             }
         }
     }
@@ -333,14 +334,15 @@ impl SharedArenaHashMap {
                 self.set_bucket(hash, key_addr, bucket);
                 return val;
             }
-            if kv.hash == hash
-                && let Some(val_addr) =
+            if kv.hash == hash {
+                if let Some(val_addr) =
                     self.get_value_addr_if_key_match(key, kv.key_value_addr, memory_arena)
-            {
-                let v = memory_arena.read(val_addr);
-                let new_v = updater(Some(v));
-                memory_arena.write_at(val_addr, new_v);
-                return new_v;
+                {
+                    let v = memory_arena.read(val_addr);
+                    let new_v = updater(Some(v));
+                    memory_arena.write_at(val_addr, new_v);
+                    return new_v;
+                }
             }
             // This allows fetching the next bucket before the loop jmp
             bucket = probe.next_probe();