Support for columnar

Cargo.toml

@@ -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"] }
@@ -61,6 +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 }
+ownedbytes = 						{ version= "0.5", path="./ownedbytes" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"

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| {
-        // We use this to make sure we skip all NaN values when
-        // working with a float type.
-        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;
-        }
+    if let Some(first_el) = vals.next() {
+        return Some(vals.fold((first_el, first_el), |(min_val, max_val), el| {
+            (min_val.min(el), max_val.max(el))
+        }));
     }
-    Some((min_so_far, max_so_far))
+    None
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_compute_num_bits() {
-        assert_eq!(compute_num_bits(1), 1u8);
-        assert_eq!(compute_num_bits(0), 0u8);
-        assert_eq!(compute_num_bits(2), 2u8);
-        assert_eq!(compute_num_bits(3), 2u8);
-        assert_eq!(compute_num_bits(4), 3u8);
-        assert_eq!(compute_num_bits(255), 8u8);
-        assert_eq!(compute_num_bits(256), 9u8);
-        assert_eq!(compute_num_bits(5_000_000_000), 33u8);
-    }
-
-    #[test]
-    fn test_minmax_empty() {
-        let vals: Vec<u32> = vec![];
-        assert_eq!(minmax(vals.into_iter()), None);
-    }
-
-    #[test]
-    fn test_minmax_one() {
-        assert_eq!(minmax(vec![1].into_iter()), Some((1, 1)));
-    }
-
-    #[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))
-        );
-    }
+#[test]
+fn test_compute_num_bits() {
+    assert_eq!(compute_num_bits(1), 1u8);
+    assert_eq!(compute_num_bits(0), 0u8);
+    assert_eq!(compute_num_bits(2), 2u8);
+    assert_eq!(compute_num_bits(3), 2u8);
+    assert_eq!(compute_num_bits(4), 3u8);
+    assert_eq!(compute_num_bits(255), 8u8);
+    assert_eq!(compute_num_bits(256), 9u8);
+    assert_eq!(compute_num_bits(5_000_000_000), 33u8);
+}
+
+#[test]
+fn test_minmax_empty() {
+    let vals: Vec<u32> = vec![];
+    assert_eq!(minmax(vals.into_iter()), None);
+}
+
+#[test]
+fn test_minmax_one() {
+    assert_eq!(minmax(vec![1].into_iter()), Some((1, 1)));
+}
+
+#[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)));
 }

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`,
-and serializing it into a `Write` object.
-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:
-- 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]`
-
-```
-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
+A quickwit/tantivy style sstable associated
 `(column names, column_cardinality, column_type) to range of bytes.
 
-Column name may not contain the zero byte `\0`.
+The format of the key is:
+`[column_name][ZERO_BYTE][column_type_header: u8]`
+
+Column name may not contain the zero byte.
 
 Listing all columns associated to `column_name` can therefore
 be done by listing all keys prefixed by

columnar/src/column_type_header.rs

@@ -1,139 +1,93 @@
-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.
     #[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),
-            1u8 => Ok(Self::Str),
-            2u8 => Ok(Self::Numerical),
-            _ => Err(InvalidData),
+            0 => Some(Cardinality::Required),
+            1 => Some(Cardinality::Optional),
+            2 => Some(Cardinality::Multivalued),
+            _ => 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
-/// - [6..8] bits: encodes the cardinality
+/// Cardinality is encoded as the first two highest two bits.
+/// 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 {
@@ -141,13 +95,13 @@ impl ColumnTypeAndCardinality {
         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 })
     }
 }
 
@@ -162,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 */ *
-            (1 + 1 + 3) // column_types (str, bool, numerical x 3)
+            3 /* cardinality */ * (1 + 3) // column_types
         );
     }
 
