Making stemming optional. (#2791)

Fixed code and CI to run on no default features.

Co-authored-by: Paul Masurel <paul.masurel@datadoghq.com>

.github/workflows/test.yml

@@ -39,11 +39,11 @@ jobs:
 
     - name: Check Formatting
       run: cargo +nightly fmt --all -- --check
-    
+
     - name: Check Stable Compilation
       run: cargo build --all-features
 
-    
+
     - name: Check Bench Compilation
       run: cargo +nightly bench --no-run --profile=dev --all-features
 
@@ -59,10 +59,10 @@ jobs:
 
     strategy:
       matrix:
-        features: [
-            { label: "all", flags: "mmap,stopwords,lz4-compression,zstd-compression,failpoints" },
-            { label: "quickwit", flags: "mmap,quickwit,failpoints" }
-        ]
+        features:
+          - { label: "all", flags: "mmap,stopwords,lz4-compression,zstd-compression,failpoints,stemmer" }
+          - { label: "quickwit", flags: "mmap,quickwit,failpoints" }
+          - { label: "none", flags: "" }
 
     name: test-${{ matrix.features.label}}
 
@@ -80,7 +80,21 @@ jobs:
     - uses: Swatinem/rust-cache@v2
 
     - name: Run tests
-      run: cargo +stable nextest run --features ${{ matrix.features.flags }} --verbose --workspace
+      run: |
+        # if matrix.feature.flags is empty then run on --lib to avoid compiling examples
+        # (as most of them rely on mmap) otherwise run all
+        if [ -z "${{ matrix.features.flags }}" ]; then
+          cargo +stable nextest run --lib --no-default-features --verbose --workspace
+        else
+          cargo +stable nextest run --features ${{ matrix.features.flags }} --no-default-features --verbose --workspace
+        fi
 
     - name: Run doctests
-      run: cargo +stable test --doc --features ${{ matrix.features.flags }} --verbose --workspace
+      run: |
+        # if matrix.feature.flags is empty then run on --lib to avoid compiling examples
+        # (as most of them rely on mmap) otherwise run all
+        if [ -z "${{ matrix.features.flags }}" ]; then
+          echo "no doctest for no feature flag"
+        else
+          cargo +stable test --doc --features ${{ matrix.features.flags }} --verbose --workspace
+        fi

Cargo.toml

@@ -37,7 +37,7 @@ fs4 = { version = "0.13.1", optional = true }
 levenshtein_automata = "0.2.1"
 uuid = { version = "1.0.0", features = ["v4", "serde"] }
 crossbeam-channel = "0.5.4"
-rust-stemmers = "1.2.0"
+rust-stemmers = { version = "1.2.0", optional = true }
 downcast-rs = "2.0.1"
 bitpacking = { version = "0.9.2", default-features = false, features = [
     "bitpacker4x",
@@ -113,7 +113,8 @@ debug-assertions = true
 overflow-checks = true
 
 [features]
-default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression"]
+default = ["mmap", "stopwords", "lz4-compression", "columnar-zstd-compression", "stemmer"]
+stemmer = ["rust-stemmers"]
 mmap = ["fs4", "tempfile", "memmap2"]
 stopwords = []
 

src/aggregation/bucket/filter.rs

@@ -446,7 +446,7 @@ impl DocumentQueryEvaluator {
         let weight = query.weight(EnableScoring::disabled_from_schema(&schema))?;
 
         // Get a scorer that iterates over matching documents
-        let mut scorer = weight.scorer(segment_reader, 1.0, 0)?;
+        let mut scorer = weight.scorer(segment_reader, 1.0)?;
 
         // Create a BitSet to hold all matching documents
         let mut bitset = BitSet::with_max_value(max_doc);

src/collector/sort_key/mod.rs

@@ -1,10 +1,12 @@
 mod order;
+mod sort_by_erased_type;
 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_erased_type::SortByErasedType;
 pub use sort_by_score::SortBySimilarityScore;
 pub use sort_by_static_fast_value::SortByStaticFastValue;
 pub use sort_by_string::SortByString;
@@ -34,11 +36,13 @@ pub(crate) mod tests {
     use std::collections::HashMap;
     use std::ops::Range;
 
-    use crate::collector::sort_key::{SortBySimilarityScore, SortByStaticFastValue, SortByString};
+    use crate::collector::sort_key::{
+        SortByErasedType, 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::schema::{OwnedValue, Schema, FAST, TEXT};
     use crate::{DocAddress, Document, Index, Order, Score, Searcher};
 
     fn make_index() -> crate::Result<Index> {
@@ -313,11 +317,9 @@ pub(crate) mod tests {
                 (SortBySimilarityScore, score_order),
                 (SortByString::for_field("city"), city_order),
             ));
-            Ok(searcher
-                .search(&AllQuery, &top_collector)?
-                .into_iter()
-                .map(|(f, doc)| (f, ids[&doc]))
-                .collect())
+            let results: Vec<((Score, Option<String>), DocAddress)> =
+                searcher.search(&AllQuery, &top_collector)?;
+            Ok(results.into_iter().map(|(f, doc)| (f, ids[&doc])).collect())
         }
 
         assert_eq!(
@@ -342,6 +344,51 @@ pub(crate) mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_order_by_score_then_owned_value() -> crate::Result<()> {
+        let index = make_index()?;
+
+        type SortKey = (Score, OwnedValue);
+
+        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::<(Score, OwnedValue)>((
+                (SortBySimilarityScore, score_order),
+                (SortByErasedType::for_field("city"), city_order),
+            ));
+            let results: Vec<((Score, OwnedValue), DocAddress)> =
+                searcher.search(&AllQuery, &top_collector)?;
+            Ok(results.into_iter().map(|(f, doc)| (f, ids[&doc])).collect())
+        }
+
+        assert_eq!(
+            &query(&index, Order::Asc, Order::Asc)?,
+            &[
+                ((1.0, OwnedValue::Str("austin".to_owned())), 0),
+                ((1.0, OwnedValue::Str("greenville".to_owned())), 1),
+                ((1.0, OwnedValue::Str("tokyo".to_owned())), 2),
+                ((1.0, OwnedValue::Null), 3),
+            ]
+        );
+
+        assert_eq!(
+            &query(&index, Order::Asc, Order::Desc)?,
+            &[
+                ((1.0, OwnedValue::Str("tokyo".to_owned())), 2),
+                ((1.0, OwnedValue::Str("greenville".to_owned())), 1),
+                ((1.0, OwnedValue::Str("austin".to_owned())), 0),
+                ((1.0, OwnedValue::Null), 3),
+            ]
+        );
+        Ok(())
+    }
+
     use proptest::prelude::*;
 
     proptest! {

src/collector/sort_key/order.rs

@@ -1,11 +1,70 @@
 use std::cmp::Ordering;
 
+use columnar::MonotonicallyMappableToU64;
 use serde::{Deserialize, Serialize};
 
 use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
-use crate::schema::Schema;
+use crate::schema::{OwnedValue, Schema};
 use crate::{DocId, Order, Score};
 
+fn compare_owned_value<const NULLS_FIRST: bool>(lhs: &OwnedValue, rhs: &OwnedValue) -> Ordering {
+    match (lhs, rhs) {
+        (OwnedValue::Null, OwnedValue::Null) => Ordering::Equal,
+        (OwnedValue::Null, _) => {
+            if NULLS_FIRST {
+                Ordering::Less
+            } else {
+                Ordering::Greater
+            }
+        }
+        (_, OwnedValue::Null) => {
+            if NULLS_FIRST {
+                Ordering::Greater
+            } else {
+                Ordering::Less
+            }
+        }
+        (OwnedValue::Str(a), OwnedValue::Str(b)) => a.cmp(b),
+        (OwnedValue::PreTokStr(a), OwnedValue::PreTokStr(b)) => a.cmp(b),
+        (OwnedValue::U64(a), OwnedValue::U64(b)) => a.cmp(b),
+        (OwnedValue::I64(a), OwnedValue::I64(b)) => a.cmp(b),
+        (OwnedValue::F64(a), OwnedValue::F64(b)) => a.to_u64().cmp(&b.to_u64()),
+        (OwnedValue::Bool(a), OwnedValue::Bool(b)) => a.cmp(b),
+        (OwnedValue::Date(a), OwnedValue::Date(b)) => a.cmp(b),
+        (OwnedValue::Facet(a), OwnedValue::Facet(b)) => a.cmp(b),
+        (OwnedValue::Bytes(a), OwnedValue::Bytes(b)) => a.cmp(b),
+        (OwnedValue::IpAddr(a), OwnedValue::IpAddr(b)) => a.cmp(b),
+        (OwnedValue::U64(a), OwnedValue::I64(b)) => {
+            if *b < 0 {
+                Ordering::Greater
+            } else {
+                a.cmp(&(*b as u64))
+            }
+        }
+        (OwnedValue::I64(a), OwnedValue::U64(b)) => {
+            if *a < 0 {
+                Ordering::Less
+            } else {
+                (*a as u64).cmp(b)
+            }
+        }
+        (OwnedValue::U64(a), OwnedValue::F64(b)) => (*a as f64).to_u64().cmp(&b.to_u64()),
+        (OwnedValue::F64(a), OwnedValue::U64(b)) => a.to_u64().cmp(&(*b as f64).to_u64()),
+        (OwnedValue::I64(a), OwnedValue::F64(b)) => (*a as f64).to_u64().cmp(&b.to_u64()),
+        (OwnedValue::F64(a), OwnedValue::I64(b)) => a.to_u64().cmp(&(*b as f64).to_u64()),
+        (a, b) => {
+            let ord = a.discriminant_value().cmp(&b.discriminant_value());
+            // If the discriminant is equal, it's because a new type was added, but hasn't been
+            // included in this `match` statement.
+            assert!(
+                ord != Ordering::Equal,
+                "Unimplemented comparison for type of {a:?}, {b:?}"
+            );
+            ord
+        }
+    }
+}
+
 /// 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.
@@ -25,7 +84,18 @@ 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()
+        lhs.partial_cmp(rhs).unwrap_or(Ordering::Equal)
+    }
+}
+
+/// A (partial) implementation of comparison for OwnedValue.
+///
+/// Intended for use within columns of homogenous types, and so will panic for OwnedValues with
+/// mismatched types. The one exception is Null, for which we do define all comparisons.
+impl Comparator<OwnedValue> for NaturalComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &OwnedValue, rhs: &OwnedValue) -> Ordering {
+        compare_owned_value::</* NULLS_FIRST= */ true>(lhs, rhs)
     }
 }
 
@@ -121,6 +191,13 @@ impl Comparator<String> for ReverseNoneIsLowerComparator {
     }
 }
 
+impl Comparator<OwnedValue> for ReverseNoneIsLowerComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &OwnedValue, rhs: &OwnedValue) -> Ordering {
+        compare_owned_value::</* NULLS_FIRST= */ false>(rhs, lhs)
+    }
+}
+
 /// Compare values naturally, but treating `None` as higher than `Some`.
 ///
 /// When used with `TopDocs`, which reverses the order, this results in a
@@ -185,6 +262,13 @@ impl Comparator<String> for NaturalNoneIsHigherComparator {
     }
 }
 
