Support for columnar

Cargo.toml

@@ -15,7 +15,7 @@ rust-version = "1.62"
 
 [dependencies]
 oneshot = "0.1.5"
-base64 = "0.21.0"
+base64 = "0.20.0"
 byteorder = "1.4.3"
 crc32fast = "1.3.2"
 once_cell = "1.10.0"
@@ -36,6 +36,7 @@ fs2 = { version = "0.4.3", optional = true }
 levenshtein_automata = "0.2.1"
 uuid = { version = "1.0.0", features = ["v4", "serde"] }
 crossbeam-channel = "0.5.4"
+stable_deref_trait = "1.2.0"
 rust-stemmers = "1.2.0"
 downcast-rs = "1.2.0"
 bitpacking = { version = "0.8.4", default-features = false, features = ["bitpacker4x"] }
@@ -48,7 +49,7 @@ murmurhash32 = "0.2.0"
 time = { version = "0.3.10", features = ["serde-well-known"] }
 smallvec = "1.8.0"
 rayon = "1.5.2"
-lru = "0.9.0"
+lru = "0.7.5"
 fastdivide = "0.4.0"
 itertools = "0.10.3"
 measure_time = "0.8.2"
@@ -61,7 +62,7 @@ tantivy-query-grammar = { version= "0.19.0", path="./query-grammar" }
 tantivy-bitpacker = 		{ version= "0.3", path="./bitpacker" }
 common = 								{ version= "0.5", path = "./common/", package = "tantivy-common" }
 fastfield_codecs = 			{ version= "0.3", path="./fastfield_codecs", default-features = false }