@@ -178,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 {
-    unordered_to_ord: Vec<OrderedId>,
-}
-
-impl TermIdMapping {
-    pub fn to_ord(&self, unordered: UnorderedId) -> OrderedId {
-        self.unordered_to_ord[unordered.0 as usize]
+fn fst_err_into_io_err(fst_err: tantivy_fst::Error) -> io::Error {
+    match fst_err {
+        tantivy_fst::Error::Fst(fst_err) => {
+            io::Error::new(io::ErrorKind::Other, format!("FST Error: {:?}", fst_err))
+        }
+        tantivy_fst::Error::Io(io_err) => io_err,
     }
 }
 
-/// 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> {
-        let mut terms: Vec<(&[u8], UnorderedId)> =
-            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 })
+    pub fn serialize<'a, W: io::Write + 'a>(&self, wrt: &mut W) -> io::Result<IdMapping> {
+        serialize_inner(&self.dict, wrt).map_err(fst_err_into_io_err)
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_dictionary_builder() {
-        let mut dictionary_builder = DictionaryBuilder::default();
-        let hello_uid = dictionary_builder.get_or_allocate_id(b"hello");
-        let happy_uid = dictionary_builder.get_or_allocate_id(b"happy");
-        let tax_uid = dictionary_builder.get_or_allocate_id(b"tax");
-        let mut buffer = Vec::new();
-        let id_mapping = dictionary_builder.serialize(&mut buffer).unwrap();
-        assert_eq!(id_mapping.to_ord(hello_uid), OrderedId(1));
-        assert_eq!(id_mapping.to_ord(happy_uid), OrderedId(0));
-        assert_eq!(id_mapping.to_ord(tax_uid), OrderedId(2));
+/// Helper function just there for error conversion.
+fn serialize_inner<'a, W: io::Write + 'a>(
+    dict: &FnvHashMap<Vec<u8>, UnorderedId>,
+    wrt: &mut W,
+) -> tantivy_fst::Result<IdMapping> {
+    let mut terms: Vec<(&[u8], UnorderedId)> =
+        dict.iter().map(|(k, v)| (k.as_slice(), *v)).collect();
+    terms.sort_unstable_by_key(|(key, _)| *key);
+    let mut unordered_to_ord: Vec<OrderedId> = vec![OrderedId(0u32); terms.len()];
+    let mut fst_builder = tantivy_fst::MapBuilder::new(wrt)?;
+    for (ord, (key, unordered_id)) in terms.into_iter().enumerate() {
+        let ordered_id = OrderedId(ord as u32);
+        fst_builder.insert(key, ord as u64)?;
+        unordered_to_ord[unordered_id.0 as usize] = ordered_id;
     }
+    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,83 +1,61 @@
+// 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 use reader::ColumnHandle;
 
 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;
-    use crate::reader::{ColumnarReader, ColumnHandle};
+
+    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_str(3u32, "my_string", "helloeee");
+        dataframe_writer.record_numerical(1u32, b"srical.value", NumericalValue::U64(1u64));
+        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);
+        dataframe_writer.serialize(5, serializer).unwrap();
         let columnar_fileslice = FileSlice::from(buffer);
         let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
         assert_eq!(columnar.num_columns(), 1);
-        let cols: Vec<ColumnHandle> =
-            columnar.read_columns("my_string").unwrap();
-        assert_eq!(cols.len(), 1);
-        assert_eq!(cols[0].num_bytes(), 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<ColumnHandle> =
-            columnar.read_columns("bool.value").unwrap();
-        assert_eq!(cols.len(), 1);
-        let col = cols.into_iter().next().unwrap();
-        assert_eq!(
-            col.column_type(),
-            ColumnType::Bool
-        );
-        assert_eq!(
-            col.cardinality(),
-            Cardinality::Optional);
-        assert_eq!(
-            col.column_name(),
-            "bool.value"
-        );
-    }
-
-    #[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);
-        let cols: Vec<ColumnHandle> =
+        let cols: Vec<(ColumnTypeAndCardinality, Range<u64>)> =
             columnar.read_columns("srical.value").unwrap();
         assert_eq!(cols.len(), 1);
         // Right now this 31 bytes are spent as follows
@@ -86,6 +64,6 @@ mod tests {
         // - vals  8 //< due to padding? could have been 1byte?.
         // - null footer 6 bytes
         // - version footer 3 bytes // Should be file-wide
-        assert_eq!(cols[0].num_bytes(), 31);
+        assert_eq!(cols[0].1, 0..31);
     }
 }

columnar/src/reader/column_handle.rs

@@ -1,42 +0,0 @@
-use common::HasLen;
-use common::file_slice::FileSlice;
-
-use crate::Cardinality;
-use crate::column_type_header::ColumnType;
-
-
-pub struct ColumnHandle {
-    column_name: String, //< Mostly for debug and display.
-    data: FileSlice,
-    column_type: ColumnType,
-    cardinality: Cardinality,
-}
-
-impl ColumnHandle {
-    pub fn new(column_name: String, data: FileSlice, column_type: ColumnType, cardinality: Cardinality) -> Self {
-        ColumnHandle {
-            column_name,
-            data,
-            column_type,
-            cardinality,
-        }
-    }
-
-    pub fn column_name(&self) -> &str {
-        self.column_name.as_str()
-    }
-
-    pub fn num_bytes(&self) -> usize {
-        self.data.len()
-    }
-
-    pub fn column_type(&self) -> ColumnType {
-        self.column_type
-    }
-
-    pub fn cardinality(&self) -> Cardinality {
-        self.cardinality
-    }
-}
-
-

columnar/src/reader/mod.rs

@@ -1,35 +1,27 @@
-mod column_handle;
-
 use std::ops::Range;
 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;
-pub use crate::reader::column_handle::ColumnHandle;
 
 fn io_invalid_data(msg: String) -> io::Error {
-    io::Error::new(io::ErrorKind::InvalidData, msg)
-    // {key_bytes:?}")));
+    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 open<F>(file_slice: F) -> io::Result<ColumnarReader>
-    where FileSlice: From<F> {
-        Self::open_inner(file_slice.into())
+    pub fn num_columns(&self) -> usize {
+        self.column_dictionary.num_terms()
     }
 
-    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()?;
@@ -43,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,
-    ) -> io::Result<Vec<ColumnHandle>> {
-        // Each column is a associated to a given `column_key`,
-        // that starts by `column_name\0column_header`.
-        //
-        // Listing the columns associate 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();
+        field_name: &str,
+    ) -> io::Result<Vec<(ColumnTypeAndCardinality, Range<u64>)>> {
+        let mut start_key = field_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
@@ -94,23 +49,18 @@ impl ColumnarReader {
             .ge(start_key.as_bytes())
             .lt(end_key.as_bytes())
             .into_stream()?;
-        let mut results: Vec<ColumnHandle> = Vec::new();
+        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}`")))?;
-            let Range { start, end } = stream.value().clone();
-            let column_data = self.column_data.slice(start as usize..end as usize);
-            let column_handle = ColumnHandle::new(column_name.to_string(), column_data, column_type_and_cardinality.typ, column_type_and_cardinality.cardinality);
-            results.push(column_handle);
+                .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 {
-    fn from(val: f64) -> Self {
+impl From<NotNan<f64>> for NumericalValue {
+    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),
-            1 => Ok(NumericalType::U64),
-            2 => Ok(NumericalType::F64),
-            _ => Err(InvalidData),
+            0 => Some(NumericalType::I64),
+            1 => Some(NumericalType::U64),
+            2 => Some(NumericalType::F64),
+            _ => 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::U64(val) => val as f64,
+            NumericalValue::I64(val) => unsafe { NotNan::new_unchecked(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,7 +1,12 @@
+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, NumericalType};
+use crate::DocId;
 
 /// When we build a columnar dataframe, we first just group
 /// all mutations per column, and append them in append-only object.
@@ -13,76 +18,6 @@ pub(crate) enum ColumnOperation<T> {
     Value(T),
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-struct ColumnOperationHeader {
-    typ_code: u8,
-    len: u8,
-}
-
-impl ColumnOperationHeader {
-    fn to_code(self) -> u8 {
-        place_bits::<0, 4>(self.len) | place_bits::<4, 8>(self.typ_code)
-    }
-
-    fn from_code(code: u8) -> Self {
-        let len = select_bits::<0, 4>(code);
-        let typ_code = select_bits::<4, 8>(code);
-        ColumnOperationHeader { typ_code, len }
-    }
-}
-
-const NEW_DOC_CODE: u8 = 0u8;
-const NEW_VALUE_CODE: u8 = 1u8;
-
-impl<V: SymbolValue> ColumnOperation<V> {
-    pub fn serialize(self) -> impl AsRef<[u8]> {
-        let mut minibuf = MiniBuffer::default();
-        let header = match self {
-            ColumnOperation::NewDoc(new_doc) => {
-                let symbol_len = new_doc.serialize(&mut minibuf.bytes[1..]);
-                ColumnOperationHeader {
-                    typ_code: NEW_DOC_CODE,
-                    len: symbol_len,
-                }
-            }
-            ColumnOperation::Value(val) => {
-                let symbol_len = val.serialize(&mut minibuf.bytes[1..]);
-                ColumnOperationHeader {
-                    typ_code: NEW_VALUE_CODE,
-                    len: symbol_len,
-                }
-            }
-        };
-        minibuf.bytes[0] = header.to_code();
-        minibuf.len = 1 + header.len;
-        minibuf
-    }
-
-    /// Deserialize a colummn operation.
-    /// Returns None if the buffer is empty.
-    ///
-    /// Panics if the payload is invalid.
-    pub fn deserialize(bytes: &mut &[u8]) -> Option<Self> {
-        let header_byte = pop_first_byte(bytes)?;
-        let column_op_header = ColumnOperationHeader::from_code(header_byte);
-        let symbol_bytes: &[u8];
-        (symbol_bytes, *bytes) = bytes.split_at(column_op_header.len as usize);
-        match column_op_header.typ_code {
-            NEW_DOC_CODE => {
-                let new_doc = u32::deserialize(symbol_bytes);
-                Some(ColumnOperation::NewDoc(new_doc))
-            }
-            NEW_VALUE_CODE => {
-                let value = V::deserialize(symbol_bytes);
-                Some(ColumnOperation::Value(value))
-            }
-            _ => {
-                panic!("Unknown code {}", column_op_header.typ_code);
-            }
-        }
-    }
-}
-
 impl<T> From<T> for ColumnOperation<T> {
     fn from(value: T) -> Self {
         ColumnOperation::Value(value)
@@ -90,116 +25,207 @@ impl<T> From<T> for ColumnOperation<T> {
 }
 
 #[allow(clippy::from_over_into)]
-pub(crate) trait SymbolValue: Clone + Copy {
-    fn serialize(self, buffer: &mut [u8]) -> u8;
-
-    // Reads the header type and the given bytes.
-    //
-    // `bytes` does not contain the header byte.
-    // This method should advance bytes by the number of bytes that were consumed.
-    fn deserialize(bytes: &[u8]) -> Self;
+pub(crate) trait SymbolValue: Into<MiniBuffer> + Clone + Copy + fmt::Debug {
+    fn deserialize(header: NonZeroU8, bytes: &mut &[u8]) -> Result<Self, ParseError>;
 }
 
-impl SymbolValue for bool {
-    fn serialize(self, buffer: &mut [u8]) -> u8 {
-        buffer[0] = if self { 1u8 } else { 0u8 };
-        1u8
-    }
+pub(crate) struct MiniBuffer {
+    pub bytes: [u8; 9],
+    pub len: usize,
+}
 
-    fn deserialize(bytes: &[u8]) -> Self {
-        bytes[0] == 1u8
+impl MiniBuffer {
+    pub fn as_slice(&self) -> &[u8] {
+        &self.bytes[..self.len]
     }
 }
 
-#[derive(Default)]
-struct MiniBuffer {
-    pub bytes: [u8; 10],
-    pub len: u8,
-}
-
-impl AsRef<[u8]> for MiniBuffer {
-    fn as_ref(&self) -> &[u8] {
-        &self.bytes[..self.len as usize]
-    }
+fn compute_header_byte(typ: SymbolType, len: usize) -> u8 {
+    assert!(len <= 9);
+    (len << 4) as u8 | typ as u8
 }
 
 impl SymbolValue for NumericalValue {
-    fn deserialize(mut bytes: &[u8]) -> Self {
-        let type_code = pop_first_byte(&mut bytes).unwrap();
-        let symbol_type = NumericalType::try_from_code(type_code).unwrap();
-        let mut octet: [u8; 8] = [0u8; 8];
-        octet[..bytes.len()].copy_from_slice(bytes);
-        match symbol_type {
-            NumericalType::U64 => {
+    fn deserialize(header_byte: NonZeroU8, bytes: &mut &[u8]) -> Result<Self, ParseError> {
+        let (typ, len) = parse_header_byte(header_byte)?;
+        let value_bytes: &[u8];
+        (value_bytes, *bytes) = bytes.split_at(len);
+        let symbol: NumericalValue = match typ {
+            SymbolType::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 => {
-                debug_assert_eq!(bytes.len(), 8);
-                let val: f64 = f64::from_le_bytes(octet);
-                NumericalValue::F64(val)
+            SymbolType::Float => {
+                let octet: [u8; 8] =
+                    value_bytes.try_into().map_err(|_| ParseError::InvalidLen {
+                        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)
     }
+}
 
-    fn serialize(self, output: &mut [u8]) -> u8 {
+#[allow(clippy::from_over_into)]
+impl Into<MiniBuffer> for NumericalValue {
+    fn into(self) -> MiniBuffer {
+        let mut bytes = [0u8; 9];
         match self {
             NumericalValue::F64(val) => {
-                output[0] = NumericalType::F64 as u8;
-                output[1..9].copy_from_slice(&val.to_le_bytes());
-                9u8
+                let len = 8;
+                let header_byte = compute_header_byte(SymbolType::Float, len);
+                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;
-                output[0] = NumericalType::U64 as u8;
-                output[1..9].copy_from_slice(&val.to_le_bytes());
-                len + 1u8
+                let len = compute_num_bytes_for_u64(val);
+                let header_byte = compute_header_byte(SymbolType::U64, len);
+                bytes[0] = header_byte;
+                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 len = compute_num_bytes_for_u64(zig_zag_encoded) as u8;
-                output[0] = NumericalType::I64 as u8;
-                output[1..9].copy_from_slice(&zig_zag_encoded.to_le_bytes());
-                len + 1u8
+                let encoded = encode_zig_zag(val);
+                let len = compute_num_bytes_for_u64(encoded);
+                let header_byte = compute_header_byte(SymbolType::I64, len);
+                bytes[0] = header_byte;
+                bytes[1..].copy_from_slice(&encoded.to_le_bytes());
+                MiniBuffer {
+                    bytes,
+                    len: len + 1,
+                }
             }
         }
     }
 }
 
-impl SymbolValue for u32 {
-    fn serialize(self, output: &mut [u8]) -> u8 {
-        let len = compute_num_bytes_for_u64(self as u64);
-        output[0..4].copy_from_slice(&self.to_le_bytes());
-        len as u8
-    }
-
-    fn deserialize(bytes: &[u8]) -> Self {
-        let mut quartet: [u8; 4] = [0u8; 4];
-        quartet[..bytes.len()].copy_from_slice(bytes);
-        u32::from_le_bytes(quartet)
+#[allow(clippy::from_over_into)]
+impl Into<MiniBuffer> for UnorderedId {
+    fn into(self) -> MiniBuffer {
+        let mut bytes = [0u8; 9];
+        let val = self.0 as u64;
+        let len = compute_num_bytes_for_u64(val) + 1;
+        bytes[0] = len as u8;
+        bytes[1..].copy_from_slice(&val.to_le_bytes());
+        MiniBuffer { bytes, len }
     }
 }
 
 impl SymbolValue for UnorderedId {
-    fn serialize(self, output: &mut [u8]) -> u8 {
-        self.0.serialize(output)
-    }
-
-    fn deserialize(bytes: &[u8]) -> Self {
-        UnorderedId(u32::deserialize(bytes))
+    fn deserialize(header: NonZeroU8, bytes: &mut &[u8]) -> Result<UnorderedId, ParseError> {
+        let len = header.get() as usize;
+        let symbol_bytes: &[u8];
+        (symbol_bytes, *bytes) = bytes.split_at(len);
+        let mut value_bytes = [0u8; 4];
+        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
 }
@@ -210,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) {
@@ -242,27 +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_header_byte_serialization() {
-        for len in 0..=15 {
-            for typ_code in 0..=15 {
-                let header = ColumnOperationHeader { typ_code, len };
-                let header_code = header.to_code();
-                let serdeser_header = ColumnOperationHeader::from_code(header_code);
-                assert_eq!(header, serdeser_header);
-            }
+        for len in 1..9 {
+            ser_deser_header_byte_aux(SymbolType::Float, len);
+            ser_deser_header_byte_aux(SymbolType::I64, len);
+            ser_deser_header_byte_aux(SymbolType::U64, len);
         }
     }
 
     #[track_caller]
-    fn ser_deser_symbol(column_op: ColumnOperation<NumericalValue>) {
-        let buf = column_op.serialize();
-        let mut buffer = buf.as_ref().to_vec();
-        buffer.extend_from_slice(b"234234");
-        let mut bytes = &buffer[..];
+    fn ser_deser_symbol(symbol: ColumnOperation<NumericalValue>) {
+        let buf = symbol.serialize();
+        let mut bytes = &buf.bytes[..];
         let serdeser_symbol = ColumnOperation::deserialize(&mut bytes).unwrap();
-        assert_eq!(bytes.len() + buf.as_ref().len() as usize, buffer.len());
-        assert_eq!(column_op, serdeser_symbol);
+        assert_eq!(bytes.len() + buf.len, buf.bytes.len());
+        assert_eq!(symbol, serdeser_symbol);
     }
 
     #[test]
@@ -288,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,271 +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 {
-    SameDoc = 0,
-    NextDoc = 1,
-    SkippedDoc = 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::SameDoc,
-        Ordering::Equal => DocumentStep::NextDoc,
-        Ordering::Greater => DocumentStep::SkippedDoc,
-    }
-}
-
-#[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(crate) 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(crate) 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::SameDoc => {
-                // This is the last encounterred document.
-                self.cardinality = Cardinality::Multivalued;
-            }
-            DocumentStep::NextDoc => {
-                self.last_doc_opt = Some(doc);
-                self.write_symbol::<S>(ColumnOperation::NewDoc(doc), arena);
-            }
-            DocumentStep::SkippedDoc => {
-                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::SameDoc | DocumentStep::NextDoc => self.cardinality,
-            DocumentStep::SkippedDoc => 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 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(crate) 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::NextDoc);
-        assert_eq!(delta_with_last_doc(None, 1u32), DocumentStep::SkippedDoc);
-        assert_eq!(delta_with_last_doc(None, 2u32), DocumentStep::SkippedDoc);
-        assert_eq!(delta_with_last_doc(Some(0u32), 0u32), DocumentStep::SameDoc);
-        assert_eq!(delta_with_last_doc(Some(1u32), 1u32), DocumentStep::SameDoc);
-        assert_eq!(delta_with_last_doc(Some(1u32), 2u32), DocumentStep::NextDoc);
-        assert_eq!(
-            delta_with_last_doc(Some(1u32), 3u32),
-            DocumentStep::SkippedDoc
-        );
-        assert_eq!(
-            delta_with_last_doc(Some(1u32), 4u32),
-            DocumentStep::SkippedDoc
-        );
-    }
-
-    #[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,52 +1,196 @@
 mod column_operation;
-mod column_writers;
-mod serializer;
 mod value_index;
 
 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 stacker::{Addr, ArenaHashMap, MemoryArena};
+use ordered_float::NotNan;
+use stacker::{Addr, ArenaHashMap, ExpUnrolledLinkedList, MemoryArena};
 
-use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality, ColumnTypeCategory};
-use crate::dictionary::{DictionaryBuilder, TermIdMapping, UnorderedId};
+use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality};
+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 only here
-/// to limit the amount of allocation.
-#[derive(Default)]
-struct SpareBuffers {
-    value_index_builders: SpareIndexBuilders,
-    i64_values: Vec<i64>,
-    u64_values: Vec<u64>,
-    f64_values: Vec<f64>,
-    bool_values: Vec<bool>,
-    column_buffer: Vec<u8>,
+#[derive(Copy, Clone, Default)]
+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,
+}
+
+#[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;
-/// fn main() {
-///     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.
@@ -54,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(),
@@ -67,296 +219,235 @@ 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>(
-        &mut self,
-        doc: DocId,
-        column_name: &str,
-        numerical_value: T,
-    ) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
+    pub fn record_numerical(&mut self, doc: DocId, key: &[u8], numerical_value: NumericalValue) {
         let (hash_map, arena) = (&mut self.numerical_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<NumericalColumnWriter>| {
-                let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
-                column.record_numerical_value(doc, numerical_value.into(), arena);
-                column
-            },
-        );
+        hash_map.mutate_or_create(key, |column_opt: Option<NumericalColumnWriter>| {
+            let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
+            column.record_numerical_value(doc, numerical_value, arena);
+            column
+        });
     }
 
-    pub fn record_bool(&mut self, doc: DocId, column_name: &str, val: bool) {
-        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"
-        );
+    pub fn record_bytes(&mut self, doc: DocId, key: &[u8], value: &[u8]) {
         let (hash_map, arena, dictionaries) = (
             &mut self.bytes_field_hash_map,
             &mut self.arena,
             &mut self.dictionaries,
         );
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<StrColumnWriter>| {
-                let mut column: StrColumnWriter = column_opt.unwrap_or_else(|| {
-                    let dictionary_id = dictionaries.len() as u32;
-                    dictionaries.push(DictionaryBuilder::default());
-                    StrColumnWriter::with_dictionary_id(dictionary_id)
-                });
-                column.record_bytes(doc, value.as_bytes(), dictionaries, arena);
-                column
-            },
-        );
+        hash_map.mutate_or_create(key, |column_opt: Option<BytesColumnWriter>| {
+            let mut column: BytesColumnWriter = column_opt.unwrap_or_else(|| {
+                let dictionary_id = dictionaries.len() as u32;
+                dictionaries.push(DictionaryBuilder::default());
+                BytesColumnWriter::with_dictionary_id(dictionary_id)
+            });
+            column.record_bytes(doc, value, dictionaries, arena);
+            column
+        });
     }
 
-    pub fn serialize(&mut self, num_docs: DocId, wrt: &mut dyn io::Write) -> io::Result<()> {
-        let mut serializer = ColumnarSerializer::new(wrt);
-        let mut field_columns: Vec<(&[u8], ColumnTypeCategory, Addr)> = self
+    pub fn serialize<W: io::Write>(
+        &mut 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(
-            self.bool_field_hash_map
-                .iter()
-                .map(|(term, addr, _)| (term, ColumnTypeCategory::Bool, addr)),
-        );
-        field_columns.sort_unstable_by_key(|(column_name, col_type, _)| (*column_name, *col_type));
+        let mut key_buffer = Vec::new();
+        field_columns.sort_unstable_by_key(|(key, col_type, _)| (*key, *col_type));
         let (arena, buffers, dictionaries) = (&self.arena, &mut self.buffers, &self.dictionaries);
-        let mut symbol_byte_buffer: Vec<u8> = Vec::new();
-        for (column_name, bytes_or_numerical, addr) in field_columns {
-            match bytes_or_numerical {
-                ColumnTypeCategory::Bool => {
-                    let column_writer: ColumnWriter = self.bool_field_hash_map.read(addr);
-                    let cardinality = column_writer.get_cardinality(num_docs);
-                    let column_type_and_cardinality = ColumnTypeAndCardinality {
-                        cardinality,
-                        typ: ColumnType::Bool,
-                    };
-                    let 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,
-                        column_serializer,
-                    )?;
-                }
-                ColumnTypeCategory::Str => {
-                    let str_column_writer: StrColumnWriter = self.bytes_field_hash_map.read(addr);
+        for (key, bytes_or_numerical, addr) in field_columns {
+            let wrt = serializer.wrt();
+            let start_offset = wrt.written_bytes();
+            let column_type_and_cardinality: ColumnTypeAndCardinality =
+                match bytes_or_numerical {
+                BytesOrNumerical::Bytes => {
+                    let BytesColumnWriter { dictionary_id, column_writer } =
+                        self.bytes_field_hash_map.read(addr);
                     let dictionary_builder =
-                        &dictionaries[str_column_writer.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 column_serializer =
-                        serializer.serialize_column(column_name, column_type_and_cardinality);
+                        &dictionaries[dictionary_id as usize];
                     serialize_bytes_column(
-                        cardinality,
+                        &column_writer,
                         num_docs,
                         dictionary_builder,
-                        str_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        arena,
                         buffers,
-                        column_serializer,
+                        wrt,
                     )?;
+                    ColumnTypeAndCardinality {
+                        cardinality: column_writer.get_cardinality(num_docs),
+                        typ: ColumnType::Bytes,
+                    }
                 }
-                ColumnTypeCategory::Numerical => {
-                    let numerical_column_writer: NumericalColumnWriter =
+                BytesOrNumerical::Numerical => {
+                    let NumericalColumnWriter { compatible_numerical_types, column_writer  } =
                         self.numerical_field_hash_map.read(addr);
-                    let (numerical_type, cardinality) =
-                        numerical_column_writer.column_type_and_cardinality(num_docs);
-                    let column_type_and_cardinality = ColumnTypeAndCardinality {
-                        cardinality,
-                        typ: ColumnType::Numerical(numerical_type),
-                    };
-                    let column_serializer =
-                        serializer.serialize_column(column_name, column_type_and_cardinality);
+                    let cardinality = column_writer.get_cardinality(num_docs);
+                    let numerical_type = compatible_numerical_types.to_numerical_type();
                     serialize_numerical_column(
                         cardinality,
-                        num_docs,
                         numerical_type,
-                        numerical_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        &column_writer,
+                        num_docs,
+                        arena,
                         buffers,
-                        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 compress_and_write_column<W: io::Write>(column_bytes: &[u8], wrt: &mut W) -> io::Result<()> {
-    wrt.write_all(column_bytes)?;
-    Ok(())
+/// Returns a key consisting of the concatenation of the key and the column_type_and_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>(
-    cardinality: Cardinality,
+    column_writer: &ColumnWriter,
     num_docs: DocId,
     dictionary_builder: &DictionaryBuilder,
-    operation_it: impl Iterator<Item = ColumnOperation<UnorderedId>>,
+    arena: &MemoryArena,
     buffers: &mut SpareBuffers,
-    mut wrt: W,
+    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,
-        column_buffer,
         ..
     } = buffers;
-    column_buffer.clear();
-    let term_id_mapping: TermIdMapping = dictionary_builder.serialize(column_buffer)?;
-    let dictionary_num_bytes: u32 = column_buffer.len() as u32;
-    let operation_iterator = operation_it.map(|symbol: ColumnOperation<UnorderedId>| {
-        // We map unordered ids to ordered ids.
-        match symbol {
-            ColumnOperation::Value(unordered_id) => {
-                let ordered_id = term_id_mapping.to_ord(unordered_id);
-                ColumnOperation::Value(ordered_id.0 as u64)
+    let symbol_iterator = column_writer
+        .symbol_iterator(arena, byte_buffer)
+        .map(|symbol: ColumnOperation<UnorderedId>| {
+            // We map unordered ids to ordered ids.
+            match symbol {
+                ColumnOperation::Value(unordered_id) => {
+                    let ordered_id = 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,
-        column_buffer,
+        wrt,
     )?;
-    column_buffer.write_all(&dictionary_num_bytes.to_le_bytes()[..])?;
-    compress_and_write_column(column_buffer, &mut wrt)?;
+    wrt.write_all(&dictionary_num_bytes.to_le_bytes()[..])?;
     Ok(())
 }
 
 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,
-    mut wrt: W,
+    wrt: &mut W,
 ) -> io::Result<()> {
     let SpareBuffers {
+        byte_buffer,
         value_index_builders,
         u64_values,
         i64_values,
         f64_values,
-        column_buffer,
-        ..
     } = buffers;
-    column_buffer.clear();
+    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,
                 i64_values,
-                column_buffer,
+                wrt,
             )?;
         }
         NumericalType::U64 => {
             serialize_column(
-                coerce_numerical_symbol::<u64>(op_iterator),
+                coerce_numerical_symbol::<u64>(symbol_iterator),
                 cardinality,
                 num_docs,
                 value_index_builders,
                 u64_values,
-                column_buffer,
+                wrt,
             )?;
         }
         NumericalType::F64 => {
             serialize_column(
-                coerce_numerical_symbol::<f64>(op_iterator),
+                coerce_numerical_symbol::<NotNan<f64>>(symbol_iterator),
                 cardinality,
                 num_docs,
                 value_index_builders,
                 f64_values,
-                column_buffer,
+                wrt,
             )?;
         }
     };
-    compress_and_write_column(column_buffer, &mut wrt)?;
-    Ok(())
-}
-
-fn serialize_bool_column<W: io::Write>(
-    cardinality: Cardinality,
-    num_docs: DocId,
-    column_operations_it: impl Iterator<Item = ColumnOperation<bool>>,
-    buffers: &mut SpareBuffers,
-    mut wrt: W,
-) -> io::Result<()> {
-    let SpareBuffers {
-        value_index_builders,
-        bool_values,
-        column_buffer,
-        ..
-    } = buffers;
-    column_buffer.clear();
-    serialize_column(
-        column_operations_it,
-        cardinality,
-        num_docs,
-        value_index_builders,
-        bool_values,
-        column_buffer,
-    )?;
-    compress_and_write_column(column_buffer, &mut 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>,
-    wrt: &mut Vec<u8>,
+    wrt: &mut W,
 ) -> io::Result<()>
 where
     for<'a> VecColumn<'a, T>: Column<T>,
 {
-    values.clear();
     match cardinality {
         Cardinality::Required => {
-            consume_operation_iterator(
-                op_iterator,
+            consume_symbol_iterator(
+                symbol_iterator,
                 value_index_builders.borrow_required_index_builder(),
                 values,
             );
@@ -368,7 +459,7 @@ where
         }
         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)),
@@ -379,7 +470,7 @@ where
         }
         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)),
@@ -393,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))
@@ -404,12 +495,12 @@ where T: Coerce {
     })
 }
 
-fn consume_operation_iterator<T: std::fmt::Debug, TIndexBuilder: IndexBuilder>(
-    operation_iterator: impl Iterator<Item = ColumnOperation<T>>,
+fn consume_symbol_iterator<T, TIndexBuilder: IndexBuilder>(
+    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);
@@ -424,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 crate::value::NumericalValue;
+    use super::prepare_key;
+    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(1u32, NumericalValue::from(15i64), &mut arena);
-        column_writer.record(2u32, NumericalValue::from(-16i64), &mut arena);
+        column_writer.record(0u32, 14i64.into(), &mut arena);
+        column_writer.record(1u32, 15i64.into(), &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)));
@@ -465,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(2u32, NumericalValue::from(-16i64), &mut arena);
+        column_writer.record(1u32, 15i64.into(), &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)));
@@ -489,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)));
@@ -507,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, NumericalValue::from(17i64), &mut arena);
+        column_writer.record(0u32, 16i64.into(), &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)));
@@ -525,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<'a>(
-    key: &[u8],
-    column_type_cardinality: ColumnTypeAndCardinality,
-    buffer: &'a 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());
-    }
-}

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> {
-        Err(io::Error::new(
-            io::ErrorKind::Unsupported,
-            "Async read is not supported.",
-        ))
+    async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
+        self.read_bytes(byte_range)
     }
 }
 
@@ -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
-/// 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.
+#[inline]
 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,19 +231,21 @@ 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};
-    use crate::{file_slice::combine_ranges, HasLen};
+    use crate::file_slice::combine_ranges;
+    use crate::HasLen;
 
     #[test]
     fn test_file_slice() -> io::Result<()> {
@@ -331,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/lib.rs

@@ -10,7 +10,7 @@ mod serialize;
 mod vint;
 mod writer;
 pub use bitset::*;
-pub use ownedbytes::{OwnedBytes, StableDeref};
+pub use ownedbytes::OwnedBytes;
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
 pub use vint::{
     deserialize_vint_u128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u128,

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/" }
+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

@@ -7,8 +7,8 @@ mod tests {
     use std::iter;
     use std::sync::Arc;
 
-    use common::OwnedBytes;
     use fastfield_codecs::*;
+    use ownedbytes::OwnedBytes;
     use rand::prelude::*;
     use test::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

@@ -42,7 +42,8 @@ pub trait Column<T: PartialOrd = u64>: Send + Sync {
         positions: &mut Vec<u32>,
     ) {
         let doc_id_range = doc_id_range.start..doc_id_range.end.min(self.num_vals());
-        for idx in doc_id_range {
+
+        for idx in doc_id_range.start..doc_id_range.end {
             let val = self.get_val(idx);
             if value_range.contains(&val) {
                 positions.push(idx);
@@ -134,7 +135,7 @@ impl<'a, T: Copy + PartialOrd + Send + Sync> Column<T> for VecColumn<'a, T> {
     }
 }
 
-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 V: AsRef<[T]> + ?Sized
 {
     fn from(values: &'a V) -> Self {

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;

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

@@ -18,7 +18,7 @@ use std::io;
 use std::io::Write;
 use std::sync::Arc;
 
-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};
@@ -435,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,6 +1,7 @@
 use std::marker::PhantomData;
 
 use fastdivide::DividerU64;
+use ordered_float::NotNan;
 
 use crate::MonotonicallyMappableToU128;
 
@@ -56,12 +57,10 @@ impl<T> From<T> for StrictlyMonotonicMappingInverter<T> {
 impl<From, To, T> StrictlyMonotonicFn<To, From> for StrictlyMonotonicMappingInverter<T>
 where T: StrictlyMonotonicFn<From, To>
 {
-    #[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)
     }
@@ -84,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)
     }
@@ -99,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)
     }
@@ -132,13 +127,11 @@ 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)
     }
@@ -149,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 }
     }
@@ -158,24 +150,20 @@ impl StrictlyMonotonicMappingToInternalBaseval {
 impl<External: MonotonicallyMappableToU64> StrictlyMonotonicFn<External, u64>
     for StrictlyMonotonicMappingToInternalBaseval
 {
-    #[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
     }
@@ -208,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

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

fastfield_codecs/src/null_index/sparse.rs

@@ -1,6 +1,7 @@
 use std::io::{self, Write};
 
-use common::{BitSet, 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,

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.
-//
-// 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::io;
 use std::num::NonZeroU64;
 use std::sync::Arc;
 
-use common::{BinarySerializable, OwnedBytes, VInt};
+use common::{BinarySerializable, VInt};
 use log::warn;
+use ownedbytes::OwnedBytes;
 
 use crate::bitpacked::BitpackedCodec;
 use crate::blockwise_linear::BlockwiseLinearCodec;
@@ -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 {}

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/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;

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/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/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 {
-            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;
+        if !self.term_open {
+            return Ok(());
         }
+        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/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/range_query_ip_fastfield.rs

@@ -280,7 +280,9 @@ impl DocSet for IpRangeDocSet {
 
     #[inline]
     fn doc(&self) -> DocId {
-        self.loaded_docs.current().unwrap_or(TERMINATED)
+        self.loaded_docs
+            .current()
+            .unwrap_or(TERMINATED)
     }
 
     /// Advances the `DocSet` forward until reaching the target, or going to the

src/store/reader.rs

@@ -4,8 +4,9 @@ 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;

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>;
-
-/// 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 TermDictionaryBuilder<W> = sstable::Writer<W, TermInfoWriter>;
 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 ValueWriter = TermInfoValueWriter;
+    type ValueReader = TermInfoReader;
+    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;
+}

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

sstable/benches/stream_bench.rs

@@ -1,87 +0,0 @@
-use std::collections::BTreeSet;
-use std::io;
-
-use common::file_slice::FileSlice;
-use criterion::{criterion_group, criterion_main, Criterion};
-use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
-use tantivy_sstable::{self, Dictionary, MonotonicU64SSTable};
-
-const CHARSET: &'static [u8] = b"abcdefghij";
-
-fn generate_key(rng: &mut impl Rng) -> String {
-    let len = rng.gen_range(3..12);
-    std::iter::from_fn(|| {
-        let idx = rng.gen_range(0..CHARSET.len());
-        Some(CHARSET[idx] as char)
-    })
-    .take(len)
-    .collect()
-}
-
-fn prepare_sstable() -> io::Result<Dictionary<MonotonicU64SSTable>> {
-    let mut rng = StdRng::from_seed([3u8; 32]);
-    let mut els = BTreeSet::new();
-    while els.len() < 100_000 {
-        els.insert(generate_key(&mut rng));
-    }
-    let mut dictionary_builder = Dictionary::<MonotonicU64SSTable>::builder(Vec::new())?;
-    for (ord, word) in els.iter().enumerate() {
-        dictionary_builder.insert(word, &(ord as u64))?;
-    }
-    let buffer = dictionary_builder.finish()?;
-    let dictionary = Dictionary::open(FileSlice::from(buffer))?;
-    Ok(dictionary)
-}
-
-fn stream_bench(
-    dictionary: &Dictionary<MonotonicU64SSTable>,
-    lower: &[u8],
-    upper: &[u8],
-    do_scan: bool,
-) -> usize {
-    let mut stream = dictionary
-        .range()
-        .ge(lower)
-        .lt(upper)
-        .into_stream()
-        .unwrap();
-    if !do_scan {
-        return 0;
-    }
-    let mut count = 0;
-    while stream.advance() {
-        count += 1;
-    }
-    count
-}
-
-pub fn criterion_benchmark(c: &mut Criterion) {
-    let dict = prepare_sstable().unwrap();
-    c.bench_function("short_scan_init", |b| {
-        b.iter(|| stream_bench(&dict, b"fa", b"fana", false))
-    });
-    c.bench_function("short_scan_init_and_scan", |b| {
-        b.iter(|| {
-            assert_eq!(stream_bench(&dict, b"fa", b"faz", true), 971);
-        })
-    });
-    c.bench_function("full_scan_init_and_scan_full_with_bound", |b| {
-        b.iter(|| {
-            assert_eq!(stream_bench(&dict, b"", b"z", true), 100_000);
-        })
-    });
-    c.bench_function("full_scan_init_and_scan_full_no_bounds", |b| {
-        b.iter(|| {
-            let mut stream = dict.stream().unwrap();
-            let mut count = 0;
-            while stream.advance() {
-                count += 1;
-            }
-            count
-        })
-    });
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

sstable/src/block_reader.rs

@@ -1,5 +1,4 @@
 use std::io;
-use std::ops::Range;
 
 pub struct BlockReader<'a> {
     buffer: Vec<u8>,
@@ -30,8 +29,8 @@ impl<'a> BlockReader<'a> {
     }
 
     #[inline(always)]
-    pub fn buffer_from_to(&self, range: Range<usize>) -> &[u8] {
-        &self.buffer[range]
+    pub fn buffer_from_to(&self, start: usize, end: usize) -> &[u8] {
+        &self.buffer[start..end]
     }
 
     pub fn read_block(&mut self) -> io::Result<bool> {
@@ -52,17 +51,14 @@ impl<'a> BlockReader<'a> {
         Ok(true)
     }
 
-    #[inline(always)]
     pub fn offset(&self) -> usize {
         self.offset
     }
 
-    #[inline(always)]
     pub fn advance(&mut self, num_bytes: usize) {
         self.offset += num_bytes;
     }
 
-    #[inline(always)]
     pub fn buffer(&self) -> &[u8] {
         &self.buffer[self.offset..]
     }

sstable/src/delta.rs

@@ -16,8 +16,6 @@ where W: io::Write
     block: Vec<u8>,
     write: CountingWriter<BufWriter<W>>,
     value_writer: TValueWriter,
-    // Only here to avoid allocations.
-    stateless_buffer: Vec<u8>,
 }
 
 impl<W, TValueWriter> DeltaWriter<W, TValueWriter>
@@ -30,7 +28,6 @@ where
             block: Vec::with_capacity(BLOCK_LEN * 2),
             write: CountingWriter::wrap(BufWriter::new(wrt)),
             value_writer: TValueWriter::default(),
-            stateless_buffer: Vec::new(),
         }
     }
 }
@@ -45,16 +42,15 @@ where
             return Ok(None);
         }
         let start_offset = self.write.written_bytes() as usize;
-        let buffer: &mut Vec<u8> = &mut self.stateless_buffer;
-        self.value_writer.serialize_block(buffer);
-        self.value_writer.clear();
+        // TODO avoid buffer allocation
+        let mut buffer = Vec::new();
+        self.value_writer.serialize_block(&mut buffer);
         let block_len = buffer.len() + self.block.len();
         self.write.write_all(&(block_len as u32).to_le_bytes())?;
         self.write.write_all(&buffer[..])?;
         self.write.write_all(&self.block[..])?;
         let end_offset = self.write.written_bytes() as usize;
         self.block.clear();
-        buffer.clear();
         Ok(Some(start_offset..end_offset))
     }
 
@@ -95,7 +91,8 @@ where
 
 pub struct DeltaReader<'a, TValueReader> {
     common_prefix_len: usize,
-    suffix_range: Range<usize>,
+    suffix_start: usize,
+    suffix_end: usize,
     value_reader: TValueReader,
     block_reader: BlockReader<'a>,
     idx: usize,
@@ -108,7 +105,8 @@ where TValueReader: value::ValueReader
         DeltaReader {
             idx: 0,
             common_prefix_len: 0,
-            suffix_range: 0..0,
+            suffix_start: 0,
+            suffix_end: 0,
             value_reader: TValueReader::default(),
             block_reader: BlockReader::new(Box::new(reader)),
         }
@@ -146,14 +144,15 @@ where TValueReader: value::ValueReader
     }
 
     fn read_delta_key(&mut self) -> bool {
-        let Some((keep, add)) = self.read_keep_add() else {
-            return false;
-        };
-        self.common_prefix_len = keep;
-        let suffix_start = self.block_reader.offset();
-        self.suffix_range = suffix_start..(suffix_start + add);
-        self.block_reader.advance(add);
-        true
+        if let Some((keep, add)) = self.read_keep_add() {
+            self.common_prefix_len = keep;
+            self.suffix_start = self.block_reader.offset();
+            self.suffix_end = self.suffix_start + add;
+            self.block_reader.advance(add);
+            true
+        } else {
+            false
+        }
     }
 
     pub fn advance(&mut self) -> io::Result<bool> {
@@ -173,17 +172,15 @@ where TValueReader: value::ValueReader
         Ok(true)
     }
 
-    #[inline(always)]
     pub fn common_prefix_len(&self) -> usize {
         self.common_prefix_len
     }
 
-    #[inline(always)]
     pub fn suffix(&self) -> &[u8] {
-        self.block_reader.buffer_from_to(self.suffix_range.clone())
+        self.block_reader
+            .buffer_from_to(self.suffix_start, self.suffix_end)
     }
 
-    #[inline(always)]
     pub fn value(&self) -> &TValueReader::Value {
         self.value_reader.value(self.idx)
     }
@@ -192,11 +189,11 @@ where TValueReader: value::ValueReader
 #[cfg(test)]
 mod tests {
     use super::DeltaReader;
-    use crate::value::U64MonotonicValueReader;
+    use crate::value::U64MonotonicReader;
 
     #[test]
     fn test_empty() {
-        let mut delta_reader: DeltaReader<U64MonotonicValueReader> = DeltaReader::empty();
+        let mut delta_reader: DeltaReader<U64MonotonicReader> = DeltaReader::empty();
         assert!(!delta_reader.advance().unwrap());
     }
 }

sstable/src/dictionary.rs

@@ -11,25 +11,12 @@ use tantivy_fst::Automaton;
 use crate::streamer::{Streamer, StreamerBuilder};
 use crate::{BlockAddr, DeltaReader, Reader, SSTable, SSTableIndex, TermOrdinal};
 
-/// An SSTable is a sorted map that associates sorted `&[u8]` keys
-/// to any kind of typed values.
+/// The term dictionary contains all of the terms in
+/// `tantivy index` in a sorted manner.
 ///
-/// The SSTable is organized in blocks.
-/// In each block, keys and values are encoded separately.
-///
-/// The keys are encoded using incremental encoding.
-/// The values on the other hand, are encoded according to a value-specific
-/// codec defined in the TSSTable generic argument.
-///
-/// Finally, an index is joined to the Dictionary to make it possible,
-/// given a key to identify which block contains this key.
-///
-/// The codec was designed in such a way that the sstable
-/// reader is not aware of block, and yet can read any sequence of blocks,
-/// as long as the slice of bytes it is given starts and stops at
-/// block boundary.
-///
-/// (See also README.md)
+/// The `Fst` crate is used to associate terms to their
+/// respective `TermOrdinal`. The `TermInfoStore` then makes it
+/// possible to fetch the associated `TermInfo`.
 pub struct Dictionary<TSSTable: SSTable> {
     pub sstable_slice: FileSlice,
     pub sstable_index: SSTableIndex,
@@ -75,23 +62,6 @@ impl<TSSTable: SSTable> Dictionary<TSSTable> {
         Ok(TSSTable::delta_reader(data))
     }
 
-    /// This function returns a file slice covering a set of sstable blocks
-    /// that include the key range passed in arguments.
-    ///
-    /// It works by identifying
-    /// - `first_block`: the block containing the start boudary key
-    /// - `last_block`: the block containing the end boundary key.
-    ///
-    /// And then returning the range that spans over all blocks between.
-    /// and including first_block and last_block, aka:
-    /// `[first_block.start_offset .. last_block.end_offset)`
-    ///
-    /// Technically this function does not provide the tightest fit, as
-    /// for simplification, it treats the start bound of the `key_range`
-    /// as if it was inclusive, even if it is exclusive.
-    /// On the rare edge case where a user asks for `(start_key, end_key]`
-    /// and `start_key` happens to be the last key of a block, we return a
-    /// slice that is the first block was not necessary.
     fn file_slice_for_range(&self, key_range: impl RangeBounds<[u8]>) -> FileSlice {
         let start_bound: Bound<usize> = match key_range.start_bound() {
             Bound::Included(key) | Bound::Excluded(key) => {

sstable/src/lib.rs

@@ -20,15 +20,13 @@ mod block_reader;
 pub use self::block_reader::BlockReader;
 pub use self::delta::{DeltaReader, DeltaWriter};
 pub use self::merge::VoidMerge;
-use self::value::{U64MonotonicValueReader, U64MonotonicValueWriter, ValueReader, ValueWriter};
-use crate::value::{RangeValueReader, RangeValueWriter};
+use self::value::{U64MonotonicReader, U64MonotonicWriter, ValueReader, ValueWriter};
+use crate::value::{RangeReader, RangeWriter};
 
 pub type TermOrdinal = u64;
 
 const DEFAULT_KEY_CAPACITY: usize = 50;
 
-/// Given two byte string returns the length of
-/// the longest common prefix.
 fn common_prefix_len(left: &[u8], right: &[u8]) -> usize {
     left.iter()
         .cloned()
@@ -40,8 +38,6 @@ fn common_prefix_len(left: &[u8], right: &[u8]) -> usize {
 #[derive(Debug, Copy, Clone)]
 pub struct SSTableDataCorruption;
 
-/// SSTable makes it possible to read and write
-/// sstables with typed values.
 pub trait SSTable: Sized {
     type Value: Clone;
     type ValueReader: ValueReader<Value = Self::Value>;
@@ -51,8 +47,14 @@ pub trait SSTable: Sized {
         DeltaWriter::new(write)
     }
 
-    fn writer<W: io::Write>(wrt: W) -> Writer<W, Self::ValueWriter> {
-        Writer::new(wrt)
+    fn writer<W: io::Write>(write: W) -> Writer<W, Self::ValueWriter> {
+        Writer {
+            previous_key: Vec::with_capacity(DEFAULT_KEY_CAPACITY),
+            num_terms: 0u64,
+            index_builder: SSTableIndexBuilder::default(),
+            delta_writer: Self::delta_writer(write),
+            first_ordinal_of_the_block: 0u64,
+        }
     }
 
     fn delta_reader<'a, R: io::Read + 'a>(reader: R) -> DeltaReader<'a, Self::ValueReader> {
@@ -87,47 +89,32 @@ pub struct VoidSSTable;
 
 impl SSTable for VoidSSTable {
     type Value = ();
-    type ValueReader = value::VoidValueReader;
-    type ValueWriter = value::VoidValueWriter;
+    type ValueReader = value::VoidReader;
+    type ValueWriter = value::VoidWriter;
 }
 
-/// SSTable associated keys to u64
-/// sorted in order.
-///
-/// In other words, two keys `k1` and `k2`
-/// such that `k1` <= `k2`, are required to observe
-/// `range_sstable[k1] <= range_sstable[k2]`.
 #[allow(dead_code)]
-pub struct MonotonicU64SSTable;
+pub struct SSTableMonotonicU64;
 
-impl SSTable for MonotonicU64SSTable {
+impl SSTable for SSTableMonotonicU64 {
     type Value = u64;
 
-    type ValueReader = U64MonotonicValueReader;
+    type ValueReader = U64MonotonicReader;
 
-    type ValueWriter = U64MonotonicValueWriter;
+    type ValueWriter = U64MonotonicWriter;
 }
 
-/// SSTable associating keys to ranges.
-/// The range are required to partition the
-/// space.
-///
-/// In other words, two consecutive keys `k1` and `k2`
-/// are required to observe
-/// `range_sstable[k1].end == range_sstable[k2].start`.
-///
-/// The first range is not required to start at `0`.
-pub struct RangeSSTable;
+/// Retpresent
+pub struct SSTableRange;
 
-impl SSTable for RangeSSTable {
+impl SSTable for SSTableRange {
     type Value = Range<u64>;
 
-    type ValueReader = RangeValueReader;
+    type ValueReader = RangeReader;
 
-    type ValueWriter = RangeValueWriter;
+    type ValueWriter = RangeWriter;
 }
 
-/// SSTable reader.
 pub struct Reader<'a, TValueReader> {
     key: Vec<u8>,
     delta_reader: DeltaReader<'a, TValueReader>,
@@ -148,19 +135,16 @@ where TValueReader: ValueReader
         Ok(true)
     }
 
-    #[inline(always)]
     pub fn key(&self) -> &[u8] {
         &self.key
     }
 
-    #[inline(always)]
     pub fn value(&self) -> &TValueReader::Value {
         self.delta_reader.value()
     }
 }
 
 impl<'a, TValueReader> AsRef<[u8]> for Reader<'a, TValueReader> {
-    #[inline(always)]
     fn as_ref(&self) -> &[u8] {
         &self.key
     }
@@ -181,54 +165,21 @@ where
     W: io::Write,
     TValueWriter: value::ValueWriter,
 {
-    /// Use `Self::new`. This method only exists to match its
-    /// equivalent in fst.
-    /// TODO remove this function. (See Issue #1727)
-    #[doc(hidden)]
     pub fn create(wrt: W) -> io::Result<Self> {
-        Ok(Self::new(wrt))
-    }
-
-    /// Creates a new `TermDictionaryBuilder`.
-    pub fn new(wrt: W) -> Self {
-        Writer {
+        Ok(Writer {
             previous_key: Vec::with_capacity(DEFAULT_KEY_CAPACITY),
             num_terms: 0u64,
             index_builder: SSTableIndexBuilder::default(),
             delta_writer: DeltaWriter::new(wrt),
             first_ordinal_of_the_block: 0u64,
-        }
+        })
     }
 
-    /// Returns the last inserted key.
-    /// If no key has been inserted yet, or the block was just
-    /// flushed, this function returns "".
     #[inline(always)]
-    pub(crate) fn last_inserted_key(&self) -> &[u8] {
+    pub(crate) fn current_key(&self) -> &[u8] {
         &self.previous_key[..]
     }
 
-    /// Inserts a `(key, value)` pair in the term dictionary.
-    /// Keys have to be inserted in order.
-    ///
-    /// # Panics
-    ///
-    /// Will panics if keys are inserted in an invalid order.
-    #[inline]
-    pub fn insert<K: AsRef<[u8]>>(
-        &mut self,
-        key: K,
-        value: &TValueWriter::Value,
-    ) -> io::Result<()> {
-        self.insert_key(key.as_ref())?;
-        self.insert_value(value)?;
-        Ok(())
-    }
-
-    /// # Warning
-    ///
-    /// Horribly dangerous internal API. See `.insert(...)`.
-    #[doc(hidden)]
     #[inline]
     pub fn insert_key(&mut self, key: &[u8]) -> io::Result<()> {
         // If this is the first key in the block, we use it to
@@ -253,10 +204,17 @@ where
         Ok(())
     }
 
-    /// # Warning
-    ///
-    /// Horribly dangerous internal API. See `.insert(...)`.
-    #[doc(hidden)]
+    #[inline]
+    pub fn insert<K: AsRef<[u8]>>(
+        &mut self,
+        key: K,
+        value: &TValueWriter::Value,
+    ) -> io::Result<()> {
+        self.insert_key(key.as_ref())?;
+        self.insert_value(value)?;
+        Ok(())
+    }
+
     #[inline]
     pub fn insert_value(&mut self, value: &TValueWriter::Value) -> io::Result<()> {
         self.delta_writer.write_value(value);
@@ -298,23 +256,11 @@ where
         Ok(wrt.into_inner()?)
     }
 }
-
-impl<TValueWriter> Writer<Vec<u8>, TValueWriter>
-where TValueWriter: value::ValueWriter
-{
-    #[inline]
-    pub fn insert_cannot_fail<K: AsRef<[u8]>>(&mut self, key: K, value: &TValueWriter::Value) {
-        self.insert(key, value)
-            .expect("SSTable over a Vec should never fail");
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::io;
-    use std::ops::Bound;
 
-    use super::{common_prefix_len, MonotonicU64SSTable, SSTable, VoidMerge, VoidSSTable};
+    use super::{common_prefix_len, SSTable, SSTableMonotonicU64, VoidMerge, VoidSSTable};
 
     fn aux_test_common_prefix_len(left: &str, right: &str, expect_len: usize) {
         assert_eq!(
@@ -423,11 +369,8 @@ mod test {
         let mut buffer = Vec::new();
         {
             let mut writer = VoidSSTable::writer(&mut buffer);
-            assert_eq!(writer.last_inserted_key(), b"");
             writer.insert(b"abcd", &()).unwrap();
-            assert_eq!(writer.last_inserted_key(), b"abcd");
             writer.insert(b"abe", &()).unwrap();
-            assert_eq!(writer.last_inserted_key(), b"abe");
             writer.finish().unwrap();
         }
         let mut output = Vec::new();
@@ -438,12 +381,12 @@ mod test {
     #[test]
     fn test_sstable_u64() -> io::Result<()> {
         let mut buffer = Vec::new();
-        let mut writer = MonotonicU64SSTable::writer(&mut buffer);
+        let mut writer = SSTableMonotonicU64::writer(&mut buffer);
         writer.insert(b"abcd", &1u64)?;
         writer.insert(b"abe", &4u64)?;
         writer.insert(b"gogo", &4324234234234234u64)?;
         writer.finish()?;
-        let mut reader = MonotonicU64SSTable::reader(&buffer[..]);
+        let mut reader = SSTableMonotonicU64::reader(&buffer[..]);
         assert!(reader.advance()?);
         assert_eq!(reader.key(), b"abcd");
         assert_eq!(reader.value(), &1u64);
@@ -459,72 +402,7 @@ mod test {
 
     #[test]
     fn test_sstable_empty() {
-        let mut sstable_range_empty = crate::RangeSSTable::create_empty_reader();
+        let mut sstable_range_empty = crate::SSTableRange::create_empty_reader();
         assert!(!sstable_range_empty.advance().unwrap());
     }
-
-    use common::file_slice::FileSlice;
-    use proptest::prelude::*;
-
-    use crate::Dictionary;
-
-    fn bound_strategy() -> impl Strategy<Value = Bound<String>> {
-        prop_oneof![
-            Just(Bound::<String>::Unbounded),
-            "[a-d]*".prop_map(|key| Bound::Included(key)),
-            "[a-d]*".prop_map(|key| Bound::Excluded(key)),
-        ]
-    }
-
-    fn extract_key(bound: Bound<&String>) -> Option<&str> {
-        match bound.as_ref() {
-            Bound::Included(key) => Some(key.as_str()),
-            Bound::Excluded(key) => Some(key.as_str()),
-            Bound::Unbounded => None,
-        }
-    }
-
-    fn bounds_strategy() -> impl Strategy<Value = (Bound<String>, Bound<String>)> {
-        (bound_strategy(), bound_strategy()).prop_filter(
-            "Lower bound <= Upper bound",
-            |(left, right)| match (extract_key(left.as_ref()), extract_key(right.as_ref())) {
-                (None, _) => true,
-                (_, None) => true,
-                (left, right) => left <= right,
-            },
-        )
-    }
-
-    proptest! {
-        #[test]
-        fn test_prop_test_ranges(words in prop::collection::btree_set("[a-d]*", 1..100),
-            (lower_bound, upper_bound) in bounds_strategy(),
-        ) {
-            // TODO tweak block size.
-            let mut builder = Dictionary::<VoidSSTable>::builder(Vec::new()).unwrap();
-            for word in &words {
-                builder.insert(word.as_bytes(), &()).unwrap();
-            }
-            let buffer: Vec<u8> = builder.finish().unwrap();
-            let dictionary: Dictionary<VoidSSTable> = Dictionary::open(FileSlice::from(buffer)).unwrap();
-            let mut range_builder = dictionary.range();
-            range_builder = match lower_bound.as_ref() {
-                Bound::Included(key) => range_builder.ge(key.as_bytes()),
-                Bound::Excluded(key) => range_builder.gt(key.as_bytes()),
-                Bound::Unbounded => range_builder,
-            };
-            range_builder = match upper_bound.as_ref() {
-                Bound::Included(key) => range_builder.le(key.as_bytes()),
-                Bound::Excluded(key) => range_builder.lt(key.as_bytes()),
-                Bound::Unbounded => range_builder,
-            };
-            let mut stream = range_builder.into_stream().unwrap();
-            let mut btree_set_range = words.range((lower_bound, upper_bound));
-            while stream.advance() {
-                let val = btree_set_range.next().unwrap();
-                assert_eq!(val.as_bytes(), stream.key());
-            }
-            assert!(btree_set_range.next().is_none());
-        }
-    }
 }

sstable/src/merge/heap_merge.rs

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

sstable/src/merge/mod.rs

@@ -71,7 +71,7 @@ mod tests {
     use std::collections::{BTreeMap, BTreeSet};
     use std::str;
 
-    use super::super::{MonotonicU64SSTable, SSTable, VoidSSTable};
+    use super::super::{SSTable, SSTableMonotonicU64, VoidSSTable};
     use super::{U64Merge, VoidMerge};
 
     fn write_sstable(keys: &[&'static str]) -> Vec<u8> {
@@ -89,7 +89,7 @@ mod tests {
     fn write_sstable_u64(keys: &[(&'static str, u64)]) -> Vec<u8> {
         let mut buffer: Vec<u8> = vec![];
         {
-            let mut sstable_writer = MonotonicU64SSTable::writer(&mut buffer);
+            let mut sstable_writer = SSTableMonotonicU64::writer(&mut buffer);
             for (key, val) in keys {
                 assert!(sstable_writer.insert(key.as_bytes(), val).is_ok());
             }
@@ -132,8 +132,8 @@ mod tests {
             }
         }
         let mut w = Vec::new();
-        assert!(MonotonicU64SSTable::merge(sstables_ref, &mut w, U64Merge).is_ok());
-        let mut reader = MonotonicU64SSTable::reader(&w[..]);
+        assert!(SSTableMonotonicU64::merge(sstables_ref, &mut w, U64Merge).is_ok());
+        let mut reader = SSTableMonotonicU64::reader(&w[..]);
         for (k, v) in merged {
             assert!(reader.advance().unwrap());
             assert_eq!(reader.key(), k.as_bytes());

sstable/src/sstable_index.rs

@@ -16,9 +16,16 @@ impl SSTableIndex {
     }
 
     pub fn search_block(&self, key: &[u8]) -> Option<BlockAddr> {
+        self.search_block_from(key).next()
+    }
+
+    pub fn search_block_from<'key, 'slf: 'key>(
+        &'slf self,
+        key: &'key [u8],
+    ) -> impl Iterator<Item = BlockAddr> + Clone + 'key {
         self.blocks
             .iter()
-            .find(|block| &block.last_key_or_greater[..] >= key)
+            .skip_while(|block| &block.last_key_or_greater[..] < key)
             .map(|block| block.block_addr.clone())
     }
 }

sstable/src/streamer.rs

@@ -211,10 +211,10 @@ mod tests {
 
     use common::OwnedBytes;
 
-    use crate::{Dictionary, MonotonicU64SSTable};
+    use crate::{Dictionary, SSTableMonotonicU64};
 
-    fn create_test_dictionary() -> io::Result<Dictionary<MonotonicU64SSTable>> {
-        let mut dict_builder = Dictionary::<MonotonicU64SSTable>::builder(Vec::new())?;
+    fn create_test_dictionary() -> io::Result<Dictionary<SSTableMonotonicU64>> {
+        let mut dict_builder = Dictionary::<SSTableMonotonicU64>::builder(Vec::new())?;
         dict_builder.insert(b"abaisance", &0)?;
         dict_builder.insert(b"abalation", &1)?;
         dict_builder.insert(b"abalienate", &2)?;

sstable/src/value/mod.rs

@@ -20,30 +20,24 @@ pub trait ValueReader: Default {
     fn load(&mut self, data: &[u8]) -> io::Result<usize>;
 }
 
-/// `ValueWriter` is a trait to make it possible to write blocks
-/// of value.
 pub trait ValueWriter: Default {
     /// Type of the value being written.
     type Value;
 
     /// Records a new value.
     /// This method usually just accumulates data in a `Vec`,
-    /// only to be serialized on the call to `ValueWriter::serialize_block`.
+    /// only to be serialized on the call to `ValueWriter::write_block`.
     fn write(&mut self, val: &Self::Value);
 
     /// Serializes the accumulated values into the output buffer.
-    fn serialize_block(&self, output: &mut Vec<u8>);
-
-    /// Clears the `ValueWriter`. After a call to clear, the `ValueWriter`
-    /// should behave like a fresh `ValueWriter::default()`.
-    fn clear(&mut self);
+    fn serialize_block(&mut self, output: &mut Vec<u8>);
 }
 
-pub use range::{RangeValueReader, RangeValueWriter};
-pub use u64_monotonic::{U64MonotonicValueReader, U64MonotonicValueWriter};
-pub use void::{VoidValueReader, VoidValueWriter};
+pub use range::{RangeReader, RangeWriter};
+pub use u64_monotonic::{U64MonotonicReader, U64MonotonicWriter};
+pub use void::{VoidReader, VoidWriter};
 
-fn deserialize_vint_u64(data: &mut &[u8]) -> u64 {
+fn deserialize_u64(data: &mut &[u8]) -> u64 {
     let (num_bytes, val) = super::vint::deserialize_read(data);
     *data = &data[num_bytes..];
     val
@@ -69,7 +63,6 @@ pub(crate) mod tests {
                 writer.write(value);
             }
             writer.serialize_block(&mut buffer);
-            writer.clear();
         }
         let data_len = buffer.len();
         buffer.extend_from_slice(&b"extradata"[..]);

sstable/src/value/range.rs

@@ -1,18 +1,16 @@
 use std::io;
 use std::ops::Range;
 
-use crate::value::{deserialize_vint_u64, ValueReader, ValueWriter};
+use crate::value::{deserialize_u64, ValueReader, ValueWriter};
 
-/// See module comment.
 #[derive(Default)]
-pub struct RangeValueReader {
+pub struct RangeReader {
     vals: Vec<Range<u64>>,
 }
 
-impl ValueReader for RangeValueReader {
+impl ValueReader for RangeReader {
     type Value = Range<u64>;
 
-    #[inline(always)]
     fn value(&self, idx: usize) -> &Range<u64> {
         &self.vals[idx]
     }
@@ -20,11 +18,11 @@ impl ValueReader for RangeValueReader {
     fn load(&mut self, mut data: &[u8]) -> io::Result<usize> {
         self.vals.clear();
         let original_num_bytes = data.len();
-        let len = deserialize_vint_u64(&mut data) as usize;
+        let len = deserialize_u64(&mut data) as usize;
         if len != 0 {
-            let mut prev_val = deserialize_vint_u64(&mut data);
+            let mut prev_val = deserialize_u64(&mut data);
             for _ in 1..len {
-                let next_val = prev_val + deserialize_vint_u64(&mut data);
+                let next_val = prev_val + deserialize_u64(&mut data);
                 self.vals.push(prev_val..next_val);
                 prev_val = next_val;
             }
@@ -33,23 +31,12 @@ impl ValueReader for RangeValueReader {
     }
 }
 
-/// Range writer. The range are required to partition the
-/// space.
-///
-/// In other words, two consecutive keys `k1` and `k2`
-/// are required to observe
-/// `range_sstable[k1].end == range_sstable[k2].start`.
-///
-/// The writer will panic if the inserted value do not follow
-/// this property.
-///
-/// The first range is not required to start at `0`.
 #[derive(Default)]
-pub struct RangeValueWriter {
+pub struct RangeWriter {
     vals: Vec<u64>,
 }
 
-impl ValueWriter for RangeValueWriter {
+impl ValueWriter for RangeWriter {
     type Value = Range<u64>;
 
     fn write(&mut self, val: &Range<u64>) {
@@ -62,7 +49,7 @@ impl ValueWriter for RangeValueWriter {
         }
     }
 
-    fn serialize_block(&self, writer: &mut Vec<u8>) {
+    fn serialize_block(&mut self, writer: &mut Vec<u8>) {
         let mut prev_val = 0u64;
         crate::vint::serialize_into_vec(self.vals.len() as u64, writer);
         for &val in &self.vals {
@@ -70,9 +57,6 @@ impl ValueWriter for RangeValueWriter {
             crate::vint::serialize_into_vec(delta, writer);
             prev_val = val;
         }
-    }
-
-    fn clear(&mut self) {
         self.vals.clear();
     }
 }
@@ -83,19 +67,17 @@ mod tests {
 
     #[test]
     fn test_range_reader_writer() {
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[]);
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
-            0..3,
-        ]);
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[]);
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[0..3]);
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[
             0..3,
             3..10,
         ]);
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[
             0..0,
             0..10,
         ]);
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[
             100..110,
             110..121,
             121..1250,
@@ -105,7 +87,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_range_reader_writer_panics() {
-        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+        crate::value::tests::test_value_reader_writer::<_, RangeReader, RangeWriter>(&[
             1..3,
             4..10,
         ]);

sstable/src/value/u64_monotonic.rs

@@ -1,28 +1,27 @@
 use std::io;
 
-use crate::value::{deserialize_vint_u64, ValueReader, ValueWriter};
+use crate::value::{deserialize_u64, ValueReader, ValueWriter};
 use crate::vint;
 
 #[derive(Default)]
-pub struct U64MonotonicValueReader {
+pub struct U64MonotonicReader {
     vals: Vec<u64>,
 }
 
-impl ValueReader for U64MonotonicValueReader {
+impl ValueReader for U64MonotonicReader {
     type Value = u64;
 
-    #[inline(always)]
     fn value(&self, idx: usize) -> &Self::Value {
         &self.vals[idx]
     }
 
     fn load(&mut self, mut data: &[u8]) -> io::Result<usize> {
         let original_num_bytes = data.len();
-        let num_vals = deserialize_vint_u64(&mut data) as usize;
+        let num_vals = deserialize_u64(&mut data) as usize;
         self.vals.clear();
         let mut prev_val = 0u64;
         for _ in 0..num_vals {
-            let delta = deserialize_vint_u64(&mut data);
+            let delta = deserialize_u64(&mut data);
             let val = prev_val + delta;
             self.vals.push(val);
             prev_val = val;
@@ -32,18 +31,18 @@ impl ValueReader for U64MonotonicValueReader {
 }
 
 #[derive(Default)]
-pub struct U64MonotonicValueWriter {
+pub struct U64MonotonicWriter {
     vals: Vec<u64>,
 }
 
-impl ValueWriter for U64MonotonicValueWriter {
+impl ValueWriter for U64MonotonicWriter {
     type Value = u64;
 
     fn write(&mut self, val: &Self::Value) {
         self.vals.push(*val);
     }
 
-    fn serialize_block(&self, output: &mut Vec<u8>) {
+    fn serialize_block(&mut self, output: &mut Vec<u8>) {
         let mut prev_val = 0u64;
         vint::serialize_into_vec(self.vals.len() as u64, output);
         for &val in &self.vals {
@@ -51,9 +50,6 @@ impl ValueWriter for U64MonotonicValueWriter {
             vint::serialize_into_vec(delta, output);
             prev_val = val;
         }
-    }
-
-    fn clear(&mut self) {
         self.vals.clear();
     }
 }
@@ -64,20 +60,14 @@ mod tests {
 
     #[test]
     fn test_u64_monotonic_reader_writer() {
-        crate::value::tests::test_value_reader_writer::<
-            _,
-            U64MonotonicValueReader,
-            U64MonotonicValueWriter,
-        >(&[]);
-        crate::value::tests::test_value_reader_writer::<
-            _,
-            U64MonotonicValueReader,
-            U64MonotonicValueWriter,
-        >(&[5]);
-        crate::value::tests::test_value_reader_writer::<
-            _,
-            U64MonotonicValueReader,
-            U64MonotonicValueWriter,
-        >(&[1u64, 30u64]);
+        crate::value::tests::test_value_reader_writer::<_, U64MonotonicReader, U64MonotonicWriter>(
+            &[],
+        );
+        crate::value::tests::test_value_reader_writer::<_, U64MonotonicReader, U64MonotonicWriter>(
+            &[5],
+        );
+        crate::value::tests::test_value_reader_writer::<_, U64MonotonicReader, U64MonotonicWriter>(
+            &[1u64, 30u64],
+        );
     }
 }

sstable/src/value/void.rs

@@ -3,12 +3,11 @@ use std::io;
 use crate::value::{ValueReader, ValueWriter};
 
 #[derive(Default)]
-pub struct VoidValueReader;
+pub struct VoidReader;
 
-impl ValueReader for VoidValueReader {
+impl ValueReader for VoidReader {
     type Value = ();
 
-    #[inline(always)]
     fn value(&self, _idx: usize) -> &() {
         &()
     }
@@ -19,16 +18,14 @@ impl ValueReader for VoidValueReader {
 }
 
 #[derive(Default)]
-pub struct VoidValueWriter;
+pub struct VoidWriter;
 
-impl ValueWriter for VoidValueWriter {
+impl ValueWriter for VoidWriter {
     type Value = ();
 
     fn write(&mut self, _val: &()) {}
 
-    fn serialize_block(&self, _output: &mut Vec<u8>) {}
-
-    fn clear(&mut self) {}
+    fn serialize_block(&mut self, _output: &mut Vec<u8>) {}
 }
 
 #[cfg(test)]
@@ -37,12 +34,8 @@ mod tests {
 
     #[test]
     fn test_range_reader_writer() {
-        crate::value::tests::test_value_reader_writer::<_, VoidValueReader, VoidValueWriter>(&[]);
-        crate::value::tests::test_value_reader_writer::<_, VoidValueReader, VoidValueWriter>(&[()]);
-        crate::value::tests::test_value_reader_writer::<_, VoidValueReader, VoidValueWriter>(&[
-            (),
-            (),
-            (),
-        ]);
+        crate::value::tests::test_value_reader_writer::<_, VoidReader, VoidWriter>(&[]);
+        crate::value::tests::test_value_reader_writer::<_, VoidReader, VoidWriter>(&[()]);
+        crate::value::tests::test_value_reader_writer::<_, VoidReader, VoidWriter>(&[(), (), ()]);
     }
 }

stacker/Cargo.toml

@@ -2,7 +2,6 @@
 name = "tantivy-stacker"
 version = "0.1.0"
 edition = "2021"
-license = "MIT"
 
 [dependencies]
 murmurhash32 = "0.2"