Introduced geopoint.

Removed use of robust.

CHANGELOG.md

@@ -78,7 +78,7 @@ This will slightly increase space and access time. [#2439](https://github.com/qu
 
 - **Store DateTime as nanoseconds in doc store** DateTime in the doc store was truncated to microseconds previously. This removes this truncation, while still keeping backwards compatibility. [#2486](https://github.com/quickwit-oss/tantivy/pull/2486)(@PSeitz)
 
-- **Performace/Memory**
+- **Performance/Memory**
     - lift clauses in LogicalAst for optimized ast during execution [#2449](https://github.com/quickwit-oss/tantivy/pull/2449)(@PSeitz)
     - Use Vec instead of BTreeMap to back OwnedValue object [#2364](https://github.com/quickwit-oss/tantivy/pull/2364)(@fulmicoton)
     - Replace TantivyDocument with CompactDoc. CompactDoc is much smaller and provides similar performance. [#2402](https://github.com/quickwit-oss/tantivy/pull/2402)(@PSeitz)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy"
-version = "0.25.0"
+version = "0.26.0"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 license = "MIT"
 categories = ["database-implementations", "data-structures"]
@@ -56,6 +56,7 @@ itertools = "0.14.0"
 measure_time = "0.9.0"
 arc-swap = "1.5.0"
 bon = "3.3.1"
+i_triangle = "0.38.0"
 
 columnar = { version = "0.6", path = "./columnar", package = "tantivy-columnar" }
 sstable = { version = "0.6", path = "./sstable", package = "tantivy-sstable", optional = true }
@@ -70,6 +71,7 @@ futures-util = { version = "0.3.28", optional = true }
 futures-channel = { version = "0.3.28", optional = true }
 fnv = "1.0.7"
 typetag = "0.2.21"
+geo-types = "0.7.17"
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"

TODO.txt

@@ -10,7 +10,7 @@ rename FastFieldReaders::open to load
 remove fast field reader
 
 find a way to unify the two DateTime.
-readd type check in the filter wrapper
+re-add type check in the filter wrapper
 
 add unit test on columnar list columns.
 

benches/agg_bench.rs

@@ -59,6 +59,8 @@ fn bench_agg(mut group: InputGroup<Index>) {
     register!(group, terms_many_order_by_term);
     register!(group, terms_many_with_top_hits);
     register!(group, terms_many_with_avg_sub_agg);
+    register!(group, terms_few_with_avg_sub_agg);
+
     register!(group, terms_many_json_mixed_type_with_avg_sub_agg);
 
     register!(group, cardinality_agg);
@@ -220,6 +222,19 @@ fn terms_many_with_avg_sub_agg(index: &Index) {
     });
     execute_agg(index, agg_req);
 }
+
+fn terms_few_with_avg_sub_agg(index: &Index) {
+    let agg_req = json!({
+        "my_texts": {
+            "terms": { "field": "text_few_terms" },
+            "aggs": {
+                "average_f64": { "avg": { "field": "score_f64" } }
+            }
+        },
+    });
+    execute_agg(index, agg_req);
+}
+
 fn terms_many_json_mixed_type_with_avg_sub_agg(index: &Index) {
     let agg_req = json!({
         "my_texts": {

benches/and_or_queries.rs

@@ -16,14 +16,15 @@
 // - This bench isolates boolean iteration speed and intersection/union cost.
 // - Use `cargo bench --bench boolean_conjunction` to run.
 
-use binggan::{black_box, BenchRunner};
+use binggan::{black_box, BenchGroup, 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};
+use tantivy::collector::sort_key::SortByStaticFastValue;
+use tantivy::collector::{Collector, Count, TopDocs};
+use tantivy::query::{Query, QueryParser};
+use tantivy::schema::{Schema, FAST, TEXT};
+use tantivy::{doc, Index, Order, ReloadPolicy, Searcher};
 
 #[derive(Clone)]
 struct BenchIndex {
@@ -33,23 +34,6 @@ struct BenchIndex {
     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"
@@ -59,6 +43,8 @@ fn build_shared_indices(num_docs: usize, p_a: f32, p_b: f32, p_c: f32) -> (Bench
     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 f_score = schema_builder.add_u64_field("score", FAST);
+    let f_score2 = schema_builder.add_u64_field("score2", FAST);
     let schema = schema_builder.build();
     let index = Index::create_in_ram(schema.clone());
 
@@ -67,11 +53,13 @@ fn build_shared_indices(num_docs: usize, p_a: f32, p_b: f32, p_c: f32) -> (Bench
 
     // Populate: spread each present token 90/10 to body/title
     {
-        let mut writer = index.writer(500_000_000).unwrap();
+        let mut writer = index.writer_with_num_threads(1, 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 score = rng.gen_range(0u64..100u64);
+            let score2 = rng.gen_range(0u64..100_000u64);
             let mut title_tokens: Vec<&str> = Vec::new();
             let mut body_tokens: Vec<&str> = Vec::new();
             if has_a {
@@ -101,7 +89,9 @@ fn build_shared_indices(num_docs: usize, p_a: f32, p_b: f32, p_c: f32) -> (Bench
             writer
                 .add_document(doc!(
                     f_title=>title_tokens.join(" "),
-                    f_body=>body_tokens.join(" ")
+                    f_body=>body_tokens.join(" "),
+                    f_score=>score,
+                    f_score2=>score2,
                 ))
                 .unwrap();
         }
@@ -153,72 +143,76 @@ fn main() {
         ),
     ];
 
+    let queries = &["a", "+a +b", "+a +b +c", "a OR b", "a OR b OR c"];
+
     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
+        for (view_name, bench_index) in [("single_field", single_view), ("multi_field", multi_view)]
         {
+            // Single-field group: default field is body only
             let mut group = runner.new_group();
-            group.set_name(format!("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.set_name(format!("{} — {}", view_name, label));
+            for query_str in queries {
+                add_bench_task(&mut group, &bench_index, query_str, Count, "count");
+                add_bench_task(
+                    &mut group,
+                    &bench_index,
+                    query_str,
+                    TopDocs::with_limit(10).order_by_score(),
+                    "top10",
+                );
+                add_bench_task(
+                    &mut group,
+                    &bench_index,
+                    query_str,
+                    TopDocs::with_limit(10).order_by_fast_field::<u64>("score", Order::Asc),
+                    "top10_by_ff",
+                );
+                add_bench_task(
+                    &mut group,
+                    &bench_index,
+                    query_str,
+                    TopDocs::with_limit(10).order_by((
+                        SortByStaticFastValue::<u64>::for_field("score"),
+                        SortByStaticFastValue::<u64>::for_field("score2"),
+                    )),
+                    "top10_by_2ff",
+                );
+            }
             group.run();
         }
     }
 }
+
+fn add_bench_task<C: Collector + 'static>(
+    bench_group: &mut BenchGroup,
+    bench_index: &BenchIndex,
+    query_str: &str,
+    collector: C,
+    collector_name: &str,
+) {
+    let task_name = format!("{}_{}", query_str.replace(" ", "_"), collector_name);
+    let query = bench_index.query_parser.parse_query(query_str).unwrap();
+    let search_task = SearchTask {
+        searcher: bench_index.searcher.clone(),
+        collector,
+        query,
+    };
+    bench_group.register(task_name, move |_| black_box(search_task.run()));
+}
+
+struct SearchTask<C: Collector> {
+    searcher: Searcher,
+    collector: C,
+    query: Box<dyn Query>,
+}
+
+impl<C: Collector> SearchTask<C> {
+    #[inline(never)]
+    pub fn run(&self) -> usize {
+        self.searcher.search(&self.query, &self.collector).unwrap();
+        1
+    }
+}

bitpacker/src/bitpacker.rs

@@ -258,7 +258,7 @@ mod test {
             bitpacker.write(val, num_bits, &mut data).unwrap();
         }
         bitpacker.close(&mut data).unwrap();
-        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8);
+        assert_eq!(data.len(), ((num_bits as usize) * len).div_ceil(8));
         let bitunpacker = BitUnpacker::new(num_bits);
         (bitunpacker, vals, data)
     }
@@ -304,7 +304,7 @@ mod test {
             bitpacker.write(val, num_bits, &mut buffer).unwrap();
         }
         bitpacker.flush(&mut buffer).unwrap();
-        assert_eq!(buffer.len(), (vals.len() * num_bits as usize + 7) / 8);
+        assert_eq!(buffer.len(), (vals.len() * num_bits as usize).div_ceil(8));
         let bitunpacker = BitUnpacker::new(num_bits);
         let max_val = if num_bits == 64 {
             u64::MAX

columnar/README.md

@@ -73,7 +73,7 @@ The crate introduces the following concepts.
 `Columnar` is an equivalent of a dataframe.
 It maps `column_key` to `Column`.
 
-A `Column<T>` asssociates a `RowId` (u32) to any
+A `Column<T>` associates a `RowId` (u32) to any
 number of values.
 
 This is made possible by wrapping a `ColumnIndex` and a `ColumnValue` object.

columnar/benches/bench_first_vals.rs

@@ -89,13 +89,6 @@ fn main() {
         black_box(sum);
     });
 
-    group.register("first_block_fetch", |column| {
-        let mut block: Vec<Option<u64>> = vec![None; 64];
-        let fetch_docids = (0..64).collect::<Vec<_>>();
-        column.first_vals(&fetch_docids, &mut block);
-        black_box(block[0]);
-    });
-
     group.register("first_block_single_calls", |column| {
         let mut block: Vec<Option<u64>> = vec![None; 64];
         let fetch_docids = (0..64).collect::<Vec<_>>();

columnar/src/column/mod.rs

@@ -131,6 +131,8 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
         self.index.docids_to_rowids(doc_ids, doc_ids_out, row_ids)
     }
 
+    /// Get an iterator over the values for the provided docid.
+    #[inline]
     pub fn values_for_doc(&self, doc_id: DocId) -> impl Iterator<Item = T> + '_ {
         self.index
             .value_row_ids(doc_id)
@@ -158,15 +160,6 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
             .select_batch_in_place(selected_docid_range.start, doc_ids);
     }
 
-    /// Fills the output vector with the (possibly multiple values that are associated_with
-    /// `row_id`.
-    ///
-    /// This method clears the `output` vector.
-    pub fn fill_vals(&self, row_id: RowId, output: &mut Vec<T>) {
-        output.clear();
-        output.extend(self.values_for_doc(row_id));
-    }
-
     pub fn first_or_default_col(self, default_value: T) -> Arc<dyn ColumnValues<T>> {
         Arc::new(FirstValueWithDefault {
             column: self,

columnar/src/column_values/monotonic_mapping_u128.rs

@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 use std::net::Ipv6Addr;
 
-/// Montonic maps a value to u128 value space
+/// Monotonic maps a value to u128 value space
 /// Monotonic mapping enables `PartialOrd` on u128 space without conversion to original space.
 pub trait MonotonicallyMappableToU128: 'static + PartialOrd + Copy + Debug + Send + Sync {
     /// Converts a value to u128.

columnar/src/column_values/u64_based/line.rs

@@ -8,7 +8,7 @@ use crate::column_values::ColumnValues;
 const MID_POINT: u64 = (1u64 << 32) - 1u64;
 
 /// `Line` describes a line function `y: ax + b` using integer
-/// arithmetics.
+/// arithmetic.
 ///
 /// The slope is in fact a decimal split into a 32 bit integer value,
 /// and a 32-bit decimal value.
@@ -94,7 +94,7 @@ impl Line {
         // `(i, ys[])`.
         //
         // The best intercept therefore has the form
-        // `y[i] - line.eval(i)` (using wrapping arithmetics).
+        // `y[i] - line.eval(i)` (using wrapping arithmetic).
         // In other words, the best intercept is one of the `y - Line::eval(ys[i])`
         // and our task is just to pick the one that minimizes our error.
         //

columnar/src/column_values/u64_based/mod.rs

@@ -52,7 +52,7 @@ pub trait ColumnCodecEstimator<T = u64>: 'static {
     ) -> io::Result<()>;
 }
 
-/// A column codec describes a colunm serialization format.
+/// A column codec describes a column serialization format.
 pub trait ColumnCodec<T: PartialOrd = u64> {
     /// Specialized `ColumnValues` type.
     type ColumnValues: ColumnValues<T> + 'static;

common/src/vint.rs

@@ -28,7 +28,9 @@ impl BinarySerializable for VIntU128 {
         writer.write_all(&buffer)
     }
 
+    #[allow(clippy::unbuffered_bytes)]
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
+        #[allow(clippy::unbuffered_bytes)]
         let mut bytes = reader.bytes();
         let mut result = 0u128;
         let mut shift = 0u64;
@@ -195,7 +197,9 @@ impl BinarySerializable for VInt {
         writer.write_all(&buffer[0..num_bytes])
     }
 
+    #[allow(clippy::unbuffered_bytes)]
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
+        #[allow(clippy::unbuffered_bytes)]
         let mut bytes = reader.bytes();
         let mut result = 0u64;
         let mut shift = 0u64;

examples/basic_search.rs

@@ -208,7 +208,7 @@ fn main() -> tantivy::Result<()> {
     // is the role of the `TopDocs` collector.
 
     // We can now perform our query.
-    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
 
     // The actual documents still need to be
     // retrieved from Tantivy's store.
@@ -226,7 +226,7 @@ fn main() -> tantivy::Result<()> {
     let query = query_parser.parse_query("title:sea^20 body:whale^70")?;
 
     let (_score, doc_address) = searcher
-        .search(&query, &TopDocs::with_limit(1))?
+        .search(&query, &TopDocs::with_limit(1).order_by_score())?
         .into_iter()
         .next()
         .unwrap();

examples/custom_tokenizer.rs

@@ -100,7 +100,7 @@ fn main() -> tantivy::Result<()> {
     // here we want to get a hit on the 'ken' in Frankenstein
     let query = query_parser.parse_query("ken")?;
 
-    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
 
     for (_, doc_address) in top_docs {
         let retrieved_doc: TantivyDocument = searcher.doc(doc_address)?;

examples/date_time_field.rs

@@ -50,14 +50,14 @@ fn main() -> tantivy::Result<()> {
     {
         // Simple exact search on the date
         let query = query_parser.parse_query("occurred_at:\"2022-06-22T12:53:50.53Z\"")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(5))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(5).order_by_score())?;
         assert_eq!(count_docs.len(), 1);
     }
     {
         // Range query on the date field
         let query = query_parser
             .parse_query(r#"occurred_at:[2022-06-22T12:58:00Z TO 2022-06-23T00:00:00Z}"#)?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(4))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(4).order_by_score())?;
         assert_eq!(count_docs.len(), 1);
         for (_score, doc_address) in count_docs {
             let retrieved_doc = searcher.doc::<TantivyDocument>(doc_address)?;

examples/deleting_updating_documents.rs

@@ -28,7 +28,7 @@ fn extract_doc_given_isbn(
     // The second argument is here to tell we don't care about decoding positions,
     // or term frequencies.
     let term_query = TermQuery::new(isbn_term.clone(), IndexRecordOption::Basic);
-    let top_docs = searcher.search(&term_query, &TopDocs::with_limit(1))?;
+    let top_docs = searcher.search(&term_query, &TopDocs::with_limit(1).order_by_score())?;
 
     if let Some((_score, doc_address)) = top_docs.first() {
         let doc = searcher.doc(*doc_address)?;

examples/fuzzy_search.rs

@@ -145,7 +145,7 @@ fn main() -> tantivy::Result<()> {
         let query = FuzzyTermQuery::new(term, 2, true);
 
         let (top_docs, count) = searcher
-            .search(&query, &(TopDocs::with_limit(5), Count))
+            .search(&query, &(TopDocs::with_limit(5).order_by_score(), Count))
             .unwrap();
         assert_eq!(count, 3);
         assert_eq!(top_docs.len(), 3);

examples/geo_json.rs

@@ -0,0 +1,66 @@
+use geo_types::Point;
+use tantivy::collector::TopDocs;
+use tantivy::query::SpatialQuery;
+use tantivy::schema::{Schema, Value, SPATIAL, STORED, TEXT};
+use tantivy::spatial::point::GeoPoint;
+use tantivy::{Index, IndexWriter, TantivyDocument};
+fn main() -> tantivy::Result<()> {
+    let mut schema_builder = Schema::builder();
+    schema_builder.add_json_field("properties", STORED | TEXT);
+    schema_builder.add_spatial_field("geometry", STORED | SPATIAL);
+    let schema = schema_builder.build();
+    let index = Index::create_in_ram(schema.clone());
+    let mut index_writer: IndexWriter = index.writer(50_000_000)?;
+    let doc = TantivyDocument::parse_json(
+        &schema,
+        r#"{
+            "type":"Feature",
+            "geometry":{
+                "type":"Polygon",
+                "coordinates":[[[-99.483911,45.577697],[-99.483869,45.571457],[-99.481739,45.571461],[-99.474881,45.571584],[-99.473167,45.571615],[-99.463394,45.57168],[-99.463391,45.57883],[-99.463368,45.586076],[-99.48177,45.585926],[-99.48384,45.585953],[-99.483885,45.57873],[-99.483911,45.577697]]]
+            },
+            "properties":{
+                "admin_level":"8",
+                "border_type":"city",
+                "boundary":"administrative",
+                "gnis:feature_id":"1267426",
+                "name":"Hosmer",
+                "place":"city",
+                "source":"TIGER/Line® 2008 Place Shapefiles (http://www.census.gov/geo/www/tiger/)",
+                "wikidata":"Q2442118",
+                "wikipedia":"en:Hosmer, South Dakota"
+            }
+        }"#,
+    )?;
+    index_writer.add_document(doc)?;
+    index_writer.commit()?;
+
+    let reader = index.reader()?;
+    let searcher = reader.searcher();
+    let field = schema.get_field("geometry").unwrap();
+    let query = SpatialQuery::new(
+        field,
+        [
+            GeoPoint {
+                lon: -99.49,
+                lat: 45.56,
+            },
+            GeoPoint {
+                lon: -99.45,
+                lat: 45.59,
+            },
+        ],
+        tantivy::query::SpatialQueryType::Intersects,
+    );
+    let hits = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
+    for (_score, doc_address) in &hits {
+        let retrieved_doc: TantivyDocument = searcher.doc(*doc_address)?;
+        if let Some(field_value) = retrieved_doc.get_first(field) {
+            if let Some(geometry_box) = field_value.as_value().into_geometry() {
+                println!("Retrieved geometry: {:?}", geometry_box);
+            }
+        }
+    }
+    assert_eq!(hits.len(), 1);
+    Ok(())
+}

examples/ip_field.rs

@@ -69,25 +69,25 @@ fn main() -> tantivy::Result<()> {
     {
         // Inclusive range queries
         let query = query_parser.parse_query("ip:[192.168.0.80 TO 192.168.0.100]")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(5))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(5).order_by_score())?;
         assert_eq!(count_docs.len(), 1);
     }
     {
         // Exclusive range queries
         let query = query_parser.parse_query("ip:{192.168.0.80 TO 192.168.1.100]")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(count_docs.len(), 0);
     }
     {
         // Find docs with IP addresses smaller equal 192.168.1.100
         let query = query_parser.parse_query("ip:[* TO 192.168.1.100]")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(count_docs.len(), 2);
     }
     {
         // Find docs with IP addresses smaller than 192.168.1.100
         let query = query_parser.parse_query("ip:[* TO 192.168.1.100}")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(count_docs.len(), 2);
     }
 

examples/json_field.rs

@@ -59,12 +59,12 @@ fn main() -> tantivy::Result<()> {
     let query_parser = QueryParser::for_index(&index, vec![event_type, attributes]);
     {
         let query = query_parser.parse_query("target:submit-button")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(count_docs.len(), 2);
     }
     {
         let query = query_parser.parse_query("target:submit")?;
-        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let count_docs = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(count_docs.len(), 2);
     }
     {
@@ -74,33 +74,33 @@ fn main() -> tantivy::Result<()> {
     }
     {
         let query = query_parser.parse_query("click AND cart.product_id:133")?;
-        let hits = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let hits = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(hits.len(), 1);
     }
     {
         // The sub-fields in the json field marked as default field still need to be explicitly
         // addressed
         let query = query_parser.parse_query("click AND 133")?;
-        let hits = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let hits = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(hits.len(), 0);
     }
     {
         // Default json fields are ignored if they collide with the schema
         let query = query_parser.parse_query("event_type:holiday-sale")?;
-        let hits = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let hits = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(hits.len(), 0);
     }
     // # Query via full attribute path
     {
         // This only searches in our schema's `event_type` field
         let query = query_parser.parse_query("event_type:click")?;
-        let hits = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let hits = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(hits.len(), 2);
     }
     {
         // Default json fields can still be accessed by full path
         let query = query_parser.parse_query("attributes.event_type:holiday-sale")?;
-        let hits = searcher.search(&*query, &TopDocs::with_limit(2))?;
+        let hits = searcher.search(&*query, &TopDocs::with_limit(2).order_by_score())?;
         assert_eq!(hits.len(), 1);
     }
     Ok(())

examples/phrase_prefix_search.rs

@@ -63,7 +63,7 @@ fn main() -> Result<()> {
     // but not "in the Gulf Stream".
     let query = query_parser.parse_query("\"in the su\"*")?;
 
-    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
     let mut titles = top_docs
         .into_iter()
         .map(|(_score, doc_address)| {

examples/pre_tokenized_text.rs

@@ -107,7 +107,8 @@ fn main() -> tantivy::Result<()> {
         IndexRecordOption::Basic,
     );
 
-    let (top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2), Count))?;
+    let (top_docs, count) =
+        searcher.search(&query, &(TopDocs::with_limit(2).order_by_score(), Count))?;
 
     assert_eq!(count, 2);
 
@@ -128,7 +129,8 @@ fn main() -> tantivy::Result<()> {
         IndexRecordOption::Basic,
     );
 
-    let (_top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2), Count))?;
+    let (_top_docs, count) =
+        searcher.search(&query, &(TopDocs::with_limit(2).order_by_score(), Count))?;
 
     assert_eq!(count, 0);
 

examples/snippet.rs

@@ -50,7 +50,7 @@ fn main() -> tantivy::Result<()> {
     let query_parser = QueryParser::for_index(&index, vec![title, body]);
     let query = query_parser.parse_query("sycamore spring")?;
 
-    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
 
     let snippet_generator = SnippetGenerator::create(&searcher, &*query, body)?;
 

examples/stop_words.rs

@@ -102,7 +102,7 @@ fn main() -> tantivy::Result<()> {
     // stop words are applied on the query as well.
     // The following will be equivalent to `title:frankenstein`
     let query = query_parser.parse_query("title:\"the Frankenstein\"")?;
-    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
 
     for (score, doc_address) in top_docs {
         let retrieved_doc: TantivyDocument = searcher.doc(doc_address)?;

examples/warmer.rs

@@ -164,7 +164,7 @@ fn main() -> tantivy::Result<()> {
         move |doc_id: DocId| Reverse(price[doc_id as usize])
     };
 
-    let most_expensive_first = TopDocs::with_limit(10).custom_score(score_by_price);
+    let most_expensive_first = TopDocs::with_limit(10).order_by(score_by_price);
 
     let hits = searcher.search(&query, &most_expensive_first)?;
     assert_eq!(

query-grammar/src/query_grammar.rs

@@ -758,7 +758,17 @@ fn negate(expr: UserInputAst) -> UserInputAst {
 fn leaf(inp: &str) -> IResult<&str, UserInputAst> {
     alt((
         delimited(char('('), ast, char(')')),
-        map(char('*'), |_| UserInputAst::from(UserInputLeaf::All)),
+        map(
+            terminated(
+                char('*'),
+                peek(alt((
+                    value((), multispace1),
+                    value((), char(')')),
+                    value((), eof),
+                ))),
+            ),
+            |_| UserInputAst::from(UserInputLeaf::All),
+        ),
         map(preceded(tuple((tag("NOT"), multispace1)), leaf), negate),
         literal,
     ))(inp)
@@ -779,7 +789,17 @@ fn leaf_infallible(inp: &str) -> JResult<&str, Option<UserInputAst>> {
                 ),
             ),
             (
-                value((), char('*')),
+                value(
+                    (),
+                    terminated(
+                        char('*'),
+                        peek(alt((
+                            value((), multispace1),
+                            value((), char(')')),
+                            value((), eof),
+                        ))),
+                    ),
+                ),
                 map(nothing, |_| {
                     (Some(UserInputAst::from(UserInputLeaf::All)), Vec::new())
                 }),
@@ -1671,6 +1691,21 @@ mod test {
         test_parse_query_to_ast_helper("abc:a b", "(*\"abc\":a *b)");
         test_parse_query_to_ast_helper("abc:\"a b\"", "\"abc\":\"a b\"");
         test_parse_query_to_ast_helper("foo:[1 TO 5]", "\"foo\":[\"1\" TO \"5\"]");
+
+        // Phrase prefixed with *
+        test_parse_query_to_ast_helper("foo:(*A)", "\"foo\":*A");
+        test_parse_query_to_ast_helper("*A", "*A");
+        test_parse_query_to_ast_helper("(*A)", "*A");
+        test_parse_query_to_ast_helper("foo:(A OR B)", "(?\"foo\":A ?\"foo\":B)");
+        test_parse_query_to_ast_helper("foo:(A* OR B*)", "(?\"foo\":A* ?\"foo\":B*)");
+        test_parse_query_to_ast_helper("foo:(*A OR *B)", "(?\"foo\":*A ?\"foo\":*B)");
+    }
+
+    #[test]
+    fn test_parse_query_all() {
+        test_parse_query_to_ast_helper("*", "*");
+        test_parse_query_to_ast_helper("(*)", "*");
+        test_parse_query_to_ast_helper("(* )", "*");
     }
 
     #[test]

src/aggregation/accessor_helpers.rs

@@ -16,15 +16,16 @@ use crate::index::SegmentReader;
 /// 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,
+    column_max_value: u64,
     missing: &Key,
     field_name: &str,
 ) -> crate::Result<Option<u64>> {
     let missing_val = match missing {
-        Key::Str(_) if column_type == ColumnType::Str => Some(u64::MAX),
+        Key::Str(_) if column_type == ColumnType::Str => Some(column_max_value + 1),
         // 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(_) if column_type == ColumnType::Str => Some(column_max_value + 1),
+        Key::U64(_) if column_type == ColumnType::Str => Some(column_max_value + 1),
+        Key::I64(_) if column_type == ColumnType::Str => Some(column_max_value + 1),
         Key::F64(val) if column_type.numerical_type().is_some() => {
             f64_to_fastfield_u64(*val, &column_type)
         }

src/aggregation/agg_data.rs

@@ -10,10 +10,10 @@ use crate::aggregation::accessor_helpers::{
 };
 use crate::aggregation::agg_req::{Aggregation, AggregationVariants, Aggregations};
 use crate::aggregation::bucket::{
-    build_segment_aggregation_collector, FilterAggReqData, HistogramAggReqData, HistogramBounds,
-    IncludeExcludeParam, MissingTermAggReqData, RangeAggReqData, SegmentFilterCollector,
-    SegmentHistogramCollector, SegmentRangeCollector, TermMissingAgg, TermsAggReqData,
-    TermsAggregation, TermsAggregationInternal,
+    FilterAggReqData, HistogramAggReqData, HistogramBounds, IncludeExcludeParam,
+    MissingTermAggReqData, RangeAggReqData, SegmentFilterCollector, SegmentHistogramCollector,
+    SegmentRangeCollector, TermMissingAgg, TermsAggReqData, TermsAggregation,
+    TermsAggregationInternal,
 };
 use crate::aggregation::metric::{
     AverageAggregation, CardinalityAggReqData, CardinalityAggregationReq, CountAggregation,
@@ -373,7 +373,7 @@ pub(crate) fn build_segment_agg_collector(
     node: &AggRefNode,
 ) -> crate::Result<Box<dyn SegmentAggregationCollector>> {
     match node.kind {
-        AggKind::Terms => build_segment_aggregation_collector(req, node),
+        AggKind::Terms => crate::aggregation::bucket::build_segment_term_collector(req, node),
         AggKind::MissingTerm => {
             let req_data = &mut req.per_request.missing_term_req_data[node.idx_in_req_data];
             if req_data.accessors.is_empty() {
@@ -496,7 +496,7 @@ pub(crate) fn build_aggregations_data_from_req(
     };
 
     for (name, agg) in aggs.iter() {
-        let nodes = build_nodes(name, agg, reader, segment_ordinal, &mut data)?;
+        let nodes = build_nodes(name, agg, reader, segment_ordinal, &mut data, true)?;
         data.per_request.agg_tree.extend(nodes);
     }
     Ok(data)
@@ -508,6 +508,7 @@ fn build_nodes(
     reader: &SegmentReader,
     segment_ordinal: SegmentOrdinal,
     data: &mut AggregationsSegmentCtx,
+    is_top_level: bool,
 ) -> crate::Result<Vec<AggRefNode>> {
     use AggregationVariants::*;
     match &req.agg {
@@ -594,6 +595,7 @@ fn build_nodes(
             data,
             &req.sub_aggregation,
             TermsOrCardinalityRequest::Terms(terms_req.clone()),
+            is_top_level,
         ),
         Cardinality(card_req) => build_terms_or_cardinality_nodes(
             agg_name,
@@ -604,6 +606,7 @@ fn build_nodes(
             data,
             &req.sub_aggregation,
             TermsOrCardinalityRequest::Cardinality(card_req.clone()),
+            is_top_level,
         ),
         Average(AverageAggregation { field, missing, .. })
         | Max(MaxAggregation { field, missing, .. })
@@ -732,7 +735,7 @@ fn build_nodes(
             // Build the query and evaluator upfront
             let schema = reader.schema();
             let tokenizers = &data.context.tokenizers;
-            let query = filter_req.parse_query(&schema, tokenizers)?;
+            let query = filter_req.parse_query(schema, tokenizers)?;
             let evaluator = crate::aggregation::bucket::DocumentQueryEvaluator::new(
                 query,
                 schema.clone(),
@@ -769,7 +772,14 @@ fn build_children(
 ) -> crate::Result<Vec<AggRefNode>> {
     let mut children = Vec::new();
     for (name, agg) in aggs.iter() {
-        children.extend(build_nodes(name, agg, reader, segment_ordinal, data)?);
+        children.extend(build_nodes(
+            name,
+            agg,
+            reader,
+            segment_ordinal,
+            data,
+            false,
+        )?);
     }
     Ok(children)
 }
@@ -833,6 +843,7 @@ fn build_terms_or_cardinality_nodes(
     data: &mut AggregationsSegmentCtx,
     sub_aggs: &Aggregations,
     req: TermsOrCardinalityRequest,
+    is_top_level: bool,
 ) -> crate::Result<Vec<AggRefNode>> {
     let mut nodes = Vec::new();
 
@@ -889,7 +900,7 @@ fn build_terms_or_cardinality_nodes(
         let missing_value_for_accessor = if use_special_missing_agg {
             None
         } else if let Some(m) = missing.as_ref() {
-            get_missing_val_as_u64_lenient(column_type, m, field_name)?
+            get_missing_val_as_u64_lenient(column_type, accessor.max_value(), m, field_name)?
         } else {
             None
         };
@@ -922,6 +933,7 @@ fn build_terms_or_cardinality_nodes(
                     sub_aggregation_blueprint: None,
                     sug_aggregations: sub_aggs.clone(),
                     allowed_term_ids,
+                    is_top_level,
                 });
                 (idx_in_req_data, AggKind::Terms)
             }

src/aggregation/agg_limits.rs

@@ -35,6 +35,7 @@ pub struct AggregationLimitsGuard {
     /// Allocated memory with this guard.
     allocated_with_the_guard: u64,
 }
+
 impl Clone for AggregationLimitsGuard {
     fn clone(&self) -> Self {
         Self {

src/aggregation/agg_result.rs

@@ -16,7 +16,7 @@ use super::{AggregationError, Key};
 use crate::TantivyError;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
-/// The final aggegation result.
+/// The final aggregation result.
 pub struct AggregationResults(pub FxHashMap<String, AggregationResult>);
 
 impl AggregationResults {

src/aggregation/bucket/filter.rs

@@ -32,7 +32,7 @@ use crate::{DocId, SegmentReader, TantivyError};
 ///
 /// # Implementation Requirements
 ///
-/// Implementors must:
+/// Implementers must:
 /// 1. Derive `Debug`, `Clone`, `Serialize`, and `Deserialize`
 /// 2. Use `#[typetag::serde]` attribute on the impl block
 /// 3. Implement `build_query()` to construct the query from schema/tokenizers
@@ -639,16 +639,14 @@ pub struct IntermediateFilterBucketResult {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Instant;
-
     use serde_json::{json, Value};
 
     use super::*;
     use crate::aggregation::agg_req::Aggregations;
     use crate::aggregation::agg_result::AggregationResults;
     use crate::aggregation::{AggContextParams, AggregationCollector};
-    use crate::query::{AllQuery, QueryParser, TermQuery};
-    use crate::schema::{IndexRecordOption, Schema, Term, FAST, INDEXED, STORED, TEXT};
+    use crate::query::{AllQuery, TermQuery};
+    use crate::schema::{IndexRecordOption, Schema, Term, FAST, INDEXED, TEXT};
     use crate::{doc, Index, IndexWriter};
 
     // Test helper functions
@@ -729,12 +727,13 @@ mod tests {
 
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
-        let mut writer: IndexWriter = index.writer(50_000_000)?;
+        let mut writer: IndexWriter = index.writer_for_tests()?;
 
         writer.add_document(doc!(
             category => "electronics", brand => "apple",
             price => 999u64, rating => 4.5f64, in_stock => true
         ))?;
+        writer.commit()?;
         writer.add_document(doc!(
             category => "electronics", brand => "samsung",
             price => 799u64, rating => 4.2f64, in_stock => true
@@ -938,7 +937,7 @@ mod tests {
         let index = create_standard_test_index()?;
         let reader = index.reader()?;
         let searcher = reader.searcher();
-
+        assert_eq!(searcher.segment_readers().len(), 2);
         let agg = json!({
             "premium_electronics": {
                 "filter": "category:electronics AND price:[800 TO *]",

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/buf_collector.rs

@@ -3,7 +3,12 @@ use super::segment_agg_result::SegmentAggregationCollector;
 use crate::aggregation::agg_data::AggregationsSegmentCtx;
 use crate::DocId;
 
+#[cfg(test)]
 pub(crate) const DOC_BLOCK_SIZE: usize = 64;
+
+#[cfg(not(test))]
+pub(crate) const DOC_BLOCK_SIZE: usize = 256;
+
 pub(crate) type DocBlock = [DocId; DOC_BLOCK_SIZE];
 
 /// BufAggregationCollector buffers documents before calling collect_block().
@@ -15,7 +20,7 @@ pub(crate) struct BufAggregationCollector {
 }
 
 impl std::fmt::Debug for BufAggregationCollector {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("SegmentAggregationResultsCollector")
             .field("staged_docs", &&self.staged_docs[..self.num_staged_docs])
             .field("num_staged_docs", &self.num_staged_docs)
@@ -66,7 +71,6 @@ impl SegmentAggregationCollector for BufAggregationCollector {
         agg_data: &mut AggregationsSegmentCtx,
     ) -> crate::Result<()> {
         self.collector.collect_block(docs, agg_data)?;
-
         Ok(())
     }
 

src/aggregation/metric/extended_stats.rs

@@ -62,7 +62,7 @@ impl ExtendedStatsAggregation {
 
 /// Extended stats contains a collection of statistics
 /// they extends stats adding variance, standard deviation
-/// and bound informations
+/// and bound information
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ExtendedStats {
     /// The number of documents.

src/aggregation/metric/top_hits.rs

@@ -16,6 +16,7 @@ use crate::aggregation::intermediate_agg_result::{
 };
 use crate::aggregation::segment_agg_result::SegmentAggregationCollector;
 use crate::aggregation::AggregationError;
+use crate::collector::sort_key::ReverseComparator;
 use crate::collector::TopNComputer;
 use crate::schema::OwnedValue;
 use crate::{DocAddress, DocId, SegmentOrdinal};
@@ -458,7 +459,7 @@ impl Eq for DocSortValuesAndFields {}
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct TopHitsTopNComputer {
     req: TopHitsAggregationReq,
-    top_n: TopNComputer<DocSortValuesAndFields, DocAddress, false>,
+    top_n: TopNComputer<DocSortValuesAndFields, DocAddress, ReverseComparator>,
 }
 
 impl std::cmp::PartialEq for TopHitsTopNComputer {
@@ -482,7 +483,7 @@ impl TopHitsTopNComputer {
 
     pub(crate) fn merge_fruits(&mut self, other_fruit: Self) -> crate::Result<()> {
         for doc in other_fruit.top_n.into_vec() {
-            self.collect(doc.feature, doc.doc);
+            self.collect(doc.sort_key, doc.doc);
         }
         Ok(())
     }
@@ -494,9 +495,9 @@ impl TopHitsTopNComputer {
             .into_sorted_vec()
             .into_iter()
             .map(|doc| TopHitsVecEntry {
-                sort: doc.feature.sorts.iter().map(|f| f.value).collect(),
+                sort: doc.sort_key.sorts.iter().map(|f| f.value).collect(),
                 doc_value_fields: doc
-                    .feature
+                    .sort_key
                     .doc_value_fields
                     .into_iter()
                     .map(|(k, v)| (k, v.into()))
@@ -517,7 +518,7 @@ impl TopHitsTopNComputer {
 pub(crate) struct TopHitsSegmentCollector {
     segment_ordinal: SegmentOrdinal,
     accessor_idx: usize,
-    top_n: TopNComputer<Vec<DocValueAndOrder>, DocAddress, false>,
+    top_n: TopNComputer<Vec<DocValueAndOrder>, DocAddress, ReverseComparator>,
 }
 
 impl TopHitsSegmentCollector {
@@ -544,7 +545,7 @@ impl TopHitsSegmentCollector {
             let doc_value_fields = req.get_document_field_data(value_accessors, res.doc.doc_id);
             top_hits_computer.collect(
                 DocSortValuesAndFields {
-                    sorts: res.feature,
+                    sorts: res.sort_key,
                     doc_value_fields,
                 },
                 res.doc,
@@ -645,6 +646,7 @@ mod tests {
     use crate::aggregation::bucket::tests::get_test_index_from_docs;
     use crate::aggregation::tests::get_test_index_from_values;
     use crate::aggregation::AggregationCollector;
+    use crate::collector::sort_key::ReverseComparator;
     use crate::collector::ComparableDoc;
     use crate::query::AllQuery;
     use crate::schema::OwnedValue;
@@ -660,7 +662,7 @@ mod tests {
 
     fn collector_with_capacity(capacity: usize) -> super::TopHitsTopNComputer {
         super::TopHitsTopNComputer {
-            top_n: super::TopNComputer::new(capacity),
+            top_n: super::TopNComputer::new_with_comparator(capacity, ReverseComparator),
             req: Default::default(),
         }
     }
@@ -774,12 +776,12 @@ mod tests {
     #[test]
     fn test_top_hits_collector_single_feature() -> crate::Result<()> {
         let docs = vec![
-            ComparableDoc::<_, _, false> {
+            ComparableDoc::<_, _> {
                 doc: crate::DocAddress {
                     segment_ord: 0,
                     doc_id: 0,
                 },
-                feature: DocSortValuesAndFields {
+                sort_key: DocSortValuesAndFields {
                     sorts: vec![DocValueAndOrder {
                         value: Some(1),
                         order: Order::Asc,
@@ -792,7 +794,7 @@ mod tests {
                     segment_ord: 0,
                     doc_id: 2,
                 },
-                feature: DocSortValuesAndFields {
+                sort_key: DocSortValuesAndFields {
                     sorts: vec![DocValueAndOrder {
                         value: Some(3),
                         order: Order::Asc,
@@ -805,7 +807,7 @@ mod tests {
                     segment_ord: 0,
                     doc_id: 1,
                 },
-                feature: DocSortValuesAndFields {
+                sort_key: DocSortValuesAndFields {
                     sorts: vec![DocValueAndOrder {
                         value: Some(5),
                         order: Order::Asc,
@@ -817,7 +819,7 @@ mod tests {
 
         let mut collector = collector_with_capacity(3);
         for doc in docs.clone() {
-            collector.collect(doc.feature, doc.doc);
+            collector.collect(doc.sort_key, doc.doc);
         }
 
         let res = collector.into_final_result();
@@ -827,15 +829,15 @@ mod tests {
             super::TopHitsMetricResult {
                 hits: vec![
                     super::TopHitsVecEntry {
-                        sort: vec![docs[0].feature.sorts[0].value],
+                        sort: vec![docs[0].sort_key.sorts[0].value],
                         doc_value_fields: Default::default(),
                     },
                     super::TopHitsVecEntry {
-                        sort: vec![docs[1].feature.sorts[0].value],
+                        sort: vec![docs[1].sort_key.sorts[0].value],
                         doc_value_fields: Default::default(),
                     },
                     super::TopHitsVecEntry {
-                        sort: vec![docs[2].feature.sorts[0].value],
+                        sort: vec![docs[2].sort_key.sorts[0].value],
                         doc_value_fields: Default::default(),
                     },
                 ]

src/aggregation/segment_agg_result.rs

@@ -17,14 +17,11 @@ pub trait SegmentAggregationCollector: CollectorClone + Debug {
         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)
-    }
+    ) -> crate::Result<()>;
 
     fn collect_block(
         &mut self,

src/collector/custom_score_top_collector.rs

@@ -1,121 +0,0 @@
-use crate::collector::top_collector::{TopCollector, TopSegmentCollector};
-use crate::collector::{Collector, SegmentCollector};
-use crate::{DocAddress, DocId, Score, SegmentReader};
-
-pub(crate) struct CustomScoreTopCollector<TCustomScorer, TScore = Score> {
-    custom_scorer: TCustomScorer,
-    collector: TopCollector<TScore>,
-}
-
-impl<TCustomScorer, TScore> CustomScoreTopCollector<TCustomScorer, TScore>
-where TScore: Clone + PartialOrd
-{
-    pub(crate) fn new(
-        custom_scorer: TCustomScorer,
-        collector: TopCollector<TScore>,
-    ) -> CustomScoreTopCollector<TCustomScorer, TScore> {
-        CustomScoreTopCollector {
-            custom_scorer,
-            collector,
-        }
-    }
-}
-
-/// A custom segment scorer makes it possible to define any kind of score
-/// for a given document belonging to a specific segment.
-///
-/// It is the segment local version of the [`CustomScorer`].
-pub trait CustomSegmentScorer<TScore>: 'static {
-    /// Computes the score of a specific `doc`.
-    fn score(&mut self, doc: DocId) -> TScore;
-}
-
-/// `CustomScorer` makes it possible to define any kind of score.
-///
-/// The `CustomerScorer` itself does not make much of the computation itself.
-/// Instead, it helps constructing `Self::Child` instances that will compute
-/// the score at a segment scale.
-pub trait CustomScorer<TScore>: Sync {
-    /// Type of the associated [`CustomSegmentScorer`].
-    type Child: CustomSegmentScorer<TScore>;
-    /// Builds a child scorer for a specific segment. The child scorer is associated with
-    /// a specific segment.
-    fn segment_scorer(&self, segment_reader: &SegmentReader) -> crate::Result<Self::Child>;
-}
-
-impl<TCustomScorer, TScore> Collector for CustomScoreTopCollector<TCustomScorer, TScore>
-where
-    TCustomScorer: CustomScorer<TScore> + Send + Sync,
-    TScore: 'static + PartialOrd + Clone + Send + Sync,
-{
-    type Fruit = Vec<(TScore, DocAddress)>;
-
-    type Child = CustomScoreTopSegmentCollector<TCustomScorer::Child, TScore>;
-
-    fn for_segment(
-        &self,
-        segment_local_id: u32,
-        segment_reader: &SegmentReader,
-    ) -> crate::Result<Self::Child> {
-        let segment_collector = self.collector.for_segment(segment_local_id, segment_reader);
-        let segment_scorer = self.custom_scorer.segment_scorer(segment_reader)?;
-        Ok(CustomScoreTopSegmentCollector {
-            segment_collector,
-            segment_scorer,
-        })
-    }
-
-    fn requires_scoring(&self) -> bool {
-        false
-    }
-
-    fn merge_fruits(&self, segment_fruits: Vec<Self::Fruit>) -> crate::Result<Self::Fruit> {
-        self.collector.merge_fruits(segment_fruits)
-    }
-}
-
-pub struct CustomScoreTopSegmentCollector<T, TScore>
-where
-    TScore: 'static + PartialOrd + Clone + Send + Sync + Sized,
-    T: CustomSegmentScorer<TScore>,
-{
-    segment_collector: TopSegmentCollector<TScore>,
-    segment_scorer: T,
-}
-
-impl<T, TScore> SegmentCollector for CustomScoreTopSegmentCollector<T, TScore>
-where
-    TScore: 'static + PartialOrd + Clone + Send + Sync,
-    T: 'static + CustomSegmentScorer<TScore>,
-{
-    type Fruit = Vec<(TScore, DocAddress)>;
-
-    fn collect(&mut self, doc: DocId, _score: Score) {
-        let score = self.segment_scorer.score(doc);
-        self.segment_collector.collect(doc, score);
-    }
-
-    fn harvest(self) -> Vec<(TScore, DocAddress)> {
-        self.segment_collector.harvest()
-    }
-}
-
-impl<F, TScore, T> CustomScorer<TScore> for F
-where
-    F: 'static + Send + Sync + Fn(&SegmentReader) -> T,
-    T: CustomSegmentScorer<TScore>,
-{
-    type Child = T;
-
-    fn segment_scorer(&self, segment_reader: &SegmentReader) -> crate::Result<Self::Child> {
-        Ok((self)(segment_reader))
-    }
-}
-
-impl<F, TScore> CustomSegmentScorer<TScore> for F
-where F: 'static + FnMut(DocId) -> TScore
-{
-    fn score(&mut self, doc: DocId) -> TScore {
-        (self)(doc)
-    }
-}

src/collector/filter_collector_wrapper.rs

@@ -12,6 +12,7 @@ use std::marker::PhantomData;
 use columnar::{BytesColumn, Column, DynamicColumn, HasAssociatedColumnType};
 
 use crate::collector::{Collector, SegmentCollector};
+use crate::schema::Schema;
 use crate::{DocId, Score, SegmentReader};
 
 /// The `FilterCollector` filters docs using a fast field value and a predicate.
@@ -49,13 +50,13 @@ use crate::{DocId, Score, SegmentReader};
 ///
 /// let query_parser = QueryParser::for_index(&index, vec![title]);
 /// let query = query_parser.parse_query("diary")?;
-/// let no_filter_collector = FilterCollector::new("price".to_string(), |value: u64| value > 20_120u64, TopDocs::with_limit(2));
+/// let no_filter_collector = FilterCollector::new("price".to_string(), |value: u64| value > 20_120u64, TopDocs::with_limit(2).order_by_score());
 /// let top_docs = searcher.search(&query, &no_filter_collector)?;
 ///
 /// assert_eq!(top_docs.len(), 1);
 /// assert_eq!(top_docs[0].1, DocAddress::new(0, 1));
 ///
-/// let filter_all_collector: FilterCollector<_, _, u64> = FilterCollector::new("price".to_string(), |value| value < 5u64, TopDocs::with_limit(2));
+/// let filter_all_collector: FilterCollector<_, _, u64> = FilterCollector::new("price".to_string(), |value| value < 5u64, TopDocs::with_limit(2).order_by_score());
 /// let filtered_top_docs = searcher.search(&query, &filter_all_collector)?;
 ///
 /// assert_eq!(filtered_top_docs.len(), 0);
@@ -104,6 +105,11 @@ where
 
     type Child = FilterSegmentCollector<TCollector::Child, TPredicate, TPredicateValue>;
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.collector.check_schema(schema)?;
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -120,6 +126,7 @@ where
             segment_collector,
             predicate: self.predicate.clone(),
             t_predicate_value: PhantomData,
+            filtered_docs: Vec::with_capacity(crate::COLLECT_BLOCK_BUFFER_LEN),
         })
     }
 
@@ -140,6 +147,7 @@ pub struct FilterSegmentCollector<TSegmentCollector, TPredicate, TPredicateValue
     segment_collector: TSegmentCollector,
     predicate: TPredicate,
     t_predicate_value: PhantomData<TPredicateValue>,
+    filtered_docs: Vec<DocId>,
 }
 
 impl<TSegmentCollector, TPredicate, TPredicateValue>
@@ -176,6 +184,20 @@ where
         }
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        self.filtered_docs.clear();
+        for &doc in docs {
+            // TODO: `accept_document` could be further optimized to do batch lookups of column
+            // values for single-valued columns.
+            if self.accept_document(doc) {
+                self.filtered_docs.push(doc);
+            }
+        }
+        if !self.filtered_docs.is_empty() {
+            self.segment_collector.collect_block(&self.filtered_docs);
+        }
+    }
+
     fn harvest(self) -> TSegmentCollector::Fruit {
         self.segment_collector.harvest()
     }
@@ -218,7 +240,7 @@ where
 ///
 /// let query_parser = QueryParser::for_index(&index, vec![title]);
 /// let query = query_parser.parse_query("diary")?;
-/// let filter_collector = BytesFilterCollector::new("barcode".to_string(), |bytes: &[u8]| bytes.starts_with(b"01"), TopDocs::with_limit(2));
+/// let filter_collector = BytesFilterCollector::new("barcode".to_string(), |bytes: &[u8]| bytes.starts_with(b"01"), TopDocs::with_limit(2).order_by_score());
 /// let top_docs = searcher.search(&query, &filter_collector)?;
 ///
 /// assert_eq!(top_docs.len(), 1);
@@ -258,6 +280,10 @@ where
 
     type Child = BytesFilterSegmentCollector<TCollector::Child, TPredicate>;
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.collector.check_schema(schema)
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -274,6 +300,7 @@ where
             segment_collector,
             predicate: self.predicate.clone(),
             buffer: Vec::new(),
+            filtered_docs: Vec::with_capacity(crate::COLLECT_BLOCK_BUFFER_LEN),
         })
     }
 
@@ -296,6 +323,7 @@ where TPredicate: 'static
     segment_collector: TSegmentCollector,
     predicate: TPredicate,
     buffer: Vec<u8>,
+    filtered_docs: Vec<DocId>,
 }
 
 impl<TSegmentCollector, TPredicate> BytesFilterSegmentCollector<TSegmentCollector, TPredicate>
@@ -334,6 +362,20 @@ where
         }
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        self.filtered_docs.clear();
+        for &doc in docs {
+            // TODO: `accept_document` could be further optimized to do batch lookups of column
+            // values for single-valued columns.
+            if self.accept_document(doc) {
+                self.filtered_docs.push(doc);
+            }
+        }
+        if !self.filtered_docs.is_empty() {
+            self.segment_collector.collect_block(&self.filtered_docs);
+        }
+    }
+
     fn harvest(self) -> TSegmentCollector::Fruit {
         self.segment_collector.harvest()
     }

src/collector/mod.rs

@@ -57,7 +57,7 @@
 //! #     let query_parser = QueryParser::for_index(&index, vec![title]);
 //! #     let query = query_parser.parse_query("diary")?;
 //! let (doc_count, top_docs): (usize, Vec<(Score, DocAddress)>) =
-//! searcher.search(&query, &(Count, TopDocs::with_limit(2)))?;
+//! searcher.search(&query, &(Count, TopDocs::with_limit(2).order_by_score()))?;
 //! #     Ok(())
 //! # }
 //! ```
@@ -83,11 +83,15 @@
 
 use downcast_rs::impl_downcast;
 
+use crate::schema::Schema;
 use crate::{DocId, Score, SegmentOrdinal, SegmentReader};
 
 mod count_collector;
 pub use self::count_collector::Count;
 
+/// Sort keys
+pub mod sort_key;
+
 mod histogram_collector;
 pub use histogram_collector::HistogramCollector;
 
@@ -95,16 +99,13 @@ mod multi_collector;
 pub use self::multi_collector::{FruitHandle, MultiCollector, MultiFruit};
 
 mod top_collector;
+pub use self::top_collector::ComparableDoc;
 
 mod top_score_collector;
-pub use self::top_collector::ComparableDoc;
 pub use self::top_score_collector::{TopDocs, TopNComputer};
 
-mod custom_score_top_collector;
-pub use self::custom_score_top_collector::{CustomScorer, CustomSegmentScorer};
-
-mod tweak_score_top_collector;
-pub use self::tweak_score_top_collector::{ScoreSegmentTweaker, ScoreTweaker};
+mod sort_key_top_collector;
+pub use self::sort_key::{SegmentSortKeyComputer, SortKeyComputer};
 mod facet_collector;
 pub use self::facet_collector::{FacetCollector, FacetCounts};
 use crate::query::Weight;
@@ -145,6 +146,11 @@ pub trait Collector: Sync + Send {
     /// Type of the `SegmentCollector` associated with this collector.
     type Child: SegmentCollector;
 
+    /// Returns an error if the schema is not compatible with the collector.
+    fn check_schema(&self, _schema: &Schema) -> crate::Result<()> {
+        Ok(())
+    }
+
     /// `set_segment` is called before beginning to enumerate
     /// on this segment.
     fn for_segment(
@@ -170,41 +176,50 @@ pub trait Collector: Sync + Send {
         segment_ord: u32,
         reader: &SegmentReader,
     ) -> crate::Result<<Self::Child as SegmentCollector>::Fruit> {
+        let with_scoring = self.requires_scoring();
         let mut segment_collector = self.for_segment(segment_ord, reader)?;
-
-        match (reader.alive_bitset(), self.requires_scoring()) {
-            (Some(alive_bitset), true) => {
-                weight.for_each(reader, &mut |doc, score| {
-                    if alive_bitset.is_alive(doc) {
-                        segment_collector.collect(doc, score);
-                    }
-                })?;
-            }
-            (Some(alive_bitset), false) => {
-                weight.for_each_no_score(reader, &mut |docs| {
-                    for doc in docs.iter().cloned() {
-                        if alive_bitset.is_alive(doc) {
-                            segment_collector.collect(doc, 0.0);
-                        }
-                    }
-                })?;
-            }
-            (None, true) => {
-                weight.for_each(reader, &mut |doc, score| {
-                    segment_collector.collect(doc, score);
-                })?;
-            }
-            (None, false) => {
-                weight.for_each_no_score(reader, &mut |docs| {
-                    segment_collector.collect_block(docs);
-                })?;
-            }
-        }
-
+        default_collect_segment_impl(&mut segment_collector, weight, reader, with_scoring)?;
         Ok(segment_collector.harvest())
     }
 }
 
+pub(crate) fn default_collect_segment_impl<TSegmentCollector: SegmentCollector>(
+    segment_collector: &mut TSegmentCollector,
+    weight: &dyn Weight,
+    reader: &SegmentReader,
+    with_scoring: bool,
+) -> crate::Result<()> {
+    match (reader.alive_bitset(), with_scoring) {
+        (Some(alive_bitset), true) => {
+            weight.for_each(reader, &mut |doc, score| {
+                if alive_bitset.is_alive(doc) {
+                    segment_collector.collect(doc, score);
+                }
+            })?;
+        }
+        (Some(alive_bitset), false) => {
+            weight.for_each_no_score(reader, &mut |docs| {
+                for doc in docs.iter().cloned() {
+                    if alive_bitset.is_alive(doc) {
+                        segment_collector.collect(doc, 0.0);
+                    }
+                }
+            })?;
+        }
+        (None, true) => {
+            weight.for_each(reader, &mut |doc, score| {
+                segment_collector.collect(doc, score);
+            })?;
+        }
+        (None, false) => {
+            weight.for_each_no_score(reader, &mut |docs| {
+                segment_collector.collect_block(docs);
+            })?;
+        }
+    }
+    Ok(())
+}
+
 impl<TSegmentCollector: SegmentCollector> SegmentCollector for Option<TSegmentCollector> {
     type Fruit = Option<TSegmentCollector::Fruit>;
 
@@ -214,6 +229,12 @@ impl<TSegmentCollector: SegmentCollector> SegmentCollector for Option<TSegmentCo
         }
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        if let Some(segment_collector) = self {
+            segment_collector.collect_block(docs);
+        }
+    }
+
     fn harvest(self) -> Self::Fruit {
         self.map(|segment_collector| segment_collector.harvest())
     }
@@ -224,6 +245,13 @@ impl<TCollector: Collector> Collector for Option<TCollector> {
 
     type Child = Option<<TCollector as Collector>::Child>;
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        if let Some(underlying_collector) = self {
+            underlying_collector.check_schema(schema)?;
+        }
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: SegmentOrdinal,
@@ -299,6 +327,12 @@ where
     type Fruit = (Left::Fruit, Right::Fruit);
     type Child = (Left::Child, Right::Child);
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -342,6 +376,11 @@ where
         self.1.collect(doc, score);
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        self.0.collect_block(docs);
+        self.1.collect_block(docs);
+    }
+
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
         (self.0.harvest(), self.1.harvest())
     }
@@ -358,6 +397,13 @@ where
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit);
     type Child = (One::Child, Two::Child, Three::Child);
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        self.2.check_schema(schema)?;
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -407,6 +453,12 @@ where
         self.2.collect(doc, score);
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        self.0.collect_block(docs);
+        self.1.collect_block(docs);
+        self.2.collect_block(docs);
+    }
+
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
         (self.0.harvest(), self.1.harvest(), self.2.harvest())
     }
@@ -424,6 +476,14 @@ where
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit, Four::Fruit);
     type Child = (One::Child, Two::Child, Three::Child, Four::Child);
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        self.2.check_schema(schema)?;
+        self.3.check_schema(schema)?;
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -482,6 +542,13 @@ where
         self.3.collect(doc, score);
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        self.0.collect_block(docs);
+        self.1.collect_block(docs);
+        self.2.collect_block(docs);
+        self.3.collect_block(docs);
+    }
+
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
         (
             self.0.harvest(),

src/collector/multi_collector.rs

@@ -3,6 +3,7 @@ use std::ops::Deref;
 
 use super::{Collector, SegmentCollector};
 use crate::collector::Fruit;
+use crate::schema::Schema;
 use crate::{DocId, Score, SegmentOrdinal, SegmentReader, TantivyError};
 
 /// MultiFruit keeps Fruits from every nested Collector
@@ -16,6 +17,10 @@ impl<TCollector: Collector> Collector for CollectorWrapper<TCollector> {
     type Fruit = Box<dyn Fruit>;
     type Child = Box<dyn BoxableSegmentCollector>;
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)
+    }
+
     fn for_segment(
         &self,
         segment_local_id: u32,
@@ -147,7 +152,7 @@ impl<TFruit: Fruit> FruitHandle<TFruit> {
 /// let searcher = reader.searcher();
 ///
 /// let mut collectors = MultiCollector::new();
-/// let top_docs_handle = collectors.add_collector(TopDocs::with_limit(2));
+/// let top_docs_handle = collectors.add_collector(TopDocs::with_limit(2).order_by_score());
 /// let count_handle = collectors.add_collector(Count);
 /// let query_parser = QueryParser::for_index(&index, vec![title]);
 /// let query = query_parser.parse_query("diary").unwrap();
@@ -194,6 +199,13 @@ impl Collector for MultiCollector<'_> {
     type Fruit = MultiFruit;
     type Child = MultiCollectorChild;
 
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        for collector in &self.collector_wrappers {
+            collector.check_schema(schema)?;
+        }
+        Ok(())
+    }
+
     fn for_segment(
         &self,
         segment_local_id: SegmentOrdinal,
@@ -250,6 +262,12 @@ impl SegmentCollector for MultiCollectorChild {
         }
     }
 
+    fn collect_block(&mut self, docs: &[DocId]) {
+        for child in &mut self.children {
+            child.collect_block(docs);
+        }
+    }
+
     fn harvest(self) -> MultiFruit {
         MultiFruit {
             sub_fruits: self
@@ -293,7 +311,7 @@ mod tests {
         let query = TermQuery::new(term, IndexRecordOption::Basic);
 
         let mut collectors = MultiCollector::new();
-        let topdocs_handler = collectors.add_collector(TopDocs::with_limit(2));
+        let topdocs_handler = collectors.add_collector(TopDocs::with_limit(2).order_by_score());
         let count_handler = collectors.add_collector(Count);
         let mut multifruits = searcher.search(&query, &collectors).unwrap();
 

src/collector/sort_key/mod.rs

@@ -0,0 +1,393 @@
+mod order;
+mod sort_by_score;
+mod sort_by_static_fast_value;
+mod sort_by_string;
+mod sort_key_computer;
+
+pub use order::*;
+pub use sort_by_score::SortBySimilarityScore;
+pub use sort_by_static_fast_value::SortByStaticFastValue;
+pub use sort_by_string::SortByString;
+pub use sort_key_computer::{SegmentSortKeyComputer, SortKeyComputer};
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::ops::Range;
+
+    use crate::collector::sort_key::{SortBySimilarityScore, SortByStaticFastValue, SortByString};
+    use crate::collector::{ComparableDoc, DocSetCollector, TopDocs};
+    use crate::indexer::NoMergePolicy;
+    use crate::query::{AllQuery, QueryParser};
+    use crate::schema::{Schema, FAST, TEXT};
+    use crate::{DocAddress, Document, Index, Order, Score, Searcher};
+
+    fn make_index() -> crate::Result<Index> {
+        let mut schema_builder = Schema::builder();
+        let id = schema_builder.add_u64_field("id", FAST);
+        let city = schema_builder.add_text_field("city", TEXT | FAST);
+        let catchphrase = schema_builder.add_text_field("catchphrase", TEXT);
+        let altitude = schema_builder.add_f64_field("altitude", FAST);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+
+        fn create_segment(index: &Index, docs: Vec<impl Document>) -> crate::Result<()> {
+            let mut index_writer = index.writer_for_tests()?;
+            index_writer.set_merge_policy(Box::new(NoMergePolicy));
+            for doc in docs {
+                index_writer.add_document(doc)?;
+            }
+            index_writer.commit()?;
+            Ok(())
+        }
+
+        create_segment(
+            &index,
+            vec![
+                doc!(
+                    id => 0_u64,
+                    city => "austin",
+                    catchphrase => "Hills, Barbeque, Glow",
+                    altitude => 149.0,
+                ),
+                doc!(
+                    id => 1_u64,
+                    city => "greenville",
+                    catchphrase => "Grow, Glow, Glow",
+                    altitude => 27.0,
+                ),
+            ],
+        )?;
+        create_segment(
+            &index,
+            vec![doc!(
+                id => 2_u64,
+                city => "tokyo",
+                catchphrase => "Glow, Glow, Glow",
+                altitude => 40.0,
+            )],
+        )?;
+        create_segment(
+            &index,
+            vec![doc!(
+                id => 3_u64,
+                catchphrase => "No, No, No",
+                altitude => 0.0,
+            )],
+        )?;
+        Ok(index)
+    }
+
+    // NOTE: You cannot determine the SegmentIds that will be generated for Segments
+    // ahead of time, so DocAddresses must be mapped back to a unique id for each Searcher.
+    fn id_mapping(searcher: &Searcher) -> HashMap<DocAddress, u64> {
+        searcher
+            .search(&AllQuery, &DocSetCollector)
+            .unwrap()
+            .into_iter()
+            .map(|doc_address| {
+                let column = searcher.segment_readers()[doc_address.segment_ord as usize]
+                    .fast_fields()
+                    .u64("id")
+                    .unwrap();
+                (doc_address, column.first(doc_address.doc_id).unwrap())
+            })
+            .collect()
+    }
+
+    #[test]
+    fn test_order_by_string() -> crate::Result<()> {
+        let index = make_index()?;
+
+        #[track_caller]
+        fn assert_query(
+            index: &Index,
+            order: Order,
+            doc_range: Range<usize>,
+            expected: Vec<(Option<String>, u64)>,
+        ) -> crate::Result<()> {
+            let searcher = index.reader()?.searcher();
+            let ids = id_mapping(&searcher);
+
+            // Try as primitive.
+            let top_collector = TopDocs::for_doc_range(doc_range)
+                .order_by((SortByString::for_field("city"), order));
+            let actual = searcher
+                .search(&AllQuery, &top_collector)?
+                .into_iter()
+                .map(|(sort_key_opt, doc)| (sort_key_opt, ids[&doc]))
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+            Ok(())
+        }
+
+        assert_query(
+            &index,
+            Order::Asc,
+            0..4,
+            vec![
+                (Some("austin".to_owned()), 0),
+                (Some("greenville".to_owned()), 1),
+                (Some("tokyo".to_owned()), 2),
+                (None, 3),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Asc,
+            0..3,
+            vec![
+                (Some("austin".to_owned()), 0),
+                (Some("greenville".to_owned()), 1),
+                (Some("tokyo".to_owned()), 2),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Asc,
+            0..2,
+            vec![
+                (Some("austin".to_owned()), 0),
+                (Some("greenville".to_owned()), 1),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Asc,
+            0..1,
+            vec![(Some("austin".to_string()), 0)],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Asc,
+            1..3,
+            vec![
+                (Some("greenville".to_owned()), 1),
+                (Some("tokyo".to_owned()), 2),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Desc,
+            0..4,
+            vec![
+                (Some("tokyo".to_owned()), 2),
+                (Some("greenville".to_owned()), 1),
+                (Some("austin".to_owned()), 0),
+                (None, 3),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Desc,
+            1..3,
+            vec![
+                (Some("greenville".to_owned()), 1),
+                (Some("austin".to_owned()), 0),
+            ],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Desc,
+            0..1,
+            vec![(Some("tokyo".to_owned()), 2)],
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_order_by_f64() -> crate::Result<()> {
+        let index = make_index()?;
+
+        fn assert_query(
+            index: &Index,
+            order: Order,
+            expected: Vec<(Option<f64>, u64)>,
+        ) -> crate::Result<()> {
+            let searcher = index.reader()?.searcher();
+            let ids = id_mapping(&searcher);
+
+            // Try as primitive.
+            let top_collector = TopDocs::with_limit(3)
+                .order_by((SortByStaticFastValue::<f64>::for_field("altitude"), order));
+            let actual = searcher
+                .search(&AllQuery, &top_collector)?
+                .into_iter()
+                .map(|(altitude_opt, doc)| (altitude_opt, ids[&doc]))
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+
+            Ok(())
+        }
+
+        assert_query(
+            &index,
+            Order::Asc,
+            vec![(Some(0.0), 3), (Some(27.0), 1), (Some(40.0), 2)],
+        )?;
+
+        assert_query(
+            &index,
+            Order::Desc,
+            vec![(Some(149.0), 0), (Some(40.0), 2), (Some(27.0), 1)],
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_order_by_score() -> crate::Result<()> {
+        let index = make_index()?;
+
+        fn query(index: &Index, order: Order) -> crate::Result<Vec<(Score, u64)>> {
+            let searcher = index.reader()?.searcher();
+            let ids = id_mapping(&searcher);
+
+            let top_collector = TopDocs::with_limit(4).order_by((SortBySimilarityScore, order));
+            let field = index.schema().get_field("catchphrase").unwrap();
+            let query_parser = QueryParser::for_index(index, vec![field]);
+            let text_query = query_parser.parse_query("glow")?;
+
+            Ok(searcher
+                .search(&text_query, &top_collector)?
+                .into_iter()
+                .map(|(score, doc)| (score, ids[&doc]))
+                .collect())
+        }
+
+        assert_eq!(
+            &query(&index, Order::Desc)?,
+            &[(0.5604893, 2), (0.4904281, 1), (0.35667497, 0),]
+        );
+
+        assert_eq!(
+            &query(&index, Order::Asc)?,
+            &[(0.35667497, 0), (0.4904281, 1), (0.5604893, 2),]
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_order_by_score_then_string() -> crate::Result<()> {
+        let index = make_index()?;
+
+        type SortKey = (Score, Option<String>);
+
+        fn query(
+            index: &Index,
+            score_order: Order,
+            city_order: Order,
+        ) -> crate::Result<Vec<(SortKey, u64)>> {
+            let searcher = index.reader()?.searcher();
+            let ids = id_mapping(&searcher);
+
+            let top_collector = TopDocs::with_limit(4).order_by((
+                (SortBySimilarityScore, score_order),
+                (SortByString::for_field("city"), city_order),
+            ));
+            Ok(searcher
+                .search(&AllQuery, &top_collector)?
+                .into_iter()
+                .map(|(f, doc)| (f, ids[&doc]))
+                .collect())
+        }
+
+        assert_eq!(
+            &query(&index, Order::Asc, Order::Asc)?,
+            &[
+                ((1.0, Some("austin".to_owned())), 0),
+                ((1.0, Some("greenville".to_owned())), 1),
+                ((1.0, Some("tokyo".to_owned())), 2),
+                ((1.0, None), 3),
+            ]
+        );
+
+        assert_eq!(
+            &query(&index, Order::Asc, Order::Desc)?,
+            &[
+                ((1.0, Some("tokyo".to_owned())), 2),
+                ((1.0, Some("greenville".to_owned())), 1),
+                ((1.0, Some("austin".to_owned())), 0),
+                ((1.0, None), 3),
+            ]
+        );
+        Ok(())
+    }
+
+    use proptest::prelude::*;
+
+    proptest! {
+    #[test]
+    fn test_order_by_string_prop(
+          order in prop_oneof!(Just(Order::Desc), Just(Order::Asc)),
+          limit in 1..64_usize,
+          offset in 0..64_usize,
+          segments_terms in
+            proptest::collection::vec(
+                proptest::collection::vec(0..32_u8, 1..32_usize),
+                0..8_usize,
+            )
+        ) {
+            let mut schema_builder = Schema::builder();
+            let city = schema_builder.add_text_field("city", TEXT | FAST);
+            let schema = schema_builder.build();
+            let index = Index::create_in_ram(schema);
+            let mut index_writer = index.writer_for_tests()?;
+
+            // A Vec<Vec<u8>>, where the outer Vec represents segments, and the inner Vec
+            // represents terms.
+            for segment_terms in segments_terms.into_iter() {
+                for term in segment_terms.into_iter() {
+                    let term = format!("{term:0>3}");
+                    index_writer.add_document(doc!(
+                        city => term,
+                    ))?;
+                }
+                index_writer.commit()?;
+            }
+
+            let searcher = index.reader()?.searcher();
+            let top_n_results = searcher.search(&AllQuery, &TopDocs::with_limit(limit)
+                .and_offset(offset)
+                .order_by_string_fast_field("city", order))?;
+            let all_results = searcher.search(&AllQuery, &DocSetCollector)?.into_iter().map(|doc_address| {
+                // Get the term for this address.
+                let column = searcher.segment_readers()[doc_address.segment_ord as usize].fast_fields().str("city").unwrap().unwrap();
+                let value = column.term_ords(doc_address.doc_id).next().map(|term_ord| {
+                    let mut city = Vec::new();
+                    column.dictionary().ord_to_term(term_ord, &mut city).unwrap();
+                    String::try_from(city).unwrap()
+                });
+                (value, doc_address)
+            });
+
+            // Using the TopDocs collector should always be equivalent to sorting, skipping the
+            // offset, and then taking the limit.
+            let sorted_docs: Vec<_> = if order.is_desc() {
+                let mut comparable_docs: Vec<ComparableDoc<_, _, true>> =
+                    all_results.into_iter().map(|(sort_key, doc)| ComparableDoc { sort_key, doc}).collect();
+                comparable_docs.sort();
+                comparable_docs.into_iter().map(|cd| (cd.sort_key, cd.doc)).collect()
+            } else {
+                let mut comparable_docs: Vec<ComparableDoc<_, _, false>> =
+                    all_results.into_iter().map(|(sort_key, doc)| ComparableDoc { sort_key, doc}).collect();
+                comparable_docs.sort();
+                comparable_docs.into_iter().map(|cd| (cd.sort_key, cd.doc)).collect()
+            };
+            let expected_docs = sorted_docs.into_iter().skip(offset).take(limit).collect::<Vec<_>>();
+            prop_assert_eq!(
+                expected_docs,
+                top_n_results
+            );
+        }
+    }
+}

src/collector/sort_key/order.rs

@@ -0,0 +1,348 @@
+use std::cmp::Ordering;
+
+use serde::{Deserialize, Serialize};
+
+use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
+use crate::schema::Schema;
+use crate::{DocId, Order, Score};
+
+/// Comparator trait defining the order in which documents should be ordered.
+pub trait Comparator<T>: Send + Sync + std::fmt::Debug + Default {
+    /// Return the order between two values.
+    fn compare(&self, lhs: &T, rhs: &T) -> Ordering;
+}
+
+/// With the natural comparator, the top k collector will return
+/// the top documents in decreasing order.
+#[derive(Debug, Copy, Clone, Default, Serialize, Deserialize)]
+pub struct NaturalComparator;
+
+impl<T: PartialOrd> Comparator<T> for NaturalComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &T, rhs: &T) -> Ordering {
+        lhs.partial_cmp(rhs).unwrap()
+    }
+}
+
+/// Sorts document in reverse order.
+///
+/// If the sort key is None, it will considered as the lowest value, and will therefore appear
+/// first.
+///
+/// The ReverseComparator does not necessarily imply that the sort order is reversed compared
+/// to the NaturalComparator. In presence of a tie, both version will retain the higher doc ids.
+#[derive(Debug, Copy, Clone, Default, Serialize, Deserialize)]
+pub struct ReverseComparator;
+
+impl<T> Comparator<T> for ReverseComparator
+where NaturalComparator: Comparator<T>
+{
+    #[inline(always)]
+    fn compare(&self, lhs: &T, rhs: &T) -> Ordering {
+        NaturalComparator.compare(rhs, lhs)
+    }
+}
+
+/// Sorts document in reverse order, but considers None as having the lowest value.
+///
+/// This is usually what is wanted when sorting by a field in an ascending order.
+/// For instance, in a e-commerce website, if I sort by price ascending, I most likely want the
+/// cheapest items first, and the items without a price at last.
+#[derive(Debug, Copy, Clone, Default)]
+pub struct ReverseNoneIsLowerComparator;
+
+impl<T> Comparator<Option<T>> for ReverseNoneIsLowerComparator
+where ReverseComparator: Comparator<T>
+{
+    #[inline(always)]
+    fn compare(&self, lhs_opt: &Option<T>, rhs_opt: &Option<T>) -> Ordering {
+        match (lhs_opt, rhs_opt) {
+            (None, None) => Ordering::Equal,
+            (None, Some(_)) => Ordering::Less,
+            (Some(_), None) => Ordering::Greater,
+            (Some(lhs), Some(rhs)) => ReverseComparator.compare(lhs, rhs),
+        }
+    }
+}
+
+impl Comparator<u32> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &u32, rhs: &u32) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+impl Comparator<u64> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &u64, rhs: &u64) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+impl Comparator<f64> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &f64, rhs: &f64) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+impl Comparator<f32> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &f32, rhs: &f32) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+impl Comparator<i64> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &i64, rhs: &i64) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+impl Comparator<String> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &String, rhs: &String) -> Ordering {
+        ReverseComparator.compare(lhs, rhs)
+    }
+}
+
+/// An enum representing the different sort orders.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+pub enum ComparatorEnum {
+    /// Natural order (See [NaturalComparator])
+    #[default]
+    Natural,
+    /// Reverse order (See [ReverseComparator])
+    Reverse,
+    /// Reverse order by treating None as the lowest value.(See [ReverseNoneLowerComparator])
+    ReverseNoneLower,
+}
+
+impl From<Order> for ComparatorEnum {
+    fn from(order: Order) -> Self {
+        match order {
+            Order::Asc => ComparatorEnum::ReverseNoneLower,
+            Order::Desc => ComparatorEnum::Natural,
+        }
+    }
+}
+
+impl<T> Comparator<T> for ComparatorEnum
+where
+    ReverseNoneIsLowerComparator: Comparator<T>,
+    NaturalComparator: Comparator<T>,
+    ReverseComparator: Comparator<T>,
+{
+    #[inline(always)]
+    fn compare(&self, lhs: &T, rhs: &T) -> Ordering {
+        match self {
+            ComparatorEnum::Natural => NaturalComparator.compare(lhs, rhs),
+            ComparatorEnum::Reverse => ReverseComparator.compare(lhs, rhs),
+            ComparatorEnum::ReverseNoneLower => ReverseNoneIsLowerComparator.compare(lhs, rhs),
+        }
+    }
+}
+
+impl<Head, Tail, LeftComparator, RightComparator> Comparator<(Head, Tail)>
+    for (LeftComparator, RightComparator)
+where
+    LeftComparator: Comparator<Head>,
+    RightComparator: Comparator<Tail>,
+{
+    #[inline(always)]
+    fn compare(&self, lhs: &(Head, Tail), rhs: &(Head, Tail)) -> Ordering {
+        self.0
+            .compare(&lhs.0, &rhs.0)
+            .then_with(|| self.1.compare(&lhs.1, &rhs.1))
+    }
+}
+
+impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, (Type2, Type3))>
+    for (Comparator1, Comparator2, Comparator3)
+where
+    Comparator1: Comparator<Type1>,
+    Comparator2: Comparator<Type2>,
+    Comparator3: Comparator<Type3>,
+{
+    #[inline(always)]
+    fn compare(&self, lhs: &(Type1, (Type2, Type3)), rhs: &(Type1, (Type2, Type3))) -> Ordering {
+        self.0
+            .compare(&lhs.0, &rhs.0)
+            .then_with(|| self.1.compare(&lhs.1 .0, &rhs.1 .0))
+            .then_with(|| self.2.compare(&lhs.1 .1, &rhs.1 .1))
+    }
+}
+
+impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, Type2, Type3)>
+    for (Comparator1, Comparator2, Comparator3)
+where
+    Comparator1: Comparator<Type1>,
+    Comparator2: Comparator<Type2>,
+    Comparator3: Comparator<Type3>,
+{
+    #[inline(always)]
+    fn compare(&self, lhs: &(Type1, Type2, Type3), rhs: &(Type1, Type2, Type3)) -> Ordering {
+        self.0
+            .compare(&lhs.0, &rhs.0)
+            .then_with(|| self.1.compare(&lhs.1, &rhs.1))
+            .then_with(|| self.2.compare(&lhs.2, &rhs.2))
+    }
+}
+
+impl<Type1, Type2, Type3, Type4, Comparator1, Comparator2, Comparator3, Comparator4>
+    Comparator<(Type1, (Type2, (Type3, Type4)))>
+    for (Comparator1, Comparator2, Comparator3, Comparator4)
+where
+    Comparator1: Comparator<Type1>,
+    Comparator2: Comparator<Type2>,
+    Comparator3: Comparator<Type3>,
+    Comparator4: Comparator<Type4>,
+{
+    #[inline(always)]
+    fn compare(
+        &self,
+        lhs: &(Type1, (Type2, (Type3, Type4))),
+        rhs: &(Type1, (Type2, (Type3, Type4))),
+    ) -> Ordering {
+        self.0
+            .compare(&lhs.0, &rhs.0)
+            .then_with(|| self.1.compare(&lhs.1 .0, &rhs.1 .0))
+            .then_with(|| self.2.compare(&lhs.1 .1 .0, &rhs.1 .1 .0))
+            .then_with(|| self.3.compare(&lhs.1 .1 .1, &rhs.1 .1 .1))
+    }
+}
+
+impl<Type1, Type2, Type3, Type4, Comparator1, Comparator2, Comparator3, Comparator4>
+    Comparator<(Type1, Type2, Type3, Type4)>
+    for (Comparator1, Comparator2, Comparator3, Comparator4)
+where
+    Comparator1: Comparator<Type1>,
+    Comparator2: Comparator<Type2>,
+    Comparator3: Comparator<Type3>,
+    Comparator4: Comparator<Type4>,
+{
+    #[inline(always)]
+    fn compare(
+        &self,
+        lhs: &(Type1, Type2, Type3, Type4),
+        rhs: &(Type1, Type2, Type3, Type4),
+    ) -> Ordering {
+        self.0
+            .compare(&lhs.0, &rhs.0)
+            .then_with(|| self.1.compare(&lhs.1, &rhs.1))
+            .then_with(|| self.2.compare(&lhs.2, &rhs.2))
+            .then_with(|| self.3.compare(&lhs.3, &rhs.3))
+    }
+}
+
+impl<TSortKeyComputer> SortKeyComputer for (TSortKeyComputer, ComparatorEnum)
+where
+    TSortKeyComputer: SortKeyComputer,
+    ComparatorEnum: Comparator<TSortKeyComputer::SortKey>,
+    ComparatorEnum: Comparator<
+        <<TSortKeyComputer as SortKeyComputer>::Child as SegmentSortKeyComputer>::SegmentSortKey,
+    >,
+{
+    type SortKey = TSortKeyComputer::SortKey;
+
+    type Child = SegmentSortKeyComputerWithComparator<TSortKeyComputer::Child, Self::Comparator>;
+
+    type Comparator = ComparatorEnum;
+
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)
+    }
+
+    fn requires_scoring(&self) -> bool {
+        self.0.requires_scoring()
+    }
+
+    fn comparator(&self) -> Self::Comparator {
+        self.1
+    }
+
+    fn segment_sort_key_computer(
+        &self,
+        segment_reader: &crate::SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        let child = self.0.segment_sort_key_computer(segment_reader)?;
+        Ok(SegmentSortKeyComputerWithComparator {
+            segment_sort_key_computer: child,
+            comparator: self.comparator(),
+        })
+    }
+}
+
+impl<TSortKeyComputer> SortKeyComputer for (TSortKeyComputer, Order)
+where
+    TSortKeyComputer: SortKeyComputer,
+    ComparatorEnum: Comparator<TSortKeyComputer::SortKey>,
+    ComparatorEnum: Comparator<
+        <<TSortKeyComputer as SortKeyComputer>::Child as SegmentSortKeyComputer>::SegmentSortKey,
+    >,
+{
+    type SortKey = TSortKeyComputer::SortKey;
+
+    type Child = SegmentSortKeyComputerWithComparator<TSortKeyComputer::Child, Self::Comparator>;
+
+    type Comparator = ComparatorEnum;
+
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)
+    }
+
+    fn requires_scoring(&self) -> bool {
+        self.0.requires_scoring()
+    }
+
+    fn comparator(&self) -> Self::Comparator {
+        self.1.into()
+    }
+
+    fn segment_sort_key_computer(
+        &self,
+        segment_reader: &crate::SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        let child = self.0.segment_sort_key_computer(segment_reader)?;
+        Ok(SegmentSortKeyComputerWithComparator {
+            segment_sort_key_computer: child,
+            comparator: self.comparator(),
+        })
+    }
+}
+
+/// A segment sort key computer with a custom ordering.
+pub struct SegmentSortKeyComputerWithComparator<TSegmentSortKeyComputer, TComparator> {
+    segment_sort_key_computer: TSegmentSortKeyComputer,
+    comparator: TComparator,
+}
+
+impl<TSegmentSortKeyComputer, TSegmentSortKey, TComparator> SegmentSortKeyComputer
+    for SegmentSortKeyComputerWithComparator<TSegmentSortKeyComputer, TComparator>
+where
+    TSegmentSortKeyComputer: SegmentSortKeyComputer<SegmentSortKey = TSegmentSortKey>,
+    TSegmentSortKey: PartialOrd + Clone + 'static + Sync + Send,
+    TComparator: Comparator<TSegmentSortKey> + 'static + Sync + Send,
+{
+    type SortKey = TSegmentSortKeyComputer::SortKey;
+    type SegmentSortKey = TSegmentSortKey;
+
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey {
+        self.segment_sort_key_computer.segment_sort_key(doc, score)
+    }
+
+    #[inline(always)]
+    fn compare_segment_sort_key(
+        &self,
+        left: &Self::SegmentSortKey,
+        right: &Self::SegmentSortKey,
+    ) -> Ordering {
+        self.comparator.compare(left, right)
+    }
+
+    fn convert_segment_sort_key(&self, sort_key: Self::SegmentSortKey) -> Self::SortKey {
+        self.segment_sort_key_computer
+            .convert_segment_sort_key(sort_key)
+    }
+}

src/collector/sort_key/sort_by_score.rs

@@ -0,0 +1,77 @@
+use crate::collector::sort_key::NaturalComparator;
+use crate::collector::{SegmentSortKeyComputer, SortKeyComputer, TopNComputer};
+use crate::{DocAddress, DocId, Score};
+
+/// Sort by similarity score.
+#[derive(Clone, Debug, Copy)]
+pub struct SortBySimilarityScore;
+
+impl SortKeyComputer for SortBySimilarityScore {
+    type SortKey = Score;
+
+    type Child = SortBySimilarityScore;
+
+    type Comparator = NaturalComparator;
+
+    fn requires_scoring(&self) -> bool {
+        true
+    }
+
+    fn segment_sort_key_computer(
+        &self,
+        _segment_reader: &crate::SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        Ok(SortBySimilarityScore)
+    }
+
+    // Sorting by score is special in that it allows for the Block-Wand optimization.
+    fn collect_segment_top_k(
+        &self,
+        k: usize,
+        weight: &dyn crate::query::Weight,
+        reader: &crate::SegmentReader,
+        segment_ord: u32,
+    ) -> crate::Result<Vec<(Self::SortKey, DocAddress)>> {
+        let mut top_n: TopNComputer<Score, DocId, Self::Comparator> =
+            TopNComputer::new_with_comparator(k, self.comparator());
+
+        if let Some(alive_bitset) = reader.alive_bitset() {
+            let mut threshold = Score::MIN;
+            top_n.threshold = Some(threshold);
+            weight.for_each_pruning(Score::MIN, reader, &mut |doc, score| {
+                if alive_bitset.is_deleted(doc) {
+                    return threshold;
+                }
+                top_n.push(score, doc);
+                threshold = top_n.threshold.unwrap_or(Score::MIN);
+                threshold
+            })?;
+        } else {
+            weight.for_each_pruning(Score::MIN, reader, &mut |doc, score| {
+                top_n.push(score, doc);
+                top_n.threshold.unwrap_or(Score::MIN)
+            })?;
+        }
+
+        Ok(top_n
+            .into_vec()
+            .into_iter()
+            .map(|cid| (cid.sort_key, DocAddress::new(segment_ord, cid.doc)))
+            .collect())
+    }
+}
+
+impl SegmentSortKeyComputer for SortBySimilarityScore {
+    type SortKey = Score;
+
+    type SegmentSortKey = Score;
+
+    #[inline(always)]
+    fn segment_sort_key(&mut self, _doc: DocId, score: Score) -> Score {
+        score
+    }
+
+    fn convert_segment_sort_key(&self, score: Score) -> Score {
+        score
+    }
+}

src/collector/sort_key/sort_by_static_fast_value.rs

@@ -0,0 +1,98 @@
+use std::marker::PhantomData;
+
+use columnar::Column;
+
+use crate::collector::sort_key::NaturalComparator;
+use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
+use crate::fastfield::{FastFieldNotAvailableError, FastValue};
+use crate::{DocId, Score, SegmentReader};
+
+/// Sorts by a fast value (u64, i64, f64, bool).
+///
+/// The field must appear explicitly in the schema, with the right type, and declared as
+/// a fast field..
+///
+/// If the field is multivalued, only the first value is considered.
+///
+/// Documents that do not have this value are still considered.
+/// Their sort key will simply be `None`.
+#[derive(Debug, Clone)]
+pub struct SortByStaticFastValue<T: FastValue> {
+    field: String,
+    typ: PhantomData<T>,
+}
+
+impl<T: FastValue> SortByStaticFastValue<T> {
+    /// Creates a new `SortByStaticFastValue` instance for the given field.
+    pub fn for_field(column_name: impl ToString) -> SortByStaticFastValue<T> {
+        Self {
+            field: column_name.to_string(),
+            typ: PhantomData,
+        }
+    }
+}
+
+impl<T: FastValue> SortKeyComputer for SortByStaticFastValue<T> {
+    type Child = SortByFastValueSegmentSortKeyComputer<T>;
+
+    type SortKey = Option<T>;
+
+    type Comparator = NaturalComparator;
+
+    fn check_schema(&self, schema: &crate::schema::Schema) -> crate::Result<()> {
+        // At the segment sort key computer level, we rely on the u64 representation.
+        // The mapping is monotonic, so it is sufficient to compute our top-K docs.
+        let field = schema.get_field(&self.field)?;
+        let field_entry = schema.get_field_entry(field);
+        if !field_entry.is_fast() {
+            return Err(crate::TantivyError::SchemaError(format!(
+                "Field `{}` is not a fast field.",
+                self.field,
+            )));
+        }
+        let schema_type = field_entry.field_type().value_type();
+        if schema_type != T::to_type() {
+            return Err(crate::TantivyError::SchemaError(format!(
+                "Field `{}` is of type {schema_type:?}, not of the type {:?}.",
+                &self.field,
+                T::to_type()
+            )));
+        }
+        Ok(())
+    }
+
+    fn segment_sort_key_computer(
+        &self,
+        segment_reader: &SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        let sort_column_opt = segment_reader.fast_fields().u64_lenient(&self.field)?;
+        let (sort_column, _sort_column_type) =
+            sort_column_opt.ok_or_else(|| FastFieldNotAvailableError {
+                field_name: self.field.clone(),
+            })?;
+        Ok(SortByFastValueSegmentSortKeyComputer {
+            sort_column,
+            typ: PhantomData,
+        })
+    }
+}
+
+pub struct SortByFastValueSegmentSortKeyComputer<T> {
+    sort_column: Column<u64>,
+    typ: PhantomData<T>,
+}
+
+impl<T: FastValue> SegmentSortKeyComputer for SortByFastValueSegmentSortKeyComputer<T> {
+    type SortKey = Option<T>;
+
+    type SegmentSortKey = Option<u64>;
+
+    #[inline(always)]
+    fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> Self::SegmentSortKey {
+        self.sort_column.first(doc)
+    }
+
+    fn convert_segment_sort_key(&self, sort_key: Self::SegmentSortKey) -> Self::SortKey {
+        sort_key.map(T::from_u64)
+    }
+}

src/collector/sort_key/sort_by_string.rs

@@ -0,0 +1,72 @@
+use columnar::StrColumn;
+
+use crate::collector::sort_key::NaturalComparator;
+use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
+use crate::termdict::TermOrdinal;
+use crate::{DocId, Score};
+
+/// Sort by the first value of a string column.
+///
+/// The string can be dynamic (coming from a json field)
+/// or static (being specificaly defined in the configuration).
+///
+/// If the field is multivalued, only the first value is considered.
+///
+/// Documents that do not have this value are still considered.
+/// Their sort key will simply be `None`.
+#[derive(Debug, Clone)]
+pub struct SortByString {
+    column_name: String,
+}
+
+impl SortByString {
+    /// Creates a new sort by string sort key computer.
+    pub fn for_field(column_name: impl ToString) -> Self {
+        SortByString {
+            column_name: column_name.to_string(),
+        }
+    }
+}
+
+impl SortKeyComputer for SortByString {
+    type SortKey = Option<String>;
+
+    type Child = ByStringColumnSegmentSortKeyComputer;
+
+    type Comparator = NaturalComparator;
+
+    fn segment_sort_key_computer(
+        &self,
+        segment_reader: &crate::SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        let str_column_opt = segment_reader.fast_fields().str(&self.column_name)?;
+        Ok(ByStringColumnSegmentSortKeyComputer { str_column_opt })
+    }
+}
+
+pub struct ByStringColumnSegmentSortKeyComputer {
+    str_column_opt: Option<StrColumn>,
+}
+
+impl SegmentSortKeyComputer for ByStringColumnSegmentSortKeyComputer {
+    type SortKey = Option<String>;
+
+    type SegmentSortKey = Option<TermOrdinal>;
+
+    #[inline(always)]
+    fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> Option<TermOrdinal> {
+        let str_column = self.str_column_opt.as_ref()?;
+        str_column.ords().first(doc)
+    }
+
+    fn convert_segment_sort_key(&self, term_ord_opt: Option<TermOrdinal>) -> Option<String> {
+        let term_ord = term_ord_opt?;
+        let str_column = self.str_column_opt.as_ref()?;
+        let mut bytes = Vec::new();
+        str_column
+            .dictionary()
+            .ord_to_term(term_ord, &mut bytes)
+            .ok()?;
+        String::try_from(bytes).ok()
+    }
+}

src/collector/sort_key/sort_key_computer.rs

@@ -0,0 +1,631 @@
+use std::cmp::Ordering;
+
+use crate::collector::sort_key::{Comparator, NaturalComparator};
+use crate::collector::sort_key_top_collector::TopBySortKeySegmentCollector;
+use crate::collector::{default_collect_segment_impl, SegmentCollector as _, TopNComputer};
+use crate::schema::Schema;
+use crate::{DocAddress, DocId, Result, Score, SegmentReader};
+
+/// A `SegmentSortKeyComputer` makes it possible to modify the default score
+/// for a given document belonging to a specific segment.
+///
+/// It is the segment local version of the [`SortKeyComputer`].
+pub trait SegmentSortKeyComputer: 'static {
+    /// The final score being emitted.
+    type SortKey: 'static + PartialOrd + Send + Sync + Clone;
+
+    /// Sort key used by at the segment level by the `SegmentSortKeyComputer`.
+    ///
+    /// It is typically small like a `u64`, and is meant to be converted
+    /// to the final score at the end of the collection of the segment.
+    type SegmentSortKey: 'static + PartialOrd + Clone + Send + Sync + Clone;
+
+    /// Computes the sort key for the given document and score.
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey;
+
+    /// Computes the sort key and pushes the document in a TopN Computer.
+    ///
+    /// When using a tuple as the sorting key, the sort key is evaluated in a lazy manner.
+    #[inline(always)]
+    fn compute_sort_key_and_collect<C: Comparator<Self::SegmentSortKey>>(
+        &mut self,
+        doc: DocId,
+        score: Score,
+        top_n_computer: &mut TopNComputer<Self::SegmentSortKey, DocId, C>,
+    ) {
+        let sort_key = self.segment_sort_key(doc, score);
+        top_n_computer.push(sort_key, doc);
+    }
+
+    /// A SegmentSortKeyComputer maps to a SegmentSortKey, but it can also decide on
+    /// its ordering.
+    ///
+    /// This method must be consistent with the `SortKey` ordering.
+    #[inline(always)]
+    fn compare_segment_sort_key(
+        &self,
+        left: &Self::SegmentSortKey,
+        right: &Self::SegmentSortKey,
+    ) -> Ordering {
+        NaturalComparator.compare(left, right)
+    }
+
+    /// Implementing this method makes it possible to avoid computing
+    /// a sort_key entirely if we can assess that it won't pass a threshold
+    /// with a partial computation.
+    ///
+    /// This is currently used for lexicographic sorting.
+    fn accept_sort_key_lazy(
+        &mut self,
+        doc_id: DocId,
+        score: Score,
+        threshold: &Self::SegmentSortKey,
+    ) -> Option<(Ordering, Self::SegmentSortKey)> {
+        let sort_key = self.segment_sort_key(doc_id, score);
+        let cmp = self.compare_segment_sort_key(&sort_key, threshold);
+        if cmp == Ordering::Less {
+            None
+        } else {
+            Some((cmp, sort_key))
+        }
+    }
+
+    /// Convert a segment level sort key into the global sort key.
+    fn convert_segment_sort_key(&self, sort_key: Self::SegmentSortKey) -> Self::SortKey;
+}
+
+/// `SortKeyComputer` defines the sort key to be used by a TopK Collector.
+///
+/// The `SortKeyComputer` itself does not make much of the computation itself.
+/// Instead, it helps constructing `Self::Child` instances that will compute
+/// the sort key at a segment scale.
+pub trait SortKeyComputer: Sync {
+    /// The sort key type.
+    type SortKey: 'static + Send + Sync + PartialOrd + Clone + std::fmt::Debug;
+    /// Type of the associated [`SegmentSortKeyComputer`].
+    type Child: SegmentSortKeyComputer<SortKey = Self::SortKey>;
+    /// Comparator type.
+    type Comparator: Comparator<Self::SortKey>
+        + Comparator<<Self::Child as SegmentSortKeyComputer>::SegmentSortKey>
+        + 'static;
+
+    /// Checks whether the schema is compatible with the sort key computer.
+    fn check_schema(&self, _schema: &Schema) -> crate::Result<()> {
+        Ok(())
+    }
+
+    /// Returns the sort key comparator.
+    fn comparator(&self) -> Self::Comparator {
+        Self::Comparator::default()
+    }
+
+    /// Indicates whether the sort key actually uses the similarity score (by default BM25).
+    /// If set to false, the similary score might not be computed (as an optimization),
+    /// and the score fed in the segment sort key computer could take any value.
+    fn requires_scoring(&self) -> bool {
+        false
+    }
+
+    /// Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
+    fn collect_segment_top_k(
+        &self,
+        k: usize,
+        weight: &dyn crate::query::Weight,
+        reader: &crate::SegmentReader,
+        segment_ord: u32,
+    ) -> crate::Result<Vec<(Self::SortKey, DocAddress)>> {
+        let with_scoring = self.requires_scoring();
+        let segment_sort_key_computer = self.segment_sort_key_computer(reader)?;
+        let topn_computer = TopNComputer::new_with_comparator(k, self.comparator());
+        let mut segment_top_key_collector = TopBySortKeySegmentCollector {
+            topn_computer,
+            segment_ord,
+            segment_sort_key_computer,
+        };
+        default_collect_segment_impl(&mut segment_top_key_collector, weight, reader, with_scoring)?;
+        Ok(segment_top_key_collector.harvest())
+    }
+
+    /// Builds a child sort key computer for a specific segment.
+    fn segment_sort_key_computer(&self, segment_reader: &SegmentReader) -> Result<Self::Child>;
+}
+
+impl<HeadSortKeyComputer, TailSortKeyComputer> SortKeyComputer
+    for (HeadSortKeyComputer, TailSortKeyComputer)
+where
+    HeadSortKeyComputer: SortKeyComputer,
+    TailSortKeyComputer: SortKeyComputer,
+{
+    type SortKey = (
+        <HeadSortKeyComputer::Child as SegmentSortKeyComputer>::SortKey,
+        <TailSortKeyComputer::Child as SegmentSortKeyComputer>::SortKey,
+    );
+    type Child = (HeadSortKeyComputer::Child, TailSortKeyComputer::Child);
+
+    type Comparator = (
+        HeadSortKeyComputer::Comparator,
+        TailSortKeyComputer::Comparator,
+    );
+
+    fn comparator(&self) -> Self::Comparator {
+        (self.0.comparator(), self.1.comparator())
+    }
+
+    fn segment_sort_key_computer(&self, segment_reader: &SegmentReader) -> Result<Self::Child> {
+        Ok((
+            self.0.segment_sort_key_computer(segment_reader)?,
+            self.1.segment_sort_key_computer(segment_reader)?,
+        ))
+    }
+
+    /// Checks whether the schema is compatible with the sort key computer.
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        Ok(())
+    }
+
+    /// Indicates whether the sort key actually uses the similarity score (by default BM25).
+    /// If set to false, the similary score might not be computed (as an optimization),
+    /// and the score fed in the segment sort key computer could take any value.
+    fn requires_scoring(&self) -> bool {
+        self.0.requires_scoring() || self.1.requires_scoring()
+    }
+}
+
+impl<HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer> SegmentSortKeyComputer
+    for (HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer)
+where
+    HeadSegmentSortKeyComputer: SegmentSortKeyComputer,
+    TailSegmentSortKeyComputer: SegmentSortKeyComputer,
+{
+    type SortKey = (
+        HeadSegmentSortKeyComputer::SortKey,
+        TailSegmentSortKeyComputer::SortKey,
+    );
+    type SegmentSortKey = (
+        HeadSegmentSortKeyComputer::SegmentSortKey,
+        TailSegmentSortKeyComputer::SegmentSortKey,
+    );
+
+    /// A SegmentSortKeyComputer maps to a SegmentSortKey, but it can also decide on
+    /// its ordering.
+    ///
+    /// By default, it uses the natural ordering.
+    #[inline]
+    fn compare_segment_sort_key(
+        &self,
+        left: &Self::SegmentSortKey,
+        right: &Self::SegmentSortKey,
+    ) -> Ordering {
+        self.0
+            .compare_segment_sort_key(&left.0, &right.0)
+            .then_with(|| self.1.compare_segment_sort_key(&left.1, &right.1))
+    }
+
+    #[inline(always)]
+    fn compute_sort_key_and_collect<C: Comparator<Self::SegmentSortKey>>(
+        &mut self,
+        doc: DocId,
+        score: Score,
+        top_n_computer: &mut TopNComputer<Self::SegmentSortKey, DocId, C>,
+    ) {
+        let sort_key: Self::SegmentSortKey;
+        if let Some(threshold) = &top_n_computer.threshold {
+            if let Some((_cmp, lazy_sort_key)) = self.accept_sort_key_lazy(doc, score, threshold) {
+                sort_key = lazy_sort_key;
+            } else {
+                return;
+            }
+        } else {
+            sort_key = self.segment_sort_key(doc, score);
+        };
+        top_n_computer.append_doc(doc, sort_key);
+    }
+
+    #[inline(always)]
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey {
+        let head_sort_key = self.0.segment_sort_key(doc, score);
+        let tail_sort_key = self.1.segment_sort_key(doc, score);
+        (head_sort_key, tail_sort_key)
+    }
+
+    fn accept_sort_key_lazy(
+        &mut self,
+        doc_id: DocId,
+        score: Score,
+        threshold: &Self::SegmentSortKey,
+    ) -> Option<(Ordering, Self::SegmentSortKey)> {
+        let (head_threshold, tail_threshold) = threshold;
+        let (head_cmp, head_sort_key) =
+            self.0.accept_sort_key_lazy(doc_id, score, head_threshold)?;
+        if head_cmp == Ordering::Equal {
+            let (tail_cmp, tail_sort_key) =
+                self.1.accept_sort_key_lazy(doc_id, score, tail_threshold)?;
+            Some((tail_cmp, (head_sort_key, tail_sort_key)))
+        } else {
+            let tail_sort_key = self.1.segment_sort_key(doc_id, score);
+            Some((head_cmp, (head_sort_key, tail_sort_key)))
+        }
+    }
+
+    fn convert_segment_sort_key(&self, sort_key: Self::SegmentSortKey) -> Self::SortKey {
+        let (head_sort_key, tail_sort_key) = sort_key;
+        (
+            self.0.convert_segment_sort_key(head_sort_key),
+            self.1.convert_segment_sort_key(tail_sort_key),
+        )
+    }
+}
+
+/// This struct is used as an adapter to take a sort key computer and map its score to another
+/// new sort key.
+pub struct MappedSegmentSortKeyComputer<T, PreviousSortKey, NewSortKey> {
+    sort_key_computer: T,
+    map: fn(PreviousSortKey) -> NewSortKey,
+}
+
+impl<T, PreviousScore, NewScore> SegmentSortKeyComputer
+    for MappedSegmentSortKeyComputer<T, PreviousScore, NewScore>
+where
+    T: SegmentSortKeyComputer<SortKey = PreviousScore>,
+    PreviousScore: 'static + Clone + Send + Sync + PartialOrd,
+    NewScore: 'static + Clone + Send + Sync + PartialOrd,
+{
+    type SortKey = NewScore;
+    type SegmentSortKey = T::SegmentSortKey;
+
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey {
+        self.sort_key_computer.segment_sort_key(doc, score)
+    }
+
+    fn accept_sort_key_lazy(
+        &mut self,
+        doc_id: DocId,
+        score: Score,
+        threshold: &Self::SegmentSortKey,
+    ) -> Option<(Ordering, Self::SegmentSortKey)> {
+        self.sort_key_computer
+            .accept_sort_key_lazy(doc_id, score, threshold)
+    }
+
+    #[inline(always)]
+    fn compute_sort_key_and_collect<C: Comparator<Self::SegmentSortKey>>(
+        &mut self,
+        doc: DocId,
+        score: Score,
+        top_n_computer: &mut TopNComputer<Self::SegmentSortKey, DocId, C>,
+    ) {
+        self.sort_key_computer
+            .compute_sort_key_and_collect(doc, score, top_n_computer);
+    }
+
+    fn convert_segment_sort_key(&self, segment_sort_key: Self::SegmentSortKey) -> Self::SortKey {
+        (self.map)(
+            self.sort_key_computer
+                .convert_segment_sort_key(segment_sort_key),
+        )
+    }
+}
+
+// We then re-use our (head, tail) implement and our mapper by seeing mapping any tuple (a, b, c,
+// ...) as the chain (a, (b, (c, ...)))
+
+impl<SortKeyComputer1, SortKeyComputer2, SortKeyComputer3> SortKeyComputer
+    for (SortKeyComputer1, SortKeyComputer2, SortKeyComputer3)
+where
+    SortKeyComputer1: SortKeyComputer,
+    SortKeyComputer2: SortKeyComputer,
+    SortKeyComputer3: SortKeyComputer,
+{
+    type SortKey = (
+        SortKeyComputer1::SortKey,
+        SortKeyComputer2::SortKey,
+        SortKeyComputer3::SortKey,
+    );
+    type Child = MappedSegmentSortKeyComputer<
+        <(SortKeyComputer1, (SortKeyComputer2, SortKeyComputer3)) as SortKeyComputer>::Child,
+        (
+            SortKeyComputer1::SortKey,
+            (SortKeyComputer2::SortKey, SortKeyComputer3::SortKey),
+        ),
+        Self::SortKey,
+    >;
+
+    type Comparator = (
+        SortKeyComputer1::Comparator,
+        SortKeyComputer2::Comparator,
+        SortKeyComputer3::Comparator,
+    );
+
+    fn comparator(&self) -> Self::Comparator {
+        (
+            self.0.comparator(),
+            self.1.comparator(),
+            self.2.comparator(),
+        )
+    }
+
+    fn segment_sort_key_computer(&self, segment_reader: &SegmentReader) -> Result<Self::Child> {
+        let sort_key_computer1 = self.0.segment_sort_key_computer(segment_reader)?;
+        let sort_key_computer2 = self.1.segment_sort_key_computer(segment_reader)?;
+        let sort_key_computer3 = self.2.segment_sort_key_computer(segment_reader)?;
+        let map = |(sort_key1, (sort_key2, sort_key3))| (sort_key1, sort_key2, sort_key3);
+        Ok(MappedSegmentSortKeyComputer {
+            sort_key_computer: (sort_key_computer1, (sort_key_computer2, sort_key_computer3)),
+            map,
+        })
+    }
+
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        self.2.check_schema(schema)?;
+        Ok(())
+    }
+
+    fn requires_scoring(&self) -> bool {
+        self.0.requires_scoring() || self.1.requires_scoring() || self.2.requires_scoring()
+    }
+}
+
+impl<SortKeyComputer1, SortKeyComputer2, SortKeyComputer3, SortKeyComputer4> SortKeyComputer
+    for (
+        SortKeyComputer1,
+        SortKeyComputer2,
+        SortKeyComputer3,
+        SortKeyComputer4,
+    )
+where
+    SortKeyComputer1: SortKeyComputer,
+    SortKeyComputer2: SortKeyComputer,
+    SortKeyComputer3: SortKeyComputer,
+    SortKeyComputer4: SortKeyComputer,
+{
+    type Child = MappedSegmentSortKeyComputer<
+        <(
+            SortKeyComputer1,
+            (SortKeyComputer2, (SortKeyComputer3, SortKeyComputer4)),
+        ) as SortKeyComputer>::Child,
+        (
+            SortKeyComputer1::SortKey,
+            (
+                SortKeyComputer2::SortKey,
+                (SortKeyComputer3::SortKey, SortKeyComputer4::SortKey),
+            ),
+        ),
+        Self::SortKey,
+    >;
+    type SortKey = (
+        SortKeyComputer1::SortKey,
+        SortKeyComputer2::SortKey,
+        SortKeyComputer3::SortKey,
+        SortKeyComputer4::SortKey,
+    );
+    type Comparator = (
+        SortKeyComputer1::Comparator,
+        SortKeyComputer2::Comparator,
+        SortKeyComputer3::Comparator,
+        SortKeyComputer4::Comparator,
+    );
+
+    fn segment_sort_key_computer(&self, segment_reader: &SegmentReader) -> Result<Self::Child> {
+        let sort_key_computer1 = self.0.segment_sort_key_computer(segment_reader)?;
+        let sort_key_computer2 = self.1.segment_sort_key_computer(segment_reader)?;
+        let sort_key_computer3 = self.2.segment_sort_key_computer(segment_reader)?;
+        let sort_key_computer4 = self.3.segment_sort_key_computer(segment_reader)?;
+        Ok(MappedSegmentSortKeyComputer {
+            sort_key_computer: (
+                sort_key_computer1,
+                (sort_key_computer2, (sort_key_computer3, sort_key_computer4)),
+            ),
+            map: |(sort_key1, (sort_key2, (sort_key3, sort_key4)))| {
+                (sort_key1, sort_key2, sort_key3, sort_key4)
+            },
+        })
+    }
+
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.0.check_schema(schema)?;
+        self.1.check_schema(schema)?;
+        self.2.check_schema(schema)?;
+        self.3.check_schema(schema)?;
+        Ok(())
+    }
+
+    fn requires_scoring(&self) -> bool {
+        self.0.requires_scoring()
+            || self.1.requires_scoring()
+            || self.2.requires_scoring()
+            || self.3.requires_scoring()
+    }
+}
+
+impl<F, SegmentF, TSortKey> SortKeyComputer for F
+where
+    F: 'static + Send + Sync + Fn(&SegmentReader) -> SegmentF,
+    SegmentF: 'static + FnMut(DocId) -> TSortKey,
+    TSortKey: 'static + PartialOrd + Clone + Send + Sync + std::fmt::Debug,
+{
+    type SortKey = TSortKey;
+    type Child = SegmentF;
+    type Comparator = NaturalComparator;
+
+    fn segment_sort_key_computer(&self, segment_reader: &SegmentReader) -> Result<Self::Child> {
+        Ok((self)(segment_reader))
+    }
+}
+
+impl<F, TSortKey> SegmentSortKeyComputer for F
+where
+    F: 'static + FnMut(DocId) -> TSortKey,
+    TSortKey: 'static + PartialOrd + Clone + Send + Sync,
+{
+    type SortKey = TSortKey;
+    type SegmentSortKey = TSortKey;
+
+    fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> TSortKey {
+        (self)(doc)
+    }
+
+    /// Convert a segment level score into the global level score.
+    fn convert_segment_sort_key(&self, sort_key: Self::SegmentSortKey) -> Self::SortKey {
+        sort_key
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cmp::Ordering;
+    use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+    use std::sync::Arc;
+
+    use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
+    use crate::schema::Schema;
+    use crate::{DocId, Index, Order, SegmentReader};
+
+    fn build_test_index() -> Index {
+        let schema = Schema::builder().build();
+        let index = Index::create_in_ram(schema);
+        let mut index_writer = index.writer_for_tests().unwrap();
+        index_writer
+            .add_document(crate::TantivyDocument::default())
+            .unwrap();
+        index_writer.commit().unwrap();
+        index
+    }
+
+    #[test]
+    fn test_lazy_score_computer() {
+        let score_computer_primary = |_segment_reader: &SegmentReader| |_doc: DocId| 200u32;
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+        let score_computer_secondary = move |_segment_reader: &SegmentReader| {
+            let call_count_new_clone = call_count_clone.clone();
+            move |_doc: DocId| {
+                call_count_new_clone.fetch_add(1, AtomicOrdering::SeqCst);
+                "b"
+            }
+        };
+        let lazy_score_computer = (score_computer_primary, score_computer_secondary);
+        let index = build_test_index();
+        let searcher = index.reader().unwrap().searcher();
+        let mut segment_sort_key_computer = lazy_score_computer
+            .segment_sort_key_computer(searcher.segment_reader(0))
+            .unwrap();
+        let expected_sort_key = (200, "b");
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(100u32, "a"));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 1);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(100u32, "c"));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 2);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(200u32, "a"));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 3);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(200u32, "c"));
+            assert!(sort_key_opt.is_none());
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(300u32, "a"));
+            assert_eq!(sort_key_opt, None);
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(300u32, "c"));
+            assert_eq!(sort_key_opt, None);
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &expected_sort_key);
+            assert_eq!(sort_key_opt, Some((Ordering::Equal, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 5);
+        }
+    }
+
+    #[test]
+    fn test_lazy_score_computer_dynamic_ordering() {
+        let score_computer_primary = |_segment_reader: &SegmentReader| |_doc: DocId| 200u32;
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+        let score_computer_secondary = move |_segment_reader: &SegmentReader| {
+            let call_count_new_clone = call_count_clone.clone();
+            move |_doc: DocId| {
+                call_count_new_clone.fetch_add(1, AtomicOrdering::SeqCst);
+                2u32
+            }
+        };
+        let lazy_score_computer = (
+            (score_computer_primary, Order::Desc),
+            (score_computer_secondary, Order::Asc),
+        );
+        let index = build_test_index();
+        let searcher = index.reader().unwrap().searcher();
+        let mut segment_sort_key_computer = lazy_score_computer
+            .segment_sort_key_computer(searcher.segment_reader(0))
+            .unwrap();
+        let expected_sort_key = (200, 2u32);
+
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(100u32, 1u32));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 1);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(100u32, 3u32));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 2);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(200u32, 1u32));
+            assert!(sort_key_opt.is_none());
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 3);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(200u32, 3u32));
+            assert_eq!(sort_key_opt, Some((Ordering::Greater, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(300u32, 1u32));
+            assert_eq!(sort_key_opt, None);
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &(300u32, 3u32));
+            assert_eq!(sort_key_opt, None);
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 4);
+        }
+        {
+            let sort_key_opt =
+                segment_sort_key_computer.accept_sort_key_lazy(0u32, 1f32, &expected_sort_key);
+            assert_eq!(sort_key_opt, Some((Ordering::Equal, expected_sort_key)));
+            assert_eq!(call_count.load(AtomicOrdering::SeqCst), 5);
+        }
+        assert_eq!(
+            segment_sort_key_computer.convert_segment_sort_key(expected_sort_key),
+            (200u32, 2u32)
+        );
+    }
+}

src/collector/sort_key_top_collector.rs

@@ -0,0 +1,193 @@
+use std::ops::Range;
+
+use crate::collector::sort_key::{Comparator, SegmentSortKeyComputer, SortKeyComputer};
+use crate::collector::{Collector, SegmentCollector, TopNComputer};
+use crate::query::Weight;
+use crate::schema::Schema;
+use crate::{DocAddress, DocId, Result, Score, SegmentReader};
+
+pub(crate) struct TopBySortKeyCollector<TSortKeyComputer> {
+    sort_key_computer: TSortKeyComputer,
+    doc_range: Range<usize>,
+}
+
+impl<TSortKeyComputer> TopBySortKeyCollector<TSortKeyComputer> {
+    pub fn new(sort_key_computer: TSortKeyComputer, doc_range: Range<usize>) -> Self {
+        TopBySortKeyCollector {
+            sort_key_computer,
+            doc_range,
+        }
+    }
+}
+
+impl<TSortKeyComputer> Collector for TopBySortKeyCollector<TSortKeyComputer>
+where TSortKeyComputer: SortKeyComputer + Send + Sync + 'static
+{
+    type Fruit = Vec<(TSortKeyComputer::SortKey, DocAddress)>;
+
+    type Child =
+        TopBySortKeySegmentCollector<TSortKeyComputer::Child, TSortKeyComputer::Comparator>;
+
+    fn check_schema(&self, schema: &Schema) -> crate::Result<()> {
+        self.sort_key_computer.check_schema(schema)
+    }
+
+    fn for_segment(&self, segment_ord: u32, segment_reader: &SegmentReader) -> Result<Self::Child> {
+        let segment_sort_key_computer = self
+            .sort_key_computer
+            .segment_sort_key_computer(segment_reader)?;
+        let topn_computer = TopNComputer::new_with_comparator(
+            self.doc_range.end,
+            self.sort_key_computer.comparator(),
+        );
+        Ok(TopBySortKeySegmentCollector {
+            topn_computer,
+            segment_ord,
+            segment_sort_key_computer,
+        })
+    }
+
+    fn requires_scoring(&self) -> bool {
+        self.sort_key_computer.requires_scoring()
+    }
+
+    fn merge_fruits(&self, segment_fruits: Vec<Self::Fruit>) -> Result<Self::Fruit> {
+        Ok(merge_top_k(
+            segment_fruits.into_iter().flatten(),
+            self.doc_range.clone(),
+            self.sort_key_computer.comparator(),
+        ))
+    }
+
+    fn collect_segment(
+        &self,
+        weight: &dyn Weight,
+        segment_ord: u32,
+        reader: &SegmentReader,
+    ) -> crate::Result<Vec<(TSortKeyComputer::SortKey, DocAddress)>> {
+        let k = self.doc_range.end;
+        let docs = self
+            .sort_key_computer
+            .collect_segment_top_k(k, weight, reader, segment_ord)?;
+        Ok(docs)
+    }
+}
+
+fn merge_top_k<D: Ord, TSortKey: Clone + std::fmt::Debug, C: Comparator<TSortKey>>(
+    sort_key_docs: impl Iterator<Item = (TSortKey, D)>,
+    doc_range: Range<usize>,
+    comparator: C,
+) -> Vec<(TSortKey, D)> {
+    if doc_range.is_empty() {
+        return Vec::new();
+    }
+    let mut top_collector: TopNComputer<TSortKey, D, C> =
+        TopNComputer::new_with_comparator(doc_range.end, comparator);
+    for (sort_key, doc) in sort_key_docs {
+        top_collector.push(sort_key, doc);
+    }
+    top_collector
+        .into_sorted_vec()
+        .into_iter()
+        .skip(doc_range.start)
+        .map(|cdoc| (cdoc.sort_key, cdoc.doc))
+        .collect()
+}
+
+pub struct TopBySortKeySegmentCollector<TSegmentSortKeyComputer, C>
+where
+    TSegmentSortKeyComputer: SegmentSortKeyComputer,
+    C: Comparator<TSegmentSortKeyComputer::SegmentSortKey>,
+{
+    pub(crate) topn_computer: TopNComputer<TSegmentSortKeyComputer::SegmentSortKey, DocId, C>,
+    pub(crate) segment_ord: u32,
+    pub(crate) segment_sort_key_computer: TSegmentSortKeyComputer,
+}
+
+impl<TSegmentSortKeyComputer, C> SegmentCollector
+    for TopBySortKeySegmentCollector<TSegmentSortKeyComputer, C>
+where
+    TSegmentSortKeyComputer: 'static + SegmentSortKeyComputer,
+    C: Comparator<TSegmentSortKeyComputer::SegmentSortKey> + 'static,
+{
+    type Fruit = Vec<(TSegmentSortKeyComputer::SortKey, DocAddress)>;
+
+    fn collect(&mut self, doc: DocId, score: Score) {
+        self.segment_sort_key_computer.compute_sort_key_and_collect(
+            doc,
+            score,
+            &mut self.topn_computer,
+        );
+    }
+
+    fn harvest(self) -> Self::Fruit {
+        let segment_ord = self.segment_ord;
+        let segment_hits: Vec<(TSegmentSortKeyComputer::SortKey, DocAddress)> = self
+            .topn_computer
+            .into_vec()
+            .into_iter()
+            .map(|comparable_doc| {
+                let sort_key = self
+                    .segment_sort_key_computer
+                    .convert_segment_sort_key(comparable_doc.sort_key);
+                (
+                    sort_key,
+                    DocAddress {
+                        segment_ord,
+                        doc_id: comparable_doc.doc,
+                    },
+                )
+            })
+            .collect();
+        segment_hits
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use rand;
+    use rand::seq::SliceRandom as _;
+
+    use super::merge_top_k;
+    use crate::collector::sort_key::ComparatorEnum;
+    use crate::Order;
+
+    fn test_merge_top_k_aux(
+        order: Order,
+        doc_range: Range<usize>,
+        expected: &[(crate::Score, usize)],
+    ) {
+        let mut vals: Vec<(crate::Score, usize)> = (0..10).map(|val| (val as f32, val)).collect();
+        vals.shuffle(&mut rand::thread_rng());
+        let vals_merged = merge_top_k(vals.into_iter(), doc_range, ComparatorEnum::from(order));
+        assert_eq!(&vals_merged, expected);
+    }
+
+    #[test]
+    fn test_merge_top_k() {
+        test_merge_top_k_aux(Order::Asc, 0..0, &[]);
+        test_merge_top_k_aux(Order::Asc, 3..3, &[]);
+        test_merge_top_k_aux(Order::Asc, 0..3, &[(0.0f32, 0), (1.0f32, 1), (2.0f32, 2)]);
+        test_merge_top_k_aux(
+            Order::Asc,
+            0..11,
+            &[
+                (0.0f32, 0),
+                (1.0f32, 1),
+                (2.0f32, 2),
+                (3.0f32, 3),
+                (4.0f32, 4),
+                (5.0f32, 5),
+                (6.0f32, 6),
+                (7.0f32, 7),
+                (8.0f32, 8),
+                (9.0f32, 9),
+            ],
+        );
+        test_merge_top_k_aux(Order::Asc, 1..3, &[(1.0f32, 1), (2.0f32, 2)]);
+        test_merge_top_k_aux(Order::Desc, 0..2, &[(9.0f32, 9), (8.0f32, 8)]);
+        test_merge_top_k_aux(Order::Desc, 2..4, &[(7.0f32, 7), (6.0f32, 6)]);
+    }
+}

src/collector/tests.rs

@@ -40,7 +40,7 @@ pub fn test_filter_collector() -> crate::Result<()> {
     let filter_some_collector = FilterCollector::new(
         "price".to_string(),
         &|value: u64| value > 20_120u64,
-        TopDocs::with_limit(2),
+        TopDocs::with_limit(2).order_by_score(),
     );
     let top_docs = searcher.search(&query, &filter_some_collector)?;
 
@@ -50,7 +50,7 @@ pub fn test_filter_collector() -> crate::Result<()> {
     let filter_all_collector: FilterCollector<_, _, u64> = FilterCollector::new(
         "price".to_string(),
         &|value| value < 5u64,
-        TopDocs::with_limit(2),
+        TopDocs::with_limit(2).order_by_score(),
     );
     let filtered_top_docs = searcher.search(&query, &filter_all_collector).unwrap();
 
@@ -62,8 +62,11 @@ pub fn test_filter_collector() -> crate::Result<()> {
             > 0
     }
 
-    let filter_dates_collector =
-        FilterCollector::new("date".to_string(), &date_filter, TopDocs::with_limit(5));
+    let filter_dates_collector = FilterCollector::new(
+        "date".to_string(),
+        &date_filter,
+        TopDocs::with_limit(5).order_by_score(),
+    );
     let filtered_date_docs = searcher.search(&query, &filter_dates_collector)?;
 
     assert_eq!(filtered_date_docs.len(), 2);

src/collector/top_collector.rs

@@ -1,12 +1,7 @@
 use std::cmp::Ordering;
-use std::marker::PhantomData;
 
 use serde::{Deserialize, Serialize};
 
-use super::top_score_collector::TopNComputer;
-use crate::index::SegmentReader;
-use crate::{DocAddress, DocId, SegmentOrdinal};
-
 /// Contains a feature (field, score, etc.) of a document along with the document address.
 ///
 /// It guarantees stable sorting: in case of a tie on the feature, the document
@@ -19,7 +14,7 @@ use crate::{DocAddress, DocId, SegmentOrdinal};
 pub struct ComparableDoc<T, D, const REVERSE_ORDER: bool = false> {
     /// The feature of the document. In practice, this is
     /// is any type that implements `PartialOrd`.
-    pub feature: T,
+    pub sort_key: T,
     /// The document address. In practice, this is any
     /// type that implements `PartialOrd`, and is guaranteed
     /// to be unique for each document.
@@ -28,9 +23,9 @@ pub struct ComparableDoc<T, D, const REVERSE_ORDER: bool = false> {
 impl<T: std::fmt::Debug, D: std::fmt::Debug, const R: bool> std::fmt::Debug
     for ComparableDoc<T, D, R>
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct(format!("ComparableDoc<_, _ {R}").as_str())
-            .field("feature", &self.feature)
+            .field("feature", &self.sort_key)
             .field("doc", &self.doc)
             .finish()
     }
@@ -46,8 +41,8 @@ impl<T: PartialOrd, D: PartialOrd, const R: bool> Ord for ComparableDoc<T, D, R>
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         let by_feature = self
-            .feature
-            .partial_cmp(&other.feature)
+            .sort_key
+            .partial_cmp(&other.sort_key)
             .map(|ord| if R { ord.reverse() } else { ord })
             .unwrap_or(Ordering::Equal);
 
@@ -67,308 +62,3 @@ impl<T: PartialOrd, D: PartialOrd, const R: bool> PartialEq for ComparableDoc<T,
 }
 
 impl<T: PartialOrd, D: PartialOrd, const R: bool> Eq for ComparableDoc<T, D, R> {}
-
-pub(crate) struct TopCollector<T> {
-    pub limit: usize,
-    pub offset: usize,
-    _marker: PhantomData<T>,
-}
-
-impl<T> TopCollector<T>
-where T: PartialOrd + Clone
-{
-    /// Creates a top collector, with a number of documents equal to "limit".
-    ///
-    /// # Panics
-    /// The method panics if limit is 0
-    pub fn with_limit(limit: usize) -> TopCollector<T> {
-        assert!(limit >= 1, "Limit must be strictly greater than 0.");
-        Self {
-            limit,
-            offset: 0,
-            _marker: PhantomData,
-        }
-    }
-
-    /// Skip the first "offset" documents when collecting.
-    ///
-    /// This is equivalent to `OFFSET` in MySQL or PostgreSQL and `start` in
-    /// Lucene's TopDocsCollector.
-    pub fn and_offset(mut self, offset: usize) -> TopCollector<T> {
-        self.offset = offset;
-        self
-    }
-
-    pub fn merge_fruits(
-        &self,
-        children: Vec<Vec<(T, DocAddress)>>,
-    ) -> crate::Result<Vec<(T, DocAddress)>> {
-        if self.limit == 0 {
-            return Ok(Vec::new());
-        }
-        let mut top_collector: TopNComputer<_, _> = TopNComputer::new(self.limit + self.offset);
-        for child_fruit in children {
-            for (feature, doc) in child_fruit {
-                top_collector.push(feature, doc);
-            }
-        }
-
-        Ok(top_collector
-            .into_sorted_vec()
-            .into_iter()
-            .skip(self.offset)
-            .map(|cdoc| (cdoc.feature, cdoc.doc))
-            .collect())
-    }
-
-    pub(crate) fn for_segment<F: PartialOrd + Clone>(
-        &self,
-        segment_id: SegmentOrdinal,
-        _: &SegmentReader,
-    ) -> TopSegmentCollector<F> {
-        TopSegmentCollector::new(segment_id, self.limit + self.offset)
-    }
-
-    /// Create a new TopCollector with the same limit and offset.
-    ///
-    /// Ideally we would use Into but the blanket implementation seems to cause the Scorer traits
-    /// to fail.
-    #[doc(hidden)]
-    pub(crate) fn into_tscore<TScore: PartialOrd + Clone>(self) -> TopCollector<TScore> {
-        TopCollector {
-            limit: self.limit,
-            offset: self.offset,
-            _marker: PhantomData,
-        }
-    }
-}
-
-/// The Top Collector keeps track of the K documents
-/// sorted by type `T`.
-///
-/// The implementation is based on a repeatedly truncating on the median after K * 2 documents
-/// The theoretical complexity for collecting the top `K` out of `n` documents
-/// is `O(n + K)`.
-pub(crate) struct TopSegmentCollector<T> {
-    /// We reverse the order of the feature in order to
-    /// have top-semantics instead of bottom semantics.
-    topn_computer: TopNComputer<T, DocId>,
-    segment_ord: u32,
-}
-
-impl<T: PartialOrd + Clone> TopSegmentCollector<T> {
-    fn new(segment_ord: SegmentOrdinal, limit: usize) -> TopSegmentCollector<T> {
-        TopSegmentCollector {
-            topn_computer: TopNComputer::new(limit),
-            segment_ord,
-        }
-    }
-}
-
-impl<T: PartialOrd + Clone> TopSegmentCollector<T> {
-    pub fn harvest(self) -> Vec<(T, DocAddress)> {
-        let segment_ord = self.segment_ord;
-        self.topn_computer
-            .into_sorted_vec()
-            .into_iter()
-            .map(|comparable_doc| {
-                (
-                    comparable_doc.feature,
-                    DocAddress {
-                        segment_ord,
-                        doc_id: comparable_doc.doc,
-                    },
-                )
-            })
-            .collect()
-    }
-
-    /// Collects a document scored by the given feature
-    ///
-    /// It collects documents until it has reached the max capacity. Once it reaches capacity, it
-    /// will compare the lowest scoring item with the given one and keep whichever is greater.
-    #[inline]
-    pub fn collect(&mut self, doc: DocId, feature: T) {
-        self.topn_computer.push(feature, doc);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{TopCollector, TopSegmentCollector};
-    use crate::DocAddress;
-
-    #[test]
-    fn test_top_collector_not_at_capacity() {
-        let mut top_collector = TopSegmentCollector::new(0, 4);
-        top_collector.collect(1, 0.8);
-        top_collector.collect(3, 0.2);
-        top_collector.collect(5, 0.3);
-        assert_eq!(
-            top_collector.harvest(),
-            vec![
-                (0.8, DocAddress::new(0, 1)),
-                (0.3, DocAddress::new(0, 5)),
-                (0.2, DocAddress::new(0, 3))
-            ]
-        );
-    }
-
-    #[test]
-    fn test_top_collector_at_capacity() {
-        let mut top_collector = TopSegmentCollector::new(0, 4);
-        top_collector.collect(1, 0.8);
-        top_collector.collect(3, 0.2);
-        top_collector.collect(5, 0.3);
-        top_collector.collect(7, 0.9);
-        top_collector.collect(9, -0.2);
-        assert_eq!(
-            top_collector.harvest(),
-            vec![
-                (0.9, DocAddress::new(0, 7)),
-                (0.8, DocAddress::new(0, 1)),
-                (0.3, DocAddress::new(0, 5)),
-                (0.2, DocAddress::new(0, 3))
-            ]
-        );
-    }
-
-    #[test]
-    fn test_top_segment_collector_stable_ordering_for_equal_feature() {
-        // given that the documents are collected in ascending doc id order,
-        // when harvesting we have to guarantee stable sorting in case of a tie
-        // on the score
-        let doc_ids_collection = [4, 5, 6];
-        let score = 3.3f32;
-
-        let mut top_collector_limit_2 = TopSegmentCollector::new(0, 2);
-        for id in &doc_ids_collection {
-            top_collector_limit_2.collect(*id, score);
-        }
-
-        let mut top_collector_limit_3 = TopSegmentCollector::new(0, 3);
-        for id in &doc_ids_collection {
-            top_collector_limit_3.collect(*id, score);
-        }
-
-        assert_eq!(
-            top_collector_limit_2.harvest(),
-            top_collector_limit_3.harvest()[..2].to_vec(),
-        );
-    }
-
-    #[test]
-    fn test_top_collector_with_limit_and_offset() {
-        let collector = TopCollector::with_limit(2).and_offset(1);
-
-        let results = collector
-            .merge_fruits(vec![vec![
-                (0.9, DocAddress::new(0, 1)),
-                (0.8, DocAddress::new(0, 2)),
-                (0.7, DocAddress::new(0, 3)),
-                (0.6, DocAddress::new(0, 4)),
-                (0.5, DocAddress::new(0, 5)),
-            ]])
-            .unwrap();
-
-        assert_eq!(
-            results,
-            vec![(0.8, DocAddress::new(0, 2)), (0.7, DocAddress::new(0, 3)),]
-        );
-    }
-
-    #[test]
-    fn test_top_collector_with_limit_larger_than_set_and_offset() {
-        let collector = TopCollector::with_limit(2).and_offset(1);
-
-        let results = collector
-            .merge_fruits(vec![vec![
-                (0.9, DocAddress::new(0, 1)),
-                (0.8, DocAddress::new(0, 2)),
-            ]])
-            .unwrap();
-
-        assert_eq!(results, vec![(0.8, DocAddress::new(0, 2)),]);
-    }
-
-    #[test]
-    fn test_top_collector_with_limit_and_offset_larger_than_set() {
-        let collector = TopCollector::with_limit(2).and_offset(20);
-
-        let results = collector
-            .merge_fruits(vec![vec![
-                (0.9, DocAddress::new(0, 1)),
-                (0.8, DocAddress::new(0, 2)),
-            ]])
-            .unwrap();
-
-        assert_eq!(results, vec![]);
-    }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-    use test::Bencher;
-
-    use super::TopSegmentCollector;
-
-    #[bench]
-    fn bench_top_segment_collector_collect_not_at_capacity(b: &mut Bencher) {
-        let mut top_collector = TopSegmentCollector::new(0, 400);
-
-        b.iter(|| {
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_at_capacity(b: &mut Bencher) {
-        let mut top_collector = TopSegmentCollector::new(0, 100);
-
-        for i in 0..100 {
-            top_collector.collect(i, 0.8);
-        }
-
-        b.iter(|| {
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_and_harvest_many_ties(b: &mut Bencher) {
-        b.iter(|| {
-            let mut top_collector = TopSegmentCollector::new(0, 100);
-
-            for i in 0..100 {
-                top_collector.collect(i, 0.8);
-            }
-
-            // it would be nice to be able to do the setup N times but still
-            // measure only harvest(). We can't since harvest() consumes
-            // the top_collector.
-            top_collector.harvest()
-        });
-    }
-
-    #[bench]
-    fn bench_top_segment_collector_collect_and_harvest_no_tie(b: &mut Bencher) {
-        b.iter(|| {
-            let mut top_collector = TopSegmentCollector::new(0, 100);
-            let mut score = 1.0;
-
-            for i in 0..100 {
-                score += 1.0;
-                top_collector.collect(i, score);
-            }
-
-            // it would be nice to be able to do the setup N times but still
-            // measure only harvest(). We can't since harvest() consumes
-            // the top_collector.
-            top_collector.harvest()
-        });
-    }
-}

src/collector/tweak_score_top_collector.rs

@@ -1,124 +0,0 @@
-use crate::collector::top_collector::{TopCollector, TopSegmentCollector};
-use crate::collector::{Collector, SegmentCollector};
-use crate::{DocAddress, DocId, Result, Score, SegmentReader};
-
-pub(crate) struct TweakedScoreTopCollector<TScoreTweaker, TScore = Score> {
-    score_tweaker: TScoreTweaker,
-    collector: TopCollector<TScore>,
-}
-
-impl<TScoreTweaker, TScore> TweakedScoreTopCollector<TScoreTweaker, TScore>
-where TScore: Clone + PartialOrd
-{
-    pub fn new(
-        score_tweaker: TScoreTweaker,
-        collector: TopCollector<TScore>,
-    ) -> TweakedScoreTopCollector<TScoreTweaker, TScore> {
-        TweakedScoreTopCollector {
-            score_tweaker,
-            collector,
-        }
-    }
-}
-
-/// A `ScoreSegmentTweaker` makes it possible to modify the default score
-/// for a given document belonging to a specific segment.
-///
-/// It is the segment local version of the [`ScoreTweaker`].
-pub trait ScoreSegmentTweaker<TScore>: 'static {
-    /// Tweak the given `score` for the document `doc`.
-    fn score(&mut self, doc: DocId, score: Score) -> TScore;
-}
-
-/// `ScoreTweaker` makes it possible to tweak the score
-/// emitted  by the scorer into another one.
-///
-/// The `ScoreTweaker` itself does not make much of the computation itself.
-/// Instead, it helps constructing `Self::Child` instances that will compute
-/// the score at a segment scale.
-pub trait ScoreTweaker<TScore>: Sync {
-    /// Type of the associated [`ScoreSegmentTweaker`].
-    type Child: ScoreSegmentTweaker<TScore>;
-
-    /// Builds a child tweaker for a specific segment. The child scorer is associated with
-    /// a specific segment.
-    fn segment_tweaker(&self, segment_reader: &SegmentReader) -> Result<Self::Child>;
-}
-
-impl<TScoreTweaker, TScore> Collector for TweakedScoreTopCollector<TScoreTweaker, TScore>
-where
-    TScoreTweaker: ScoreTweaker<TScore> + Send + Sync,
-    TScore: 'static + PartialOrd + Clone + Send + Sync,
-{
-    type Fruit = Vec<(TScore, DocAddress)>;
-
-    type Child = TopTweakedScoreSegmentCollector<TScoreTweaker::Child, TScore>;
-
-    fn for_segment(
-        &self,
-        segment_local_id: u32,
-        segment_reader: &SegmentReader,
-    ) -> Result<Self::Child> {
-        let segment_scorer = self.score_tweaker.segment_tweaker(segment_reader)?;
-        let segment_collector = self.collector.for_segment(segment_local_id, segment_reader);
-        Ok(TopTweakedScoreSegmentCollector {
-            segment_collector,
-            segment_scorer,
-        })
-    }
-
-    fn requires_scoring(&self) -> bool {
-        true
-    }
-
-    fn merge_fruits(&self, segment_fruits: Vec<Self::Fruit>) -> Result<Self::Fruit> {
-        self.collector.merge_fruits(segment_fruits)
-    }
-}
-
-pub struct TopTweakedScoreSegmentCollector<TSegmentScoreTweaker, TScore>
-where
-    TScore: 'static + PartialOrd + Clone + Send + Sync + Sized,
-    TSegmentScoreTweaker: ScoreSegmentTweaker<TScore>,
-{
-    segment_collector: TopSegmentCollector<TScore>,
-    segment_scorer: TSegmentScoreTweaker,
-}
-
-impl<TSegmentScoreTweaker, TScore> SegmentCollector
-    for TopTweakedScoreSegmentCollector<TSegmentScoreTweaker, TScore>
-where
-    TScore: 'static + PartialOrd + Clone + Send + Sync,
-    TSegmentScoreTweaker: 'static + ScoreSegmentTweaker<TScore>,
-{
-    type Fruit = Vec<(TScore, DocAddress)>;
-
-    fn collect(&mut self, doc: DocId, score: Score) {
-        let score = self.segment_scorer.score(doc, score);
-        self.segment_collector.collect(doc, score);
-    }
-
-    fn harvest(self) -> Vec<(TScore, DocAddress)> {
-        self.segment_collector.harvest()
-    }
-}
-
-impl<F, TScore, TSegmentScoreTweaker> ScoreTweaker<TScore> for F
-where
-    F: 'static + Send + Sync + Fn(&SegmentReader) -> TSegmentScoreTweaker,
-    TSegmentScoreTweaker: ScoreSegmentTweaker<TScore>,
-{
-    type Child = TSegmentScoreTweaker;
-
-    fn segment_tweaker(&self, segment_reader: &SegmentReader) -> Result<Self::Child> {
-        Ok((self)(segment_reader))
-    }
-}
-
-impl<F, TScore> ScoreSegmentTweaker<TScore> for F
-where F: 'static + FnMut(DocId, Score) -> TScore
-{
-    fn score(&mut self, doc: DocId, score: Score) -> TScore {
-        (self)(doc, score)
-    }
-}

src/compat_tests.rs

@@ -69,7 +69,7 @@ fn assert_date_time_precision(index: &Index, doc_store_precision: DateTimePrecis
         .parse_query("dateformat")
         .expect("Failed to parse query");
     let top_docs = searcher
-        .search(&query, &TopDocs::with_limit(1))
+        .search(&query, &TopDocs::with_limit(1).order_by_score())
         .expect("Search failed");
 
     assert_eq!(top_docs.len(), 1, "Expected 1 search result");

src/core/json_utils.rs

@@ -3,6 +3,7 @@ use common::json_path_writer::{JSON_END_OF_PATH, JSON_PATH_SEGMENT_SEP};
 use common::{replace_in_place, JsonPathWriter};
 use rustc_hash::FxHashMap;
 
+use crate::indexer::indexing_term::IndexingTerm;
 use crate::postings::{IndexingContext, IndexingPosition, PostingsWriter};
 use crate::schema::document::{ReferenceValue, ReferenceValueLeaf, Value};
 use crate::schema::{Type, DATE_TIME_PRECISION_INDEXED};
@@ -77,7 +78,7 @@ fn index_json_object<'a, V: Value<'a>>(
     doc: DocId,
     json_visitor: V::ObjectIter,
     text_analyzer: &mut TextAnalyzer,
-    term_buffer: &mut Term,
+    term_buffer: &mut IndexingTerm,
     json_path_writer: &mut JsonPathWriter,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
@@ -107,17 +108,17 @@ pub(crate) fn index_json_value<'a, V: Value<'a>>(
     doc: DocId,
     json_value: V,
     text_analyzer: &mut TextAnalyzer,
-    term_buffer: &mut Term,
+    term_buffer: &mut IndexingTerm,
     json_path_writer: &mut JsonPathWriter,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
     positions_per_path: &mut IndexingPositionsPerPath,
 ) {
-    let set_path_id = |term_buffer: &mut Term, unordered_id: u32| {
+    let set_path_id = |term_buffer: &mut IndexingTerm, unordered_id: u32| {
         term_buffer.truncate_value_bytes(0);
         term_buffer.append_bytes(&unordered_id.to_be_bytes());
     };
-    let set_type = |term_buffer: &mut Term, typ: Type| {
+    let set_type = |term_buffer: &mut IndexingTerm, typ: Type| {
         term_buffer.append_bytes(&[typ.to_code()]);
     };
 
@@ -226,6 +227,9 @@ pub(crate) fn index_json_value<'a, V: Value<'a>>(
             ReferenceValueLeaf::IpAddr(_) => {
                 unimplemented!("IP address support in dynamic fields is not yet implemented")
             }
+            ReferenceValueLeaf::Geometry(_) => {
+                unimplemented!("Geometry support in dynamic fields is not implemented")
+            }
         },
         ReferenceValue::Array(elements) => {
             for val in elements {

src/core/searcher.rs

@@ -225,6 +225,7 @@ impl Searcher {
         enabled_scoring: EnableScoring,
     ) -> crate::Result<C::Fruit> {
         let weight = query.weight(enabled_scoring)?;
+        collector.check_schema(self.schema())?;
         let segment_readers = self.segment_readers();
         let fruits = executor.map(
             |(segment_ord, segment_reader)| {

src/directory/directory.rs

@@ -108,7 +108,7 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     /// Opens a file and returns a boxed `FileHandle`.
     ///
     /// Users of `Directory` should typically call `Directory::open_read(...)`,
-    /// while `Directory` implementor should implement `get_file_handle()`.
+    /// while `Directory` implementer should implement `get_file_handle()`.
     fn get_file_handle(&self, path: &Path) -> Result<Arc<dyn FileHandle>, OpenReadError>;
 
     /// Once a virtual file is open, its data may not

src/error.rs

@@ -104,7 +104,7 @@ pub enum TantivyError {
     #[error("{0:?}")]
     IncompatibleIndex(Incompatibility),
     /// An internal error occurred. This is are internal states that should not be reached.
-    /// e.g. a datastructure is incorrectly inititalized.
+    /// e.g. a datastructure is incorrectly initialized.
     #[error("Internal error: '{0}'")]
     InternalError(String),
     #[error("Deserialize error: {0}")]

src/fastfield/mod.rs

@@ -683,7 +683,7 @@ mod tests {
     }
 
     #[test]
-    fn test_datefastfield() -> crate::Result<()> {
+    fn test_datefastfield() {
         let mut schema_builder = Schema::builder();
         let date_field = schema_builder.add_date_field(
             "date",
@@ -697,22 +697,28 @@ mod tests {
         );
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests()?;
+        let mut index_writer = index.writer_for_tests().unwrap();
         index_writer.set_merge_policy(Box::new(NoMergePolicy));
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_u64(1i64.to_u64()),
-            multi_date_field => DateTime::from_u64(2i64.to_u64()),
-            multi_date_field => DateTime::from_u64(3i64.to_u64())
-        ))?;
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_u64(4i64.to_u64())
-        ))?;
-        index_writer.add_document(doc!(
-            multi_date_field => DateTime::from_u64(5i64.to_u64()),
-            multi_date_field => DateTime::from_u64(6i64.to_u64())
-        ))?;
-        index_writer.commit()?;
-        let reader = index.reader()?;
+        index_writer
+            .add_document(doc!(
+                date_field => DateTime::from_u64(1i64.to_u64()),
+                multi_date_field => DateTime::from_u64(2i64.to_u64()),
+                multi_date_field => DateTime::from_u64(3i64.to_u64())
+            ))
+            .unwrap();
+        index_writer
+            .add_document(doc!(
+                date_field => DateTime::from_u64(4i64.to_u64())
+            ))
+            .unwrap();
+        index_writer
+            .add_document(doc!(
+                multi_date_field => DateTime::from_u64(5i64.to_u64()),
+                multi_date_field => DateTime::from_u64(6i64.to_u64())
+            ))
+            .unwrap();
+        index_writer.commit().unwrap();
+        let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         assert_eq!(searcher.segment_readers().len(), 1);
         let segment_reader = searcher.segment_reader(0);
@@ -726,27 +732,26 @@ mod tests {
             .column_opt::<DateTime>("multi_date")
             .unwrap()
             .unwrap();
-        let mut dates = Vec::new();
+
         {
             assert_eq!(date_fast_field.get_val(0).into_timestamp_nanos(), 1i64);
-            dates_fast_field.fill_vals(0u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(0u32).collect();
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_nanos(), 2i64);
             assert_eq!(dates[1].into_timestamp_nanos(), 3i64);
         }
         {
             assert_eq!(date_fast_field.get_val(1).into_timestamp_nanos(), 4i64);
-            dates_fast_field.fill_vals(1u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(1u32).collect();
             assert!(dates.is_empty());
         }
         {
             assert_eq!(date_fast_field.get_val(2).into_timestamp_nanos(), 0i64);
-            dates_fast_field.fill_vals(2u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(2u32).collect();
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_nanos(), 5i64);
             assert_eq!(dates[1].into_timestamp_nanos(), 6i64);
         }
-        Ok(())
     }
 
     #[test]

src/fastfield/writer.rs

@@ -189,6 +189,9 @@ impl FastFieldsWriter {
                             .record_str(doc_id, field_name, &token.text);
                     }
                 }
+                ReferenceValueLeaf::Geometry(_) => {
+                    panic!("Geometry fields should not be routed to fast field writer")
+                }
             },
             ReferenceValue::Array(val) => {
                 // TODO: Check this is the correct behaviour we want.
@@ -320,6 +323,9 @@ fn record_json_value_to_columnar_writer<'a, V: Value<'a>>(
                     "Pre-tokenized string support in dynamic fields is not yet implemented"
                 )
             }
+            ReferenceValueLeaf::Geometry(_) => {
+                unimplemented!("Geometry support in dynamic fields is not yet implemented")
+            }
         },
         ReferenceValue::Array(elements) => {
             for el in elements {

src/index/index_meta.rs

@@ -142,6 +142,7 @@ impl SegmentMeta {
             SegmentComponent::FastFields => ".fast".to_string(),
             SegmentComponent::FieldNorms => ".fieldnorm".to_string(),
             SegmentComponent::Delete => format!(".{}.del", self.delete_opstamp().unwrap_or(0)),
+            SegmentComponent::Spatial => ".spatial".to_string(),
         });
         PathBuf::from(path)
     }
@@ -276,13 +277,14 @@ impl Default for IndexSettings {
 }
 
 /// The order to sort by
-#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq)]
 pub enum Order {
     /// Ascending Order
     Asc,
     /// Descending Order
     Desc,
 }
+
 impl Order {
     /// return if the Order is ascending
     pub fn is_asc(&self) -> bool {

src/index/segment_component.rs

@@ -28,12 +28,14 @@ pub enum SegmentComponent {
     /// Bitset describing which document of the segment is alive.
     /// (It was representing deleted docs but changed to represent alive docs from v0.17)
     Delete,
+    /// HUSH
+    Spatial,
 }
 
 impl SegmentComponent {
     /// Iterates through the components.
     pub fn iterator() -> slice::Iter<'static, SegmentComponent> {
-        static SEGMENT_COMPONENTS: [SegmentComponent; 8] = [
+        static SEGMENT_COMPONENTS: [SegmentComponent; 9] = [
             SegmentComponent::Postings,
             SegmentComponent::Positions,
             SegmentComponent::FastFields,
@@ -42,6 +44,7 @@ impl SegmentComponent {
             SegmentComponent::Store,
             SegmentComponent::TempStore,
             SegmentComponent::Delete,
+            SegmentComponent::Spatial,
         ];
         SEGMENT_COMPONENTS.iter()
     }

src/index/segment_reader.rs

@@ -14,6 +14,7 @@ use crate::index::{InvertedIndexReader, Segment, SegmentComponent, SegmentId};
 use crate::json_utils::json_path_sep_to_dot;
 use crate::schema::{Field, IndexRecordOption, Schema, Type};
 use crate::space_usage::SegmentSpaceUsage;
+use crate::spatial::reader::SpatialReaders;
 use crate::store::StoreReader;
 use crate::termdict::TermDictionary;
 use crate::{DocId, Opstamp};
@@ -43,6 +44,7 @@ pub struct SegmentReader {
     positions_composite: CompositeFile,
     fast_fields_readers: FastFieldReaders,
     fieldnorm_readers: FieldNormReaders,
+    spatial_readers: SpatialReaders,
 
     store_file: FileSlice,
     alive_bitset_opt: Option<AliveBitSet>,
@@ -92,6 +94,11 @@ impl SegmentReader {
         &self.fast_fields_readers
     }
 
+    /// HUSH
+    pub fn spatial_fields(&self) -> &SpatialReaders {
+        &self.spatial_readers
+    }
+
     /// Accessor to the `FacetReader` associated with a given `Field`.
     pub fn facet_reader(&self, field_name: &str) -> crate::Result<FacetReader> {
         let schema = self.schema();
@@ -173,6 +180,12 @@ impl SegmentReader {
         let fast_fields_readers = FastFieldReaders::open(fast_fields_data, schema.clone())?;
         let fieldnorm_data = segment.open_read(SegmentComponent::FieldNorms)?;
         let fieldnorm_readers = FieldNormReaders::open(fieldnorm_data)?;
+        let spatial_readers = if schema.contains_spatial_field() {
+            let spatial_data = segment.open_read(SegmentComponent::Spatial)?;
+            SpatialReaders::open(spatial_data)?
+        } else {
+            SpatialReaders::empty()
+        };
 
         let original_bitset = if segment.meta().has_deletes() {
             let alive_doc_file_slice = segment.open_read(SegmentComponent::Delete)?;
@@ -198,6 +211,7 @@ impl SegmentReader {
             postings_composite,
             fast_fields_readers,
             fieldnorm_readers,
+            spatial_readers,
             segment_id: segment.id(),
             delete_opstamp: segment.meta().delete_opstamp(),
             store_file,
@@ -460,6 +474,7 @@ impl SegmentReader {
             self.positions_composite.space_usage(),
             self.fast_fields_readers.space_usage(self.schema())?,
             self.fieldnorm_readers.space_usage(),
+            self.spatial_readers.space_usage(),
             self.get_store_reader(0)?.space_usage(),
             self.alive_bitset_opt
                 .as_ref()
@@ -608,7 +623,7 @@ mod test {
             term_dictionary_size: Some(ByteCount::from(100u64)),
             postings_size: Some(ByteCount::from(1_000u64)),
             positions_size: Some(ByteCount::from(2_000u64)),
-            fast_size: Some(ByteCount::from(1_000u64).into()),
+            fast_size: Some(ByteCount::from(1_000u64)),
         };
         let field_metadata2 = FieldMetadata {
             field_name: "a".to_string(),
@@ -617,7 +632,7 @@ mod test {
             term_dictionary_size: Some(ByteCount::from(80u64)),
             postings_size: Some(ByteCount::from(1_500u64)),
             positions_size: Some(ByteCount::from(2_500u64)),
-            fast_size: Some(ByteCount::from(3_000u64).into()),
+            fast_size: Some(ByteCount::from(3_000u64)),
         };
         let expected = FieldMetadata {
             field_name: "a".to_string(),
@@ -626,7 +641,7 @@ mod test {
             term_dictionary_size: Some(ByteCount::from(180u64)),
             postings_size: Some(ByteCount::from(2_500u64)),
             positions_size: Some(ByteCount::from(4_500u64)),
-            fast_size: Some(ByteCount::from(4_000u64).into()),
+            fast_size: Some(ByteCount::from(4_000u64)),
         };
         assert_merge(
             &[vec![field_metadata1.clone()], vec![field_metadata2]],

src/indexer/index_writer.rs

@@ -513,7 +513,7 @@ impl<D: Document> IndexWriter<D> {
     ///     let searcher = index.reader()?.searcher();
     ///     let query_parser = QueryParser::for_index(&index, vec![title]);
     ///     let query_promo = query_parser.parse_query("Prometheus")?;
-    ///     let top_docs_promo = searcher.search(&query_promo, &TopDocs::with_limit(1))?;
+    ///     let top_docs_promo = searcher.search(&query_promo, &TopDocs::with_limit(1).order_by_score())?;
     ///
     ///     assert!(top_docs_promo.is_empty());
     ///     Ok(())
@@ -946,11 +946,11 @@ mod tests {
         let searcher = reader.searcher();
 
         let a_docs = searcher
-            .search(&a_query, &TopDocs::with_limit(1))
+            .search(&a_query, &TopDocs::with_limit(1).order_by_score())
             .expect("search for a failed");
 
         let b_docs = searcher
-            .search(&b_query, &TopDocs::with_limit(1))
+            .search(&b_query, &TopDocs::with_limit(1).order_by_score())
             .expect("search for b failed");
 
         assert_eq!(a_docs.len(), 1);
@@ -2014,8 +2014,9 @@ mod tests {
             let query = QueryParser::for_index(&index, vec![field])
                 .parse_query(term)
                 .unwrap();
-            let top_docs: Vec<(f32, DocAddress)> =
-                searcher.search(&query, &TopDocs::with_limit(1000)).unwrap();
+            let top_docs: Vec<(f32, DocAddress)> = searcher
+                .search(&query, &TopDocs::with_limit(1000).order_by_score())
+                .unwrap();
 
             top_docs.iter().map(|el| el.1).collect::<Vec<_>>()
         };
@@ -2449,8 +2450,9 @@ mod tests {
             Term::from_field_u64(id_field, existing_id),
             IndexRecordOption::Basic,
         );
-        let top_docs: Vec<(f32, DocAddress)> =
-            searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+        let top_docs: Vec<(f32, DocAddress)> = searcher
+            .search(&query, &TopDocs::with_limit(10).order_by_score())
+            .unwrap();
 
         assert_eq!(top_docs.len(), 1); // Was failing
 
@@ -2491,8 +2493,9 @@ mod tests {
             Term::from_field_i64(id_field, 10i64),
             IndexRecordOption::Basic,
         );
-        let top_docs: Vec<(f32, DocAddress)> =
-            searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+        let top_docs: Vec<(f32, DocAddress)> = searcher
+            .search(&query, &TopDocs::with_limit(10).order_by_score())
+            .unwrap();
 
         assert_eq!(top_docs.len(), 1); // Fails
 
@@ -2500,8 +2503,9 @@ mod tests {
             Term::from_field_i64(id_field, 30i64),
             IndexRecordOption::Basic,
         );
-        let top_docs: Vec<(f32, DocAddress)> =
-            searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+        let top_docs: Vec<(f32, DocAddress)> = searcher
+            .search(&query, &TopDocs::with_limit(10).order_by_score())
+            .unwrap();
 
         assert_eq!(top_docs.len(), 1); // Fails
 

src/indexer/indexing_term.rs

@@ -0,0 +1,184 @@
+use std::net::Ipv6Addr;
+
+use columnar::MonotonicallyMappableToU128;
+
+use crate::fastfield::FastValue;
+use crate::schema::{Field, Type};
+
+/// Term represents the value that the token can take.
+/// It's a serialized representation over different types.
+///
+/// It actually wraps a `Vec<u8>`. The first 5 bytes are metadata.
+/// 4 bytes are the field id, and the last byte is the type.
+///
+/// The serialized value `ValueBytes` is considered everything after the 4 first bytes (term id).
+#[derive(Clone)]
+pub(crate) struct IndexingTerm<B = Vec<u8>>(B)
+where B: AsRef<[u8]>;
+
+/// The number of bytes used as metadata by `Term`.
+const TERM_METADATA_LENGTH: usize = 5;
+
+impl IndexingTerm {
+    /// Create a new Term with a buffer with a given capacity.
+    pub fn with_capacity(capacity: usize) -> IndexingTerm {
+        let mut data = Vec::with_capacity(TERM_METADATA_LENGTH + capacity);
+        data.resize(TERM_METADATA_LENGTH, 0u8);
+        IndexingTerm(data)
+    }
+
+    /// Panics when the term is not empty... ie: some value is set.
+    /// Use `clear_with_field_and_type` in that case.
+    ///
+    /// Sets field and the type.
+    pub(crate) fn set_field_and_type(&mut self, field: Field, typ: Type) {
+        assert!(self.is_empty());
+        self.0[0..4].clone_from_slice(field.field_id().to_be_bytes().as_ref());
+        self.0[4] = typ.to_code();
+    }
+
+    /// Is empty if there are no value bytes.
+    pub fn is_empty(&self) -> bool {
+        self.0.len() == TERM_METADATA_LENGTH
+    }
+
+    /// Removes the value_bytes and set the field and type code.
+    pub(crate) fn clear_with_field_and_type(&mut self, typ: Type, field: Field) {
+        self.truncate_value_bytes(0);
+        self.set_field_and_type(field, typ);
+    }
+
+    /// Sets a u64 value in the term.
+    ///
+    /// U64 are serialized using (8-byte) BigEndian
+    /// representation.
+    /// The use of BigEndian has the benefit of preserving
+    /// the natural order of the values.
+    pub fn set_u64(&mut self, val: u64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `i64` value in the term.
+    pub fn set_i64(&mut self, val: i64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `f64` value in the term.
+    pub fn set_f64(&mut self, val: f64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `bool` value in the term.
+    pub fn set_bool(&mut self, val: bool) {
+        self.set_fast_value(val);
+    }
+
+    fn set_fast_value<T: FastValue>(&mut self, val: T) {
+        self.set_bytes(val.to_u64().to_be_bytes().as_ref());
+    }
+
+    /// Append a type marker + fast value to a term.
+    /// This is used in JSON type to append a fast value after the path.
+    ///
+    /// It will not clear existing bytes.
+    pub fn append_type_and_fast_value<T: FastValue>(&mut self, val: T) {
+        self.0.push(T::to_type().to_code());
+        let value = val.to_u64();
+        self.0.extend(value.to_be_bytes().as_ref());
+    }
+
+    /// Sets a `Ipv6Addr` value in the term.
+    pub fn set_ip_addr(&mut self, val: Ipv6Addr) {
+        self.set_bytes(val.to_u128().to_be_bytes().as_ref());
+    }
+
+    /// Sets the value of a `Bytes` field.
+    pub fn set_bytes(&mut self, bytes: &[u8]) {
+        self.truncate_value_bytes(0);
+        self.0.extend(bytes);
+    }
+
+    /// Truncates the value bytes of the term. Value and field type stays the same.
+    pub fn truncate_value_bytes(&mut self, len: usize) {
+        self.0.truncate(len + TERM_METADATA_LENGTH);
+    }
+
+    /// The length of the bytes.
+    pub fn len_bytes(&self) -> usize {
+        self.0.len() - TERM_METADATA_LENGTH
+    }
+
+    /// Appends value bytes to the Term.
+    ///
+    /// This function returns the segment that has just been added.
+    #[inline]
+    pub fn append_bytes(&mut self, bytes: &[u8]) -> &mut [u8] {
+        let len_before = self.0.len();
+        self.0.extend_from_slice(bytes);
+        &mut self.0[len_before..]
+    }
+}
+
+impl<B> IndexingTerm<B>
+where B: AsRef<[u8]>
+{
+    /// Returns the serialized representation of Term.
+    /// This includes field_id, value type and value.
+    ///
+    /// Do NOT rely on this byte representation in the index.
+    /// This value is likely to change in the future.
+    #[inline]
+    pub fn serialized_term(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::schema::*;
+
+    #[test]
+    pub fn test_term_str() {
+        let mut schema_builder = Schema::builder();
+        schema_builder.add_text_field("text", STRING);
+        let title_field = schema_builder.add_text_field("title", STRING);
+        let term = Term::from_field_text(title_field, "test");
+        assert_eq!(term.field(), title_field);
+        assert_eq!(term.typ(), Type::Str);
+        assert_eq!(term.value().as_str(), Some("test"))
+    }
+
+    /// Size (in bytes) of the buffer of a fast value (u64, i64, f64, or date) term.
+    /// <field> + <type byte> + <value len>
+    ///
+    /// - <field> is a big endian encoded u32 field id
+    /// - <type_byte>'s most significant bit expresses whether the term is a json term or not The
+    ///   remaining 7 bits are used to encode the type of the value. If this is a JSON term, the
+    ///   type is the type of the leaf of the json.
+    /// - <value> is,  if this is not the json term, a binary representation specific to the type.
+    ///   If it is a JSON Term, then it is prepended with the path that leads to this leaf value.
+    const FAST_VALUE_TERM_LEN: usize = 4 + 1 + 8;
+
+    #[test]
+    pub fn test_term_u64() {
+        let mut schema_builder = Schema::builder();
+        let count_field = schema_builder.add_u64_field("count", INDEXED);
+        let term = Term::from_field_u64(count_field, 983u64);
+        assert_eq!(term.field(), count_field);
+        assert_eq!(term.typ(), Type::U64);
+        assert_eq!(term.serialized_term().len(), FAST_VALUE_TERM_LEN);
+        assert_eq!(term.value().as_u64(), Some(983u64))
+    }
+
+    #[test]
+    pub fn test_term_bool() {
+        let mut schema_builder = Schema::builder();
+        let bool_field = schema_builder.add_bool_field("bool", INDEXED);
+        let term = Term::from_field_bool(bool_field, true);
+        assert_eq!(term.field(), bool_field);
+        assert_eq!(term.typ(), Type::Bool);
+        assert_eq!(term.serialized_term().len(), FAST_VALUE_TERM_LEN);
+        assert_eq!(term.value().as_bool(), Some(true))
+    }
+}

src/indexer/merge_index_test.rs

@@ -104,8 +104,9 @@ mod tests {
                 let query = QueryParser::for_index(&index, vec![my_text_field])
                     .parse_query(term)
                     .unwrap();
-                let top_docs: Vec<(f32, DocAddress)> =
-                    searcher.search(&query, &TopDocs::with_limit(3)).unwrap();
+                let top_docs: Vec<(f32, DocAddress)> = searcher
+                    .search(&query, &TopDocs::with_limit(3).order_by_score())
+                    .unwrap();
 
                 top_docs.iter().map(|el| el.1.doc_id).collect::<Vec<_>>()
             };

src/indexer/merger.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::io::{BufWriter, Write};
 use std::sync::Arc;
 
 use columnar::{
@@ -6,6 +8,7 @@ use columnar::{
 use common::ReadOnlyBitSet;
 use itertools::Itertools;
 use measure_time::debug_time;
+use tempfile::NamedTempFile;
 
 use crate::directory::WritePtr;
 use crate::docset::{DocSet, TERMINATED};
@@ -17,6 +20,8 @@ use crate::indexer::doc_id_mapping::{MappingType, SegmentDocIdMapping};
 use crate::indexer::SegmentSerializer;
 use crate::postings::{InvertedIndexSerializer, Postings, SegmentPostings};
 use crate::schema::{value_type_to_column_type, Field, FieldType, Schema};
+use crate::spatial::bkd::LeafPageIterator;
+use crate::spatial::triangle::Triangle;
 use crate::store::StoreWriter;
 use crate::termdict::{TermMerger, TermOrdinal};
 use crate::{DocAddress, DocId, InvertedIndexReader};
@@ -170,6 +175,7 @@ impl IndexMerger {
         let mut readers = vec![];
         for (segment, new_alive_bitset_opt) in segments.iter().zip(alive_bitset_opt) {
             if segment.meta().num_docs() > 0 {
+                dbg!("segment");
                 let reader =
                     SegmentReader::open_with_custom_alive_set(segment, new_alive_bitset_opt)?;
                 readers.push(reader);
@@ -520,6 +526,89 @@ impl IndexMerger {
         Ok(())
     }
 
+    fn write_spatial_fields(
+        &self,
+        serializer: &mut SegmentSerializer,
+        doc_id_mapping: &SegmentDocIdMapping,
+    ) -> crate::Result<()> {
+        /// We need to rebuild a BKD-tree based off the list of triangles.
+        ///
+        /// Because the data can be large, we do this by writing the sequence of triangles to
+        /// disk, and mmapping it as mutable slice, and calling the same code as what
+        /// is done for the segment serialization.
+        ///
+        /// The OS is in charge of deciding how to handle its page cache.
+        /// This is the same as what would have happened with swapping,
+        /// except by explicitly mapping the file, the OS is more likely to
+        /// swap, the memory will not be accounted as anonymous memory,
+        /// swap space is reserved etc.
+        use crate::spatial::bkd::Segment;
+
+        let Some(mut spatial_serializer) = serializer.extract_spatial_serializer() else {
+            // The schema does not contain any spatial field.
+            return Ok(());
+        };
+
+        let mut segment_mappings: Vec<Vec<Option<DocId>>> = Vec::new();
+        for reader in &self.readers {
+            let max_doc = reader.max_doc();
+            segment_mappings.push(vec![None; max_doc as usize]);
+        }
+        for (new_doc_id, old_doc_addr) in doc_id_mapping.iter_old_doc_addrs().enumerate() {
+            segment_mappings[old_doc_addr.segment_ord as usize][old_doc_addr.doc_id as usize] =
+                Some(new_doc_id as DocId);
+        }
+        let mut temp_files: HashMap<Field, NamedTempFile> = HashMap::new();
+
+        for (field, field_entry) in self.schema.fields() {
+            if matches!(field_entry.field_type(), FieldType::Spatial(_)) {
+                temp_files.insert(field, NamedTempFile::new()?);
+            }
+        }
+        for (segment_ord, reader) in self.readers.iter().enumerate() {
+            for (field, temp_file) in &mut temp_files {
+                let mut buf_temp_file = BufWriter::new(temp_file);
+                let spatial_readers = reader.spatial_fields();
+                let Some(spatial_reader) = spatial_readers.get_field(*field)? else {
+                    continue;
+                };
+                let segment = Segment::new(spatial_reader.get_bytes());
+                for triangle_result in LeafPageIterator::new(&segment) {
+                    let triangles = triangle_result?;
+                    for triangle in triangles {
+                        if let Some(new_doc_id) =
+                            segment_mappings[segment_ord][triangle.doc_id as usize]
+                        {
+                            // This is really just a temporary file, not meant to be portable, so we
+                            // use native endianness here.
+                            for &word in &triangle.words {
+                                buf_temp_file.write_all(&word.to_ne_bytes())?;
+                            }
+                            buf_temp_file.write_all(&new_doc_id.to_ne_bytes())?;
+                        }
+                    }
+                }
+                buf_temp_file.flush()?;
+                // No need to fsync here. This file is not here for persistency.
+            }
+        }
+        for (field, temp_file) in temp_files {
+            // Memory map the triangle file.
+            use memmap2::MmapOptions;
+            let mmap = unsafe { MmapOptions::new().map_mut(temp_file.as_file())? };
+            // Cast to &[Triangle] slice
+            let triangle_count = mmap.len() / std::mem::size_of::<Triangle>();
+            let triangles = unsafe {
+                std::slice::from_raw_parts_mut(mmap.as_ptr() as *mut Triangle, triangle_count)
+            };
+            // Get spatial writer and rebuild block kd-tree.
+            spatial_serializer.serialize_field(field, triangles)?;
+        }
+        spatial_serializer.close()?;
+
+        Ok(())
+    }
+
     /// Writes the merged segment by pushing information
     /// to the `SegmentSerializer`.
     ///
@@ -544,9 +633,10 @@ impl IndexMerger {
 
         debug!("write-storagefields");
         self.write_storable_fields(serializer.get_store_writer())?;
+        debug!("write-spatialfields");
+        self.write_spatial_fields(&mut serializer, &doc_id_mapping)?;
         debug!("write-fastfields");
         self.write_fast_fields(serializer.get_fast_field_write(), doc_id_mapping)?;
-
         debug!("close-serializer");
         serializer.close()?;
         Ok(self.max_doc)
@@ -1518,7 +1608,8 @@ mod tests {
         let searcher = reader.searcher();
         let mut term_scorer = term_query
             .specialized_weight(EnableScoring::enabled_from_searcher(&searcher))?
-            .specialized_scorer(searcher.segment_reader(0u32), 1.0)?;
+            .term_scorer_for_test(searcher.segment_reader(0u32), 1.0)?
+            .unwrap();
         assert_eq!(term_scorer.doc(), 0);
         assert_nearly_equals!(term_scorer.block_max_score(), 0.0079681855);
         assert_nearly_equals!(term_scorer.score(), 0.0079681855);
@@ -1533,7 +1624,8 @@ mod tests {
         for segment_reader in searcher.segment_readers() {
             let mut term_scorer = term_query
                 .specialized_weight(EnableScoring::enabled_from_searcher(&searcher))?
-                .specialized_scorer(segment_reader, 1.0)?;
+                .term_scorer_for_test(segment_reader, 1.0)?
+                .unwrap();
             // the difference compared to before is intrinsic to the bm25 formula. no worries
             // there.
             for doc in segment_reader.doc_ids_alive() {
@@ -1558,7 +1650,8 @@ mod tests {
         let segment_reader = searcher.segment_reader(0u32);
         let mut term_scorer = term_query
             .specialized_weight(EnableScoring::enabled_from_searcher(&searcher))?
-            .specialized_scorer(segment_reader, 1.0)?;
+            .term_scorer_for_test(segment_reader, 1.0)?
+            .unwrap();
         // the difference compared to before is intrinsic to the bm25 formula. no worries there.
         for doc in segment_reader.doc_ids_alive() {
             assert_eq!(term_scorer.doc(), doc);

src/indexer/mod.rs

@@ -12,6 +12,7 @@ mod doc_opstamp_mapping;
 mod flat_map_with_buffer;
 pub(crate) mod index_writer;
 pub(crate) mod index_writer_status;
+pub(crate) mod indexing_term;
 mod log_merge_policy;
 mod merge_index_test;
 mod merge_operation;
@@ -181,6 +182,7 @@ mod tests_mmap {
         let field_name_out = ".";
         test_json_field_name(field_name_in, field_name_out);
     }
+
     #[test]
     fn test_json_field_dot() {
         // Test when field name contains a '.'
@@ -587,7 +589,9 @@ mod tests_mmap {
             };
             let query_str = &format!("{}:{}", indexed_field.field_name, val);
             let query = query_parser.parse_query(query_str).unwrap();
-            let count_docs = searcher.search(&*query, &TopDocs::with_limit(2)).unwrap();
+            let count_docs = searcher
+                .search(&*query, &TopDocs::with_limit(2).order_by_score())
+                .unwrap();
             if indexed_field.field_name.contains("empty") || indexed_field.typ == Type::Json {
                 assert_eq!(count_docs.len(), 0);
             } else {
@@ -659,7 +663,9 @@ mod tests_mmap {
         for (indexed_field, val) in fields_and_vals.iter() {
             let query_str = &format!("{indexed_field}:{val}");
             let query = query_parser.parse_query(query_str).unwrap();
-            let count_docs = searcher.search(&*query, &TopDocs::with_limit(2)).unwrap();
+            let count_docs = searcher
+                .search(&*query, &TopDocs::with_limit(2).order_by_score())
+                .unwrap();
             assert!(!count_docs.is_empty(), "{indexed_field}:{val}");
         }
         // Test if field name can be used for aggregation

src/indexer/segment_serializer.rs

@@ -4,6 +4,7 @@ use crate::directory::WritePtr;
 use crate::fieldnorm::FieldNormsSerializer;
 use crate::index::{Segment, SegmentComponent};
 use crate::postings::InvertedIndexSerializer;
+use crate::spatial::serializer::SpatialSerializer;
 use crate::store::StoreWriter;
 
 /// Segment serializer is in charge of laying out on disk
@@ -12,6 +13,7 @@ pub struct SegmentSerializer {
     segment: Segment,
     pub(crate) store_writer: StoreWriter,
     fast_field_write: WritePtr,
+    spatial_serializer: Option<SpatialSerializer>,
     fieldnorms_serializer: Option<FieldNormsSerializer>,
     postings_serializer: InvertedIndexSerializer,
 }
@@ -35,11 +37,20 @@ impl SegmentSerializer {
         let fieldnorms_write = segment.open_write(SegmentComponent::FieldNorms)?;
         let fieldnorms_serializer = FieldNormsSerializer::from_write(fieldnorms_write)?;
 
+        let spatial_serializer: Option<SpatialSerializer> =
+            if segment.schema().contains_spatial_field() {
+                let spatial_write = segment.open_write(SegmentComponent::Spatial)?;
+                Some(SpatialSerializer::from_write(spatial_write)?)
+            } else {
+                None
+            };
+
         let postings_serializer = InvertedIndexSerializer::open(&mut segment)?;
         Ok(SegmentSerializer {
             segment,
             store_writer,
             fast_field_write,
+            spatial_serializer,
             fieldnorms_serializer: Some(fieldnorms_serializer),
             postings_serializer,
         })
@@ -64,6 +75,11 @@ impl SegmentSerializer {
         &mut self.fast_field_write
     }
 
+    /// Accessor to the `SpatialSerializer`
+    pub fn extract_spatial_serializer(&mut self) -> Option<SpatialSerializer> {
+        self.spatial_serializer.take()
+    }
+
     /// Extract the field norm serializer.
     ///
     /// Note the fieldnorms serializer can only be extracted once.
@@ -81,6 +97,9 @@ impl SegmentSerializer {
         if let Some(fieldnorms_serializer) = self.extract_fieldnorms_serializer() {
             fieldnorms_serializer.close()?;
         }
+        if let Some(spatial_serializer) = self.extract_spatial_serializer() {
+            spatial_serializer.close()?;
+        }
         self.fast_field_write.terminate()?;
         self.postings_serializer.close()?;
         self.store_writer.close()?;

src/indexer/segment_updater.rs

@@ -1052,8 +1052,9 @@ mod tests {
                 let query = QueryParser::for_index(&index, vec![text_field])
                     .parse_query(term)
                     .unwrap();
-                let top_docs: Vec<(f32, DocAddress)> =
-                    searcher.search(&query, &TopDocs::with_limit(3)).unwrap();
+                let top_docs: Vec<(f32, DocAddress)> = searcher
+                    .search(&query, &TopDocs::with_limit(3).order_by_score())
+                    .unwrap();
 
                 top_docs.iter().map(|el| el.1.doc_id).collect::<Vec<_>>()
             };

src/indexer/segment_writer.rs

@@ -7,6 +7,7 @@ use super::operation::AddOperation;
 use crate::fastfield::FastFieldsWriter;
 use crate::fieldnorm::{FieldNormReaders, FieldNormsWriter};
 use crate::index::{Segment, SegmentComponent};
+use crate::indexer::indexing_term::IndexingTerm;
 use crate::indexer::segment_serializer::SegmentSerializer;
 use crate::json_utils::{index_json_value, IndexingPositionsPerPath};
 use crate::postings::{
@@ -14,7 +15,8 @@ use crate::postings::{
     PerFieldPostingsWriter, PostingsWriter,
 };
 use crate::schema::document::{Document, Value};
-use crate::schema::{FieldEntry, FieldType, Schema, Term, DATE_TIME_PRECISION_INDEXED};
+use crate::schema::{FieldEntry, FieldType, Schema, DATE_TIME_PRECISION_INDEXED};
+use crate::spatial::writer::SpatialWriter;
 use crate::tokenizer::{FacetTokenizer, PreTokenizedStream, TextAnalyzer, Tokenizer};
 use crate::{DocId, Opstamp, TantivyError};
 
@@ -51,11 +53,12 @@ pub struct SegmentWriter {
     pub(crate) segment_serializer: SegmentSerializer,
     pub(crate) fast_field_writers: FastFieldsWriter,
     pub(crate) fieldnorms_writer: FieldNormsWriter,
+    pub(crate) spatial_writer: SpatialWriter,
     pub(crate) json_path_writer: JsonPathWriter,
     pub(crate) json_positions_per_path: IndexingPositionsPerPath,
     pub(crate) doc_opstamps: Vec<Opstamp>,
     per_field_text_analyzers: Vec<TextAnalyzer>,
-    term_buffer: Term,
+    term_buffer: IndexingTerm,
     schema: Schema,
 }
 
@@ -103,6 +106,7 @@ impl SegmentWriter {
             ctx: IndexingContext::new(table_size),
             per_field_postings_writers,
             fieldnorms_writer: FieldNormsWriter::for_schema(&schema),
+            spatial_writer: SpatialWriter::default(),
             json_path_writer: JsonPathWriter::default(),
             json_positions_per_path: IndexingPositionsPerPath::default(),
             segment_serializer,
@@ -112,7 +116,7 @@ impl SegmentWriter {
             )?,
             doc_opstamps: Vec::with_capacity(1_000),
             per_field_text_analyzers,
-            term_buffer: Term::with_capacity(16),
+            term_buffer: IndexingTerm::with_capacity(16),
             schema,
         })
     }
@@ -129,6 +133,7 @@ impl SegmentWriter {
             self.ctx,
             self.fast_field_writers,
             &self.fieldnorms_writer,
+            &mut self.spatial_writer,
             self.segment_serializer,
         )?;
         Ok(self.doc_opstamps)
@@ -141,6 +146,7 @@ impl SegmentWriter {
             + self.fieldnorms_writer.mem_usage()
             + self.fast_field_writers.mem_usage()
             + self.segment_serializer.mem_usage()
+            + self.spatial_writer.mem_usage()
     }
 
     fn index_document<D: Document>(&mut self, doc: &D) -> crate::Result<()> {
@@ -337,6 +343,13 @@ impl SegmentWriter {
                         self.fieldnorms_writer.record(doc_id, field, num_vals);
                     }
                 }
+                FieldType::Spatial(_) => {
+                    for value in values {
+                        if let Some(geometry) = value.as_geometry() {
+                            self.spatial_writer.add_geometry(doc_id, field, *geometry);
+                        }
+                    }
+                }
             }
         }
         Ok(())
@@ -391,12 +404,16 @@ fn remap_and_write(
     ctx: IndexingContext,
     fast_field_writers: FastFieldsWriter,
     fieldnorms_writer: &FieldNormsWriter,
+    spatial_writer: &mut SpatialWriter,
     mut serializer: SegmentSerializer,
 ) -> crate::Result<()> {
     debug!("remap-and-write");
     if let Some(fieldnorms_serializer) = serializer.extract_fieldnorms_serializer() {
         fieldnorms_writer.serialize(fieldnorms_serializer)?;
     }
+    if let Some(spatial_serializer) = serializer.extract_spatial_serializer() {
+        spatial_writer.serialize(spatial_serializer)?;
+    }
     let fieldnorm_data = serializer
         .segment()
         .open_read(SegmentComponent::FieldNorms)?;
@@ -519,7 +536,7 @@ mod tests {
             .reader()
             .unwrap()
             .searcher()
-            .search(&text_query, &TopDocs::with_limit(4))
+            .search(&text_query, &TopDocs::with_limit(4).order_by_score())
             .unwrap();
         assert_eq!(score_docs.len(), 1);
 
@@ -528,7 +545,7 @@ mod tests {
             .reader()
             .unwrap()
             .searcher()
-            .search(&text_query, &TopDocs::with_limit(4))
+            .search(&text_query, &TopDocs::with_limit(4).order_by_score())
             .unwrap();
         assert_eq!(score_docs.len(), 2);
     }
@@ -561,7 +578,7 @@ mod tests {
                 .reader()
                 .unwrap()
                 .searcher()
-                .search(&text_query, &TopDocs::with_limit(4))
+                .search(&text_query, &TopDocs::with_limit(4).order_by_score())
                 .unwrap();
             assert_eq!(score_docs.len(), 1);
         };

src/indexer/stamper.rs

@@ -42,7 +42,6 @@ mod test {
 
     use super::Stamper;
 
-    #[expect(clippy::redundant_clone)]
     #[test]
     fn test_stamper() {
         let stamper = Stamper::new(7u64);
@@ -58,7 +57,6 @@ mod test {
         assert_eq!(stamper.stamp(), 15u64);
     }
 
-    #[expect(clippy::redundant_clone)]
     #[test]
     fn test_stamper_revert() {
         let stamper = Stamper::new(7u64);

src/lib.rs

@@ -85,7 +85,7 @@
 //! // Perform search.
 //! // `topdocs` contains the 10 most relevant doc ids, sorted by decreasing scores...
 //! let top_docs: Vec<(Score, DocAddress)> =
-//!     searcher.search(&query, &TopDocs::with_limit(10))?;
+//!     searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
 //!
 //! for (_score, doc_address) in top_docs {
 //!     // Retrieve the actual content of documents given its `doc_address`.
@@ -125,7 +125,7 @@
 //!
 //! - **Searching**: [Searcher] searches the segments with anything that implements
 //!   [Query](query::Query) and merges the results. The list of [supported
-//!   queries](query::Query#implementors). Custom Queries are supported by implementing the
+//!   queries](query::Query#implementers). Custom Queries are supported by implementing the
 //!   [Query](query::Query) trait.
 //!
 //! - **[Directory](directory)**: Abstraction over the storage where the index data is stored.
@@ -191,6 +191,7 @@ pub mod fieldnorm;
 pub mod index;
 pub mod positions;
 pub mod postings;
+pub mod spatial;
 
 /// Module containing the different query implementations.
 pub mod query;

src/postings/json_postings_writer.rs

@@ -3,13 +3,14 @@ use std::io;
 use common::json_path_writer::JSON_END_OF_PATH;
 use stacker::Addr;
 
+use crate::indexer::indexing_term::IndexingTerm;
 use crate::indexer::path_to_unordered_id::OrderedPathId;
 use crate::postings::postings_writer::SpecializedPostingsWriter;
 use crate::postings::recorder::{BufferLender, DocIdRecorder, Recorder};
 use crate::postings::{FieldSerializer, IndexingContext, IndexingPosition, PostingsWriter};
-use crate::schema::{Field, Type};
+use crate::schema::{Field, Type, ValueBytes};
 use crate::tokenizer::TokenStream;
-use crate::{DocId, Term};
+use crate::DocId;
 
 /// The `JsonPostingsWriter` is odd in that it relies on a hidden contract:
 ///
@@ -33,7 +34,7 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         &mut self,
         doc: crate::DocId,
         pos: u32,
-        term: &crate::Term,
+        term: &IndexingTerm,
         ctx: &mut IndexingContext,
     ) {
         self.non_str_posting_writer.subscribe(doc, pos, term, ctx);
@@ -43,7 +44,7 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         &mut self,
         doc_id: DocId,
         token_stream: &mut dyn TokenStream,
-        term_buffer: &mut Term,
+        term_buffer: &mut IndexingTerm,
         ctx: &mut IndexingContext,
         indexing_position: &mut IndexingPosition,
     ) {
@@ -64,40 +65,38 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         ctx: &IndexingContext,
         serializer: &mut FieldSerializer,
     ) -> io::Result<()> {
-        let mut term_buffer = Term::with_capacity(48);
+        let mut term_buffer = JsonTermSerializer(Vec::with_capacity(48));
         let mut buffer_lender = BufferLender::default();
-        term_buffer.clear_with_field_and_type(Type::Json, Field::from_field_id(0));
         let mut prev_term_id = u32::MAX;
         let mut term_path_len = 0; // this will be set in the first iteration
         for (_field, path_id, term, addr) in ordered_term_addrs {
             if prev_term_id != path_id.path_id() {
-                term_buffer.truncate_value_bytes(0);
-                term_buffer.append_path(ordered_id_to_path[path_id.path_id() as usize].as_bytes());
-                term_buffer.append_bytes(&[JSON_END_OF_PATH]);
-                term_path_len = term_buffer.len_bytes();
+                term_buffer.clear();
+                term_buffer.append_json_path(ordered_id_to_path[path_id.path_id() as usize]);
+                term_path_len = term_buffer.len();
                 prev_term_id = path_id.path_id();
             }
-            term_buffer.truncate_value_bytes(term_path_len);
+            term_buffer.truncate(term_path_len);
             term_buffer.append_bytes(term);
-            if let Some(json_value) = term_buffer.value().as_json_value_bytes() {
-                let typ = json_value.typ();
-                if typ == Type::Str {
-                    SpecializedPostingsWriter::<Rec>::serialize_one_term(
-                        term_buffer.serialized_value_bytes(),
-                        *addr,
-                        &mut buffer_lender,
-                        ctx,
-                        serializer,
-                    )?;
-                } else {
-                    SpecializedPostingsWriter::<DocIdRecorder>::serialize_one_term(
-                        term_buffer.serialized_value_bytes(),
-                        *addr,
-                        &mut buffer_lender,
-                        ctx,
-                        serializer,
-                    )?;
-                }
+
+            let json_value = ValueBytes::wrap(term);
+            let typ = json_value.typ();
+            if typ == Type::Str {
+                SpecializedPostingsWriter::<Rec>::serialize_one_term(
+                    term_buffer.as_bytes(),
+                    *addr,
+                    &mut buffer_lender,
+                    ctx,
+                    serializer,
+                )?;
+            } else {
+                SpecializedPostingsWriter::<DocIdRecorder>::serialize_one_term(
+                    term_buffer.as_bytes(),
+                    *addr,
+                    &mut buffer_lender,
+                    ctx,
+                    serializer,
+                )?;
             }
         }
         Ok(())
@@ -107,3 +106,48 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         self.str_posting_writer.total_num_tokens() + self.non_str_posting_writer.total_num_tokens()
     }
 }
+
+struct JsonTermSerializer(Vec<u8>);
+impl JsonTermSerializer {
+    /// Appends a JSON path to the Term.
+    /// The path is terminated by a special end-of-path 0 byte.
+    #[inline]
+    pub fn append_json_path(&mut self, path: &str) {
+        let bytes = path.as_bytes();
+        // Replace any occurrence of the end-of-path byte with Ascii '0' byte.
+        if bytes.contains(&JSON_END_OF_PATH) {
+            self.0.extend(
+                bytes
+                    .iter()
+                    .map(|&b| if b == JSON_END_OF_PATH { b'0' } else { b }),
+            );
+        } else {
+            self.0.extend_from_slice(bytes);
+        }
+        self.0.push(JSON_END_OF_PATH);
+    }
+
+    /// Appends value bytes to the Term.
+    ///
+    /// This function returns the segment that has just been added.
+    #[inline]
+    pub fn append_bytes(&mut self, bytes: &[u8]) -> &mut [u8] {
+        let len_before = self.0.len();
+        self.0.extend_from_slice(bytes);
+        &mut self.0[len_before..]
+    }
+
+    fn clear(&mut self) {
+        self.0.clear();
+    }
+    fn truncate(&mut self, len: usize) {
+        self.0.truncate(len);
+    }
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}

src/postings/per_field_postings_writer.rs

@@ -51,6 +51,7 @@ fn posting_writer_from_field_entry(field_entry: &FieldEntry) -> Box<dyn Postings
         | FieldType::Date(_)
         | FieldType::Bytes(_)
         | FieldType::IpAddr(_)
+        | FieldType::Spatial(_)
         | FieldType::Facet(_) => Box::<SpecializedPostingsWriter<DocIdRecorder>>::default(),
         FieldType::JsonObject(ref json_object_options) => {
             if let Some(text_indexing_option) = json_object_options.get_text_indexing_options() {

src/postings/postings_writer.rs

@@ -5,6 +5,7 @@ use std::ops::Range;
 use stacker::Addr;
 
 use crate::fieldnorm::FieldNormReaders;
+use crate::indexer::indexing_term::IndexingTerm;
 use crate::indexer::path_to_unordered_id::OrderedPathId;
 use crate::postings::recorder::{BufferLender, Recorder};
 use crate::postings::{
@@ -111,7 +112,7 @@ pub(crate) trait PostingsWriter: Send + Sync {
     /// * term - the term
     /// * ctx - Contains a term hashmap and a memory arena to store all necessary posting list
     ///   information.
-    fn subscribe(&mut self, doc: DocId, pos: u32, term: &Term, ctx: &mut IndexingContext);
+    fn subscribe(&mut self, doc: DocId, pos: u32, term: &IndexingTerm, ctx: &mut IndexingContext);
 
     /// Serializes the postings on disk.
     /// The actual serialization format is handled by the `PostingsSerializer`.
@@ -128,7 +129,7 @@ pub(crate) trait PostingsWriter: Send + Sync {
         &mut self,
         doc_id: DocId,
         token_stream: &mut dyn TokenStream,
-        term_buffer: &mut Term,
+        term_buffer: &mut IndexingTerm,
         ctx: &mut IndexingContext,
         indexing_position: &mut IndexingPosition,
     ) {
@@ -198,7 +199,13 @@ impl<Rec: Recorder> SpecializedPostingsWriter<Rec> {
 
 impl<Rec: Recorder> PostingsWriter for SpecializedPostingsWriter<Rec> {
     #[inline]
-    fn subscribe(&mut self, doc: DocId, position: u32, term: &Term, ctx: &mut IndexingContext) {
+    fn subscribe(
+        &mut self,
+        doc: DocId,
+        position: u32,
+        term: &IndexingTerm,
+        ctx: &mut IndexingContext,
+    ) {
         debug_assert!(term.serialized_term().len() >= 4);
         self.total_num_tokens += 1;
         let (term_index, arena) = (&mut ctx.term_index, &mut ctx.arena);

src/query/bm25.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use crate::fieldnorm::FieldNormReader;
 use crate::query::Explanation;
 use crate::schema::Field;
@@ -57,13 +59,13 @@ fn cached_tf_component(fieldnorm: u32, average_fieldnorm: Score) -> Score {
     K1 * (1.0 - B + B * fieldnorm as Score / average_fieldnorm)
 }
 
-fn compute_tf_cache(average_fieldnorm: Score) -> [Score; 256] {
+fn compute_tf_cache(average_fieldnorm: Score) -> Arc<[Score; 256]> {
     let mut cache: [Score; 256] = [0.0; 256];
     for (fieldnorm_id, cache_mut) in cache.iter_mut().enumerate() {
         let fieldnorm = FieldNormReader::id_to_fieldnorm(fieldnorm_id as u8);
         *cache_mut = cached_tf_component(fieldnorm, average_fieldnorm);
     }
-    cache
+    Arc::new(cache)
 }
 
 /// A struct used for computing BM25 scores.
@@ -71,17 +73,20 @@ fn compute_tf_cache(average_fieldnorm: Score) -> [Score; 256] {
 pub struct Bm25Weight {
     idf_explain: Option<Explanation>,
     weight: Score,
-    cache: [Score; 256],
+    cache: Arc<[Score; 256]>,
     average_fieldnorm: Score,
 }
 
 impl Bm25Weight {
     /// Increase the weight by a multiplicative factor.
     pub fn boost_by(&self, boost: Score) -> Bm25Weight {
+        if boost == 1.0f32 {
+            return self.clone();
+        }
         Bm25Weight {
             idf_explain: self.idf_explain.clone(),
             weight: self.weight * boost,
-            cache: self.cache,
+            cache: self.cache.clone(),
             average_fieldnorm: self.average_fieldnorm,
         }
     }

src/query/boolean_query/boolean_weight.rs

@@ -9,7 +9,7 @@ use crate::query::score_combiner::{DoNothingCombiner, ScoreCombiner};
 use crate::query::term_query::TermScorer;
 use crate::query::weight::{for_each_docset_buffered, for_each_pruning_scorer, for_each_scorer};
 use crate::query::{
-    intersect_scorers, BufferedUnionScorer, EmptyScorer, Exclude, Explanation, Occur,
+    intersect_scorers, AllScorer, BufferedUnionScorer, EmptyScorer, Exclude, Explanation, Occur,
     RequiredOptionalScorer, Scorer, Weight,
 };
 use crate::{DocId, Score};
@@ -97,6 +97,15 @@ fn into_box_scorer<TScoreCombiner: ScoreCombiner>(
     }
 }
 
+enum ShouldScorersCombinationMethod {
+    // Should scorers are irrelevant.
+    Ignored,
+    // Only contributes to final score.
+    Optional(SpecializedScorer),
+    // Regardless of score, the should scorers may impact whether a document is matching or not.
+    Required(SpecializedScorer),
+}
+
 /// Weight associated to the `BoolQuery`.
 pub struct BooleanWeight<TScoreCombiner: ScoreCombiner> {
     weights: Vec<(Occur, Box<dyn Weight>)>,
@@ -159,27 +168,50 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
     ) -> 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 {
-            Ignored,
-            // Only contributes to final score.
-            Optional(SpecializedScorer),
-            Required(SpecializedScorer),
+
+        // Indicate how should clauses are combined with must clauses.
+        let mut must_scorers: Vec<Box<dyn Scorer>> =
+            per_occur_scorers.remove(&Occur::Must).unwrap_or_default();
+        let must_special_scorer_counts = remove_and_count_all_and_empty_scorers(&mut must_scorers);
+
+        if must_special_scorer_counts.num_empty_scorers > 0 {
+            return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)));
         }
-        let mut must_scorers = per_occur_scorers.remove(&Occur::Must);
-        let should_opt = if let Some(mut should_scorers) = per_occur_scorers.remove(&Occur::Should)
-        {
+
+        let mut should_scorers = per_occur_scorers.remove(&Occur::Should).unwrap_or_default();
+        let should_special_scorer_counts =
+            remove_and_count_all_and_empty_scorers(&mut should_scorers);
+
+        let mut exclude_scorers: Vec<Box<dyn Scorer>> = per_occur_scorers
+            .remove(&Occur::MustNot)
+            .unwrap_or_default();
+        let exclude_special_scorer_counts =
+            remove_and_count_all_and_empty_scorers(&mut exclude_scorers);
+
+        if exclude_special_scorer_counts.num_all_scorers > 0 {
+            // We exclude all documents at one point.
+            return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)));
+        }
+
+        let minimum_number_should_match = self
+            .minimum_number_should_match
+            .saturating_sub(should_special_scorer_counts.num_all_scorers);
+
+        let should_scorers: ShouldScorersCombinationMethod = {
             let num_of_should_scorers = should_scorers.len();
-            if self.minimum_number_should_match > num_of_should_scorers {
+            if minimum_number_should_match > num_of_should_scorers {
+                // We don't have enough scorers to satisfy the minimum number of should matches.
+                // The request will match no documents.
                 return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)));
             }
-            match self.minimum_number_should_match {
-                0 => CombinationMethod::Optional(scorer_union(
+            match minimum_number_should_match {
+                0 if num_of_should_scorers == 0 => ShouldScorersCombinationMethod::Ignored,
+                0 => ShouldScorersCombinationMethod::Optional(scorer_union(
                     should_scorers,
                     &score_combiner_fn,
                     num_docs,
                 )),
-                1 => CombinationMethod::Required(scorer_union(
+                1 => ShouldScorersCombinationMethod::Required(scorer_union(
                     should_scorers,
                     &score_combiner_fn,
                     num_docs,
@@ -187,76 +219,120 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
                 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.
-                    must_scorers = match must_scorers.take() {
-                        Some(mut must_scorers) => {
-                            must_scorers.append(&mut should_scorers);
-                            Some(must_scorers)
-                        }
-                        None => Some(should_scorers),
-                    };
-                    CombinationMethod::Ignored
+                    must_scorers.append(&mut should_scorers);
+                    ShouldScorersCombinationMethod::Ignored
                 }
-                _ => CombinationMethod::Required(SpecializedScorer::Other(scorer_disjunction(
-                    should_scorers,
-                    score_combiner_fn(),
-                    self.minimum_number_should_match,
-                ))),
-            }
-        } else {
-            // None of should clauses are provided.
-            if self.minimum_number_should_match > 0 {
-                return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)));
-            } else {
-                CombinationMethod::Ignored
+                _ => ShouldScorersCombinationMethod::Required(SpecializedScorer::Other(
+                    scorer_disjunction(
+                        should_scorers,
+                        score_combiner_fn(),
+                        self.minimum_number_should_match,
+                    ),
+                )),
             }
         };
-        let exclude_scorer_opt: Option<Box<dyn Scorer>> = per_occur_scorers
-            .remove(&Occur::MustNot)
-            .map(|scorers| scorer_union(scorers, DoNothingCombiner::default, num_docs))
-            .map(|specialized_scorer: SpecializedScorer| {
-                into_box_scorer(specialized_scorer, DoNothingCombiner::default, num_docs)
-            });
-        let positive_scorer = match (should_opt, must_scorers) {
-            (CombinationMethod::Ignored, Some(must_scorers)) => {
-                SpecializedScorer::Other(intersect_scorers(must_scorers, num_docs))
+
+        let exclude_scorer_opt: Option<Box<dyn Scorer>> = if exclude_scorers.is_empty() {
+            None
+        } else {
+            let exclude_specialized_scorer: SpecializedScorer =
+                scorer_union(exclude_scorers, DoNothingCombiner::default, num_docs);
+            Some(into_box_scorer(
+                exclude_specialized_scorer,
+                DoNothingCombiner::default,
+                num_docs,
+            ))
+        };
+
+        let include_scorer = match (should_scorers, must_scorers) {
+            (ShouldScorersCombinationMethod::Ignored, must_scorers) => {
+                let boxed_scorer: Box<dyn Scorer> = if must_scorers.is_empty() {
+                    // We do not have any should scorers, nor all scorers.
+                    // There are still two cases here.
+                    //
+                    // If this follows the removal of some AllScorers in the should/must clauses,
+                    // then we match all documents.
+                    //
+                    // Otherwise, it is really just an EmptyScorer.
+                    if must_special_scorer_counts.num_all_scorers
+                        + should_special_scorer_counts.num_all_scorers
+                        > 0
+                    {
+                        Box::new(AllScorer::new(reader.max_doc()))
+                    } else {
+                        Box::new(EmptyScorer)
+                    }
+                } else {
+                    intersect_scorers(must_scorers, num_docs)
+                };
+                SpecializedScorer::Other(boxed_scorer)
             }
-            (CombinationMethod::Optional(should_scorer), Some(must_scorers)) => {
-                let must_scorer = intersect_scorers(must_scorers, num_docs);
-                if self.scoring_enabled {
-                    SpecializedScorer::Other(Box::new(
-                        RequiredOptionalScorer::<_, _, TScoreCombiner>::new(
+            (ShouldScorersCombinationMethod::Optional(should_scorer), must_scorers) => {
+                if must_scorers.is_empty() && must_special_scorer_counts.num_all_scorers == 0 {
+                    // Optional options are promoted to required if no must scorers exists.
+                    should_scorer
+                } else {
+                    let must_scorer = intersect_scorers(must_scorers, num_docs);
+                    if self.scoring_enabled {
+                        SpecializedScorer::Other(Box::new(RequiredOptionalScorer::<
+                            _,
+                            _,
+                            TScoreCombiner,
+                        >::new(
                             must_scorer,
                             into_box_scorer(should_scorer, &score_combiner_fn, num_docs),
-                        ),
-                    ))
-                } else {
-                    SpecializedScorer::Other(must_scorer)
+                        )))
+                    } else {
+                        SpecializedScorer::Other(must_scorer)
+                    }
                 }
             }
-            (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))
+            (ShouldScorersCombinationMethod::Required(should_scorer), mut must_scorers) => {
+                if must_scorers.is_empty() {
+                    should_scorer
+                } else {
+                    must_scorers.push(into_box_scorer(should_scorer, &score_combiner_fn, num_docs));
+                    SpecializedScorer::Other(intersect_scorers(must_scorers, num_docs))
+                }
             }
-            (CombinationMethod::Ignored, None) => {
-                return Ok(SpecializedScorer::Other(Box::new(EmptyScorer)))
-            }
-            (CombinationMethod::Required(should_scorer), None) => should_scorer,
-            // Optional options are promoted to required if no must scorers exists.
-            (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 include_scorer_boxed =
+                into_box_scorer(include_scorer, &score_combiner_fn, num_docs);
             Ok(SpecializedScorer::Other(Box::new(Exclude::new(
-                positive_scorer_boxed,
+                include_scorer_boxed,
                 exclude_scorer,
             ))))
         } else {
-            Ok(positive_scorer)
+            Ok(include_scorer)
         }
     }
 }
 
+#[derive(Default, Copy, Clone, Debug)]
+struct AllAndEmptyScorerCounts {
+    num_all_scorers: usize,
+    num_empty_scorers: usize,
+}
+
+fn remove_and_count_all_and_empty_scorers(
+    scorers: &mut Vec<Box<dyn Scorer>>,
+) -> AllAndEmptyScorerCounts {
+    let mut counts = AllAndEmptyScorerCounts::default();
+    scorers.retain(|scorer| {
+        if scorer.is::<AllScorer>() {
+            counts.num_all_scorers += 1;
+            false
+        } else if scorer.is::<EmptyScorer>() {
+            counts.num_empty_scorers += 1;
+            false
+        } else {
+            true
+        }
+    });
+    counts
+}
+
 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();
@@ -293,7 +369,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
 
         let mut explanation = Explanation::new("BooleanClause. sum of ...", scorer.score());
         for (occur, subweight) in &self.weights {
-            if is_positive_occur(*occur) {
+            if is_include_occur(*occur) {
                 if let Ok(child_explanation) = subweight.explain(reader, doc) {
                     explanation.add_detail(child_explanation);
                 }
@@ -377,7 +453,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
     }
 }
 
-fn is_positive_occur(occur: Occur) -> bool {
+fn is_include_occur(occur: Occur) -> bool {
     match occur {
         Occur::Must | Occur::Should => true,
         Occur::MustNot => false,

src/query/boolean_query/mod.rs

@@ -14,8 +14,8 @@ mod tests {
     use crate::collector::TopDocs;
     use crate::query::term_query::TermScorer;
     use crate::query::{
-        EnableScoring, Intersection, Occur, Query, QueryParser, RequiredOptionalScorer, Scorer,
-        SumCombiner, TermQuery,
+        AllScorer, EmptyScorer, EnableScoring, Intersection, Occur, Query, QueryParser,
+        RequiredOptionalScorer, Scorer, SumCombiner, TermQuery,
     };
     use crate::schema::*;
     use crate::{assert_nearly_equals, DocAddress, DocId, Index, IndexWriter, Score};
@@ -182,7 +182,7 @@ mod tests {
         let matching_topdocs = |query: &dyn Query| {
             reader
                 .searcher()
-                .search(query, &TopDocs::with_limit(3))
+                .search(query, &TopDocs::with_limit(3).order_by_score())
                 .unwrap()
         };
 
@@ -311,4 +311,67 @@ mod tests {
         assert_nearly_equals!(explanation.value(), std::f32::consts::LN_2);
         Ok(())
     }
+
+    #[test]
+    pub fn test_boolean_weight_optimization() -> crate::Result<()> {
+        let mut schema_builder = Schema::builder();
+        let text_field = schema_builder.add_text_field("text", TEXT);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+        let mut index_writer: IndexWriter = index.writer_for_tests()?;
+        index_writer.add_document(doc!(text_field=>"hello"))?;
+        index_writer.add_document(doc!(text_field=>"hello happy"))?;
+        index_writer.commit()?;
+        let searcher = index.reader()?.searcher();
+        let term_match_all: Box<dyn Query> = Box::new(TermQuery::new(
+            Term::from_field_text(text_field, "hello"),
+            IndexRecordOption::Basic,
+        ));
+        let term_match_some: Box<dyn Query> = Box::new(TermQuery::new(
+            Term::from_field_text(text_field, "happy"),
+            IndexRecordOption::Basic,
+        ));
+        let term_match_none: Box<dyn Query> = Box::new(TermQuery::new(
+            Term::from_field_text(text_field, "tax"),
+            IndexRecordOption::Basic,
+        ));
+        {
+            let query = BooleanQuery::from(vec![
+                (Occur::Must, term_match_all.box_clone()),
+                (Occur::Must, term_match_some.box_clone()),
+            ]);
+            let weight = query.weight(EnableScoring::disabled_from_searcher(&searcher))?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
+            assert!(scorer.is::<TermScorer>());
+        }
+        {
+            let query = BooleanQuery::from(vec![
+                (Occur::Must, term_match_all.box_clone()),
+                (Occur::Must, term_match_some.box_clone()),
+                (Occur::Must, term_match_none.box_clone()),
+            ]);
+            let weight = query.weight(EnableScoring::disabled_from_searcher(&searcher))?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
+            assert!(scorer.is::<EmptyScorer>());
+        }
+        {
+            let query = BooleanQuery::from(vec![
+                (Occur::Should, term_match_all.box_clone()),
+                (Occur::Should, term_match_none.box_clone()),
+            ]);
+            let weight = query.weight(EnableScoring::disabled_from_searcher(&searcher))?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
+            assert!(scorer.is::<AllScorer>());
+        }
+        {
+            let query = BooleanQuery::from(vec![
+                (Occur::Should, term_match_some.box_clone()),
+                (Occur::Should, term_match_none.box_clone()),
+            ]);
+            let weight = query.weight(EnableScoring::disabled_from_searcher(&searcher))?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
+            assert!(scorer.is::<TermScorer>());
+        }
+        Ok(())
+    }
 }

src/query/disjunction_max_query.rs

@@ -53,7 +53,7 @@ use crate::{Score, Term};
 ///    // TermQuery "diary" and "girl" should be present and only one should be accounted in score
 ///    let queries1 = vec![diary_term_query.box_clone(), girl_term_query.box_clone()];
 ///    let diary_and_girl = DisjunctionMaxQuery::new(queries1);
-///    let documents = searcher.search(&diary_and_girl, &TopDocs::with_limit(3))?;
+///    let documents = searcher.search(&diary_and_girl, &TopDocs::with_limit(3).order_by_score())?;
 ///    assert_eq!(documents[0].0, documents[1].0);
 ///    assert_eq!(documents[1].0, documents[2].0);
 ///
@@ -62,7 +62,7 @@ use crate::{Score, Term};
 ///    let queries2 = vec![diary_term_query.box_clone(), girl_term_query.box_clone()];
 ///    let tie_breaker = 0.7;
 ///    let diary_and_girl_with_tie_breaker = DisjunctionMaxQuery::with_tie_breaker(queries2, tie_breaker);
-///    let documents = searcher.search(&diary_and_girl_with_tie_breaker, &TopDocs::with_limit(3))?;
+///    let documents = searcher.search(&diary_and_girl_with_tie_breaker, &TopDocs::with_limit(3).order_by_score())?;
 ///    assert_eq!(documents[1].0, documents[2].0);
 ///    // For this test all terms brings the same score. So we can do easy math and assume that
 ///    // `DisjunctionMaxQuery` with tie breakers score should be equal

src/query/exist_query.rs

@@ -127,7 +127,11 @@ impl Weight for ExistsWeight {
             .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 boost != 1.0f32 {
+                return Ok(Box::new(BoostScorer::new(all_scorer, boost)));
+            } else {
+                return Ok(Box::new(all_scorer));
+            }
         }
 
         // If we have a single dynamic column, use ExistsDocSet

src/query/fuzzy_query.rs

@@ -67,7 +67,7 @@ impl Automaton for DfaWrapper {
 ///     {
 ///         let term = Term::from_field_text(title, "Diary");
 ///         let query = FuzzyTermQuery::new(term, 1, true);
-///         let (top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2), Count)).unwrap();
+///         let (top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2).order_by_score(), Count)).unwrap();
 ///         assert_eq!(count, 2);
 ///         assert_eq!(top_docs.len(), 2);
 ///     }
@@ -241,7 +241,8 @@ mod test {
         {
             let term = get_json_path_term("attributes.aa:japan")?;
             let fuzzy_query = FuzzyTermQuery::new(term, 2, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected only 1 document");
             assert_eq!(top_docs[0].1.doc_id, 1, "Expected the second document");
         }
@@ -252,7 +253,8 @@ mod test {
             let term = get_json_path_term("attributes.a:japon")?;
 
             let fuzzy_query = FuzzyTermQuery::new(term, 1, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected only 1 document");
             assert_eq!(top_docs[0].1.doc_id, 0, "Expected the first document");
         }
@@ -262,7 +264,8 @@ mod test {
             let term = get_json_path_term("attributes.a:jap")?;
 
             let fuzzy_query = FuzzyTermQuery::new(term, 1, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 0, "Expected no document");
         }
 
@@ -292,7 +295,8 @@ mod test {
         {
             let term = Term::from_field_text(country_field, "japon");
             let fuzzy_query = FuzzyTermQuery::new(term, 1, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected only 1 document");
             let (score, _) = top_docs[0];
             assert_nearly_equals!(1.0, score);
@@ -303,7 +307,8 @@ mod test {
             let term = Term::from_field_text(country_field, "jap");
 
             let fuzzy_query = FuzzyTermQuery::new(term, 1, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 0, "Expected no document");
         }
 
@@ -311,7 +316,8 @@ mod test {
         {
             let term = Term::from_field_text(country_field, "jap");
             let fuzzy_query = FuzzyTermQuery::new_prefix(term, 1, true);
-            let top_docs = searcher.search(&fuzzy_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&fuzzy_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected only 1 document");
             let (score, _) = top_docs[0];
             assert_nearly_equals!(1.0, score);

src/query/mod.rs

@@ -24,6 +24,7 @@ mod reqopt_scorer;
 mod scorer;
 mod set_query;
 mod size_hint;
+mod spatial_query;
 mod term_query;
 mod union;
 mod weight;
@@ -62,6 +63,7 @@ pub use self::reqopt_scorer::RequiredOptionalScorer;
 pub use self::score_combiner::{DisjunctionMaxCombiner, ScoreCombiner, SumCombiner};
 pub use self::scorer::Scorer;
 pub use self::set_query::TermSetQuery;
+pub use self::spatial_query::{SpatialQuery, SpatialQueryType};
 pub use self::term_query::TermQuery;
 pub use self::union::BufferedUnionScorer;
 #[cfg(test)]

src/query/more_like_this/query.rs

@@ -267,7 +267,7 @@ mod tests {
             .with_boost_factor(1.0)
             .with_stop_words(vec!["old".to_string()])
             .with_document(DocAddress::new(0, 0));
-        let top_docs = searcher.search(&query, &TopDocs::with_limit(5))?;
+        let top_docs = searcher.search(&query, &TopDocs::with_limit(5).order_by_score())?;
         let mut doc_ids: Vec<_> = top_docs.iter().map(|item| item.1.doc_id).collect();
         doc_ids.sort_unstable();
 
@@ -283,7 +283,7 @@ mod tests {
             .with_max_word_length(5)
             .with_boost_factor(1.0)
             .with_document(DocAddress::new(0, 4));
-        let top_docs = searcher.search(&query, &TopDocs::with_limit(5))?;
+        let top_docs = searcher.search(&query, &TopDocs::with_limit(5).order_by_score())?;
         let mut doc_ids: Vec<_> = top_docs.iter().map(|item| item.1.doc_id).collect();
         doc_ids.sort_unstable();
 

src/query/query_parser/query_parser.rs

@@ -524,6 +524,9 @@ impl QueryParser {
                 let ip_v6 = IpAddr::from_str(phrase)?.into_ipv6_addr();
                 Ok(Term::from_field_ip_addr(field, ip_v6))
             }
+            FieldType::Spatial(_) => Err(QueryParserError::UnsupportedQuery(
+                "Spatial queries are not yet supported in text query parser".to_string(),
+            )),
         }
     }
 
@@ -624,6 +627,10 @@ impl QueryParser {
                 let term = Term::from_field_ip_addr(field, ip_v6);
                 Ok(vec![LogicalLiteral::Term(term)])
             }
+            FieldType::Spatial(_) => Err(QueryParserError::UnsupportedQuery(format!(
+                "Spatial queries are not yet supported for field '{}'",
+                field_name
+            ))),
         }
     }
 

src/query/range_query/mod.rs

@@ -20,6 +20,6 @@ pub(crate) fn is_type_valid_for_fastfield_range_query(typ: Type) -> bool {
         | Type::Date
         | Type::Json
         | Type::IpAddr => true,
-        Type::Facet | Type::Bytes => false,
+        Type::Facet | Type::Bytes | Type::Spatial => false,
     }
 }

src/query/range_query/range_query.rs

@@ -266,8 +266,9 @@ mod tests {
     use super::RangeQuery;
     use crate::collector::{Count, TopDocs};
     use crate::indexer::NoMergePolicy;
+    use crate::query::range_query::fast_field_range_doc_set::RangeDocSet;
     use crate::query::range_query::range_query::InvertedIndexRangeQuery;
-    use crate::query::QueryParser;
+    use crate::query::{AllScorer, ConstScorer, EmptyScorer, EnableScoring, Query, QueryParser};
     use crate::schema::{
         Field, IntoIpv6Addr, Schema, TantivyDocument, FAST, INDEXED, STORED, TEXT,
     };
@@ -495,7 +496,7 @@ mod tests {
         let searcher = reader.searcher();
         let query_parser = QueryParser::for_index(&index, vec![title]);
         let query = query_parser.parse_query("hemoglobin AND year:[1970 TO 1990]")?;
-        let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
+        let top_docs = searcher.search(&query, &TopDocs::with_limit(10).order_by_score())?;
         assert_eq!(top_docs.len(), 1);
         Ok(())
     }
@@ -549,7 +550,7 @@ mod tests {
 
         let get_num_hits = |query| {
             let (_top_docs, count) = searcher
-                .search(&query, &(TopDocs::with_limit(10), Count))
+                .search(&query, &(TopDocs::with_limit(10).order_by_score(), Count))
                 .unwrap();
             count
         };
@@ -660,4 +661,46 @@ mod tests {
             0
         );
     }
+
+    #[test]
+    fn test_range_query_simplified() {
+        // This test checks that if the targeted column values are entirely
+        // within the range, and the column is full, we end up with a AllScorer.
+        let mut schema_builder = Schema::builder();
+        let u64_field = schema_builder.add_u64_field("u64_field", FAST);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema.clone());
+        let mut index_writer = index.writer_for_tests().unwrap();
+        index_writer.add_document(doc!(u64_field=> 2u64)).unwrap();
+        index_writer.add_document(doc!(u64_field=> 4u64)).unwrap();
+        index_writer.commit().unwrap();
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+        assert_eq!(searcher.segment_readers().len(), 1);
+        let make_term = |value: u64| Term::from_field_u64(u64_field, value);
+        let make_scorer = move |lower_bound: Bound<u64>, upper_bound: Bound<u64>| {
+            let lower_bound_term = lower_bound.map(make_term);
+            let upper_bound_term = upper_bound.map(make_term);
+            let range_query = RangeQuery::new(lower_bound_term, upper_bound_term);
+            let range_weight = range_query
+                .weight(EnableScoring::disabled_from_schema(&schema))
+                .unwrap();
+            let range_scorer = range_weight
+                .scorer(&searcher.segment_readers()[0], 1.0f32)
+                .unwrap();
+            range_scorer
+        };
+        let range_scorer = make_scorer(Bound::Included(1), Bound::Included(4));
+        assert!(range_scorer.is::<AllScorer>());
+        let range_scorer = make_scorer(Bound::Included(0), Bound::Included(2));
+        assert!(range_scorer.is::<ConstScorer<RangeDocSet<u64>>>());
+        let range_scorer = make_scorer(Bound::Included(3), Bound::Included(10));
+        assert!(range_scorer.is::<ConstScorer<RangeDocSet<u64>>>());
+        let range_scorer = make_scorer(Bound::Included(10), Bound::Included(12));
+        assert!(range_scorer.is::<ConstScorer<RangeDocSet<u64>>>());
+        let range_scorer = make_scorer(Bound::Included(0), Bound::Included(1));
+        assert!(range_scorer.is::<EmptyScorer>());
+        let range_scorer = make_scorer(Bound::Included(0), Bound::Excluded(2));
+        assert!(range_scorer.is::<EmptyScorer>());
+    }
 }

src/query/range_query/range_query_fastfield.rs

@@ -6,8 +6,8 @@ use std::net::Ipv6Addr;
 use std::ops::{Bound, RangeInclusive};
 
 use columnar::{
-    Column, ColumnType, MonotonicallyMappableToU128, MonotonicallyMappableToU64, NumericalType,
-    StrColumn,
+    Cardinality, Column, ColumnType, MonotonicallyMappableToU128, MonotonicallyMappableToU64,
+    NumericalType, StrColumn,
 };
 use common::bounds::{BoundsRange, TransformBound};
 
@@ -128,12 +128,15 @@ impl Weight for FastFieldRangeWeight {
                         BoundsRange::new(bounds.lower_bound, bounds.upper_bound),
                     )
                 }
-                Type::Bool | Type::Facet | Type::Bytes | Type::Json | Type::IpAddr => {
-                    Err(crate::TantivyError::InvalidArgument(format!(
-                        "unsupported value bytes type in json term value_bytes {:?}",
-                        term_value.typ()
-                    )))
-                }
+                Type::Bool
+                | Type::Facet
+                | Type::Bytes
+                | Type::Json
+                | Type::IpAddr
+                | Type::Spatial => Err(crate::TantivyError::InvalidArgument(format!(
+                    "unsupported value bytes type in json term value_bytes {:?}",
+                    term_value.typ()
+                ))),
             }
         } else if field_type.is_ip_addr() {
             let parse_ip_from_bytes = |term: &Term| {
@@ -397,6 +400,8 @@ fn search_on_u64_ff(
     boost: Score,
     bounds: BoundsRange<u64>,
 ) -> crate::Result<Box<dyn Scorer>> {
+    let col_min_value = column.min_value();
+    let col_max_value = column.max_value();
     #[expect(clippy::reversed_empty_ranges)]
     let value_range = bound_to_value_range(
         &bounds.lower_bound,
@@ -408,6 +413,22 @@ fn search_on_u64_ff(
     if value_range.is_empty() {
         return Ok(Box::new(EmptyScorer));
     }
+    if col_min_value >= *value_range.start() && col_max_value <= *value_range.end() {
+        // all values in the column are within the range.
+        if column.index.get_cardinality() == Cardinality::Full {
+            if boost != 1.0f32 {
+                return Ok(Box::new(ConstScorer::new(
+                    AllScorer::new(column.num_docs()),
+                    boost,
+                )));
+            } else {
+                return Ok(Box::new(AllScorer::new(column.num_docs())));
+            }
+        } else {
+            // TODO Make it a field presence request for that specific column
+        }
+    }
+
     let docset = RangeDocSet::new(value_range, column);
     Ok(Box::new(ConstScorer::new(docset, boost)))
 }
@@ -417,7 +438,7 @@ pub(crate) fn maps_to_u64_fastfield(typ: Type) -> bool {
     match typ {
         Type::U64 | Type::I64 | Type::F64 | Type::Bool | Type::Date => true,
         Type::IpAddr => false,
-        Type::Str | Type::Facet | Type::Bytes | Type::Json => false,
+        Type::Str | Type::Facet | Type::Bytes | Type::Json | Type::Spatial => false,
     }
 }
 
@@ -509,7 +530,9 @@ mod tests {
 
         let test_query = |query, num_hits| {
             let query = query_parser.parse_query(query).unwrap();
-            let top_docs = searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+            let top_docs = searcher
+                .search(&query, &TopDocs::with_limit(10).order_by_score())
+                .unwrap();
             assert_eq!(top_docs.len(), num_hits);
         };
 
@@ -595,7 +618,9 @@ mod tests {
         let query_parser = QueryParser::for_index(&index, vec![date_field]);
         let test_query = |query, num_hits| {
             let query = query_parser.parse_query(query).unwrap();
-            let top_docs = searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+            let top_docs = searcher
+                .search(&query, &TopDocs::with_limit(10).order_by_score())
+                .unwrap();
             assert_eq!(top_docs.len(), num_hits);
         };
 
@@ -975,7 +1000,9 @@ mod tests {
         let query_parser = QueryParser::for_index(&index, vec![json_field]);
         let test_query = |query, num_hits| {
             let query = query_parser.parse_query(query).unwrap();
-            let top_docs = searcher.search(&query, &TopDocs::with_limit(10)).unwrap();
+            let top_docs = searcher
+                .search(&query, &TopDocs::with_limit(10).order_by_score())
+                .unwrap();
             assert_eq!(top_docs.len(), num_hits);
         };
 

src/query/regex_query.rs

@@ -125,14 +125,20 @@ mod test {
         let searcher = reader.searcher();
         {
             let scored_docs = searcher
-                .search(&query_matching_one, &TopDocs::with_limit(2))
+                .search(
+                    &query_matching_one,
+                    &TopDocs::with_limit(2).order_by_score(),
+                )
                 .unwrap();
             assert_eq!(scored_docs.len(), 1, "Expected only 1 document");
             let (score, _) = scored_docs[0];
             assert_nearly_equals!(1.0, score);
         }
         let top_docs = searcher
-            .search(&query_matching_zero, &TopDocs::with_limit(2))
+            .search(
+                &query_matching_zero,
+                &TopDocs::with_limit(2).order_by_score(),
+            )
             .unwrap();
         assert!(top_docs.is_empty(), "Expected ZERO document");
     }

src/query/set_query.rs

@@ -153,7 +153,8 @@ mod tests {
             let terms = vec![Term::from_field_text(field1, "doc1")];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected 1 document");
             let (score, _) = top_docs[0];
             assert_nearly_equals!(1.0, score);
@@ -164,7 +165,8 @@ mod tests {
             let terms = vec![Term::from_field_text(field1, "doc4")];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(1))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(1).order_by_score())?;
             assert!(top_docs.is_empty(), "Expected 0 document");
         }
 
@@ -176,7 +178,8 @@ mod tests {
             ];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 2, "Expected 2 documents");
             for (score, _) in top_docs {
                 assert_nearly_equals!(1.0, score);
@@ -192,7 +195,8 @@ mod tests {
             ];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(3))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(3).order_by_score())?;
 
             assert_eq!(top_docs.len(), 2, "Expected 2 document");
             for (score, _) in top_docs {
@@ -205,13 +209,15 @@ mod tests {
             let terms = vec![Term::from_field_text(field1, "doc3")];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(3))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(3).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected 1 document");
 
             let terms = vec![Term::from_field_text(field2, "doc3")];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(3))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(3).order_by_score())?;
             assert_eq!(top_docs.len(), 1, "Expected 1 document");
 
             let terms = vec![
@@ -220,7 +226,8 @@ mod tests {
             ];
 
             let term_set_query = TermSetQuery::new(terms);
-            let top_docs = searcher.search(&term_set_query, &TopDocs::with_limit(3))?;
+            let top_docs =
+                searcher.search(&term_set_query, &TopDocs::with_limit(3).order_by_score())?;
             assert_eq!(top_docs.len(), 2, "Expected 2 document");
         }
 
@@ -249,7 +256,7 @@ mod tests {
         let searcher = reader.searcher();
         let query_parser = QueryParser::for_index(&index, vec![]);
         let query = query_parser.parse_query("field: IN [val1 val2]")?;
-        let top_docs = searcher.search(&query, &TopDocs::with_limit(3))?;
+        let top_docs = searcher.search(&query, &TopDocs::with_limit(3).order_by_score())?;
         assert_eq!(top_docs.len(), 2);
         Ok(())
     }

src/query/spatial_query.rs

@@ -0,0 +1,186 @@
+//! HUSH
+
+use common::BitSet;
+
+use crate::query::explanation::does_not_match;
+use crate::query::{BitSetDocSet, Explanation, Query, Scorer, Weight};
+use crate::schema::Field;
+use crate::spatial::bkd::{search_intersects, Segment};
+use crate::spatial::point::GeoPoint;
+use crate::spatial::writer::as_point_i32;
+use crate::{DocId, DocSet, Score, TantivyError, TERMINATED};
+
+#[derive(Clone, Copy, Debug)]
+/// HUSH
+pub enum SpatialQueryType {
+    /// HUSH
+    Intersects,
+    //      Within,
+    // Contains,
+}
+
+#[derive(Clone, Copy, Debug)]
+/// HUSH
+pub struct SpatialQuery {
+    field: Field,
+    bounds: [(i32, i32); 2],
+    query_type: SpatialQueryType,
+}
+
+impl SpatialQuery {
+    /// HUSH
+    pub fn new(field: Field, bounds: [GeoPoint; 2], query_type: SpatialQueryType) -> Self {
+        SpatialQuery {
+            field,
+            bounds: [as_point_i32(bounds[0]), as_point_i32(bounds[1])],
+            query_type,
+        }
+    }
+}
+
+impl Query for SpatialQuery {
+    fn weight(
+        &self,
+        _enable_scoring: super::EnableScoring<'_>,
+    ) -> crate::Result<Box<dyn super::Weight>> {
+        Ok(Box::new(SpatialWeight::new(
+            self.field,
+            self.bounds,
+            self.query_type,
+        )))
+    }
+}
+
+pub struct SpatialWeight {
+    field: Field,
+    bounds: [(i32, i32); 2],
+    query_type: SpatialQueryType,
+}
+
+impl SpatialWeight {
+    fn new(field: Field, bounds: [(i32, i32); 2], query_type: SpatialQueryType) -> Self {
+        SpatialWeight {
+            field,
+            bounds,
+            query_type,
+        }
+    }
+}
+
+impl Weight for SpatialWeight {
+    fn scorer(
+        &self,
+        reader: &crate::SegmentReader,
+        boost: crate::Score,
+    ) -> crate::Result<Box<dyn super::Scorer>> {
+        let spatial_reader = reader
+            .spatial_fields()
+            .get_field(self.field)?
+            .ok_or_else(|| TantivyError::SchemaError(format!("No spatial data for field")))?;
+        let block_kd_tree = Segment::new(spatial_reader.get_bytes());
+        match self.query_type {
+            SpatialQueryType::Intersects => {
+                let mut include = BitSet::with_max_value(reader.max_doc());
+                search_intersects(
+                    &block_kd_tree,
+                    block_kd_tree.root_offset,
+                    &[
+                        self.bounds[0].1,
+                        self.bounds[0].0,
+                        self.bounds[1].1,
+                        self.bounds[1].0,
+                    ],
+                    &mut include,
+                )?;
+                Ok(Box::new(SpatialScorer::new(boost, include, None)))
+            }
+        }
+    }
+    fn explain(
+        &self,
+        reader: &crate::SegmentReader,
+        doc: DocId,
+    ) -> crate::Result<super::Explanation> {
+        let mut scorer = self.scorer(reader, 1.0)?;
+        if scorer.seek(doc) != doc {
+            return Err(does_not_match(doc));
+        }
+        let query_type_desc = match self.query_type {
+            SpatialQueryType::Intersects => "SpatialQuery::Intersects",
+        };
+        let score = scorer.score();
+        let mut explanation = Explanation::new(query_type_desc, score);
+        explanation.add_context(format!(
+            "bounds: [({}, {}), ({}, {})]",
+            self.bounds[0].0, self.bounds[0].1, self.bounds[1].0, self.bounds[1].1,
+        ));
+        explanation.add_context(format!("field: {:?}", self.field));
+        Ok(explanation)
+    }
+}
+
+struct SpatialScorer {
+    include: BitSetDocSet,
+    exclude: Option<BitSet>,
+    doc_id: DocId,
+    score: Score,
+}
+
+impl SpatialScorer {
+    pub fn new(score: Score, include: BitSet, exclude: Option<BitSet>) -> Self {
+        let mut scorer = SpatialScorer {
+            include: BitSetDocSet::from(include),
+            exclude,
+            doc_id: 0,
+            score,
+        };
+        scorer.prime();
+        scorer
+    }
+    fn prime(&mut self) {
+        self.doc_id = self.include.doc();
+        while self.exclude() {
+            self.doc_id = self.include.advance();
+        }
+    }
+
+    fn exclude(&self) -> bool {
+        if self.doc_id == TERMINATED {
+            return false;
+        }
+        match &self.exclude {
+            Some(exclude) => exclude.contains(self.doc_id),
+            None => false,
+        }
+    }
+}
+
+impl Scorer for SpatialScorer {
+    fn score(&mut self) -> Score {
+        self.score
+    }
+}
+
+impl DocSet for SpatialScorer {
+    fn advance(&mut self) -> DocId {
+        if self.doc_id == TERMINATED {
+            return TERMINATED;
+        }
+        self.doc_id = self.include.advance();
+        while self.exclude() {
+            self.doc_id = self.include.advance();
+        }
+        self.doc_id
+    }
+
+    fn size_hint(&self) -> u32 {
+        match &self.exclude {
+            Some(exclude) => self.include.size_hint() - exclude.len() as u32,
+            None => self.include.size_hint(),
+        }
+    }
+
+    fn doc(&self) -> DocId {
+        self.doc_id
+    }
+}

src/query/term_query/mod.rs

@@ -10,7 +10,10 @@ mod tests {
     use crate::collector::TopDocs;
     use crate::docset::DocSet;
     use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
-    use crate::query::{EnableScoring, Query, QueryParser, Scorer, TermQuery};
+    use crate::query::term_query::TermScorer;
+    use crate::query::{
+        AllScorer, EmptyScorer, EnableScoring, Query, QueryParser, Scorer, TermQuery,
+    };
     use crate::schema::{Field, IndexRecordOption, Schema, FAST, STRING, TEXT};
     use crate::{assert_nearly_equals, DocAddress, Index, IndexWriter, Term, TERMINATED};
 
@@ -97,7 +100,7 @@ mod tests {
         {
             let term = Term::from_field_text(left_field, "left2");
             let term_query = TermQuery::new(term, IndexRecordOption::WithFreqs);
-            let topdocs = searcher.search(&term_query, &TopDocs::with_limit(2))?;
+            let topdocs = searcher.search(&term_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(topdocs.len(), 1);
             let (score, _) = topdocs[0];
             assert_nearly_equals!(0.77802235, score);
@@ -105,7 +108,8 @@ mod tests {
         {
             let term = Term::from_field_text(left_field, "left1");
             let term_query = TermQuery::new(term, IndexRecordOption::WithFreqs);
-            let top_docs = searcher.search(&term_query, &TopDocs::with_limit(2))?;
+            let top_docs =
+                searcher.search(&term_query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 2);
             let (score1, _) = top_docs[0];
             assert_nearly_equals!(0.27101856, score1);
@@ -115,7 +119,7 @@ mod tests {
         {
             let query_parser = QueryParser::for_index(&index, Vec::new());
             let query = query_parser.parse_query("left:left2 left:left1")?;
-            let top_docs = searcher.search(&query, &TopDocs::with_limit(2))?;
+            let top_docs = searcher.search(&query, &TopDocs::with_limit(2).order_by_score())?;
             assert_eq!(top_docs.len(), 2);
             let (score1, _) = top_docs[0];
             assert_nearly_equals!(0.9153879, score1);
@@ -435,9 +439,87 @@ mod tests {
 
         // 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));
+        let res = searcher.search(&tq, &TopDocs::with_limit(1).order_by_score());
         assert!(matches!(res, Err(crate::TantivyError::SchemaError(_))));
 
         Ok(())
     }
+
+    #[test]
+    fn test_term_weight_all_query_optimization() {
+        let mut schema_builder = Schema::builder();
+        let text_field = schema_builder.add_text_field("text", crate::schema::TEXT);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema.clone());
+        let mut index_writer = index.writer_for_tests().unwrap();
+        index_writer
+            .add_document(doc!(text_field=>"hello"))
+            .unwrap();
+        index_writer
+            .add_document(doc!(text_field=>"hello happy"))
+            .unwrap();
+        index_writer.commit().unwrap();
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+        let get_scorer_for_term = |term: &str| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, term),
+                IndexRecordOption::Basic,
+            );
+            let term_weight = term_query
+                .weight(EnableScoring::disabled_from_schema(&schema))
+                .unwrap();
+            term_weight
+                .scorer(searcher.segment_reader(0u32), 1.0f32)
+                .unwrap()
+        };
+        // Should be an allscorer
+        let match_all_scorer = get_scorer_for_term("hello");
+        // Should be a term scorer
+        let match_some_scorer = get_scorer_for_term("happy");
+        // Should be an empty scorer
+        let empty_scorer = get_scorer_for_term("tax");
+        assert!(match_all_scorer.is::<AllScorer>());
+        assert!(match_some_scorer.is::<TermScorer>());
+        assert!(empty_scorer.is::<EmptyScorer>());
+    }
+
+    #[test]
+    fn test_term_weight_all_query_optimization_disable_when_scoring_enabled() {
+        let mut schema_builder = Schema::builder();
+        let text_field = schema_builder.add_text_field("text", crate::schema::TEXT);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema.clone());
+        let mut index_writer = index.writer_for_tests().unwrap();
+        index_writer
+            .add_document(doc!(text_field=>"hello"))
+            .unwrap();
+        index_writer
+            .add_document(doc!(text_field=>"hello happy"))
+            .unwrap();
+        index_writer.commit().unwrap();
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+        let get_scorer_for_term = |term: &str| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, term),
+                IndexRecordOption::Basic,
+            );
+            let term_weight = term_query
+                .weight(EnableScoring::enabled_from_searcher(&searcher))
+                .unwrap();
+            term_weight
+                .scorer(searcher.segment_reader(0u32), 1.0f32)
+                .unwrap()
+        };
+        // Should be an allscorer
+        let match_all_scorer = get_scorer_for_term("hello");
+        // Should be a term scorer
+        let one_scorer = get_scorer_for_term("happy");
+        // Should be an empty scorer
+        let empty_scorer = get_scorer_for_term("tax");
+        assert!(match_all_scorer.is::<TermScorer>());
+        assert!(one_scorer.is::<TermScorer>());
+        assert!(empty_scorer.is::<EmptyScorer>());
+    }
 }

src/query/term_query/term_query.rs

@@ -50,7 +50,7 @@ use crate::Term;
 ///     Term::from_field_text(title, "diary"),
 ///     IndexRecordOption::Basic,
 /// );
-/// let (top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2), Count))?;
+/// let (top_docs, count) = searcher.search(&query, &(TopDocs::with_limit(2).order_by_score(), Count))?;
 /// assert_eq!(count, 2);
 /// Ok(())
 /// # }
@@ -101,7 +101,7 @@ impl TermQuery {
             EnableScoring::Enabled {
                 statistics_provider,
                 ..
-            } => Bm25Weight::for_terms(statistics_provider, &[self.term.clone()])?,
+            } => Bm25Weight::for_terms(statistics_provider, std::slice::from_ref(&self.term))?,
             EnableScoring::Disabled { .. } => {
                 Bm25Weight::new(Explanation::new("<no score>", 1.0f32), 1.0f32)
             }
@@ -190,7 +190,7 @@ mod tests {
 
         let assert_single_hit = |query| {
             let (_top_docs, count) = searcher
-                .search(&query, &(TopDocs::with_limit(2), Count))
+                .search(&query, &(TopDocs::with_limit(2).order_by_score(), Count))
                 .unwrap();
             assert_eq!(count, 1);
         };

src/query/term_query/term_scorer.rs

@@ -259,7 +259,7 @@ mod tests {
             let mut block_max_scores_b = vec![];
             let mut docs = vec![];
             {
-                let mut term_scorer = term_weight.specialized_scorer(reader, 1.0)?;
+                let mut term_scorer = term_weight.term_scorer_for_test(reader, 1.0)?.unwrap();
                 while term_scorer.doc() != TERMINATED {
                     let mut score = term_scorer.score();
                     docs.push(term_scorer.doc());
@@ -273,7 +273,7 @@ mod tests {
                 }
             }
             {
-                let mut term_scorer = term_weight.specialized_scorer(reader, 1.0)?;
+                let mut term_scorer = term_weight.term_scorer_for_test(reader, 1.0)?.unwrap();
                 for d in docs {
                     term_scorer.seek_block(d);
                     block_max_scores_b.push(term_scorer.block_max_score());

src/query/term_query/term_weight.rs

@@ -6,9 +6,9 @@ use crate::postings::SegmentPostings;
 use crate::query::bm25::Bm25Weight;
 use crate::query::explanation::does_not_match;
 use crate::query::weight::{for_each_docset_buffered, for_each_scorer};
-use crate::query::{Explanation, Scorer, Weight};
+use crate::query::{AllScorer, AllWeight, EmptyScorer, Explanation, Scorer, Weight};
 use crate::schema::IndexRecordOption;
-use crate::{DocId, Score, Term};
+use crate::{DocId, Score, TantivyError, Term};
 
 pub struct TermWeight {
     term: Term,
@@ -17,20 +17,40 @@ pub struct TermWeight {
     scoring_enabled: bool,
 }
 
+enum TermOrEmptyOrAllScorer {
+    TermScorer(Box<TermScorer>),
+    Empty,
+    AllMatch(AllScorer),
+}
+
+impl TermOrEmptyOrAllScorer {
+    pub fn into_boxed_scorer(self) -> Box<dyn Scorer> {
+        match self {
+            TermOrEmptyOrAllScorer::TermScorer(scorer) => scorer,
+            TermOrEmptyOrAllScorer::Empty => Box::new(EmptyScorer),
+            TermOrEmptyOrAllScorer::AllMatch(scorer) => Box::new(scorer),
+        }
+    }
+}
+
 impl Weight for TermWeight {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
-        let term_scorer = self.specialized_scorer(reader, boost)?;
-        Ok(Box::new(term_scorer))
+        Ok(self.specialized_scorer(reader, boost)?.into_boxed_scorer())
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.specialized_scorer(reader, 1.0)?;
-        if scorer.doc() > doc || scorer.seek(doc) != doc {
-            return Err(does_not_match(doc));
+        match self.specialized_scorer(reader, 1.0)? {
+            TermOrEmptyOrAllScorer::TermScorer(mut term_scorer) => {
+                if term_scorer.doc() > doc || term_scorer.seek(doc) != doc {
+                    return Err(does_not_match(doc));
+                }
+                let mut explanation = term_scorer.explain();
+                explanation.add_context(format!("Term={:?}", self.term,));
+                Ok(explanation)
+            }
+            TermOrEmptyOrAllScorer::Empty => Err(does_not_match(doc)),
+            TermOrEmptyOrAllScorer::AllMatch(_) => AllWeight.explain(reader, doc),
         }
-        let mut explanation = scorer.explain();
-        explanation.add_context(format!("Term={:?}", self.term,));
-        Ok(explanation)
     }
 
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
@@ -51,8 +71,15 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
-        let mut scorer = self.specialized_scorer(reader, 1.0)?;
-        for_each_scorer(&mut scorer, callback);
+        match self.specialized_scorer(reader, 1.0)? {
+            TermOrEmptyOrAllScorer::TermScorer(mut term_scorer) => {
+                for_each_scorer(&mut *term_scorer, callback);
+            }
+            TermOrEmptyOrAllScorer::Empty => {}
+            TermOrEmptyOrAllScorer::AllMatch(mut all_scorer) => {
+                for_each_scorer(&mut all_scorer, callback);
+            }
+        }
         Ok(())
     }
 
@@ -63,9 +90,18 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(&[DocId]),
     ) -> crate::Result<()> {
-        let mut scorer = self.specialized_scorer(reader, 1.0)?;
-        let mut buffer = [0u32; COLLECT_BLOCK_BUFFER_LEN];
-        for_each_docset_buffered(&mut scorer, &mut buffer, callback);
+        match self.specialized_scorer(reader, 1.0)? {
+            TermOrEmptyOrAllScorer::TermScorer(mut term_scorer) => {
+                let mut buffer = [0u32; COLLECT_BLOCK_BUFFER_LEN];
+                for_each_docset_buffered(&mut term_scorer, &mut buffer, callback);
+            }
+            TermOrEmptyOrAllScorer::Empty => {}
+            TermOrEmptyOrAllScorer::AllMatch(mut all_scorer) => {
+                let mut buffer = [0u32; COLLECT_BLOCK_BUFFER_LEN];
+                for_each_docset_buffered(&mut all_scorer, &mut buffer, callback);
+            }
+        };
+
         Ok(())
     }
 
@@ -85,8 +121,22 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score) -> Score,
     ) -> crate::Result<()> {
-        let scorer = self.specialized_scorer(reader, 1.0)?;
-        crate::query::boolean_query::block_wand_single_scorer(scorer, threshold, callback);
+        let specialized_scorer = self.specialized_scorer(reader, 1.0)?;
+        match specialized_scorer {
+            TermOrEmptyOrAllScorer::TermScorer(term_scorer) => {
+                crate::query::boolean_query::block_wand_single_scorer(
+                    *term_scorer,
+                    threshold,
+                    callback,
+                );
+            }
+            TermOrEmptyOrAllScorer::Empty => {}
+            TermOrEmptyOrAllScorer::AllMatch(_) => {
+                return Err(TantivyError::InvalidArgument(
+                    "for each pruning should only be called if scoring is enabled".to_string(),
+                ));
+            }
+        }
         Ok(())
     }
 }
@@ -110,35 +160,61 @@ impl TermWeight {
         &self.term
     }
 
-    pub(crate) fn specialized_scorer(
+    /// We need a method to access the actual `TermScorer` implementation
+    /// for `white box` test, checking in particular that the block max
+    /// is correct.
+    #[cfg(test)]
+    pub(crate) fn term_scorer_for_test(
         &self,
         reader: &SegmentReader,
         boost: Score,
-    ) -> crate::Result<TermScorer> {
+    ) -> crate::Result<Option<TermScorer>> {
+        let scorer = self.specialized_scorer(reader, boost)?;
+        Ok(match scorer {
+            TermOrEmptyOrAllScorer::TermScorer(scorer) => Some(*scorer),
+            _ => None,
+        })
+    }
+
+    fn specialized_scorer(
+        &self,
+        reader: &SegmentReader,
+        boost: Score,
+    ) -> crate::Result<TermOrEmptyOrAllScorer> {
         let field = self.term.field();
         let inverted_index = reader.inverted_index(field)?;
-        let fieldnorm_reader_opt = if self.scoring_enabled {
-            reader.fieldnorms_readers().get_field(field)?
-        } else {
-            None
+        let Some(term_info) = inverted_index.get_term_info(&self.term)? else {
+            // The term was not found.
+            return Ok(TermOrEmptyOrAllScorer::Empty);
         };
-        let fieldnorm_reader =
-            fieldnorm_reader_opt.unwrap_or_else(|| FieldNormReader::constant(reader.max_doc(), 1));
-        let similarity_weight = self.similarity_weight.boost_by(boost);
-        let postings_opt: Option<SegmentPostings> =
-            inverted_index.read_postings(&self.term, self.index_record_option)?;
-        if let Some(segment_postings) = postings_opt {
-            Ok(TermScorer::new(
-                segment_postings,
-                fieldnorm_reader,
-                similarity_weight,
-            ))
-        } else {
-            Ok(TermScorer::new(
-                SegmentPostings::empty(),
-                fieldnorm_reader,
-                similarity_weight,
-            ))
+
+        // If we don't care about scores, and our posting lists matches all doc, we can return the
+        // AllMatch scorer.
+        if !self.scoring_enabled && term_info.doc_freq == reader.max_doc() {
+            return Ok(TermOrEmptyOrAllScorer::AllMatch(AllScorer::new(
+                reader.max_doc(),
+            )));
         }
+
+        let segment_postings: SegmentPostings =
+            inverted_index.read_postings_from_terminfo(&term_info, self.index_record_option)?;
+
+        let fieldnorm_reader = self.fieldnorm_reader(reader)?;
+        let similarity_weight = self.similarity_weight.boost_by(boost);
+        Ok(TermOrEmptyOrAllScorer::TermScorer(Box::new(
+            TermScorer::new(segment_postings, fieldnorm_reader, similarity_weight),
+        )))
+    }
+
+    fn fieldnorm_reader(&self, segment_reader: &SegmentReader) -> crate::Result<FieldNormReader> {
+        if self.scoring_enabled {
+            if let Some(field_norm_reader) = segment_reader
+                .fieldnorms_readers()
+                .get_field(self.term.field())?
+            {
+                return Ok(field_norm_reader);
+            }
+        }
+        Ok(FieldNormReader::constant(segment_reader.max_doc(), 1))
     }
 }

src/schema/document/de.rs

@@ -22,6 +22,7 @@ use super::se::BinaryObjectSerializer;
 use super::{OwnedValue, Value};
 use crate::schema::document::type_codes;
 use crate::schema::{Facet, Field};
+use crate::spatial::geometry::Geometry;
 use crate::store::DocStoreVersion;
 use crate::tokenizer::PreTokenizedString;
 
@@ -129,6 +130,9 @@ pub trait ValueDeserializer<'de> {
     /// Attempts to deserialize a pre-tokenized string value from the deserializer.
     fn deserialize_pre_tokenized_string(self) -> Result<PreTokenizedString, DeserializeError>;
 
+    /// HUSH
+    fn deserialize_geometry(self) -> Result<Geometry, DeserializeError>;
+
     /// Attempts to deserialize the value using a given visitor.
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DeserializeError>
     where V: ValueVisitor;
@@ -166,6 +170,8 @@ pub enum ValueType {
     /// A JSON object value. Deprecated.
     #[deprecated(note = "We keep this for backwards compatibility, use Object instead")]
     JSONObject,
+    /// HUSH
+    Geometry,
 }
 
 /// A value visitor for deserializing a document value.
@@ -246,6 +252,12 @@ pub trait ValueVisitor {
         Err(DeserializeError::UnsupportedType(ValueType::PreTokStr))
     }
 
+    #[inline]
+    /// Called when the deserializer visits a geometry value.
+    fn visit_geometry(&self, _val: Geometry) -> Result<Self::Value, DeserializeError> {
+        Err(DeserializeError::UnsupportedType(ValueType::Geometry))
+    }
+
     #[inline]
     /// Called when the deserializer visits an array.
     fn visit_array<'de, A>(&self, _access: A) -> Result<Self::Value, DeserializeError>
@@ -380,6 +392,7 @@ where R: Read
 
                 match ext_type_code {
                     type_codes::TOK_STR_EXT_CODE => ValueType::PreTokStr,
+                    type_codes::GEO_EXT_CODE => ValueType::Geometry,
                     _ => {
                         return Err(DeserializeError::from(io::Error::new(
                             io::ErrorKind::InvalidData,
@@ -495,6 +508,11 @@ where R: Read
             .map_err(DeserializeError::from)
     }
 
+    fn deserialize_geometry(self) -> Result<Geometry, DeserializeError> {
+        self.validate_type(ValueType::Geometry)?;
+        <Geometry as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
+    }
+
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DeserializeError>
     where V: ValueVisitor {
         match self.value_type {
@@ -539,6 +557,10 @@ where R: Read
                 let val = self.deserialize_pre_tokenized_string()?;
                 visitor.visit_pre_tokenized_string(val)
             }
+            ValueType::Geometry => {
+                let val = self.deserialize_geometry()?;
+                visitor.visit_geometry(val)
+            }
             ValueType::Array => {
                 let access =
                     BinaryArrayDeserializer::from_reader(self.reader, self.doc_store_version)?;

src/schema/document/default_document.rs

@@ -13,6 +13,7 @@ use crate::schema::document::{
 };
 use crate::schema::field_type::ValueParsingError;
 use crate::schema::{Facet, Field, NamedFieldDocument, OwnedValue, Schema};
+use crate::spatial::geometry::Geometry;
 use crate::tokenizer::PreTokenizedString;
 
 #[repr(C, packed)]
@@ -254,6 +255,7 @@ impl CompactDoc {
             }
             ReferenceValueLeaf::IpAddr(num) => write_into(&mut self.node_data, num.to_u128()),
             ReferenceValueLeaf::PreTokStr(pre_tok) => write_into(&mut self.node_data, *pre_tok),
+            ReferenceValueLeaf::Geometry(geometry) => write_into(&mut self.node_data, *geometry),
         };
         ValueAddr { type_id, val_addr }
     }
@@ -464,6 +466,12 @@ impl<'a> CompactDocValue<'a> {
                 .map(Into::into)
                 .map(ReferenceValueLeaf::PreTokStr)
                 .map(Into::into),
+            ValueType::Geometry => self
+                .container
+                .read_from::<Geometry>(addr)
+                .map(Into::into)
+                .map(ReferenceValueLeaf::Geometry)
+                .map(Into::into),
             ValueType::Object => Ok(ReferenceValue::Object(CompactDocObjectIter::new(
                 self.container,
                 addr,
@@ -542,6 +550,8 @@ pub enum ValueType {
     Object = 11,
     /// Pre-tokenized str type,
     Array = 12,
+    /// HUSH
+    Geometry = 13,
 }
 
 impl BinarySerializable for ValueType {
@@ -587,6 +597,7 @@ impl<'a> From<&ReferenceValueLeaf<'a>> for ValueType {
             ReferenceValueLeaf::PreTokStr(_) => ValueType::PreTokStr,
             ReferenceValueLeaf::Facet(_) => ValueType::Facet,
             ReferenceValueLeaf::Bytes(_) => ValueType::Bytes,
+            ReferenceValueLeaf::Geometry(_) => ValueType::Geometry,
         }
     }
 }

src/schema/document/mod.rs

@@ -26,7 +26,7 @@
 //! significant amount of time when indexing by avoiding the additional allocations.
 //!
 //! ### Important Note
-//! The implementor of the `Document` trait must be `'static` and safe to send across
+//! The implementer of the `Document` trait must be `'static` and safe to send across
 //! thread boundaries.
 //!
 //! ## Reusing existing types
@@ -107,7 +107,7 @@
 //!
 //! Values can just as easily be customised as documents by implementing the `Value` trait.
 //!
-//! The implementor of this type should not own the data it's returning, instead it should just
+//! The implementer of this type should not own the data it's returning, instead it should just
 //! hold references of the data held by the parent [Document] which can then be passed
 //! on to the [ReferenceValue].
 //!
@@ -117,7 +117,7 @@
 //!
 //! ### A note about returning values
 //! The custom value type does not have to be the type stored by the document, instead the
-//! implementor of a `Value` can just be used as a way to convert between the owned type
+//! implementer of a `Value` can just be used as a way to convert between the owned type
 //! kept in the parent document, and the value passed into Tantivy.
 //!
 //! ```
@@ -273,4 +273,5 @@ pub(crate) mod type_codes {
 
     // Extended type codes
     pub const TOK_STR_EXT_CODE: u8 = 0;
+    pub const GEO_EXT_CODE: u8 = 1;
 }

src/schema/document/owned_value.rs

@@ -15,6 +15,7 @@ use crate::schema::document::{
     ValueDeserializer, ValueVisitor,
 };
 use crate::schema::Facet;
+use crate::spatial::geometry::Geometry;
 use crate::tokenizer::PreTokenizedString;
 use crate::DateTime;
 
@@ -49,6 +50,8 @@ pub enum OwnedValue {
     Object(Vec<(String, Self)>),
     /// IpV6 Address. Internally there is no IpV4, it needs to be converted to `Ipv6Addr`.
     IpAddr(Ipv6Addr),
+    /// A GeoRust multi-polygon.
+    Geometry(Geometry),
 }
 
 impl AsRef<OwnedValue> for OwnedValue {
@@ -77,6 +80,9 @@ impl<'a> Value<'a> for &'a OwnedValue {
             OwnedValue::IpAddr(val) => ReferenceValueLeaf::IpAddr(*val).into(),
             OwnedValue::Array(array) => ReferenceValue::Array(array.iter()),
             OwnedValue::Object(object) => ReferenceValue::Object(ObjectMapIter(object.iter())),
+            OwnedValue::Geometry(geometry) => {
+                ReferenceValueLeaf::Geometry(Box::new(geometry.clone())).into()
+            }
         }
     }
 }
@@ -136,6 +142,10 @@ impl ValueDeserialize for OwnedValue {
                 Ok(OwnedValue::PreTokStr(val))
             }
 
+            fn visit_geometry(&self, val: Geometry) -> Result<Self::Value, DeserializeError> {
+                Ok(OwnedValue::Geometry(val))
+            }
+
             fn visit_array<'de, A>(&self, mut access: A) -> Result<Self::Value, DeserializeError>
             where A: ArrayAccess<'de> {
                 let mut elements = Vec::with_capacity(access.size_hint());
@@ -198,6 +208,7 @@ impl serde::Serialize for OwnedValue {
                 }
             }
             OwnedValue::Array(ref array) => array.serialize(serializer),
+            OwnedValue::Geometry(ref geometry) => geometry.to_geojson().serialize(serializer),
         }
     }
 }
@@ -285,6 +296,7 @@ impl<'a, V: Value<'a>> From<ReferenceValue<'a, V>> for OwnedValue {
                 ReferenceValueLeaf::IpAddr(val) => OwnedValue::IpAddr(val),
                 ReferenceValueLeaf::Bool(val) => OwnedValue::Bool(val),
                 ReferenceValueLeaf::PreTokStr(val) => OwnedValue::PreTokStr(*val.clone()),
+                ReferenceValueLeaf::Geometry(val) => OwnedValue::Geometry(*val.clone()),
             },
             ReferenceValue::Array(val) => {
                 OwnedValue::Array(val.map(|v| v.as_value().into()).collect())