-tokenizer-api = { version="0.1", path="./tokenizer-api", package="tantivy-tokenizer-api" }
+ownedbytes = 						{ version= "0.5", path="./ownedbytes" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"
@@ -107,7 +108,7 @@ unstable = [] # useful for benches.
 quickwit = ["sstable"]
 
 [workspace]
-members = ["query-grammar", "bitpacker", "common", "fastfield_codecs", "ownedbytes", "stacker", "sstable", "columnar", "tokenizer-api"]
+members = ["query-grammar", "bitpacker", "common", "fastfield_codecs", "ownedbytes", "stacker", "sstable", "columnar"]
 
 # Following the "fail" crate best practises, we isolate
 # tests that define specific behavior in fail check points

README.md

@@ -29,7 +29,7 @@ Your mileage WILL vary depending on the nature of queries and their load.
 # Features
 
 - Full-text search
-- Configurable tokenizer (stemming available for 17 Latin languages) with third party support for Chinese ([tantivy-jieba](https://crates.io/crates/tantivy-jieba) and [cang-jie](https://crates.io/crates/cang-jie)), Japanese ([lindera](https://github.com/lindera-morphology/lindera-tantivy), [Vaporetto](https://crates.io/crates/vaporetto_tantivy), and [tantivy-tokenizer-tiny-segmenter](https://crates.io/crates/tantivy-tokenizer-tiny-segmenter)) and Korean ([lindera](https://github.com/lindera-morphology/lindera-tantivy) + [lindera-ko-dic-builder](https://github.com/lindera-morphology/lindera-ko-dic-builder))
+- Configurable tokenizer (stemming available for 17 Latin languages with third party support for Chinese ([tantivy-jieba](https://crates.io/crates/tantivy-jieba) and [cang-jie](https://crates.io/crates/cang-jie)), Japanese ([lindera](https://github.com/lindera-morphology/lindera-tantivy), [Vaporetto](https://crates.io/crates/vaporetto_tantivy), and [tantivy-tokenizer-tiny-segmenter](https://crates.io/crates/tantivy-tokenizer-tiny-segmenter)) and Korean ([lindera](https://github.com/lindera-morphology/lindera-tantivy) + [lindera-ko-dic-builder](https://github.com/lindera-morphology/lindera-ko-dic-builder))
 - Fast (check out the :racehorse: :sparkles: [benchmark](https://tantivy-search.github.io/bench/) :sparkles: :racehorse:)
 - Tiny startup time (<10ms), perfect for command-line tools
 - BM25 scoring (the same as Lucene)
@@ -42,12 +42,12 @@ Your mileage WILL vary depending on the nature of queries and their load.
 - Single valued and multivalued u64, i64, and f64 fast fields (equivalent of doc values in Lucene)
 - `&[u8]` fast fields
 - Text, i64, u64, f64, dates, and hierarchical facet fields
-- Compressed document store (LZ4, Zstd, None, Brotli, Snap)
+- LZ4 compressed document store
 - Range queries
 - Faceted search
 - Configurable indexing (optional term frequency and position indexing)
 - JSON Field
-- Aggregation Collector: histogram, range buckets, average, and stats metrics
+- Aggregation Collector: range buckets, average, and stats metrics
 - LogMergePolicy with deletes
 - Searcher Warmer API
 - Cheesy logo with a horse
@@ -81,10 +81,6 @@ There are many ways to support this project.
 
 We use the GitHub Pull Request workflow: reference a GitHub ticket and/or include a comprehensive commit message when opening a PR.
 
-## Tokenizer
-
-When implementing a tokenizer for tantivy depend on the `tantivy-tokenizer-api` crate.
-
 ## Minimum supported Rust version
 
 Tantivy currently requires at least Rust 1.62 or later to compile.

bitpacker/src/bitpacker.rs

@@ -91,15 +91,17 @@ impl BitUnpacker {
             return 0u64;
         }
         let addr_in_bits = idx * self.num_bits as u32;
-        let addr = (addr_in_bits >> 3) as usize;
+        let addr = addr_in_bits >> 3;
         let bit_shift = addr_in_bits & 7;
         debug_assert!(
-            addr + 8 <= data.len(),
+            addr + 8 <= data.len() as u32,
             "The fast field field should have been padded with 7 bytes."
         );
-        let bytes: [u8; 8] = (&data[addr..addr + 8]).try_into().unwrap();
+        let bytes: [u8; 8] = (&data[(addr as usize)..(addr as usize) + 8])
+            .try_into()
+            .unwrap();
         let val_unshifted_unmasked: u64 = u64::from_le_bytes(bytes);
-        let val_shifted = val_unshifted_unmasked >> bit_shift;
+        let val_shifted: u64 = val_unshifted_unmasked >> bit_shift;
         val_shifted & self.mask
     }
 }

bitpacker/src/lib.rs

@@ -1,8 +1,6 @@
 mod bitpacker;
 mod blocked_bitpacker;
 
-use std::cmp::Ordering;
-
 pub use crate::bitpacker::{BitPacker, BitUnpacker};
 pub use crate::blocked_bitpacker::BlockedBitpacker;
 
@@ -39,104 +37,44 @@ pub fn compute_num_bits(n: u64) -> u8 {
     }
 }
 
-/// Computes the (min, max) of an iterator of `PartialOrd` values.
-///
-/// For values implementing `Ord` (in a way consistent to their `PartialOrd` impl),
-/// this function behaves as expected.
-///
-/// For values with partial ordering, the behavior is non-trivial and may
-/// depends on the order of the values.
-/// For floats however, it simply returns the same results as if NaN were
-/// skipped.
 pub fn minmax<I, T>(mut vals: I) -> Option<(T, T)>
 where
     I: Iterator<Item = T>,
-    T: Copy + PartialOrd,
+    T: Copy + Ord,
 {
-    let first_el = vals.find(|val| {
+    if let Some(first_el) = vals.next() {
-        // We use this to make sure we skip all NaN values when
+        return Some(vals.fold((first_el, first_el), |(min_val, max_val), el| {
-        // working with a float type.
+            (min_val.min(el), max_val.max(el))
-        val.partial_cmp(val) == Some(Ordering::Equal)
+        }));
-    })?;
-    let mut min_so_far: T = first_el;
-    let mut max_so_far: T = first_el;
-    for val in vals {
-        if val.partial_cmp(&min_so_far) == Some(Ordering::Less) {
-            min_so_far = val;
-        }
-        if val.partial_cmp(&max_so_far) == Some(Ordering::Greater) {
-            max_so_far = val;
-        }
     }
-    Some((min_so_far, max_so_far))
+    None
 }
 
-#[cfg(test)]
+#[test]
-mod tests {
+fn test_compute_num_bits() {
-    use super::*;
+    assert_eq!(compute_num_bits(1), 1u8);
-
+    assert_eq!(compute_num_bits(0), 0u8);
-    #[test]
+    assert_eq!(compute_num_bits(2), 2u8);
-    fn test_compute_num_bits() {
+    assert_eq!(compute_num_bits(3), 2u8);
-        assert_eq!(compute_num_bits(1), 1u8);
+    assert_eq!(compute_num_bits(4), 3u8);
-        assert_eq!(compute_num_bits(0), 0u8);
+    assert_eq!(compute_num_bits(255), 8u8);
-        assert_eq!(compute_num_bits(2), 2u8);
+    assert_eq!(compute_num_bits(256), 9u8);
-        assert_eq!(compute_num_bits(3), 2u8);
+    assert_eq!(compute_num_bits(5_000_000_000), 33u8);
-        assert_eq!(compute_num_bits(4), 3u8);
+}
-        assert_eq!(compute_num_bits(255), 8u8);
+
-        assert_eq!(compute_num_bits(256), 9u8);
+#[test]
-        assert_eq!(compute_num_bits(5_000_000_000), 33u8);
+fn test_minmax_empty() {
-    }
+    let vals: Vec<u32> = vec![];
-
+    assert_eq!(minmax(vals.into_iter()), None);
-    #[test]
+}
-    fn test_minmax_empty() {
+
-        let vals: Vec<u32> = vec![];
+#[test]
-        assert_eq!(minmax(vals.into_iter()), None);
+fn test_minmax_one() {
-    }
+    assert_eq!(minmax(vec![1].into_iter()), Some((1, 1)));
-
+}
-    #[test]
+
-    fn test_minmax_one() {
+#[test]
-        assert_eq!(minmax(vec![1].into_iter()), Some((1, 1)));
+fn test_minmax_two() {
-    }
+    assert_eq!(minmax(vec![1, 2].into_iter()), Some((1, 2)));
-
+    assert_eq!(minmax(vec![2, 1].into_iter()), Some((1, 2)));
-    #[test]
-    fn test_minmax_two() {
-        assert_eq!(minmax(vec![1, 2].into_iter()), Some((1, 2)));
-        assert_eq!(minmax(vec![2, 1].into_iter()), Some((1, 2)));
-    }
-
-    #[test]
-    fn test_minmax_nan() {
-        assert_eq!(
-            minmax(vec![f64::NAN, 1f64, 2f64].into_iter()),
-            Some((1f64, 2f64))
-        );
-        assert_eq!(
-            minmax(vec![2f64, f64::NAN, 1f64].into_iter()),
-            Some((1f64, 2f64))
-        );
-        assert_eq!(
-            minmax(vec![2f64, 1f64, f64::NAN].into_iter()),
-            Some((1f64, 2f64))
-        );
-    }
-
-    #[test]
-    fn test_minmax_inf() {
-        assert_eq!(
-            minmax(vec![f64::INFINITY, 1f64, 2f64].into_iter()),
-            Some((1f64, f64::INFINITY))
-        );
-        assert_eq!(
-            minmax(vec![-f64::INFINITY, 1f64, 2f64].into_iter()),
-            Some((-f64::INFINITY, 2f64))
-        );
-        assert_eq!(
-            minmax(vec![2f64, f64::INFINITY, 1f64].into_iter()),
-            Some((1f64, f64::INFINITY))
-        );
-        assert_eq!(
-            minmax(vec![2f64, 1f64, -f64::INFINITY].into_iter()),
-            Some((-f64::INFINITY, 2f64))
-        );
-    }
 }

columnar/Cargo.toml

@@ -2,17 +2,25 @@
 name = "tantivy-columnar"
 version = "0.1.0"
 edition = "2021"
-license = "MIT"
 
 [dependencies]
 stacker = { path = "../stacker", package="tantivy-stacker"}
 serde_json = "1"
 thiserror = "1"
 fnv = "1"
+tantivy-fst =  "0.4.0"
 sstable = { path = "../sstable", package = "tantivy-sstable" }
 common = { path = "../common", package = "tantivy-common" }
 fastfield_codecs = { path = "../fastfield_codecs"}
+ordered-float = "3.4"
 itertools = "0.10"
 
+[features]
+# default = ["quickwit"]
+# quickwit = ["common/quickwit"]
+
+
+
+
 [dev-dependencies]
 proptest = "1"

columnar/README.md

@@ -2,6 +2,7 @@
 
 This crate describes columnar format used in tantivy.
 
+
 ## Goals
 
 This format is special in the following way.
@@ -14,50 +15,15 @@ we need to be able to load columns rapidly.
 and different cardinality `(required, optional, multivalued)`.
 - columns, once loaded, offer cheap random access.
 
-# Coercion rules
+# Format
 
-Users can create a columnar by inserting rows to a `ColumnarWriter`,
+A quickwit/tantivy style sstable associated
-and serializing it into a `Write` object.
+`(column names, column_cardinality, column_type) to range of bytes.
-Nothing prevents a user from recording values with different type to the same `column_name`.
 
-In that case, `tantivy-columnar`'s behavior is as follows:
+The format of the key is:
-- JsonValues are grouped into 3 types (String, Number, bool).
-Values that corresponds to different groups are mapped to different columns. For instance, String values are treated independently
-from Number or boolean values. `tantivy-columnar` will simply emit several columns associated to a given column_name.
-- Only one column for a given json value type is emitted.  If number values with different number types are recorded (e.g. u64, i64, f64),
-`tantivy-columnar` will pick the first type that can represents the set of appended value, with the following prioriy order (`i64`, `u64`, `f64`).
-`i64` is picked over `u64` as it is likely to  yield less change of types. Most use cases strictly requiring `u64` show the
-restriction on 50% of the values (e.g. a 64-bit hash). On the other hand, a lot of use cases can show rare negative value.
-
-# Columnar format
-
-This columnar format may have more than one column (with different types) associated to the same `column_name` (see [Coercion rules](#coercion-rules) above).
-The `(column_name, columne_type)` couple however uniquely identifies a column.
-That couple is serialized as a column `column_key`.  The format of that key is:
 `[column_name][ZERO_BYTE][column_type_header: u8]`
 
-```
+Column name may not contain the zero byte.
-COLUMNAR:=
-    [COLUMNAR_DATA]
-    [COLUMNAR_KEY_TO_DATA_INDEX]
-    [COLUMNAR_FOOTER];
-
-
-# Columns are sorted by their column key.
-COLUMNAR_DATA:=
-    [COLUMN_DATA]+;
-
-COLUMNAR_FOOTER := [RANGE_SSTABLE_BYTES_LEN: 8 bytes little endian]
-
-```
-
-The columnar file starts by the actual column data, concatenated one after the other,
-sorted by column key.
-
-A sstable associates
-`(column name, column_cardinality, column_type) to range of bytes.
-
-Column name may not contain the zero byte `\0`.
 
 Listing all columns associated to `column_name` can therefore
 be done by listing all keys prefixed by

columnar/src/column_type_header.rs

@@ -1,154 +1,107 @@
-use crate::utils::{place_bits, select_bits};
 use crate::value::NumericalType;
-use crate::InvalidData;
 
-/// Enum describing the number of values that can exist per document
-/// (or per row if you will).
-///
-/// The cardinality must fit on 2 bits.
 #[derive(Clone, Copy, Hash, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum Cardinality {
-    /// All documents contain exactly one value.
-    /// Required is the default for auto-detecting the Cardinality, since it is the most strict.
     #[default]
     Required = 0,
-    /// All documents contain at most one value.
     Optional = 1,
-    /// All documents may contain any number of values.
     Multivalued = 2,
 }
 
 impl Cardinality {
-    pub(crate) fn to_code(self) -> u8 {
-        self as u8
-    }
-
-    pub(crate) fn try_from_code(code: u8) -> Result<Cardinality, InvalidData> {
-        match code {
-            0 => Ok(Cardinality::Required),
-            1 => Ok(Cardinality::Optional),
-            2 => Ok(Cardinality::Multivalued),
-            _ => Err(InvalidData),
-        }
-    }
-}
-
-/// The column type represents the column type and can fit on 6-bits.
-///
-/// - bits[0..3]: Column category type.
-/// - bits[3..6]: Numerical type if necessary.
-#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
-pub enum ColumnType {
-    Bytes,
-    Numerical(NumericalType),
-    Bool,
-}
-
-impl ColumnType {
-    /// Encoded over 6 bits.
-    pub(crate) fn to_code(self) -> u8 {
-        let column_type_category;
-        let numerical_type_code: u8;
-        match self {
-            ColumnType::Bytes => {
-                column_type_category = ColumnTypeCategory::Str;
-                numerical_type_code = 0u8;
-            }
-            ColumnType::Numerical(numerical_type) => {
-                column_type_category = ColumnTypeCategory::Numerical;
-                numerical_type_code = numerical_type.to_code();
-            }
-            ColumnType::Bool => {
-                column_type_category = ColumnTypeCategory::Bool;
-                numerical_type_code = 0u8;
-            }
-        }
-        place_bits::<0, 3>(column_type_category.to_code()) | place_bits::<3, 6>(numerical_type_code)
-    }
-
-    pub(crate) fn try_from_code(code: u8) -> Result<ColumnType, InvalidData> {
-        if select_bits::<6, 8>(code) != 0u8 {
-            return Err(InvalidData);
-        }
-        let column_type_category_code = select_bits::<0, 3>(code);
-        let numerical_type_code = select_bits::<3, 6>(code);
-        let column_type_category = ColumnTypeCategory::try_from_code(column_type_category_code)?;
-        match column_type_category {
-            ColumnTypeCategory::Bool => {
-                if numerical_type_code != 0u8 {
-                    return Err(InvalidData);
-                }
-                Ok(ColumnType::Bool)
-            }
-            ColumnTypeCategory::Str => {
-                if numerical_type_code != 0u8 {
-                    return Err(InvalidData);
-                }
-                Ok(ColumnType::Bytes)
-            }
-            ColumnTypeCategory::Numerical => {
-                let numerical_type = NumericalType::try_from_code(numerical_type_code)?;
-                Ok(ColumnType::Numerical(numerical_type))
-            }
-        }
-    }
-}
-
-/// Column types are grouped into different categories that
-/// corresponds to the different types of `JsonValue` types.
-///
-/// The columnar writer will apply coercion rules to make sure that
-/// at most one column exist per `ColumnTypeCategory`.
-///
-/// See also [README.md].
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
-#[repr(u8)]
-pub(crate) enum ColumnTypeCategory {
-    Bool = 0u8,
-    Str = 1u8,
-    Numerical = 2u8,
-}
-
-impl ColumnTypeCategory {
     pub fn to_code(self) -> u8 {
         self as u8
     }
 
-    pub fn try_from_code(code: u8) -> Result<Self, InvalidData> {
+    pub fn try_from_code(code: u8) -> Option<Cardinality> {
         match code {
-            0u8 => Ok(Self::Bool),
+            0 => Some(Cardinality::Required),
-            1u8 => Ok(Self::Str),
+            1 => Some(Cardinality::Optional),
-            2u8 => Ok(Self::Numerical),
+            2 => Some(Cardinality::Multivalued),
-            _ => Err(InvalidData),
+            _ => None,
         }
     }
 }
 
+#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
+pub enum ColumnType {
+    Bytes,
+    Numerical(NumericalType),
+}
+
+impl ColumnType {
+    pub fn to_code(self) -> u8 {
+        match self {
+            ColumnType::Bytes => 0u8,
+            ColumnType::Numerical(numerical_type) => 1u8 | (numerical_type.to_code() << 1),
+        }
+    }
+
+    pub fn try_from_code(code: u8) -> Option<ColumnType> {
+        if code == 0u8 {
+            return Some(ColumnType::Bytes);
+        }
+        if code & 1u8 == 0u8 {
+            return None;
+        }
+        let numerical_type = NumericalType::try_from_code(code >> 1)?;
+        Some(ColumnType::Numerical(numerical_type))
+    }
+}
+
 /// Represents the type and cardinality of a column.
 /// This is encoded over one-byte and added to a column key in the
 /// columnar sstable.
 ///
-/// - [0..6] bits: encodes the column type
+/// Cardinality is encoded as the first two highest two bits.
-/// - [6..8] bits: encodes the cardinality
+/// The low 6 bits encode the column type.
 #[derive(Eq, Hash, PartialEq, Debug, Copy, Clone)]
 pub struct ColumnTypeAndCardinality {
-    pub typ: ColumnType,
     pub cardinality: Cardinality,
+    pub typ: ColumnType,
+}
+
+#[inline]
+const fn compute_mask(num_bits: u8) -> u8 {
+    if num_bits == 8 {
+        u8::MAX
+    } else {
+        (1u8 << num_bits) - 1
+    }
+}
+
+#[inline]
+fn select_bits<const START: u8, const END: u8>(code: u8) -> u8 {
+    assert!(START <= END);
+    assert!(END <= 8);
+    let num_bits: u8 = END - START;
+    let mask: u8 = compute_mask(num_bits);
+    (code >> START) & mask
+}
+
+#[inline]
+fn place_bits<const START: u8, const END: u8>(code: u8) -> u8 {
+    assert!(START <= END);
+    assert!(END <= 8);
+    let num_bits: u8 = END - START;
+    let mask: u8 = compute_mask(num_bits);
+    assert!(code <= mask);
+    code << START
 }
 
 impl ColumnTypeAndCardinality {
     pub fn to_code(self) -> u8 {
-        place_bits::<0, 6>(self.typ.to_code()) | place_bits::<6, 8>(self.cardinality.to_code())
+        place_bits::<6, 8>(self.cardinality.to_code()) | place_bits::<0, 6>(self.typ.to_code())
     }
 
-    pub fn try_from_code(code: u8) -> Result<ColumnTypeAndCardinality, InvalidData> {
+    pub fn try_from_code(code: u8) -> Option<ColumnTypeAndCardinality> {
         let typ_code = select_bits::<0, 6>(code);
         let cardinality_code = select_bits::<6, 8>(code);
         let cardinality = Cardinality::try_from_code(cardinality_code)?;
         let typ = ColumnType::try_from_code(typ_code)?;
         assert_eq!(typ.to_code(), typ_code);
-        Ok(ColumnTypeAndCardinality { cardinality, typ })
+        Some(ColumnTypeAndCardinality { cardinality, typ })
     }
 }
 
@@ -163,15 +116,14 @@ mod tests {
     fn test_column_type_header_to_code() {
         let mut column_type_header_set: HashSet<ColumnTypeAndCardinality> = HashSet::new();
         for code in u8::MIN..=u8::MAX {
-            if let Ok(column_type_header) = ColumnTypeAndCardinality::try_from_code(code) {
+            if let Some(column_type_header) = ColumnTypeAndCardinality::try_from_code(code) {
                 assert_eq!(column_type_header.to_code(), code);
                 assert!(column_type_header_set.insert(column_type_header));
             }
         }
         assert_eq!(
             column_type_header_set.len(),
-            3 /* cardinality */ *
+            3 /* cardinality */ * (1 + 3) // column_types
-            (1 + 1 + 3) // column_types (str, bool, numerical x 3)
         );
     }
 
@@ -179,19 +131,20 @@ mod tests {
     fn test_column_type_to_code() {
         let mut column_type_set: HashSet<ColumnType> = HashSet::new();
         for code in u8::MIN..=u8::MAX {
-            if let Ok(column_type) = ColumnType::try_from_code(code) {
+            if let Some(column_type) = ColumnType::try_from_code(code) {
                 assert_eq!(column_type.to_code(), code);
                 assert!(column_type_set.insert(column_type));
             }
         }
-        assert_eq!(column_type_set.len(), 2 + 3);
+        assert_eq!(column_type_set.len(), 1 + 3);
     }
 
     #[test]
     fn test_cardinality_to_code() {
         let mut num_cardinality = 0;
         for code in u8::MIN..=u8::MAX {
-            if let Ok(cardinality) = Cardinality::try_from_code(code) {
+            let cardinality_opt = Cardinality::try_from_code(code);
+            if let Some(cardinality) = cardinality_opt {
                 assert_eq!(cardinality.to_code(), code);
                 num_cardinality += 1;
             }

columnar/src/dictionary.rs

@@ -1,27 +1,16 @@
 use std::io;
 
 use fnv::FnvHashMap;
-use sstable::SSTable;
 
-pub(crate) struct TermIdMapping {
+fn fst_err_into_io_err(fst_err: tantivy_fst::Error) -> io::Error {
-    unordered_to_ord: Vec<OrderedId>,
+    match fst_err {
-}
+        tantivy_fst::Error::Fst(fst_err) => {
-
+            io::Error::new(io::ErrorKind::Other, format!("FST Error: {:?}", fst_err))
-impl TermIdMapping {
+        }
-    pub fn to_ord(&self, unordered: UnorderedId) -> OrderedId {
+        tantivy_fst::Error::Io(io_err) => io_err,
-        self.unordered_to_ord[unordered.0 as usize]
     }
 }
 
-/// When we add values, we cannot know their ordered id yet.
-/// For this reason, we temporarily assign them a `UnorderedId`
-/// that will be mapped to an `OrderedId` upon serialization.
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub struct UnorderedId(pub u32);
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
-pub struct OrderedId(pub u32);
-
 /// `DictionaryBuilder` for dictionary encoding.
 ///
 /// It stores the different terms encounterred and assigns them a temporary value
@@ -30,10 +19,20 @@ pub struct OrderedId(pub u32);
 /// Upon serialization, we will sort the ids and hence build a `UnorderedId -> Term ordinal`
 /// mapping.
 #[derive(Default)]
-pub(crate) struct DictionaryBuilder {
+pub struct DictionaryBuilder {
     dict: FnvHashMap<Vec<u8>, UnorderedId>,
 }
 
+pub struct IdMapping {
+    unordered_to_ord: Vec<OrderedId>,
+}
+
+impl IdMapping {
+    pub fn to_ord(&self, unordered: UnorderedId) -> OrderedId {
+        self.unordered_to_ord[unordered.0 as usize]
+    }
+}
+
 impl DictionaryBuilder {
     /// Get or allocate an unordered id.
     /// (This ID is simply an auto-incremented id.)
@@ -48,37 +47,32 @@ impl DictionaryBuilder {
 
     /// Serialize the dictionary into an fst, and returns the
     /// `UnorderedId -> TermOrdinal` map.
-    pub fn serialize<'a, W: io::Write + 'a>(&self, wrt: &mut W) -> io::Result<TermIdMapping> {
+    pub fn serialize<'a, W: io::Write + 'a>(&self, wrt: &mut W) -> io::Result<IdMapping> {
-        let mut terms: Vec<(&[u8], UnorderedId)> =
+        serialize_inner(&self.dict, wrt).map_err(fst_err_into_io_err)
-            self.dict.iter().map(|(k, v)| (k.as_slice(), *v)).collect();
-        terms.sort_unstable_by_key(|(key, _)| *key);
-        // TODO Remove the allocation.
-        let mut unordered_to_ord: Vec<OrderedId> = vec![OrderedId(0u32); terms.len()];
-        let mut sstable_builder = sstable::VoidSSTable::writer(wrt);
-        for (ord, (key, unordered_id)) in terms.into_iter().enumerate() {
-            let ordered_id = OrderedId(ord as u32);
-            sstable_builder.insert(key, &())?;
-            unordered_to_ord[unordered_id.0 as usize] = ordered_id;
-        }
-        sstable_builder.finish()?;
-        Ok(TermIdMapping { unordered_to_ord })
     }
 }
 
-#[cfg(test)]
+/// Helper function just there for error conversion.
-mod tests {
+fn serialize_inner<'a, W: io::Write + 'a>(
-    use super::*;
+    dict: &FnvHashMap<Vec<u8>, UnorderedId>,
-
+    wrt: &mut W,
-    #[test]
+) -> tantivy_fst::Result<IdMapping> {
-    fn test_dictionary_builder() {
+    let mut terms: Vec<(&[u8], UnorderedId)> =
-        let mut dictionary_builder = DictionaryBuilder::default();
+        dict.iter().map(|(k, v)| (k.as_slice(), *v)).collect();
-        let hello_uid = dictionary_builder.get_or_allocate_id(b"hello");
+    terms.sort_unstable_by_key(|(key, _)| *key);
-        let happy_uid = dictionary_builder.get_or_allocate_id(b"happy");
+    let mut unordered_to_ord: Vec<OrderedId> = vec![OrderedId(0u32); terms.len()];
-        let tax_uid = dictionary_builder.get_or_allocate_id(b"tax");
+    let mut fst_builder = tantivy_fst::MapBuilder::new(wrt)?;
-        let mut buffer = Vec::new();
+    for (ord, (key, unordered_id)) in terms.into_iter().enumerate() {
-        let id_mapping = dictionary_builder.serialize(&mut buffer).unwrap();
+        let ordered_id = OrderedId(ord as u32);
-        assert_eq!(id_mapping.to_ord(hello_uid), OrderedId(1));
+        fst_builder.insert(key, ord as u64)?;
-        assert_eq!(id_mapping.to_ord(happy_uid), OrderedId(0));
+        unordered_to_ord[unordered_id.0 as usize] = ordered_id;
-        assert_eq!(id_mapping.to_ord(tax_uid), OrderedId(2));
     }
+    fst_builder.finish()?;
+    Ok(IdMapping { unordered_to_ord })
 }
+
+#[derive(Clone, Copy, Debug)]
+pub struct UnorderedId(pub u32);
+
+#[derive(Clone, Copy)]
+pub struct OrderedId(pub u32);

columnar/src/lib.rs

@@ -1,77 +1,57 @@
+// Copyright (C) 2022 Quickwit, Inc.
+//
+// Quickwit is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at hello@quickwit.io.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
 mod column_type_header;
 mod dictionary;
 mod reader;
-pub(crate) mod utils;
+mod serializer;
 mod value;
 mod writer;
 
 pub use column_type_header::Cardinality;
 pub use reader::ColumnarReader;
-pub use value::{NumericalType, NumericalValue};
+pub use serializer::ColumnarSerializer;
 pub use writer::ColumnarWriter;
 
 pub type DocId = u32;
 
-#[derive(Copy, Clone, Debug)]
-pub struct InvalidData;
-
 #[cfg(test)]
 mod tests {
     use std::ops::Range;
 
     use common::file_slice::FileSlice;
 
-    use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality};
+    use crate::column_type_header::ColumnTypeAndCardinality;
     use crate::reader::ColumnarReader;
+    use crate::serializer::ColumnarSerializer;
     use crate::value::NumericalValue;
-    use crate::{Cardinality, ColumnarWriter};
+    use crate::ColumnarWriter;
 
     #[test]
-    fn test_dataframe_writer_bytes() {
+    fn test_dataframe_writer() {
         let mut dataframe_writer = ColumnarWriter::default();
-        dataframe_writer.record_str(1u32, "my_string", "hello");
+        dataframe_writer.record_numerical(1u32, b"srical.value", NumericalValue::U64(1u64));
-        dataframe_writer.record_str(3u32, "my_string", "helloeee");
+        dataframe_writer.record_numerical(2u32, b"srical.value", NumericalValue::U64(2u64));
+        dataframe_writer.record_numerical(4u32, b"srical.value", NumericalValue::I64(2i64));
         let mut buffer: Vec<u8> = Vec::new();
-        dataframe_writer.serialize(5, &mut buffer).unwrap();
+        let serializer = ColumnarSerializer::new(&mut buffer);
-        let columnar_fileslice = FileSlice::from(buffer);
+        dataframe_writer.serialize(5, serializer).unwrap();
-        let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
-        assert_eq!(columnar.num_columns(), 1);
-        let cols: Vec<(ColumnTypeAndCardinality, Range<u64>)> =
-            columnar.read_columns("my_string").unwrap();
-        assert_eq!(cols.len(), 1);
-        assert_eq!(cols[0].1, 0..158);
-    }
-
-    #[test]
-    fn test_dataframe_writer_bool() {
-        let mut dataframe_writer = ColumnarWriter::default();
-        dataframe_writer.record_bool(1u32, "bool.value", false);
-        let mut buffer: Vec<u8> = Vec::new();
-        dataframe_writer.serialize(5, &mut buffer).unwrap();
-        let columnar_fileslice = FileSlice::from(buffer);
-        let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
-        assert_eq!(columnar.num_columns(), 1);
-        let cols: Vec<(ColumnTypeAndCardinality, Range<u64>)> =
-            columnar.read_columns("bool.value").unwrap();
-        assert_eq!(cols.len(), 1);
-        assert_eq!(
-            cols[0].0,
-            ColumnTypeAndCardinality {
-                cardinality: Cardinality::Optional,
-                typ: ColumnType::Bool
-            }
-        );
-        assert_eq!(cols[0].1, 0..21);
-    }
-
-    #[test]
-    fn test_dataframe_writer_numerical() {
-        let mut dataframe_writer = ColumnarWriter::default();
-        dataframe_writer.record_numerical(1u32, "srical.value", NumericalValue::U64(12u64));
-        dataframe_writer.record_numerical(2u32, "srical.value", NumericalValue::U64(13u64));
-        dataframe_writer.record_numerical(4u32, "srical.value", NumericalValue::U64(15u64));
-        let mut buffer: Vec<u8> = Vec::new();
-        dataframe_writer.serialize(5, &mut buffer).unwrap();
         let columnar_fileslice = FileSlice::from(buffer);
         let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
         assert_eq!(columnar.num_columns(), 1);

columnar/src/reader/mod.rs

@@ -3,29 +3,25 @@ use std::{io, mem};
 
 use common::file_slice::FileSlice;
 use common::BinarySerializable;
-use sstable::{Dictionary, RangeSSTable};
+use sstable::{Dictionary, SSTableRange};
 
 use crate::column_type_header::ColumnTypeAndCardinality;
 
 fn io_invalid_data(msg: String) -> io::Error {
-    io::Error::new(io::ErrorKind::InvalidData, msg)
+    io::Error::new(io::ErrorKind::InvalidData, msg) // format!("Invalid key found.
+                                                    // {key_bytes:?}")));
 }
-
-/// The ColumnarReader makes it possible to access a set of columns
-/// associated to field names.
 pub struct ColumnarReader {
-    column_dictionary: Dictionary<RangeSSTable>,
+    column_dictionary: Dictionary<SSTableRange>,
     column_data: FileSlice,
 }
 
 impl ColumnarReader {
-    /// Opens a new Columnar file.
+    pub fn num_columns(&self) -> usize {
-    pub fn open<F>(file_slice: F) -> io::Result<ColumnarReader>
+        self.column_dictionary.num_terms()
-    where FileSlice: From<F> {
-        Self::open_inner(file_slice.into())
     }
 
-    fn open_inner(file_slice: FileSlice) -> io::Result<ColumnarReader> {
+    pub fn open(file_slice: FileSlice) -> io::Result<ColumnarReader> {
         let (file_slice_without_sstable_len, sstable_len_bytes) =
             file_slice.split_from_end(mem::size_of::<u64>());
         let mut sstable_len_bytes = sstable_len_bytes.read_bytes()?;
@@ -39,50 +35,13 @@ impl ColumnarReader {
         })
     }
 
-    // TODO fix ugly API
-    pub fn list_columns(
-        &self,
-    ) -> io::Result<Vec<(String, ColumnTypeAndCardinality, Range<u64>, u64)>> {
-        let mut stream = self.column_dictionary.stream()?;
-        let mut results = Vec::new();
-        while stream.advance() {
-            let key_bytes: &[u8] = stream.key();
-            let column_code: u8 = key_bytes.last().cloned().unwrap();
-            let column_type_and_cardinality = ColumnTypeAndCardinality::try_from_code(column_code)
-                .map_err(|_| io_invalid_data(format!("Unknown column code `{column_code}`")))?;
-            let range = stream.value().clone();
-            let column_name = String::from_utf8_lossy(&key_bytes[..key_bytes.len() - 1]);
-            let range_len = range.end - range.start;
-            results.push((
-                column_name.to_string(),
-                column_type_and_cardinality,
-                range,
-                range_len,
-            ));
-        }
-        Ok(results)
-    }
-
-    /// Get all columns for the given column name.
-    ///
-    /// There can be more than one column associated to a given column name, provided they have
-    /// different types.
-    // TODO fix ugly API
     pub fn read_columns(
         &self,
-        column_name: &str,
+        field_name: &str,
     ) -> io::Result<Vec<(ColumnTypeAndCardinality, Range<u64>)>> {
-        // Each column is a associated to a given `column_key`,
+        let mut start_key = field_name.to_string();
-        // that starts by `column_name\0column_header`.
-        //
-        // Listing the columns associated to the given column name is therefore equivalent to
-        // listing `column_key` with the prefix `column_name\0`.
-        //
-        // This is in turn equivalent to searching for the range
-        // `[column_name,\0`..column_name\1)`.
-        let mut start_key = column_name.to_string();
         start_key.push('\0');
-        let mut end_key = column_name.to_string();
+        let mut end_key = field_name.to_string();
         end_key.push(1u8 as char);
         let mut stream = self
             .column_dictionary
@@ -93,18 +52,15 @@ impl ColumnarReader {
         let mut results = Vec::new();
         while stream.advance() {
             let key_bytes: &[u8] = stream.key();
-            assert!(key_bytes.starts_with(start_key.as_bytes()));
+            if !key_bytes.starts_with(start_key.as_bytes()) {
+                return Err(io_invalid_data(format!("Invalid key found. {key_bytes:?}")));
+            }
             let column_code: u8 = key_bytes.last().cloned().unwrap();
             let column_type_and_cardinality = ColumnTypeAndCardinality::try_from_code(column_code)
-                .map_err(|_| io_invalid_data(format!("Unknown column code `{column_code}`")))?;
+                .ok_or_else(|| io_invalid_data(format!("Unknown column code `{column_code}`")))?;
             let range = stream.value().clone();
             results.push((column_type_and_cardinality, range));
         }
         Ok(results)
     }
-
-    /// Return the number of columns in the columnar.
-    pub fn num_columns(&self) -> usize {
-        self.column_dictionary.num_terms()
-    }
 }

columnar/src/serializer.rs

@@ -0,0 +1,39 @@
+use std::io;
+use std::io::Write;
+use std::ops::Range;
+
+use common::CountingWriter;
+use sstable::value::RangeWriter;
+use sstable::SSTableRange;
+
+pub struct ColumnarSerializer<W: io::Write> {
+    wrt: CountingWriter<W>,
+    sstable_range: sstable::Writer<Vec<u8>, RangeWriter>,
+}
+
+impl<W: io::Write> ColumnarSerializer<W> {
+    pub fn new(wrt: W) -> ColumnarSerializer<W> {
+        let sstable_range: sstable::Writer<Vec<u8>, RangeWriter> =
+            sstable::Dictionary::<SSTableRange>::builder(Vec::with_capacity(100_000)).unwrap();
+        ColumnarSerializer {
+            wrt: CountingWriter::wrap(wrt),
+            sstable_range,
+        }
+    }
+
+    pub fn record_column_offsets(&mut self, key: &[u8], byte_range: Range<u64>) -> io::Result<()> {
+        self.sstable_range.insert(key, &byte_range)
+    }
+
+    pub fn wrt(&mut self) -> &mut CountingWriter<W> {
+        &mut self.wrt
+    }
+
+    pub fn finalize(mut self) -> io::Result<()> {
+        let sstable_bytes: Vec<u8> = self.sstable_range.finish()?;
+        let sstable_num_bytes: u64 = sstable_bytes.len() as u64;
+        self.wrt.write_all(&sstable_bytes)?;
+        self.wrt.write_all(&sstable_num_bytes.to_le_bytes()[..])?;
+        Ok(())
+    }
+}

columnar/src/utils.rs

@@ -1,76 +0,0 @@
-const fn compute_mask(num_bits: u8) -> u8 {
-    if num_bits == 8 {
-        u8::MAX
-    } else {
-        (1u8 << num_bits) - 1
-    }
-}
-
-#[inline(always)]
-#[must_use]
-pub(crate) fn select_bits<const START: u8, const END: u8>(code: u8) -> u8 {
-    assert!(START <= END);
-    assert!(END <= 8);
-    let num_bits: u8 = END - START;
-    let mask: u8 = compute_mask(num_bits);
-    (code >> START) & mask
-}
-
-#[inline(always)]
-#[must_use]
-pub(crate) fn place_bits<const START: u8, const END: u8>(code: u8) -> u8 {
-    assert!(START <= END);
-    assert!(END <= 8);
-    let num_bits: u8 = END - START;
-    let mask: u8 = compute_mask(num_bits);
-    assert!(code <= mask);
-    code << START
-}
-
-/// Pop-front one bytes from a slice of bytes.
-#[inline(always)]
-pub fn pop_first_byte(bytes: &mut &[u8]) -> Option<u8> {
-    if bytes.is_empty() {
-        return None;
-    }
-    let first_byte = bytes[0];
-    *bytes = &bytes[1..];
-    Some(first_byte)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_select_bits() {
-        assert_eq!(255u8, select_bits::<0, 8>(255u8));
-        assert_eq!(0u8, select_bits::<0, 0>(255u8));
-        assert_eq!(8u8, select_bits::<0, 4>(8u8));
-        assert_eq!(4u8, select_bits::<1, 4>(8u8));
-        assert_eq!(0u8, select_bits::<1, 3>(8u8));
-    }
-
-    #[test]
-    fn test_place_bits() {
-        assert_eq!(255u8, place_bits::<0, 8>(255u8));
-        assert_eq!(4u8, place_bits::<2, 3>(1u8));
-        assert_eq!(0u8, place_bits::<2, 2>(0u8));
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_place_bits_overflows() {
-        let _ = place_bits::<1, 4>(8u8);
-    }
-
-    #[test]
-    fn test_pop_first_byte() {
-        let mut cursor: &[u8] = &b"abcd"[..];
-        assert_eq!(pop_first_byte(&mut cursor), Some(b'a'));
-        assert_eq!(pop_first_byte(&mut cursor), Some(b'b'));
-        assert_eq!(pop_first_byte(&mut cursor), Some(b'c'));
-        assert_eq!(pop_first_byte(&mut cursor), Some(b'd'));
-        assert_eq!(pop_first_byte(&mut cursor), None);
-    }
-}

columnar/src/value.rs

@@ -1,10 +1,10 @@
-use crate::InvalidData;
+use ordered_float::NotNan;
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum NumericalValue {
     I64(i64),
     U64(u64),
-    F64(f64),
+    F64(NotNan<f64>),
 }
 
 impl From<u64> for NumericalValue {
@@ -19,8 +19,8 @@ impl From<i64> for NumericalValue {
     }
 }
 
-impl From<f64> for NumericalValue {
+impl From<NotNan<f64>> for NumericalValue {
-    fn from(val: f64) -> Self {
+    fn from(val: NotNan<f64>) -> Self {
         NumericalValue::F64(val)
     }
 }
@@ -51,12 +51,12 @@ impl NumericalType {
         self as u8
     }
 
-    pub fn try_from_code(code: u8) -> Result<NumericalType, InvalidData> {
+    pub fn try_from_code(code: u8) -> Option<NumericalType> {
         match code {
-            0 => Ok(NumericalType::I64),
+            0 => Some(NumericalType::I64),
-            1 => Ok(NumericalType::U64),
+            1 => Some(NumericalType::U64),
-            2 => Ok(NumericalType::F64),
+            2 => Some(NumericalType::F64),
-            _ => Err(InvalidData),
+            _ => None,
         }
     }
 }
@@ -64,7 +64,6 @@ impl NumericalType {
 /// We voluntarily avoid using `Into` here to keep this
 /// implementation quirk as private as possible.
 ///
-/// # Panics
 /// This coercion trait actually panics if it is used
 /// to convert a loose types to a stricter type.
 ///
@@ -96,11 +95,11 @@ impl Coerce for u64 {
     }
 }
 
-impl Coerce for f64 {
+impl Coerce for NotNan<f64> {
     fn coerce(value: NumericalValue) -> Self {
         match value {
-            NumericalValue::I64(val) => val as f64,
+            NumericalValue::I64(val) => unsafe { NotNan::new_unchecked(val as f64) },
-            NumericalValue::U64(val) => val as f64,
+            NumericalValue::U64(val) => unsafe { NotNan::new_unchecked(val as f64) },
             NumericalValue::F64(val) => val,
         }
     }
@@ -114,7 +113,7 @@ mod tests {
     fn test_numerical_type_code() {
         let mut num_numerical_type = 0;
         for code in u8::MIN..=u8::MAX {
-            if let Ok(numerical_type) = NumericalType::try_from_code(code) {
+            if let Some(numerical_type) = NumericalType::try_from_code(code) {
                 assert_eq!(numerical_type.to_code(), code);
                 num_numerical_type += 1;
             }

columnar/src/writer/column_operation.rs

@@ -1,239 +1,231 @@
+use std::fmt;
+use std::num::NonZeroU8;
+
+use ordered_float::NotNan;
+use thiserror::Error;
+
 use crate::dictionary::UnorderedId;
-use crate::utils::{place_bits, pop_first_byte, select_bits};
 use crate::value::NumericalValue;
-use crate::{DocId, InvalidData, NumericalType};
+use crate::DocId;
 
 /// When we build a columnar dataframe, we first just group
-/// all mutations per column, and appends them in append-only buffer
+/// all mutations per column, and append them in append-only object.
-/// in the stacker.
-///
-/// These ColumnOperation<T> are therefore serialize/deserialized
-/// in memory.
 ///
 /// We represents all of these operations as `ColumnOperation`.
 #[derive(Eq, PartialEq, Debug, Clone, Copy)]
-pub(super) enum ColumnOperation<T> {
+pub(crate) enum ColumnOperation<T> {
     NewDoc(DocId),
     Value(T),
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-struct ColumnOperationMetadata {
-    op_type: ColumnOperationType,
-    len: u8,
-}
-
-impl ColumnOperationMetadata {
-    fn to_code(self) -> u8 {
-        place_bits::<0, 4>(self.len) | place_bits::<4, 8>(self.op_type.to_code())
-    }
-
-    fn try_from_code(code: u8) -> Result<Self, InvalidData> {
-        let len = select_bits::<0, 4>(code);
-        let typ_code = select_bits::<4, 8>(code);
-        let column_type = ColumnOperationType::try_from_code(typ_code)?;
-        Ok(ColumnOperationMetadata {
-            op_type: column_type,
-            len,
-        })
-    }
-}
-
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-#[repr(u8)]
-enum ColumnOperationType {
-    NewDoc = 0u8,
-    AddValue = 1u8,
-}
-
-impl ColumnOperationType {
-    pub fn to_code(self) -> u8 {
-        self as u8
-    }
-
-    pub fn try_from_code(code: u8) -> Result<Self, InvalidData> {
-        match code {
-            0 => Ok(Self::NewDoc),
-            1 => Ok(Self::AddValue),
-            _ => Err(InvalidData),
-        }
-    }
-}
-
-impl<V: SymbolValue> ColumnOperation<V> {
-    pub(super) fn serialize(self) -> impl AsRef<[u8]> {
-        let mut minibuf = MiniBuffer::default();
-        let column_op_metadata = match self {
-            ColumnOperation::NewDoc(new_doc) => {
-                let symbol_len = new_doc.serialize(&mut minibuf.bytes[1..]);
-                ColumnOperationMetadata {
-                    op_type: ColumnOperationType::NewDoc,
-                    len: symbol_len,
-                }
-            }
-            ColumnOperation::Value(val) => {
-                let symbol_len = val.serialize(&mut minibuf.bytes[1..]);
-                ColumnOperationMetadata {
-                    op_type: ColumnOperationType::AddValue,
-                    len: symbol_len,
-                }
-            }
-        };
-        minibuf.bytes[0] = column_op_metadata.to_code();
-        // +1 for the metadata
-        minibuf.len = 1 + column_op_metadata.len;
-        minibuf
-    }
-
-    /// Deserialize a colummn operation.
-    /// Returns None if the buffer is empty.
-    ///
-    /// Panics if the payload is invalid:
-    /// this deserialize method is meant to target in memory.
-    pub(super) fn deserialize(bytes: &mut &[u8]) -> Option<Self> {
-        let column_op_metadata_byte = pop_first_byte(bytes)?;
-        let column_op_metadata = ColumnOperationMetadata::try_from_code(column_op_metadata_byte)
-            .expect("Invalid op metadata byte");
-        let symbol_bytes: &[u8];
-        (symbol_bytes, *bytes) = bytes.split_at(column_op_metadata.len as usize);
-        match column_op_metadata.op_type {
-            ColumnOperationType::NewDoc => {
-                let new_doc = u32::deserialize(symbol_bytes);
-                Some(ColumnOperation::NewDoc(new_doc))
-            }
-            ColumnOperationType::AddValue => {
-                let value = V::deserialize(symbol_bytes);
-                Some(ColumnOperation::Value(value))
-            }
-        }
-    }
-}
-
 impl<T> From<T> for ColumnOperation<T> {
     fn from(value: T) -> Self {
         ColumnOperation::Value(value)
     }
 }
 
-// Serialization trait very local to the writer.
-// As we write fast fields, we accumulate them in "in memory".
-// In order to limit memory usage, and in order
-// to benefit from the stacker, we do this by serialization our data
-// as "Symbols".
 #[allow(clippy::from_over_into)]
-pub(super) trait SymbolValue: Clone + Copy {
+pub(crate) trait SymbolValue: Into<MiniBuffer> + Clone + Copy + fmt::Debug {
-    // Serializes the symbol into the given buffer.
+    fn deserialize(header: NonZeroU8, bytes: &mut &[u8]) -> Result<Self, ParseError>;
-    // Returns the number of bytes written into the buffer.
-    /// # Panics
-    /// May not exceed 9bytes
-    fn serialize(self, buffer: &mut [u8]) -> u8;
-    // Panics if invalid
-    fn deserialize(bytes: &[u8]) -> Self;
 }
 
-impl SymbolValue for bool {
+pub(crate) struct MiniBuffer {
-    fn serialize(self, buffer: &mut [u8]) -> u8 {
+    pub bytes: [u8; 9],
-        buffer[0] = u8::from(self);
+    pub len: usize,
-        1u8
+}
-    }
 
-    fn deserialize(bytes: &[u8]) -> Self {
+impl MiniBuffer {
-        bytes[0] == 1u8
+    pub fn as_slice(&self) -> &[u8] {
+        &self.bytes[..self.len]
     }
 }
 
-#[derive(Default)]
+fn compute_header_byte(typ: SymbolType, len: usize) -> u8 {
-struct MiniBuffer {
+    assert!(len <= 9);
-    pub bytes: [u8; 10],
+    (len << 4) as u8 | typ as u8
-    pub len: u8,
-}
-
-impl AsRef<[u8]> for MiniBuffer {
-    fn as_ref(&self) -> &[u8] {
-        &self.bytes[..self.len as usize]
-    }
 }
 
 impl SymbolValue for NumericalValue {
-    fn deserialize(mut bytes: &[u8]) -> Self {
+    fn deserialize(header_byte: NonZeroU8, bytes: &mut &[u8]) -> Result<Self, ParseError> {
-        let type_code = pop_first_byte(&mut bytes).unwrap();
+        let (typ, len) = parse_header_byte(header_byte)?;
-        let symbol_type = NumericalType::try_from_code(type_code).unwrap();
+        let value_bytes: &[u8];
-        let mut octet: [u8; 8] = [0u8; 8];
+        (value_bytes, *bytes) = bytes.split_at(len);
-        octet[..bytes.len()].copy_from_slice(bytes);
+        let symbol: NumericalValue = match typ {
-        match symbol_type {
+            SymbolType::U64 => {
-            NumericalType::U64 => {
+                let mut octet: [u8; 8] = [0u8; 8];
+                octet[..value_bytes.len()].copy_from_slice(value_bytes);
                 let val: u64 = u64::from_le_bytes(octet);
                 NumericalValue::U64(val)
             }
-            NumericalType::I64 => {
+            SymbolType::I64 => {
+                let mut octet: [u8; 8] = [0u8; 8];
+                octet[..value_bytes.len()].copy_from_slice(value_bytes);
                 let encoded: u64 = u64::from_le_bytes(octet);
                 let val: i64 = decode_zig_zag(encoded);
                 NumericalValue::I64(val)
             }
-            NumericalType::F64 => {
+            SymbolType::Float => {
-                debug_assert_eq!(bytes.len(), 8);
+                let octet: [u8; 8] =
-                let val: f64 = f64::from_le_bytes(octet);
+                    value_bytes.try_into().map_err(|_| ParseError::InvalidLen {
-                NumericalValue::F64(val)
+                        typ: SymbolType::Float,
+                        len,
+                    })?;
+                let val_possibly_nan = f64::from_le_bytes(octet);
+                let val_not_nan = NotNan::new(val_possibly_nan)
+                    .map_err(|_| ParseError::NaN)?;
+                NumericalValue::F64(val_not_nan)
             }
-        }
+        };
+        Ok(symbol)
     }
+}
 
-    /// F64: Serialize with a fixed size of 9 bytes
+#[allow(clippy::from_over_into)]
-    /// U64: Serialize without leading zeroes
+impl Into<MiniBuffer> for NumericalValue {
-    /// I64: ZigZag encoded and serialize without leading zeroes
+    fn into(self) -> MiniBuffer {
-    fn serialize(self, output: &mut [u8]) -> u8 {
+        let mut bytes = [0u8; 9];
         match self {
             NumericalValue::F64(val) => {
-                output[0] = NumericalType::F64 as u8;
+                let len = 8;
-                output[1..9].copy_from_slice(&val.to_le_bytes());
+                let header_byte = compute_header_byte(SymbolType::Float, len);
-                9u8
+                bytes[0] = header_byte;
+                bytes[1..].copy_from_slice(&val.to_le_bytes());
+                MiniBuffer {
+                    bytes,
+                    len: len + 1,
+                }
             }
             NumericalValue::U64(val) => {
-                let len = compute_num_bytes_for_u64(val) as u8;
+                let len = compute_num_bytes_for_u64(val);
-                output[0] = NumericalType::U64 as u8;
+                let header_byte = compute_header_byte(SymbolType::U64, len);
-                output[1..9].copy_from_slice(&val.to_le_bytes());
+                bytes[0] = header_byte;
-                len + 1u8
+                bytes[1..].copy_from_slice(&val.to_le_bytes());
+                MiniBuffer {
+                    bytes,
+                    len: len + 1,
+                }
             }
             NumericalValue::I64(val) => {
-                let zig_zag_encoded = encode_zig_zag(val);
+                let encoded = encode_zig_zag(val);
-                let len = compute_num_bytes_for_u64(zig_zag_encoded) as u8;
+                let len = compute_num_bytes_for_u64(encoded);
-                output[0] = NumericalType::I64 as u8;
+                let header_byte = compute_header_byte(SymbolType::I64, len);
-                output[1..9].copy_from_slice(&zig_zag_encoded.to_le_bytes());
+                bytes[0] = header_byte;
-                len + 1u8
+                bytes[1..].copy_from_slice(&encoded.to_le_bytes());
+                MiniBuffer {
+                    bytes,
+                    len: len + 1,
+                }
             }
         }
     }
 }
 
-impl SymbolValue for u32 {
+#[allow(clippy::from_over_into)]
-    fn serialize(self, output: &mut [u8]) -> u8 {
+impl Into<MiniBuffer> for UnorderedId {
-        let len = compute_num_bytes_for_u64(self as u64);
+    fn into(self) -> MiniBuffer {
-        output[0..4].copy_from_slice(&self.to_le_bytes());
+        let mut bytes = [0u8; 9];
-        len as u8
+        let val = self.0 as u64;
-    }
+        let len = compute_num_bytes_for_u64(val) + 1;
-
+        bytes[0] = len as u8;
-    fn deserialize(bytes: &[u8]) -> Self {
+        bytes[1..].copy_from_slice(&val.to_le_bytes());
-        let mut quartet: [u8; 4] = [0u8; 4];
+        MiniBuffer { bytes, len }
-        quartet[..bytes.len()].copy_from_slice(bytes);
-        u32::from_le_bytes(quartet)
     }
 }
 
 impl SymbolValue for UnorderedId {
-    fn serialize(self, output: &mut [u8]) -> u8 {
+    fn deserialize(header: NonZeroU8, bytes: &mut &[u8]) -> Result<UnorderedId, ParseError> {
-        self.0.serialize(output)
+        let len = header.get() as usize;
-    }
+        let symbol_bytes: &[u8];
-
+        (symbol_bytes, *bytes) = bytes.split_at(len);
-    fn deserialize(bytes: &[u8]) -> Self {
+        let mut value_bytes = [0u8; 4];
-        UnorderedId(u32::deserialize(bytes))
+        value_bytes[..len - 1].copy_from_slice(&symbol_bytes[1..]);
+        let value = u32::from_le_bytes(value_bytes);
+        Ok(UnorderedId(value))
     }
 }
 
+const HEADER_MASK: u8 = (1u8 << 4) - 1u8;
+
 fn compute_num_bytes_for_u64(val: u64) -> usize {
     let msb = (64u32 - val.leading_zeros()) as usize;
     (msb + 7) / 8
 }
 
+fn parse_header_byte(byte: NonZeroU8) -> Result<(SymbolType, usize), ParseError> {
+    let len = (byte.get() as usize) >> 4;
+    let typ_code = byte.get() & HEADER_MASK;
+    let typ = SymbolType::try_from(typ_code)?;
+    Ok((typ, len))
+}
+
+#[derive(Error, Debug)]
+pub enum ParseError {
+    #[error("Type byte unknown `{0}`")]
+    UnknownType(u8),
+    #[error("Invalid len for type `{len}` for type `{typ:?}`.")]
+    InvalidLen { typ: SymbolType, len: usize },
+    #[error("Missing bytes.")]
+    MissingBytes,
+    #[error("Not a number value.")]
+    NaN,
+}
+
+impl<V: SymbolValue> ColumnOperation<V> {
+    pub fn serialize(self) -> MiniBuffer {
+        match self {
+            ColumnOperation::NewDoc(doc) => {
+                let mut minibuf: [u8; 9] = [0u8; 9];
+                minibuf[0] = 0u8;
+                minibuf[1..5].copy_from_slice(&doc.to_le_bytes());
+                MiniBuffer {
+                    bytes: minibuf,
+                    len: 5,
+                }
+            }
+            ColumnOperation::Value(val) => val.into(),
+        }
+    }
+
+    pub fn deserialize(bytes: &mut &[u8]) -> Result<Self, ParseError> {
+        if bytes.is_empty() {
+            return Err(ParseError::MissingBytes);
+        }
+        let header_byte = bytes[0];
+        *bytes = &bytes[1..];
+        if let Some(header_byte) = NonZeroU8::new(header_byte) {
+            let value = V::deserialize(header_byte, bytes)?;
+            Ok(ColumnOperation::Value(value))
+        } else {
+            let doc_bytes: &[u8];
+            (doc_bytes, *bytes) = bytes.split_at(4);
+            let doc: u32 =
+                u32::from_le_bytes(doc_bytes.try_into().map_err(|_| ParseError::MissingBytes)?);
+            Ok(ColumnOperation::NewDoc(doc))
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum SymbolType {
+    U64 = 1u8,
+    I64 = 2u8,
+    Float = 3u8,
+}
+
+impl TryFrom<u8> for SymbolType {
+    type Error = ParseError;
+
+    fn try_from(byte: u8) -> Result<Self, ParseError> {
+        match byte {
+            1u8 => Ok(SymbolType::U64),
+            2u8 => Ok(SymbolType::I64),
+            3u8 => Ok(SymbolType::Float),
+            _ => Err(ParseError::UnknownType(byte)),
+        }
+    }
+}
+
 fn encode_zig_zag(n: i64) -> u64 {
     ((n << 1) ^ (n >> 63)) as u64
 }
@@ -244,7 +236,7 @@ fn decode_zig_zag(n: u64) -> i64 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::{SymbolType, *};
 
     #[track_caller]
     fn test_zig_zag_aux(val: i64) {
@@ -276,28 +268,31 @@ mod tests {
         }
     }
 
+    #[track_caller]
+    fn ser_deser_header_byte_aux(symbol_type: SymbolType, len: usize) {
+        let header_byte = compute_header_byte(symbol_type, len);
+        let (serdeser_numerical_type, serdeser_len) =
+            parse_header_byte(NonZeroU8::new(header_byte).unwrap()).unwrap();
+        assert_eq!(symbol_type, serdeser_numerical_type);
+        assert_eq!(len, serdeser_len);
+    }
+
     #[test]
-    fn test_column_op_metadata_byte_serialization() {
+    fn test_header_byte_serialization() {
-        for len in 0..=15 {
+        for len in 1..9 {
-            for op_type in [ColumnOperationType::AddValue, ColumnOperationType::NewDoc] {
+            ser_deser_header_byte_aux(SymbolType::Float, len);
-                let column_op_metadata = ColumnOperationMetadata { op_type, len };
+            ser_deser_header_byte_aux(SymbolType::I64, len);
-                let column_op_metadata_code = column_op_metadata.to_code();
+            ser_deser_header_byte_aux(SymbolType::U64, len);
-                let serdeser_metadata =
-                    ColumnOperationMetadata::try_from_code(column_op_metadata_code).unwrap();
-                assert_eq!(column_op_metadata, serdeser_metadata);
-            }
         }
     }
 
     #[track_caller]
-    fn ser_deser_symbol(column_op: ColumnOperation<NumericalValue>) {
+    fn ser_deser_symbol(symbol: ColumnOperation<NumericalValue>) {
-        let buf = column_op.serialize();
+        let buf = symbol.serialize();
-        let mut buffer = buf.as_ref().to_vec();
+        let mut bytes = &buf.bytes[..];
-        buffer.extend_from_slice(b"234234");
-        let mut bytes = &buffer[..];
         let serdeser_symbol = ColumnOperation::deserialize(&mut bytes).unwrap();
-        assert_eq!(bytes.len() + buf.as_ref().len() as usize, buffer.len());
+        assert_eq!(bytes.len() + buf.len, buf.bytes.len());
-        assert_eq!(column_op, serdeser_symbol);
+        assert_eq!(symbol, serdeser_symbol);
     }
 
     #[test]
@@ -323,24 +318,4 @@ mod tests {
         ser_deser_symbol(ColumnOperation::Value(NumericalValue::U64(u64::MIN)));
         ser_deser_symbol(ColumnOperation::Value(NumericalValue::U64(u64::MAX)));
     }
-
-    fn test_column_operation_unordered_aux(val: u32, expected_len: usize) {
-        let column_op = ColumnOperation::Value(UnorderedId(val));
-        let minibuf = column_op.serialize();
-        assert_eq!(minibuf.as_ref().len() as usize, expected_len);
-        let mut buf = minibuf.as_ref().to_vec();
-        buf.extend_from_slice(&[2, 2, 2, 2, 2, 2]);
-        let mut cursor = &buf[..];
-        let column_op_serdeser: ColumnOperation<UnorderedId> =
-            ColumnOperation::deserialize(&mut cursor).unwrap();
-        assert_eq!(column_op_serdeser, ColumnOperation::Value(UnorderedId(val)));
-        assert_eq!(cursor.len() + expected_len, buf.len());
-    }
-
-    #[test]
-    fn test_column_operation_unordered() {
-        test_column_operation_unordered_aux(300u32, 3);
-        test_column_operation_unordered_aux(1u32, 2);
-        test_column_operation_unordered_aux(0u32, 1);
-    }
 }

columnar/src/writer/column_writers.rs

@@ -1,265 +0,0 @@
-use std::cmp::Ordering;
-
-use stacker::{ExpUnrolledLinkedList, MemoryArena};
-
-use crate::dictionary::{DictionaryBuilder, UnorderedId};
-use crate::writer::column_operation::{ColumnOperation, SymbolValue};
-use crate::{Cardinality, DocId, NumericalType, NumericalValue};
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(u8)]
-enum DocumentStep {
-    Same = 0,
-    Next = 1,
-    Skipped = 2,
-}
-
-#[inline(always)]
-fn delta_with_last_doc(last_doc_opt: Option<u32>, doc: u32) -> DocumentStep {
-    let expected_next_doc = last_doc_opt.map(|last_doc| last_doc + 1).unwrap_or(0u32);
-    match doc.cmp(&expected_next_doc) {
-        Ordering::Less => DocumentStep::Same,
-        Ordering::Equal => DocumentStep::Next,
-        Ordering::Greater => DocumentStep::Skipped,
-    }
-}
-
-#[derive(Copy, Clone, Default)]
-pub struct ColumnWriter {
-    // Detected cardinality of the column so far.
-    cardinality: Cardinality,
-    // Last document inserted.
-    // None if no doc has been added yet.
-    last_doc_opt: Option<u32>,
-    // Buffer containing the serialized values.
-    values: ExpUnrolledLinkedList,
-}
-
-impl ColumnWriter {
-    /// Returns an iterator over the Symbol that have been recorded
-    /// for the given column.
-    pub(super) fn operation_iterator<'a, V: SymbolValue>(
-        &self,
-        arena: &MemoryArena,
-        buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a {
-        buffer.clear();
-        self.values.read_to_end(arena, buffer);
-        let mut cursor: &[u8] = &buffer[..];
-        std::iter::from_fn(move || ColumnOperation::deserialize(&mut cursor))
-    }
-
-    /// Records a change of the document being recorded.
-    ///
-    /// This function will also update the cardinality of the column
-    /// if necessary.
-    pub(super) fn record<S: SymbolValue>(&mut self, doc: DocId, value: S, arena: &mut MemoryArena) {
-        // Difference between `doc` and the last doc.
-        match delta_with_last_doc(self.last_doc_opt, doc) {
-            DocumentStep::Same => {
-                // This is the last encounterred document.
-                self.cardinality = Cardinality::Multivalued;
-            }
-            DocumentStep::Next => {
-                self.last_doc_opt = Some(doc);
-                self.write_symbol::<S>(ColumnOperation::NewDoc(doc), arena);
-            }
-            DocumentStep::Skipped => {
-                self.cardinality = self.cardinality.max(Cardinality::Optional);
-                self.last_doc_opt = Some(doc);
-                self.write_symbol::<S>(ColumnOperation::NewDoc(doc), arena);
-            }
-        }
-        self.write_symbol(ColumnOperation::Value(value), arena);
-    }
-
-    // Get the cardinality.
-    // The overall number of docs in the column is necessary to
-    // deal with the case where the all docs contain 1 value, except some documents
-    // at the end of the column.
-    pub(crate) fn get_cardinality(&self, num_docs: DocId) -> Cardinality {
-        match delta_with_last_doc(self.last_doc_opt, num_docs) {
-            DocumentStep::Same | DocumentStep::Next => self.cardinality,
-            DocumentStep::Skipped => self.cardinality.max(Cardinality::Optional),
-        }
-    }
-
-    /// Appends a new symbol to the `ColumnWriter`.
-    fn write_symbol<V: SymbolValue>(
-        &mut self,
-        column_operation: ColumnOperation<V>,
-        arena: &mut MemoryArena,
-    ) {
-        self.values
-            .writer(arena)
-            .extend_from_slice(column_operation.serialize().as_ref());
-    }
-}
-
-#[derive(Clone, Copy, Default)]
-pub(crate) struct NumericalColumnWriter {
-    compatible_numerical_types: CompatibleNumericalTypes,
-    column_writer: ColumnWriter,
-}
-
-/// State used to store what types are still acceptable
-/// after having seen a set of numerical values.
-#[derive(Clone, Copy)]
-struct CompatibleNumericalTypes {
-    all_values_within_i64_range: bool,
-    all_values_within_u64_range: bool,
-    // f64 is always acceptable.
-}
-
-impl Default for CompatibleNumericalTypes {
-    fn default() -> CompatibleNumericalTypes {
-        CompatibleNumericalTypes {
-            all_values_within_i64_range: true,
-            all_values_within_u64_range: true,
-        }
-    }
-}
-
-impl CompatibleNumericalTypes {
-    fn accept_value(&mut self, numerical_value: NumericalValue) {
-        match numerical_value {
-            NumericalValue::I64(val_i64) => {
-                let value_within_u64_range = val_i64 >= 0i64;
-                self.all_values_within_u64_range &= value_within_u64_range;
-            }
-            NumericalValue::U64(val_u64) => {
-                let value_within_i64_range = val_u64 < i64::MAX as u64;
-                self.all_values_within_i64_range &= value_within_i64_range;
-            }
-            NumericalValue::F64(_) => {
-                self.all_values_within_i64_range = false;
-                self.all_values_within_u64_range = false;
-            }
-        }
-    }
-
-    pub fn to_numerical_type(self) -> NumericalType {
-        if self.all_values_within_i64_range {
-            NumericalType::I64
-        } else if self.all_values_within_u64_range {
-            NumericalType::U64
-        } else {
-            NumericalType::F64
-        }
-    }
-}
-
-impl NumericalColumnWriter {
-    pub fn column_type_and_cardinality(&self, num_docs: DocId) -> (NumericalType, Cardinality) {
-        let numerical_type = self.compatible_numerical_types.to_numerical_type();
-        let cardinality = self.column_writer.get_cardinality(num_docs);
-        (numerical_type, cardinality)
-    }
-
-    pub fn record_numerical_value(
-        &mut self,
-        doc: DocId,
-        value: NumericalValue,
-        arena: &mut MemoryArena,
-    ) {
-        self.compatible_numerical_types.accept_value(value);
-        self.column_writer.record(doc, value, arena);
-    }
-
-    pub(super) fn operation_iterator<'a>(
-        self,
-        arena: &MemoryArena,
-        buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<NumericalValue>> + 'a {
-        self.column_writer.operation_iterator(arena, buffer)
-    }
-}
-
-#[derive(Copy, Clone, Default)]
-pub(crate) struct StrColumnWriter {
-    pub(crate) dictionary_id: u32,
-    pub(crate) column_writer: ColumnWriter,
-}
-
-impl StrColumnWriter {
-    pub(crate) fn with_dictionary_id(dictionary_id: u32) -> StrColumnWriter {
-        StrColumnWriter {
-            dictionary_id,
-            column_writer: Default::default(),
-        }
-    }
-
-    pub(crate) fn record_bytes(
-        &mut self,
-        doc: DocId,
-        bytes: &[u8],
-        dictionaries: &mut [DictionaryBuilder],
-        arena: &mut MemoryArena,
-    ) {
-        let unordered_id = dictionaries[self.dictionary_id as usize].get_or_allocate_id(bytes);
-        self.column_writer.record(doc, unordered_id, arena);
-    }
-
-    pub(super) fn operation_iterator<'a>(
-        &self,
-        arena: &MemoryArena,
-        byte_buffer: &'a mut Vec<u8>,
-    ) -> impl Iterator<Item = ColumnOperation<UnorderedId>> + 'a {
-        self.column_writer.operation_iterator(arena, byte_buffer)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_delta_with_last_doc() {
-        assert_eq!(delta_with_last_doc(None, 0u32), DocumentStep::Next);
-        assert_eq!(delta_with_last_doc(None, 1u32), DocumentStep::Skipped);
-        assert_eq!(delta_with_last_doc(None, 2u32), DocumentStep::Skipped);
-        assert_eq!(delta_with_last_doc(Some(0u32), 0u32), DocumentStep::Same);
-        assert_eq!(delta_with_last_doc(Some(1u32), 1u32), DocumentStep::Same);
-        assert_eq!(delta_with_last_doc(Some(1u32), 2u32), DocumentStep::Next);
-        assert_eq!(delta_with_last_doc(Some(1u32), 3u32), DocumentStep::Skipped);
-        assert_eq!(delta_with_last_doc(Some(1u32), 4u32), DocumentStep::Skipped);
-    }
-
-    #[track_caller]
-    fn test_column_writer_coercion_iter_aux(
-        values: impl Iterator<Item = NumericalValue>,
-        expected_numerical_type: NumericalType,
-    ) {
-        let mut compatible_numerical_types = CompatibleNumericalTypes::default();
-        for value in values {
-            compatible_numerical_types.accept_value(value);
-        }
-        assert_eq!(
-            compatible_numerical_types.to_numerical_type(),
-            expected_numerical_type
-        );
-    }
-
-    #[track_caller]
-    fn test_column_writer_coercion_aux(
-        values: &[NumericalValue],
-        expected_numerical_type: NumericalType,
-    ) {
-        test_column_writer_coercion_iter_aux(values.iter().copied(), expected_numerical_type);
-        test_column_writer_coercion_iter_aux(values.iter().rev().copied(), expected_numerical_type);
-    }
-
-    #[test]
-    fn test_column_writer_coercion() {
-        test_column_writer_coercion_aux(&[], NumericalType::I64);
-        test_column_writer_coercion_aux(&[1i64.into()], NumericalType::I64);
-        test_column_writer_coercion_aux(&[1u64.into()], NumericalType::I64);
-        // We don't detect exact integer at the moment. We could!
-        test_column_writer_coercion_aux(&[1f64.into()], NumericalType::F64);
-        test_column_writer_coercion_aux(&[u64::MAX.into()], NumericalType::U64);
-        test_column_writer_coercion_aux(&[(i64::MAX as u64).into()], NumericalType::U64);
-        test_column_writer_coercion_aux(&[(1u64 << 63).into()], NumericalType::U64);
-        test_column_writer_coercion_aux(&[1i64.into(), 1u64.into()], NumericalType::I64);
-        test_column_writer_coercion_aux(&[u64::MAX.into(), (-1i64).into()], NumericalType::F64);
-    }
-}

columnar/src/writer/mod.rs

@@ -1,51 +1,196 @@
 mod column_operation;
-mod column_writers;
-mod serializer;
 mod value_index;
 
-use std::io;
+use std::io::{self, Write};
 
 use column_operation::ColumnOperation;
 use common::CountingWriter;
 use fastfield_codecs::serialize::ValueIndexInfo;
 use fastfield_codecs::{Column, MonotonicallyMappableToU64, VecColumn};
-use serializer::ColumnarSerializer;
+use ordered_float::NotNan;
-use stacker::{Addr, ArenaHashMap, MemoryArena};
+use stacker::{Addr, ArenaHashMap, ExpUnrolledLinkedList, MemoryArena};
 
-use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality, ColumnTypeCategory};
+use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality};
-use crate::dictionary::{DictionaryBuilder, TermIdMapping, UnorderedId};
+use crate::dictionary::{DictionaryBuilder, IdMapping, UnorderedId};
 use crate::value::{Coerce, NumericalType, NumericalValue};
-use crate::writer::column_writers::{ColumnWriter, NumericalColumnWriter, StrColumnWriter};
+use crate::writer::column_operation::SymbolValue;
 use crate::writer::value_index::{IndexBuilder, SpareIndexBuilders};
-use crate::{Cardinality, DocId};
+use crate::{Cardinality, ColumnarSerializer, DocId};
 
-/// This is a set of buffers that are used to temporarily write the values into before passing them
+#[derive(Copy, Clone, Default)]
-/// to the fast field codecs.
+struct ColumnWriter {
-#[derive(Default)]
+    // Detected cardinality of the column so far.
-struct SpareBuffers {
+    cardinality: Cardinality,
-    value_index_builders: SpareIndexBuilders,
+    // Last document inserted.
-    i64_values: Vec<i64>,
+    // None if no doc has been added yet.
-    u64_values: Vec<u64>,
+    last_doc_opt: Option<u32>,
-    f64_values: Vec<f64>,
+    // Buffer containing the serialized values.
-    bool_values: Vec<bool>,
+    values: ExpUnrolledLinkedList,
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct NumericalColumnWriter {
+    compatible_numerical_types: CompatibleNumericalTypes,
+    column_writer: ColumnWriter,
+}
+
+#[derive(Clone, Copy)]
+struct CompatibleNumericalTypes {
+    all_values_within_i64_range: bool,
+    all_values_within_u64_range: bool,
+}
+
+impl Default for CompatibleNumericalTypes {
+    fn default() -> CompatibleNumericalTypes {
+        CompatibleNumericalTypes {
+            all_values_within_i64_range: true,
+            all_values_within_u64_range: true,
+        }
+    }
+}
+
+impl CompatibleNumericalTypes {
+    pub fn accept_value(&mut self, numerical_value: NumericalValue) {
+        match numerical_value {
+            NumericalValue::I64(val_i64) => {
+                let value_within_u64_range = val_i64 >= 0i64;
+                self.all_values_within_u64_range &= value_within_u64_range;
+            }
+            NumericalValue::U64(val_u64) => {
+                let value_within_i64_range = val_u64 < i64::MAX as u64;
+                self.all_values_within_i64_range &= value_within_i64_range;
+            }
+            NumericalValue::F64(_) => {
+                self.all_values_within_i64_range = false;
+                self.all_values_within_u64_range = false;
+            }
+        }
+    }
+
+    pub fn to_numerical_type(self) -> NumericalType {
+        if self.all_values_within_i64_range {
+            NumericalType::I64
+        } else if self.all_values_within_u64_range {
+            NumericalType::U64
+        } else {
+            NumericalType::F64
+        }
+    }
+}
+
+impl NumericalColumnWriter {
+    pub fn record_numerical_value(
+        &mut self,
+        doc: DocId,
+        value: NumericalValue,
+        arena: &mut MemoryArena,
+    ) {
+        self.compatible_numerical_types.accept_value(value);
+        self.column_writer.record(doc, value, arena);
+    }
+}
+
+impl ColumnWriter {
+    fn symbol_iterator<'a, V: SymbolValue>(
+        &self,
+        arena: &MemoryArena,
+        buffer: &'a mut Vec<u8>,
+    ) -> impl Iterator<Item = ColumnOperation<V>> + 'a {
+        buffer.clear();
+        self.values.read_to_end(arena, buffer);
+        let mut cursor: &[u8] = &buffer[..];
+        std::iter::from_fn(move || {
+            if cursor.is_empty() {
+                return None;
+            }
+            let symbol = ColumnOperation::deserialize(&mut cursor)
+                .expect("Failed to deserialize symbol from in-memory. This should never happen.");
+            Some(symbol)
+        })
+    }
+
+    fn delta_with_last_doc(&self, doc: DocId) -> u32 {
+        self.last_doc_opt
+            .map(|last_doc| doc - last_doc)
+            .unwrap_or(doc + 1u32)
+    }
+
+    /// Records a change of the document being recorded.
+    ///
+    /// This function will also update the cardinality of the column
+    /// if necessary.
+    fn record(&mut self, doc: DocId, value: NumericalValue, arena: &mut MemoryArena) {
+        // Difference between `doc` and the last doc.
+        match self.delta_with_last_doc(doc) {
+            0 => {
+                // This is the last encounterred document.
+                self.cardinality = Cardinality::Multivalued;
+            }
+            1 => {
+                self.last_doc_opt = Some(doc);
+                self.write_symbol::<NumericalValue>(ColumnOperation::NewDoc(doc), arena);
+            }
+            _ => {
+                self.cardinality = self.cardinality.max(Cardinality::Optional);
+                self.last_doc_opt = Some(doc);
+                self.write_symbol::<NumericalValue>(ColumnOperation::NewDoc(doc), arena);
+            }
+        }
+        self.write_symbol(ColumnOperation::Value(value), arena);
+    }
+
+    // Get the cardinality.
+    // The overall number of docs in the column is necessary to
+    // deal with the case where the all docs contain 1 value, except some documents
+    // at the end of the column.
+    fn get_cardinality(&self, num_docs: DocId) -> Cardinality {
+        if self.delta_with_last_doc(num_docs) > 1 {
+            self.cardinality.max(Cardinality::Optional)
+        } else {
+            self.cardinality
+        }
+    }
+
+    fn write_symbol<V: SymbolValue>(
+        &mut self,
+        symbol: ColumnOperation<V>,
+        arena: &mut MemoryArena,
+    ) {
+        self.values
+            .writer(arena)
+            .extend_from_slice(symbol.serialize().as_slice());
+    }
+}
+
+#[derive(Copy, Clone, Default)]
+pub struct BytesColumnWriter {
+    dictionary_id: u32,
+    column_writer: ColumnWriter,
+}
+
+impl BytesColumnWriter {
+    pub fn with_dictionary_id(dictionary_id: u32) -> BytesColumnWriter {
+        BytesColumnWriter {
+            dictionary_id,
+            column_writer: Default::default(),
+        }
+    }
+
+    pub fn record_bytes(
+        &mut self,
+        doc: DocId,
+        bytes: &[u8],
+        dictionaries: &mut [DictionaryBuilder],
+        arena: &mut MemoryArena,
+    ) {
+        let unordered_id = dictionaries[self.dictionary_id as usize].get_or_allocate_id(bytes);
+        let numerical_value = NumericalValue::U64(unordered_id.0 as u64);
+        self.column_writer.record(doc, numerical_value, arena);
+    }
 }
 
-/// Makes it possible to create a new columnar.
-///
-/// ```rust
-/// use tantivy_columnar::ColumnarWriter;
-///
-/// let mut columnar_writer = ColumnarWriter::default();
-/// columnar_writer.record_str(0u32 /* doc id */, "product_name", "Red backpack");
-/// columnar_writer.record_numerical(0u32 /* doc id */, "price", 10u64);
-/// columnar_writer.record_str(1u32 /* doc id */, "product_name", "Apple");
-/// columnar_writer.record_numerical(0u32 /* doc id */, "price", 10.5f64); //< uh oh we ended up mixing integer and floats.
-/// let mut wrt: Vec<u8> =  Vec::new();
-/// columnar_writer.serialize(2u32, &mut wrt).unwrap();
-/// ```
 pub struct ColumnarWriter {
     numerical_field_hash_map: ArenaHashMap,
-    bool_field_hash_map: ArenaHashMap,
     bytes_field_hash_map: ArenaHashMap,
     arena: MemoryArena,
     // Dictionaries used to store dictionary-encoded values.
@@ -53,11 +198,19 @@ pub struct ColumnarWriter {
     buffers: SpareBuffers,
 }
 
+#[derive(Default)]
+struct SpareBuffers {
+    byte_buffer: Vec<u8>,
+    value_index_builders: SpareIndexBuilders,
+    i64_values: Vec<i64>,
+    u64_values: Vec<u64>,
+    f64_values: Vec<ordered_float::NotNan<f64>>,
+}
+
 impl Default for ColumnarWriter {
     fn default() -> Self {
         ColumnarWriter {
             numerical_field_hash_map: ArenaHashMap::new(10_000),
-            bool_field_hash_map: ArenaHashMap::new(10_000),
             bytes_field_hash_map: ArenaHashMap::new(10_000),
             dictionaries: Vec::new(),
             arena: MemoryArena::default(),
@@ -66,213 +219,186 @@ impl Default for ColumnarWriter {
     }
 }
 
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+enum BytesOrNumerical {
+    Bytes,
+    Numerical,
+}
+
 impl ColumnarWriter {
-    pub fn record_numerical<T: Into<NumericalValue> + Copy>(
+    pub fn record_numerical(&mut self, doc: DocId, key: &[u8], numerical_value: NumericalValue) {
-        &mut self,
-        doc: DocId,
-        column_name: &str,
-        numerical_value: T,
-    ) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
         let (hash_map, arena) = (&mut self.numerical_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
+        hash_map.mutate_or_create(key, |column_opt: Option<NumericalColumnWriter>| {
-            column_name.as_bytes(),
+            let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
-            |column_opt: Option<NumericalColumnWriter>| {
+            column.record_numerical_value(doc, numerical_value, arena);
-                let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
+            column
-                column.record_numerical_value(doc, numerical_value.into(), arena);
+        });
-                column
-            },
-        );
     }
 
-    pub fn record_bool(&mut self, doc: DocId, column_name: &str, val: bool) {
+    pub fn record_bytes(&mut self, doc: DocId, key: &[u8], value: &[u8]) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
-        let (hash_map, arena) = (&mut self.bool_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<ColumnWriter>| {
-                let mut column: ColumnWriter = column_opt.unwrap_or_default();
-                column.record(doc, val, arena);
-                column
-            },
-        );
-    }
-
-    pub fn record_str(&mut self, doc: DocId, column_name: &str, value: &str) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
         let (hash_map, arena, dictionaries) = (
             &mut self.bytes_field_hash_map,
             &mut self.arena,
             &mut self.dictionaries,
         );
-        hash_map.mutate_or_create(
+        hash_map.mutate_or_create(key, |column_opt: Option<BytesColumnWriter>| {
-            column_name.as_bytes(),
+            let mut column: BytesColumnWriter = column_opt.unwrap_or_else(|| {
-            |column_opt: Option<StrColumnWriter>| {
+                let dictionary_id = dictionaries.len() as u32;
-                let mut column: StrColumnWriter = column_opt.unwrap_or_else(|| {
+                dictionaries.push(DictionaryBuilder::default());
-                    // Each column has its own dictionary
+                BytesColumnWriter::with_dictionary_id(dictionary_id)
-                    let dictionary_id = dictionaries.len() as u32;
+            });
-                    dictionaries.push(DictionaryBuilder::default());
+            column.record_bytes(doc, value, dictionaries, arena);
-                    StrColumnWriter::with_dictionary_id(dictionary_id)
+            column
-                });
+        });
-                column.record_bytes(doc, value.as_bytes(), dictionaries, arena);
-                column
-            },
-        );
     }
 
-    pub fn serialize(&mut self, num_docs: DocId, wrt: &mut dyn io::Write) -> io::Result<()> {
+    pub fn serialize<W: io::Write>(
-        let mut serializer = ColumnarSerializer::new(wrt);
+        &mut self,
-        let mut field_columns: Vec<(&[u8], ColumnTypeCategory, Addr)> = self
+        num_docs: DocId,
+        mut serializer: ColumnarSerializer<W>,
+    ) -> io::Result<()> {
+        let mut field_columns: Vec<(&[u8], BytesOrNumerical, Addr)> = self
             .numerical_field_hash_map
             .iter()
-            .map(|(term, addr, _)| (term, ColumnTypeCategory::Numerical, addr))
+            .map(|(term, addr, _)| (term, BytesOrNumerical::Numerical, addr))
             .collect();
         field_columns.extend(
             self.bytes_field_hash_map
                 .iter()
-                .map(|(term, addr, _)| (term, ColumnTypeCategory::Str, addr)),
+                .map(|(term, addr, _)| (term, BytesOrNumerical::Bytes, addr)),
         );
-        field_columns.extend(
+        let mut key_buffer = Vec::new();
-            self.bool_field_hash_map
+        field_columns.sort_unstable_by_key(|(key, col_type, _)| (*key, *col_type));
-                .iter()
-                .map(|(term, addr, _)| (term, ColumnTypeCategory::Bool, addr)),
-        );
-        field_columns.sort_unstable_by_key(|(column_name, col_type, _)| (*column_name, *col_type));
         let (arena, buffers, dictionaries) = (&self.arena, &mut self.buffers, &self.dictionaries);
-        let mut symbol_byte_buffer: Vec<u8> = Vec::new();
+        for (key, bytes_or_numerical, addr) in field_columns {
-        for (column_name, bytes_or_numerical, addr) in field_columns {
+            let wrt = serializer.wrt();
-            match bytes_or_numerical {
+            let start_offset = wrt.written_bytes();
-                ColumnTypeCategory::Bool => {
+            let column_type_and_cardinality: ColumnTypeAndCardinality =
-                    let column_writer: ColumnWriter = self.bool_field_hash_map.read(addr);
+                match bytes_or_numerical {
-                    let cardinality = column_writer.get_cardinality(num_docs);
+                BytesOrNumerical::Bytes => {
-                    let column_type_and_cardinality = ColumnTypeAndCardinality {
+                    let BytesColumnWriter { dictionary_id, column_writer } =
-                        cardinality,
+                        self.bytes_field_hash_map.read(addr);
-                        typ: ColumnType::Bool,
-                    };
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, column_type_and_cardinality);
-                    serialize_bool_column(
-                        cardinality,
-                        num_docs,
-                        column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
-                        buffers,
-                        &mut column_serializer,
-                    )?;
-                }
-                ColumnTypeCategory::Str => {
-                    let str_column_writer: StrColumnWriter = self.bytes_field_hash_map.read(addr);
                     let dictionary_builder =
-                        &dictionaries[str_column_writer.dictionary_id as usize];
+                        &dictionaries[dictionary_id as usize];
-                    let cardinality = str_column_writer.column_writer.get_cardinality(num_docs);
-                    let column_type_and_cardinality = ColumnTypeAndCardinality {
-                        cardinality,
-                        typ: ColumnType::Bytes,
-                    };
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, column_type_and_cardinality);
                     serialize_bytes_column(
-                        cardinality,
+                        &column_writer,
                         num_docs,
                         dictionary_builder,
-                        str_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        arena,
                         buffers,
-                        &mut column_serializer,
+                        wrt,
                     )?;
+                    ColumnTypeAndCardinality {
+                        cardinality: column_writer.get_cardinality(num_docs),
+                        typ: ColumnType::Bytes,
+                    }
                 }
-                ColumnTypeCategory::Numerical => {
+                BytesOrNumerical::Numerical => {
-                    let numerical_column_writer: NumericalColumnWriter =
+                    let NumericalColumnWriter { compatible_numerical_types, column_writer  } =
                         self.numerical_field_hash_map.read(addr);
-                    let (numerical_type, cardinality) =
+                    let cardinality = column_writer.get_cardinality(num_docs);
-                        numerical_column_writer.column_type_and_cardinality(num_docs);
+                    let numerical_type = compatible_numerical_types.to_numerical_type();
-                    let column_type_and_cardinality = ColumnTypeAndCardinality {
-                        cardinality,
-                        typ: ColumnType::Numerical(numerical_type),
-                    };
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, column_type_and_cardinality);
                     serialize_numerical_column(
                         cardinality,
-                        num_docs,
                         numerical_type,
-                        numerical_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        &column_writer,
+                        num_docs,
+                        arena,
                         buffers,
-                        &mut column_serializer,
+                        wrt,
                     )?;
+                    ColumnTypeAndCardinality {
+                        cardinality,
+                        typ: ColumnType::Numerical(numerical_type),
+                    }
                 }
             };
+            let end_offset = wrt.written_bytes();
+            let key_with_type = prepare_key(key, column_type_and_cardinality, &mut key_buffer);
+            serializer.record_column_offsets(key_with_type, start_offset..end_offset)?;
         }
         serializer.finalize()?;
         Ok(())
     }
 }
 
-fn serialize_bytes_column(
+/// Returns a key consisting of the concatenation of the key and the column_type_and_cardinality
-    cardinality: Cardinality,
+/// code.
+fn prepare_key<'a>(
+    key: &[u8],
+    column_type_cardinality: ColumnTypeAndCardinality,
+    buffer: &'a mut Vec<u8>,
+) -> &'a [u8] {
+    buffer.clear();
+    buffer.extend_from_slice(key);
+    buffer.push(0u8);
+    buffer.push(column_type_cardinality.to_code());
+    &buffer[..]
+}
+
+fn serialize_bytes_column<W: io::Write>(
+    column_writer: &ColumnWriter,
     num_docs: DocId,
     dictionary_builder: &DictionaryBuilder,
-    operation_it: impl Iterator<Item = ColumnOperation<UnorderedId>>,
+    arena: &MemoryArena,
     buffers: &mut SpareBuffers,
-    wrt: impl io::Write,
+    wrt: &mut CountingWriter<W>,
 ) -> io::Result<()> {
+    let start_offset = wrt.written_bytes();
+    let id_mapping: IdMapping = dictionary_builder.serialize(wrt)?;
+    let dictionary_num_bytes: u32 = (wrt.written_bytes() - start_offset) as u32;
+    let cardinality = column_writer.get_cardinality(num_docs);
     let SpareBuffers {
+        byte_buffer,
         value_index_builders,
         u64_values,
         ..
     } = buffers;
-    let mut counting_writer = CountingWriter::wrap(wrt);
+    let symbol_iterator = column_writer
-    let term_id_mapping: TermIdMapping = dictionary_builder.serialize(&mut counting_writer)?;
+        .symbol_iterator(arena, byte_buffer)
-    let dictionary_num_bytes: u32 = counting_writer.written_bytes() as u32;
+        .map(|symbol: ColumnOperation<UnorderedId>| {
-    let mut wrt = counting_writer.finish();
+            // We map unordered ids to ordered ids.
-    let operation_iterator = operation_it.map(|symbol: ColumnOperation<UnorderedId>| {
+            match symbol {
-        // We map unordered ids to ordered ids.
+                ColumnOperation::Value(unordered_id) => {
-        match symbol {
+                    let ordered_id = id_mapping.to_ord(unordered_id);
-            ColumnOperation::Value(unordered_id) => {
+                    ColumnOperation::Value(ordered_id.0 as u64)
-                let ordered_id = term_id_mapping.to_ord(unordered_id);
+                }
-                ColumnOperation::Value(ordered_id.0 as u64)
+                ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
             }
-            ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
+        });
-        }
-    });
     serialize_column(
-        operation_iterator,
+        symbol_iterator,
         cardinality,
         num_docs,
         value_index_builders,
         u64_values,
-        &mut wrt,
+        wrt,
     )?;
     wrt.write_all(&dictionary_num_bytes.to_le_bytes()[..])?;
     Ok(())
 }
 
-fn serialize_numerical_column(
+fn serialize_numerical_column<W: io::Write>(
     cardinality: Cardinality,
-    num_docs: DocId,
     numerical_type: NumericalType,
-    op_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
+    column_writer: &ColumnWriter,
+    num_docs: DocId,
+    arena: &MemoryArena,
     buffers: &mut SpareBuffers,
-    wrt: &mut impl io::Write,
+    wrt: &mut W,
 ) -> io::Result<()> {
     let SpareBuffers {
+        byte_buffer,
         value_index_builders,
         u64_values,
         i64_values,
         f64_values,
-        ..
     } = buffers;
+    let symbol_iterator = column_writer.symbol_iterator(arena, byte_buffer);
     match numerical_type {
         NumericalType::I64 => {
             serialize_column(
-                coerce_numerical_symbol::<i64>(op_iterator),
+                coerce_numerical_symbol::<i64>(symbol_iterator),
                 cardinality,
                 num_docs,
                 value_index_builders,
@@ -282,7 +408,7 @@ fn serialize_numerical_column(
         }
         NumericalType::U64 => {
             serialize_column(
-                coerce_numerical_symbol::<u64>(op_iterator),
+                coerce_numerical_symbol::<u64>(symbol_iterator),
                 cardinality,
                 num_docs,
                 value_index_builders,
@@ -292,7 +418,7 @@ fn serialize_numerical_column(
         }
         NumericalType::F64 => {
             serialize_column(
-                coerce_numerical_symbol::<f64>(op_iterator),
+                coerce_numerical_symbol::<NotNan<f64>>(symbol_iterator),
                 cardinality,
                 num_docs,
                 value_index_builders,
@@ -304,75 +430,52 @@ fn serialize_numerical_column(
     Ok(())
 }
 
-fn serialize_bool_column(
-    cardinality: Cardinality,
-    num_docs: DocId,
-    column_operations_it: impl Iterator<Item = ColumnOperation<bool>>,
-    buffers: &mut SpareBuffers,
-    wrt: &mut impl io::Write,
-) -> io::Result<()> {
-    let SpareBuffers {
-        value_index_builders,
-        bool_values,
-        ..
-    } = buffers;
-    serialize_column(
-        column_operations_it,
-        cardinality,
-        num_docs,
-        value_index_builders,
-        bool_values,
-        wrt,
-    )?;
-    Ok(())
-}
-
 fn serialize_column<
-    T: Copy + Default + std::fmt::Debug + Send + Sync + MonotonicallyMappableToU64 + PartialOrd,
+    T: Copy + Ord + Default + Send + Sync + MonotonicallyMappableToU64,
+    W: io::Write,
 >(
-    op_iterator: impl Iterator<Item = ColumnOperation<T>>,
+    symbol_iterator: impl Iterator<Item = ColumnOperation<T>>,
     cardinality: Cardinality,
     num_docs: DocId,
     value_index_builders: &mut SpareIndexBuilders,
     values: &mut Vec<T>,
-    mut wrt: impl io::Write,
+    wrt: &mut W,
 ) -> io::Result<()>
 where
     for<'a> VecColumn<'a, T>: Column<T>,
 {
-    values.clear();
     match cardinality {
         Cardinality::Required => {
-            consume_operation_iterator(
+            consume_symbol_iterator(
-                op_iterator,
+                symbol_iterator,
                 value_index_builders.borrow_required_index_builder(),
                 values,
             );
             fastfield_codecs::serialize(
                 VecColumn::from(&values[..]),
-                &mut wrt,
+                wrt,
                 &fastfield_codecs::ALL_CODEC_TYPES[..],
             )?;
         }
         Cardinality::Optional => {
             let optional_index_builder = value_index_builders.borrow_optional_index_builder();
-            consume_operation_iterator(op_iterator, optional_index_builder, values);
+            consume_symbol_iterator(symbol_iterator, optional_index_builder, values);
             let optional_index = optional_index_builder.finish(num_docs);
             fastfield_codecs::serialize::serialize_new(
                 ValueIndexInfo::SingleValue(Box::new(optional_index)),
                 VecColumn::from(&values[..]),
-                &mut wrt,
+                wrt,
                 &fastfield_codecs::ALL_CODEC_TYPES[..],
             )?;
         }
         Cardinality::Multivalued => {
             let multivalued_index_builder = value_index_builders.borrow_multivalued_index_builder();
-            consume_operation_iterator(op_iterator, multivalued_index_builder, values);
+            consume_symbol_iterator(symbol_iterator, multivalued_index_builder, values);
             let multivalued_index = multivalued_index_builder.finish(num_docs);
             fastfield_codecs::serialize::serialize_new(
                 ValueIndexInfo::MultiValue(Box::new(multivalued_index)),
                 VecColumn::from(&values[..]),
-                &mut wrt,
+                wrt,
                 &fastfield_codecs::ALL_CODEC_TYPES[..],
             )?;
         }
@@ -381,10 +484,10 @@ where
 }
 
 fn coerce_numerical_symbol<T>(
-    operation_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
+    symbol_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
 ) -> impl Iterator<Item = ColumnOperation<T>>
 where T: Coerce {
-    operation_iterator.map(|symbol| match symbol {
+    symbol_iterator.map(|symbol| match symbol {
         ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
         ColumnOperation::Value(numerical_value) => {
             ColumnOperation::Value(Coerce::coerce(numerical_value))
@@ -392,12 +495,12 @@ where T: Coerce {
     })
 }
 
-fn consume_operation_iterator<T: std::fmt::Debug, TIndexBuilder: IndexBuilder>(
+fn consume_symbol_iterator<T, TIndexBuilder: IndexBuilder>(
-    operation_iterator: impl Iterator<Item = ColumnOperation<T>>,
+    symbol_iterator: impl Iterator<Item = ColumnOperation<T>>,
     index_builder: &mut TIndexBuilder,
     values: &mut Vec<T>,
 ) {
-    for symbol in operation_iterator {
+    for symbol in symbol_iterator {
         match symbol {
             ColumnOperation::NewDoc(doc) => {
                 index_builder.record_doc(doc);
@@ -412,24 +515,42 @@ fn consume_operation_iterator<T: std::fmt::Debug, TIndexBuilder: IndexBuilder>(
 
 #[cfg(test)]
 mod tests {
-    use column_operation::ColumnOperation;
+
+    use ordered_float::NotNan;
     use stacker::MemoryArena;
 
-    use super::*;
+    use super::prepare_key;
-    use crate::value::NumericalValue;
+    use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality};
+    use crate::value::{NumericalType, NumericalValue};
+    use crate::writer::column_operation::ColumnOperation;
+    use crate::writer::CompatibleNumericalTypes;
     use crate::Cardinality;
 
+    #[test]
+    fn test_prepare_key_bytes() {
+        let mut buffer: Vec<u8> = b"somegarbage".to_vec();
+        let column_type_and_cardinality = ColumnTypeAndCardinality {
+            typ: ColumnType::Bytes,
+            cardinality: Cardinality::Optional,
+        };
+        let prepared_key = prepare_key(b"root\0child", column_type_and_cardinality, &mut buffer);
+        assert_eq!(prepared_key.len(), 12);
+        assert_eq!(&prepared_key[..10], b"root\0child");
+        assert_eq!(prepared_key[10], 0u8);
+        assert_eq!(prepared_key[11], column_type_and_cardinality.to_code());
+    }
+
     #[test]
     fn test_column_writer_required_simple() {
         let mut arena = MemoryArena::default();
         let mut column_writer = super::ColumnWriter::default();
-        column_writer.record(0u32, NumericalValue::from(14i64), &mut arena);
+        column_writer.record(0u32, 14i64.into(), &mut arena);
-        column_writer.record(1u32, NumericalValue::from(15i64), &mut arena);
+        column_writer.record(1u32, 15i64.into(), &mut arena);
-        column_writer.record(2u32, NumericalValue::from(-16i64), &mut arena);
+        column_writer.record(2u32, (-16i64).into(), &mut arena);
         assert_eq!(column_writer.get_cardinality(3), Cardinality::Required);
         let mut buffer = Vec::new();
         let symbols: Vec<ColumnOperation<NumericalValue>> = column_writer
-            .operation_iterator(&mut arena, &mut buffer)
+            .symbol_iterator(&mut arena, &mut buffer)
             .collect();
         assert_eq!(symbols.len(), 6);
         assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
@@ -453,12 +574,12 @@ mod tests {
     fn test_column_writer_optional_cardinality_missing_first() {
         let mut arena = MemoryArena::default();
         let mut column_writer = super::ColumnWriter::default();
-        column_writer.record(1u32, NumericalValue::from(15i64), &mut arena);
+        column_writer.record(1u32, 15i64.into(), &mut arena);
-        column_writer.record(2u32, NumericalValue::from(-16i64), &mut arena);
+        column_writer.record(2u32, (-16i64).into(), &mut arena);
         assert_eq!(column_writer.get_cardinality(3), Cardinality::Optional);
         let mut buffer = Vec::new();
         let symbols: Vec<ColumnOperation<NumericalValue>> = column_writer
-            .operation_iterator(&mut arena, &mut buffer)
+            .symbol_iterator(&mut arena, &mut buffer)
             .collect();
         assert_eq!(symbols.len(), 4);
         assert!(matches!(symbols[0], ColumnOperation::NewDoc(1u32)));
@@ -477,11 +598,11 @@ mod tests {
     fn test_column_writer_optional_cardinality_missing_last() {
         let mut arena = MemoryArena::default();
         let mut column_writer = super::ColumnWriter::default();
-        column_writer.record(0u32, NumericalValue::from(15i64), &mut arena);
+        column_writer.record(0u32, 15i64.into(), &mut arena);
         assert_eq!(column_writer.get_cardinality(2), Cardinality::Optional);
         let mut buffer = Vec::new();
         let symbols: Vec<ColumnOperation<NumericalValue>> = column_writer
-            .operation_iterator(&mut arena, &mut buffer)
+            .symbol_iterator(&mut arena, &mut buffer)
             .collect();
         assert_eq!(symbols.len(), 2);
         assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
@@ -495,12 +616,12 @@ mod tests {
     fn test_column_writer_multivalued() {
         let mut arena = MemoryArena::default();
         let mut column_writer = super::ColumnWriter::default();
-        column_writer.record(0u32, NumericalValue::from(16i64), &mut arena);
+        column_writer.record(0u32, 16i64.into(), &mut arena);
-        column_writer.record(0u32, NumericalValue::from(17i64), &mut arena);
+        column_writer.record(0u32, 17i64.into(), &mut arena);
         assert_eq!(column_writer.get_cardinality(1), Cardinality::Multivalued);
         let mut buffer = Vec::new();
         let symbols: Vec<ColumnOperation<NumericalValue>> = column_writer
-            .operation_iterator(&mut arena, &mut buffer)
+            .symbol_iterator(&mut arena, &mut buffer)
             .collect();
         assert_eq!(symbols.len(), 3);
         assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
@@ -513,4 +634,42 @@ mod tests {
             ColumnOperation::Value(NumericalValue::I64(17i64))
         ));
     }
+
+    #[track_caller]
+    fn test_column_writer_coercion_iter_aux(
+        values: impl Iterator<Item = NumericalValue>,
+        expected_numerical_type: NumericalType,
+    ) {
+        let mut compatible_numerical_types = CompatibleNumericalTypes::default();
+        for value in values {
+            compatible_numerical_types.accept_value(value);
+        }
+        assert_eq!(
+            compatible_numerical_types.to_numerical_type(),
+            expected_numerical_type
+        );
+    }
+
+    #[track_caller]
+    fn test_column_writer_coercion_aux(
+        values: &[NumericalValue],
+        expected_numerical_type: NumericalType,
+    ) {
+        test_column_writer_coercion_iter_aux(values.iter().copied(), expected_numerical_type);
+        test_column_writer_coercion_iter_aux(values.iter().rev().copied(), expected_numerical_type);
+    }
+
+    #[test]
+    fn test_column_writer_coercion() {
+        test_column_writer_coercion_aux(&[], NumericalType::I64);
+        test_column_writer_coercion_aux(&[1i64.into()], NumericalType::I64);
+        test_column_writer_coercion_aux(&[1u64.into()], NumericalType::I64);
+        // We don't detect exact integer at the moment. We could!
+        test_column_writer_coercion_aux(&[NotNan::new(1f64).unwrap().into()], NumericalType::F64);
+        test_column_writer_coercion_aux(&[u64::MAX.into()], NumericalType::U64);
+        test_column_writer_coercion_aux(&[(i64::MAX as u64).into()], NumericalType::U64);
+        test_column_writer_coercion_aux(&[(1u64 << 63).into()], NumericalType::U64);
+        test_column_writer_coercion_aux(&[1i64.into(), 1u64.into()], NumericalType::I64);
+        test_column_writer_coercion_aux(&[u64::MAX.into(), (-1i64).into()], NumericalType::F64);
+    }
 }

columnar/src/writer/serializer.rs

@@ -1,116 +0,0 @@
-use std::io;
-use std::io::Write;
-
-use common::CountingWriter;
-use sstable::value::RangeValueWriter;
-use sstable::RangeSSTable;
-
-use crate::column_type_header::ColumnTypeAndCardinality;
-
-pub struct ColumnarSerializer<W: io::Write> {
-    wrt: CountingWriter<W>,
-    sstable_range: sstable::Writer<Vec<u8>, RangeValueWriter>,
-    prepare_key_buffer: Vec<u8>,
-}
-
-/// Returns a key consisting of the concatenation of the key and the column_type_and_cardinality
-/// code.
-fn prepare_key(
-    key: &[u8],
-    column_type_cardinality: ColumnTypeAndCardinality,
-    buffer: &mut Vec<u8>,
-) {
-    buffer.clear();
-    buffer.extend_from_slice(key);
-    buffer.push(0u8);
-    buffer.push(column_type_cardinality.to_code());
-}
-
-impl<W: io::Write> ColumnarSerializer<W> {
-    pub(crate) fn new(wrt: W) -> ColumnarSerializer<W> {
-        let sstable_range: sstable::Writer<Vec<u8>, RangeValueWriter> =
-            sstable::Dictionary::<RangeSSTable>::builder(Vec::with_capacity(100_000)).unwrap();
-        ColumnarSerializer {
-            wrt: CountingWriter::wrap(wrt),
-            sstable_range,
-            prepare_key_buffer: Vec::new(),
-        }
-    }
-
-    pub fn serialize_column<'a>(
-        &'a mut self,
-        column_name: &[u8],
-        column_type_cardinality: ColumnTypeAndCardinality,
-    ) -> impl io::Write + 'a {
-        let start_offset = self.wrt.written_bytes();
-        prepare_key(
-            column_name,
-            column_type_cardinality,
-            &mut self.prepare_key_buffer,
-        );
-        ColumnSerializer {
-            columnar_serializer: self,
-            start_offset,
-        }
-    }
-
-    pub(crate) fn finalize(mut self) -> io::Result<()> {
-        let sstable_bytes: Vec<u8> = self.sstable_range.finish()?;
-        let sstable_num_bytes: u64 = sstable_bytes.len() as u64;
-        self.wrt.write_all(&sstable_bytes)?;
-        self.wrt.write_all(&sstable_num_bytes.to_le_bytes()[..])?;
-        Ok(())
-    }
-}
-
-struct ColumnSerializer<'a, W: io::Write> {
-    columnar_serializer: &'a mut ColumnarSerializer<W>,
-    start_offset: u64,
-}
-
-impl<'a, W: io::Write> Drop for ColumnSerializer<'a, W> {
-    fn drop(&mut self) {
-        let end_offset: u64 = self.columnar_serializer.wrt.written_bytes();
-        let byte_range = self.start_offset..end_offset;
-        self.columnar_serializer.sstable_range.insert_cannot_fail(
-            &self.columnar_serializer.prepare_key_buffer[..],
-            &byte_range,
-        );
-        self.columnar_serializer.prepare_key_buffer.clear();
-    }
-}
-
-impl<'a, W: io::Write> io::Write for ColumnSerializer<'a, W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.columnar_serializer.wrt.write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.columnar_serializer.wrt.flush()
-    }
-
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.columnar_serializer.wrt.write_all(buf)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::column_type_header::ColumnType;
-    use crate::Cardinality;
-
-    #[test]
-    fn test_prepare_key_bytes() {
-        let mut buffer: Vec<u8> = b"somegarbage".to_vec();
-        let column_type_and_cardinality = ColumnTypeAndCardinality {
-            typ: ColumnType::Bytes,
-            cardinality: Cardinality::Optional,
-        };
-        prepare_key(b"root\0child", column_type_and_cardinality, &mut buffer);
-        assert_eq!(buffer.len(), 12);
-        assert_eq!(&buffer[..10], b"root\0child");
-        assert_eq!(buffer[10], 0u8);
-        assert_eq!(buffer[11], column_type_and_cardinality.to_code());
-    }
-}

columnar/src/writer/value_index.rs

@@ -5,7 +5,7 @@ use crate::DocId;
 /// The `IndexBuilder` interprets a sequence of
 /// calls of the form:
 /// (record_doc,record_value+)*
-/// and can then serialize the results into an index to associate docids with their value[s].
+/// and can then serialize the results into an index.
 ///
 /// It has different implementation depending on whether the
 /// cardinality is required, optional, or multivalued.
@@ -30,7 +30,6 @@ pub struct OptionalIndexBuilder {
 }
 
 struct SingleValueArrayIndex<'a> {
-    // DocIds with a value. DocIds are strictly increasing
     docs: &'a [DocId],
     num_docs: DocId,
 }
@@ -84,8 +83,7 @@ impl IndexBuilder for OptionalIndexBuilder {
 #[derive(Default)]
 pub struct MultivaluedIndexBuilder {
     // TODO should we switch to `start_offset`?
-    // contains the num values so far for each `DocId`.
+    end_values: Vec<DocId>,
-    end_offsets: Vec<DocId>,
     total_num_vals_seen: u32,
 }
 
@@ -113,22 +111,22 @@ impl<'a> MultiValueIndexInfo for MultivaluedValueArrayIndex<'a> {
 
 impl MultivaluedIndexBuilder {
     pub fn finish(&mut self, num_docs: DocId) -> impl MultiValueIndexInfo + '_ {
-        self.end_offsets
+        self.end_values
             .resize(num_docs as usize, self.total_num_vals_seen);
         MultivaluedValueArrayIndex {
-            end_offsets: &self.end_offsets[..],
+            end_offsets: &self.end_values[..],
         }
     }
 
     fn reset(&mut self) {
-        self.end_offsets.clear();
+        self.end_values.clear();
         self.total_num_vals_seen = 0;
     }
 }
 
 impl IndexBuilder for MultivaluedIndexBuilder {
     fn record_doc(&mut self, doc: DocId) {
-        self.end_offsets
+        self.end_values
             .resize(doc as usize, self.total_num_vals_seen);
     }
 

common/src/file_slice.rs

@@ -24,11 +24,8 @@ pub trait FileHandle: 'static + Send + Sync + HasLen + fmt::Debug {
     fn read_bytes(&self, range: Range<usize>) -> io::Result<OwnedBytes>;
 
     #[doc(hidden)]
-    async fn read_bytes_async(&self, _byte_range: Range<usize>) -> io::Result<OwnedBytes> {
+    async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
-        Err(io::Error::new(
+        self.read_bytes(byte_range)
-            io::ErrorKind::Unsupported,
-            "Async read is not supported.",
-        ))
     }
 }
 
@@ -39,6 +36,7 @@ impl FileHandle for &'static [u8] {
         Ok(OwnedBytes::new(bytes))
     }
 
+    #[cfg(feature = "quickwit")]
     async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
         Ok(self.read_bytes(byte_range)?)
     }
@@ -67,16 +65,7 @@ impl fmt::Debug for FileSlice {
     }
 }
 
-/// Takes a range, a `RangeBounds` object, and returns
+#[inline]
-/// a `Range` that corresponds to the relative application of the
-/// `RangeBounds` object to the original `Range`.
-///
-/// For instance, combine_ranges(`[2..11)`, `[5..7]`) returns `[7..10]`
-/// as it reads, what is the sub-range that starts at the 5 element of
-/// `[2..11)` and ends at the 9th element included.
-///
-/// This function panics, if the result would suggest something outside
-/// of the bounds of the original range.
 fn combine_ranges<R: RangeBounds<usize>>(orig_range: Range<usize>, rel_range: R) -> Range<usize> {
     let start: usize = orig_range.start
         + match rel_range.start_bound().cloned() {
@@ -224,6 +213,7 @@ impl FileHandle for FileSlice {
         self.read_bytes_slice(range)
     }
 
+    #[cfg(feature = "quickwit")]
     async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
         self.read_bytes_slice_async(byte_range).await
     }
@@ -241,15 +231,16 @@ impl FileHandle for OwnedBytes {
         Ok(self.slice(range))
     }
 
+    #[cfg(feature = "quickwit")]
     async fn read_bytes_async(&self, range: Range<usize>) -> io::Result<OwnedBytes> {
-        self.read_bytes(range)
+        let bytes = self.read_bytes(range)?;
+        Ok(bytes)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use std::io;
-    use std::ops::Bound;
     use std::sync::Arc;
 
     use super::{FileHandle, FileSlice};
@@ -332,11 +323,6 @@ mod tests {
         assert_eq!(combine_ranges(1..3, 1..), 2..3);
         assert_eq!(combine_ranges(1..4, ..2), 1..3);
         assert_eq!(combine_ranges(3..10, 2..5), 5..8);
-        assert_eq!(combine_ranges(2..11, 5..=7), 7..10);
-        assert_eq!(
-            combine_ranges(2..11, (Bound::Excluded(5), Bound::Unbounded)),
-            8..11
-        );
     }
 
     #[test]

common/src/group_by.rs

@@ -1,166 +0,0 @@
-use std::cell::RefCell;
-use std::iter::Peekable;
-use std::rc::Rc;
-
-pub trait GroupByIteratorExtended: Iterator {
-    /// Return an `Iterator` that groups iterator elements. Consecutive elements that map to the
-    /// same key are assigned to the same group.
-    ///
-    /// The returned Iterator item is `(K, impl Iterator)`, where Iterator are the items of the
-    /// group.
-    ///
-    /// ```
-    /// use tantivy_common::GroupByIteratorExtended;
-    ///
-    /// // group data into blocks of larger than zero or not.
-    /// let data: Vec<i32> = vec![1, 3, -2, -2, 1, 0, 1, 2];
-    /// // groups:               |---->|------>|--------->|
-    ///
-    /// let mut data_grouped = Vec::new();
-    /// // Note: group is an iterator
-    /// for (key, group) in data.into_iter().group_by(|val| *val >= 0) {
-    ///     data_grouped.push((key, group.collect()));
-    /// }
-    /// assert_eq!(data_grouped, vec![(true, vec![1, 3]), (false, vec![-2, -2]), (true, vec![1, 0, 1, 2])]);
-    /// ```
-    fn group_by<K, F>(self, key: F) -> GroupByIterator<Self, F, K>
-    where
-        Self: Sized,
-        F: FnMut(&Self::Item) -> K,
-        K: PartialEq + Copy,
-        Self::Item: Copy,
-    {
-        GroupByIterator::new(self, key)
-    }
-}
-impl<I: Iterator> GroupByIteratorExtended for I {}
-
-pub struct GroupByIterator<I, F, K: Copy>
-where
-    I: Iterator,
-    F: FnMut(&I::Item) -> K,
-{
-    // I really would like to avoid the Rc<RefCell>, but the Iterator is shared between
-    // `GroupByIterator` and `GroupIter`. In practice they are used consecutive and
-    // `GroupByIter` is finished before calling next on `GroupByIterator`. I'm not sure there
-    // is a solution with lifetimes for that, because we would need to enforce it in the usage
-    // somehow.
-    //
-    // One potential solution would be to replace the iterator approach with something similar.
-    inner: Rc<RefCell<GroupByShared<I, F, K>>>,
-}
-
-struct GroupByShared<I, F, K: Copy>
-where
-    I: Iterator,
-    F: FnMut(&I::Item) -> K,
-{
-    iter: Peekable<I>,
-    group_by_fn: F,
-}
-
-impl<I, F, K> GroupByIterator<I, F, K>
-where
-    I: Iterator,
-    F: FnMut(&I::Item) -> K,
-    K: Copy,
-{
-    fn new(inner: I, group_by_fn: F) -> Self {
-        let inner = GroupByShared {
-            iter: inner.peekable(),
-            group_by_fn,
-        };
-
-        Self {
-            inner: Rc::new(RefCell::new(inner)),
-        }
-    }
-}
-
-impl<I, F, K> Iterator for GroupByIterator<I, F, K>
-where
-    I: Iterator,
-    I::Item: Copy,
-    F: FnMut(&I::Item) -> K,
-    K: Copy,
-{
-    type Item = (K, GroupIterator<I, F, K>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let mut inner = self.inner.borrow_mut();
-        let value = *inner.iter.peek()?;
-        let key = (inner.group_by_fn)(&value);
-
-        let inner = self.inner.clone();
-
-        let group_iter = GroupIterator {
-            inner,
-            group_key: key,
-        };
-        Some((key, group_iter))
-    }
-}
-
-pub struct GroupIterator<I, F, K: Copy>
-where
-    I: Iterator,
-    F: FnMut(&I::Item) -> K,
-{
-    inner: Rc<RefCell<GroupByShared<I, F, K>>>,
-    group_key: K,
-}
-
-impl<I, F, K: PartialEq + Copy> Iterator for GroupIterator<I, F, K>
-where
-    I: Iterator,
-    I::Item: Copy,
-    F: FnMut(&I::Item) -> K,
-{
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let mut inner = self.inner.borrow_mut();
-        // peek if next value is in group
-        let peek_val = *inner.iter.peek()?;
-        if (inner.group_by_fn)(&peek_val) == self.group_key {
-            inner.iter.next()
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn group_by_collect<I: Iterator<Item = u32>>(iter: I) -> Vec<(I::Item, Vec<I::Item>)> {
-        iter.group_by(|val| val / 10)
-            .map(|(el, iter)| (el, iter.collect::<Vec<_>>()))
-            .collect::<Vec<_>>()
-    }
-
-    #[test]
-    fn group_by_two_groups() {
-        let vals = vec![1u32, 4, 15];
-        let grouped_vals = group_by_collect(vals.into_iter());
-        assert_eq!(grouped_vals, vec![(0, vec![1, 4]), (1, vec![15])]);
-    }
-
-    #[test]
-    fn group_by_test_empty() {
-        let vals = vec![];
-        let grouped_vals = group_by_collect(vals.into_iter());
-        assert_eq!(grouped_vals, vec![]);
-    }
-
-    #[test]
-    fn group_by_three_groups() {
-        let vals = vec![1u32, 4, 15, 1];
-        let grouped_vals = group_by_collect(vals.into_iter());
-        assert_eq!(
-            grouped_vals,
-            vec![(0, vec![1, 4]), (1, vec![15]), (0, vec![1])]
-        );
-    }
-}

common/src/lib.rs

@@ -6,13 +6,11 @@ pub use byteorder::LittleEndian as Endianness;
 
 mod bitset;
 pub mod file_slice;
-mod group_by;
 mod serialize;
 mod vint;
 mod writer;
 pub use bitset::*;
-pub use group_by::GroupByIteratorExtended;
+pub use ownedbytes::OwnedBytes;
-pub use ownedbytes::{OwnedBytes, StableDeref};
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
 pub use vint::{
     deserialize_vint_u128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u128,

examples/faceted_search.rs

@@ -1,17 +1,15 @@
-// # Faceted Search
+// # Basic Example
 //
-// This example covers the faceted search functionalities of
+// This example covers the basic functionalities of
 // tantivy.
 //
 // We will :
-// - define a text field "name" in our schema
+// - define our schema
-// - define a facet field "classification" in our schema
+// = create an index in a directory
-// - create an index in memory
+// - index few documents in our index
-// - index few documents with respective facets in our index
+// - search for the best document matchings "sea whale"
-// - search and count the number of documents that the classifications start the facet "/Felidae"
+// - retrieve the best document original content.
-// - Search the facet "/Felidae/Pantherinae" and count the number of documents that the
+
-//   classifications include the facet.
-//
 // ---
 // Importing tantivy...
 use tantivy::collector::FacetCollector;
@@ -23,7 +21,7 @@ fn main() -> tantivy::Result<()> {
     // Let's create a temporary directory for the sake of this example
     let mut schema_builder = Schema::builder();
 
-    let name = schema_builder.add_text_field("name", TEXT | STORED);
+    let name = schema_builder.add_text_field("felin_name", TEXT | STORED);
     // this is our faceted field: its scientific classification
     let classification = schema_builder.add_facet_field("classification", FacetOptions::default());
 

fastfield_codecs/Cargo.toml

@@ -14,12 +14,14 @@ repository = "https://github.com/quickwit-oss/tantivy"
 [dependencies]
 common = { version = "0.5", path = "../common/", package = "tantivy-common" }
 tantivy-bitpacker = { version= "0.3", path = "../bitpacker/" }
-prettytable-rs = {version="0.10.0", optional= true}
+ownedbytes = { version = "0.5", path = "../ownedbytes" }
+prettytable-rs = {version="0.9.0", optional= true}
 rand = {version="0.8.3", optional= true}
 fastdivide = "0.4"
 log = "0.4"
 itertools = { version = "0.10.3" }
 measure_time = { version="0.8.2", optional=true}
+ordered-float = "3.4"
 
 [dev-dependencies]
 more-asserts = "0.3.0"

fastfield_codecs/benches/bench.rs

@@ -4,11 +4,11 @@ extern crate test;
 
 #[cfg(test)]
 mod tests {
-    use std::ops::RangeInclusive;
+    use std::iter;
     use std::sync::Arc;
 
-    use common::OwnedBytes;
     use fastfield_codecs::*;
+    use ownedbytes::OwnedBytes;
     use rand::prelude::*;
     use test::Bencher;
 
@@ -71,24 +71,27 @@ mod tests {
         });
     }
 
-    const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
+    fn get_exp_data() -> Vec<u64> {
-    const SINGLE_ITEM: u64 = 90;
-    const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
-    const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
-    fn get_data_50percent_item() -> Vec<u128> {
-        let mut rng = StdRng::from_seed([1u8; 32]);
-
         let mut data = vec![];
-        for _ in 0..300_000 {
+        for i in 0..100 {
-            let val = rng.gen_range(1..=100);
+            let num = i * i;
-            data.push(val);
+            data.extend(iter::repeat(i as u64).take(num));
         }
-        data.push(SINGLE_ITEM);
+        data.shuffle(&mut StdRng::from_seed([1u8; 32]));
 
-        data.shuffle(&mut rng);
+        // lengt = 328350
-        let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
         data
     }
+
+    fn get_data_50percent_item() -> (u128, u128, Vec<u128>) {
+        let mut permutation = get_exp_data();
+        let major_item = 20;
+        let minor_item = 10;
+        permutation.extend(iter::repeat(major_item).take(permutation.len()));
+        permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
+        let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
+        (major_item as u128, minor_item as u128, permutation)
+    }
     fn get_u128_column_random() -> Arc<dyn Column<u128>> {
         let permutation = generate_random();
         let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
@@ -103,82 +106,15 @@ mod tests {
         open_u128::<u128>(out).unwrap()
     }
 
-    // U64 RANGE START
-    #[bench]
-    fn bench_intfastfield_getrange_u64_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                FIFTY_PERCENT_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_1percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                ONE_PERCENT_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                SINGLE_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(0..=u64::MAX, 0..data.len() as u32, &mut positions);
-            positions
-        });
-    }
-    // U64 RANGE END
-
-    // U128 RANGE START
     #[bench]
     fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
+        let (major_item, _minor_item, data) = get_data_50percent_item();
         let column = get_u128_column_from_data(&data);
 
         b.iter(|| {
             let mut positions = Vec::new();
             column.get_docids_for_value_range(
-                *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
+                major_item..=major_item,
                 0..data.len() as u32,
                 &mut positions,
             );
@@ -188,13 +124,13 @@ mod tests {
 
     #[bench]
     fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
+        let (_major_item, minor_item, data) = get_data_50percent_item();
         let column = get_u128_column_from_data(&data);
 
         b.iter(|| {
             let mut positions = Vec::new();
             column.get_docids_for_value_range(
-                *SINGLE_ITEM_RANGE.start() as u128..=*SINGLE_ITEM_RANGE.end() as u128,
+                minor_item..=minor_item,
                 0..data.len() as u32,
                 &mut positions,
             );
@@ -204,7 +140,7 @@ mod tests {
 
     #[bench]
     fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
+        let (_major_item, _minor_item, data) = get_data_50percent_item();
         let column = get_u128_column_from_data(&data);
 
         b.iter(|| {
@@ -213,7 +149,6 @@ mod tests {
             positions
         });
     }
-    // U128 RANGE END
 
     #[bench]
     fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {

fastfield_codecs/src/bitpacked.rs

@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 
-use common::OwnedBytes;
+use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::serialize::NormalizedHeader;

fastfield_codecs/src/blockwise_linear.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 use std::{io, iter};
 
-use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
+use common::{BinarySerializable, CountingWriter, DeserializeFrom};
+use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::line::Line;
@@ -46,7 +47,7 @@ impl FastFieldCodec for BlockwiseLinearCodec {
     type Reader = BlockwiseLinearReader;
 
     fn open_from_bytes(
-        bytes: common::OwnedBytes,
+        bytes: ownedbytes::OwnedBytes,
         normalized_header: NormalizedHeader,
     ) -> io::Result<Self::Reader> {
         let footer_len: u32 = (&bytes[bytes.len() - 4..]).deserialize()?;
@@ -170,18 +171,15 @@ impl Column for BlockwiseLinearReader {
         interpoled_val.wrapping_add(bitpacked_diff)
     }
 
-    #[inline(always)]
     fn min_value(&self) -> u64 {
         // The BlockwiseLinearReader assumes a normalized vector.
         0u64
     }
 
-    #[inline(always)]
     fn max_value(&self) -> u64 {
         self.normalized_header.max_value
     }
 
-    #[inline(always)]
     fn num_vals(&self) -> u32 {
         self.normalized_header.num_vals
     }

fastfield_codecs/src/column.rs

@@ -1,4 +1,3 @@
-use std::fmt::{self, Debug};
 use std::marker::PhantomData;
 use std::ops::{Range, RangeInclusive};
 
@@ -7,7 +6,7 @@ use tantivy_bitpacker::minmax;
 use crate::monotonic_mapping::StrictlyMonotonicFn;
 
 /// `Column` provides columnar access on a field.
-pub trait Column<T: PartialOrd + Debug = u64>: Send + Sync {
+pub trait Column<T: PartialOrd = u64>: Send + Sync {
     /// Return the value associated with the given idx.
     ///
     /// This accessor should return as fast as possible.
@@ -35,10 +34,6 @@ pub trait Column<T: PartialOrd + Debug = u64>: Send + Sync {
     /// Get the positions of values which are in the provided value range.
     ///
     /// Note that position == docid for single value fast fields
-    ///
-    /// # Truncation
-    /// `DateTime` has a truncation setting. This function should get passed the truncated values
-    /// to avoid unexpected results.
     #[inline]
     fn get_docids_for_value_range(
         &self,
@@ -88,7 +83,7 @@ pub struct VecColumn<'a, T = u64> {
     max_value: T,
 }
 
-impl<'a, C: Column<T>, T: Copy + PartialOrd + fmt::Debug> Column<T> for &'a C {
+impl<'a, C: Column<T>, T: Copy + PartialOrd> Column<T> for &'a C {
     fn get_val(&self, idx: u32) -> T {
         (*self).get_val(idx)
     }
@@ -114,7 +109,7 @@ impl<'a, C: Column<T>, T: Copy + PartialOrd + fmt::Debug> Column<T> for &'a C {
     }
 }
 
-impl<'a, T: Copy + PartialOrd + Send + Sync + Debug> Column<T> for VecColumn<'a, T> {
+impl<'a, T: Copy + PartialOrd + Send + Sync> Column<T> for VecColumn<'a, T> {
     fn get_val(&self, position: u32) -> T {
         self.values[position as usize]
     }
@@ -140,9 +135,8 @@ impl<'a, T: Copy + PartialOrd + Send + Sync + Debug> Column<T> for VecColumn<'a,
     }
 }
 
-impl<'a, T: Copy + PartialOrd + Default, V> From<&'a V> for VecColumn<'a, T>
+impl<'a, T: Copy + Ord + Default, V> From<&'a V> for VecColumn<'a, T>
-where
+where V: AsRef<[T]> + ?Sized
-    V: AsRef<[T]> + ?Sized,
 {
     fn from(values: &'a V) -> Self {
         let values = values.as_ref();
@@ -183,8 +177,8 @@ pub fn monotonic_map_column<C, T, Input, Output>(
 where
     C: Column<Input>,
     T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
-    Input: PartialOrd + Send + Sync + Copy + Debug,
+    Input: PartialOrd + Send + Sync + Clone,
-    Output: PartialOrd + Send + Sync + Copy + Debug,
+    Output: PartialOrd + Send + Sync + Clone,
 {
     MonotonicMappingColumn {
         from_column,
@@ -197,8 +191,8 @@ impl<C, T, Input, Output> Column<Output> for MonotonicMappingColumn<C, T, Input>
 where
     C: Column<Input>,
     T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
-    Input: PartialOrd + Send + Sync + Copy + Debug,
+    Input: PartialOrd + Send + Sync + Clone,
-    Output: PartialOrd + Send + Sync + Copy + Debug,
+    Output: PartialOrd + Send + Sync + Clone,
 {
     #[inline]
     fn get_val(&self, idx: u32) -> Output {
@@ -234,15 +228,12 @@ where
         doc_id_range: Range<u32>,
         positions: &mut Vec<u32>,
     ) {
-        if range.start() > &self.max_value() || range.end() < &self.min_value() {
+        self.from_column.get_docids_for_value_range(
-            return;
+            self.monotonic_mapping.inverse(range.start().clone())
-        }
+                ..=self.monotonic_mapping.inverse(range.end().clone()),
-        let range = self.monotonic_mapping.inverse_coerce(range);
+            doc_id_range,
-        if range.start() > range.end() {
+            positions,
-            return;
+        )
-        }
-        self.from_column
-            .get_docids_for_value_range(range, doc_id_range, positions)
     }
 
     // We voluntarily do not implement get_range as it yields a regression,
@@ -253,8 +244,7 @@ where
 pub struct IterColumn<T>(T);
 
 impl<T> From<T> for IterColumn<T>
-where
+where T: Iterator + Clone + ExactSizeIterator
-    T: Iterator + Clone + ExactSizeIterator,
 {
     fn from(iter: T) -> Self {
         IterColumn(iter)
@@ -264,7 +254,7 @@ where
 impl<T> Column<T::Item> for IterColumn<T>
 where
     T: Iterator + Clone + ExactSizeIterator + Send + Sync,
-    T::Item: PartialOrd + fmt::Debug,
+    T::Item: PartialOrd,
 {
     fn get_val(&self, idx: u32) -> T::Item {
         self.0.clone().nth(idx as usize).unwrap()

fastfield_codecs/src/compact_space/mod.rs

@@ -17,7 +17,8 @@ use std::{
     ops::{Range, RangeInclusive},
 };
 
-use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt, VIntU128};
+use common::{BinarySerializable, CountingWriter, VInt, VIntU128};
+use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{self, BitPacker, BitUnpacker};
 
 use crate::compact_space::build_compact_space::get_compact_space;
@@ -453,8 +454,6 @@ impl CompactSpaceDecompressor {
 #[cfg(test)]
 mod tests {
 
-    use std::fmt;
-
     use super::*;
     use crate::format_version::read_format_version;
     use crate::null_index_footer::read_null_index_footer;
@@ -708,7 +707,7 @@ mod tests {
         );
     }
 
-    fn get_positions_for_value_range_helper<C: Column<T> + ?Sized, T: PartialOrd + fmt::Debug>(
+    fn get_positions_for_value_range_helper<C: Column<T> + ?Sized, T: PartialOrd>(
         column: &C,
         value_range: RangeInclusive<T>,
         doc_id_range: Range<u32>,

fastfield_codecs/src/format_version.rs

@@ -1,6 +1,7 @@
 use std::io;
 
-use common::{BinarySerializable, OwnedBytes};
+use common::BinarySerializable;
+use ownedbytes::OwnedBytes;
 
 const MAGIC_NUMBER: u16 = 4335u16;
 const FASTFIELD_FORMAT_VERSION: u8 = 1;

fastfield_codecs/src/gcd.rs

@@ -45,7 +45,7 @@ mod tests {
     use std::io;
     use std::num::NonZeroU64;
 
-    use common::OwnedBytes;
+    use ownedbytes::OwnedBytes;
 
     use crate::gcd::{compute_gcd, find_gcd};
     use crate::{FastFieldCodecType, VecColumn};

fastfield_codecs/src/lib.rs

@@ -14,11 +14,11 @@ extern crate more_asserts;
 #[cfg(all(test, feature = "unstable"))]
 extern crate test;
 
+use std::io;
 use std::io::Write;
 use std::sync::Arc;
-use std::{fmt, io};
 
-use common::{BinarySerializable, OwnedBytes};
+use common::BinarySerializable;
 use compact_space::CompactSpaceDecompressor;
 use format_version::read_format_version;
 use monotonic_mapping::{
@@ -26,6 +26,7 @@ use monotonic_mapping::{
     StrictlyMonotonicMappingToInternalBaseval, StrictlyMonotonicMappingToInternalGCDBaseval,
 };
 use null_index_footer::read_null_index_footer;
+use ownedbytes::OwnedBytes;
 use serialize::{Header, U128Header};
 
 mod bitpacked;
@@ -44,6 +45,8 @@ mod column;
 mod gcd;
 pub mod serialize;
 
+pub use ordered_float;
+
 use self::bitpacked::BitpackedCodec;
 use self::blockwise_linear::BlockwiseLinearCodec;
 pub use self::column::{monotonic_map_column, Column, IterColumn, VecColumn};
@@ -133,7 +136,7 @@ impl U128FastFieldCodecType {
 }
 
 /// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open_u128<Item: MonotonicallyMappableToU128 + fmt::Debug>(
+pub fn open_u128<Item: MonotonicallyMappableToU128>(
     bytes: OwnedBytes,
 ) -> io::Result<Arc<dyn Column<Item>>> {
     let (bytes, _format_version) = read_format_version(bytes)?;
@@ -147,9 +150,7 @@ pub fn open_u128<Item: MonotonicallyMappableToU128 + fmt::Debug>(
 }
 
 /// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open<T: MonotonicallyMappableToU64 + fmt::Debug>(
+pub fn open<T: MonotonicallyMappableToU64>(bytes: OwnedBytes) -> io::Result<Arc<dyn Column<T>>> {
-    bytes: OwnedBytes,
-) -> io::Result<Arc<dyn Column<T>>> {
     let (bytes, _format_version) = read_format_version(bytes)?;
     let (mut bytes, _null_index_footer) = read_null_index_footer(bytes)?;
     let header = Header::deserialize(&mut bytes)?;
@@ -162,7 +163,7 @@ pub fn open<T: MonotonicallyMappableToU64 + fmt::Debug>(
     }
 }
 
-fn open_specific_codec<C: FastFieldCodec, Item: MonotonicallyMappableToU64 + fmt::Debug>(
+fn open_specific_codec<C: FastFieldCodec, Item: MonotonicallyMappableToU64>(
     bytes: OwnedBytes,
     header: &Header,
 ) -> io::Result<Arc<dyn Column<Item>>> {
@@ -323,9 +324,6 @@ mod tests {
     pub fn get_codec_test_datasets() -> Vec<(Vec<u64>, &'static str)> {
         let mut data_and_names = vec![];
 
-        let data = vec![10];
-        data_and_names.push((data, "minimal test"));
-
         let data = (10..=10_000_u64).collect::<Vec<_>>();
         data_and_names.push((data, "simple monotonically increasing"));
 
@@ -333,9 +331,6 @@ mod tests {
             vec![5, 6, 7, 8, 9, 10, 99, 100],
             "offset in linear interpol",
         ));
-
-        data_and_names.push((vec![3, 18446744073709551613, 5], "docid range regression"));
-
         data_and_names.push((vec![5, 50, 3, 13, 1, 1000, 35], "rand small"));
         data_and_names.push((vec![10], "single value"));
 
@@ -443,7 +438,7 @@ mod tests {
 mod bench {
     use std::sync::Arc;
 
-    use common::OwnedBytes;
+    use ownedbytes::OwnedBytes;
     use rand::rngs::StdRng;
     use rand::{Rng, SeedableRng};
     use test::{self, Bencher};

fastfield_codecs/src/linear.rs

@@ -1,6 +1,7 @@
 use std::io::{self, Write};
 
-use common::{BinarySerializable, OwnedBytes};
+use common::BinarySerializable;
+use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::line::Line;
@@ -24,13 +25,13 @@ impl Column for LinearReader {
         interpoled_val.wrapping_add(bitpacked_diff)
     }
 
-    #[inline(always)]
+    #[inline]
     fn min_value(&self) -> u64 {
         // The LinearReader assumes a normalized vector.
         0u64
     }
 
-    #[inline(always)]
+    #[inline]
     fn max_value(&self) -> u64 {
         self.header.max_value
     }

fastfield_codecs/src/main.rs

@@ -6,10 +6,10 @@ use std::io::BufRead;
 use std::net::{IpAddr, Ipv6Addr};
 use std::str::FromStr;
 
-use common::OwnedBytes;
 use fastfield_codecs::{open_u128, serialize_u128, Column, FastFieldCodecType, VecColumn};
 use itertools::Itertools;
 use measure_time::print_time;
+use ownedbytes::OwnedBytes;
 use prettytable::{Cell, Row, Table};
 
 fn print_set_stats(ip_addrs: &[u128]) {

fastfield_codecs/src/monotonic_mapping.rs

@@ -1,16 +1,13 @@
-use std::fmt;
 use std::marker::PhantomData;
-use std::ops::RangeInclusive;
 
 use fastdivide::DividerU64;
+use ordered_float::NotNan;
 
 use crate::MonotonicallyMappableToU128;
 
 /// Monotonic maps a value to u64 value space.
 /// Monotonic mapping enables `PartialOrd` on u64 space without conversion to original space.
-pub trait MonotonicallyMappableToU64:
+pub trait MonotonicallyMappableToU64: 'static + PartialOrd + Copy + Send + Sync {
-    'static + PartialOrd + Copy + Send + Sync + fmt::Debug
-{
     /// Converts a value to u64.
     ///
     /// Internally all fast field values are encoded as u64.
@@ -33,29 +30,11 @@ pub trait MonotonicallyMappableToU64:
 /// mapping from their range to their domain. The `inverse` method is required when opening a codec,
 /// so a value can be converted back to its original domain (e.g. ip address or f64) from its
 /// internal representation.
-pub trait StrictlyMonotonicFn<External: Copy, Internal: Copy> {
+pub trait StrictlyMonotonicFn<External, Internal> {
     /// Strictly monotonically maps the value from External to Internal.
     fn mapping(&self, inp: External) -> Internal;
     /// Inverse of `mapping`. Maps the value from Internal to External.
     fn inverse(&self, out: Internal) -> External;
-
-    /// Maps a user provded value from External to Internal.
-    /// It may be necessary to coerce the value if it is outside the value space.
-    /// In that case it tries to find the next greater value in the value space.
-    ///
-    /// Returns a bool to mark if a value was outside the value space and had to be coerced _up_.
-    /// With that information we can detect if two values in a range both map outside the same value
-    /// space.
-    ///
-    /// coerce_up means the next valid upper value in the value space will be chosen if the value
-    /// has to be coerced.
-    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<Internal> {
-        self.mapping(*inp.start())..=self.mapping(*inp.end())
-    }
-    /// Inverse of `mapping_coerce`.
-    fn inverse_coerce(&self, out: RangeInclusive<Internal>) -> RangeInclusive<External> {
-        self.inverse(*out.start())..=self.inverse(*out.end())
-    }
 }
 
 /// Inverts a strictly monotonic mapping from `StrictlyMonotonicFn<A, B>` to
@@ -76,29 +55,15 @@ impl<T> From<T> for StrictlyMonotonicMappingInverter<T> {
 }
 
 impl<From, To, T> StrictlyMonotonicFn<To, From> for StrictlyMonotonicMappingInverter<T>
-where
+where T: StrictlyMonotonicFn<From, To>
-    T: StrictlyMonotonicFn<From, To>,
-    From: Copy,
-    To: Copy,
 {
-    #[inline(always)]
     fn mapping(&self, val: To) -> From {
         self.orig_mapping.inverse(val)
     }
 
-    #[inline(always)]
     fn inverse(&self, val: From) -> To {
         self.orig_mapping.mapping(val)
     }
-
-    #[inline]
-    fn mapping_coerce(&self, inp: RangeInclusive<To>) -> RangeInclusive<From> {
-        self.orig_mapping.inverse_coerce(inp)
-    }
-    #[inline]
-    fn inverse_coerce(&self, out: RangeInclusive<From>) -> RangeInclusive<To> {
-        self.orig_mapping.mapping_coerce(out)
-    }
 }
 
 /// Applies the strictly monotonic mapping from `T` without any additional changes.
@@ -118,12 +83,10 @@ impl<External: MonotonicallyMappableToU128, T: MonotonicallyMappableToU128>
     StrictlyMonotonicFn<External, u128> for StrictlyMonotonicMappingToInternal<T>
 where T: MonotonicallyMappableToU128
 {
-    #[inline(always)]
     fn mapping(&self, inp: External) -> u128 {
         External::to_u128(inp)
     }
 
-    #[inline(always)]
     fn inverse(&self, out: u128) -> External {
         External::from_u128(out)
     }
@@ -133,12 +96,10 @@ impl<External: MonotonicallyMappableToU64, T: MonotonicallyMappableToU64>
     StrictlyMonotonicFn<External, u64> for StrictlyMonotonicMappingToInternal<T>
 where T: MonotonicallyMappableToU64
 {
-    #[inline(always)]
     fn mapping(&self, inp: External) -> u64 {
         External::to_u64(inp)
     }
 
-    #[inline(always)]
     fn inverse(&self, out: u64) -> External {
         External::from_u64(out)
     }
@@ -166,41 +127,14 @@ impl StrictlyMonotonicMappingToInternalGCDBaseval {
 impl<External: MonotonicallyMappableToU64> StrictlyMonotonicFn<External, u64>
     for StrictlyMonotonicMappingToInternalGCDBaseval
 {
-    #[inline(always)]
     fn mapping(&self, inp: External) -> u64 {
         self.gcd_divider
             .divide(External::to_u64(inp) - self.min_value)
     }
 
-    #[inline(always)]
     fn inverse(&self, out: u64) -> External {
         External::from_u64(self.min_value + out * self.gcd)
     }
-
-    #[inline]
-    #[allow(clippy::reversed_empty_ranges)]
-    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<u64> {
-        let end = External::to_u64(*inp.end());
-        if end < self.min_value || inp.end() < inp.start() {
-            return 1..=0;
-        }
-        let map_coerce = |mut inp, coerce_up| {
-            let inp_lower_bound = self.inverse(0);
-            if inp < inp_lower_bound {
-                inp = inp_lower_bound;
-            }
-            let val = External::to_u64(inp);
-            let need_coercion = coerce_up && (val - self.min_value) % self.gcd != 0;
-            let mut mapped_val = self.mapping(inp);
-            if need_coercion {
-                mapped_val += 1;
-            }
-            mapped_val
-        };
-        let start = map_coerce(*inp.start(), true);
-        let end = map_coerce(*inp.end(), false);
-        start..=end
-    }
 }
 
 /// Strictly monotonic mapping with a base value.
@@ -208,7 +142,6 @@ pub(crate) struct StrictlyMonotonicMappingToInternalBaseval {
     min_value: u64,
 }
 impl StrictlyMonotonicMappingToInternalBaseval {
-    #[inline(always)]
     pub(crate) fn new(min_value: u64) -> Self {
         Self { min_value }
     }
@@ -217,35 +150,20 @@ impl StrictlyMonotonicMappingToInternalBaseval {
 impl<External: MonotonicallyMappableToU64> StrictlyMonotonicFn<External, u64>
     for StrictlyMonotonicMappingToInternalBaseval
 {
-    #[inline]
-    #[allow(clippy::reversed_empty_ranges)]
-    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<u64> {
-        if External::to_u64(*inp.end()) < self.min_value {
-            return 1..=0;
-        }
-        let start = self.mapping(External::to_u64(*inp.start()).max(self.min_value));
-        let end = self.mapping(External::to_u64(*inp.end()));
-        start..=end
-    }
-
-    #[inline(always)]
     fn mapping(&self, val: External) -> u64 {
         External::to_u64(val) - self.min_value
     }
 
-    #[inline(always)]
     fn inverse(&self, val: u64) -> External {
         External::from_u64(self.min_value + val)
     }
 }
 
 impl MonotonicallyMappableToU64 for u64 {
-    #[inline(always)]
     fn to_u64(self) -> u64 {
         self
     }
 
-    #[inline(always)]
     fn from_u64(val: u64) -> Self {
         val
     }
@@ -278,22 +196,51 @@ impl MonotonicallyMappableToU64 for bool {
 // TODO remove me.
 // Tantivy should refuse NaN values and work with NotNaN internally.
 impl MonotonicallyMappableToU64 for f64 {
-    #[inline(always)]
     fn to_u64(self) -> u64 {
         common::f64_to_u64(self)
     }
 
-    #[inline(always)]
     fn from_u64(val: u64) -> Self {
         common::u64_to_f64(val)
     }
 }
 
+impl MonotonicallyMappableToU64 for ordered_float::NotNan<f64> {
+    fn to_u64(self) -> u64 {
+        common::f64_to_u64(self.into_inner())
+    }
+
+    fn from_u64(val: u64) -> Self {
+        NotNan::new(common::u64_to_f64(val)).expect("Invalid NotNaN f64 value.")
+    }
+}
+
 #[cfg(test)]
 mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_from_u64_pos_inf() {
+        let inf_as_u64 = common::f64_to_u64(f64::INFINITY);
+        let inf_back_to_f64 = NotNan::from_u64(inf_as_u64);
+        assert_eq!(inf_back_to_f64, NotNan::new(f64::INFINITY).unwrap());
+    }
+
+    #[test]
+    fn test_from_u64_neg_inf() {
+        let inf_as_u64 = common::f64_to_u64(-f64::INFINITY);
+        let inf_back_to_f64 = NotNan::from_u64(inf_as_u64);
+        assert_eq!(inf_back_to_f64, NotNan::new(-f64::INFINITY).unwrap());
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid NotNaN")]
+    fn test_from_u64_nan_panics() {
+        let nan_as_u64 = common::f64_to_u64(f64::NAN);
+        NotNan::from_u64(nan_as_u64);
+    }
+
     #[test]
     fn strictly_monotonic_test() {
         // identity mapping
@@ -311,7 +258,7 @@ mod tests {
         test_round_trip::<_, _, u64>(&mapping, 100u64);
     }
 
-    fn test_round_trip<T: StrictlyMonotonicFn<K, L>, K: std::fmt::Debug + Eq + Copy, L: Copy>(
+    fn test_round_trip<T: StrictlyMonotonicFn<K, L>, K: std::fmt::Debug + Eq + Copy, L>(
         mapping: &T,
         test_val: K,
     ) {

fastfield_codecs/src/monotonic_mapping_u128.rs

@@ -1,11 +1,8 @@
-use std::fmt;
 use std::net::Ipv6Addr;
 
 /// Montonic maps a value to u128 value space
 /// Monotonic mapping enables `PartialOrd` on u128 space without conversion to original space.
-pub trait MonotonicallyMappableToU128:
+pub trait MonotonicallyMappableToU128: 'static + PartialOrd + Copy + Send + Sync {
-    'static + PartialOrd + Copy + Send + Sync + fmt::Debug
-{
     /// Converts a value to u128.
     ///
     /// Internally all fast field values are encoded as u64.

fastfield_codecs/src/null_index/dense.rs

@@ -1,8 +1,9 @@
 use std::convert::TryInto;
 use std::io::{self, Write};
 
-use common::{BinarySerializable, OwnedBytes};
+use common::BinarySerializable;
 use itertools::Itertools;
+use ownedbytes::OwnedBytes;
 
 use super::{get_bit_at, set_bit_at};
 
@@ -31,16 +32,15 @@ const BLOCK_BITVEC_SIZE: usize = 8;
 const BLOCK_OFFSET_SIZE: usize = 4;
 const SERIALIZED_BLOCK_SIZE: usize = BLOCK_BITVEC_SIZE + BLOCK_OFFSET_SIZE;
 
-/// Interpreting the bitvec as a list of 64 bits from the low weight to the
-/// high weight.
-///
-/// This function returns the number of bits set to 1 within
-/// `[0..pos_in_vec)`.
 #[inline]
 fn count_ones(bitvec: u64, pos_in_bitvec: u32) -> u32 {
-    let mask = (1u64 << pos_in_bitvec) - 1;
+    if pos_in_bitvec == 63 {
-    let masked_bitvec = bitvec & mask;
+        bitvec.count_ones()
-    masked_bitvec.count_ones()
+    } else {
+        let mask = (1u64 << (pos_in_bitvec + 1)) - 1;
+        let masked_bitvec = bitvec & mask;
+        masked_bitvec.count_ones()
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -67,7 +67,9 @@ impl DenseCodec {
     pub fn exists(&self, idx: u32) -> bool {
         let block_pos = idx / ELEMENTS_PER_BLOCK;
         let bitvec = self.dense_index_block(block_pos).bitvec;
+
         let pos_in_bitvec = idx % ELEMENTS_PER_BLOCK;
+
         get_bit_at(bitvec, pos_in_bitvec)
     }
     #[inline]
@@ -89,7 +91,8 @@ impl DenseCodec {
         let pos_in_block_bit_vec = idx % ELEMENTS_PER_BLOCK;
         let ones_in_block = count_ones(index_block.bitvec, pos_in_block_bit_vec);
         if get_bit_at(index_block.bitvec, pos_in_block_bit_vec) {
-            Some(index_block.offset + ones_in_block)
+            // -1 is ok, since idx does exist, so there's at least one
+            Some(index_block.offset + ones_in_block - 1)
         } else {
             None
         }
@@ -317,10 +320,9 @@ mod tests {
         set_bit_at(&mut block, 0);
         set_bit_at(&mut block, 2);
 
-        assert_eq!(count_ones(block, 0), 0);
+        assert_eq!(count_ones(block, 0), 1);
         assert_eq!(count_ones(block, 1), 1);
-        assert_eq!(count_ones(block, 2), 1);
+        assert_eq!(count_ones(block, 2), 2);
-        assert_eq!(count_ones(block, 3), 2);
     }
 }
 
@@ -346,16 +348,11 @@ mod bench {
         codec
     }
 
-    fn random_range_iterator(
+    fn random_range_iterator(start: u32, end: u32, step_size: u32) -> impl Iterator<Item = u32> {
-        start: u32,
-        end: u32,
-        avg_step_size: u32,
-        avg_deviation: u32,
-    ) -> impl Iterator<Item = u32> {
         let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
         let mut current = start;
         std::iter::from_fn(move || {
-            current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+            current += rng.gen_range(1..step_size + 1);
             if current >= end {
                 None
             } else {
@@ -364,17 +361,10 @@ mod bench {
         })
     }
 
-    fn n_percent_step_iterator(percent: f32, num_values: u32) -> impl Iterator<Item = u32> {
+    fn walk_over_data(codec: &DenseCodec, max_step_size: u32) -> Option<u32> {
-        let ratio = percent as f32 / 100.0;
-        let step_size = (1f32 / ratio) as u32;
-        let deviation = step_size - 1;
-        random_range_iterator(0, num_values, step_size, deviation)
-    }
-
-    fn walk_over_data(codec: &DenseCodec, avg_step_size: u32) -> Option<u32> {
         walk_over_data_from_positions(
             codec,
-            random_range_iterator(0, TOTAL_NUM_VALUES, avg_step_size, 0),
+            random_range_iterator(0, TOTAL_NUM_VALUES, max_step_size),
         )
     }
 
@@ -390,105 +380,69 @@ mod bench {
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_1percent_filled_10percent_hit(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_orig_to_codec_90percent_filled_random_stride(
-        let codec = gen_bools(0.01f64);
+        bench: &mut Bencher,
-        bench.iter(|| walk_over_data(&codec, 100));
+    ) {
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_5percent_filled_10percent_hit(bench: &mut Bencher) {
-        let codec = gen_bools(0.05f64);
-        bench.iter(|| walk_over_data(&codec, 100));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_5percent_filled_1percent_hit(bench: &mut Bencher) {
-        let codec = gen_bools(0.05f64);
-        bench.iter(|| walk_over_data(&codec, 1000));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_full_scan_1percent_filled(bench: &mut Bencher) {
-        let codec = gen_bools(0.01f64);
-        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_full_scan_10percent_filled(bench: &mut Bencher) {
-        let codec = gen_bools(0.1f64);
-        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_full_scan_90percent_filled(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
-        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_10percent_filled_1percent_hit(bench: &mut Bencher) {
-        let codec = gen_bools(0.1f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_50percent_filled_1percent_hit(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_orig_to_codec_50percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.5f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_90percent_filled_1percent_hit(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_orig_to_codec_full_scan_10percent(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_dense_codec_translate_orig_to_codec_full_scan_90percent(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_dense_codec_translate_orig_to_codec_10percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
+        let codec = gen_bools(0.1f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_codec_to_orig_90percent_filled_random_stride_big_step(
-        let codec = gen_bools(0.01f64);
+        bench: &mut Bencher,
-        let num_non_nulls = codec.num_non_nulls();
+    ) {
-        bench.iter(|| {
+        let codec = gen_bools(0.9f64);
-            codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
-                .last()
-        });
-    }
-
-    #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_10percent_hit(bench: &mut Bencher) {
-        let codec = gen_bools(0.01f64);
-        let num_non_nulls = codec.num_non_nulls();
-        bench.iter(|| {
-            codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(10.0, num_non_nulls))
-                .last()
-        });
-    }
-
-    #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
-        let codec = gen_bools(0.01f64);
         let num_vals = codec.num_non_nulls();
         bench.iter(|| {
             codec
-                .translate_codec_idx_to_original_idx(0..num_vals)
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 50_000))
                 .last()
         });
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_90percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_codec_to_orig_90percent_filled_random_stride(
-        let codec = gen_bools(0.90f64);
+        bench: &mut Bencher,
-        let num_non_nulls = codec.num_non_nulls();
+    ) {
+        let codec = gen_bools(0.9f64);
+        let num_vals = codec.num_non_nulls();
         bench.iter(|| {
             codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 100))
                 .last()
         });
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
+    fn bench_dense_codec_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
         let num_vals = codec.num_non_nulls();
         bench.iter(|| {

fastfield_codecs/src/null_index/sparse.rs

@@ -1,6 +1,7 @@
 use std::io::{self, Write};
 
-use common::{BitSet, GroupByIteratorExtended, OwnedBytes};
+use common::BitSet;
+use ownedbytes::OwnedBytes;
 
 use super::{serialize_dense_codec, DenseCodec};
 
@@ -58,7 +59,6 @@ enum SparseCodecBlockVariant {
 
 impl SparseCodecBlockVariant {
     /// The number of non-null values that preceeded that block.
-    #[inline]
     fn offset(&self) -> u32 {
         match self {
             SparseCodecBlockVariant::Empty { offset } => *offset,
@@ -78,22 +78,12 @@ struct DenseBlock {
 }
 
 impl DenseBlock {
-    #[inline]
     pub fn exists(&self, idx: u32) -> bool {
         self.codec.exists(idx)
     }
-    #[inline]
     pub fn translate_to_codec_idx(&self, idx: u32) -> Option<u32> {
         self.codec.translate_to_codec_idx(idx)
     }
-    #[inline]
-    pub fn translate_codec_idx_to_original_idx_iter<'a>(
-        &'a self,
-        iter: impl Iterator<Item = u32> + 'a,
-    ) -> impl Iterator<Item = u32> + 'a {
-        self.codec.translate_codec_idx_to_original_idx(iter)
-    }
-    #[inline]
     pub fn translate_codec_idx_to_original_idx(&self, idx: u32) -> u32 {
         self.codec
             .translate_codec_idx_to_original_idx(idx..=idx)
@@ -217,7 +207,6 @@ struct ValueAddr {
 }
 
 /// Splits a idx into block index and value in the block
-#[inline]
 fn value_addr(idx: u32) -> ValueAddr {
     /// Static assert number elements per block this method expects
     #[allow(clippy::assertions_on_constants)]
@@ -284,7 +273,6 @@ impl SparseCodec {
         }
     }
 
-    #[inline]
     fn find_block(&self, dense_idx: u32, mut block_pos: u32) -> u32 {
         loop {
             let offset = self.blocks[block_pos as usize].offset();
@@ -296,7 +284,6 @@ impl SparseCodec {
     }
 
     /// Translate positions from the codec index to the original index.
-    /// Correctness: Provided values must be in increasing values
     ///
     /// # Panics
     ///
@@ -305,41 +292,35 @@ impl SparseCodec {
         &'a self,
         iter: impl Iterator<Item = u32> + 'a,
     ) -> impl Iterator<Item = u32> + 'a {
+        // TODO: There's a big potential performance gain, by using iterators per block instead of
+        // random access for each element in a block
+        // group_by itertools won't help though, since it requires a temporary local variable
         let mut block_pos = 0u32;
-        iter.group_by(move |codec_idx| {
+        iter.map(move |codec_idx| {
-            block_pos = self.find_block(*codec_idx, block_pos);
+            // update block_pos to limit search scope
-            block_pos
+            block_pos = self.find_block(codec_idx, block_pos);
-        })
-        .flat_map(move |(block_pos, block_iter)| {
             let block_doc_idx_start = block_pos * ELEMENTS_PER_BLOCK;
             let block = &self.blocks[block_pos as usize];
-            let offset = block.offset();
+            let idx_in_block = codec_idx - block.offset();
-            let indexes_in_block_iter = block_iter.map(move |codec_idx| codec_idx - offset);
             match block {
                 SparseCodecBlockVariant::Empty { offset: _ } => {
                     panic!(
                         "invalid input, cannot translate to original index. associated empty \
-                         block with dense idx. block_pos {}, idx_in_block {:?}",
+                         block with dense idx. block_pos {}, idx_in_block {}",
-                        block_pos,
+                        block_pos, idx_in_block
-                        indexes_in_block_iter.collect::<Vec<_>>()
                     )
                 }
                 SparseCodecBlockVariant::Dense(dense) => {
-                    Box::new(dense.translate_codec_idx_to_original_idx_iter(indexes_in_block_iter))
+                    dense.translate_codec_idx_to_original_idx(idx_in_block) + block_doc_idx_start
-                        as Box<dyn Iterator<Item = u32>>
                 }
                 SparseCodecBlockVariant::Sparse(block) => {
-                    Box::new(indexes_in_block_iter.map(move |idx_in_block| {
+                    block.value_at_idx(&self.data, idx_in_block as u16) as u32 + block_doc_idx_start
-                        block.value_at_idx(&self.data, idx_in_block as u16) as u32
-                    }))
                 }
             }
-            .map(move |idx| idx + block_doc_idx_start)
         })
     }
 }
 
-#[inline]
 fn is_sparse(num_elem_in_block: u32) -> bool {
     num_elem_in_block < DENSE_BLOCK_THRESHOLD
 }
@@ -614,16 +595,11 @@ mod bench {
         codec
     }
 
-    fn random_range_iterator(
+    fn random_range_iterator(start: u32, end: u32, step_size: u32) -> impl Iterator<Item = u32> {
-        start: u32,
-        end: u32,
-        avg_step_size: u32,
-        avg_deviation: u32,
-    ) -> impl Iterator<Item = u32> {
         let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
         let mut current = start;
         std::iter::from_fn(move || {
-            current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+            current += rng.gen_range(1..step_size + 1);
             if current >= end {
                 None
             } else {
@@ -632,17 +608,10 @@ mod bench {
         })
     }
 
-    fn n_percent_step_iterator(percent: f32, num_values: u32) -> impl Iterator<Item = u32> {
+    fn walk_over_data(codec: &SparseCodec, max_step_size: u32) -> Option<u32> {
-        let ratio = percent as f32 / 100.0;
-        let step_size = (1f32 / ratio) as u32;
-        let deviation = step_size - 1;
-        random_range_iterator(0, num_values, step_size, deviation)
-    }
-
-    fn walk_over_data(codec: &SparseCodec, avg_step_size: u32) -> Option<u32> {
         walk_over_data_from_positions(
             codec,
-            random_range_iterator(0, TOTAL_NUM_VALUES, avg_step_size, 0),
+            random_range_iterator(0, TOTAL_NUM_VALUES, max_step_size),
         )
     }
 
@@ -658,83 +627,83 @@ mod bench {
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_1percent_filled_10percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_1percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.01f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_5percent_filled_10percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_5percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.05f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_5percent_filled_1percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_full_scan_10percent(bench: &mut Bencher) {
-        let codec = gen_bools(0.05f64);
-        bench.iter(|| walk_over_data(&codec, 1000));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_full_scan_1percent_filled(bench: &mut Bencher) {
-        let codec = gen_bools(0.01f64);
-        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_full_scan_10percent_filled(bench: &mut Bencher) {
         let codec = gen_bools(0.1f64);
         bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_full_scan_90percent_filled(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_full_scan_90percent(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
         bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_10percent_filled_1percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_full_scan_1percent(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_sparse_codec_translate_orig_to_codec_10percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.1f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_orig_to_codec_50percent_filled_1percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_orig_to_codec_90percent_filled_random_stride(
-        let codec = gen_bools(0.5f64);
+        bench: &mut Bencher,
-        bench.iter(|| walk_over_data(&codec, 100));
+    ) {
-    }
-
-    #[bench]
-    fn bench_translate_orig_to_codec_90percent_filled_1percent_hit(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
         bench.iter(|| walk_over_data(&codec, 100));
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_codec_to_orig_1percent_filled_random_stride_big_step(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.01f64);
-        let num_non_nulls = codec.num_non_nulls();
+        let num_vals = codec.num_non_nulls();
         bench.iter(|| {
             codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 50_000))
                 .last()
         });
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_10percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_codec_to_orig_1percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.01f64);
-        let num_non_nulls = codec.num_non_nulls();
+        let num_vals = codec.num_non_nulls();
         bench.iter(|| {
             codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(10.0, num_non_nulls))
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 100))
                 .last()
         });
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
         let codec = gen_bools(0.01f64);
         let num_vals = codec.num_non_nulls();
         bench.iter(|| {
@@ -745,18 +714,33 @@ mod bench {
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_90percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_codec_to_orig_90percent_filled_random_stride_big_step(
+        bench: &mut Bencher,
+    ) {
         let codec = gen_bools(0.90f64);
-        let num_non_nulls = codec.num_non_nulls();
+        let num_vals = codec.num_non_nulls();
         bench.iter(|| {
             codec
-                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 50_000))
                 .last()
         });
     }
 
     #[bench]
-    fn bench_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
+    fn bench_sparse_codec_translate_codec_to_orig_90percent_filled_random_stride(
+        bench: &mut Bencher,
+    ) {
+        let codec = gen_bools(0.9f64);
+        let num_vals = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(random_range_iterator(0, num_vals, 100))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_sparse_codec_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
         let codec = gen_bools(0.9f64);
         let num_vals = codec.num_non_nulls();
         bench.iter(|| {

fastfield_codecs/src/null_index_footer.rs

@@ -1,7 +1,8 @@
 use std::io::{self, Write};
 use std::ops::Range;
 
-use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt};
+use common::{BinarySerializable, CountingWriter, VInt};
+use ownedbytes::OwnedBytes;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub(crate) enum FastFieldCardinality {

fastfield_codecs/src/serialize.rs

@@ -1,28 +1,10 @@
-// Copyright (C) 2022 Quickwit, Inc.
+use std::io;
-//
-// Quickwit is offered under the AGPL v3.0 and as commercial software.
-// For commercial licensing, contact us at hello@quickwit.io.
-//
-// AGPL:
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program. If not, see <http://www.gnu.org/licenses/>.
-
 use std::num::NonZeroU64;
 use std::sync::Arc;
-use std::{fmt, io};
 
-use common::{BinarySerializable, OwnedBytes, VInt};
+use common::{BinarySerializable, VInt};
 use log::warn;
+use ownedbytes::OwnedBytes;
 
 use crate::bitpacked::BitpackedCodec;
 use crate::blockwise_linear::BlockwiseLinearCodec;
@@ -167,7 +149,7 @@ impl BinarySerializable for Header {
 
 /// Return estimated compression for given codec in the value range [0.0..1.0], where 1.0 means no
 /// compression.
-pub fn estimate<T: MonotonicallyMappableToU64 + fmt::Debug>(
+pub fn estimate<T: MonotonicallyMappableToU64>(
     typed_column: impl Column<T>,
     codec_type: FastFieldCodecType,
 ) -> Option<f32> {
@@ -202,7 +184,6 @@ pub enum ValueIndexInfo<'a> {
     SingleValue(Box<dyn SingleValueIndexInfo + 'a>),
 }
 
-// TODO Remove me
 impl Default for ValueIndexInfo<'static> {
     fn default() -> Self {
         struct Dummy {}
@@ -276,7 +257,7 @@ pub fn serialize_u128_new<F: Fn() -> I, I: Iterator<Item = u128>>(
 }
 
 /// Serializes the column with the codec with the best estimate on the data.
-pub fn serialize<T: MonotonicallyMappableToU64 + fmt::Debug>(
+pub fn serialize<T: MonotonicallyMappableToU64>(
     typed_column: impl Column<T>,
     output: &mut impl io::Write,
     codecs: &[FastFieldCodecType],
@@ -285,7 +266,7 @@ pub fn serialize<T: MonotonicallyMappableToU64 + fmt::Debug>(
 }
 
 /// Serializes the column with the codec with the best estimate on the data.
-pub fn serialize_new<T: MonotonicallyMappableToU64 + fmt::Debug>(
+pub fn serialize_new<T: MonotonicallyMappableToU64>(
     value_index: ValueIndexInfo,
     typed_column: impl Column<T>,
     output: &mut impl io::Write,
@@ -366,7 +347,7 @@ fn serialize_given_codec(
 }
 
 /// Helper function to serialize a column (autodetect from all codecs) and then open it
-pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default + fmt::Debug>(
+pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default>(
     column: &[T],
 ) -> Arc<dyn Column<T>> {
     let mut buffer = Vec::new();

src/aggregation/mod.rs

@@ -1208,7 +1208,7 @@ mod tests {
                         text_field_many_terms => many_terms_data.choose(&mut rng).unwrap().to_string(),
                         text_field_few_terms => few_terms_data.choose(&mut rng).unwrap().to_string(),
                         score_field => val as u64,
-                        score_field_f64 => val,
+                        score_field_f64 => val as f64,
                         score_field_i64 => val as i64,
                     ))?;
                 }
@@ -1250,7 +1250,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&term_query, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&term_query, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1278,7 +1281,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&term_query, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&term_query, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1306,7 +1312,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&term_query, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&term_query, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1342,7 +1351,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&term_query, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&term_query, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1368,7 +1380,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1394,7 +1409,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1428,7 +1446,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1460,7 +1481,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1496,7 +1520,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1523,7 +1550,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&AllQuery, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&AllQuery, &collector).unwrap().into();
+
+                agg_res
             });
         }
 
@@ -1567,7 +1597,7 @@ mod tests {
                                 ],
                                 ..Default::default()
                             }),
-                            sub_aggregation: sub_agg_req_1,
+                            sub_aggregation: sub_agg_req_1.clone(),
                         }),
                     ),
                 ]
@@ -1577,7 +1607,10 @@ mod tests {
                 let collector = AggregationCollector::from_aggs(agg_req_1, None, index.schema());
 
                 let searcher = reader.searcher();
-                searcher.search(&term_query, &collector).unwrap()
+                let agg_res: AggregationResults =
+                    searcher.search(&term_query, &collector).unwrap().into();
+
+                agg_res
             });
         }
     }

src/core/searcher.rs

@@ -198,10 +198,11 @@ impl Searcher {
         collector: &C,
         executor: &Executor,
     ) -> crate::Result<C::Fruit> {
-        let enabled_scoring = if collector.requires_scoring() {
+        let scoring_enabled = collector.requires_scoring();
-            EnableScoring::enabled_from_searcher(self)
+        let enabled_scoring = if scoring_enabled {
+            EnableScoring::Enabled(self)
         } else {
-            EnableScoring::disabled_from_searcher(self)
+            EnableScoring::Disabled(self.schema())
         };
         let weight = query.weight(enabled_scoring)?;
         let segment_readers = self.segment_readers();

src/directory/error.rs

@@ -32,7 +32,7 @@ impl LockError {
 /// Error that may occur when opening a directory
 #[derive(Debug, Clone, Error)]
 pub enum OpenDirectoryError {
-    /// The underlying directory does not exist.
+    /// The underlying directory does not exists.
     #[error("Directory does not exist: '{0}'.")]
     DoesNotExist(PathBuf),
     /// The path exists but is not a directory.
@@ -151,8 +151,8 @@ impl fmt::Debug for Incompatibility {
 /// Error that may occur when accessing a file read
 #[derive(Debug, Clone, Error)]
 pub enum OpenReadError {
-    /// The file does not exist.
+    /// The file does not exists.
-    #[error("Files does not exist: {0:?}")]
+    #[error("Files does not exists: {0:?}")]
     FileDoesNotExist(PathBuf),
     /// Any kind of io::Error.
     #[error(
@@ -181,8 +181,8 @@ impl OpenReadError {
 /// Error that may occur when trying to delete a file
 #[derive(Debug, Clone, Error)]
 pub enum DeleteError {
-    /// The file does not exist.
+    /// The file does not exists.
-    #[error("File does not exist: '{0}'.")]
+    #[error("File does not exists: '{0}'.")]
     FileDoesNotExist(PathBuf),
     /// Any kind of IO error that happens when
     /// interacting with the underlying IO device.

src/directory/mmap_directory.rs

@@ -6,10 +6,10 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock, Weak};
 use std::{fmt, result};
 
-use common::StableDeref;
 use fs2::FileExt;
 use memmap2::Mmap;
 use serde::{Deserialize, Serialize};
+use stable_deref_trait::StableDeref;
 use tempfile::TempDir;
 
 use crate::core::META_FILEPATH;

src/directory/mod.rs

@@ -20,7 +20,8 @@ use std::io::BufWriter;
 use std::path::PathBuf;
 
 pub use common::file_slice::{FileHandle, FileSlice};
-pub use common::{AntiCallToken, OwnedBytes, TerminatingWrite};
+pub use common::{AntiCallToken, TerminatingWrite};
+pub use ownedbytes::OwnedBytes;
 
 pub(crate) use self::composite_file::{CompositeFile, CompositeWrite};
 pub use self::directory::{Directory, DirectoryClone, DirectoryLock};

src/directory/ram_directory.rs

@@ -232,7 +232,7 @@ impl Directory for RamDirectory {
         let path_buf = PathBuf::from(path);
         self.fs.write().unwrap().write(path_buf, data);
         if path == *META_FILEPATH {
-            drop(self.fs.write().unwrap().watch_router.broadcast());
+            let _ = self.fs.write().unwrap().watch_router.broadcast();
         }
         Ok(())
     }

src/directory/watch_event_router.rs

@@ -168,7 +168,7 @@ mod tests {
         watch_event_router.broadcast().wait().unwrap();
         assert_eq!(2, counter.load(Ordering::SeqCst));
         mem::drop(handle_a);
-        drop(watch_event_router.broadcast());
+        let _ = watch_event_router.broadcast();
         watch_event_router.broadcast().wait().unwrap();
         assert_eq!(2, counter.load(Ordering::SeqCst));
     }

src/fastfield/alive_bitset.rs

@@ -1,7 +1,8 @@
 use std::io;
 use std::io::Write;
 
-use common::{intersect_bitsets, BitSet, OwnedBytes, ReadOnlyBitSet};
+use common::{intersect_bitsets, BitSet, ReadOnlyBitSet};
+use ownedbytes::OwnedBytes;
 
 use crate::space_usage::ByteCount;
 use crate::DocId;
@@ -175,7 +176,7 @@ mod bench {
 
     fn get_alive() -> Vec<u32> {
         let mut data = (0..1_000_000_u32).collect::<Vec<u32>>();
-        for _ in 0..1_000_000 / 8 {
+        for _ in 0..(1_000_000) * 1 / 8 {
             remove_rand(&mut data);
         }
         data

src/fastfield/bytes/mod.rs

@@ -96,7 +96,7 @@ mod tests {
         let term = Term::from_field_bytes(field, b"lucene".as_ref());
         let term_query = TermQuery::new(term, IndexRecordOption::Basic);
         let term_weight_err =
-            term_query.specialized_weight(EnableScoring::disabled_from_schema(searcher.schema()));
+            term_query.specialized_weight(EnableScoring::Disabled(searcher.schema()));
         assert!(matches!(
             term_weight_err,
             Err(crate::TantivyError::SchemaError(_))

src/fastfield/mod.rs

@@ -12,15 +12,13 @@
 //!
 //!
 //! Fields have to be declared as `FAST` in the schema.
-//! Currently supported fields are: u64, i64, f64, bytes, ip and text.
+//! Currently supported fields are: u64, i64, f64, bytes and text.
 //!
 //! Fast fields are stored in with [different codecs](fastfield_codecs). The best codec is detected
 //! automatically, when serializing.
 //!
 //! Read access performance is comparable to that of an array lookup.
 
-use std::net::Ipv6Addr;
-
 use fastfield_codecs::MonotonicallyMappableToU64;
 
 pub use self::alive_bitset::{intersect_alive_bitsets, write_alive_bitset, AliveBitSet};
@@ -30,7 +28,7 @@ pub use self::facet_reader::FacetReader;
 pub(crate) use self::multivalued::{get_fastfield_codecs_for_multivalue, MultivalueStartIndex};
 pub use self::multivalued::{
     MultiValueIndex, MultiValueU128FastFieldWriter, MultiValuedFastFieldReader,
-    MultiValuedFastFieldWriter,
+    MultiValuedFastFieldWriter, MultiValuedU128FastFieldReader,
 };
 pub(crate) use self::readers::type_and_cardinality;
 pub use self::readers::FastFieldReaders;
@@ -49,33 +47,6 @@ mod readers;
 mod serializer;
 mod writer;
 
-/// Trait for types that provide a zero value.
-///
-/// The resulting value is never used, just as placeholder, e.g. for `vec.resize()`.
-pub trait MakeZero {
-    /// Build a default value. This default value is never used, so the value does not
-    /// really matter.
-    fn make_zero() -> Self;
-}
-
-impl<T: FastValue> MakeZero for T {
-    fn make_zero() -> Self {
-        T::from_u64(0)
-    }
-}
-
-impl MakeZero for u128 {
-    fn make_zero() -> Self {
-        0
-    }
-}
-
-impl MakeZero for Ipv6Addr {
-    fn make_zero() -> Self {
-        Ipv6Addr::from(0u128.to_be_bytes())
-    }
-}
-
 /// Trait for types that are allowed for fast fields:
 /// (u64, i64 and f64, bool, DateTime).
 pub trait FastValue:
@@ -83,6 +54,12 @@ pub trait FastValue:
 {
     /// Returns the `schema::Type` for this FastValue.
     fn to_type() -> Type;
+
+    /// Build a default value. This default value is never used, so the value does not
+    /// really matter.
+    fn make_zero() -> Self {
+        Self::from_u64(0u64)
+    }
 }
 
 impl FastValue for u64 {
@@ -124,6 +101,12 @@ impl FastValue for DateTime {
     fn to_type() -> Type {
         Type::Date
     }
+
+    fn make_zero() -> Self {
+        DateTime {
+            timestamp_micros: 0,
+        }
+    }
 }
 
 fn value_to_u64(value: &Value) -> crate::Result<u64> {
@@ -162,7 +145,7 @@ impl FastFieldType {
 mod tests {
 
     use std::collections::HashMap;
-    use std::ops::{Range, RangeInclusive};
+    use std::ops::Range;
     use std::path::Path;
     use std::sync::Arc;
 
@@ -176,9 +159,7 @@ mod tests {
     use super::*;
     use crate::directory::{CompositeFile, Directory, RamDirectory, WritePtr};
     use crate::merge_policy::NoMergePolicy;
-    use crate::schema::{
+    use crate::schema::{Cardinality, Document, Field, Schema, SchemaBuilder, FAST, STRING, TEXT};
-        Cardinality, Document, Field, Schema, SchemaBuilder, FAST, INDEXED, STRING, TEXT,
-    };
     use crate::time::OffsetDateTime;
     use crate::{DateOptions, DatePrecision, Index, SegmentId, SegmentReader};
 
@@ -539,6 +520,11 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_default_date() {
+        assert_eq!(0, DateTime::make_zero().into_timestamp_secs());
+    }
+
     fn get_vals_for_docs(ff: &MultiValuedFastFieldReader<u64>, docs: Range<u32>) -> Vec<u64> {
         let mut all = vec![];
 
@@ -983,117 +969,4 @@ mod tests {
         }
         Ok(len)
     }
-
-    #[test]
-    fn test_gcd_bug_regression_1757() {
-        let mut schema_builder = Schema::builder();
-        let num_field = schema_builder.add_u64_field("url_norm_hash", FAST | INDEXED);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        {
-            let mut writer = index.writer_for_tests().unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 100u64,
-                })
-                .unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 200u64,
-                })
-                .unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 300u64,
-                })
-                .unwrap();
-
-            writer.commit().unwrap();
-        }
-
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
-        let segment = &searcher.segment_readers()[0];
-        let field = segment.fast_fields().u64(num_field).unwrap();
-
-        let numbers = vec![100, 200, 300];
-        let test_range = |range: RangeInclusive<u64>| {
-            let expexted_count = numbers.iter().filter(|num| range.contains(num)).count();
-            let mut vec = vec![];
-            field.get_docids_for_value_range(range, 0..u32::MAX, &mut vec);
-            assert_eq!(vec.len(), expexted_count);
-        };
-        test_range(50..=50);
-        test_range(150..=150);
-        test_range(350..=350);
-        test_range(100..=250);
-        test_range(101..=200);
-        test_range(101..=199);
-        test_range(100..=300);
-        test_range(100..=299);
-    }
-
-    #[test]
-    fn test_mapping_bug_docids_for_value_range() {
-        let mut schema_builder = Schema::builder();
-        let num_field = schema_builder.add_u64_field("url_norm_hash", FAST | INDEXED);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        {
-            // Values without gcd, but with min_value
-            let mut writer = index.writer_for_tests().unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 1000u64,
-                })
-                .unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 1001u64,
-                })
-                .unwrap();
-            writer
-                .add_document(doc! {
-                    num_field => 1003u64,
-                })
-                .unwrap();
-            writer.commit().unwrap();
-        }
-
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
-        let segment = &searcher.segment_readers()[0];
-        let field = segment.fast_fields().u64(num_field).unwrap();
-
-        let numbers = vec![1000, 1001, 1003];
-        let test_range = |range: RangeInclusive<u64>| {
-            let expexted_count = numbers.iter().filter(|num| range.contains(num)).count();
-            let mut vec = vec![];
-            field.get_docids_for_value_range(range, 0..u32::MAX, &mut vec);
-            assert_eq!(vec.len(), expexted_count);
-        };
-        let test_range_variant = |start, stop| {
-            let start_range = start..=stop;
-            test_range(start_range);
-            let start_range = start..=(stop - 1);
-            test_range(start_range);
-            let start_range = start..=(stop + 1);
-            test_range(start_range);
-            let start_range = (start - 1)..=stop;
-            test_range(start_range);
-            let start_range = (start - 1)..=(stop - 1);
-            test_range(start_range);
-            let start_range = (start - 1)..=(stop + 1);
-            test_range(start_range);
-            let start_range = (start + 1)..=stop;
-            test_range(start_range);
-            let start_range = (start + 1)..=(stop - 1);
-            test_range(start_range);
-            let start_range = (start + 1)..=(stop + 1);
-            test_range(start_range);
-        };
-        test_range_variant(50, 50);
-        test_range_variant(1000, 1000);
-        test_range_variant(1000, 1002);
-    }
 }

src/fastfield/multivalued/index.rs

@@ -80,7 +80,6 @@ impl MultiValueIndex {
     ///
     /// TODO: Instead of a linear scan we can employ a exponential search into binary search to
     /// match a docid to its value position.
-    #[allow(clippy::bool_to_int_with_if)]
     pub(crate) fn positions_to_docids(&self, doc_id_range: Range<u32>, positions: &mut Vec<u32>) {
         if positions.is_empty() {
             return;

src/fastfield/multivalued/mod.rs

@@ -5,7 +5,7 @@ mod writer;
 use fastfield_codecs::FastFieldCodecType;
 pub use index::MultiValueIndex;
 
-pub use self::reader::MultiValuedFastFieldReader;
+pub use self::reader::{MultiValuedFastFieldReader, MultiValuedU128FastFieldReader};
 pub(crate) use self::writer::MultivalueStartIndex;
 pub use self::writer::{MultiValueU128FastFieldWriter, MultiValuedFastFieldWriter};
 
@@ -525,7 +525,7 @@ mod bench {
             serializer.close().unwrap();
             field
         };
-        let file = directory.open_read(path).unwrap();
+        let file = directory.open_read(&path).unwrap();
         {
             let fast_fields_composite = CompositeFile::open(&file).unwrap();
             let data_idx = fast_fields_composite

src/fastfield/multivalued/reader.rs

@@ -1,31 +1,107 @@
-use core::fmt;
 use std::ops::{Range, RangeInclusive};
 use std::sync::Arc;
 
-use fastfield_codecs::Column;
+use fastfield_codecs::{Column, MonotonicallyMappableToU128};
 
 use super::MultiValueIndex;
-use crate::fastfield::MakeZero;
+use crate::fastfield::FastValue;
 use crate::DocId;
 
-/// Reader for a multivalued fast field.
+/// Reader for a multivalued `u64` fast field.
 ///
-/// The reader is implemented as two fast fields, one u64 fast field for the index and one for the
+/// The reader is implemented as two `u64` fast field.
-/// values.
 ///
-/// The `vals_reader` will access the concatenated list of all values.
+/// The `vals_reader` will access the concatenated list of all
-/// The `idx_reader` associates, for each document, the index of its first value.
+/// values for all reader.
+/// The `idx_reader` associated, for each document, the index of its first value.
+/// Stores the start position for each document.
 #[derive(Clone)]
-pub struct MultiValuedFastFieldReader<T> {
+pub struct MultiValuedFastFieldReader<Item: FastValue> {
+    idx_reader: MultiValueIndex,
+    vals_reader: Arc<dyn Column<Item>>,
+}
+
+impl<Item: FastValue> MultiValuedFastFieldReader<Item> {
+    pub(crate) fn open(
+        idx_reader: Arc<dyn Column<u64>>,
+        vals_reader: Arc<dyn Column<Item>>,
+    ) -> MultiValuedFastFieldReader<Item> {
+        MultiValuedFastFieldReader {
+            idx_reader: MultiValueIndex::new(idx_reader),
+            vals_reader,
+        }
+    }
+
+    /// Returns the array of values associated with the given `doc`.
+    #[inline]
+    fn get_vals_for_range(&self, range: Range<u32>, vals: &mut Vec<Item>) {
+        let len = (range.end - range.start) as usize;
+        vals.resize(len, Item::make_zero());
+        self.vals_reader
+            .get_range(range.start as u64, &mut vals[..]);
+    }
+
+    /// Returns the array of values associated with the given `doc`.
+    #[inline]
+    pub fn get_vals(&self, doc: DocId, vals: &mut Vec<Item>) {
+        let range = self.idx_reader.range(doc);
+        self.get_vals_for_range(range, vals);
+    }
+
+    /// returns the multivalue index
+    pub fn get_index_reader(&self) -> &MultiValueIndex {
+        &self.idx_reader
+    }
+
+    /// Returns the minimum value for this fast field.
+    ///
+    /// The min value does not take in account of possible
+    /// deleted document, and should be considered as a lower bound
+    /// of the actual minimum value.
+    pub fn min_value(&self) -> Item {
+        self.vals_reader.min_value()
+    }
+
+    /// Returns the maximum value for this fast field.
+    ///
+    /// The max value does not take in account of possible
+    /// deleted document, and should be considered as an upper bound
+    /// of the actual maximum value.
+    pub fn max_value(&self) -> Item {
+        self.vals_reader.max_value()
+    }
+
+    /// Returns the number of values associated with the document `DocId`.
+    #[inline]
+    pub fn num_vals(&self, doc: DocId) -> u32 {
+        self.idx_reader.num_vals_for_doc(doc)
+    }
+
+    /// Returns the overall number of values in this field.
+    #[inline]
+    pub fn total_num_vals(&self) -> u32 {
+        self.idx_reader.total_num_vals()
+    }
+}
+
+/// Reader for a multivalued `u128` fast field.
+///
+/// The reader is implemented as a `u64` fast field for the index and a `u128` fast field.
+///
+/// The `vals_reader` will access the concatenated list of all
+/// values for all reader.
+/// The `idx_reader` associated, for each document, the index of its first value.
+#[derive(Clone)]
+pub struct MultiValuedU128FastFieldReader<T: MonotonicallyMappableToU128> {
     idx_reader: MultiValueIndex,
     vals_reader: Arc<dyn Column<T>>,
 }
 
-impl<T: PartialOrd + MakeZero + Copy + fmt::Debug> MultiValuedFastFieldReader<T> {
+impl<T: MonotonicallyMappableToU128> MultiValuedU128FastFieldReader<T> {
     pub(crate) fn open(
         idx_reader: Arc<dyn Column<u64>>,
         vals_reader: Arc<dyn Column<T>>,
-    ) -> MultiValuedFastFieldReader<T> {
+    ) -> MultiValuedU128FastFieldReader<T> {
         Self {
             idx_reader: MultiValueIndex::new(idx_reader),
             vals_reader,
@@ -46,7 +122,7 @@ impl<T: PartialOrd + MakeZero + Copy + fmt::Debug> MultiValuedFastFieldReader<T>
     #[inline]
     fn get_vals_for_range(&self, range: Range<u32>, vals: &mut Vec<T>) {
         let len = (range.end - range.start) as usize;
-        vals.resize(len, T::make_zero());
+        vals.resize(len, T::from_u128(0));
         self.vals_reader
             .get_range(range.start as u64, &mut vals[..]);
     }
@@ -123,131 +199,8 @@ impl<T: PartialOrd + MakeZero + Copy + fmt::Debug> MultiValuedFastFieldReader<T>
 #[cfg(test)]
 mod tests {
 
-    use time::{Duration, OffsetDateTime};
-
-    use crate::collector::Count;
     use crate::core::Index;
-    use crate::query::RangeQuery;
     use crate::schema::{Cardinality, Facet, FacetOptions, NumericOptions, Schema};
-    use crate::{DateOptions, DatePrecision, DateTime};
-
-    #[test]
-    fn test_multivalued_date_docids_for_value_range_1() -> crate::Result<()> {
-        let mut schema_builder = Schema::builder();
-        let date_field = schema_builder.add_date_field(
-            "multi_date_field",
-            DateOptions::default()
-                .set_fast(Cardinality::MultiValues)
-                .set_indexed()
-                .set_fieldnorm()
-                .set_precision(DatePrecision::Microseconds)
-                .set_stored(),
-        );
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests()?;
-        let first_time_stamp = OffsetDateTime::now_utc();
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_utc(first_time_stamp),
-            date_field => DateTime::from_utc(first_time_stamp),
-        ))?;
-        // add another second
-        let two_secs_ahead = first_time_stamp + Duration::seconds(2);
-        index_writer.commit()?;
-
-        let reader = index.reader()?;
-        let searcher = reader.searcher();
-        let reader = searcher.segment_reader(0);
-
-        let date_ff_reader = reader.fast_fields().dates(date_field).unwrap();
-        let mut docids = vec![];
-        date_ff_reader.get_docids_for_value_range(
-            DateTime::from_utc(first_time_stamp)..=DateTime::from_utc(two_secs_ahead),
-            0..5,
-            &mut docids,
-        );
-        assert_eq!(docids, vec![0]);
-
-        let count_multiples =
-            |range_query: RangeQuery| searcher.search(&range_query, &Count).unwrap();
-
-        assert_eq!(
-            count_multiples(RangeQuery::new_date(
-                date_field,
-                DateTime::from_utc(first_time_stamp)..DateTime::from_utc(two_secs_ahead)
-            )),
-            1
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_multivalued_date_docids_for_value_range_2() -> crate::Result<()> {
-        let mut schema_builder = Schema::builder();
-        let date_field = schema_builder.add_date_field(
-            "multi_date_field",
-            DateOptions::default()
-                .set_fast(Cardinality::MultiValues)
-                // TODO: Test different precision after fixing https://github.com/quickwit-oss/tantivy/issues/1783
-                .set_precision(DatePrecision::Microseconds)
-                .set_indexed()
-                .set_fieldnorm()
-                .set_stored(),
-        );
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests()?;
-        let first_time_stamp = OffsetDateTime::now_utc();
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_utc(first_time_stamp),
-            date_field => DateTime::from_utc(first_time_stamp),
-        ))?;
-        index_writer.add_document(doc!())?;
-        // add one second
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_utc(first_time_stamp + Duration::seconds(1)),
-        ))?;
-        // add another second
-        let two_secs_ahead = first_time_stamp + Duration::seconds(2);
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_utc(two_secs_ahead),
-            date_field => DateTime::from_utc(two_secs_ahead),
-            date_field => DateTime::from_utc(two_secs_ahead),
-        ))?;
-        // add three seconds
-        index_writer.add_document(doc!(
-            date_field => DateTime::from_utc(first_time_stamp + Duration::seconds(3)),
-        ))?;
-        index_writer.commit()?;
-
-        let reader = index.reader()?;
-        let searcher = reader.searcher();
-        let reader = searcher.segment_reader(0);
-        assert_eq!(reader.num_docs(), 5);
-
-        let date_ff_reader = reader.fast_fields().dates(date_field).unwrap();
-        let mut docids = vec![];
-        date_ff_reader.get_docids_for_value_range(
-            DateTime::from_utc(first_time_stamp)..=DateTime::from_utc(two_secs_ahead),
-            0..5,
-            &mut docids,
-        );
-        assert_eq!(docids, vec![0, 2, 3]);
-
-        let count_multiples =
-            |range_query: RangeQuery| searcher.search(&range_query, &Count).unwrap();
-
-        assert_eq!(
-            count_multiples(RangeQuery::new_date(
-                date_field,
-                DateTime::from_utc(first_time_stamp)..DateTime::from_utc(two_secs_ahead)
-            )),
-            2
-        );
-
-        Ok(())
-    }
 
     #[test]
     fn test_multifastfield_reader() -> crate::Result<()> {

src/fastfield/readers.rs

@@ -3,9 +3,11 @@ use std::sync::Arc;
 
 use fastfield_codecs::{open, open_u128, Column};
 
-use super::multivalued::MultiValuedFastFieldReader;
+use super::multivalued::MultiValuedU128FastFieldReader;
 use crate::directory::{CompositeFile, FileSlice};
-use crate::fastfield::{BytesFastFieldReader, FastFieldNotAvailableError, FastValue};
+use crate::fastfield::{
+    BytesFastFieldReader, FastFieldNotAvailableError, FastValue, MultiValuedFastFieldReader,
+};
 use crate::schema::{Cardinality, Field, FieldType, Schema};
 use crate::space_usage::PerFieldSpaceUsage;
 use crate::{DateTime, TantivyError};
@@ -159,14 +161,20 @@ impl FastFieldReaders {
     /// Returns the `ip` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.
-    pub fn ip_addrs(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<Ipv6Addr>> {
+    pub fn ip_addrs(
+        &self,
+        field: Field,
+    ) -> crate::Result<MultiValuedU128FastFieldReader<Ipv6Addr>> {
         self.check_type(field, FastType::U128, Cardinality::MultiValues)?;
         let idx_reader: Arc<dyn Column<u64>> = self.typed_fast_field_reader(field)?;
 
         let bytes = self.fast_field_data(field, 1)?.read_bytes()?;
         let vals_reader = open_u128::<Ipv6Addr>(bytes)?;
 
-        Ok(MultiValuedFastFieldReader::open(idx_reader, vals_reader))
+        Ok(MultiValuedU128FastFieldReader::open(
+            idx_reader,
+            vals_reader,
+        ))
     }
 
     /// Returns the `u128` fast field reader reader associated to `field`.
@@ -181,14 +189,17 @@ impl FastFieldReaders {
     /// Returns the `u128` multi-valued fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 multi-valued fast field, this method returns an Error.
-    pub fn u128s(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<u128>> {
+    pub fn u128s(&self, field: Field) -> crate::Result<MultiValuedU128FastFieldReader<u128>> {
         self.check_type(field, FastType::U128, Cardinality::MultiValues)?;
         let idx_reader: Arc<dyn Column<u64>> = self.typed_fast_field_reader(field)?;
 
         let bytes = self.fast_field_data(field, 1)?.read_bytes()?;
         let vals_reader = open_u128::<u128>(bytes)?;
 
-        Ok(MultiValuedFastFieldReader::open(idx_reader, vals_reader))
+        Ok(MultiValuedU128FastFieldReader::open(
+            idx_reader,
+            vals_reader,
+        ))
     }
 
     /// Returns the `u64` fast field reader reader associated with `field`, regardless of whether

src/fastfield/serializer/mod.rs

@@ -1,4 +1,3 @@
-use std::fmt;
 use std::io::{self, Write};
 
 pub use fastfield_codecs::Column;
@@ -50,7 +49,7 @@ impl CompositeFastFieldSerializer {
 
     /// Serialize data into a new u64 fast field. The best compression codec will be chosen
     /// automatically.
-    pub fn create_auto_detect_u64_fast_field<T: MonotonicallyMappableToU64 + fmt::Debug>(
+    pub fn create_auto_detect_u64_fast_field<T: MonotonicallyMappableToU64>(
         &mut self,
         field: Field,
         fastfield_accessor: impl Column<T>,
@@ -60,9 +59,7 @@ impl CompositeFastFieldSerializer {
 
     /// Serialize data into a new u64 fast field. The best compression codec will be chosen
     /// automatically.
-    pub fn create_auto_detect_u64_fast_field_with_idx<
+    pub fn create_auto_detect_u64_fast_field_with_idx<T: MonotonicallyMappableToU64>(
-        T: MonotonicallyMappableToU64 + fmt::Debug,
-    >(
         &mut self,
         field: Field,
         fastfield_accessor: impl Column<T>,
@@ -75,9 +72,7 @@ impl CompositeFastFieldSerializer {
 
     /// Serialize data into a new u64 fast field. The best compression codec of the the provided
     /// will be chosen.
-    pub fn create_auto_detect_u64_fast_field_with_idx_and_codecs<
+    pub fn create_auto_detect_u64_fast_field_with_idx_and_codecs<T: MonotonicallyMappableToU64>(
-        T: MonotonicallyMappableToU64 + fmt::Debug,
-    >(
         &mut self,
         field: Field,
         fastfield_accessor: impl Column<T>,

src/indexer/index_writer.rs

@@ -678,7 +678,7 @@ impl IndexWriter {
     /// only after calling `commit()`.
     #[doc(hidden)]
     pub fn delete_query(&self, query: Box<dyn Query>) -> crate::Result<Opstamp> {
-        let weight = query.weight(EnableScoring::disabled_from_schema(&self.index.schema()))?;
+        let weight = query.weight(EnableScoring::Disabled(&self.index.schema()))?;
         let opstamp = self.stamper.stamp();
         let delete_operation = DeleteOperation {
             opstamp,
@@ -759,8 +759,7 @@ impl IndexWriter {
             match user_op {
                 UserOperation::Delete(term) => {
                     let query = TermQuery::new(term, IndexRecordOption::Basic);
-                    let weight =
+                    let weight = query.weight(EnableScoring::Disabled(&self.index.schema()))?;
-                        query.weight(EnableScoring::disabled_from_schema(&self.index.schema()))?;
                     let delete_operation = DeleteOperation {
                         opstamp,
                         target: weight,

src/indexer/json_term_writer.rs

@@ -89,11 +89,11 @@ pub(crate) fn index_json_values<'a>(
     Ok(())
 }
 
-fn index_json_object(
+fn index_json_object<'a>(
     doc: DocId,
     json_value: &serde_json::Map<String, serde_json::Value>,
     text_analyzer: &TextAnalyzer,
-    json_term_writer: &mut JsonTermWriter,
+    json_term_writer: &mut JsonTermWriter<'a>,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
     positions_per_path: &mut IndexingPositionsPerPath,
@@ -113,11 +113,11 @@ fn index_json_object(
     }
 }
 
-fn index_json_value(
+fn index_json_value<'a>(
     doc: DocId,
     json_value: &serde_json::Value,
     text_analyzer: &TextAnalyzer,
-    json_term_writer: &mut JsonTermWriter,
+    json_term_writer: &mut JsonTermWriter<'a>,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
     positions_per_path: &mut IndexingPositionsPerPath,

src/indexer/merger.rs

@@ -13,7 +13,7 @@ use crate::docset::{DocSet, TERMINATED};
 use crate::error::DataCorruption;
 use crate::fastfield::{
     get_fastfield_codecs_for_multivalue, AliveBitSet, Column, CompositeFastFieldSerializer,
-    MultiValueIndex, MultiValuedFastFieldReader,
+    MultiValueIndex, MultiValuedFastFieldReader, MultiValuedU128FastFieldReader,
 };
 use crate::fieldnorm::{FieldNormReader, FieldNormReaders, FieldNormsSerializer, FieldNormsWriter};
 use crate::indexer::doc_id_mapping::{expect_field_id_for_sort_field, SegmentDocIdMapping};
@@ -331,18 +331,18 @@ impl IndexMerger {
         fast_field_serializer: &mut CompositeFastFieldSerializer,
         doc_id_mapping: &SegmentDocIdMapping,
     ) -> crate::Result<()> {
-        let segment_and_ff_readers: Vec<(&SegmentReader, MultiValuedFastFieldReader<u128>)> = self
+        let segment_and_ff_readers: Vec<(&SegmentReader, MultiValuedU128FastFieldReader<u128>)> =
-            .readers
+            self.readers
-            .iter()
+                .iter()
-            .map(|segment_reader| {
+                .map(|segment_reader| {
-                let ff_reader: MultiValuedFastFieldReader<u128> =
+                    let ff_reader: MultiValuedU128FastFieldReader<u128> =
-                    segment_reader.fast_fields().u128s(field).expect(
+                        segment_reader.fast_fields().u128s(field).expect(
-                        "Failed to find index for multivalued field. This is a bug in tantivy, \
+                            "Failed to find index for multivalued field. This is a bug in \
-                         please report.",
+                             tantivy, please report.",
-                    );
+                        );
-                (segment_reader, ff_reader)
+                    (segment_reader, ff_reader)
-            })
+                })
-            .collect::<Vec<_>>();
+                .collect::<Vec<_>>();
 
         Self::write_1_n_fast_field_idx_generic(
             field,

src/indexer/segment_updater.rs

@@ -577,7 +577,7 @@ impl SegmentUpdater {
         for merge_operation in merge_candidates {
             // If a merge cannot be started this is not a fatal error.
             // We do log a warning in `start_merge`.
-            drop(self.start_merge(merge_operation));
+            let _ = self.start_merge(merge_operation);
         }
     }
 

src/indexer/stamper.rs

@@ -20,7 +20,7 @@ mod atomic_impl {
         }
 
         pub fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
-            self.0.fetch_add(val, order)
+            self.0.fetch_add(val, order) as u64
         }
 
         pub fn revert(&self, val: u64, order: Ordering) -> u64 {

src/lib.rs

@@ -1,14 +1,17 @@
 #![doc(html_logo_url = "http://fulmicoton.com/tantivy-logo/tantivy-logo.png")]
 #![cfg_attr(all(feature = "unstable", test), feature(test))]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        clippy::module_inception,
+        clippy::needless_range_loop,
+        clippy::bool_assert_comparison
+    )
+)]
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![warn(missing_docs)]
-#![allow(
+#![allow(clippy::len_without_is_empty)]
-    clippy::len_without_is_empty,
+#![allow(clippy::derive_partial_eq_without_eq)]
-    clippy::derive_partial_eq_without_eq,
-    clippy::module_inception,
-    clippy::needless_range_loop,
-    clippy::bool_assert_comparison
-)]
 
 //! # `tantivy`
 //!
@@ -141,7 +144,7 @@ use crate::time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
 /// All constructors and conversions are provided as explicit
 /// functions and not by implementing any `From`/`Into` traits
 /// to prevent unintended usage.
-#[derive(Clone, Default, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct DateTime {
     // Timestamp in microseconds.
     pub(crate) timestamp_micros: i64,

src/postings/compression/mod.rs

@@ -291,7 +291,7 @@ pub mod tests {
         const PADDING_VALUE: u32 = 234_234_345u32;
         let expected_length = 154;
         let mut encoder = BlockEncoder::new();
-        let input: Vec<u32> = (0u32..123u32).map(|i| 4 + i * 7 / 2).collect();
+        let input: Vec<u32> = (0u32..123u32).map(|i| 4 + i * 7 / 2).into_iter().collect();
         for offset in &[0u32, 1u32, 2u32] {
             let encoded_data = encoder.compress_vint_sorted(&input, *offset);
             assert!(encoded_data.len() <= expected_length);

src/postings/mod.rs

@@ -631,7 +631,7 @@ mod bench {
             let mut segment_postings = segment_reader
                 .inverted_index(TERM_A.field())
                 .unwrap()
-                .read_postings(&TERM_A, IndexRecordOption::Basic)
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             while segment_postings.advance() != TERMINATED {}
@@ -647,25 +647,25 @@ mod bench {
             let segment_postings_a = segment_reader
                 .inverted_index(TERM_A.field())
                 .unwrap()
-                .read_postings(&TERM_A, IndexRecordOption::Basic)
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             let segment_postings_b = segment_reader
                 .inverted_index(TERM_B.field())
                 .unwrap()
-                .read_postings(&TERM_B, IndexRecordOption::Basic)
+                .read_postings(&*TERM_B, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             let segment_postings_c = segment_reader
                 .inverted_index(TERM_C.field())
                 .unwrap()
-                .read_postings(&TERM_C, IndexRecordOption::Basic)
+                .read_postings(&*TERM_C, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             let segment_postings_d = segment_reader
                 .inverted_index(TERM_D.field())
                 .unwrap()
-                .read_postings(&TERM_D, IndexRecordOption::Basic)
+                .read_postings(&*TERM_D, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             let mut intersection = Intersection::new(vec![
@@ -687,7 +687,7 @@ mod bench {
         let mut segment_postings = segment_reader
             .inverted_index(TERM_A.field())
             .unwrap()
-            .read_postings(&TERM_A, IndexRecordOption::Basic)
+            .read_postings(&*TERM_A, IndexRecordOption::Basic)
             .unwrap()
             .unwrap();
 
@@ -705,7 +705,7 @@ mod bench {
             let mut segment_postings = segment_reader
                 .inverted_index(TERM_A.field())
                 .unwrap()
-                .read_postings(&TERM_A, IndexRecordOption::Basic)
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             for doc in &existing_docs {
@@ -746,7 +746,7 @@ mod bench {
             let mut segment_postings = segment_reader
                 .inverted_index(TERM_A.field())
                 .unwrap()
-                .read_postings(&TERM_A, IndexRecordOption::Basic)
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap()
                 .unwrap();
             let mut s = 0u32;

src/postings/serializer.rs

@@ -213,21 +213,21 @@ impl<'a> FieldSerializer<'a> {
         fail_point!("FieldSerializer::close_term", |msg: Option<String>| {
             Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", msg)))
         });
-        if self.term_open {
+        if !self.term_open {
-            self.postings_serializer
+            return Ok(());
-                .close_term(self.current_term_info.doc_freq)?;
-            self.current_term_info.postings_range.end =
-                self.postings_serializer.written_bytes() as usize;
-
-            if let Some(positions_serializer) = self.positions_serializer_opt.as_mut() {
-                positions_serializer.close_term()?;
-                self.current_term_info.positions_range.end =
-                    positions_serializer.written_bytes() as usize;
-            }
-            self.term_dictionary_builder
-                .insert_value(&self.current_term_info)?;
-            self.term_open = false;
         }
+        self.postings_serializer
+            .close_term(self.current_term_info.doc_freq)?;
+        self.current_term_info.postings_range.end =
+            self.postings_serializer.written_bytes() as usize;
+        if let Some(positions_serializer) = self.positions_serializer_opt.as_mut() {
+            positions_serializer.close_term()?;
+            self.current_term_info.positions_range.end =
+                positions_serializer.written_bytes() as usize;
+        }
+        self.term_dictionary_builder
+            .insert_value(&self.current_term_info)?;
+        self.term_open = false;
         Ok(())
     }
 

src/query/all_query.rs

@@ -95,7 +95,7 @@ mod tests {
         let index = create_test_index()?;
         let reader = index.reader()?;
         let searcher = reader.searcher();
-        let weight = AllQuery.weight(EnableScoring::disabled_from_schema(&index.schema()))?;
+        let weight = AllQuery.weight(EnableScoring::Disabled(&index.schema()))?;
         {
             let reader = searcher.segment_reader(0);
             let mut scorer = weight.scorer(reader, 1.0)?;
@@ -118,7 +118,7 @@ mod tests {
         let index = create_test_index()?;
         let reader = index.reader()?;
         let searcher = reader.searcher();
-        let weight = AllQuery.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
+        let weight = AllQuery.weight(EnableScoring::Disabled(searcher.schema()))?;
         let reader = searcher.segment_reader(0);
         {
             let mut scorer = weight.scorer(reader, 2.0)?;

src/query/boolean_query/boolean_query.rs

@@ -146,7 +146,7 @@ impl Query for BooleanQuery {
         let sub_weights = self
             .subqueries
             .iter()
-            .map(|(occur, subquery)| Ok((*occur, subquery.weight(enable_scoring)?)))
+            .map(|&(ref occur, ref subquery)| Ok((*occur, subquery.weight(enable_scoring)?)))
             .collect::<crate::Result<_>>()?;
         Ok(Box::new(BooleanWeight::new(
             sub_weights,

src/query/boolean_query/boolean_weight.rs

@@ -91,7 +91,7 @@ impl<TScoreCombiner: ScoreCombiner> BooleanWeight<TScoreCombiner> {
         boost: Score,
     ) -> crate::Result<HashMap<Occur, Vec<Box<dyn Scorer>>>> {
         let mut per_occur_scorers: HashMap<Occur, Vec<Box<dyn Scorer>>> = HashMap::new();
-        for (occur, subweight) in &self.weights {
+        for &(ref occur, ref subweight) in &self.weights {
             let sub_scorer: Box<dyn Scorer> = subweight.scorer(reader, boost)?;
             per_occur_scorers
                 .entry(*occur)
@@ -191,7 +191,7 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
         }
 
         let mut explanation = Explanation::new("BooleanClause. Sum of ...", scorer.score());
-        for (occur, subweight) in &self.weights {
+        for &(ref occur, ref subweight) in &self.weights {
             if is_positive_occur(*occur) {
                 if let Ok(child_explanation) = subweight.explain(reader, doc) {
                     explanation.add_detail(child_explanation);

src/query/boolean_query/mod.rs

@@ -98,7 +98,7 @@ mod tests {
         }
         {
             let query = query_parser.parse_query("+a b")?;
-            let weight = query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
+            let weight = query.weight(EnableScoring::Disabled(searcher.schema()))?;
             let scorer = weight.scorer(searcher.segment_reader(0u32), 1.0)?;
             assert!(scorer.is::<TermScorer>());
         }

src/query/disjunction_max_query.rs

@@ -3,7 +3,7 @@ use tantivy_query_grammar::Occur;
 use crate::query::{BooleanWeight, DisjunctionMaxCombiner, EnableScoring, Query, Weight};
 use crate::{Score, Term};
 
-/// The disjunction max query returns documents matching one or more wrapped queries,
+/// The disjunction max query кeturns documents matching one or more wrapped queries,
 /// called query clauses or clauses.
 ///
 /// If a returned document matches multiple query clauses,

src/query/fuzzy_query.rs

@@ -1,5 +1,8 @@
+use std::collections::HashMap;
+use std::ops::Range;
+
 use levenshtein_automata::{Distance, LevenshteinAutomatonBuilder, DFA};
-use once_cell::sync::OnceCell;
+use once_cell::sync::Lazy;
 use tantivy_fst::Automaton;
 
 use crate::query::{AutomatonWeight, EnableScoring, Query, Weight};
@@ -31,6 +34,22 @@ impl Automaton for DfaWrapper {
     }
 }
 
+/// A range of Levenshtein distances that we will build DFAs for our terms
+/// The computation is exponential, so best keep it to low single digits
+const VALID_LEVENSHTEIN_DISTANCE_RANGE: Range<u8> = 0..3;
+
+static LEV_BUILDER: Lazy<HashMap<(u8, bool), LevenshteinAutomatonBuilder>> = Lazy::new(|| {
+    let mut lev_builder_cache = HashMap::new();
+    // TODO make population lazy on a `(distance, val)` basis
+    for distance in VALID_LEVENSHTEIN_DISTANCE_RANGE {
+        for &transposition in &[false, true] {
+            let lev_automaton_builder = LevenshteinAutomatonBuilder::new(distance, transposition);
+            lev_builder_cache.insert((distance, transposition), lev_automaton_builder);
+        }
+    }
+    lev_builder_cache
+});
+
 /// A Fuzzy Query matches all of the documents
 /// containing a specific term that is within
 /// Levenshtein distance
@@ -110,39 +129,30 @@ impl FuzzyTermQuery {
     }
 
     fn specialized_weight(&self) -> crate::Result<AutomatonWeight<DfaWrapper>> {
-        static AUTOMATON_BUILDER: [[OnceCell<LevenshteinAutomatonBuilder>; 2]; 3] = [
+        // LEV_BUILDER is a HashMap, whose `get` method returns an Option
-            [OnceCell::new(), OnceCell::new()],
+        match LEV_BUILDER.get(&(self.distance, self.transposition_cost_one)) {
-            [OnceCell::new(), OnceCell::new()],
+            // Unwrap the option and build the Ok(AutomatonWeight)
-            [OnceCell::new(), OnceCell::new()],
+            Some(automaton_builder) => {
-        ];
+                let term_text = self.term.as_str().ok_or_else(|| {
-
+                    crate::TantivyError::InvalidArgument(
-        let automaton_builder = AUTOMATON_BUILDER
+                        "The fuzzy term query requires a string term.".to_string(),
-            .get(self.distance as usize)
+                    )
-            .ok_or_else(|| {
+                })?;
-                InvalidArgument(format!(
+                let automaton = if self.prefix {
-                    "Levenshtein distance of {} is not allowed. Choose a value less than {}",
+                    automaton_builder.build_prefix_dfa(term_text)
-                    self.distance,
+                } else {
-                    AUTOMATON_BUILDER.len()
+                    automaton_builder.build_dfa(term_text)
+                };
+                Ok(AutomatonWeight::new(
+                    self.term.field(),
+                    DfaWrapper(automaton),
                 ))
-            })?
+            }
-            .get(self.transposition_cost_one as usize)
+            None => Err(InvalidArgument(format!(
-            .unwrap()
+                "Levenshtein distance of {} is not allowed. Choose a value in the {:?} range",
-            .get_or_init(|| {
+                self.distance, VALID_LEVENSHTEIN_DISTANCE_RANGE
-                LevenshteinAutomatonBuilder::new(self.distance, self.transposition_cost_one)
+            ))),
-            });
+        }
-
-        let term_text = self.term.as_str().ok_or_else(|| {
-            InvalidArgument("The fuzzy term query requires a string term.".to_string())
-        })?;
-        let automaton = if self.prefix {
-            automaton_builder.build_prefix_dfa(term_text)
-        } else {
-            automaton_builder.build_dfa(term_text)
-        };
-        Ok(AutomatonWeight::new(
-            self.term.field(),
-            DfaWrapper(automaton),
-        ))
     }
 }
 

src/query/mod.rs

@@ -16,6 +16,7 @@ mod phrase_query;
 mod query;
 mod query_parser;
 mod range_query;
+mod range_query_ip_fastfield;
 mod regex_query;
 mod reqopt_scorer;
 mod scorer;

src/query/more_like_this/query.rs

@@ -45,7 +45,7 @@ impl Query for MoreLikeThisQuery {
     fn weight(&self, enable_scoring: EnableScoring<'_>) -> crate::Result<Box<dyn Weight>> {
         let searcher = match enable_scoring {
             EnableScoring::Enabled(searcher) => searcher,
-            EnableScoring::Disabled { .. } => {
+            EnableScoring::Disabled(_) => {
                 let err = "MoreLikeThisQuery requires to enable scoring.".to_string();
                 return Err(crate::TantivyError::InvalidArgument(err));
             }

src/query/phrase_query/mod.rs

@@ -80,7 +80,7 @@ pub mod tests {
             .collect();
         let phrase_query = PhraseQuery::new(terms);
         let phrase_weight =
-            phrase_query.phrase_weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
+            phrase_query.phrase_weight(EnableScoring::Disabled(searcher.schema()))?;
         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);
@@ -361,7 +361,7 @@ pub mod tests {
             let query_parser = QueryParser::for_index(&index, vec![json_field]);
             let phrase_query = query_parser.parse_query(query).unwrap();
             let phrase_weight = phrase_query
-                .weight(EnableScoring::disabled_from_schema(searcher.schema()))
+                .weight(EnableScoring::Disabled(searcher.schema()))
                 .unwrap();
             let mut phrase_scorer = phrase_weight
                 .scorer(searcher.segment_reader(0), 1.0f32)

src/query/phrase_query/phrase_query.rs

@@ -109,7 +109,7 @@ impl PhraseQuery {
         let terms = self.phrase_terms();
         let bm25_weight_opt = match enable_scoring {
             EnableScoring::Enabled(searcher) => Some(Bm25Weight::for_terms(searcher, &terms)?),
-            EnableScoring::Disabled { .. } => None,
+            EnableScoring::Disabled(_) => None,
         };
         let mut weight = PhraseWeight::new(self.phrase_terms.clone(), bm25_weight_opt);
         if self.slop > 0 {

src/query/query.rs

@@ -15,55 +15,24 @@ pub enum EnableScoring<'a> {
     Enabled(&'a Searcher),
     /// Pass this to disable scoring.
     /// This can improve performance.
-    Disabled {
+    Disabled(&'a Schema),
-        /// Schema is required.
-        schema: &'a Schema,
-        /// Searcher should be provided if available.
-        searcher_opt: Option<&'a Searcher>,
-    },
 }
 
 impl<'a> EnableScoring<'a> {
-    /// Create using [Searcher] with scoring enabled.
-    pub fn enabled_from_searcher(searcher: &'a Searcher) -> EnableScoring<'a> {
-        EnableScoring::Enabled(searcher)
-    }
-
-    /// Create using [Searcher] with scoring disabled.
-    pub fn disabled_from_searcher(searcher: &'a Searcher) -> EnableScoring<'a> {
-        EnableScoring::Disabled {
-            schema: searcher.schema(),
-            searcher_opt: Some(searcher),
-        }
-    }
-
-    /// Create using [Schema] with scoring disabled.
-    pub fn disabled_from_schema(schema: &'a Schema) -> EnableScoring<'a> {
-        Self::Disabled {
-            schema,
-            searcher_opt: None,
-        }
-    }
-
-    /// Returns the searcher if available.
-    pub fn searcher(&self) -> Option<&Searcher> {
-        match self {
-            EnableScoring::Enabled(searcher) => Some(searcher),
-            EnableScoring::Disabled { searcher_opt, .. } => searcher_opt.to_owned(),
-        }
-    }
-
     /// Returns the schema.
     pub fn schema(&self) -> &Schema {
         match self {
             EnableScoring::Enabled(searcher) => searcher.schema(),
-            EnableScoring::Disabled { schema, .. } => schema,
+            EnableScoring::Disabled(schema) => schema,
         }
     }
 
     /// Returns true if the scoring is enabled.
     pub fn is_scoring_enabled(&self) -> bool {
-        matches!(self, EnableScoring::Enabled(..))
+        match self {
+            EnableScoring::Enabled(_) => true,
+            EnableScoring::Disabled(_) => false,
+        }
     }
 }
 
@@ -112,14 +81,14 @@ pub trait Query: QueryClone + Send + Sync + downcast_rs::Downcast + fmt::Debug {
 
     /// Returns an `Explanation` for the score of the document.
     fn explain(&self, searcher: &Searcher, doc_address: DocAddress) -> crate::Result<Explanation> {
-        let weight = self.weight(EnableScoring::enabled_from_searcher(searcher))?;
+        let weight = self.weight(EnableScoring::Enabled(searcher))?;
         let reader = searcher.segment_reader(doc_address.segment_ord);
         weight.explain(reader, doc_address.doc_id)
     }
 
     /// Returns the number of documents matching the query.
     fn count(&self, searcher: &Searcher) -> crate::Result<usize> {
-        let weight = self.weight(EnableScoring::disabled_from_searcher(searcher))?;
+        let weight = self.weight(EnableScoring::Disabled(searcher.schema()))?;
         let mut result = 0;
         for reader in searcher.segment_readers() {
             result += weight.count(reader)? as usize;

src/query/query_parser/logical_ast.rs

@@ -54,9 +54,9 @@ impl fmt::Debug for LogicalAst {
                 if clause.is_empty() {
                     write!(formatter, "<emptyclause>")?;
                 } else {
-                    let (occur, subquery) = &clause[0];
+                    let (ref occur, ref subquery) = clause[0];
                     write!(formatter, "({}{:?}", occur_letter(*occur), subquery)?;
-                    for (occur, subquery) in &clause[1..] {
+                    for &(ref occur, ref subquery) in &clause[1..] {
                         write!(formatter, " {}{:?}", occur_letter(*occur), subquery)?;
                     }
                     formatter.write_str(")")?;

src/query/query_parser/query_parser.rs

@@ -1,11 +1,9 @@
+use std::collections::HashMap;
 use std::net::{AddrParseError, IpAddr};
 use std::num::{ParseFloatError, ParseIntError};
 use std::ops::Bound;
 use std::str::{FromStr, ParseBoolError};
 
-use base64::engine::general_purpose::STANDARD as BASE64;
-use base64::Engine;
-use rustc_hash::FxHashMap;
 use tantivy_query_grammar::{UserInputAst, UserInputBound, UserInputLeaf, UserInputLiteral};
 
 use super::logical_ast::*;
@@ -13,10 +11,9 @@ use crate::core::Index;
 use crate::indexer::{
     convert_to_fast_value_and_get_term, set_string_and_get_terms, JsonTermWriter,
 };
-use crate::query::range_query::is_type_valid_for_fastfield_range_query;
 use crate::query::{
-    AllQuery, BooleanQuery, BoostQuery, EmptyQuery, FuzzyTermQuery, Occur, PhraseQuery, Query,
+    AllQuery, BooleanQuery, BoostQuery, EmptyQuery, Occur, PhraseQuery, Query, RangeQuery,
-    RangeQuery, TermQuery, TermSetQuery,
+    TermQuery, TermSetQuery,
 };
 use crate::schema::{
     Facet, FacetParseError, Field, FieldType, IndexRecordOption, IntoIpv6Addr, JsonObjectOptions,
@@ -37,7 +34,7 @@ pub enum QueryParserError {
     #[error("Unsupported query: {0}")]
     UnsupportedQuery(String),
     /// The query references a field that is not in the schema
-    #[error("Field does not exist: '{0}'")]
+    #[error("Field does not exists: '{0}'")]
     FieldDoesNotExist(String),
     /// The query contains a term for a `u64` or `i64`-field, but the value
     /// is neither.
@@ -163,10 +160,6 @@ fn trim_ast(logical_ast: LogicalAst) -> Option<LogicalAst> {
 ///   word lexicographically between `a` and `c` (inclusive lower bound, exclusive upper bound).
 ///   Inclusive bounds are `[]`, exclusive are `{}`.
 ///
-/// * set terms: Using the `IN` operator, a field can be matched against a set of literals, e.g.
-///   `title: IN [a b cd]` will match documents where `title` is either `a`, `b` or `cd`, but do so
-///   more efficiently than the alternative query `title:a OR title:b OR title:c` does.
-///
 /// * date values: The query parser supports rfc3339 formatted dates. For example
 ///   `"2002-10-02T15:00:00.05Z"` or `some_date_field:[2002-10-02T15:00:00Z TO
 ///   2002-10-02T18:00:00Z}`
@@ -181,9 +174,6 @@ fn trim_ast(logical_ast: LogicalAst) -> Option<LogicalAst> {
 /// (See [`set_field_boost(...)`](QueryParser::set_field_boost)). Typically you may want to boost a
 /// title field.
 ///
-/// Additionally, specific fields can be marked to use fuzzy term queries for each literal
-/// via the [`QueryParser::set_field_fuzzy`] method.
-///
 /// Phrase terms support the `~` slop operator which allows to set the phrase's matching
 /// distance in words. `"big wolf"~1` will return documents containing the phrase `"big bad wolf"`.
 #[derive(Clone)]
@@ -192,15 +182,7 @@ pub struct QueryParser {
     default_fields: Vec<Field>,
     conjunction_by_default: bool,
     tokenizer_manager: TokenizerManager,
-    boost: FxHashMap<Field, Score>,
+    boost: HashMap<Field, Score>,
-    fuzzy: FxHashMap<Field, Fuzzy>,
-}
-
-#[derive(Clone)]
-struct Fuzzy {
-    prefix: bool,
-    distance: u8,
-    transpose_cost_one: bool,
 }
 
 fn all_negative(ast: &LogicalAst) -> bool {
@@ -228,7 +210,6 @@ impl QueryParser {
             tokenizer_manager,
             conjunction_by_default: false,
             boost: Default::default(),
-            fuzzy: Default::default(),
         }
     }
 
@@ -266,30 +247,6 @@ impl QueryParser {
         self.boost.insert(field, boost);
     }
 
-    /// Sets the given [field][`Field`] to use [fuzzy term queries][`FuzzyTermQuery`]
-    ///
-    /// If set, the parse will produce queries using fuzzy term queries
-    /// with the given parameters for each literal matched against the given field.
-    ///
-    /// See the [`FuzzyTermQuery::new`] and [`FuzzyTermQuery::new_prefix`] methods
-    /// for the meaning of the individual parameters.
-    pub fn set_field_fuzzy(
-        &mut self,
-        field: Field,
-        prefix: bool,
-        distance: u8,
-        transpose_cost_one: bool,
-    ) {
-        self.fuzzy.insert(
-            field,
-            Fuzzy {
-                prefix,
-                distance,
-                transpose_cost_one,
-            },
-        );
-    }
-
     /// Parse a query
     ///
     /// Note that `parse_query` returns an error if the input
@@ -302,7 +259,7 @@ impl QueryParser {
     /// in [Issue 5](https://github.com/fulmicoton/tantivy/issues/5)
     pub fn parse_query(&self, query: &str) -> Result<Box<dyn Query>, QueryParserError> {
         let logical_ast = self.parse_query_to_logical_ast(query)?;
-        Ok(convert_to_query(&self.fuzzy, logical_ast))
+        Ok(convert_to_query(logical_ast))
     }
 
     /// Parse the user query into an AST.
@@ -336,10 +293,9 @@ impl QueryParser {
     ) -> Result<Term, QueryParserError> {
         let field_entry = self.schema.get_field_entry(field);
         let field_type = field_entry.field_type();
-        let field_supports_ff_range_queries = field_type.is_fast()
-            && is_type_valid_for_fastfield_range_query(field_type.value_type());
 
-        if !field_type.is_indexed() && !field_supports_ff_range_queries {
+        let is_ip_and_fast = field_type.is_ip_addr() && field_type.is_fast();
+        if !field_type.is_indexed() && !is_ip_and_fast {
             return Err(QueryParserError::FieldNotIndexed(
                 field_entry.name().to_string(),
             ));
@@ -407,9 +363,7 @@ impl QueryParser {
                 Err(e) => Err(QueryParserError::from(e)),
             },
             FieldType::Bytes(_) => {
-                let bytes = BASE64
+                let bytes = base64::decode(phrase).map_err(QueryParserError::ExpectedBase64)?;
-                    .decode(phrase)
-                    .map_err(QueryParserError::ExpectedBase64)?;
                 Ok(Term::from_field_bytes(field, &bytes))
             }
             FieldType::IpAddr(_) => {
@@ -504,9 +458,7 @@ impl QueryParser {
                 Err(e) => Err(QueryParserError::from(e)),
             },
             FieldType::Bytes(_) => {
-                let bytes = BASE64
+                let bytes = base64::decode(phrase).map_err(QueryParserError::ExpectedBase64)?;
-                    .decode(phrase)
-                    .map_err(QueryParserError::ExpectedBase64)?;
                 let bytes_term = Term::from_field_bytes(field, &bytes);
                 Ok(vec![LogicalLiteral::Term(bytes_term)])
             }
@@ -708,30 +660,9 @@ impl QueryParser {
     }
 }
 
-fn convert_literal_to_query(
+fn convert_literal_to_query(logical_literal: LogicalLiteral) -> Box<dyn Query> {
-    fuzzy: &FxHashMap<Field, Fuzzy>,
-    logical_literal: LogicalLiteral,
-) -> Box<dyn Query> {
     match logical_literal {
-        LogicalLiteral::Term(term) => {
+        LogicalLiteral::Term(term) => Box::new(TermQuery::new(term, IndexRecordOption::WithFreqs)),
-            if let Some(fuzzy) = fuzzy.get(&term.field()) {
-                if fuzzy.prefix {
-                    Box::new(FuzzyTermQuery::new_prefix(
-                        term,
-                        fuzzy.distance,
-                        fuzzy.transpose_cost_one,
-                    ))
-                } else {
-                    Box::new(FuzzyTermQuery::new(
-                        term,
-                        fuzzy.distance,
-                        fuzzy.transpose_cost_one,
-                    ))
-                }
-            } else {
-                Box::new(TermQuery::new(term, IndexRecordOption::WithFreqs))
-            }
-        }
         LogicalLiteral::Phrase(term_with_offsets, slop) => Box::new(
             PhraseQuery::new_with_offset_and_slop(term_with_offsets, slop),
         ),
@@ -824,12 +755,12 @@ fn generate_literals_for_json_object(
     Ok(logical_literals)
 }
 
-fn convert_to_query(fuzzy: &FxHashMap<Field, Fuzzy>, logical_ast: LogicalAst) -> Box<dyn Query> {
+fn convert_to_query(logical_ast: LogicalAst) -> Box<dyn Query> {
     match trim_ast(logical_ast) {
         Some(LogicalAst::Clause(trimmed_clause)) => {
             let occur_subqueries = trimmed_clause
                 .into_iter()
-                .map(|(occur, subquery)| (occur, convert_to_query(fuzzy, subquery)))
+                .map(|(occur, subquery)| (occur, convert_to_query(subquery)))
                 .collect::<Vec<_>>();
             assert!(
                 !occur_subqueries.is_empty(),
@@ -838,10 +769,10 @@ fn convert_to_query(fuzzy: &FxHashMap<Field, Fuzzy>, logical_ast: LogicalAst) ->
             Box::new(BooleanQuery::new(occur_subqueries))
         }
         Some(LogicalAst::Leaf(trimmed_logical_literal)) => {
-            convert_literal_to_query(fuzzy, *trimmed_logical_literal)
+            convert_literal_to_query(*trimmed_logical_literal)
         }
         Some(LogicalAst::Boost(ast, boost)) => {
-            let query = convert_to_query(fuzzy, *ast);
+            let query = convert_to_query(*ast);
             let boosted_query = BoostQuery::new(query, boost);
             Box::new(boosted_query)
         }
@@ -857,7 +788,7 @@ mod test {
     use super::{QueryParser, QueryParserError};
     use crate::query::Query;
     use crate::schema::{
-        FacetOptions, Field, IndexRecordOption, Schema, Term, TextFieldIndexing, TextOptions, FAST,
+        FacetOptions, Field, IndexRecordOption, Schema, Term, TextFieldIndexing, TextOptions,
         INDEXED, STORED, STRING, TEXT,
     };
     use crate::tokenizer::{
@@ -891,7 +822,6 @@ mod test {
         schema_builder.add_json_field("json_not_indexed", STORED);
         schema_builder.add_bool_field("bool", INDEXED);
         schema_builder.add_bool_field("notindexed_bool", STORED);
-        schema_builder.add_u64_field("u64_ff", FAST);
         schema_builder.build()
     }
 
@@ -1347,11 +1277,6 @@ mod test {
             r#"(Excluded(Term(type=F64, field=10, -1.5)) TO Excluded(Term(type=F64, field=10, 1.5)))"#,
             false,
         );
-        test_parse_query_to_logical_ast_helper(
-            "u64_ff:[7 TO 77]",
-            r#"(Included(Term(type=U64, field=18, 7)) TO Included(Term(type=U64, field=18, 77)))"#,
-            false,
-        );
     }
 
     #[test]
@@ -1643,41 +1568,4 @@ mod test {
             false,
         );
     }
-
-    #[test]
-    pub fn test_set_field_fuzzy() {
-        {
-            let mut query_parser = make_query_parser();
-            query_parser.set_field_fuzzy(
-                query_parser.schema.get_field("title").unwrap(),
-                false,
-                1,
-                true,
-            );
-            let query = query_parser.parse_query("abc").unwrap();
-            assert_eq!(
-                format!("{:?}", query),
-                "BooleanQuery { subqueries: [(Should, FuzzyTermQuery { term: Term(type=Str, \
-                 field=0, \"abc\"), distance: 1, transposition_cost_one: true, prefix: false }), \
-                 (Should, TermQuery(Term(type=Str, field=1, \"abc\")))] }"
-            );
-        }
-
-        {
-            let mut query_parser = make_query_parser();
-            query_parser.set_field_fuzzy(
-                query_parser.schema.get_field("text").unwrap(),
-                true,
-                2,
-                false,
-            );
-            let query = query_parser.parse_query("abc").unwrap();
-            assert_eq!(
-                format!("{:?}", query),
-                "BooleanQuery { subqueries: [(Should, TermQuery(Term(type=Str, field=0, \
-                 \"abc\"))), (Should, FuzzyTermQuery { term: Term(type=Str, field=1, \"abc\"), \
-                 distance: 2, transposition_cost_one: false, prefix: true })] }"
-            );
-        }
-    }
 }

src/query/range_query.rs

@@ -1,17 +1,16 @@
 use std::io;
 use std::ops::{Bound, Range};
 
-use common::{BinarySerializable, BitSet};
+use common::BitSet;
 
-use super::range_query_u64_fastfield::FastFieldRangeWeight;
 use crate::core::SegmentReader;
 use crate::error::TantivyError;
 use crate::query::explanation::does_not_match;
-use crate::query::range_query::range_query_ip_fastfield::IPFastFieldRangeWeight;
+use crate::query::range_query_ip_fastfield::IPFastFieldRangeWeight;
 use crate::query::{BitSetDocSet, ConstScorer, EnableScoring, Explanation, Query, Scorer, Weight};
 use crate::schema::{Field, IndexRecordOption, Term, Type};
 use crate::termdict::{TermDictionary, TermStreamer};
-use crate::{DateTime, DocId, Score};
+use crate::{DocId, Score};
 
 pub(crate) fn map_bound<TFrom, TTo, Transform: Fn(&TFrom) -> TTo>(
     bound: &Bound<TFrom>,
@@ -204,40 +203,6 @@ impl RangeQuery {
         )
     }
 
-    /// Create a new `RangeQuery` over a `date` field.
-    ///
-    /// The two `Bound` arguments make it possible to create more complex
-    /// ranges than semi-inclusive range.
-    ///
-    /// If the field is not of the type `date`, tantivy
-    /// will panic when the `Weight` object is created.
-    pub fn new_date_bounds(
-        field: Field,
-        left_bound: Bound<DateTime>,
-        right_bound: Bound<DateTime>,
-    ) -> RangeQuery {
-        let make_term_val =
-            |val: &DateTime| Term::from_field_date(field, *val).value_bytes().to_owned();
-        RangeQuery {
-            field,
-            value_type: Type::Date,
-            left_bound: map_bound(&left_bound, &make_term_val),
-            right_bound: map_bound(&right_bound, &make_term_val),
-        }
-    }
-
-    /// Create a new `RangeQuery` over a `date` field.
-    ///
-    /// If the field is not of the type `date`, tantivy
-    /// will panic when the `Weight` object is created.
-    pub fn new_date(field: Field, range: Range<DateTime>) -> RangeQuery {
-        RangeQuery::new_date_bounds(
-            field,
-            Bound::Included(range.start),
-            Bound::Excluded(range.end),
-        )
-    }
-
     /// Create a new `RangeQuery` over a `Str` field.
     ///
     /// The two `Bound` arguments make it possible to create more complex
@@ -287,23 +252,6 @@ impl RangeQuery {
     }
 }
 
-pub(crate) fn is_type_valid_for_fastfield_range_query(typ: Type) -> bool {
-    match typ {
-        Type::U64 | Type::I64 | Type::F64 | Type::Bool | Type::Date => true,
-        Type::IpAddr => true,
-        Type::Str | Type::Facet | Type::Bytes | Type::Json => false,
-    }
-}
-
-/// Returns true if the type maps to a u64 fast field
-pub(crate) fn maps_to_u64_fastfield(typ: Type) -> bool {
-    match typ {
-        Type::U64 | Type::I64 | Type::F64 | Type::Bool | Type::Date => true,
-        Type::IpAddr => false,
-        Type::Str | Type::Facet | Type::Bytes | Type::Json => false,
-    }
-}
-
 impl Query for RangeQuery {
     fn weight(&self, enable_scoring: EnableScoring<'_>) -> crate::Result<Box<dyn Weight>> {
         let schema = enable_scoring.schema();
@@ -317,29 +265,12 @@ impl Query for RangeQuery {
             return Err(TantivyError::SchemaError(err_msg));
         }
 
-        if field_type.is_fast() && is_type_valid_for_fastfield_range_query(self.value_type) {
+        if field_type.is_ip_addr() && field_type.is_fast() {
-            if field_type.is_ip_addr() {
+            Ok(Box::new(IPFastFieldRangeWeight::new(
-                Ok(Box::new(IPFastFieldRangeWeight::new(
+                self.field,
-                    self.field,
+                &self.left_bound,
-                    &self.left_bound,
+                &self.right_bound,
-                    &self.right_bound,
+            )))
-                )))
-            } else {
-                // We run the range query on u64 value space for performance reasons and simpicity
-                // assert the type maps to u64
-                assert!(maps_to_u64_fastfield(self.value_type));
-                let parse_from_bytes = |data: &Vec<u8>| {
-                    u64::from_be(BinarySerializable::deserialize(&mut &data[..]).unwrap())
-                };
-
-                let left_bound = map_bound(&self.left_bound, &parse_from_bytes);
-                let right_bound = map_bound(&self.right_bound, &parse_from_bytes);
-                Ok(Box::new(FastFieldRangeWeight::new(
-                    self.field,
-                    left_bound,
-                    right_bound,
-                )))
-            }
         } else {
             Ok(Box::new(RangeWeight {
                 field: self.field,

src/query/range_query/fast_field_range_query.rs

@@ -1,210 +0,0 @@
-use core::fmt;
-use std::ops::RangeInclusive;
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
-
-use crate::fastfield::{MakeZero, MultiValuedFastFieldReader};
-use crate::{DocId, DocSet, TERMINATED};
-
-/// Helper to have a cursor over a vec of docids
-struct VecCursor {
-    docs: Vec<u32>,
-    current_pos: usize,
-}
-impl VecCursor {
-    fn new() -> Self {
-        Self {
-            docs: Vec::with_capacity(32),
-            current_pos: 0,
-        }
-    }
-    fn next(&mut self) -> Option<u32> {
-        self.current_pos += 1;
-        self.current()
-    }
-    #[inline]
-    fn current(&self) -> Option<u32> {
-        self.docs.get(self.current_pos).copied()
-    }
-    fn get_cleared_data(&mut self) -> &mut Vec<u32> {
-        self.docs.clear();
-        self.current_pos = 0;
-        &mut self.docs
-    }
-    fn last_value(&self) -> Option<u32> {
-        self.docs.iter().last().cloned()
-    }
-    fn is_empty(&self) -> bool {
-        self.current().is_none()
-    }
-}
-
-pub(crate) enum FastFieldCardinality<T: MakeZero> {
-    SingleValue(Arc<dyn Column<T>>),
-    MultiValue(MultiValuedFastFieldReader<T>),
-}
-
-impl<T: MakeZero + PartialOrd + Copy + fmt::Debug> FastFieldCardinality<T> {
-    fn num_docs(&self) -> u32 {
-        match self {
-            FastFieldCardinality::SingleValue(single_value) => single_value.num_vals(),
-            FastFieldCardinality::MultiValue(multi_value) => {
-                multi_value.get_index_reader().num_docs()
-            }
-        }
-    }
-}
-
-pub(crate) struct RangeDocSet<T: MakeZero> {
-    /// The range filter on the values.
-    value_range: RangeInclusive<T>,
-    fast_field: FastFieldCardinality<T>,
-    /// The next docid start range to fetch (inclusive).
-    next_fetch_start: u32,
-    /// Number of docs range checked in a batch.
-    ///
-    /// There are two patterns.
-    /// - We do a full scan. => We can load large chunks. We don't know in advance if seek call
-    /// will come, so we start with small chunks
-    /// - We load docs, interspersed with seek calls. When there are big jumps in the seek, we
-    /// should load small chunks. When the seeks are small, we can employ the same strategy as on a
-    /// full scan.
-    fetch_horizon: u32,
-    /// Current batch of loaded docs.
-    loaded_docs: VecCursor,
-    last_seek_pos_opt: Option<u32>,
-}
-
-const DEFAULT_FETCH_HORIZON: u32 = 128;
-impl<T: MakeZero + Send + PartialOrd + Copy + fmt::Debug> RangeDocSet<T> {
-    pub(crate) fn new(value_range: RangeInclusive<T>, fast_field: FastFieldCardinality<T>) -> Self {
-        let mut range_docset = Self {
-            value_range,
-            fast_field,
-            loaded_docs: VecCursor::new(),
-            next_fetch_start: 0,
-            fetch_horizon: DEFAULT_FETCH_HORIZON,
-            last_seek_pos_opt: None,
-        };
-        range_docset.reset_fetch_range();
-        range_docset.fetch_block();
-        range_docset
-    }
-
-    fn reset_fetch_range(&mut self) {
-        self.fetch_horizon = DEFAULT_FETCH_HORIZON;
-    }
-
-    /// Returns true if more data could be fetched
-    fn fetch_block(&mut self) {
-        const MAX_HORIZON: u32 = 100_000;
-        while self.loaded_docs.is_empty() {
-            let finished_to_end = self.fetch_horizon(self.fetch_horizon);
-            if finished_to_end {
-                break;
-            }
-            // Fetch more data, increase horizon. Horizon only gets reset when doing a seek.
-            self.fetch_horizon = (self.fetch_horizon * 2).min(MAX_HORIZON);
-        }
-    }
-
-    /// check if the distance between the seek calls is large
-    fn is_last_seek_distance_large(&self, new_seek: DocId) -> bool {
-        if let Some(last_seek_pos) = self.last_seek_pos_opt {
-            (new_seek - last_seek_pos) >= 128
-        } else {
-            true
-        }
-    }
-
-    /// Fetches a block for docid range [next_fetch_start .. next_fetch_start + HORIZON]
-    fn fetch_horizon(&mut self, horizon: u32) -> bool {
-        let mut finished_to_end = false;
-
-        let limit = self.fast_field.num_docs();
-        let mut end = self.next_fetch_start + horizon;
-        if end >= limit {
-            end = limit;
-            finished_to_end = true;
-        }
-
-        match &self.fast_field {
-            FastFieldCardinality::MultiValue(multi) => {
-                let last_value = self.loaded_docs.last_value();
-
-                multi.get_docids_for_value_range(
-                    self.value_range.clone(),
-                    self.next_fetch_start..end,
-                    self.loaded_docs.get_cleared_data(),
-                );
-                // In case of multivalues, we may have an overlap of the same docid between fetching
-                // blocks
-                if let Some(last_value) = last_value {
-                    while self.loaded_docs.current() == Some(last_value) {
-                        self.loaded_docs.next();
-                    }
-                }
-            }
-            FastFieldCardinality::SingleValue(single) => {
-                single.get_docids_for_value_range(
-                    self.value_range.clone(),
-                    self.next_fetch_start..end,
-                    self.loaded_docs.get_cleared_data(),
-                );
-            }
-        }
-        self.next_fetch_start = end;
-
-        finished_to_end
-    }
-}
-
-impl<T: MakeZero + Send + PartialOrd + Copy + fmt::Debug> DocSet for RangeDocSet<T> {
-    #[inline]
-    fn advance(&mut self) -> DocId {
-        if let Some(docid) = self.loaded_docs.next() {
-            docid
-        } else {
-            if self.next_fetch_start >= self.fast_field.num_docs() {
-                return TERMINATED;
-            }
-            self.fetch_block();
-            self.loaded_docs.current().unwrap_or(TERMINATED)
-        }
-    }
-
-    #[inline]
-    fn doc(&self) -> DocId {
-        self.loaded_docs.current().unwrap_or(TERMINATED)
-    }
-
-    /// Advances the `DocSet` forward until reaching the target, or going to the
-    /// lowest [`DocId`] greater than the target.
-    ///
-    /// If the end of the `DocSet` is reached, [`TERMINATED`] is returned.
-    ///
-    /// Calling `.seek(target)` on a terminated `DocSet` is legal. Implementation
-    /// of `DocSet` should support it.
-    ///
-    /// Calling `seek(TERMINATED)` is also legal and is the normal way to consume a `DocSet`.
-    fn seek(&mut self, target: DocId) -> DocId {
-        if self.is_last_seek_distance_large(target) {
-            self.reset_fetch_range();
-        }
-        if target > self.next_fetch_start {
-            self.next_fetch_start = target;
-        }
-        let mut doc = self.doc();
-        debug_assert!(doc <= target);
-        while doc < target {
-            doc = self.advance();
-        }
-        self.last_seek_pos_opt = Some(target);
-        doc
-    }
-
-    fn size_hint(&self) -> u32 {
-        0 // heuristic possible by checking number of hits when fetching a block
-    }
-}

src/query/range_query/mod.rs

@@ -1,8 +0,0 @@
-mod fast_field_range_query;
-mod range_query;
-mod range_query_ip_fastfield;
-mod range_query_u64_fastfield;
-
-pub(crate) use range_query::is_type_valid_for_fastfield_range_query;
-
-pub use self::range_query::RangeQuery;

src/query/range_query/range_query_u64_fastfield.rs

@@ -1,557 +0,0 @@
-//! Fastfields support efficient scanning for range queries.
-//! We use this variant only if the fastfield exists, otherwise the default in `range_query` is
-//! used, which uses the term dictionary + postings.
-
-use std::ops::{Bound, RangeInclusive};
-
-use fastfield_codecs::MonotonicallyMappableToU64;
-
-use super::fast_field_range_query::{FastFieldCardinality, RangeDocSet};
-use super::range_query::map_bound;
-use crate::query::{ConstScorer, Explanation, Scorer, Weight};
-use crate::schema::{Cardinality, Field};
-use crate::{DocId, DocSet, Score, SegmentReader, TantivyError};
-
-/// `FastFieldRangeWeight` uses the fast field to execute range queries.
-pub struct FastFieldRangeWeight {
-    field: Field,
-    left_bound: Bound<u64>,
-    right_bound: Bound<u64>,
-}
-
-impl FastFieldRangeWeight {
-    pub fn new(field: Field, left_bound: Bound<u64>, right_bound: Bound<u64>) -> Self {
-        let left_bound = map_bound(&left_bound, &|val| *val);
-        let right_bound = map_bound(&right_bound, &|val| *val);
-        Self {
-            field,
-            left_bound,
-            right_bound,
-        }
-    }
-}
-
-impl Weight for FastFieldRangeWeight {
-    fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
-        let field_type = reader.schema().get_field_entry(self.field).field_type();
-        match field_type.fastfield_cardinality().unwrap() {
-            Cardinality::SingleValue => {
-                let fast_field = reader.fast_fields().u64_lenient(self.field)?;
-                let value_range = bound_to_value_range(
-                    &self.left_bound,
-                    &self.right_bound,
-                    fast_field.min_value(),
-                    fast_field.max_value(),
-                );
-                let docset =
-                    RangeDocSet::new(value_range, FastFieldCardinality::SingleValue(fast_field));
-                Ok(Box::new(ConstScorer::new(docset, boost)))
-            }
-            Cardinality::MultiValues => {
-                let fast_field = reader.fast_fields().u64s_lenient(self.field)?;
-                let value_range = bound_to_value_range(
-                    &self.left_bound,
-                    &self.right_bound,
-                    fast_field.min_value(),
-                    fast_field.max_value(),
-                );
-                let docset =
-                    RangeDocSet::new(value_range, FastFieldCardinality::MultiValue(fast_field));
-                Ok(Box::new(ConstScorer::new(docset, boost)))
-            }
-        }
-    }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation> {
-        let mut scorer = self.scorer(reader, 1.0)?;
-        if scorer.seek(doc) != doc {
-            return Err(TantivyError::InvalidArgument(format!(
-                "Document #({}) does not match",
-                doc
-            )));
-        }
-        let explanation = Explanation::new("Const", scorer.score());
-
-        Ok(explanation)
-    }
-}
-
-fn bound_to_value_range<T: MonotonicallyMappableToU64>(
-    left_bound: &Bound<T>,
-    right_bound: &Bound<T>,
-    min_value: T,
-    max_value: T,
-) -> RangeInclusive<T> {
-    let start_value = match left_bound {
-        Bound::Included(val) => *val,
-        Bound::Excluded(val) => T::from_u64(val.to_u64() + 1),
-        Bound::Unbounded => min_value,
-    };
-
-    let end_value = match right_bound {
-        Bound::Included(val) => *val,
-        Bound::Excluded(val) => T::from_u64(val.to_u64() - 1),
-        Bound::Unbounded => max_value,
-    };
-    start_value..=end_value
-}
-
-#[cfg(test)]
-mod tests {
-    use proptest::prelude::ProptestConfig;
-    use proptest::strategy::Strategy;
-    use proptest::{prop_oneof, proptest};
-    use rand::rngs::StdRng;
-    use rand::seq::SliceRandom;
-    use rand::SeedableRng;
-
-    use super::*;
-    use crate::collector::Count;
-    use crate::query::QueryParser;
-    use crate::schema::{NumericOptions, Schema, FAST, INDEXED, STORED, STRING};
-    use crate::Index;
-
-    #[derive(Clone, Debug)]
-    pub struct Doc {
-        pub id_name: String,
-        pub id: u64,
-    }
-
-    fn operation_strategy() -> impl Strategy<Value = Doc> {
-        prop_oneof![
-            (0u64..10_000u64).prop_map(doc_from_id_1),
-            (1u64..10_000u64).prop_map(doc_from_id_2),
-        ]
-    }
-
-    pub fn doc_from_id_1(id: u64) -> Doc {
-        let id = id * 1000;
-        Doc {
-            id_name: id.to_string(),
-            id,
-        }
-    }
-    fn doc_from_id_2(id: u64) -> Doc {
-        let id = id * 1000;
-        Doc {
-            id_name: (id - 1).to_string(),
-            id,
-        }
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(10))]
-        #[test]
-        fn test_range_for_docs_prop(ops in proptest::collection::vec(operation_strategy(), 1..1000)) {
-            assert!(test_id_range_for_docs(ops).is_ok());
-        }
-    }
-
-    #[test]
-    fn range_regression1_test() {
-        let ops = vec![doc_from_id_1(0)];
-        assert!(test_id_range_for_docs(ops).is_ok());
-    }
-
-    #[test]
-    fn range_regression2_test() {
-        let ops = vec![
-            doc_from_id_1(52),
-            doc_from_id_1(63),
-            doc_from_id_1(12),
-            doc_from_id_2(91),
-            doc_from_id_2(33),
-        ];
-        assert!(test_id_range_for_docs(ops).is_ok());
-    }
-
-    #[test]
-    fn range_regression3_test() {
-        let ops = vec![doc_from_id_1(1), doc_from_id_1(2), doc_from_id_1(3)];
-        assert!(test_id_range_for_docs(ops).is_ok());
-    }
-
-    #[test]
-    fn range_regression4_test() {
-        let ops = vec![doc_from_id_2(100)];
-        assert!(test_id_range_for_docs(ops).is_ok());
-    }
-
-    pub fn create_index_from_docs(docs: &[Doc]) -> Index {
-        let mut schema_builder = Schema::builder();
-        let id_u64_field = schema_builder.add_u64_field("id", INDEXED | STORED | FAST);
-        let ids_u64_field = schema_builder.add_u64_field(
-            "ids",
-            NumericOptions::default()
-                .set_fast(Cardinality::MultiValues)
-                .set_indexed(),
-        );
-
-        let id_f64_field = schema_builder.add_f64_field("id_f64", INDEXED | STORED | FAST);
-        let ids_f64_field = schema_builder.add_f64_field(
-            "ids_f64",
-            NumericOptions::default()
-                .set_fast(Cardinality::MultiValues)
-                .set_indexed(),
-        );
-
-        let id_i64_field = schema_builder.add_i64_field("id_i64", INDEXED | STORED | FAST);
-        let ids_i64_field = schema_builder.add_i64_field(
-            "ids_i64",
-            NumericOptions::default()
-                .set_fast(Cardinality::MultiValues)
-                .set_indexed(),
-        );
-
-        let text_field = schema_builder.add_text_field("id_name", STRING | STORED);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        {
-            let mut index_writer = index.writer(3_000_000).unwrap();
-            for doc in docs.iter() {
-                index_writer
-                    .add_document(doc!(
-                        ids_i64_field => doc.id as i64,
-                        ids_i64_field => doc.id as i64,
-                        ids_f64_field => doc.id as f64,
-                        ids_f64_field => doc.id as f64,
-                        ids_u64_field => doc.id,
-                        ids_u64_field => doc.id,
-                        id_u64_field => doc.id,
-                        id_f64_field => doc.id as f64,
-                        id_i64_field => doc.id as i64,
-                        text_field => doc.id_name.to_string(),
-                    ))
-                    .unwrap();
-            }
-
-            index_writer.commit().unwrap();
-        }
-        index
-    }
-
-    fn test_id_range_for_docs(docs: Vec<Doc>) -> crate::Result<()> {
-        let index = create_index_from_docs(&docs);
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
-
-        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
-
-        let get_num_hits = |query| searcher.search(&query, &(Count)).unwrap();
-        let query_from_text = |text: &str| {
-            QueryParser::for_index(&index, vec![])
-                .parse_query(text)
-                .unwrap()
-        };
-
-        let gen_query_inclusive = |field: &str, from: u64, to: u64| {
-            format!("{}:[{} TO {}]", field, &from.to_string(), &to.to_string())
-        };
-
-        let test_sample = |sample_docs: Vec<Doc>| {
-            let mut ids: Vec<u64> = sample_docs.iter().map(|doc| doc.id).collect();
-            ids.sort();
-            let expected_num_hits = docs
-                .iter()
-                .filter(|doc| (ids[0]..=ids[1]).contains(&doc.id))
-                .count();
-
-            let query = gen_query_inclusive("id", ids[0], ids[1]);
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-
-            let query = gen_query_inclusive("ids", ids[0], ids[1]);
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-
-            // Intersection search
-            let id_filter = sample_docs[0].id_name.to_string();
-            let expected_num_hits = docs
-                .iter()
-                .filter(|doc| (ids[0]..=ids[1]).contains(&doc.id) && doc.id_name == id_filter)
-                .count();
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("id", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("id_f64", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("id_i64", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-
-            // Intersection search on multivalue id field
-            let id_filter = sample_docs[0].id_name.to_string();
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("ids", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("ids_f64", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-            let query = format!(
-                "{} AND id_name:{}",
-                gen_query_inclusive("ids_i64", ids[0], ids[1]),
-                &id_filter
-            );
-            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
-        };
-
-        test_sample(vec![docs[0].clone(), docs[0].clone()]);
-
-        let samples: Vec<_> = docs.choose_multiple(&mut rng, 3).collect();
-
-        if samples.len() > 1 {
-            test_sample(vec![samples[0].clone(), samples[1].clone()]);
-            test_sample(vec![samples[1].clone(), samples[1].clone()]);
-        }
-        if samples.len() > 2 {
-            test_sample(vec![samples[1].clone(), samples[2].clone()]);
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use rand::rngs::StdRng;
-    use rand::{Rng, SeedableRng};
-    use test::Bencher;
-
-    use super::tests::*;
-    use super::*;
-    use crate::collector::Count;
-    use crate::query::QueryParser;
-    use crate::Index;
-
-    fn get_index_0_to_100() -> Index {
-        let mut rng = StdRng::from_seed([1u8; 32]);
-        let num_vals = 100_000;
-        let docs: Vec<_> = (0..num_vals)
-            .map(|_i| {
-                let id_name = if rng.gen_bool(0.01) {
-                    "veryfew".to_string() // 1%
-                } else if rng.gen_bool(0.1) {
-                    "few".to_string() // 9%
-                } else {
-                    "many".to_string() // 90%
-                };
-                Doc {
-                    id_name,
-                    id: rng.gen_range(0..100),
-                }
-            })
-            .collect();
-
-        create_index_from_docs(&docs)
-    }
-
-    fn get_90_percent() -> RangeInclusive<u64> {
-        0..=90
-    }
-
-    fn get_10_percent() -> RangeInclusive<u64> {
-        0..=10
-    }
-
-    fn get_1_percent() -> RangeInclusive<u64> {
-        10..=10
-    }
-
-    fn excute_query(
-        field: &str,
-        id_range: RangeInclusive<u64>,
-        suffix: &str,
-        index: &Index,
-    ) -> usize {
-        let gen_query_inclusive = |from: &u64, to: &u64| {
-            format!(
-                "{}:[{} TO {}] {}",
-                field,
-                &from.to_string(),
-                &to.to_string(),
-                suffix
-            )
-        };
-
-        let query = gen_query_inclusive(id_range.start(), id_range.end());
-        let query_from_text = |text: &str| {
-            QueryParser::for_index(index, vec![])
-                .parse_query(text)
-                .unwrap()
-        };
-        let query = query_from_text(&query);
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
-        searcher.search(&query, &(Count)).unwrap()
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_90_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_10_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_1_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent_intersect_with_10_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_10_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_10_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_1_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_90_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_1_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_1_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_1_percent(), "AND id_name:veryfew", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent_intersect_with_90_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_10_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_90_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_90_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_10_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_90_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_1_percent(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("id", get_90_percent(), "AND id_name:veryfew", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_90_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_10_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_1_percent(), "", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent_intersect_with_10_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_10_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_10_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_1_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_90_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_1_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_1_percent_intersect_with_1_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_1_percent(), "AND id_name:veryfew", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_10_percent_intersect_with_90_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_10_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_90_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_90_percent(), "AND id_name:many", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_10_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_90_percent(), "AND id_name:few", &index));
-    }
-
-    #[bench]
-    fn bench_id_range_hit_90_percent_intersect_with_1_percent_multi(bench: &mut Bencher) {
-        let index = get_index_0_to_100();
-
-        bench.iter(|| excute_query("ids", get_90_percent(), "AND id_name:veryfew", &index));
-    }
-}

src/query/range_query_ip_fastfield.rs

@@ -4,15 +4,16 @@
 
 use std::net::Ipv6Addr;
 use std::ops::{Bound, RangeInclusive};
+use std::sync::Arc;
 
 use common::BinarySerializable;
-use fastfield_codecs::MonotonicallyMappableToU128;
+use fastfield_codecs::{Column, MonotonicallyMappableToU128};
 
-use super::fast_field_range_query::{FastFieldCardinality, RangeDocSet};
 use super::range_query::map_bound;
-use crate::query::{ConstScorer, Explanation, Scorer, Weight};
+use super::{ConstScorer, Explanation, Scorer, Weight};
+use crate::fastfield::MultiValuedU128FastFieldReader;
 use crate::schema::{Cardinality, Field};
-use crate::{DocId, DocSet, Score, SegmentReader, TantivyError};
+use crate::{DocId, DocSet, Score, SegmentReader, TantivyError, TERMINATED};
 
 /// `IPFastFieldRangeWeight` uses the ip address fast field to execute range queries.
 pub struct IPFastFieldRangeWeight {
@@ -23,13 +24,13 @@ pub struct IPFastFieldRangeWeight {
 
 impl IPFastFieldRangeWeight {
     pub fn new(field: Field, left_bound: &Bound<Vec<u8>>, right_bound: &Bound<Vec<u8>>) -> Self {
-        let parse_ip_from_bytes = |data: &Vec<u8>| {
+        let ip_from_bound_raw_data = |data: &Vec<u8>| {
-            let ip_u128: u128 =
+            let left_ip_u128: u128 =
                 u128::from_be(BinarySerializable::deserialize(&mut &data[..]).unwrap());
-            Ipv6Addr::from_u128(ip_u128)
+            Ipv6Addr::from_u128(left_ip_u128)
         };
-        let left_bound = map_bound(left_bound, &parse_ip_from_bytes);
+        let left_bound = map_bound(left_bound, &ip_from_bound_raw_data);
-        let right_bound = map_bound(right_bound, &parse_ip_from_bytes);
+        let right_bound = map_bound(right_bound, &ip_from_bound_raw_data);
         Self {
             field,
             left_bound,
@@ -50,9 +51,9 @@ impl Weight for IPFastFieldRangeWeight {
                     ip_addr_fast_field.min_value(),
                     ip_addr_fast_field.max_value(),
                 );
-                let docset = RangeDocSet::new(
+                let docset = IpRangeDocSet::new(
                     value_range,
-                    FastFieldCardinality::SingleValue(ip_addr_fast_field),
+                    IpFastFieldCardinality::SingleValue(ip_addr_fast_field),
                 );
                 Ok(Box::new(ConstScorer::new(docset, boost)))
             }
@@ -64,9 +65,9 @@ impl Weight for IPFastFieldRangeWeight {
                     ip_addr_fast_field.min_value(),
                     ip_addr_fast_field.max_value(),
                 );
-                let docset = RangeDocSet::new(
+                let docset = IpRangeDocSet::new(
                     value_range,
-                    FastFieldCardinality::MultiValue(ip_addr_fast_field),
+                    IpFastFieldCardinality::MultiValue(ip_addr_fast_field),
                 );
                 Ok(Box::new(ConstScorer::new(docset, boost)))
             }
@@ -107,6 +108,213 @@ fn bound_to_value_range(
     start_value..=end_value
 }
 
+/// Helper to have a cursor over a vec of docids
+struct VecCursor {
+    docs: Vec<u32>,
+    current_pos: usize,
+}
+impl VecCursor {
+    fn new() -> Self {
+        Self {
+            docs: Vec::with_capacity(32),
+            current_pos: 0,
+        }
+    }
+    fn next(&mut self) -> Option<u32> {
+        self.current_pos += 1;
+        self.current()
+    }
+    #[inline]
+    fn current(&self) -> Option<u32> {
+        self.docs.get(self.current_pos).copied()
+    }
+    fn get_cleared_data(&mut self) -> &mut Vec<u32> {
+        self.docs.clear();
+        self.current_pos = 0;
+        &mut self.docs
+    }
+    fn last_value(&self) -> Option<u32> {
+        self.docs.iter().last().cloned()
+    }
+    fn is_empty(&self) -> bool {
+        self.current_pos >= self.docs.len()
+    }
+}
+
+pub(crate) enum IpFastFieldCardinality {
+    SingleValue(Arc<dyn Column<Ipv6Addr>>),
+    MultiValue(MultiValuedU128FastFieldReader<Ipv6Addr>),
+}
+
+impl IpFastFieldCardinality {
+    fn num_docs(&self) -> u32 {
+        match self {
+            IpFastFieldCardinality::SingleValue(single_value) => single_value.num_vals(),
+            IpFastFieldCardinality::MultiValue(multi_value) => {
+                multi_value.get_index_reader().num_docs()
+            }
+        }
+    }
+}
+
+struct IpRangeDocSet {
+    /// The range filter on the values.
+    value_range: RangeInclusive<Ipv6Addr>,
+    ip_addr_fast_field: IpFastFieldCardinality,
+    /// The next docid start range to fetch (inclusive).
+    next_fetch_start: u32,
+    /// Number of docs range checked in a batch.
+    ///
+    /// There are two patterns.
+    /// - We do a full scan. => We can load large chunks. We don't know in advance if seek call
+    /// will come, so we start with small chunks
+    /// - We load docs, interspersed with seek calls. When there are big jumps in the seek, we
+    /// should load small chunks. When the seeks are small, we can employ the same strategy as on a
+    /// full scan.
+    fetch_horizon: u32,
+    /// Current batch of loaded docs.
+    loaded_docs: VecCursor,
+    last_seek_pos_opt: Option<u32>,
+}
+
+const DEFAULT_FETCH_HORIZON: u32 = 128;
+impl IpRangeDocSet {
+    fn new(
+        value_range: RangeInclusive<Ipv6Addr>,
+        ip_addr_fast_field: IpFastFieldCardinality,
+    ) -> Self {
+        let mut ip_range_docset = Self {
+            value_range,
+            ip_addr_fast_field,
+            loaded_docs: VecCursor::new(),
+            next_fetch_start: 0,
+            fetch_horizon: DEFAULT_FETCH_HORIZON,
+            last_seek_pos_opt: None,
+        };
+        ip_range_docset.reset_fetch_range();
+        ip_range_docset.fetch_block();
+        ip_range_docset
+    }
+
+    fn reset_fetch_range(&mut self) {
+        self.fetch_horizon = DEFAULT_FETCH_HORIZON;
+    }
+
+    /// Returns true if more data could be fetched
+    fn fetch_block(&mut self) {
+        const MAX_HORIZON: u32 = 100_000;
+        while self.loaded_docs.is_empty() {
+            let finished_to_end = self.fetch_horizon(self.fetch_horizon);
+            if finished_to_end {
+                break;
+            }
+            // Fetch more data, increase horizon. Horizon only gets reset when doing a seek.
+            self.fetch_horizon = (self.fetch_horizon * 2).min(MAX_HORIZON);
+        }
+    }
+
+    /// check if the distance between the seek calls is large
+    fn is_last_seek_distance_large(&self, new_seek: DocId) -> bool {
+        if let Some(last_seek_pos) = self.last_seek_pos_opt {
+            (new_seek - last_seek_pos) >= 128
+        } else {
+            true
+        }
+    }
+
+    /// Fetches a block for docid range [next_fetch_start .. next_fetch_start + HORIZON]
+    fn fetch_horizon(&mut self, horizon: u32) -> bool {
+        let mut finished_to_end = false;
+
+        let limit = self.ip_addr_fast_field.num_docs();
+        let mut end = self.next_fetch_start + horizon;
+        if end >= limit {
+            end = limit;
+            finished_to_end = true;
+        }
+
+        match &self.ip_addr_fast_field {
+            IpFastFieldCardinality::MultiValue(multi) => {
+                let last_value = self.loaded_docs.last_value();
+
+                multi.get_docids_for_value_range(
+                    self.value_range.clone(),
+                    self.next_fetch_start..end,
+                    self.loaded_docs.get_cleared_data(),
+                );
+                // In case of multivalues, we may have an overlap of the same docid between fetching
+                // blocks
+                if let Some(last_value) = last_value {
+                    while self.loaded_docs.current() == Some(last_value) {
+                        self.loaded_docs.next();
+                    }
+                }
+            }
+            IpFastFieldCardinality::SingleValue(single) => {
+                single.get_docids_for_value_range(
+                    self.value_range.clone(),
+                    self.next_fetch_start..end,
+                    self.loaded_docs.get_cleared_data(),
+                );
+            }
+        }
+        self.next_fetch_start = end;
+
+        finished_to_end
+    }
+}
+
+impl DocSet for IpRangeDocSet {
+    #[inline]
+    fn advance(&mut self) -> DocId {
+        if let Some(docid) = self.loaded_docs.next() {
+            docid
+        } else {
+            if self.next_fetch_start >= self.ip_addr_fast_field.num_docs() {
+                return TERMINATED;
+            }
+            self.fetch_block();
+            self.loaded_docs.current().unwrap_or(TERMINATED)
+        }
+    }
+
+    #[inline]
+    fn doc(&self) -> DocId {
+        self.loaded_docs
+            .current()
+            .unwrap_or(TERMINATED)
+    }
+
+    /// Advances the `DocSet` forward until reaching the target, or going to the
+    /// lowest [`DocId`] greater than the target.
+    ///
+    /// If the end of the `DocSet` is reached, [`TERMINATED`] is returned.
+    ///
+    /// Calling `.seek(target)` on a terminated `DocSet` is legal. Implementation
+    /// of `DocSet` should support it.
+    ///
+    /// Calling `seek(TERMINATED)` is also legal and is the normal way to consume a `DocSet`.
+    fn seek(&mut self, target: DocId) -> DocId {
+        if self.is_last_seek_distance_large(target) {
+            self.reset_fetch_range();
+        }
+        if target > self.next_fetch_start {
+            self.next_fetch_start = target;
+        }
+        let mut doc = self.doc();
+        debug_assert!(doc <= target);
+        while doc < target {
+            doc = self.advance();
+        }
+        self.last_seek_pos_opt = Some(target);
+        doc
+    }
+
+    fn size_hint(&self) -> u32 {
+        0 // heuristic possible by checking number of hits when fetching a block
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use proptest::prelude::ProptestConfig;
@@ -195,7 +403,7 @@ mod tests {
         let index = Index::create_in_ram(schema);
 
         {
-            let mut index_writer = index.writer(10_000_000).unwrap();
+            let mut index_writer = index.writer(3_000_000).unwrap();
             for doc in docs.iter() {
                 index_writer
                     .add_document(doc!(
@@ -313,7 +521,8 @@ mod bench {
             })
             .collect();
 
-        create_index_from_docs(&docs)
+        let index = create_index_from_docs(&docs);
+        index
     }
 
     fn get_90_percent() -> RangeInclusive<Ipv6Addr> {
@@ -352,7 +561,7 @@ mod bench {
 
         let query = gen_query_inclusive(ip_range.start(), ip_range.end());
         let query_from_text = |text: &str| {
-            QueryParser::for_index(index, vec![])
+            QueryParser::for_index(&index, vec![])
                 .parse_query(text)
                 .unwrap()
         };

src/query/term_query/mod.rs

@@ -158,8 +158,7 @@ mod tests {
         let term_a = Term::from_field_text(text_field, "a");
         let term_query = TermQuery::new(term_a, IndexRecordOption::Basic);
         let searcher = index.reader()?.searcher();
-        let term_weight =
+        let term_weight = term_query.weight(EnableScoring::Disabled(searcher.schema()))?;
-            term_query.weight(EnableScoring::disabled_from_schema(searcher.schema()))?;
         let mut term_scorer = term_weight.scorer(searcher.segment_reader(0u32), 1.0)?;
         assert_eq!(term_scorer.doc(), 0u32);
         term_scorer.seek(1u32);

src/query/term_query/term_query.rs

@@ -99,7 +99,7 @@ impl TermQuery {
             EnableScoring::Enabled(searcher) => {
                 Bm25Weight::for_terms(searcher, &[self.term.clone()])?
             }
-            EnableScoring::Disabled { .. } => {
+            EnableScoring::Disabled(_schema) => {
                 Bm25Weight::new(Explanation::new("<no score>".to_string(), 1.0f32), 1.0f32)
             }
         };

src/schema/field_type.rs

@@ -1,8 +1,6 @@
 use std::net::IpAddr;
 use std::str::FromStr;
 
-use base64::engine::general_purpose::STANDARD as BASE64;
-use base64::Engine;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use thiserror::Error;
@@ -360,8 +358,7 @@ impl FieldType {
                         json: JsonValue::String(field_text),
                     }),
                     FieldType::Facet(_) => Ok(Value::Facet(Facet::from(&field_text))),
-                    FieldType::Bytes(_) => BASE64
+                    FieldType::Bytes(_) => base64::decode(&field_text)
-                        .decode(&field_text)
                         .map(Value::Bytes)
                         .map_err(|_| ValueParsingError::InvalidBase64 { base64: field_text }),
                     FieldType::JsonObject(_) => Err(ValueParsingError::TypeError {

src/schema/text_options.rs

@@ -258,7 +258,7 @@ mod tests {
         let field = schema.get_field("body").unwrap();
         let field_entry = schema.get_field_entry(field);
         assert!(matches!(field_entry.field_type(),
-                FieldType::Str(text_options)
+                &FieldType::Str(ref text_options)
                 if text_options.get_indexing_options().unwrap().tokenizer() == "default"));
     }
 

src/schema/value.rs

@@ -1,8 +1,6 @@
 use std::fmt;
 use std::net::Ipv6Addr;
 
-use base64::engine::general_purpose::STANDARD as BASE64;
-use base64::Engine;
 use serde::de::Visitor;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Map;
@@ -53,7 +51,7 @@ impl Serialize for Value {
             Value::Bool(b) => serializer.serialize_bool(b),
             Value::Date(ref date) => time::serde::rfc3339::serialize(&date.into_utc(), serializer),
             Value::Facet(ref facet) => facet.serialize(serializer),
-            Value::Bytes(ref bytes) => serializer.serialize_str(&BASE64.encode(bytes)),
+            Value::Bytes(ref bytes) => serializer.serialize_str(&base64::encode(bytes)),
             Value::JsonObject(ref obj) => obj.serialize(serializer),
             Value::IpAddr(ref obj) => {
                 // Ensure IpV4 addresses get serialized as IpV4, but excluding IpV6 loopback.

src/snippet/mod.rs

@@ -124,9 +124,9 @@ impl Snippet {
 ///
 /// Fragments must be valid in the sense that `&text[fragment.start..fragment.stop]`\
 /// has to be a valid string.
-fn search_fragments(
+fn search_fragments<'a>(
     tokenizer: &TextAnalyzer,
-    text: &str,
+    text: &'a str,
     terms: &BTreeMap<String, Score>,
     max_num_chars: usize,
 ) -> Vec<FragmentCandidate> {

src/store/reader.rs

@@ -1,12 +1,12 @@
 use std::io;
 use std::iter::Sum;
-use std::num::NonZeroUsize;
 use std::ops::{AddAssign, Range};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 
-use common::{BinarySerializable, HasLen, OwnedBytes};
+use common::{BinarySerializable, HasLen};
 use lru::LruCache;
+use ownedbytes::OwnedBytes;
 
 use super::footer::DocStoreFooter;
 use super::index::SkipIndex;
@@ -34,29 +34,23 @@ pub struct StoreReader {
 
 /// The cache for decompressed blocks.
 struct BlockCache {
-    cache: Option<Mutex<LruCache<usize, Block>>>,
+    cache: Mutex<LruCache<usize, Block>>,
-    cache_hits: AtomicUsize,
+    cache_hits: Arc<AtomicUsize>,
-    cache_misses: AtomicUsize,
+    cache_misses: Arc<AtomicUsize>,
 }
 
 impl BlockCache {
     fn get_from_cache(&self, pos: usize) -> Option<Block> {
-        if let Some(block) = self
+        if let Some(block) = self.cache.lock().unwrap().get(&pos) {
-            .cache
-            .as_ref()
-            .and_then(|cache| cache.lock().unwrap().get(&pos).cloned())
-        {
             self.cache_hits.fetch_add(1, Ordering::SeqCst);
-            return Some(block);
+            return Some(block.clone());
         }
         self.cache_misses.fetch_add(1, Ordering::SeqCst);
         None
     }
 
     fn put_into_cache(&self, pos: usize, data: Block) {
-        if let Some(cache) = self.cache.as_ref() {
+        self.cache.lock().unwrap().put(pos, data);
-            cache.lock().unwrap().put(pos, data);
-        }
     }
 
     fn stats(&self) -> CacheStats {
@@ -66,18 +60,13 @@ impl BlockCache {
             num_entries: self.len(),
         }
     }
-
     fn len(&self) -> usize {
-        self.cache
+        self.cache.lock().unwrap().len()
-            .as_ref()
-            .map_or(0, |cache| cache.lock().unwrap().len())
     }
 
     #[cfg(test)]
     fn peek_lru(&self) -> Option<usize> {
-        self.cache
+        self.cache.lock().unwrap().peek_lru().map(|(&k, _)| k)
-            .as_ref()
-            .and_then(|cache| cache.lock().unwrap().peek_lru().map(|(&k, _)| k))
     }
 }
 
@@ -125,8 +114,7 @@ impl StoreReader {
             decompressor: footer.decompressor,
             data: data_file,
             cache: BlockCache {
-                cache: NonZeroUsize::new(cache_size)
+                cache: Mutex::new(LruCache::new(cache_size)),
-                    .map(|cache_size| Mutex::new(LruCache::new(cache_size))),
                 cache_hits: Default::default(),
                 cache_misses: Default::default(),
             },

src/termdict/fst_termdict/merger.rs

@@ -113,7 +113,7 @@ mod bench {
     }
 
     /// Create a dictionary of random strings.
-    fn rand_dict(num_terms: usize) -> std::io::Result<TermDictionary> {
+    fn rand_dict(num_terms: usize) -> crate::Result<TermDictionary> {
         let buffer: Vec<u8> = {
             let mut terms = vec![];
             for _i in 0..num_terms {

src/termdict/sstable_termdict/mod.rs

@@ -1,6 +1,7 @@
 use std::io;
 
 mod merger;
+mod termdict;
 
 use std::iter::ExactSizeIterator;
 
@@ -12,39 +13,26 @@ use tantivy_fst::automaton::AlwaysMatch;
 pub use self::merger::TermMerger;
 use crate::postings::TermInfo;
 
-/// The term dictionary contains all of the terms in
-/// `tantivy index` in a sorted manner.
-///
-/// The `Fst` crate is used to associate terms to their
-/// respective `TermOrdinal`. The `TermInfoStore` then makes it
-/// possible to fetch the associated `TermInfo`.
 pub type TermDictionary = sstable::Dictionary<TermSSTable>;
-
+pub type TermDictionaryBuilder<W> = sstable::Writer<W, TermInfoWriter>;
-/// Builder for the new term dictionary.
-pub type TermDictionaryBuilder<W> = sstable::Writer<W, TermInfoValueWriter>;
-
-/// `TermStreamer` acts as a cursor over a range of terms of a segment.
-/// Terms are guaranteed to be sorted.
 pub type TermStreamer<'a, A = AlwaysMatch> = sstable::Streamer<'a, TermSSTable, A>;
 
-/// SSTable used to store TermInfo objects.
 pub struct TermSSTable;
 
 impl SSTable for TermSSTable {
     type Value = TermInfo;
-    type ValueReader = TermInfoValueReader;
+    type ValueReader = TermInfoReader;
-    type ValueWriter = TermInfoValueWriter;
+    type ValueWriter = TermInfoWriter;
 }
 
 #[derive(Default)]
-pub struct TermInfoValueReader {
+pub struct TermInfoReader {
     term_infos: Vec<TermInfo>,
 }
 
-impl ValueReader for TermInfoValueReader {
+impl ValueReader for TermInfoReader {
     type Value = TermInfo;
 
-    #[inline(always)]
     fn value(&self, idx: usize) -> &TermInfo {
         &self.term_infos[idx]
     }
@@ -76,18 +64,18 @@ impl ValueReader for TermInfoValueReader {
 }
 
 #[derive(Default)]
-pub struct TermInfoValueWriter {
+pub struct TermInfoWriter {
     term_infos: Vec<TermInfo>,
 }
 
-impl ValueWriter for TermInfoValueWriter {
+impl ValueWriter for TermInfoWriter {
     type Value = TermInfo;
 
     fn write(&mut self, term_info: &TermInfo) {
         self.term_infos.push(term_info.clone());
     }
 
-    fn serialize_block(&self, buffer: &mut Vec<u8>) {
+    fn serialize_block(&mut self, buffer: &mut Vec<u8>) {
         VInt(self.term_infos.len() as u64).serialize_into_vec(buffer);
         if self.term_infos.is_empty() {
             return;
@@ -99,9 +87,6 @@ impl ValueWriter for TermInfoValueWriter {
             VInt(term_info.postings_range.len() as u64).serialize_into_vec(buffer);
             VInt(term_info.positions_range.len() as u64).serialize_into_vec(buffer);
         }
-    }
-
-    fn clear(&mut self) {
         self.term_infos.clear();
     }
 }
@@ -111,11 +96,11 @@ mod tests {
     use sstable::value::{ValueReader, ValueWriter};
 
     use crate::postings::TermInfo;
-    use crate::termdict::sstable_termdict::TermInfoValueReader;
+    use crate::termdict::sstable_termdict::TermInfoReader;
 
     #[test]
     fn test_block_terminfos() {
-        let mut term_info_writer = super::TermInfoValueWriter::default();
+        let mut term_info_writer = super::TermInfoWriter::default();
         term_info_writer.write(&TermInfo {
             doc_freq: 120u32,
             postings_range: 17..45,
@@ -133,7 +118,8 @@ mod tests {
         });
         let mut buffer = Vec::new();
         term_info_writer.serialize_block(&mut buffer);
-        let mut term_info_reader = TermInfoValueReader::default();
+        // let mut block_reader = make_block_reader(&buffer[..]);
+        let mut term_info_reader = TermInfoReader::default();
         let num_bytes: usize = term_info_reader.load(&buffer[..]).unwrap();
         assert_eq!(
             term_info_reader.value(0),

src/termdict/sstable_termdict/termdict.rs

@@ -0,0 +1,11 @@
+use sstable::SSTable;
+
+use crate::postings::TermInfo;
+use crate::termdict::sstable_termdict::{TermInfoReader, TermInfoWriter};
+
+pub struct TermInfoSSTable;
+impl SSTable for TermInfoSSTable {
+    type Value = TermInfo;
+    type ValueReader = TermInfoReader;
+    type ValueWriter = TermInfoWriter;
+}

src/termdict/tests.rs

@@ -99,7 +99,7 @@ fn test_term_dictionary_stream() -> crate::Result<()> {
         .collect();
     let buffer: Vec<u8> = {
         let mut term_dictionary_builder = TermDictionaryBuilder::create(vec![]).unwrap();
-        for (id, i) in &ids {
+        for &(ref id, ref i) in &ids {
             term_dictionary_builder
                 .insert(id.as_bytes(), &make_term_info(*i as u64))
                 .unwrap();
@@ -112,14 +112,14 @@ fn test_term_dictionary_stream() -> crate::Result<()> {
         let mut streamer = term_dictionary.stream()?;
         let mut i = 0;
         while let Some((streamer_k, streamer_v)) = streamer.next() {
-            let (key, v) = &ids[i];
+            let &(ref key, ref v) = &ids[i];
             assert_eq!(streamer_k, key.as_bytes());
             assert_eq!(streamer_v, &make_term_info(*v as u64));
             i += 1;
         }
     }
 
-    let (key, val) = &ids[2047];
+    let &(ref key, ref val) = &ids[2047];
     assert_eq!(
         term_dictionary.get(key.as_bytes())?,
         Some(make_term_info(*val as u64))
@@ -160,7 +160,7 @@ fn test_stream_range() -> crate::Result<()> {
         .collect();
     let buffer: Vec<u8> = {
         let mut term_dictionary_builder = TermDictionaryBuilder::create(vec![]).unwrap();
-        for (id, i) in &ids {
+        for &(ref id, ref i) in &ids {
             term_dictionary_builder
                 .insert(id.as_bytes(), &make_term_info(*i as u64))
                 .unwrap();
@@ -173,14 +173,14 @@ fn test_stream_range() -> crate::Result<()> {
     let term_dictionary: TermDictionary = TermDictionary::open(file)?;
     {
         for i in (0..20).chain(6000..8_000) {
-            let (target_key, _) = &ids[i];
+            let &(ref target_key, _) = &ids[i];
             let mut streamer = term_dictionary
                 .range()
                 .ge(target_key.as_bytes())
                 .into_stream()?;
             for j in 0..3 {
                 let (streamer_k, streamer_v) = streamer.next().unwrap();
-                let (key, v) = &ids[i + j];
+                let &(ref key, ref v) = &ids[i + j];
                 assert_eq!(str::from_utf8(streamer_k).unwrap(), key);
                 assert_eq!(streamer_v.doc_freq, *v);
                 assert_eq!(streamer_v, &make_term_info(*v as u64));
@@ -190,14 +190,14 @@ fn test_stream_range() -> crate::Result<()> {
 
     {
         for i in (0..20).chain(BLOCK_SIZE - 10..BLOCK_SIZE + 10) {
-            let (target_key, _) = &ids[i];
+            let &(ref target_key, _) = &ids[i];
             let mut streamer = term_dictionary
                 .range()
                 .gt(target_key.as_bytes())
                 .into_stream()?;
             for j in 0..3 {
                 let (streamer_k, streamer_v) = streamer.next().unwrap();
-                let (key, v) = &ids[i + j + 1];
+                let &(ref key, ref v) = &ids[i + j + 1];
                 assert_eq!(streamer_k, key.as_bytes());
                 assert_eq!(streamer_v.doc_freq, *v);
             }
@@ -207,8 +207,8 @@ fn test_stream_range() -> crate::Result<()> {
     {
         for i in (0..20).chain(BLOCK_SIZE - 10..BLOCK_SIZE + 10) {
             for j in 0..3 {
-                let (fst_key, _) = &ids[i];
+                let &(ref fst_key, _) = &ids[i];
-                let (last_key, _) = &ids[i + j];
+                let &(ref last_key, _) = &ids[i + j];
                 let mut streamer = term_dictionary
                     .range()
                     .ge(fst_key.as_bytes())

src/tokenizer/mod.rs

@@ -52,8 +52,6 @@
 //! remove their inflection. This tokenizer is slower than the default one,
 //! but is recommended to improve recall.
 //!
-//! # Custom tokenizer Library
-//! Avoid using tantivy as dependency and prefer `tantivy-tokenizer-api` instead.
 //!
 //! # Custom tokenizers
 //!
@@ -126,7 +124,6 @@ mod facet_tokenizer;
 mod lower_caser;
 mod ngram_tokenizer;
 mod raw_tokenizer;
-mod regex_tokenizer;
 mod remove_long;
 mod simple_tokenizer;
 mod split_compound_words;
@@ -137,24 +134,21 @@ mod tokenizer;
 mod tokenizer_manager;
 mod whitespace_tokenizer;
 
-pub use tokenizer_api::{
-    BoxTokenFilter, BoxTokenStream, Token, TokenFilter, TokenStream, Tokenizer,
-};
-
 pub use self::alphanum_only::AlphaNumOnlyFilter;
 pub use self::ascii_folding_filter::AsciiFoldingFilter;
 pub use self::facet_tokenizer::FacetTokenizer;
 pub use self::lower_caser::LowerCaser;
 pub use self::ngram_tokenizer::NgramTokenizer;
 pub use self::raw_tokenizer::RawTokenizer;
-pub use self::regex_tokenizer::RegexTokenizer;
 pub use self::remove_long::RemoveLongFilter;
 pub use self::simple_tokenizer::SimpleTokenizer;
 pub use self::split_compound_words::SplitCompoundWords;
 pub use self::stemmer::{Language, Stemmer};
 pub use self::stop_word_filter::StopWordFilter;
 pub use self::tokenized_string::{PreTokenizedStream, PreTokenizedString};
-pub use self::tokenizer::TextAnalyzer;
+pub use self::tokenizer::{
+    BoxTokenFilter, BoxTokenStream, TextAnalyzer, Token, TokenFilter, TokenStream, Tokenizer,
+};
 pub use self::tokenizer_manager::TokenizerManager;
 pub use self::whitespace_tokenizer::WhitespaceTokenizer;
 

src/tokenizer/ngram_tokenizer.rs

@@ -303,7 +303,8 @@ mod tests {
 
     use super::{utf8_codepoint_width, CodepointFrontiers, NgramTokenizer, StutteringIterator};
     use crate::tokenizer::tests::assert_token;
-    use crate::tokenizer::{BoxTokenStream, Token, Tokenizer};
+    use crate::tokenizer::tokenizer::Tokenizer;
+    use crate::tokenizer::{BoxTokenStream, Token};
 
     fn test_helper(mut tokenizer: BoxTokenStream) -> Vec<Token> {
         let mut tokens: Vec<Token> = vec![];

src/tokenizer/regex_tokenizer.rs

@@ -1,158 +0,0 @@
-use regex::Regex;
-
-use super::{BoxTokenStream, Token, TokenStream, Tokenizer};
-use crate::TantivyError;
-
-/// Tokenize the text by using a regex pattern to split.
-/// Each match of the regex emits a distinct token, empty tokens will not be emitted. Anchors such
-/// as `\A` will match the text from the part where the last token was emitted or the beginning of
-/// the complete text if no token was emitted yet.
-///
-/// Example: `` 'aaa' bbb 'ccc' 'ddd' `` with the pattern `` '(?:\w*)' `` will be tokenized as
-/// followed:
-///
-/// | Term     | aaa  | ccc    | ddd   |
-/// |----------|------|--------|-------|
-/// | Position | 1    | 2      | 3     |
-/// | Offsets  |0,5   | 10,15  | 16,21 |
-///
-///
-/// # Example
-///
-/// ```rust
-/// use tantivy::tokenizer::*;
-///
-/// let tokenizer = RegexTokenizer::new(r"'(?:\w*)'").unwrap();
-/// let mut stream = tokenizer.token_stream("'aaa' bbb 'ccc' 'ddd'");
-/// {
-///     let token = stream.next().unwrap();
-///     assert_eq!(token.text, "'aaa'");
-///     assert_eq!(token.offset_from, 0);
-///     assert_eq!(token.offset_to, 5);
-/// }
-/// {
-///   let token = stream.next().unwrap();
-///     assert_eq!(token.text, "'ccc'");
-///     assert_eq!(token.offset_from, 10);
-///     assert_eq!(token.offset_to, 15);
-/// }
-/// {
-///   let token = stream.next().unwrap();
-///     assert_eq!(token.text, "'ddd'");
-///     assert_eq!(token.offset_from, 16);
-///     assert_eq!(token.offset_to, 21);
-/// }
-/// assert!(stream.next().is_none());
-/// ```
-
-#[derive(Clone)]
-pub struct RegexTokenizer {
-    regex: Regex,
-}
-
-impl RegexTokenizer {
-    /// Creates a new RegexTokenizer.
-    pub fn new(regex_pattern: &str) -> crate::Result<RegexTokenizer> {
-        Regex::new(regex_pattern)
-            .map_err(|_| TantivyError::InvalidArgument(regex_pattern.to_owned()))
-            .map(|regex| Self { regex })
-    }
-}
-
-impl Tokenizer for RegexTokenizer {
-    fn token_stream<'a>(&self, text: &'a str) -> BoxTokenStream<'a> {
-        BoxTokenStream::from(RegexTokenStream {
-            regex: self.regex.clone(),
-            text,
-            token: Token::default(),
-            cursor: 0,
-        })
-    }
-}
-
-pub struct RegexTokenStream<'a> {
-    regex: Regex,
-    text: &'a str,
-    token: Token,
-    cursor: usize,
-}
-
-impl<'a> TokenStream for RegexTokenStream<'a> {
-    fn advance(&mut self) -> bool {
-        let Some(regex_match) = self.regex.find(self.text) else {
-            return false;
-        };
-        if regex_match.as_str().is_empty() {
-            return false;
-        }
-        self.token.text.clear();
-        self.token.text.push_str(regex_match.as_str());
-
-        self.token.offset_from = self.cursor + regex_match.start();
-        self.cursor += regex_match.end();
-        self.token.offset_to = self.cursor;
-
-        self.token.position = self.token.position.wrapping_add(1);
-
-        self.text = &self.text[regex_match.end()..];
-        true
-    }
-
-    fn token(&self) -> &Token {
-        &self.token
-    }
-
-    fn token_mut(&mut self) -> &mut Token {
-        &mut self.token
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::tokenizer::regex_tokenizer::RegexTokenizer;
-    use crate::tokenizer::tests::assert_token;
-    use crate::tokenizer::{TextAnalyzer, Token};
-
-    #[test]
-    fn test_regex_tokenizer() {
-        let tokens = token_stream_helper("'aaa' bbb 'ccc' 'ddd'", r"'(?:\w*)'");
-        assert_eq!(tokens.len(), 3);
-        assert_token(&tokens[0], 0, "'aaa'", 0, 5);
-        assert_token(&tokens[1], 1, "'ccc'", 10, 15);
-        assert_token(&tokens[2], 2, "'ddd'", 16, 21);
-    }
-
-    #[test]
-    fn test_regexp_tokenizer_no_match_on_input_data() {
-        let tokens = token_stream_helper("aaa", r"'(?:\w*)'");
-        assert_eq!(tokens.len(), 0);
-    }
-
-    #[test]
-    fn test_regexp_tokenizer_no_input_data() {
-        let tokens = token_stream_helper("", r"'(?:\w*)'");
-        assert_eq!(tokens.len(), 0);
-    }
-
-    #[test]
-    fn test_regexp_tokenizer_error_on_invalid_regex() {
-        let tokenizer = RegexTokenizer::new(r"\@");
-        assert_eq!(tokenizer.is_err(), true);
-        assert_eq!(
-            tokenizer.err().unwrap().to_string(),
-            "An invalid argument was passed: '\\@'"
-        );
-    }
-
-    fn token_stream_helper(text: &str, pattern: &str) -> Vec<Token> {
-        let r = RegexTokenizer::new(pattern).unwrap();
-        let a = TextAnalyzer::from(r);
-        let mut token_stream = a.token_stream(text);
-        let mut tokens: Vec<Token> = vec![];
-        let mut add_token = |token: &Token| {
-            tokens.push(token.clone());
-        };
-        token_stream.process(&mut add_token);
-        tokens
-    }
-}

src/tokenizer/simple_tokenizer.rs

@@ -26,7 +26,7 @@ impl<'a> SimpleTokenStream<'a> {
     // search for the end of the current token.
     fn search_token_end(&mut self) -> usize {
         (&mut self.chars)
-            .filter(|(_, c)| !c.is_alphanumeric())
+            .filter(|&(_, ref c)| !c.is_alphanumeric())
             .map(|(offset, _)| offset)
             .next()
             .unwrap_or(self.text.len())

src/tokenizer/tokenizer.rs

@@ -1,9 +1,42 @@
 /// The tokenizer module contains all of the tools used to process
 /// text in `tantivy`.
-use tokenizer_api::{BoxTokenFilter, BoxTokenStream, Tokenizer};
+use std::borrow::{Borrow, BorrowMut};
+use std::ops::{Deref, DerefMut};
+
+use serde::{Deserialize, Serialize};
 
 use crate::tokenizer::empty_tokenizer::EmptyTokenizer;
 
+/// Token
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub struct Token {
+    /// Offset (byte index) of the first character of the token.
+    /// Offsets shall not be modified by token filters.
+    pub offset_from: usize,
+    /// Offset (byte index) of the last character of the token + 1.
+    /// The text that generated the token should be obtained by
+    /// &text[token.offset_from..token.offset_to]
+    pub offset_to: usize,
+    /// Position, expressed in number of tokens.
+    pub position: usize,
+    /// Actual text content of the token.
+    pub text: String,
+    /// Is the length expressed in term of number of original tokens.
+    pub position_length: usize,
+}
+
+impl Default for Token {
+    fn default() -> Token {
+        Token {
+            offset_from: 0,
+            offset_to: 0,
+            position: usize::MAX,
+            text: String::with_capacity(200),
+            position_length: 1,
+        }
+    }
+}
+
 /// `TextAnalyzer` tokenizes an input text into tokens and modifies the resulting `TokenStream`.
 ///
 /// It simply wraps a `Tokenizer` and a list of `TokenFilter` that are applied sequentially.
@@ -79,3 +112,200 @@ impl Clone for TextAnalyzer {
         }
     }
 }
+
+/// `Tokenizer` are in charge of splitting text into a stream of token
+/// before indexing.
+///
+/// See the [module documentation](crate::tokenizer) for more detail.
+///
+/// # Warning
+///
+/// This API may change to use associated types.
+pub trait Tokenizer: 'static + Send + Sync + TokenizerClone {
+    /// Creates a token stream for a given `str`.
+    fn token_stream<'a>(&self, text: &'a str) -> BoxTokenStream<'a>;
+}
+
+pub trait TokenizerClone {
+    fn box_clone(&self) -> Box<dyn Tokenizer>;
+}
+
+impl<T: Tokenizer + Clone> TokenizerClone for T {
+    fn box_clone(&self) -> Box<dyn Tokenizer> {
+        Box::new(self.clone())
+    }
+}
+
+impl<'a> TokenStream for Box<dyn TokenStream + 'a> {
+    fn advance(&mut self) -> bool {
+        let token_stream: &mut dyn TokenStream = self.borrow_mut();
+        token_stream.advance()
+    }
+
+    fn token<'b>(&'b self) -> &'b Token {
+        let token_stream: &'b (dyn TokenStream + 'a) = self.borrow();
+        token_stream.token()
+    }
+
+    fn token_mut<'b>(&'b mut self) -> &'b mut Token {
+        let token_stream: &'b mut (dyn TokenStream + 'a) = self.borrow_mut();
+        token_stream.token_mut()
+    }
+}
+
+/// Simple wrapper of `Box<dyn TokenStream + 'a>`.
+///
+/// See [`TokenStream`] for more information.
+pub struct BoxTokenStream<'a>(Box<dyn TokenStream + 'a>);
+
+impl<'a, T> From<T> for BoxTokenStream<'a>
+where T: TokenStream + 'a
+{
+    fn from(token_stream: T) -> BoxTokenStream<'a> {
+        BoxTokenStream(Box::new(token_stream))
+    }
+}
+
+impl<'a> Deref for BoxTokenStream<'a> {
+    type Target = dyn TokenStream + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl<'a> DerefMut for BoxTokenStream<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.0
+    }
+}
+
+/// Simple wrapper of `Box<dyn TokenFilter + 'a>`.
+///
+/// See [`TokenFilter`] for more information.
+pub struct BoxTokenFilter(Box<dyn TokenFilter>);
+
+impl Deref for BoxTokenFilter {
+    type Target = dyn TokenFilter;
+
+    fn deref(&self) -> &dyn TokenFilter {
+        &*self.0
+    }
+}
+
+impl<T: TokenFilter> From<T> for BoxTokenFilter {
+    fn from(tokenizer: T) -> BoxTokenFilter {
+        BoxTokenFilter(Box::new(tokenizer))
+    }
+}
+
+/// `TokenStream` is the result of the tokenization.
+///
+/// It consists consumable stream of `Token`s.
+///
+/// # Example
+///
+/// ```
+/// use tantivy::tokenizer::*;
+///
+/// let tokenizer = TextAnalyzer::from(SimpleTokenizer)
+///        .filter(RemoveLongFilter::limit(40))
+///        .filter(LowerCaser);
+/// let mut token_stream = tokenizer.token_stream("Hello, happy tax payer");
+/// {
+///     let token = token_stream.next().unwrap();
+///     assert_eq!(&token.text, "hello");
+///     assert_eq!(token.offset_from, 0);
+///     assert_eq!(token.offset_to, 5);
+///     assert_eq!(token.position, 0);
+/// }
+/// {
+///     let token = token_stream.next().unwrap();
+///     assert_eq!(&token.text, "happy");
+///     assert_eq!(token.offset_from, 7);
+///     assert_eq!(token.offset_to, 12);
+///     assert_eq!(token.position, 1);
+/// }
+/// ```
+pub trait TokenStream {
+    /// Advance to the next token
+    ///
+    /// Returns false if there are no other tokens.
+    fn advance(&mut self) -> bool;
+
+    /// Returns a reference to the current token.
+    fn token(&self) -> &Token;
+
+    /// Returns a mutable reference to the current token.
+    fn token_mut(&mut self) -> &mut Token;
+
+    /// Helper to iterate over tokens. It
+    /// simply combines a call to `.advance()`
+    /// and `.token()`.
+    ///
+    /// ```
+    /// use tantivy::tokenizer::*;
+    ///
+    /// let tokenizer = TextAnalyzer::from(SimpleTokenizer)
+    ///       .filter(RemoveLongFilter::limit(40))
+    ///       .filter(LowerCaser);
+    /// let mut token_stream = tokenizer.token_stream("Hello, happy tax payer");
+    /// while let Some(token) = token_stream.next() {
+    ///     println!("Token {:?}", token.text);
+    /// }
+    /// ```
+    fn next(&mut self) -> Option<&Token> {
+        if self.advance() {
+            Some(self.token())
+        } else {
+            None
+        }
+    }
+
+    /// Helper function to consume the entire `TokenStream`
+    /// and push the tokens to a sink function.
+    ///
+    /// Remove this.
+    fn process(&mut self, sink: &mut dyn FnMut(&Token)) {
+        while self.advance() {
+            sink(self.token());
+        }
+    }
+}
+
+pub trait TokenFilterClone {
+    fn box_clone(&self) -> BoxTokenFilter;
+}
+
+/// Trait for the pluggable components of `Tokenizer`s.
+pub trait TokenFilter: 'static + Send + Sync + TokenFilterClone {
+    /// Wraps a token stream and returns the modified one.
+    fn transform<'a>(&self, token_stream: BoxTokenStream<'a>) -> BoxTokenStream<'a>;
+}
+
+impl<T: TokenFilter + Clone> TokenFilterClone for T {
+    fn box_clone(&self) -> BoxTokenFilter {
+        BoxTokenFilter::from(self.clone())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Token;
+
+    #[test]
+    fn clone() {
+        let t1 = Token {
+            position: 1,
+            offset_from: 2,
+            offset_to: 3,
+            text: "abc".to_string(),
+            position_length: 1,
+        };
+        let t2 = t1.clone();
+
+        assert_eq!(t1.position, t2.position);
+        assert_eq!(t1.offset_from, t2.offset_from);
+        assert_eq!(t1.offset_to, t2.offset_to);
+        assert_eq!(t1.text, t2.text);
+    }
+}

src/tokenizer/whitespace_tokenizer.rs

@@ -26,7 +26,7 @@ impl<'a> WhitespaceTokenStream<'a> {
     // search for the end of the current token.
     fn search_token_end(&mut self) -> usize {
         (&mut self.chars)
-            .filter(|(_, c)| c.is_ascii_whitespace())
+            .filter(|&(_, ref c)| c.is_ascii_whitespace())
             .map(|(offset, _)| offset)
             .next()
             .unwrap_or(self.text.len())

sstable/Cargo.toml

@@ -2,7 +2,6 @@
 name = "tantivy-sstable"
 version = "0.1.0"
 edition = "2021"
-license = "MIT"
 
 [dependencies]
 common = {path="../common", package="tantivy-common"}
@@ -12,10 +11,3 @@ tantivy-fst = "0.4"
 
 [dev-dependencies]
 proptest = "1"
-criterion = "0.4"
-names = "0.14"
-rand = "0.8"
-
-[[bench]]
-name = "stream_bench"
-harness = false

sstable/README.md

@@ -1,28 +0,0 @@
-# SSTable
-
-The `tantivy-sstable` crate is yet another sstable crate.
-
-It has been designed to be used in `quickwit`:
-- as an alternative to the default tantivy fst dictionary.
-- as a way to store the column index for dynamic fast fields.
-
-The benefit compared to the fst crate is locality.
-Searching a key in the fst crate requires downloading the entire dictionary.
-
-Once the sstable index is downloaded, running a `get` in the sstable
-crate only requires a single fetch.
-
-Right now, the block index and the default block size have been thought
-for quickwit, and the performance of a get is very bad.
-
-# Sorted strings?
-
-SSTable stands for Sorted String Table.
-Strings have to be insert in sorted order.
-
-That sorted order is used in different ways:
-- it makes gets and streaming ranges of keys
-possible.
-- it allows incremental encoding of the keys
-- the front compression is leveraged to optimize
-the intersection with an automaton