+impl Comparator<OwnedValue> for NaturalNoneIsHigherComparator {
+    #[inline(always)]
+    fn compare(&self, lhs: &OwnedValue, rhs: &OwnedValue) -> Ordering {
+        compare_owned_value::</* NULLS_FIRST= */ false>(lhs, rhs)
+    }
+}
+
 /// An enum representing the different sort orders.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
 pub enum ComparatorEnum {
@@ -404,11 +488,12 @@ impl<TSegmentSortKeyComputer, TSegmentSortKey, TComparator> SegmentSortKeyComput
     for SegmentSortKeyComputerWithComparator<TSegmentSortKeyComputer, TComparator>
 where
     TSegmentSortKeyComputer: SegmentSortKeyComputer<SegmentSortKey = TSegmentSortKey>,
-    TSegmentSortKey: PartialOrd + Clone + 'static + Sync + Send,
+    TSegmentSortKey: Clone + 'static + Sync + Send,
     TComparator: Comparator<TSegmentSortKey> + 'static + Sync + Send,
 {
     type SortKey = TSegmentSortKeyComputer::SortKey;
     type SegmentSortKey = TSegmentSortKey;
+    type SegmentComparator = TComparator;
 
     fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey {
         self.segment_sort_key_computer.segment_sort_key(doc, score)
@@ -432,6 +517,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::schema::OwnedValue;
 
     #[test]
     fn test_natural_none_is_higher() {
@@ -455,4 +541,27 @@ mod tests {
         // compare(None, None) should be Equal.
         assert_eq!(comp.compare(&null, &null), Ordering::Equal);
     }
+
+    #[test]
+    fn test_mixed_ownedvalue_compare() {
+        let u = OwnedValue::U64(10);
+        let i = OwnedValue::I64(10);
+        let f = OwnedValue::F64(10.0);
+
+        let nc = NaturalComparator;
+        assert_eq!(nc.compare(&u, &i), Ordering::Equal);
+        assert_eq!(nc.compare(&u, &f), Ordering::Equal);
+        assert_eq!(nc.compare(&i, &f), Ordering::Equal);
+
+        let u2 = OwnedValue::U64(11);
+        assert_eq!(nc.compare(&u2, &f), Ordering::Greater);
+
+        let s = OwnedValue::Str("a".to_string());
+        // Str < U64
+        assert_eq!(nc.compare(&s, &u), Ordering::Less);
+        // Str < I64
+        assert_eq!(nc.compare(&s, &i), Ordering::Less);
+        // Str < F64
+        assert_eq!(nc.compare(&s, &f), Ordering::Less);
+    }
 }

src/collector/sort_key/sort_by_erased_type.rs

@@ -0,0 +1,361 @@
+use columnar::{ColumnType, MonotonicallyMappableToU64};
+
+use crate::collector::sort_key::{
+    NaturalComparator, SortBySimilarityScore, SortByStaticFastValue, SortByString,
+};
+use crate::collector::{SegmentSortKeyComputer, SortKeyComputer};
+use crate::fastfield::FastFieldNotAvailableError;
+use crate::schema::OwnedValue;
+use crate::{DateTime, DocId, Score};
+
+/// Sort by the boxed / OwnedValue representation of either a fast field, or of the score.
+///
+/// Using the OwnedValue representation allows for type erasure, and can be useful when sort orders
+/// are not known until runtime. But it comes with a performance cost: wherever possible, prefer to
+/// use a SortKeyComputer implementation with a known-type at compile time.
+#[derive(Debug, Clone)]
+pub enum SortByErasedType {
+    /// Sort by a fast field
+    Field(String),
+    /// Sort by score
+    Score,
+}
+
+impl SortByErasedType {
+    /// Creates a new sort key computer which will sort by the given fast field column, with type
+    /// erasure.
+    pub fn for_field(column_name: impl ToString) -> Self {
+        Self::Field(column_name.to_string())
+    }
+
+    /// Creates a new sort key computer which will sort by score, with type erasure.
+    pub fn for_score() -> Self {
+        Self::Score
+    }
+}
+
+trait ErasedSegmentSortKeyComputer: Send + Sync {
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Option<u64>;
+    fn convert_segment_sort_key(&self, sort_key: Option<u64>) -> OwnedValue;
+}
+
+struct ErasedSegmentSortKeyComputerWrapper<C, F> {
+    inner: C,
+    converter: F,
+}
+
+impl<C, F> ErasedSegmentSortKeyComputer for ErasedSegmentSortKeyComputerWrapper<C, F>
+where
+    C: SegmentSortKeyComputer<SegmentSortKey = Option<u64>> + Send + Sync,
+    F: Fn(C::SortKey) -> OwnedValue + Send + Sync + 'static,
+{
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Option<u64> {
+        self.inner.segment_sort_key(doc, score)
+    }
+
+    fn convert_segment_sort_key(&self, sort_key: Option<u64>) -> OwnedValue {
+        let val = self.inner.convert_segment_sort_key(sort_key);
+        (self.converter)(val)
+    }
+}
+
+struct ScoreSegmentSortKeyComputer {
+    segment_computer: SortBySimilarityScore,
+}
+
+impl ErasedSegmentSortKeyComputer for ScoreSegmentSortKeyComputer {
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Option<u64> {
+        let score_value: f64 = self.segment_computer.segment_sort_key(doc, score).into();
+        Some(score_value.to_u64())
+    }
+
+    fn convert_segment_sort_key(&self, sort_key: Option<u64>) -> OwnedValue {
+        let score_value: u64 = sort_key.expect("This implementation always produces a score.");
+        OwnedValue::F64(f64::from_u64(score_value))
+    }
+}
+
+impl SortKeyComputer for SortByErasedType {
+    type SortKey = OwnedValue;
+    type Child = ErasedColumnSegmentSortKeyComputer;
+    type Comparator = NaturalComparator;
+
+    fn requires_scoring(&self) -> bool {
+        matches!(self, Self::Score)
+    }
+
+    fn segment_sort_key_computer(
+        &self,
+        segment_reader: &crate::SegmentReader,
+    ) -> crate::Result<Self::Child> {
+        let inner: Box<dyn ErasedSegmentSortKeyComputer> = match self {
+            Self::Field(column_name) => {
+                let fast_fields = segment_reader.fast_fields();
+                // TODO: We currently double-open the column to avoid relying on the implementation
+                // details of `SortByString` or `SortByStaticFastValue`. Once
+                // https://github.com/quickwit-oss/tantivy/issues/2776 is resolved, we should
+                // consider directly constructing the appropriate `SegmentSortKeyComputer` type for
+                // the column that we open here.
+                let (_column, column_type) =
+                    fast_fields.u64_lenient(column_name)?.ok_or_else(|| {
+                        FastFieldNotAvailableError {
+                            field_name: column_name.to_owned(),
+                        }
+                    })?;
+
+                match column_type {
+                    ColumnType::Str => {
+                        let computer = SortByString::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<String>| {
+                                val.map(OwnedValue::Str).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    ColumnType::U64 => {
+                        let computer = SortByStaticFastValue::<u64>::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<u64>| {
+                                val.map(OwnedValue::U64).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    ColumnType::I64 => {
+                        let computer = SortByStaticFastValue::<i64>::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<i64>| {
+                                val.map(OwnedValue::I64).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    ColumnType::F64 => {
+                        let computer = SortByStaticFastValue::<f64>::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<f64>| {
+                                val.map(OwnedValue::F64).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    ColumnType::Bool => {
+                        let computer = SortByStaticFastValue::<bool>::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<bool>| {
+                                val.map(OwnedValue::Bool).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    ColumnType::DateTime => {
+                        let computer = SortByStaticFastValue::<DateTime>::for_field(column_name);
+                        let inner = computer.segment_sort_key_computer(segment_reader)?;
+                        Box::new(ErasedSegmentSortKeyComputerWrapper {
+                            inner,
+                            converter: |val: Option<DateTime>| {
+                                val.map(OwnedValue::Date).unwrap_or(OwnedValue::Null)
+                            },
+                        })
+                    }
+                    column_type => {
+                        return Err(crate::TantivyError::SchemaError(format!(
+                            "Field `{}` is of type {column_type:?}, which is not supported for \
+                             sorting by owned value yet.",
+                            column_name
+                        )))
+                    }
+                }
+            }
+            Self::Score => Box::new(ScoreSegmentSortKeyComputer {
+                segment_computer: SortBySimilarityScore,
+            }),
+        };
+        Ok(ErasedColumnSegmentSortKeyComputer { inner })
+    }
+}
+
+pub struct ErasedColumnSegmentSortKeyComputer {
+    inner: Box<dyn ErasedSegmentSortKeyComputer>,
+}
+
+impl SegmentSortKeyComputer for ErasedColumnSegmentSortKeyComputer {
+    type SortKey = OwnedValue;
+    type SegmentSortKey = Option<u64>;
+    type SegmentComparator = NaturalComparator;
+
+    #[inline(always)]
+    fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Option<u64> {
+        self.inner.segment_sort_key(doc, score)
+    }
+
+    fn convert_segment_sort_key(&self, segment_sort_key: Self::SegmentSortKey) -> OwnedValue {
+        self.inner.convert_segment_sort_key(segment_sort_key)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::collector::sort_key::{ComparatorEnum, SortByErasedType};
+    use crate::collector::TopDocs;
+    use crate::query::AllQuery;
+    use crate::schema::{OwnedValue, Schema, FAST, TEXT};
+    use crate::Index;
+
+    #[test]
+    fn test_sort_by_owned_u64() {
+        let mut schema_builder = Schema::builder();
+        let id_field = schema_builder.add_u64_field("id", FAST);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+        let mut writer = index.writer_for_tests().unwrap();
+        writer.add_document(doc!(id_field => 10u64)).unwrap();
+        writer.add_document(doc!(id_field => 2u64)).unwrap();
+        writer.add_document(doc!()).unwrap();
+        writer.commit().unwrap();
+
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+
+        let collector = TopDocs::with_limit(10)
+            .order_by((SortByErasedType::for_field("id"), ComparatorEnum::Natural));
+        let top_docs = searcher.search(&AllQuery, &collector).unwrap();
+
+        let values: Vec<OwnedValue> = top_docs.into_iter().map(|(key, _)| key).collect();
+
+        assert_eq!(
+            values,
+            vec![OwnedValue::U64(10), OwnedValue::U64(2), OwnedValue::Null]
+        );
+
+        let collector = TopDocs::with_limit(10).order_by((
+            SortByErasedType::for_field("id"),
+            ComparatorEnum::ReverseNoneLower,
+        ));
+        let top_docs = searcher.search(&AllQuery, &collector).unwrap();
+
+        let values: Vec<OwnedValue> = top_docs.into_iter().map(|(key, _)| key).collect();
+
+        assert_eq!(
+            values,
+            vec![OwnedValue::U64(2), OwnedValue::U64(10), OwnedValue::Null]
+        );
+    }
+
+    #[test]
+    fn test_sort_by_owned_string() {
+        let mut schema_builder = Schema::builder();
+        let city_field = schema_builder.add_text_field("city", FAST | TEXT);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+        let mut writer = index.writer_for_tests().unwrap();
+        writer.add_document(doc!(city_field => "tokyo")).unwrap();
+        writer.add_document(doc!(city_field => "austin")).unwrap();
+        writer.add_document(doc!()).unwrap();
+        writer.commit().unwrap();
+
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+
+        let collector = TopDocs::with_limit(10).order_by((
+            SortByErasedType::for_field("city"),
+            ComparatorEnum::ReverseNoneLower,
+        ));
+        let top_docs = searcher.search(&AllQuery, &collector).unwrap();
+
+        let values: Vec<OwnedValue> = top_docs.into_iter().map(|(key, _)| key).collect();
+
+        assert_eq!(
+            values,
+            vec![
+                OwnedValue::Str("austin".to_string()),
+                OwnedValue::Str("tokyo".to_string()),
+                OwnedValue::Null
+            ]
+        );
+    }
+
+    #[test]
+    fn test_sort_by_owned_reverse() {
+        let mut schema_builder = Schema::builder();
+        let id_field = schema_builder.add_u64_field("id", FAST);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+        let mut writer = index.writer_for_tests().unwrap();
+        writer.add_document(doc!(id_field => 10u64)).unwrap();
+        writer.add_document(doc!(id_field => 2u64)).unwrap();
+        writer.add_document(doc!()).unwrap();
+        writer.commit().unwrap();
+
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+
+        let collector = TopDocs::with_limit(10)
+            .order_by((SortByErasedType::for_field("id"), ComparatorEnum::Reverse));
+        let top_docs = searcher.search(&AllQuery, &collector).unwrap();
+
+        let values: Vec<OwnedValue> = top_docs.into_iter().map(|(key, _)| key).collect();
+
+        assert_eq!(
+            values,
+            vec![OwnedValue::Null, OwnedValue::U64(2), OwnedValue::U64(10)]
+        );
+    }
+
+    #[test]
+    fn test_sort_by_owned_score() {
+        let mut schema_builder = Schema::builder();
+        let body_field = schema_builder.add_text_field("body", TEXT);
+        let schema = schema_builder.build();
+        let index = Index::create_in_ram(schema);
+        let mut writer = index.writer_for_tests().unwrap();
+        writer.add_document(doc!(body_field => "a a")).unwrap();
+        writer.add_document(doc!(body_field => "a")).unwrap();
+        writer.commit().unwrap();
+
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
+        let query_parser = crate::query::QueryParser::for_index(&index, vec![body_field]);
+        let query = query_parser.parse_query("a").unwrap();
+
+        // Sort by score descending (Natural)
+        let collector = TopDocs::with_limit(10)
+            .order_by((SortByErasedType::for_score(), ComparatorEnum::Natural));
+        let top_docs = searcher.search(&query, &collector).unwrap();
+
+        let values: Vec<f64> = top_docs
+            .into_iter()
+            .map(|(key, _)| match key {
+                OwnedValue::F64(val) => val,
+                _ => panic!("Wrong type {key:?}"),
+            })
+            .collect();
+
+        assert_eq!(values.len(), 2);
+        assert!(values[0] > values[1]);
+
+        // Sort by score ascending (ReverseNoneLower)
+        let collector = TopDocs::with_limit(10).order_by((
+            SortByErasedType::for_score(),
+            ComparatorEnum::ReverseNoneLower,
+        ));
+        let top_docs = searcher.search(&query, &collector).unwrap();
+
+        let values: Vec<f64> = top_docs
+            .into_iter()
+            .map(|(key, _)| match key {
+                OwnedValue::F64(val) => val,
+                _ => panic!("Wrong type {key:?}"),
+            })
+            .collect();
+
+        assert_eq!(values.len(), 2);
+        assert!(values[0] < values[1]);
+    }
+}

src/collector/sort_key/sort_by_score.rs

@@ -63,8 +63,8 @@ impl SortKeyComputer for SortBySimilarityScore {
 
 impl SegmentSortKeyComputer for SortBySimilarityScore {
     type SortKey = Score;
-
     type SegmentSortKey = Score;
+    type SegmentComparator = NaturalComparator;
 
     #[inline(always)]
     fn segment_sort_key(&mut self, _doc: DocId, score: Score) -> Score {

src/collector/sort_key/sort_by_static_fast_value.rs

@@ -34,9 +34,7 @@ impl<T: FastValue> SortByStaticFastValue<T> {
 
 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<()> {
@@ -84,8 +82,8 @@ pub struct SortByFastValueSegmentSortKeyComputer<T> {
 
 impl<T: FastValue> SegmentSortKeyComputer for SortByFastValueSegmentSortKeyComputer<T> {
     type SortKey = Option<T>;
-
     type SegmentSortKey = Option<u64>;
+    type SegmentComparator = NaturalComparator;
 
     #[inline(always)]
     fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> Self::SegmentSortKey {

src/collector/sort_key/sort_by_string.rs

@@ -30,9 +30,7 @@ impl SortByString {
 
 impl SortKeyComputer for SortByString {
     type SortKey = Option<String>;
-
     type Child = ByStringColumnSegmentSortKeyComputer;
-
     type Comparator = NaturalComparator;
 
     fn segment_sort_key_computer(
@@ -50,8 +48,8 @@ pub struct ByStringColumnSegmentSortKeyComputer {
 
 impl SegmentSortKeyComputer for ByStringColumnSegmentSortKeyComputer {
     type SortKey = Option<String>;
-
     type SegmentSortKey = Option<TermOrdinal>;
+    type SegmentComparator = NaturalComparator;
 
     #[inline(always)]
     fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> Option<TermOrdinal> {
@@ -60,6 +58,8 @@ impl SegmentSortKeyComputer for ByStringColumnSegmentSortKeyComputer {
     }
 
     fn convert_segment_sort_key(&self, term_ord_opt: Option<TermOrdinal>) -> Option<String> {
+        // TODO: Individual lookups to the dictionary like this are very likely to repeatedly
+        // decompress the same blocks. See https://github.com/quickwit-oss/tantivy/issues/2776
         let term_ord = term_ord_opt?;
         let str_column = self.str_column_opt.as_ref()?;
         let mut bytes = Vec::new();

src/collector/sort_key/sort_key_computer.rs

@@ -12,13 +12,21 @@ use crate::{DocAddress, DocId, Result, Score, SegmentReader};
 /// 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;
+    type SortKey: 'static + 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;
+    type SegmentSortKey: 'static + Clone + Send + Sync + Clone;
+
+    /// Comparator type.
+    type SegmentComparator: Comparator<Self::SegmentSortKey> + 'static;
+
+    /// Returns the segment sort key comparator.
+    fn segment_comparator(&self) -> Self::SegmentComparator {
+        Self::SegmentComparator::default()
+    }
 
     /// Computes the sort key for the given document and score.
     fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey;
@@ -47,7 +55,7 @@ pub trait SegmentSortKeyComputer: 'static {
         left: &Self::SegmentSortKey,
         right: &Self::SegmentSortKey,
     ) -> Ordering {
-        NaturalComparator.compare(left, right)
+        self.segment_comparator().compare(left, right)
     }
 
     /// Implementing this method makes it possible to avoid computing
@@ -81,7 +89,7 @@ pub trait SegmentSortKeyComputer: 'static {
 /// 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 SortKey: 'static + Send + Sync + Clone + std::fmt::Debug;
     /// Type of the associated [`SegmentSortKeyComputer`].
     type Child: SegmentSortKeyComputer<SortKey = Self::SortKey>;
     /// Comparator type.
@@ -136,10 +144,7 @@ where
     HeadSortKeyComputer: SortKeyComputer,
     TailSortKeyComputer: SortKeyComputer,
 {
-    type SortKey = (
-        <HeadSortKeyComputer::Child as SegmentSortKeyComputer>::SortKey,
-        <TailSortKeyComputer::Child as SegmentSortKeyComputer>::SortKey,
-    );
+    type SortKey = (HeadSortKeyComputer::SortKey, TailSortKeyComputer::SortKey);
     type Child = (HeadSortKeyComputer::Child, TailSortKeyComputer::Child);
 
     type Comparator = (
@@ -188,6 +193,11 @@ where
         TailSegmentSortKeyComputer::SegmentSortKey,
     );
 
+    type SegmentComparator = (
+        HeadSegmentSortKeyComputer::SegmentComparator,
+        TailSegmentSortKeyComputer::SegmentComparator,
+    );
+
     /// A SegmentSortKeyComputer maps to a SegmentSortKey, but it can also decide on
     /// its ordering.
     ///
@@ -269,11 +279,12 @@ 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,
+    PreviousScore: 'static + Clone + Send + Sync,
+    NewScore: 'static + Clone + Send + Sync,
 {
     type SortKey = NewScore;
     type SegmentSortKey = T::SegmentSortKey;
+    type SegmentComparator = T::SegmentComparator;
 
     fn segment_sort_key(&mut self, doc: DocId, score: Score) -> Self::SegmentSortKey {
         self.sort_key_computer.segment_sort_key(doc, score)
@@ -463,6 +474,7 @@ where
 {
     type SortKey = TSortKey;
     type SegmentSortKey = TSortKey;
+    type SegmentComparator = NaturalComparator;
 
     fn segment_sort_key(&mut self, doc: DocId, _score: Score) -> TSortKey {
         (self)(doc)

src/collector/top_score_collector.rs

@@ -324,7 +324,7 @@ impl TopDocs {
         sort_key_computer: impl SortKeyComputer<SortKey = TSortKey> + Send + 'static,
     ) -> impl Collector<Fruit = Vec<(TSortKey, DocAddress)>>
     where
-        TSortKey: 'static + Clone + Send + Sync + PartialOrd + std::fmt::Debug,
+        TSortKey: 'static + Clone + Send + Sync + std::fmt::Debug,
     {
         TopBySortKeyCollector::new(sort_key_computer, self.doc_range())
     }
@@ -445,7 +445,7 @@ where
     F: 'static + Send + Sync + Fn(&SegmentReader) -> TTweakScoreSortKeyFn,
     TTweakScoreSortKeyFn: 'static + Fn(DocId, Score) -> TSortKey,
     TweakScoreSegmentSortKeyComputer<TTweakScoreSortKeyFn>:
-        SegmentSortKeyComputer<SortKey = TSortKey>,
+        SegmentSortKeyComputer<SortKey = TSortKey, SegmentSortKey = TSortKey>,
     TSortKey: 'static + PartialOrd + Clone + Send + Sync + std::fmt::Debug,
 {
     type SortKey = TSortKey;
@@ -480,6 +480,7 @@ where
 {
     type SortKey = TSortKey;
     type SegmentSortKey = TSortKey;
+    type SegmentComparator = NaturalComparator;
 
     fn segment_sort_key(&mut self, doc: DocId, score: Score) -> TSortKey {
         (self.sort_key_fn)(doc, score)

src/directory/mmap_directory/mod.rs

@@ -1,3 +1,5 @@
+mod file_watcher;
+
 use std::collections::HashMap;
 use std::fmt;
 use std::fs::{self, File, OpenOptions};
@@ -7,6 +9,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock, Weak};
 
 use common::StableDeref;
+use file_watcher::FileWatcher;
 use fs4::fs_std::FileExt;
 #[cfg(all(feature = "mmap", unix))]
 pub use memmap2::Advice;
@@ -18,7 +21,6 @@ use crate::core::META_FILEPATH;
 use crate::directory::error::{
     DeleteError, LockError, OpenDirectoryError, OpenReadError, OpenWriteError,
 };
-use crate::directory::file_watcher::FileWatcher;
 use crate::directory::{
     AntiCallToken, Directory, DirectoryLock, FileHandle, Lock, OwnedBytes, TerminatingWrite,
     WatchCallback, WatchHandle, WritePtr,

src/directory/mod.rs

@@ -5,7 +5,6 @@ mod mmap_directory;
 
 mod directory;
 mod directory_lock;
-mod file_watcher;
 pub mod footer;
 mod managed_directory;
 mod ram_directory;

src/docset.rs

@@ -42,7 +42,6 @@ pub trait DocSet: Send {
     /// Calling `seek(TERMINATED)` is also legal and is the normal way to consume a `DocSet`.
     ///
     /// `target` has to be larger or equal to `.doc()` when calling `seek`.
-    /// If `target` is equal to `.doc()` then the DocSet should not advance.
     fn seek(&mut self, target: DocId) -> DocId {
         let mut doc = self.doc();
         debug_assert!(doc <= target);
@@ -167,19 +166,6 @@ pub trait DocSet: Send {
     }
 }
 
-/// Consumes the `DocSet` and returns a Vec with all of the docs in the DocSet
-/// including the current doc.
-#[cfg(test)]
-pub fn docset_to_doc_vec(mut doc_set: Box<dyn DocSet>) -> Vec<DocId> {
-    let mut output = Vec::new();
-    let mut doc = doc_set.doc();
-    while doc != TERMINATED {
-        output.push(doc);
-        doc = doc_set.advance();
-    }
-    output
-}
-
 impl DocSet for &mut dyn DocSet {
     fn advance(&mut self) -> u32 {
         (**self).advance()

src/fieldnorm/mod.rs

@@ -113,7 +113,7 @@ mod tests {
             IndexRecordOption::WithFreqs,
         );
         let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-        let mut scorer = weight.scorer(searcher.segment_reader(0), 1.0f32, 0)?;
+        let mut scorer = weight.scorer(searcher.segment_reader(0), 1.0f32)?;
         assert_eq!(scorer.doc(), 0);
         assert!((scorer.score() - 0.22920431).abs() < 0.001f32);
         assert_eq!(scorer.advance(), 1);
@@ -142,7 +142,7 @@ mod tests {
             IndexRecordOption::WithFreqs,
         );
         let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-        let mut scorer = weight.scorer(searcher.segment_reader(0), 1.0f32, 0)?;
+        let mut scorer = weight.scorer(searcher.segment_reader(0), 1.0f32)?;
         assert_eq!(scorer.doc(), 0);
         assert!((scorer.score() - 0.22920431).abs() < 0.001f32);
         assert_eq!(scorer.advance(), 1);

src/index/index_meta.rs

@@ -404,7 +404,10 @@ mod tests {
             schema_builder.build()
         };
         let index_metas = IndexMeta {
-            index_settings: IndexSettings::default(),
+            index_settings: IndexSettings {
+                docstore_compression: Compressor::None,
+                ..Default::default()
+            },
             segments: Vec::new(),
             schema,
             opstamp: 0u64,
@@ -413,7 +416,7 @@ mod tests {
         let json = serde_json::ser::to_string(&index_metas).expect("serialization failed");
         assert_eq!(
             json,
-            r#"{"index_settings":{"docstore_compression":"lz4","docstore_blocksize":16384},"segments":[],"schema":[{"name":"text","type":"text","options":{"indexing":{"record":"position","fieldnorms":true,"tokenizer":"default"},"stored":false,"fast":false}}],"opstamp":0}"#
+            r#"{"index_settings":{"docstore_compression":"none","docstore_blocksize":16384},"segments":[],"schema":[{"name":"text","type":"text","options":{"indexing":{"record":"position","fieldnorms":true,"tokenizer":"default"},"stored":false,"fast":false}}],"opstamp":0}"#
         );
 
         let deser_meta: UntrackedIndexMeta = serde_json::from_str(&json).unwrap();
@@ -494,6 +497,8 @@ mod tests {
     #[test]
     #[cfg(feature = "lz4-compression")]
     fn test_index_settings_default() {
+        use crate::store::Compressor;
+
         let mut index_settings = IndexSettings::default();
         assert_eq!(
             index_settings,

src/index/inverted_index_reader.rs

@@ -11,12 +11,9 @@ use tantivy_fst::automaton::{AlwaysMatch, Automaton};
 
 use crate::directory::FileSlice;
 use crate::positions::PositionReader;
-use crate::postings::{
-    BlockSegmentPostings, BlockSegmentPostingsNotLoaded, SegmentPostings, TermInfo,
-};
+use crate::postings::{BlockSegmentPostings, SegmentPostings, TermInfo};
 use crate::schema::{IndexRecordOption, Term, Type};
 use crate::termdict::TermDictionary;
-use crate::DocId;
 
 /// The inverted index reader is in charge of accessing
 /// the inverted index associated with a specific field.
@@ -195,32 +192,9 @@ impl InvertedIndexReader {
         term: &Term,
         option: IndexRecordOption,
     ) -> io::Result<Option<BlockSegmentPostings>> {
-        let Some(term_info) = self.get_term_info(term)? else {
-            return Ok(None);
-        };
-        let block_postings_not_loaded =
-            self.read_block_postings_from_terminfo(&term_info, option)?;
-        Ok(Some(block_postings_not_loaded))
-    }
-
-    /// Returns a block postings given a `term_info`.
-    /// This method is for an advanced usage only.
-    ///
-    /// Most users should prefer using [`Self::read_postings()`] instead.
-    pub(crate) fn read_block_postings_from_terminfo_not_loaded(
-        &self,
-        term_info: &TermInfo,
-        requested_option: IndexRecordOption,
-    ) -> io::Result<BlockSegmentPostingsNotLoaded> {
-        let postings_data = self
-            .postings_file_slice
-            .slice(term_info.postings_range.clone());
-        BlockSegmentPostings::open(
-            term_info.doc_freq,
-            postings_data,
-            self.record_option,
-            requested_option,
-        )
+        self.get_term_info(term)?
+            .map(move |term_info| self.read_block_postings_from_terminfo(&term_info, option))
+            .transpose()
     }
 
     /// Returns a block postings given a `term_info`.
@@ -232,10 +206,15 @@ impl InvertedIndexReader {
         term_info: &TermInfo,
         requested_option: IndexRecordOption,
     ) -> io::Result<BlockSegmentPostings> {
-        let block_segment_postings_not_loaded = self
-            .read_block_postings_from_terminfo_not_loaded(term_info, requested_option)?
-            .load_at_start();
-        Ok(block_segment_postings_not_loaded)
+        let postings_data = self
+            .postings_file_slice
+            .slice(term_info.postings_range.clone());
+        BlockSegmentPostings::open(
+            term_info.doc_freq,
+            postings_data,
+            self.record_option,
+            requested_option,
+        )
     }
 
     /// Returns a posting object given a `term_info`.
@@ -245,13 +224,13 @@ impl InvertedIndexReader {
     pub fn read_postings_from_terminfo(
         &self,
         term_info: &TermInfo,
-        record_option: IndexRecordOption,
-        seek_doc: DocId,
+        option: IndexRecordOption,
     ) -> io::Result<SegmentPostings> {
-        let block_segment_postings_not_loaded =
-            self.read_block_postings_from_terminfo_not_loaded(term_info, record_option)?;
+        let option = option.downgrade(self.record_option);
+
+        let block_postings = self.read_block_postings_from_terminfo(term_info, option)?;
         let position_reader = {
-            if record_option.has_positions() {
+            if option.has_positions() {
                 let positions_data = self
                     .positions_file_slice
                     .read_bytes_slice(term_info.positions_range.clone())?;
@@ -262,9 +241,8 @@ impl InvertedIndexReader {
             }
         };
         Ok(SegmentPostings::from_block_postings(
-            block_segment_postings_not_loaded,
+            block_postings,
             position_reader,
-            seek_doc,
         ))
     }
 
@@ -290,7 +268,7 @@ impl InvertedIndexReader {
         option: IndexRecordOption,
     ) -> io::Result<Option<SegmentPostings>> {
         self.get_term_info(term)?
-            .map(move |term_info| self.read_postings_from_terminfo(&term_info, option, 0u32))
+            .map(move |term_info| self.read_postings_from_terminfo(&term_info, option))
             .transpose()
     }
 

src/indexer/delete_queue.rs

@@ -4,19 +4,20 @@ use std::sync::{Arc, RwLock, Weak};
 use super::operation::DeleteOperation;
 use crate::Opstamp;
 
-// The DeleteQueue is similar in conceptually to a multiple
-// consumer single producer broadcast channel.
-//
-// All consumer will receive all messages.
-//
-// Consumer of the delete queue are holding a `DeleteCursor`,
-// which points to a specific place of the `DeleteQueue`.
-//
-// New consumer can be created in two ways
-// - calling `delete_queue.cursor()` returns a cursor, that will include all future delete operation
-//   (and some or none of the past operations... The client is in charge of checking the opstamps.).
-// - cloning an existing cursor returns a new cursor, that is at the exact same position, and can
-//   now advance independently from the original cursor.
+/// The DeleteQueue is similar in conceptually to a multiple
+/// consumer single producer broadcast channel.
+///
+/// All consumer will receive all messages.
+///
+/// Consumer of the delete queue are holding a `DeleteCursor`,
+/// which points to a specific place of the `DeleteQueue`.
+///
+/// New consumer can be created in two ways
+/// - calling `delete_queue.cursor()` returns a cursor, that will include all future delete
+///   operation (and some or none of the past operations... The client is in charge of checking the
+///   opstamps.).
+/// - cloning an existing cursor returns a new cursor, that is at the exact same position, and can
+///   now advance independently from the original cursor.
 #[derive(Default)]
 struct InnerDeleteQueue {
     writer: Vec<DeleteOperation>,
@@ -249,12 +250,7 @@ mod tests {
 
     struct DummyWeight;
     impl Weight for DummyWeight {
-        fn scorer(
-            &self,
-            _reader: &SegmentReader,
-            _boost: Score,
-            _seek_doc: DocId,
-        ) -> crate::Result<Box<dyn Scorer>> {
+        fn scorer(&self, _reader: &SegmentReader, _boost: Score) -> crate::Result<Box<dyn Scorer>> {
             Err(crate::TantivyError::InternalError("dummy impl".to_owned()))
         }
 

src/indexer/merger.rs

@@ -367,11 +367,8 @@ impl IndexMerger {
             for (segment_ord, term_info) in merged_terms.current_segment_ords_and_term_infos() {
                 let segment_reader = &self.readers[segment_ord];
                 let inverted_index: &InvertedIndexReader = &field_readers[segment_ord];
-                let segment_postings = inverted_index.read_postings_from_terminfo(
-                    &term_info,
-                    segment_postings_option,
-                    0u32,
-                )?;
+                let segment_postings = inverted_index
+                    .read_postings_from_terminfo(&term_info, segment_postings_option)?;
                 let alive_bitset_opt = segment_reader.alive_bitset();
                 let doc_freq = if let Some(alive_bitset) = alive_bitset_opt {
                     segment_postings.doc_freq_given_deletes(alive_bitset)

src/indexer/mod.rs

@@ -4,6 +4,7 @@
 //! `IndexWriter` is the main entry point for that, which created from
 //! [`Index::writer`](crate::Index::writer).
 
+/// Delete queue implementation for broadcasting delete operations to consumers.
 pub(crate) mod delete_queue;
 pub(crate) mod path_to_unordered_id;
 

src/indexer/segment_writer.rs

@@ -421,10 +421,9 @@ fn remap_and_write(
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeMap;
-    use std::path::{Path, PathBuf};
+    use std::path::Path;
 
     use columnar::ColumnType;
-    use tempfile::TempDir;
 
     use crate::collector::{Count, TopDocs};
     use crate::directory::RamDirectory;
@@ -1067,10 +1066,7 @@ mod tests {
         let mut schema_builder = Schema::builder();
         schema_builder.add_text_field("title", text_options);
         let schema = schema_builder.build();
-        let tempdir = TempDir::new().unwrap();
-        let tempdir_path = PathBuf::from(tempdir.path());
-        Index::create_in_dir(&tempdir_path, schema).unwrap();
-        let index = Index::open_in_dir(tempdir_path).unwrap();
+        let index = Index::create_in_ram(schema);
         let schema = index.schema();
         let mut index_writer = index.writer(50_000_000).unwrap();
         let title = schema.get_field("title").unwrap();

src/lib.rs

@@ -17,6 +17,7 @@
 //!
 //! ```rust
 //! # use std::path::Path;
+//! # use std::fs;
 //! # use tempfile::TempDir;
 //! # use tantivy::collector::TopDocs;
 //! # use tantivy::query::QueryParser;
@@ -27,8 +28,11 @@
 //! #     // Let's create a temporary directory for the
 //! #     // sake of this example
 //! #     if let Ok(dir) = TempDir::new() {
-//! #         run_example(dir.path()).unwrap();
-//! #         dir.close().unwrap();
+//! #         let index_path = dir.path().join("index");
+//! #         // In case the directory already exists, we remove it
+//! #         let _ = fs::remove_dir_all(&index_path);
+//! #         fs::create_dir_all(&index_path).unwrap();
+//! #         run_example(&index_path).unwrap();
 //! #     }
 //! # }
 //! #
@@ -203,6 +207,7 @@ mod docset;
 mod reader;
 
 #[cfg(test)]
+#[cfg(feature = "mmap")]
 mod compat_tests;
 
 pub use self::reader::{IndexReader, IndexReaderBuilder, ReloadPolicy, Warmer};
@@ -1170,12 +1175,11 @@ pub mod tests {
 
     #[test]
     fn test_validate_checksum() -> crate::Result<()> {
-        let index_path = tempfile::tempdir().expect("dir");
         let mut builder = Schema::builder();
         let body = builder.add_text_field("body", TEXT | STORED);
         let schema = builder.build();
-        let index = Index::create_in_dir(&index_path, schema)?;
-        let mut writer: IndexWriter = index.writer(50_000_000)?;
+        let index = Index::create_in_ram(schema);
+        let mut writer: IndexWriter = index.writer_for_tests()?;
         writer.set_merge_policy(Box::new(NoMergePolicy));
         for _ in 0..5000 {
             writer.add_document(doc!(body => "foo"))?;

src/postings/block_segment_postings.rs

@@ -87,31 +87,6 @@ fn split_into_skips_and_postings(
     Ok((Some(skip_data), postings_data))
 }
 
-/// A block segment postings for which the first block has not been loaded yet.
-///
-/// You can either call `load_at_start` to load it its first block,
-/// or skip a few blocks by calling `seek_and_load`.
-pub(crate) struct BlockSegmentPostingsNotLoaded(BlockSegmentPostings);
-
-impl BlockSegmentPostingsNotLoaded {
-    /// Seek into the block segment postings directly, possibly avoiding loading its first block.
-    pub fn seek_and_load(self, seek_doc: DocId) -> (BlockSegmentPostings, usize) {
-        let BlockSegmentPostingsNotLoaded(mut block_segment_postings) = self;
-        block_segment_postings.load_block();
-        let inner_pos = if seek_doc == 0 {
-            0
-        } else {
-            block_segment_postings.seek(seek_doc)
-        };
-        (block_segment_postings, inner_pos)
-    }
-
-    /// Load the first block of segment postings.
-    pub fn load_at_start(self) -> BlockSegmentPostings {
-        self.seek_and_load(0u32).0
-    }
-}
-
 impl BlockSegmentPostings {
     /// Opens a `BlockSegmentPostings`.
     /// `doc_freq` is the number of documents in the posting list.
@@ -124,7 +99,7 @@ impl BlockSegmentPostings {
         data: FileSlice,
         mut record_option: IndexRecordOption,
         requested_option: IndexRecordOption,
-    ) -> io::Result<BlockSegmentPostingsNotLoaded> {
+    ) -> io::Result<BlockSegmentPostings> {
         let bytes = data.read_bytes()?;
         let (skip_data_opt, postings_data) = split_into_skips_and_postings(doc_freq, bytes)?;
         let skip_reader = match skip_data_opt {
@@ -150,7 +125,7 @@ impl BlockSegmentPostings {
             (_, _) => FreqReadingOption::ReadFreq,
         };
 
-        Ok(BlockSegmentPostingsNotLoaded(BlockSegmentPostings {
+        let mut block_segment_postings = BlockSegmentPostings {
             doc_decoder: BlockDecoder::with_val(TERMINATED),
             block_loaded: false,
             freq_decoder: BlockDecoder::with_val(1),
@@ -159,7 +134,9 @@ impl BlockSegmentPostings {
             doc_freq,
             data: postings_data,
             skip_reader,
-        }))
+        };
+        block_segment_postings.load_block();
+        Ok(block_segment_postings)
     }
 
     /// Returns the block_max_score for the current block.
@@ -281,9 +258,7 @@ impl BlockSegmentPostings {
         self.doc_decoder.output_len
     }
 
-    /// Position on a block that may contains `target_doc`, and returns the
-    /// position of the first document greater than or equal to `target_doc`
-    /// within that block.
+    /// Position on a block that may contains `target_doc`.
     ///
     /// If all docs are smaller than target, the block loaded may be empty,
     /// or be the last an incomplete VInt block.
@@ -413,7 +388,7 @@ mod tests {
     use crate::index::Index;
     use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
     use crate::postings::postings::Postings;
-    use crate::postings::{BlockSegmentPostingsNotLoaded, SegmentPostings};
+    use crate::postings::SegmentPostings;
     use crate::schema::{IndexRecordOption, Schema, Term, INDEXED};
     use crate::DocId;
 
@@ -452,8 +427,7 @@ mod tests {
 
     #[test]
     fn test_block_segment_postings() -> crate::Result<()> {
-        let mut block_segments =
-            build_block_postings(&(0..100_000).collect::<Vec<u32>>())?.load_at_start();
+        let mut block_segments = build_block_postings(&(0..100_000).collect::<Vec<u32>>())?;
         let mut offset: u32 = 0u32;
         // checking that the `doc_freq` is correct
         assert_eq!(block_segments.doc_freq(), 100_000);
@@ -479,7 +453,7 @@ mod tests {
         doc_ids.push(130);
         {
             let block_segments = build_block_postings(&doc_ids)?;
-            let mut docset = SegmentPostings::from_block_postings(block_segments, None, 0);
+            let mut docset = SegmentPostings::from_block_postings(block_segments, None);
             assert_eq!(docset.seek(128), 129);
             assert_eq!(docset.doc(), 129);
             assert_eq!(docset.advance(), 130);
@@ -488,7 +462,7 @@ mod tests {
         }
         {
             let block_segments = build_block_postings(&doc_ids).unwrap();
-            let mut docset = SegmentPostings::from_block_postings(block_segments, None, 0);
+            let mut docset = SegmentPostings::from_block_postings(block_segments, None);
             assert_eq!(docset.seek(129), 129);
             assert_eq!(docset.doc(), 129);
             assert_eq!(docset.advance(), 130);
@@ -497,7 +471,7 @@ mod tests {
         }
         {
             let block_segments = build_block_postings(&doc_ids)?;
-            let mut docset = SegmentPostings::from_block_postings(block_segments, None, 0);
+            let mut docset = SegmentPostings::from_block_postings(block_segments, None);
             assert_eq!(docset.doc(), 0);
             assert_eq!(docset.seek(131), TERMINATED);
             assert_eq!(docset.doc(), TERMINATED);
@@ -505,7 +479,7 @@ mod tests {
         Ok(())
     }
 
-    fn build_block_postings(docs: &[DocId]) -> crate::Result<BlockSegmentPostingsNotLoaded> {
+    fn build_block_postings(docs: &[DocId]) -> crate::Result<BlockSegmentPostings> {
         let mut schema_builder = Schema::builder();
         let int_field = schema_builder.add_u64_field("id", INDEXED);
         let schema = schema_builder.build();
@@ -525,9 +499,9 @@ mod tests {
         let inverted_index = segment_reader.inverted_index(int_field).unwrap();
         let term = Term::from_field_u64(int_field, 0u64);
         let term_info = inverted_index.get_term_info(&term)?.unwrap();
-        let block_postings_not_loaded = inverted_index
-            .read_block_postings_from_terminfo_not_loaded(&term_info, IndexRecordOption::Basic)?;
-        Ok(block_postings_not_loaded)
+        let block_postings = inverted_index
+            .read_block_postings_from_terminfo(&term_info, IndexRecordOption::Basic)?;
+        Ok(block_postings)
     }
 
     #[test]
@@ -536,7 +510,7 @@ mod tests {
         for i in 0..1300 {
             docs.push((i * i / 100) + i);
         }
-        let mut block_postings = build_block_postings(&docs[..])?.load_at_start();
+        let mut block_postings = build_block_postings(&docs[..])?;
         for i in &[0, 424, 10000] {
             block_postings.seek(*i);
             let docs = block_postings.docs();

src/postings/mod.rs

@@ -22,7 +22,6 @@ pub(crate) use loaded_postings::LoadedPostings;
 pub(crate) use stacker::compute_table_memory_size;
 
 pub use self::block_segment_postings::BlockSegmentPostings;
-pub(crate) use self::block_segment_postings::BlockSegmentPostingsNotLoaded;
 pub(crate) use self::indexing_context::IndexingContext;
 pub(crate) use self::per_field_postings_writer::PerFieldPostingsWriter;
 pub use self::postings::Postings;
@@ -528,6 +527,7 @@ pub(crate) mod tests {
     }
 
     impl<TScorer: Scorer> Scorer for UnoptimizedDocSet<TScorer> {
+        #[inline]
         fn score(&mut self) -> Score {
             self.0.score()
         }

src/postings/segment_postings.rs

@@ -4,7 +4,7 @@ use crate::docset::DocSet;
 use crate::fastfield::AliveBitSet;
 use crate::positions::PositionReader;
 use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
-use crate::postings::{BlockSegmentPostings, BlockSegmentPostingsNotLoaded, Postings};
+use crate::postings::{BlockSegmentPostings, Postings};
 use crate::{DocId, TERMINATED};
 
 /// `SegmentPostings` represents the inverted list or postings associated with
@@ -86,7 +86,7 @@ impl SegmentPostings {
             IndexRecordOption::Basic,
         )
         .unwrap();
-        SegmentPostings::from_block_postings(block_segment_postings, None, 0)
+        SegmentPostings::from_block_postings(block_segment_postings, None)
     }
 
     /// Helper functions to create `SegmentPostings` for tests.
@@ -134,22 +134,21 @@ impl SegmentPostings {
             IndexRecordOption::WithFreqs,
         )
         .unwrap();
-        SegmentPostings::from_block_postings(block_segment_postings, None, 0)
+        SegmentPostings::from_block_postings(block_segment_postings, None)
     }
 
-    /// Creates a Segment Postings from a
-    /// - `BlockSegmentPostings`,
-    /// - a position reader
-    /// - a target document to seek to
+    /// Reads a Segment postings from an &[u8]
+    ///
+    /// * `len` - number of document in the posting lists.
+    /// * `data` - data array. The complete data is not necessarily used.
+    /// * `freq_handler` - the freq handler is in charge of decoding frequencies and/or positions
     pub(crate) fn from_block_postings(
-        segment_block_postings: BlockSegmentPostingsNotLoaded,
+        segment_block_postings: BlockSegmentPostings,
         position_reader: Option<PositionReader>,
-        seek_doc: DocId,
     ) -> SegmentPostings {
-        let (block_cursor, cur) = segment_block_postings.seek_and_load(seek_doc);
         SegmentPostings {
-            block_cursor,
-            cur,
+            block_cursor: segment_block_postings,
+            cur: 0, // cursor within the block
             position_reader,
         }
     }

src/postings/skip.rs

@@ -6,17 +6,21 @@ use crate::{DocId, Score, TERMINATED};
 
 // doc num bits uses the following encoding:
 // given 0b a b cdefgh
-//         |1|2|   3  |
+//         |1|2|3|  4  |
 // - 1: unused
 // - 2: is delta-1 encoded. 0 if not, 1, if yes
-// - 3: a 6 bit number in 0..=32, the actual bitwidth
+// - 3: unused
+// - 4: a 5 bit number in 0..32, the actual bitwidth. Bitpacking could in theory say this is 32
+//   (requiring a 6th bit), but the biggest doc_id we can want to encode is TERMINATED-1, which can
+//   be represented on 31b without delta encoding.
 fn encode_bitwidth(bitwidth: u8, delta_1: bool) -> u8 {
+    assert!(bitwidth < 32);
     bitwidth | ((delta_1 as u8) << 6)
 }
 
 fn decode_bitwidth(raw_bitwidth: u8) -> (u8, bool) {
     let delta_1 = ((raw_bitwidth >> 6) & 1) != 0;
-    let bitwidth = raw_bitwidth & 0x3f;
+    let bitwidth = raw_bitwidth & 0x1f;
     (bitwidth, delta_1)
 }
 
@@ -430,7 +434,7 @@ mod tests {
 
     #[test]
     fn test_encode_decode_bitwidth() {
-        for bitwidth in 0..=32 {
+        for bitwidth in 0..32 {
             for delta_1 in [false, true] {
                 assert_eq!(
                     (bitwidth, delta_1),

src/query/all_query.rs

@@ -21,12 +21,7 @@ impl Query for AllQuery {
 pub struct AllWeight;
 
 impl Weight for AllWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        _seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let all_scorer = AllScorer::new(reader.max_doc());
         if boost != 1.0 {
             Ok(Box::new(BoostScorer::new(all_scorer, boost)))
@@ -110,6 +105,7 @@ impl DocSet for AllScorer {
 }
 
 impl Scorer for AllScorer {
+    #[inline]
     fn score(&mut self) -> Score {
         1.0
     }
@@ -145,7 +141,7 @@ mod tests {
         let weight = AllQuery.weight(EnableScoring::disabled_from_schema(&index.schema()))?;
         {
             let reader = searcher.segment_reader(0);
-            let mut scorer = weight.scorer(reader, 1.0, 0)?;
+            let mut scorer = weight.scorer(reader, 1.0)?;
             assert_eq!(scorer.doc(), 0u32);
             assert_eq!(scorer.advance(), 1u32);
             assert_eq!(scorer.doc(), 1u32);
@@ -153,7 +149,7 @@ mod tests {
         }
         {
             let reader = searcher.segment_reader(1);
-            let mut scorer = weight.scorer(reader, 1.0, 0)?;
+            let mut scorer = weight.scorer(reader, 1.0)?;
             assert_eq!(scorer.doc(), 0u32);
             assert_eq!(scorer.advance(), TERMINATED);
         }
@@ -168,12 +164,12 @@ mod tests {
         let weight = AllQuery.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
         let reader = searcher.segment_reader(0);
         {
-            let mut scorer = weight.scorer(reader, 2.0, 0)?;
+            let mut scorer = weight.scorer(reader, 2.0)?;
             assert_eq!(scorer.doc(), 0u32);
             assert_eq!(scorer.score(), 2.0);
         }
         {
-            let mut scorer = weight.scorer(reader, 1.5, 0)?;
+            let mut scorer = weight.scorer(reader, 1.5)?;
             assert_eq!(scorer.doc(), 0u32);
             assert_eq!(scorer.score(), 1.5);
         }

src/query/automaton_weight.rs

@@ -84,12 +84,7 @@ where
     A: Automaton + Send + Sync + 'static,
     A::State: Clone,
 {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let max_doc = reader.max_doc();
         let mut doc_bitset = BitSet::with_max_value(max_doc);
         let inverted_index = reader.inverted_index(self.field)?;
@@ -98,9 +93,7 @@ where
         while term_stream.advance() {
             let term_info = term_stream.value();
             let mut block_segment_postings = inverted_index
-                .read_block_postings_from_terminfo_not_loaded(term_info, IndexRecordOption::Basic)?
-                .seek_and_load(seek_doc)
-                .0;
+                .read_block_postings_from_terminfo(term_info, IndexRecordOption::Basic)?;
             loop {
                 let docs = block_segment_postings.docs();
                 if docs.is_empty() {
@@ -118,7 +111,7 @@ where
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) == doc {
             Ok(Explanation::new("AutomatonScorer", 1.0))
         } else {
@@ -193,7 +186,7 @@ mod tests {
         let automaton_weight = AutomatonWeight::new(field, PrefixedByA);
         let reader = index.reader()?;
         let searcher = reader.searcher();
-        let mut scorer = automaton_weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+        let mut scorer = automaton_weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert_eq!(scorer.doc(), 0u32);
         assert_eq!(scorer.score(), 1.0);
         assert_eq!(scorer.advance(), 2u32);
@@ -210,7 +203,7 @@ mod tests {
         let automaton_weight = AutomatonWeight::new(field, PrefixedByA);
         let reader = index.reader()?;
         let searcher = reader.searcher();
-        let mut scorer = automaton_weight.scorer(searcher.segment_reader(0u32), 1.32, 0)?;
+        let mut scorer = automaton_weight.scorer(searcher.segment_reader(0u32), 1.32)?;
         assert_eq!(scorer.doc(), 0u32);
         assert_eq!(scorer.score(), 1.32);
         Ok(())

src/query/boolean_query/boolean_weight.rs

@@ -12,7 +12,7 @@ use crate::query::{
     intersect_scorers, AllScorer, BufferedUnionScorer, EmptyScorer, Exclude, Explanation, Occur,
     RequiredOptionalScorer, Scorer, Weight,
 };
-use crate::{DocId, Score, TERMINATED};
+use crate::{DocId, Score};
 
 enum SpecializedScorer {
     TermUnion(Vec<TermScorer>),
@@ -156,19 +156,6 @@ fn effective_should_scorer_for_union<TScoreCombiner: ScoreCombiner>(
     }
 }
 
-fn create_scorer(
-    weight: &dyn Weight,
-    reader: &SegmentReader,
-    boost: Score,
-    target_doc: DocId,
-) -> crate::Result<Box<dyn Scorer>> {
-    if target_doc >= reader.max_doc() {
-        Ok(Box::new(EmptyScorer))
-    } else {
-        weight.scorer(reader, boost, target_doc)
-    }
-}
-
 enum ShouldScorersCombinationMethod {
     // Should scorers are irrelevant.
     Ignored,
@@ -220,29 +207,10 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
         &self,
         reader: &SegmentReader,
         boost: Score,
-        mut seek_first_doc: DocId,
     ) -> crate::Result<HashMap<Occur, Vec<Box<dyn Scorer>>>> {
         let mut per_occur_scorers: HashMap<Occur, Vec<Box<dyn Scorer>>> = HashMap::new();
-        let (mut must_weights, other_weights): (Vec<(Occur, _)>, Vec<(Occur, _)>) = self
-            .weights
-            .iter()
-            .map(|(occur, weight)| (*occur, weight))
-            .partition(|(occur, _weight)| *occur == Occur::Must);
-        // We start by must weights in order to get the best "seek_first_doc" so that we
-        // can skip the first few documents of the other scorers.
-        must_weights.sort_by_key(|weight| weight.1.intersection_priority());
-        for (_, must_sub_weight) in must_weights {
-            let sub_scorer: Box<dyn Scorer> =
-                create_scorer(must_sub_weight.as_ref(), reader, boost, seek_first_doc)?;
-            seek_first_doc = seek_first_doc.max(sub_scorer.doc());
-            per_occur_scorers
-                .entry(Occur::Must)
-                .or_default()
-                .push(sub_scorer);
-        }
-        for (occur, sub_weight) in &other_weights {
-            let sub_scorer: Box<dyn Scorer> =
-                create_scorer(sub_weight.as_ref(), reader, boost, seek_first_doc)?;
+        for (occur, subweight) in &self.weights {
+            let sub_scorer: Box<dyn Scorer> = subweight.scorer(reader, boost)?;
             per_occur_scorers
                 .entry(*occur)
                 .or_default()
@@ -256,10 +224,9 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
         reader: &SegmentReader,
         boost: Score,
         score_combiner_fn: impl Fn() -> TComplexScoreCombiner,
-        seek_doc: u32,
     ) -> crate::Result<SpecializedScorer> {
         let num_docs = reader.num_docs();
-        let mut per_occur_scorers = self.per_occur_scorers(reader, boost, seek_doc)?;
+        let mut per_occur_scorers = self.per_occur_scorers(reader, boost)?;
 
         // Indicate how should clauses are combined with must clauses.
         let mut must_scorers: Vec<Box<dyn Scorer>> =
@@ -440,7 +407,7 @@ fn remove_and_count_all_and_empty_scorers(
         if scorer.is::<AllScorer>() {
             counts.num_all_scorers += 1;
             false
-        } else if scorer.doc() == TERMINATED {
+        } else if scorer.is::<EmptyScorer>() {
             counts.num_empty_scorers += 1;
             false
         } else {
@@ -451,12 +418,7 @@ fn remove_and_count_all_and_empty_scorers(
 }
 
 impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombiner> {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let num_docs = reader.num_docs();
         if self.weights.is_empty() {
             Ok(Box::new(EmptyScorer))
@@ -465,15 +427,15 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
             if occur == Occur::MustNot {
                 Ok(Box::new(EmptyScorer))
             } else {
-                weight.scorer(reader, boost, seek_doc)
+                weight.scorer(reader, boost)
             }
         } else if self.scoring_enabled {
-            self.complex_scorer(reader, boost, &self.score_combiner_fn, seek_doc)
+            self.complex_scorer(reader, boost, &self.score_combiner_fn)
                 .map(|specialized_scorer| {
                     into_box_scorer(specialized_scorer, &self.score_combiner_fn, num_docs)
                 })
         } else {
-            self.complex_scorer(reader, boost, DoNothingCombiner::default, seek_doc)
+            self.complex_scorer(reader, boost, DoNothingCombiner::default)
                 .map(|specialized_scorer| {
                     into_box_scorer(specialized_scorer, DoNothingCombiner::default, num_docs)
                 })
@@ -481,7 +443,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) != doc {
             return Err(does_not_match(doc));
         }
@@ -505,7 +467,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
-        let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn, 0)?;
+        let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn)?;
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
                 let mut union_scorer = BufferedUnionScorer::build(
@@ -527,7 +489,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         reader: &SegmentReader,
         callback: &mut dyn FnMut(&[DocId]),
     ) -> crate::Result<()> {
-        let scorer = self.complex_scorer(reader, 1.0, || DoNothingCombiner, 0u32)?;
+        let scorer = self.complex_scorer(reader, 1.0, || DoNothingCombiner)?;
         let mut buffer = [0u32; COLLECT_BLOCK_BUFFER_LEN];
 
         match scorer {
@@ -562,7 +524,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score) -> Score,
     ) -> crate::Result<()> {
-        let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn, 0u32)?;
+        let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn)?;
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
                 super::block_wand(term_scorers, threshold, callback);

src/query/boolean_query/mod.rs

@@ -57,7 +57,7 @@ mod tests {
         let query = query_parser.parse_query("+a")?;
         let searcher = index.reader()?.searcher();
         let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-        let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+        let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert!(scorer.is::<TermScorer>());
         Ok(())
     }
@@ -70,13 +70,13 @@ mod tests {
         {
             let query = query_parser.parse_query("+a +b +c")?;
             let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert!(scorer.is::<Intersection<TermScorer>>());
         }
         {
             let query = query_parser.parse_query("+a +(b c)")?;
             let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert!(scorer.is::<Intersection<Box<dyn Scorer>>>());
         }
         Ok(())
@@ -90,14 +90,14 @@ mod tests {
         {
             let query = query_parser.parse_query("+a b")?;
             let weight = query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
-            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert!(scorer
                 .is::<RequiredOptionalScorer<Box<dyn Scorer>, Box<dyn Scorer>, SumCombiner>>());
         }
         {
             let query = query_parser.parse_query("+a b")?;
             let weight = query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert!(scorer.is::<TermScorer>());
         }
         Ok(())
@@ -244,14 +244,12 @@ mod tests {
             .weight(EnableScoring::enabled_from_searcher(&searcher))
             .unwrap();
         {
-            let mut boolean_scorer =
-                boolean_weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+            let mut boolean_scorer = boolean_weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert_eq!(boolean_scorer.doc(), 0u32);
             assert_nearly_equals!(boolean_scorer.score(), 0.84163445);
         }
         {
-            let mut boolean_scorer =
-                boolean_weight.scorer(searcher.segment_reader(0u32), 2.0, 0)?;
+            let mut boolean_scorer = boolean_weight.scorer(searcher.segment_reader(0u32), 2.0)?;
             assert_eq!(boolean_scorer.doc(), 0u32);
             assert_nearly_equals!(boolean_scorer.score(), 1.6832689);
         }
@@ -345,7 +343,7 @@ mod tests {
                 (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, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
             assert!(scorer.is::<TermScorer>());
         }
         {
@@ -355,7 +353,7 @@ mod tests {
                 (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, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
             assert!(scorer.is::<EmptyScorer>());
         }
         {
@@ -364,7 +362,7 @@ mod tests {
                 (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, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
             assert!(scorer.is::<AllScorer>());
         }
         {
@@ -373,7 +371,7 @@ mod tests {
                 (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, 0)?;
+            let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0f32)?;
             assert!(scorer.is::<TermScorer>());
         }
         Ok(())
@@ -613,134 +611,6 @@ mod tests {
         Ok(())
     }
 
-    /// Test that the seek_doc parameter correctly skips documents in BooleanWeight::scorer.
-    ///
-    /// When seek_doc is provided, the scorer should start from that document (or the first
-    /// matching document >= seek_doc), skipping earlier documents.
-    #[test]
-    pub fn test_boolean_weight_seek_doc() -> crate::Result<()> {
-        let mut schema_builder = Schema::builder();
-        let text_field = schema_builder.add_text_field("text", TEXT);
-        let value_field = schema_builder.add_u64_field("value", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer: IndexWriter = index.writer_for_tests()?;
-
-        // Create 11 documents:
-        // doc 0: value=0
-        // doc 1: value=10
-        // doc 2: value=20
-        // ...
-        // doc 9: value=90
-        // doc 10: value=50 (matches range 30-70)
-        for i in 0..10 {
-            index_writer.add_document(doc!(
-                text_field => "hello",
-                value_field => (i * 10) as u64
-            ))?;
-        }
-        index_writer.add_document(doc!(
-            text_field => "hello",
-            value_field => 50u64
-        ))?;
-        index_writer.commit()?;
-
-        let searcher = index.reader()?.searcher();
-        let segment_reader = searcher.segment_reader(0);
-
-        // Create a Boolean query: MUST(term "hello") AND MUST(range 30..=70)
-        // This should match docs with value in [30, 70]: docs 3, 4, 5, 6, 7, 10
-        let term_query: Box<dyn Query> = Box::new(TermQuery::new(
-            Term::from_field_text(text_field, "hello"),
-            IndexRecordOption::Basic,
-        ));
-        let range_query: Box<dyn Query> = Box::new(RangeQuery::new(
-            Bound::Included(Term::from_field_u64(value_field, 30)),
-            Bound::Included(Term::from_field_u64(value_field, 70)),
-        ));
-
-        let boolean_query =
-            BooleanQuery::new(vec![(Occur::Must, term_query), (Occur::Must, range_query)]);
-
-        let weight =
-            boolean_query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-
-        let doc_when_seeking_from = |seek_from: DocId| {
-            let scorer = weight.scorer(segment_reader, 1.0f32, seek_from).unwrap();
-            crate::docset::docset_to_doc_vec(scorer)
-        };
-
-        // Expected matching docs: 3, 4, 5, 6, 7, 10 (values 30, 40, 50, 60, 70, 50)
-        assert_eq!(doc_when_seeking_from(0), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(1), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(3), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(4), vec![4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(7), vec![7, 10]);
-        assert_eq!(doc_when_seeking_from(8), vec![10]);
-        assert_eq!(doc_when_seeking_from(10), vec![10]);
-        assert_eq!(doc_when_seeking_from(11), Vec::<DocId>::new());
-
-        Ok(())
-    }
-
-    /// Test that the seek_doc parameter works correctly with SHOULD clauses.
-    #[test]
-    pub fn test_boolean_weight_seek_doc_with_should() -> 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()?;
-
-        // Create documents:
-        // doc 0: "a b"
-        // doc 1: "a"
-        // doc 2: "b"
-        // doc 3: "c"
-        // doc 4: "a b c"
-        index_writer.add_document(doc!(text_field => "a b"))?;
-        index_writer.add_document(doc!(text_field => "a"))?;
-        index_writer.add_document(doc!(text_field => "b"))?;
-        index_writer.add_document(doc!(text_field => "c"))?;
-        index_writer.add_document(doc!(text_field => "a b c"))?;
-        index_writer.commit()?;
-
-        let searcher = index.reader()?.searcher();
-        let segment_reader = searcher.segment_reader(0);
-
-        // Create a Boolean query: SHOULD(term "a") OR SHOULD(term "b")
-        // This should match docs 0, 1, 2, 4
-        let term_a: Box<dyn Query> = Box::new(TermQuery::new(
-            Term::from_field_text(text_field, "a"),
-            IndexRecordOption::Basic,
-        ));
-        let term_b: Box<dyn Query> = Box::new(TermQuery::new(
-            Term::from_field_text(text_field, "b"),
-            IndexRecordOption::Basic,
-        ));
-
-        let boolean_query =
-            BooleanQuery::new(vec![(Occur::Should, term_a), (Occur::Should, term_b)]);
-
-        let weight =
-            boolean_query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-
-        let doc_when_seeking_from = |seek_from: DocId| {
-            let scorer = weight.scorer(segment_reader, 1.0f32, seek_from).unwrap();
-            crate::docset::docset_to_doc_vec(scorer)
-        };
-
-        // Expected matching docs: 0, 1, 2, 4
-        assert_eq!(doc_when_seeking_from(0), vec![0, 1, 2, 4]);
-        assert_eq!(doc_when_seeking_from(1), vec![1, 2, 4]);
-        assert_eq!(doc_when_seeking_from(2), vec![2, 4]);
-        assert_eq!(doc_when_seeking_from(3), vec![4]);
-        assert_eq!(doc_when_seeking_from(4), vec![4]);
-        assert_eq!(doc_when_seeking_from(5), Vec::<DocId>::new());
-
-        Ok(())
-    }
-
     /// Test multiple AllScorer instances in different clause types.
     ///
     /// Verifies correct behavior when AllScorers appear in multiple positions.

src/query/boost_query.rs

@@ -67,13 +67,8 @@ impl BoostWeight {
 }
 
 impl Weight for BoostWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
-        self.weight.scorer(reader, boost * self.boost, seek_doc)
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
+        self.weight.scorer(reader, boost * self.boost)
     }
 
     fn explain(&self, reader: &SegmentReader, doc: u32) -> crate::Result<Explanation> {
@@ -88,10 +83,6 @@ impl Weight for BoostWeight {
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
         self.weight.count(reader)
     }
-
-    fn intersection_priority(&self) -> u32 {
-        self.weight.intersection_priority()
-    }
 }
 
 pub(crate) struct BoostScorer<S: Scorer> {
@@ -143,6 +134,7 @@ impl<S: Scorer> DocSet for BoostScorer<S> {
 }
 
 impl<S: Scorer> Scorer for BoostScorer<S> {
+    #[inline]
     fn score(&mut self) -> Score {
         self.underlying.score() * self.boost
     }

src/query/const_score_query.rs

@@ -63,18 +63,13 @@ impl ConstWeight {
 }
 
 impl Weight for ConstWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
-        let inner_scorer = self.weight.scorer(reader, boost, seek_doc)?;
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
+        let inner_scorer = self.weight.scorer(reader, boost)?;
         Ok(Box::new(ConstScorer::new(inner_scorer, boost * self.score)))
     }
 
     fn explain(&self, reader: &SegmentReader, doc: u32) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) != doc {
             return Err(TantivyError::InvalidArgument(format!(
                 "Document #({doc}) does not match"
@@ -89,10 +84,6 @@ impl Weight for ConstWeight {
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
         self.weight.count(reader)
     }
-
-    fn intersection_priority(&self) -> u32 {
-        self.weight.intersection_priority()
-    }
 }
 
 /// Wraps a `DocSet` and simply returns a constant `Scorer`.
@@ -146,6 +137,7 @@ impl<TDocSet: DocSet> DocSet for ConstScorer<TDocSet> {
 }
 
 impl<TDocSet: DocSet + 'static> Scorer for ConstScorer<TDocSet> {
+    #[inline]
     fn score(&mut self) -> Score {
         self.score
     }

src/query/disjunction.rs

@@ -173,6 +173,7 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> DocSet
 impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> Scorer
     for Disjunction<TScorer, TScoreCombiner>
 {
+    #[inline]
     fn score(&mut self) -> Score {
         self.current_score
     }
@@ -307,6 +308,7 @@ mod tests {
     }
 
     impl Scorer for DummyScorer {
+        #[inline]
         fn score(&mut self) -> Score {
             self.foo.get(self.cursor).map(|x| x.1).unwrap_or(0.0)
         }

src/query/empty_query.rs

@@ -26,24 +26,13 @@ impl Query for EmptyQuery {
 /// It is useful for tests and handling edge cases.
 pub struct EmptyWeight;
 impl Weight for EmptyWeight {
-    fn scorer(
-        &self,
-        _reader: &SegmentReader,
-        _boost: Score,
-        _seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, _reader: &SegmentReader, _boost: Score) -> crate::Result<Box<dyn Scorer>> {
         Ok(Box::new(EmptyScorer))
     }
 
     fn explain(&self, _reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
         Err(does_not_match(doc))
     }
-
-    /// Returns a priority number used to sort weights when running an
-    /// intersection.
-    fn intersection_priority(&self) -> u32 {
-        0u32
-    }
 }
 
 /// `EmptyScorer` is a dummy `Scorer` in which no document matches.
@@ -66,6 +55,7 @@ impl DocSet for EmptyScorer {
 }
 
 impl Scorer for EmptyScorer {
+    #[inline]
     fn score(&mut self) -> Score {
         0.0
     }

src/query/exclude.rs

@@ -84,6 +84,7 @@ where
     TScorer: Scorer,
     TDocSetExclude: DocSet + 'static,
 {
+    #[inline]
     fn score(&mut self) -> Score {
         self.underlying_docset.score()
     }

src/query/exist_query.rs

@@ -98,12 +98,7 @@ pub struct ExistsWeight {
 }
 
 impl Weight for ExistsWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        _seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let fast_field_reader = reader.fast_fields();
         let mut column_handles = fast_field_reader.dynamic_column_handles(&self.field_name)?;
         if self.field_type == Type::Json && self.json_subpaths {
@@ -171,7 +166,7 @@ impl Weight for ExistsWeight {
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) != doc {
             return Err(does_not_match(doc));
         }

src/query/intersection.rs

@@ -105,6 +105,7 @@ impl<TDocSet: DocSet> Intersection<TDocSet, TDocSet> {
 }
 
 impl<TDocSet: DocSet, TOtherDocSet: DocSet> DocSet for Intersection<TDocSet, TOtherDocSet> {
+    #[inline]
     fn advance(&mut self) -> DocId {
         let (left, right) = (&mut self.left, &mut self.right);
         let mut candidate = left.advance();
@@ -174,6 +175,7 @@ impl<TDocSet: DocSet, TOtherDocSet: DocSet> DocSet for Intersection<TDocSet, TOt
                 .all(|docset| docset.seek_into_the_danger_zone(target))
     }
 
+    #[inline]
     fn doc(&self) -> DocId {
         self.left.doc()
     }
@@ -200,6 +202,7 @@ where
     TScorer: Scorer,
     TOtherScorer: Scorer,
 {
+    #[inline]
     fn score(&mut self) -> Score {
         self.left.score()
             + self.right.score()

src/query/phrase_prefix_query/phrase_prefix_scorer.rs

@@ -81,6 +81,7 @@ impl<TPostings: Postings> DocSet for PhraseKind<TPostings> {
 }
 
 impl<TPostings: Postings> Scorer for PhraseKind<TPostings> {
+    #[inline]
     fn score(&mut self) -> Score {
         match self {
             PhraseKind::SinglePrefix { positions, .. } => {
@@ -215,6 +216,7 @@ impl<TPostings: Postings> DocSet for PhrasePrefixScorer<TPostings> {
 }
 
 impl<TPostings: Postings> Scorer for PhrasePrefixScorer<TPostings> {
+    #[inline]
     fn score(&mut self) -> Score {
         // TODO modify score??
         self.phrase_scorer.score()

src/query/phrase_prefix_query/phrase_prefix_weight.rs

@@ -42,11 +42,10 @@ impl PhrasePrefixWeight {
         Ok(FieldNormReader::constant(reader.max_doc(), 1))
     }
 
-    pub(crate) fn prefix_phrase_scorer(
+    pub(crate) fn phrase_scorer(
         &self,
         reader: &SegmentReader,
         boost: Score,
-        seek_doc: DocId,
     ) -> crate::Result<Option<PhrasePrefixScorer<SegmentPostings>>> {
         let similarity_weight_opt = self
             .similarity_weight_opt
@@ -55,16 +54,14 @@ impl PhrasePrefixWeight {
         let fieldnorm_reader = self.fieldnorm_reader(reader)?;
         let mut term_postings_list = Vec::new();
         for &(offset, ref term) in &self.phrase_terms {
-            let inverted_index = reader.inverted_index(term.field())?;
-            let Some(term_info) = inverted_index.get_term_info(term)? else {
+            if let Some(postings) = reader
+                .inverted_index(term.field())?
+                .read_postings(term, IndexRecordOption::WithFreqsAndPositions)?
+            {
+                term_postings_list.push((offset, postings));
+            } else {
                 return Ok(None);
-            };
-            let postings = inverted_index.read_postings_from_terminfo(
-                &term_info,
-                IndexRecordOption::WithFreqsAndPositions,
-                seek_doc,
-            )?;
-            term_postings_list.push((offset, postings));
+            }
         }
 
         let inv_index = reader.inverted_index(self.prefix.1.field())?;
@@ -117,13 +114,8 @@ impl PhrasePrefixWeight {
 }
 
 impl Weight for PhrasePrefixWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
-        if let Some(scorer) = self.prefix_phrase_scorer(reader, boost, seek_doc)? {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
+        if let Some(scorer) = self.phrase_scorer(reader, boost)? {
             Ok(Box::new(scorer))
         } else {
             Ok(Box::new(EmptyScorer))
@@ -131,7 +123,7 @@ impl Weight for PhrasePrefixWeight {
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let scorer_opt = self.prefix_phrase_scorer(reader, 1.0, doc)?;
+        let scorer_opt = self.phrase_scorer(reader, 1.0)?;
         if scorer_opt.is_none() {
             return Err(does_not_match(doc));
         }
@@ -148,10 +140,6 @@ impl Weight for PhrasePrefixWeight {
         }
         Ok(explanation)
     }
-
-    fn intersection_priority(&self) -> u32 {
-        50u32
-    }
 }
 
 #[cfg(test)]
@@ -199,7 +187,7 @@ mod tests {
             .unwrap()
             .unwrap();
         let mut phrase_scorer = phrase_weight
-            .prefix_phrase_scorer(searcher.segment_reader(0u32), 1.0, 0u32)?
+            .phrase_scorer(searcher.segment_reader(0u32), 1.0)?
             .unwrap();
         assert_eq!(phrase_scorer.doc(), 1);
         assert_eq!(phrase_scorer.phrase_count(), 2);
@@ -226,7 +214,7 @@ mod tests {
             .unwrap()
             .unwrap();
         let mut phrase_scorer = phrase_weight
-            .prefix_phrase_scorer(searcher.segment_reader(0u32), 1.0, 0u32)?
+            .phrase_scorer(searcher.segment_reader(0u32), 1.0)?
             .unwrap();
         assert_eq!(phrase_scorer.doc(), 1);
         assert_eq!(phrase_scorer.phrase_count(), 2);
@@ -250,7 +238,7 @@ mod tests {
             .unwrap()
             .is_none());
         let weight = phrase_query.weight(enable_scoring).unwrap();
-        let mut phrase_scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+        let mut phrase_scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert_eq!(phrase_scorer.doc(), 1);
         assert_eq!(phrase_scorer.advance(), 2);
         assert_eq!(phrase_scorer.doc(), 2);
@@ -271,7 +259,7 @@ mod tests {
         ]);
         let enable_scoring = EnableScoring::enabled_from_searcher(&searcher);
         let weight = phrase_query.weight(enable_scoring).unwrap();
-        let mut phrase_scorer = weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+        let mut phrase_scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert_eq!(phrase_scorer.advance(), TERMINATED);
         Ok(())
     }

src/query/phrase_query/mod.rs

@@ -84,7 +84,7 @@ pub(crate) mod tests {
         let phrase_query = PhraseQuery::new(terms);
         let phrase_weight =
             phrase_query.phrase_weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-        let mut phrase_scorer = phrase_weight.scorer(searcher.segment_reader(0), 1.0, 0)?;
+        let mut phrase_scorer = phrase_weight.scorer(searcher.segment_reader(0), 1.0)?;
         assert_eq!(phrase_scorer.doc(), 1);
         assert_eq!(phrase_scorer.advance(), TERMINATED);
         Ok(())
@@ -343,43 +343,6 @@ pub(crate) mod tests {
         Ok(())
     }
 
-    #[test]
-    pub fn test_phrase_weight_seek_doc() -> crate::Result<()> {
-        // Create an index with documents where the phrase "a b" appears in some of them.
-        // Documents: 0: "c d", 1: "a b", 2: "e f", 3: "a b c", 4: "g h", 5: "a b", 6: "i j"
-        let index = create_index(&["c d", "a b", "e f", "a b c", "g h", "a b", "i j"])?;
-        let text_field = index.schema().get_field("text").unwrap();
-        let searcher = index.reader()?.searcher();
-        let segment_reader = searcher.segment_reader(0);
-
-        let phrase_query = PhraseQuery::new(vec![
-            Term::from_field_text(text_field, "a"),
-            Term::from_field_text(text_field, "b"),
-        ]);
-        let phrase_weight =
-            phrase_query.phrase_weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-
-        // Helper function to collect all docs from a scorer created with a given seek_doc
-        let docs_when_seeking_from = |seek_from: DocId| {
-            let scorer = phrase_weight
-                .scorer(segment_reader, 1.0f32, seek_from)
-                .unwrap();
-            crate::docset::docset_to_doc_vec(scorer)
-        };
-
-        // Documents with "a b": 1, 3, 5
-        assert_eq!(docs_when_seeking_from(0), vec![1, 3, 5]);
-        assert_eq!(docs_when_seeking_from(1), vec![1, 3, 5]);
-        assert_eq!(docs_when_seeking_from(2), vec![3, 5]);
-        assert_eq!(docs_when_seeking_from(3), vec![3, 5]);
-        assert_eq!(docs_when_seeking_from(4), vec![5]);
-        assert_eq!(docs_when_seeking_from(5), vec![5]);
-        assert_eq!(docs_when_seeking_from(6), Vec::<DocId>::new());
-        assert_eq!(docs_when_seeking_from(7), Vec::<DocId>::new());
-
-        Ok(())
-    }
-
     #[test]
     pub fn test_phrase_query_on_json() -> crate::Result<()> {
         let mut schema_builder = Schema::builder();
@@ -410,7 +373,7 @@ pub(crate) mod tests {
                 .weight(EnableScoring::disabled_from_schema(searcher.schema()))
                 .unwrap();
             let mut phrase_scorer = phrase_weight
-                .scorer(searcher.segment_reader(0), 1.0f32, 0)
+                .scorer(searcher.segment_reader(0), 1.0f32)
                 .unwrap();
             let mut docs = Vec::new();
             loop {

src/query/phrase_query/phrase_scorer.rs

@@ -563,6 +563,7 @@ impl<TPostings: Postings> DocSet for PhraseScorer<TPostings> {
 }
 
 impl<TPostings: Postings> Scorer for PhraseScorer<TPostings> {
+    #[inline]
     fn score(&mut self) -> Score {
         let doc = self.doc();
         let fieldnorm_id = self.fieldnorm_reader.fieldnorm_id(doc);

src/query/phrase_query/phrase_weight.rs

@@ -43,7 +43,6 @@ impl PhraseWeight {
         &self,
         reader: &SegmentReader,
         boost: Score,
-        seek_doc: DocId,
     ) -> crate::Result<Option<PhraseScorer<SegmentPostings>>> {
         let similarity_weight_opt = self
             .similarity_weight_opt
@@ -52,16 +51,14 @@ impl PhraseWeight {
         let fieldnorm_reader = self.fieldnorm_reader(reader)?;
         let mut term_postings_list = Vec::new();
         for &(offset, ref term) in &self.phrase_terms {
-            let inverted_index = reader.inverted_index(term.field())?;
-            let Some(term_info) = inverted_index.get_term_info(term)? else {
+            if let Some(postings) = reader
+                .inverted_index(term.field())?
+                .read_postings(term, IndexRecordOption::WithFreqsAndPositions)?
+            {
+                term_postings_list.push((offset, postings));
+            } else {
                 return Ok(None);
-            };
-            let postings = inverted_index.read_postings_from_terminfo(
-                &term_info,
-                IndexRecordOption::WithFreqsAndPositions,
-                seek_doc,
-            )?;
-            term_postings_list.push((offset, postings));
+            }
         }
         Ok(Some(PhraseScorer::new(
             term_postings_list,
@@ -77,13 +74,8 @@ impl PhraseWeight {
 }
 
 impl Weight for PhraseWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
-        if let Some(scorer) = self.phrase_scorer(reader, boost, seek_doc)? {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
+        if let Some(scorer) = self.phrase_scorer(reader, boost)? {
             Ok(Box::new(scorer))
         } else {
             Ok(Box::new(EmptyScorer))
@@ -91,12 +83,12 @@ impl Weight for PhraseWeight {
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let scorer_opt = self.phrase_scorer(reader, 1.0, doc)?;
+        let scorer_opt = self.phrase_scorer(reader, 1.0)?;
         if scorer_opt.is_none() {
             return Err(does_not_match(doc));
         }
         let mut scorer = scorer_opt.unwrap();
-        if scorer.doc() != doc {
+        if scorer.seek(doc) != doc {
             return Err(does_not_match(doc));
         }
         let fieldnorm_reader = self.fieldnorm_reader(reader)?;
@@ -108,10 +100,6 @@ impl Weight for PhraseWeight {
         }
         Ok(explanation)
     }
-
-    fn intersection_priority(&self) -> u32 {
-        40u32
-    }
 }
 
 #[cfg(test)]
@@ -134,7 +122,7 @@ mod tests {
         let enable_scoring = EnableScoring::enabled_from_searcher(&searcher);
         let phrase_weight = phrase_query.phrase_weight(enable_scoring).unwrap();
         let mut phrase_scorer = phrase_weight
-            .phrase_scorer(searcher.segment_reader(0u32), 1.0, 0)?
+            .phrase_scorer(searcher.segment_reader(0u32), 1.0)?
             .unwrap();
         assert_eq!(phrase_scorer.doc(), 1);
         assert_eq!(phrase_scorer.phrase_count(), 2);

src/query/phrase_query/regex_phrase_weight.rs

@@ -195,11 +195,8 @@ impl RegexPhraseWeight {
         const SPARSE_TERM_DOC_THRESHOLD: u32 = 100;
 
         for term_info in term_infos {
-            let mut term_posting = inverted_index.read_postings_from_terminfo(
-                term_info,
-                IndexRecordOption::WithFreqsAndPositions,
-                0u32,
-            )?;
+            let mut term_posting = inverted_index
+                .read_postings_from_terminfo(term_info, IndexRecordOption::WithFreqsAndPositions)?;
             let num_docs = term_posting.doc_freq();
 
             if num_docs < SPARSE_TERM_DOC_THRESHOLD {
@@ -272,12 +269,7 @@ impl RegexPhraseWeight {
 }
 
 impl Weight for RegexPhraseWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        _seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         if let Some(scorer) = self.phrase_scorer(reader, boost)? {
             Ok(Box::new(scorer))
         } else {

src/query/range_query/fast_field_range_doc_set.rs

@@ -61,11 +61,7 @@ pub(crate) struct RangeDocSet<T> {
 
 const DEFAULT_FETCH_HORIZON: u32 = 128;
 impl<T: Send + Sync + PartialOrd + Copy + Debug + 'static> RangeDocSet<T> {
-    pub(crate) fn new(
-        value_range: RangeInclusive<T>,
-        column: Column<T>,
-        seek_first_doc: DocId,
-    ) -> Self {
+    pub(crate) fn new(value_range: RangeInclusive<T>, column: Column<T>) -> Self {
         if *value_range.start() > column.max_value() || *value_range.end() < column.min_value() {
             return Self {
                 value_range,
@@ -81,7 +77,7 @@ impl<T: Send + Sync + PartialOrd + Copy + Debug + 'static> RangeDocSet<T> {
             value_range,
             column,
             loaded_docs: VecCursor::new(),
-            next_fetch_start: seek_first_doc,
+            next_fetch_start: 0,
             fetch_horizon: DEFAULT_FETCH_HORIZON,
             last_seek_pos_opt: None,
         };

src/query/range_query/range_query.rs

@@ -212,12 +212,7 @@ impl InvertedIndexRangeWeight {
 }
 
 impl Weight for InvertedIndexRangeWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let max_doc = reader.max_doc();
         let mut doc_bitset = BitSet::with_max_value(max_doc);
 
@@ -234,9 +229,7 @@ impl Weight for InvertedIndexRangeWeight {
             processed_count += 1;
             let term_info = term_range.value();
             let mut block_segment_postings = inverted_index
-                .read_block_postings_from_terminfo_not_loaded(term_info, IndexRecordOption::Basic)?
-                .seek_and_load(seek_doc)
-                .0;
+                .read_block_postings_from_terminfo(term_info, IndexRecordOption::Basic)?;
             loop {
                 let docs = block_segment_postings.docs();
                 if docs.is_empty() {
@@ -253,7 +246,7 @@ impl Weight for InvertedIndexRangeWeight {
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) != doc {
             return Err(does_not_match(doc));
         }
@@ -693,7 +686,7 @@ mod tests {
                 .weight(EnableScoring::disabled_from_schema(&schema))
                 .unwrap();
             let range_scorer = range_weight
-                .scorer(&searcher.segment_readers()[0], 1.0f32, 0)
+                .scorer(&searcher.segment_readers()[0], 1.0f32)
                 .unwrap();
             range_scorer
         };

src/query/range_query/range_query_fastfield.rs

@@ -52,12 +52,7 @@ impl FastFieldRangeWeight {
 }
 
 impl Weight for FastFieldRangeWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         // Check if both bounds are Bound::Unbounded
         if self.bounds.is_unbounded() {
             return Ok(Box::new(AllScorer::new(reader.max_doc())));
@@ -114,21 +109,11 @@ impl Weight for FastFieldRangeWeight {
                     else {
                         return Ok(Box::new(EmptyScorer));
                     };
-                    search_on_u64_ff(
-                        column,
-                        boost,
-                        BoundsRange::new(lower_bound, upper_bound),
-                        seek_doc,
-                    )
+                    search_on_u64_ff(column, boost, BoundsRange::new(lower_bound, upper_bound))
+                }
+                Type::U64 | Type::I64 | Type::F64 => {
+                    search_on_json_numerical_field(reader, &field_name, typ, bounds, boost)
                 }
-                Type::U64 | Type::I64 | Type::F64 => search_on_json_numerical_field(
-                    reader,
-                    &field_name,
-                    typ,
-                    bounds,
-                    boost,
-                    seek_doc,
-                ),
                 Type::Date => {
                     let fast_field_reader = reader.fast_fields();
                     let Some((column, _col_type)) = fast_field_reader
@@ -141,7 +126,6 @@ impl Weight for FastFieldRangeWeight {
                         column,
                         boost,
                         BoundsRange::new(bounds.lower_bound, bounds.upper_bound),
-                        seek_doc,
                     )
                 }
                 Type::Bool | Type::Facet | Type::Bytes | Type::Json | Type::IpAddr => {
@@ -170,7 +154,7 @@ impl Weight for FastFieldRangeWeight {
                 ip_addr_column.min_value(),
                 ip_addr_column.max_value(),
             );
-            let docset = RangeDocSet::new(value_range, ip_addr_column, seek_doc);
+            let docset = RangeDocSet::new(value_range, ip_addr_column);
             Ok(Box::new(ConstScorer::new(docset, boost)))
         } else if field_type.is_str() {
             let Some(str_dict_column): Option<StrColumn> = reader.fast_fields().str(&field_name)?
@@ -189,12 +173,7 @@ impl Weight for FastFieldRangeWeight {
             else {
                 return Ok(Box::new(EmptyScorer));
             };
-            search_on_u64_ff(
-                column,
-                boost,
-                BoundsRange::new(lower_bound, upper_bound),
-                seek_doc,
-            )
+            search_on_u64_ff(column, boost, BoundsRange::new(lower_bound, upper_bound))
         } else {
             assert!(
                 maps_to_u64_fastfield(field_type.value_type()),
@@ -236,13 +215,12 @@ impl Weight for FastFieldRangeWeight {
                 column,
                 boost,
                 BoundsRange::new(bounds.lower_bound, bounds.upper_bound),
-                seek_doc,
             )
         }
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if scorer.seek(doc) != doc {
             return Err(TantivyError::InvalidArgument(format!(
                 "Document #({doc}) does not match"
@@ -252,10 +230,6 @@ impl Weight for FastFieldRangeWeight {
 
         Ok(explanation)
     }
-
-    fn intersection_priority(&self) -> u32 {
-        30u32
-    }
 }
 
 /// On numerical fields the column type may not match the user provided one.
@@ -267,7 +241,6 @@ fn search_on_json_numerical_field(
     typ: Type,
     bounds: BoundsRange<ValueBytes<Vec<u8>>>,
     boost: Score,
-    seek_doc: DocId,
 ) -> crate::Result<Box<dyn Scorer>> {
     // Since we don't know which type was interpolated for the internal column we
     // have to check for all numeric types (only one exists)
@@ -345,7 +318,6 @@ fn search_on_json_numerical_field(
         column,
         boost,
         BoundsRange::new(bounds.lower_bound, bounds.upper_bound),
-        seek_doc,
     )
 }
 
@@ -424,7 +396,6 @@ fn search_on_u64_ff(
     column: Column<u64>,
     boost: Score,
     bounds: BoundsRange<u64>,
-    seek_doc: DocId,
 ) -> crate::Result<Box<dyn Scorer>> {
     let col_min_value = column.min_value();
     let col_max_value = column.max_value();
@@ -455,8 +426,8 @@ fn search_on_u64_ff(
         }
     }
 
-    let doc_set = RangeDocSet::new(value_range, column, seek_doc);
-    Ok(Box::new(ConstScorer::new(doc_set, boost)))
+    let docset = RangeDocSet::new(value_range, column);
+    Ok(Box::new(ConstScorer::new(docset, boost)))
 }
 
 /// Returns true if the type maps to a u64 fast field
@@ -533,7 +504,7 @@ mod tests {
         DateOptions, Field, NumericOptions, Schema, SchemaBuilder, FAST, INDEXED, STORED, STRING,
         TEXT,
     };
-    use crate::{DocId, Index, IndexWriter, TantivyDocument, Term, TERMINATED};
+    use crate::{Index, IndexWriter, TantivyDocument, Term, TERMINATED};
 
     #[test]
     fn test_text_field_ff_range_query() -> crate::Result<()> {
@@ -1171,52 +1142,11 @@ mod tests {
             Bound::Included(Term::from_field_u64(field, 50_002)),
         ));
         let scorer = range_query
-            .scorer(searcher.segment_reader(0), 1.0f32, 0)
+            .scorer(searcher.segment_reader(0), 1.0f32)
             .unwrap();
         assert_eq!(scorer.doc(), TERMINATED);
     }
 
-    #[test]
-    fn test_fastfield_range_weight_seek_doc() {
-        let mut schema_builder = SchemaBuilder::new();
-        let field = schema_builder.add_u64_field("value", FAST);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut writer: IndexWriter = index.writer_for_tests().unwrap();
-
-        // Create 20 documents with values
-        //  0, 10, 20, ..., 90
-        // and then 50  again.
-        for i in 0..10 {
-            writer.add_document(doc!(field => (i * 10) as u64)).unwrap();
-        }
-        writer.add_document(doc!(field => 50u64)).unwrap();
-        writer.commit().unwrap();
-
-        let searcher = index.reader().unwrap().searcher();
-        let segment_reader = searcher.segment_reader(0);
-
-        let range_weight = FastFieldRangeWeight::new(BoundsRange::new(
-            Bound::Included(Term::from_field_u64(field, 30)),
-            Bound::Included(Term::from_field_u64(field, 70)),
-        ));
-
-        let doc_when_seeking_from = |seek_from: DocId| {
-            let doc_set = range_weight
-                .scorer(segment_reader, 1.0f32, seek_from)
-                .unwrap();
-            crate::docset::docset_to_doc_vec(doc_set)
-        };
-
-        assert_eq!(doc_when_seeking_from(0), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(1), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(3), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(7), vec![7, 10]);
-        assert_eq!(doc_when_seeking_from(8), vec![10]);
-        assert_eq!(doc_when_seeking_from(10), vec![10]);
-        assert_eq!(doc_when_seeking_from(11), Vec::<DocId>::new());
-    }
-
     #[test]
     fn range_regression3_test() {
         let ops = vec![doc_from_id_1(1), doc_from_id_1(2), doc_from_id_1(3)];

src/query/reqopt_scorer.rs

@@ -81,6 +81,7 @@ where
     TOptScorer: Scorer,
     TScoreCombiner: ScoreCombiner,
 {
+    #[inline]
     fn score(&mut self) -> Score {
         if let Some(score) = self.score_cache {
             return score;

src/query/score_combiner.rs

@@ -29,6 +29,7 @@ impl ScoreCombiner for DoNothingCombiner {
 
     fn clear(&mut self) {}
 
+    #[inline]
     fn score(&self) -> Score {
         1.0
     }
@@ -49,6 +50,7 @@ impl ScoreCombiner for SumCombiner {
         self.score = 0.0;
     }
 
+    #[inline]
     fn score(&self) -> Score {
         self.score
     }
@@ -86,6 +88,7 @@ impl ScoreCombiner for DisjunctionMaxCombiner {
         self.sum = 0.0;
     }
 
+    #[inline]
     fn score(&self) -> Score {
         self.max + (self.sum - self.max) * self.tie_breaker
     }

src/query/scorer.rs

@@ -18,6 +18,7 @@ pub trait Scorer: downcast_rs::Downcast + DocSet + 'static {
 impl_downcast!(Scorer);
 
 impl Scorer for Box<dyn Scorer> {
+    #[inline]
     fn score(&mut self) -> Score {
         self.deref_mut().score()
     }

src/query/term_query/mod.rs

@@ -37,7 +37,7 @@ mod tests {
         );
         let term_weight = term_query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
         let segment_reader = searcher.segment_reader(0);
-        let mut term_scorer = term_weight.scorer(segment_reader, 1.0, 0)?;
+        let mut term_scorer = term_weight.scorer(segment_reader, 1.0)?;
         assert_eq!(term_scorer.doc(), 0);
         assert_nearly_equals!(term_scorer.score(), 0.28768212);
         Ok(())
@@ -65,7 +65,7 @@ mod tests {
         );
         let term_weight = term_query.weight(EnableScoring::enabled_from_searcher(&searcher))?;
         let segment_reader = searcher.segment_reader(0);
-        let mut term_scorer = term_weight.scorer(segment_reader, 1.0, 0)?;
+        let mut term_scorer = term_weight.scorer(segment_reader, 1.0)?;
         for i in 0u32..COMPRESSION_BLOCK_SIZE as u32 {
             assert_eq!(term_scorer.doc(), i);
             if i == COMPRESSION_BLOCK_SIZE as u32 - 1u32 {
@@ -162,7 +162,7 @@ mod tests {
         let searcher = index.reader()?.searcher();
         let term_weight =
             term_query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-        let mut term_scorer = term_weight.scorer(searcher.segment_reader(0u32), 1.0, 0)?;
+        let mut term_scorer = term_weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert_eq!(term_scorer.doc(), 0u32);
         term_scorer.seek(1u32);
         assert_eq!(term_scorer.doc(), 1u32);
@@ -470,7 +470,7 @@ mod tests {
                 .weight(EnableScoring::disabled_from_schema(&schema))
                 .unwrap();
             term_weight
-                .scorer(searcher.segment_reader(0u32), 1.0f32, 0)
+                .scorer(searcher.segment_reader(0u32), 1.0f32)
                 .unwrap()
         };
         // Should be an allscorer
@@ -484,53 +484,6 @@ mod tests {
         assert!(empty_scorer.is::<EmptyScorer>());
     }
 
-    #[test]
-    fn test_term_weight_seek_doc() -> 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()?;
-
-        // Create 11 documents where docs 3, 4, 5, 6, 7, and 10 contain "target"
-        // (similar pattern to test_fastfield_range_weight_seek_doc)
-        for i in 0..11 {
-            if i == 3 || i == 4 || i == 5 || i == 6 || i == 7 || i == 10 {
-                index_writer.add_document(doc!(text_field => "target"))?;
-            } else {
-                index_writer.add_document(doc!(text_field => "other"))?;
-            }
-        }
-        index_writer.commit()?;
-
-        let searcher = index.reader()?.searcher();
-        let segment_reader = searcher.segment_reader(0);
-
-        let term_query = TermQuery::new(
-            Term::from_field_text(text_field, "target"),
-            IndexRecordOption::Basic,
-        );
-        let term_weight =
-            term_query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
-
-        let doc_when_seeking_from = |seek_from: crate::DocId| {
-            let scorer = term_weight
-                .scorer(segment_reader, 1.0f32, seek_from)
-                .unwrap();
-            crate::docset::docset_to_doc_vec(scorer)
-        };
-
-        assert_eq!(doc_when_seeking_from(0), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(1), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(3), vec![3, 4, 5, 6, 7, 10]);
-        assert_eq!(doc_when_seeking_from(7), vec![7, 10]);
-        assert_eq!(doc_when_seeking_from(8), vec![10]);
-        assert_eq!(doc_when_seeking_from(10), vec![10]);
-        assert_eq!(doc_when_seeking_from(11), Vec::<crate::DocId>::new());
-
-        Ok(())
-    }
-
     #[test]
     fn test_term_weight_all_query_optimization_disable_when_scoring_enabled() {
         let mut schema_builder = Schema::builder();
@@ -556,7 +509,7 @@ mod tests {
                 .weight(EnableScoring::enabled_from_searcher(&searcher))
                 .unwrap();
             term_weight
-                .scorer(searcher.segment_reader(0u32), 1.0f32, 0)
+                .scorer(searcher.segment_reader(0u32), 1.0f32)
                 .unwrap()
         };
         // Should be an allscorer

src/query/term_query/term_scorer.rs

@@ -119,6 +119,7 @@ impl DocSet for TermScorer {
 }
 
 impl Scorer for TermScorer {
+    #[inline]
     fn score(&mut self) -> Score {
         let fieldnorm_id = self.fieldnorm_id();
         let term_freq = self.term_freq();

src/query/term_query/term_weight.rs

@@ -34,19 +34,12 @@ impl TermOrEmptyOrAllScorer {
 }
 
 impl Weight for TermWeight {
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>> {
-        Ok(self
-            .specialized_scorer(reader, boost, seek_doc)?
-            .into_boxed_scorer())
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
+        Ok(self.specialized_scorer(reader, boost)?.into_boxed_scorer())
     }
 
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        match self.specialized_scorer(reader, 1.0, 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));
@@ -62,7 +55,7 @@ impl Weight for TermWeight {
 
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
         if let Some(alive_bitset) = reader.alive_bitset() {
-            Ok(self.scorer(reader, 1.0, 0)?.count(alive_bitset))
+            Ok(self.scorer(reader, 1.0)?.count(alive_bitset))
         } else {
             let field = self.term.field();
             let inv_index = reader.inverted_index(field)?;
@@ -78,7 +71,7 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
-        match self.specialized_scorer(reader, 1.0, 0u32)? {
+        match self.specialized_scorer(reader, 1.0)? {
             TermOrEmptyOrAllScorer::TermScorer(mut term_scorer) => {
                 for_each_scorer(&mut *term_scorer, callback);
             }
@@ -97,7 +90,7 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(&[DocId]),
     ) -> crate::Result<()> {
-        match self.specialized_scorer(reader, 1.0, 0u32)? {
+        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);
@@ -128,7 +121,7 @@ impl Weight for TermWeight {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score) -> Score,
     ) -> crate::Result<()> {
-        let specialized_scorer = self.specialized_scorer(reader, 1.0, 0u32)?;
+        let specialized_scorer = self.specialized_scorer(reader, 1.0)?;
         match specialized_scorer {
             TermOrEmptyOrAllScorer::TermScorer(term_scorer) => {
                 crate::query::boolean_query::block_wand_single_scorer(
@@ -146,12 +139,6 @@ impl Weight for TermWeight {
         }
         Ok(())
     }
-
-    /// Returns a priority number used to sort weights when running an
-    /// intersection.
-    fn intersection_priority(&self) -> u32 {
-        10u32
-    }
 }
 
 impl TermWeight {
@@ -182,7 +169,7 @@ impl TermWeight {
         reader: &SegmentReader,
         boost: Score,
     ) -> crate::Result<Option<TermScorer>> {
-        let scorer = self.specialized_scorer(reader, boost, 0u32)?;
+        let scorer = self.specialized_scorer(reader, boost)?;
         Ok(match scorer {
             TermOrEmptyOrAllScorer::TermScorer(scorer) => Some(*scorer),
             _ => None,
@@ -193,7 +180,6 @@ impl TermWeight {
         &self,
         reader: &SegmentReader,
         boost: Score,
-        seek_doc: DocId,
     ) -> crate::Result<TermOrEmptyOrAllScorer> {
         let field = self.term.field();
         let inverted_index = reader.inverted_index(field)?;
@@ -210,11 +196,8 @@ impl TermWeight {
             )));
         }
 
-        let segment_postings: SegmentPostings = inverted_index.read_postings_from_terminfo(
-            &term_info,
-            self.index_record_option,
-            seek_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);

src/query/union/buffered_union.rs

@@ -128,6 +128,7 @@ impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> BufferedUnionScorer<TScorer
         }
     }
 
+    #[inline]
     fn advance_buffered(&mut self) -> bool {
         while self.bucket_idx < HORIZON_NUM_TINYBITSETS {
             if let Some(val) = self.bitsets[self.bucket_idx].pop_lowest() {
@@ -156,6 +157,7 @@ where
     TScorer: Scorer,
     TScoreCombiner: ScoreCombiner,
 {
+    #[inline]
     fn advance(&mut self) -> DocId {
         if self.advance_buffered() {
             return self.doc;
@@ -245,6 +247,7 @@ where
         }
     }
 
+    #[inline]
     fn doc(&self) -> DocId {
         self.doc
     }
@@ -286,6 +289,7 @@ where
     TScoreCombiner: ScoreCombiner,
     TScorer: Scorer,
 {
+    #[inline]
     fn score(&mut self) -> Score {
         self.score
     }

src/query/weight.rs

@@ -68,28 +68,15 @@ pub trait Weight: Send + Sync + 'static {
     ///
     /// `boost` is a multiplier to apply to the score.
     ///
-    /// As an optimization, the scorer can be positioned on any document below `seek_doc`
-    /// matching the request.
-    /// If there are no such document, it should match the first document matching the request;
-    /// (or TERMINATED if no documents match).
-    ///
-    /// Entirely ignoring that parameter and positionning the Scorer on the first document
-    /// is always correct.
-    ///
     /// See [`Query`](crate::query::Query).
-    fn scorer(
-        &self,
-        reader: &SegmentReader,
-        boost: Score,
-        seek_doc: DocId,
-    ) -> crate::Result<Box<dyn Scorer>>;
+    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>>;
 
     /// Returns an [`Explanation`] for the given document.
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation>;
 
     /// Returns the number documents within the given [`SegmentReader`].
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         if let Some(alive_bitset) = reader.alive_bitset() {
             Ok(scorer.count(alive_bitset))
         } else {
@@ -104,7 +91,7 @@ pub trait Weight: Send + Sync + 'static {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         for_each_scorer(scorer.as_mut(), callback);
         Ok(())
     }
@@ -116,7 +103,7 @@ pub trait Weight: Send + Sync + 'static {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(&[DocId]),
     ) -> crate::Result<()> {
-        let mut docset = self.scorer(reader, 1.0, 0)?;
+        let mut docset = self.scorer(reader, 1.0)?;
 
         let mut buffer = [0u32; COLLECT_BLOCK_BUFFER_LEN];
         for_each_docset_buffered(&mut docset, &mut buffer, callback);
@@ -139,14 +126,8 @@ pub trait Weight: Send + Sync + 'static {
         reader: &SegmentReader,
         callback: &mut dyn FnMut(DocId, Score) -> Score,
     ) -> crate::Result<()> {
-        let mut scorer = self.scorer(reader, 1.0, 0)?;
+        let mut scorer = self.scorer(reader, 1.0)?;
         for_each_pruning_scorer(scorer.as_mut(), threshold, callback);
         Ok(())
     }
-
-    /// Returns a priority number used to sort weights when running an
-    /// intersection.
-    fn intersection_priority(&self) -> u32 {
-        20u32
-    }
 }

src/schema/document/owned_value.rs

@@ -58,6 +58,31 @@ impl AsRef<OwnedValue> for OwnedValue {
     }
 }
 
+impl OwnedValue {
+    /// Returns a u8 discriminant value for the `OwnedValue` variant.
+    ///
+    /// This can be used to sort `OwnedValue` instances by their type.
+    pub fn discriminant_value(&self) -> u8 {
+        match self {
+            OwnedValue::Null => 0,
+            OwnedValue::Str(_) => 1,
+            OwnedValue::PreTokStr(_) => 2,
+            // It is key to make sure U64, I64, F64 are grouped together in there, otherwise we
+            // might be breaking transivity.
+            OwnedValue::U64(_) => 3,
+            OwnedValue::I64(_) => 4,
+            OwnedValue::F64(_) => 5,
+            OwnedValue::Bool(_) => 6,
+            OwnedValue::Date(_) => 7,
+            OwnedValue::Facet(_) => 8,
+            OwnedValue::Bytes(_) => 9,
+            OwnedValue::Array(_) => 10,
+            OwnedValue::Object(_) => 11,
+            OwnedValue::IpAddr(_) => 12,
+        }
+    }
+}
+
 impl<'a> Value<'a> for &'a OwnedValue {
     type ArrayIter = std::slice::Iter<'a, OwnedValue>;
     type ObjectIter = ObjectMapIter<'a>;

src/schema/mod.rs

@@ -98,6 +98,10 @@
 //! make it possible to access the value given the doc id rapidly. This is useful if the value
 //! of the field is required during scoring or collection for instance.
 //!
+//! Some queries may leverage Fast fields when run on a field that is not indexed. This can be
+//! handy if that kind of request is infrequent, however note that searching on a Fast field is
+//! generally much slower than searching in an index.
+//!
 //! ```
 //! use tantivy::schema::*;
 //! let mut schema_builder = Schema::builder();

src/snippet/mod.rs

@@ -483,7 +483,7 @@ mod tests {
 
     use super::{collapse_overlapped_ranges, search_fragments, select_best_fragment_combination};
     use crate::query::QueryParser;
-    use crate::schema::{IndexRecordOption, Schema, TextFieldIndexing, TextOptions, TEXT};
+    use crate::schema::{Schema, TEXT};
     use crate::snippet::SnippetGenerator;
     use crate::tokenizer::{NgramTokenizer, SimpleTokenizer};
     use crate::Index;
@@ -727,8 +727,10 @@ Survey in 2016, 2017, and 2018."#;
         Ok(())
     }
 
+    #[cfg(feature = "stemmer")]
     #[test]
     fn test_snippet_generator() -> crate::Result<()> {
+        use crate::schema::{IndexRecordOption, TextFieldIndexing, TextOptions};
         let mut schema_builder = Schema::builder();
         let text_options = TextOptions::default().set_indexing_options(
             TextFieldIndexing::default()

src/store/mod.rs

@@ -102,6 +102,7 @@ pub(crate) mod tests {
     }
 
     const NUM_DOCS: usize = 1_000;
+
     #[test]
     fn test_doc_store_iter_with_delete_bug_1077() -> crate::Result<()> {
         // this will cover deletion of the first element in a checkpoint
@@ -113,7 +114,7 @@ pub(crate) mod tests {
         let directory = RamDirectory::create();
         let store_wrt = directory.open_write(path)?;
         let schema =
-            write_lorem_ipsum_store(store_wrt, NUM_DOCS, Compressor::Lz4, BLOCK_SIZE, true);
+            write_lorem_ipsum_store(store_wrt, NUM_DOCS, Compressor::default(), BLOCK_SIZE, true);
         let field_title = schema.get_field("title").unwrap();
         let store_file = directory.open_read(path)?;
         let store = StoreReader::open(store_file, 10)?;

src/store/reader.rs

@@ -465,7 +465,7 @@ mod tests {
         let directory = RamDirectory::create();
         let path = Path::new("store");
         let writer = directory.open_write(path)?;
-        let schema = write_lorem_ipsum_store(writer, 500, Compressor::default(), BLOCK_SIZE, true);
+        let schema = write_lorem_ipsum_store(writer, 500, Compressor::None, BLOCK_SIZE, true);
         let title = schema.get_field("title").unwrap();
         let store_file = directory.open_read(path)?;
         let store = StoreReader::open(store_file, DOCSTORE_CACHE_CAPACITY)?;
@@ -499,7 +499,7 @@ mod tests {
         assert_eq!(store.cache_stats().cache_hits, 1);
         assert_eq!(store.cache_stats().cache_misses, 2);
 
-        assert_eq!(store.cache.peek_lru(), Some(11207));
+        assert_eq!(store.cache.peek_lru(), Some(232206));
 
         Ok(())
     }

src/tokenizer/mod.rs

@@ -132,13 +132,14 @@ mod regex_tokenizer;
 mod remove_long;
 mod simple_tokenizer;
 mod split_compound_words;
-mod stemmer;
 mod stop_word_filter;
 mod tokenized_string;
 mod tokenizer;
 mod tokenizer_manager;
 mod whitespace_tokenizer;
 
+#[cfg(feature = "stemmer")]
+mod stemmer;
 pub use tokenizer_api::{BoxTokenStream, Token, TokenFilter, TokenStream, Tokenizer};
 
 pub use self::alphanum_only::AlphaNumOnlyFilter;
@@ -151,6 +152,7 @@ pub use self::regex_tokenizer::RegexTokenizer;
 pub use self::remove_long::RemoveLongFilter;
 pub use self::simple_tokenizer::{SimpleTokenStream, SimpleTokenizer};
 pub use self::split_compound_words::SplitCompoundWords;
+#[cfg(feature = "stemmer")]
 pub use self::stemmer::{Language, Stemmer};
 pub use self::stop_word_filter::StopWordFilter;
 pub use self::tokenized_string::{PreTokenizedStream, PreTokenizedString};
@@ -167,10 +169,7 @@ pub const MAX_TOKEN_LEN: usize = u16::MAX as usize - 5;
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use super::{
-        Language, LowerCaser, RemoveLongFilter, SimpleTokenizer, Stemmer, Token, TokenizerManager,
-    };
-    use crate::tokenizer::TextAnalyzer;
+    use super::{Token, TokenizerManager};
 
     /// This is a function that can be used in tests and doc tests
     /// to assert a token's correctness.
@@ -205,59 +204,15 @@ pub(crate) mod tests {
     }
 
     #[test]
-    fn test_en_tokenizer() {
+    fn test_tokenizer_does_not_exist() {
         let tokenizer_manager = TokenizerManager::default();
         assert!(tokenizer_manager.get("en_doesnotexist").is_none());
-        let mut en_tokenizer = tokenizer_manager.get("en_stem").unwrap();
-        let mut tokens: Vec<Token> = vec![];
-        {
-            let mut add_token = |token: &Token| {
-                tokens.push(token.clone());
-            };
-            en_tokenizer
-                .token_stream("Hello, happy tax payer!")
-                .process(&mut add_token);
-        }
-
-        assert_eq!(tokens.len(), 4);
-        assert_token(&tokens[0], 0, "hello", 0, 5);
-        assert_token(&tokens[1], 1, "happi", 7, 12);
-        assert_token(&tokens[2], 2, "tax", 13, 16);
-        assert_token(&tokens[3], 3, "payer", 17, 22);
-    }
-
-    #[test]
-    fn test_non_en_tokenizer() {
-        let tokenizer_manager = TokenizerManager::default();
-        tokenizer_manager.register(
-            "el_stem",
-            TextAnalyzer::builder(SimpleTokenizer::default())
-                .filter(RemoveLongFilter::limit(40))
-                .filter(LowerCaser)
-                .filter(Stemmer::new(Language::Greek))
-                .build(),
-        );
-        let mut en_tokenizer = tokenizer_manager.get("el_stem").unwrap();
-        let mut tokens: Vec<Token> = vec![];
-        {
-            let mut add_token = |token: &Token| {
-                tokens.push(token.clone());
-            };
-            en_tokenizer
-                .token_stream("Καλημέρα, χαρούμενε φορολογούμενε!")
-                .process(&mut add_token);
-        }
-
-        assert_eq!(tokens.len(), 3);
-        assert_token(&tokens[0], 0, "καλημερ", 0, 16);
-        assert_token(&tokens[1], 1, "χαρουμεν", 18, 36);
-        assert_token(&tokens[2], 2, "φορολογουμεν", 37, 63);
     }
 
     #[test]
     fn test_tokenizer_empty() {
         let tokenizer_manager = TokenizerManager::default();
-        let mut en_tokenizer = tokenizer_manager.get("en_stem").unwrap();
+        let mut en_tokenizer = tokenizer_manager.get("default").unwrap();
         {
             let mut tokens: Vec<Token> = vec![];
             {

src/tokenizer/stemmer.rs

@@ -142,3 +142,60 @@ impl<T: TokenStream> TokenStream for StemmerTokenStream<T> {
         self.tail.token_mut()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use tokenizer_api::Token;
+
+    use super::*;
+    use crate::tokenizer::tests::assert_token;
+    use crate::tokenizer::{LowerCaser, SimpleTokenizer, TextAnalyzer, TokenizerManager};
+
+    #[test]
+    fn test_en_stem() {
+        let tokenizer_manager = TokenizerManager::default();
+        let mut en_tokenizer = tokenizer_manager.get("en_stem").unwrap();
+        let mut tokens: Vec<Token> = vec![];
+        {
+            let mut add_token = |token: &Token| {
+                tokens.push(token.clone());
+            };
+            en_tokenizer
+                .token_stream("Dogs are the bests!")
+                .process(&mut add_token);
+        }
+
+        assert_eq!(tokens.len(), 4);
+        assert_token(&tokens[0], 0, "dog", 0, 4);
+        assert_token(&tokens[1], 1, "are", 5, 8);
+        assert_token(&tokens[2], 2, "the", 9, 12);
+        assert_token(&tokens[3], 3, "best", 13, 18);
+    }
+
+    #[test]
+    fn test_non_en_stem() {
+        let tokenizer_manager = TokenizerManager::default();
+        tokenizer_manager.register(
+            "el_stem",
+            TextAnalyzer::builder(SimpleTokenizer::default())
+                .filter(LowerCaser)
+                .filter(Stemmer::new(Language::Greek))
+                .build(),
+        );
+        let mut el_tokenizer = tokenizer_manager.get("el_stem").unwrap();
+        let mut tokens: Vec<Token> = vec![];
+        {
+            let mut add_token = |token: &Token| {
+                tokens.push(token.clone());
+            };
+            el_tokenizer
+                .token_stream("Καλημέρα, χαρούμενε φορολογούμενε!")
+                .process(&mut add_token);
+        }
+
+        assert_eq!(tokens.len(), 3);
+        assert_token(&tokens[0], 0, "καλημερ", 0, 16);
+        assert_token(&tokens[1], 1, "χαρουμεν", 18, 36);
+        assert_token(&tokens[2], 2, "φορολογουμεν", 37, 63);
+    }
+}

src/tokenizer/tokenizer_manager.rs

@@ -1,10 +1,9 @@
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 
-use crate::tokenizer::stemmer::Language;
 use crate::tokenizer::tokenizer::TextAnalyzer;
 use crate::tokenizer::{
-    LowerCaser, RawTokenizer, RemoveLongFilter, SimpleTokenizer, Stemmer, WhitespaceTokenizer,
+    LowerCaser, RawTokenizer, RemoveLongFilter, SimpleTokenizer, WhitespaceTokenizer,
 };
 
 /// The tokenizer manager serves as a store for
@@ -64,14 +63,18 @@ impl Default for TokenizerManager {
                 .filter(LowerCaser)
                 .build(),
         );
-        manager.register(
-            "en_stem",
-            TextAnalyzer::builder(SimpleTokenizer::default())
-                .filter(RemoveLongFilter::limit(40))
-                .filter(LowerCaser)
-                .filter(Stemmer::new(Language::English))
-                .build(),
-        );
+        #[cfg(feature = "stemmer")]
+        {
+            use crate::tokenizer::stemmer::{Language, Stemmer};
+            manager.register(
+                "en_stem",
+                TextAnalyzer::builder(SimpleTokenizer::default())
+                    .filter(RemoveLongFilter::limit(40))
+                    .filter(LowerCaser) // The stemmer does not lowercase
+                    .filter(Stemmer::new(Language::English))
+                    .build(),
+            );
+        }
         manager.register("whitespace", WhitespaceTokenizer::default());
         manager
     }