Added simple columnar CLI program

See README for more information.

.gitignore

@@ -13,3 +13,5 @@ benchmark
 .idea
 trace.dat
 cargo-timing*
+columnar/columnar-cli/*.json
+**/perf.data*

Cargo.toml

@@ -36,7 +36,6 @@ 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"] }
@@ -60,9 +59,8 @@ sstable = { version="0.1", path="./sstable", package ="tantivy-sstable", optiona
 stacker = { version="0.1", path="./stacker", package ="tantivy-stacker" }
 tantivy-query-grammar = { version= "0.19.0", path="./query-grammar" }
 tantivy-bitpacker = 		{ version= "0.3", path="./bitpacker" }
-common = 								{ version= "0.4", path = "./common/", package = "tantivy-common" }
+common = 								{ version= "0.5", path = "./common/", package = "tantivy-common" }
 fastfield_codecs = 			{ version= "0.3", path="./fastfield_codecs", default-features = false }
-ownedbytes = 						{ version= "0.4", path="./ownedbytes" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"
@@ -108,7 +106,7 @@ unstable = [] # useful for benches.
 quickwit = ["sstable"]
 
 [workspace]
-members = ["query-grammar", "bitpacker", "common", "fastfield_codecs", "ownedbytes", "stacker", "sstable"]
+members = ["query-grammar", "bitpacker", "common", "fastfield_codecs", "ownedbytes", "stacker", "sstable", "columnar"]
 
 # Following the "fail" crate best practises, we isolate
 # tests that define specific behavior in fail check points

bitpacker/src/bitpacker.rs

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

bitpacker/src/lib.rs

@@ -1,6 +1,8 @@
 mod bitpacker;
 mod blocked_bitpacker;
 
+use std::cmp::Ordering;
+
 pub use crate::bitpacker::{BitPacker, BitUnpacker};
 pub use crate::blocked_bitpacker::BlockedBitpacker;
 
@@ -37,44 +39,104 @@ 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 + Ord,
+    T: Copy + PartialOrd,
 {
-    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))
-        }));
+    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;
+        }
     }
-    None
+    Some((min_so_far, max_so_far))
 }
 
-#[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);
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-#[test]
-fn test_minmax_empty() {
-    let vals: Vec<u32> = vec![];
-    assert_eq!(minmax(vals.into_iter()), None);
-}
+    #[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_one() {
-    assert_eq!(minmax(vec![1].into_iter()), Some((1, 1)));
-}
+    #[test]
+    fn test_minmax_empty() {
+        let vals: Vec<u32> = vec![];
+        assert_eq!(minmax(vals.into_iter()), None);
+    }
 
-#[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_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))
+        );
+    }
 }

columnar/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+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"
+sstable = { path = "../sstable", package = "tantivy-sstable" }
+zstd = "0.12"
+common = { path = "../common", package = "tantivy-common" }
+fastfield_codecs = { path = "../fastfield_codecs"}
+itertools = "0.10"
+
+[dev-dependencies]
+proptest = "1"

columnar/README.md

@@ -0,0 +1,73 @@
+# Columnar format
+
+This crate describes columnar format used in tantivy.
+
+## Goals
+
+This format is special in the following way.
+- it needs to be compact
+- it does not required to be loaded in memory.
+- it is designed to fit well with quickwit's strange constraint:
+we need to be able to load columns rapidly.
+- columns of several types can be associated with the same column name.
+- it needs to support columns with different types `(str, u64, i64, f64)`
+and different cardinality `(required, optional, multivalued)`.
+- columns, once loaded, offer cheap random access.
+
+# Coercion rules
+
+Users can create a columnar by appending rows to a writer.
+Nothing prevents a user from recording values with different to a same `column_key`.
+
+In that case, `tantivy-columnar`'s behavior is as follows:
+- Values that corresponds to different JsonValue type 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
+
+Because this columnar format tries to avoid some coercion.
+There can be several columns (with different type) associated to a single `column_name`.
+
+Each column is associated to `column_key`.
+The format of that key is:
+`[column_name][ZERO_BYTE][column_type_header: u8]`
+
+```
+COLUMNAR:=
+    [COLUMNAR_DATA]
+    [COLUMNAR_INDEX]
+    [COLUMNAR_FOOTER];
+
+
+# Columns are sorted by their column key.
+COLUMNAR_DATA:=
+    [COLUMN]+;
+
+COLUMN:=
+    COMPRESSED_COLUMN | NON_COMPRESSED_COLUMN;
+
+# COLUMN_DATA is compressed when it exceeds a threshold of 100KB.
+
+COMPRESSED_COLUMN := [b'1'][zstd(COLUMN_DATA)]
+NON_COMPRESSED_COLUMN:= [b'0'][COLUMN_DATA]
+
+COLUMNAR_INDEX := [RANGE_SSTABLE_BYTES]
+
+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 quickwit/tantivy style sstable associates
+`(column names, column_cardinality, column_type) to range of bytes.
+
+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
+`[column_name][ZERO_BYTE]`
+
+The associated range of bytes refer to a range of bytes
+

columnar/columnar-cli/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tantivy-columnar-cli"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+
+[dependencies]
+columnar = {path="../", package="tantivy-columnar"}
+serde_json = "1"
+serde_json_borrow = {git="https://github.com/PSeitz/serde_json_borrow/"}
+serde = "1"
+
+[workspace]
+members = []
+
+[profile.release]
+debug = true

columnar/columnar-cli/src/main.rs

@@ -0,0 +1,126 @@
+use columnar::ColumnarWriter;
+use columnar::NumericalValue;
+use serde_json_borrow;
+use std::fs::File;
+use std::io;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::time::Instant;
+
+#[derive(Default)]
+struct JsonStack {
+    path: String,
+    stack: Vec<usize>,
+}
+
+impl JsonStack {
+    fn push(&mut self, seg: &str) {
+        let len = self.path.len();
+        self.stack.push(len);
+        self.path.push('.');
+        self.path.push_str(seg);
+    }
+
+    fn pop(&mut self) {
+        if let Some(len) = self.stack.pop() {
+            self.path.truncate(len);
+        }
+    }
+
+    fn path(&self) -> &str {
+        &self.path[1..]
+    }
+}
+
+fn append_json_to_columnar(
+    doc: u32,
+    json_value: &serde_json_borrow::Value,
+    columnar: &mut ColumnarWriter,
+    stack: &mut JsonStack,
+) -> usize {
+    let mut count = 0;
+    match json_value {
+        serde_json_borrow::Value::Null => {}
+        serde_json_borrow::Value::Bool(val) => {
+            columnar.record_numerical(
+                doc,
+                stack.path(),
+                NumericalValue::from(if *val { 1u64 } else { 0u64 }),
+            );
+            count += 1;
+        }
+        serde_json_borrow::Value::Number(num) => {
+            let numerical_value: NumericalValue = if let Some(num_i64) = num.as_i64() {
+                num_i64.into()
+            } else if let Some(num_u64) = num.as_u64() {
+                num_u64.into()
+            } else if let Some(num_f64) = num.as_f64() {
+                num_f64.into()
+            } else {
+                panic!();
+            };
+            count += 1;
+            columnar.record_numerical(
+                doc,
+                stack.path(),
+                numerical_value,
+            );
+        }
+        serde_json_borrow::Value::Str(msg) => {
+            columnar.record_str(
+                doc,
+                stack.path(),
+                msg.as_bytes(),
+            );
+            count += 1;
+        },
+        serde_json_borrow::Value::Array(vals) => {
+            for val in vals {
+                count += append_json_to_columnar(doc, val, columnar, stack);
+            }
+        },
+        serde_json_borrow::Value::Object(json_map) => {
+            for (child_key, child_val) in json_map {
+                stack.push(child_key);
+                count += append_json_to_columnar(doc, child_val, columnar, stack);
+                stack.pop();
+            }
+        },
+    }
+    count
+}
+
+fn main() -> io::Result<()> {
+    let file = File::open("gh_small.json")?;
+    let mut reader = BufReader::new(file);
+    let mut line = String::with_capacity(100);
+    let mut columnar = columnar::ColumnarWriter::default();
+    let mut doc = 0;
+    let start = Instant::now();
+    let mut stack = JsonStack::default();
+    let mut total_count = 0;
+    loop {
+        line.clear();
+        let len = reader.read_line(&mut line)?;
+        if len == 0 {
+            break;
+        }
+        let Ok(json_value) = serde_json::from_str::<serde_json_borrow::Value>(&line) else { continue; };
+        total_count += append_json_to_columnar(doc, &json_value, &mut columnar, &mut stack);
+        doc += 1;
+    }
+    println!("value count {total_count}");
+    println!("record {:?}", start.elapsed());
+    let mut buffer = Vec::new();
+    columnar.serialize(doc, &mut buffer)?;
+    println!("num docs: {doc}, {:?}", start.elapsed());
+    println!("buffer len {} MB", buffer.len() / 1_000_000);
+    let columnar = columnar::ColumnarReader::open(buffer)?;
+    for (column_name, typ, offsets, num_bytes) in columnar.list_columns()? {
+        if num_bytes>1_000_000 {
+            println!("{column_name} {typ:?} {offsets:?} {}", num_bytes / 1_000_000);
+        }
+    }
+    println!("{} columns", columnar.num_columns());
+    Ok(())
+}

columnar/src/column_type_header.rs

@@ -0,0 +1,188 @@
+use crate::utils::{place_bits, select_bits};
+use crate::value::NumericalType;
+
+/// Enum describing the number of values that can exist per document
+/// (or per row if you will).
+#[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) -> Option<Cardinality> {
+        match code {
+            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),
+    Bool,
+}
+
+impl ColumnType {
+    /// Encoded over 6 bits.
+    pub(crate) fn to_code(self) -> u8 {
+        let high_type;
+        let low_code: u8;
+        match self {
+            ColumnType::Bytes => {
+                high_type = GeneralType::Str;
+                low_code = 0u8;
+            }
+            ColumnType::Numerical(numerical_type) => {
+                high_type = GeneralType::Numerical;
+                low_code = numerical_type.to_code();
+            }
+            ColumnType::Bool => {
+                high_type = GeneralType::Bool;
+                low_code = 0u8;
+            }
+        }
+        place_bits::<3, 6>(high_type.to_code()) | place_bits::<0, 3>(low_code)
+    }
+
+    pub(crate) fn try_from_code(code: u8) -> Option<ColumnType> {
+        if select_bits::<6, 8>(code) != 0u8 {
+            return None;
+        }
+        let high_code = select_bits::<3, 6>(code);
+        let low_code = select_bits::<0, 3>(code);
+        let high_type = GeneralType::try_from_code(high_code)?;
+        match high_type {
+            GeneralType::Bool => {
+                if low_code != 0u8 {
+                    return None;
+                }
+                Some(ColumnType::Bool)
+            }
+            GeneralType::Str => {
+                if low_code != 0u8 {
+                    return None;
+                }
+                Some(ColumnType::Bytes)
+            }
+            GeneralType::Numerical => {
+                let numerical_type = NumericalType::try_from_code(low_code)?;
+                Some(ColumnType::Numerical(numerical_type))
+            }
+        }
+    }
+}
+
+/// This corresponds to the JsonType.
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+#[repr(u8)]
+pub(crate) enum GeneralType {
+    Bool = 0u8,
+    Str = 1u8,
+    Numerical = 2u8,
+}
+
+impl GeneralType {
+    pub fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub fn try_from_code(code: u8) -> Option<Self> {
+        match code {
+            0u8 => Some(Self::Bool),
+            1u8 => Some(Self::Str),
+            2u8 => Some(Self::Numerical),
+            _ => None,
+        }
+    }
+}
+
+/// Represents the type and cardinality of a column.
+/// This is encoded over one-byte and added to a column key in the
+/// columnar sstable.
+///
+/// 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 cardinality: Cardinality,
+    pub typ: ColumnType,
+}
+
+impl ColumnTypeAndCardinality {
+    pub fn to_code(self) -> u8 {
+        place_bits::<6, 8>(self.cardinality.to_code()) | place_bits::<0, 6>(self.typ.to_code())
+    }
+
+    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);
+        Some(ColumnTypeAndCardinality { cardinality, typ })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::ColumnTypeAndCardinality;
+    use crate::column_type_header::{Cardinality, ColumnType};
+
+    #[test]
+    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 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)
+        );
+    }
+
+    #[test]
+    fn test_column_type_to_code() {
+        let mut column_type_set: HashSet<ColumnType> = HashSet::new();
+        for code in u8::MIN..=u8::MAX {
+            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);
+    }
+
+    #[test]
+    fn test_cardinality_to_code() {
+        let mut num_cardinality = 0;
+        for code in u8::MIN..=u8::MAX {
+            let cardinality_opt = Cardinality::try_from_code(code);
+            if let Some(cardinality) = cardinality_opt {
+                assert_eq!(cardinality.to_code(), code);
+                num_cardinality += 1;
+            }
+        }
+        assert_eq!(num_cardinality, 3);
+    }
+}

columnar/src/dictionary.rs

@@ -0,0 +1,84 @@
+use std::io;
+
+use fnv::FnvHashMap;
+use sstable::SSTable;
+
+pub(crate) 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]
+    }
+}
+
+/// 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
+/// we call unordered id.
+///
+/// Upon serialization, we will sort the ids and hence build a `UnorderedId -> Term ordinal`
+/// mapping.
+#[derive(Default)]
+pub(crate) struct DictionaryBuilder {
+    dict: FnvHashMap<Vec<u8>, UnorderedId>,
+}
+
+impl DictionaryBuilder {
+    /// Get or allocate an unordered id.
+    /// (This ID is simply an auto-incremented id.)
+    pub fn get_or_allocate_id(&mut self, term: &[u8]) -> UnorderedId {
+        if let Some(term_id) = self.dict.get(term) {
+            return *term_id;
+        }
+        let new_id = UnorderedId(self.dict.len() as u32);
+        self.dict.insert(term.to_vec(), new_id);
+        new_id
+    }
+
+    /// 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<IdMapping> {
+        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(IdMapping { unordered_to_ord })
+    }
+}
+
+#[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));
+    }
+}

columnar/src/lib.rs

@@ -0,0 +1,86 @@
+mod column_type_header;
+mod dictionary;
+mod reader;
+pub(crate) mod utils;
+mod value;
+mod writer;
+
+pub use column_type_header::Cardinality;
+pub use reader::ColumnarReader;
+pub use value::{NumericalType, NumericalValue};
+pub use writer::ColumnarWriter;
+
+pub type DocId = u32;
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use common::file_slice::FileSlice;
+
+    use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality};
+    use crate::reader::ColumnarReader;
+    use crate::value::NumericalValue;
+    use crate::{Cardinality, ColumnarWriter};
+
+    #[test]
+    fn test_dataframe_writer_bytes() {
+        let mut dataframe_writer = ColumnarWriter::default();
+        dataframe_writer.record_str(1u32, "my_string", b"hello");
+        dataframe_writer.record_str(3u32, "my_string", b"helloeee");
+        let mut buffer: Vec<u8> = Vec::new();
+        dataframe_writer.serialize(5, &mut buffer).unwrap();
+        let columnar_fileslice = FileSlice::from(buffer);
+        let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
+        assert_eq!(columnar.num_columns(), 1);
+        let cols: Vec<(ColumnTypeAndCardinality, Range<u64>)> =
+            columnar.read_columns("my_string").unwrap();
+        assert_eq!(cols.len(), 1);
+        assert_eq!(cols[0].1, 0..159);
+    }
+
+    #[test]
+    fn test_dataframe_writer_bool() {
+        let mut dataframe_writer = ColumnarWriter::default();
+        dataframe_writer.record_bool(1u32, "bool.value", false);
+        let mut buffer: Vec<u8> = Vec::new();
+        dataframe_writer.serialize(5, &mut buffer).unwrap();
+        let columnar_fileslice = FileSlice::from(buffer);
+        let columnar = ColumnarReader::open(columnar_fileslice).unwrap();
+        assert_eq!(columnar.num_columns(), 1);
+        let cols: Vec<(ColumnTypeAndCardinality, Range<u64>)> =
+            columnar.read_columns("bool.value").unwrap();
+        assert_eq!(cols.len(), 1);
+        assert_eq!(
+            cols[0].0,
+            ColumnTypeAndCardinality {
+                cardinality: Cardinality::Optional,
+                typ: ColumnType::Bool
+            }
+        );
+        assert_eq!(cols[0].1, 0..22);
+    }
+
+    #[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<(ColumnTypeAndCardinality, Range<u64>)> =
+            columnar.read_columns("srical.value").unwrap();
+        assert_eq!(cols.len(), 1);
+        // Right now this 31 bytes are spent as follows
+        //
+        // - header 14 bytes
+        // - 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].1, 0..32);
+    }
+}

columnar/src/reader/mod.rs

@@ -0,0 +1,102 @@
+use std::ops::Range;
+use std::{io, mem};
+
+use common::file_slice::FileSlice;
+use common::BinarySerializable;
+use sstable::{Dictionary, RangeSSTable};
+
+use crate::column_type_header::ColumnTypeAndCardinality;
+
+fn io_invalid_data(msg: String) -> io::Error {
+    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_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())
+    }
+
+    fn open_inner(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()?;
+        let sstable_len = u64::deserialize(&mut sstable_len_bytes)?;
+        let (column_data, sstable) =
+            file_slice_without_sstable_len.split_from_end(sstable_len as usize);
+        let column_dictionary = Dictionary::open(sstable)?;
+        Ok(ColumnarReader {
+            column_dictionary,
+            column_data,
+        })
+    }
+
+    // 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)
+                .ok_or_else(|| 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 field_name.
+    // TODO fix ugly API
+    pub fn read_columns(
+        &self,
+        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 = field_name.to_string();
+        end_key.push(1u8 as char);
+        let mut stream = self
+            .column_dictionary
+            .range()
+            .ge(start_key.as_bytes())
+            .lt(end_key.as_bytes())
+            .into_stream()?;
+        let mut results = Vec::new();
+        while stream.advance() {
+            let key_bytes: &[u8] = stream.key();
+            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)
+                .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/utils.rs

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,121 @@
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum NumericalValue {
+    I64(i64),
+    U64(u64),
+    F64(f64),
+}
+
+impl From<u64> for NumericalValue {
+    fn from(val: u64) -> NumericalValue {
+        NumericalValue::U64(val)
+    }
+}
+
+impl From<i64> for NumericalValue {
+    fn from(val: i64) -> Self {
+        NumericalValue::I64(val)
+    }
+}
+
+impl From<f64> for NumericalValue {
+    fn from(val: f64) -> Self {
+        NumericalValue::F64(val)
+    }
+}
+
+impl NumericalValue {
+    pub fn numerical_type(&self) -> NumericalType {
+        match self {
+            NumericalValue::F64(_) => NumericalType::F64,
+            NumericalValue::I64(_) => NumericalType::I64,
+            NumericalValue::U64(_) => NumericalType::U64,
+        }
+    }
+}
+
+impl Eq for NumericalValue {}
+
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq)]
+#[repr(u8)]
+pub enum NumericalType {
+    #[default]
+    I64 = 0,
+    U64 = 1,
+    F64 = 2,
+}
+
+impl NumericalType {
+    pub fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub fn try_from_code(code: u8) -> Option<NumericalType> {
+        match code {
+            0 => Some(NumericalType::I64),
+            1 => Some(NumericalType::U64),
+            2 => Some(NumericalType::F64),
+            _ => None,
+        }
+    }
+}
+
+/// We voluntarily avoid using `Into` here to keep this
+/// implementation quirk as private as possible.
+///
+/// This coercion trait actually panics if it is used
+/// to convert a loose types to a stricter type.
+///
+/// The level is strictness is somewhat arbitrary.
+/// - i64
+/// - u64
+/// - f64.
+pub(crate) trait Coerce {
+    fn coerce(numerical_value: NumericalValue) -> Self;
+}
+
+impl Coerce for i64 {
+    fn coerce(value: NumericalValue) -> Self {
+        match value {
+            NumericalValue::I64(val) => val,
+            NumericalValue::U64(val) => val as i64,
+            NumericalValue::F64(_) => unreachable!(),
+        }
+    }
+}
+
+impl Coerce for u64 {
+    fn coerce(value: NumericalValue) -> Self {
+        match value {
+            NumericalValue::I64(val) => val as u64,
+            NumericalValue::U64(val) => val,
+            NumericalValue::F64(_) => unreachable!(),
+        }
+    }
+}
+
+impl Coerce for f64 {
+    fn coerce(value: NumericalValue) -> Self {
+        match value {
+            NumericalValue::I64(val) => val as f64,
+            NumericalValue::U64(val) => val as f64,
+            NumericalValue::F64(val) => val,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::NumericalType;
+
+    #[test]
+    fn test_numerical_type_code() {
+        let mut num_numerical_type = 0;
+        for code in u8::MIN..=u8::MAX {
+            if let Some(numerical_type) = NumericalType::try_from_code(code) {
+                assert_eq!(numerical_type.to_code(), code);
+                num_numerical_type += 1;
+            }
+        }
+        assert_eq!(num_numerical_type, 3);
+    }
+}

columnar/src/writer/column_operation.rs

@@ -0,0 +1,311 @@
+use crate::dictionary::UnorderedId;
+use crate::utils::{place_bits, pop_first_byte, select_bits};
+use crate::value::NumericalValue;
+use crate::{DocId, NumericalType};
+
+/// When we build a columnar dataframe, we first just group
+/// all mutations per column, and append them in append-only object.
+///
+/// We represents all of these operations as `ColumnOperation`.
+#[derive(Eq, PartialEq, Debug, Clone, Copy)]
+pub(crate) enum ColumnOperation<T> {
+    NewDoc(DocId),
+    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)
+    }
+}
+
+#[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;
+}
+
+impl SymbolValue for bool {
+    fn serialize(self, buffer: &mut [u8]) -> u8 {
+        buffer[0] = if self { 1u8 } else { 0u8 };
+        1u8
+    }
+
+    fn deserialize(bytes: &[u8]) -> Self {
+        bytes[0] == 1u8
+    }
+}
+
+#[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]
+    }
+}
+
+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 => {
+                let val: u64 = u64::from_le_bytes(octet);
+                NumericalValue::U64(val)
+            }
+            NumericalType::I64 => {
+                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)
+            }
+        }
+    }
+
+    fn serialize(self, output: &mut [u8]) -> u8 {
+        match self {
+            NumericalValue::F64(val) => {
+                output[0] = NumericalType::F64 as u8;
+                output[1..9].copy_from_slice(&val.to_le_bytes());
+                9u8
+            }
+            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
+            }
+            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
+            }
+        }
+    }
+}
+
+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)
+    }
+}
+
+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 compute_num_bytes_for_u64(val: u64) -> usize {
+    let msb = (64u32 - val.leading_zeros()) as usize;
+    (msb + 7) / 8
+}
+
+fn encode_zig_zag(n: i64) -> u64 {
+    ((n << 1) ^ (n >> 63)) as u64
+}
+
+fn decode_zig_zag(n: u64) -> i64 {
+    ((n >> 1) as i64) ^ (-((n & 1) as i64))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[track_caller]
+    fn test_zig_zag_aux(val: i64) {
+        let encoded = super::encode_zig_zag(val);
+        assert_eq!(decode_zig_zag(encoded), val);
+        if let Some(abs_val) = val.checked_abs() {
+            let abs_val = abs_val as u64;
+            assert!(encoded <= abs_val * 2);
+        }
+    }
+
+    #[test]
+    fn test_zig_zag() {
+        assert_eq!(encode_zig_zag(0i64), 0u64);
+        assert_eq!(encode_zig_zag(-1i64), 1u64);
+        assert_eq!(encode_zig_zag(1i64), 2u64);
+        test_zig_zag_aux(0i64);
+        test_zig_zag_aux(i64::MIN);
+        test_zig_zag_aux(i64::MAX);
+    }
+
+    use proptest::prelude::any;
+    use proptest::proptest;
+
+    proptest! {
+        #[test]
+        fn test_proptest_zig_zag(val in any::<i64>()) {
+            test_zig_zag_aux(val);
+        }
+    }
+
+    #[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);
+            }
+        }
+    }
+
+    #[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[..];
+        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);
+    }
+
+    #[test]
+    fn test_compute_num_bytes_for_u64() {
+        assert_eq!(compute_num_bytes_for_u64(0), 0);
+        assert_eq!(compute_num_bytes_for_u64(1), 1);
+        assert_eq!(compute_num_bytes_for_u64(255), 1);
+        assert_eq!(compute_num_bytes_for_u64(256), 2);
+        assert_eq!(compute_num_bytes_for_u64((1 << 16) - 1), 2);
+        assert_eq!(compute_num_bytes_for_u64(1 << 16), 3);
+    }
+
+    #[test]
+    fn test_symbol_serialization() {
+        ser_deser_symbol(ColumnOperation::NewDoc(0));
+        ser_deser_symbol(ColumnOperation::NewDoc(3));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::I64(0i64)));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::I64(1i64)));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::U64(257u64)));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::I64(-257i64)));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::I64(i64::MIN)));
+        ser_deser_symbol(ColumnOperation::Value(NumericalValue::U64(0u64)));
+        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

@@ -0,0 +1,270 @@
+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 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)]
+pub(crate) 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 struct StrColumnWriter {
+    pub(crate) dictionary_id: u32,
+    pub(crate) column_writer: ColumnWriter,
+}
+
+impl StrColumnWriter {
+    pub 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

@@ -0,0 +1,526 @@
+mod column_operation;
+mod column_writers;
+mod serializer;
+mod value_index;
+
+use std::io::{self, Write};
+
+use column_operation::ColumnOperation;
+use fastfield_codecs::serialize::ValueIndexInfo;
+use fastfield_codecs::{Column, MonotonicallyMappableToU64, VecColumn};
+use serializer::ColumnarSerializer;
+use stacker::{Addr, ArenaHashMap, MemoryArena};
+
+use crate::column_type_header::{ColumnType, ColumnTypeAndCardinality, GeneralType};
+use crate::dictionary::{DictionaryBuilder, IdMapping, UnorderedId};
+use crate::value::{Coerce, NumericalType, NumericalValue};
+use crate::writer::column_writers::{ColumnWriter, NumericalColumnWriter, StrColumnWriter};
+use crate::writer::value_index::{IndexBuilder, SpareIndexBuilders};
+use crate::{Cardinality, DocId};
+
+/// Threshold above which a column data will be compressed
+/// using ZSTD.
+const COLUMN_COMPRESSION_THRESHOLD: usize = 100_000;
+
+/// 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>,
+}
+
+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.
+    dictionaries: Vec<DictionaryBuilder>,
+    buffers: SpareBuffers,
+}
+
+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(),
+            buffers: SpareBuffers::default(),
+        }
+    }
+}
+
+impl ColumnarWriter {
+    pub fn record_numerical(
+        &mut self,
+        doc: DocId,
+        column_name: &str,
+        numerical_value: NumericalValue,
+    ) {
+        assert!(
+            !column_name.as_bytes().contains(&0u8),
+            "key may not contain the 0 byte"
+        );
+        let (hash_map, arena) = (&mut self.numerical_field_hash_map, &mut self.arena);
+        hash_map.mutate_or_create(
+            column_name.as_bytes(),
+            |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: &[u8]) {
+        assert!(
+            !column_name.as_bytes().contains(&0u8),
+            "key may not contain the 0 byte"
+        );
+        let (hash_map, arena, dictionaries) = (
+            &mut self.bytes_field_hash_map,
+            &mut self.arena,
+            &mut self.dictionaries,
+        );
+        hash_map.mutate_or_create(
+            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, 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], GeneralType, Addr)> = self
+            .numerical_field_hash_map
+            .iter()
+            .map(|(term, addr, _)| (term, GeneralType::Numerical, addr))
+            .collect();
+        field_columns.extend(
+            self.bytes_field_hash_map
+                .iter()
+                .map(|(term, addr, _)| (term, GeneralType::Str, addr)),
+        );
+        field_columns.extend(
+            self.bool_field_hash_map
+                .iter()
+                .map(|(term, addr, _)| (term, GeneralType::Bool, addr)),
+        );
+        field_columns.sort_unstable_by_key(|(column_name, col_type, _)| (*column_name, *col_type));
+        let (arena, buffers, dictionaries) = (&self.arena, &mut self.buffers, &self.dictionaries);
+        let mut symbol_byte_buffer: Vec<u8> = Vec::new();
+        for (column_name, bytes_or_numerical, addr) in field_columns {
+            match bytes_or_numerical {
+                GeneralType::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,
+                    )?;
+                }
+                GeneralType::Str => {
+                    let str_column_writer: StrColumnWriter = 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);
+                    serialize_bytes_column(
+                        cardinality,
+                        num_docs,
+                        dictionary_builder,
+                        str_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        buffers,
+                        column_serializer,
+                    )?;
+                }
+                GeneralType::Numerical => {
+                    let numerical_column_writer: NumericalColumnWriter =
+                        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);
+                    serialize_numerical_column(
+                        cardinality,
+                        num_docs,
+                        numerical_type,
+                        numerical_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
+                        buffers,
+                        column_serializer,
+                    )?;
+                }
+            };
+        }
+        serializer.finalize()?;
+        Ok(())
+    }
+}
+
+fn compress_and_write_column<W: io::Write>(column_bytes: &[u8], wrt: &mut W) -> io::Result<()> {
+    if column_bytes.len() >= COLUMN_COMPRESSION_THRESHOLD {
+        wrt.write_all(&[1])?;
+        let mut encoder = zstd::Encoder::new(wrt, 3)?;
+        encoder.write_all(column_bytes)?;
+        encoder.finish()?;
+    } else {
+        wrt.write_all(&[0])?;
+        wrt.write_all(column_bytes)?;
+    }
+    Ok(())
+}
+
+fn serialize_bytes_column<W: io::Write>(
+    cardinality: Cardinality,
+    num_docs: DocId,
+    dictionary_builder: &DictionaryBuilder,
+    operation_it: impl Iterator<Item = ColumnOperation<UnorderedId>>,
+    buffers: &mut SpareBuffers,
+    mut wrt: W,
+) -> io::Result<()> {
+    let SpareBuffers {
+        value_index_builders,
+        u64_values,
+        column_buffer,
+        ..
+    } = buffers;
+    column_buffer.clear();
+    let id_mapping: IdMapping = 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 = id_mapping.to_ord(unordered_id);
+                ColumnOperation::Value(ordered_id.0 as u64)
+            }
+            ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
+        }
+    });
+    serialize_column(
+        operation_iterator,
+        cardinality,
+        num_docs,
+        value_index_builders,
+        u64_values,
+        column_buffer,
+    )?;
+    column_buffer.write_all(&dictionary_num_bytes.to_le_bytes()[..])?;
+    compress_and_write_column(column_buffer, &mut wrt)?;
+    Ok(())
+}
+
+fn serialize_numerical_column<W: io::Write>(
+    cardinality: Cardinality,
+    num_docs: DocId,
+    numerical_type: NumericalType,
+    op_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
+    buffers: &mut SpareBuffers,
+    mut wrt: W,
+) -> io::Result<()> {
+    let SpareBuffers {
+        value_index_builders,
+        u64_values,
+        i64_values,
+        f64_values,
+        column_buffer,
+        ..
+    } = buffers;
+    column_buffer.clear();
+    match numerical_type {
+        NumericalType::I64 => {
+            serialize_column(
+                coerce_numerical_symbol::<i64>(op_iterator),
+                cardinality,
+                num_docs,
+                value_index_builders,
+                i64_values,
+                column_buffer,
+            )?;
+        }
+        NumericalType::U64 => {
+            serialize_column(
+                coerce_numerical_symbol::<u64>(op_iterator),
+                cardinality,
+                num_docs,
+                value_index_builders,
+                u64_values,
+                column_buffer,
+            )?;
+        }
+        NumericalType::F64 => {
+            serialize_column(
+                coerce_numerical_symbol::<f64>(op_iterator),
+                cardinality,
+                num_docs,
+                value_index_builders,
+                f64_values,
+                column_buffer,
+            )?;
+        }
+    };
+    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,
+>(
+    op_iterator: impl Iterator<Item = ColumnOperation<T>>,
+    cardinality: Cardinality,
+    num_docs: DocId,
+    value_index_builders: &mut SpareIndexBuilders,
+    values: &mut Vec<T>,
+    wrt: &mut Vec<u8>,
+) -> io::Result<()>
+where
+    for<'a> VecColumn<'a, T>: Column<T>,
+{
+    values.clear();
+    match cardinality {
+        Cardinality::Required => {
+            consume_operation_iterator(
+                op_iterator,
+                value_index_builders.borrow_required_index_builder(),
+                values,
+            );
+            fastfield_codecs::serialize(
+                VecColumn::from(&values[..]),
+                wrt,
+                &fastfield_codecs::ALL_CODEC_TYPES[..],
+            )?;
+        }
+        Cardinality::Optional => {
+            let optional_index_builder = value_index_builders.borrow_optional_index_builder();
+            consume_operation_iterator(op_iterator, optional_index_builder, values);
+            let optional_index = optional_index_builder.finish(num_docs);
+            fastfield_codecs::serialize::serialize_new(
+                ValueIndexInfo::SingleValue(Box::new(optional_index)),
+                VecColumn::from(&values[..]),
+                wrt,
+                &fastfield_codecs::ALL_CODEC_TYPES[..],
+            )?;
+        }
+        Cardinality::Multivalued => {
+            let multivalued_index_builder = value_index_builders.borrow_multivalued_index_builder();
+            consume_operation_iterator(op_iterator, multivalued_index_builder, values);
+            let multivalued_index = multivalued_index_builder.finish(num_docs);
+            fastfield_codecs::serialize::serialize_new(
+                ValueIndexInfo::MultiValue(Box::new(multivalued_index)),
+                VecColumn::from(&values[..]),
+                wrt,
+                &fastfield_codecs::ALL_CODEC_TYPES[..],
+            )?;
+        }
+    }
+    Ok(())
+}
+
+fn coerce_numerical_symbol<T>(
+    operation_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
+) -> impl Iterator<Item = ColumnOperation<T>>
+where T: Coerce {
+    operation_iterator.map(|symbol| match symbol {
+        ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
+        ColumnOperation::Value(numerical_value) => {
+            ColumnOperation::Value(Coerce::coerce(numerical_value))
+        }
+    })
+}
+
+fn consume_operation_iterator<T: std::fmt::Debug, TIndexBuilder: IndexBuilder>(
+    operation_iterator: impl Iterator<Item = ColumnOperation<T>>,
+    index_builder: &mut TIndexBuilder,
+    values: &mut Vec<T>,
+) {
+    for symbol in operation_iterator {
+        match symbol {
+            ColumnOperation::NewDoc(doc) => {
+                index_builder.record_doc(doc);
+            }
+            ColumnOperation::Value(value) => {
+                index_builder.record_value();
+                values.push(value);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use column_operation::ColumnOperation;
+    use stacker::MemoryArena;
+
+    use super::*;
+    use crate::value::NumericalValue;
+    use crate::Cardinality;
+
+    #[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);
+        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)
+            .collect();
+        assert_eq!(symbols.len(), 6);
+        assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
+        assert!(matches!(
+            symbols[1],
+            ColumnOperation::Value(NumericalValue::I64(14i64))
+        ));
+        assert!(matches!(symbols[2], ColumnOperation::NewDoc(1u32)));
+        assert!(matches!(
+            symbols[3],
+            ColumnOperation::Value(NumericalValue::I64(15i64))
+        ));
+        assert!(matches!(symbols[4], ColumnOperation::NewDoc(2u32)));
+        assert!(matches!(
+            symbols[5],
+            ColumnOperation::Value(NumericalValue::I64(-16i64))
+        ));
+    }
+
+    #[test]
+    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);
+        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)
+            .collect();
+        assert_eq!(symbols.len(), 4);
+        assert!(matches!(symbols[0], ColumnOperation::NewDoc(1u32)));
+        assert!(matches!(
+            symbols[1],
+            ColumnOperation::Value(NumericalValue::I64(15i64))
+        ));
+        assert!(matches!(symbols[2], ColumnOperation::NewDoc(2u32)));
+        assert!(matches!(
+            symbols[3],
+            ColumnOperation::Value(NumericalValue::I64(-16i64))
+        ));
+    }
+
+    #[test]
+    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);
+        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)
+            .collect();
+        assert_eq!(symbols.len(), 2);
+        assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
+        assert!(matches!(
+            symbols[1],
+            ColumnOperation::Value(NumericalValue::I64(15i64))
+        ));
+    }
+
+    #[test]
+    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);
+        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)
+            .collect();
+        assert_eq!(symbols.len(), 3);
+        assert!(matches!(symbols[0], ColumnOperation::NewDoc(0u32)));
+        assert!(matches!(
+            symbols[1],
+            ColumnOperation::Value(NumericalValue::I64(16i64))
+        ));
+        assert!(matches!(
+            symbols[2],
+            ColumnOperation::Value(NumericalValue::I64(17i64))
+        ));
+    }
+}

columnar/src/writer/serializer.rs

@@ -0,0 +1,116 @@
+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());
+    }
+}

columnar/src/writer/value_index.rs

@@ -0,0 +1,218 @@
+use fastfield_codecs::serialize::{MultiValueIndexInfo, SingleValueIndexInfo};
+
+use crate::DocId;
+
+/// The `IndexBuilder` interprets a sequence of
+/// calls of the form:
+/// (record_doc,record_value+)*
+/// and can then serialize the results into an index.
+///
+/// It has different implementation depending on whether the
+/// cardinality is required, optional, or multivalued.
+pub(crate) trait IndexBuilder {
+    fn record_doc(&mut self, doc: DocId);
+    #[inline]
+    fn record_value(&mut self) {}
+}
+
+/// The RequiredIndexBuilder does nothing.
+#[derive(Default)]
+pub struct RequiredIndexBuilder;
+
+impl IndexBuilder for RequiredIndexBuilder {
+    #[inline(always)]
+    fn record_doc(&mut self, _doc: DocId) {}
+}
+
+#[derive(Default)]
+pub struct OptionalIndexBuilder {
+    docs: Vec<DocId>,
+}
+
+struct SingleValueArrayIndex<'a> {
+    docs: &'a [DocId],
+    num_docs: DocId,
+}
+
+impl<'a> SingleValueIndexInfo for SingleValueArrayIndex<'a> {
+    fn num_vals(&self) -> u32 {
+        self.num_docs as u32
+    }
+
+    fn num_non_nulls(&self) -> u32 {
+        self.docs.len() as u32
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_> {
+        Box::new(self.docs.iter().copied())
+    }
+}
+
+impl OptionalIndexBuilder {
+    pub fn finish(&mut self, num_docs: DocId) -> impl SingleValueIndexInfo + '_ {
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|last_doc| last_doc < num_docs)
+            .unwrap_or(true));
+        SingleValueArrayIndex {
+            docs: &self.docs[..],
+            num_docs,
+        }
+    }
+
+    fn reset(&mut self) {
+        self.docs.clear();
+    }
+}
+
+impl IndexBuilder for OptionalIndexBuilder {
+    #[inline(always)]
+    fn record_doc(&mut self, doc: DocId) {
+        debug_assert!(self
+            .docs
+            .last()
+            .copied()
+            .map(|prev_doc| doc > prev_doc)
+            .unwrap_or(true));
+        self.docs.push(doc);
+    }
+}
+
+#[derive(Default)]
+pub struct MultivaluedIndexBuilder {
+    // TODO should we switch to `start_offset`?
+    end_values: Vec<DocId>,
+    total_num_vals_seen: u32,
+}
+
+pub struct MultivaluedValueArrayIndex<'a> {
+    end_offsets: &'a [DocId],
+}
+
+impl<'a> MultiValueIndexInfo for MultivaluedValueArrayIndex<'a> {
+    fn num_docs(&self) -> u32 {
+        self.end_offsets.len() as u32
+    }
+
+    fn num_vals(&self) -> u32 {
+        self.end_offsets.last().copied().unwrap_or(0u32)
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_> {
+        if self.end_offsets.is_empty() {
+            return Box::new(std::iter::empty());
+        }
+        let n = self.end_offsets.len();
+        Box::new(std::iter::once(0u32).chain(self.end_offsets[..n - 1].iter().copied()))
+    }
+}
+
+impl MultivaluedIndexBuilder {
+    pub fn finish(&mut self, num_docs: DocId) -> impl MultiValueIndexInfo + '_ {
+        self.end_values
+            .resize(num_docs as usize, self.total_num_vals_seen);
+        MultivaluedValueArrayIndex {
+            end_offsets: &self.end_values[..],
+        }
+    }
+
+    fn reset(&mut self) {
+        self.end_values.clear();
+        self.total_num_vals_seen = 0;
+    }
+}
+
+impl IndexBuilder for MultivaluedIndexBuilder {
+    fn record_doc(&mut self, doc: DocId) {
+        self.end_values
+            .resize(doc as usize, self.total_num_vals_seen);
+    }
+
+    fn record_value(&mut self) {
+        self.total_num_vals_seen += 1;
+    }
+}
+
+/// The `SpareIndexBuilders` is there to avoid allocating a
+/// new index builder for every single column.
+#[derive(Default)]
+pub struct SpareIndexBuilders {
+    required_index_builder: RequiredIndexBuilder,
+    optional_index_builder: OptionalIndexBuilder,
+    multivalued_index_builder: MultivaluedIndexBuilder,
+}
+
+impl SpareIndexBuilders {
+    pub fn borrow_required_index_builder(&mut self) -> &mut RequiredIndexBuilder {
+        &mut self.required_index_builder
+    }
+
+    pub fn borrow_optional_index_builder(&mut self) -> &mut OptionalIndexBuilder {
+        self.optional_index_builder.reset();
+        &mut self.optional_index_builder
+    }
+
+    pub fn borrow_multivalued_index_builder(&mut self) -> &mut MultivaluedIndexBuilder {
+        self.multivalued_index_builder.reset();
+        &mut self.multivalued_index_builder
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_optional_value_index_builder() {
+        let mut opt_value_index_builder = OptionalIndexBuilder::default();
+        opt_value_index_builder.record_doc(0u32);
+        opt_value_index_builder.record_value();
+        assert_eq!(
+            &opt_value_index_builder
+                .finish(1u32)
+                .iter()
+                .collect::<Vec<u32>>(),
+            &[0]
+        );
+        opt_value_index_builder.reset();
+        opt_value_index_builder.record_doc(1u32);
+        opt_value_index_builder.record_value();
+        assert_eq!(
+            &opt_value_index_builder
+                .finish(2u32)
+                .iter()
+                .collect::<Vec<u32>>(),
+            &[1]
+        );
+    }
+
+    #[test]
+    fn test_multivalued_value_index_builder() {
+        let mut multivalued_value_index_builder = MultivaluedIndexBuilder::default();
+        multivalued_value_index_builder.record_doc(1u32);
+        multivalued_value_index_builder.record_value();
+        multivalued_value_index_builder.record_value();
+        multivalued_value_index_builder.record_doc(2u32);
+        multivalued_value_index_builder.record_value();
+        assert_eq!(
+            multivalued_value_index_builder
+                .finish(4u32)
+                .iter()
+                .collect::<Vec<u32>>(),
+            vec![0, 0, 2, 3]
+        );
+        multivalued_value_index_builder.reset();
+        multivalued_value_index_builder.record_doc(2u32);
+        multivalued_value_index_builder.record_value();
+        multivalued_value_index_builder.record_value();
+        assert_eq!(
+            multivalued_value_index_builder
+                .finish(4u32)
+                .iter()
+                .collect::<Vec<u32>>(),
+            vec![0, 0, 0, 2]
+        );
+    }
+}

common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy-common"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Paul Masurel <paul@quickwit.io>", "Pascal Seitz <pascal@quickwit.io>"]
 license = "MIT"
 edition = "2021"
@@ -14,7 +14,8 @@ repository = "https://github.com/quickwit-oss/tantivy"
 
 [dependencies]
 byteorder = "1.4.3"
-ownedbytes = { version= "0.4", path="../ownedbytes" }
+ownedbytes = { version= "0.5", path="../ownedbytes" }
+async-trait = "0.1"
 
 [dev-dependencies]
 proptest = "1.0.0"

common/src/file_slice.rs

@@ -1,19 +1,18 @@
-use std::ops::{Deref, Range};
+use std::ops::{Deref, Range, RangeBounds};
 use std::sync::Arc;
 use std::{fmt, io};
 
 use async_trait::async_trait;
-use common::HasLen;
-use stable_deref_trait::StableDeref;
+use ownedbytes::{OwnedBytes, StableDeref};
 
-use crate::directory::OwnedBytes;
+use crate::HasLen;
 
 /// Objects that represents files sections in tantivy.
 ///
 /// By contract, whatever happens to the directory file, as long as a FileHandle
 /// is alive, the data associated with it cannot be altered or destroyed.
 ///
-/// The underlying behavior is therefore specific to the [`Directory`](crate::Directory) that
+/// The underlying behavior is therefore specific to the `Directory` that
 /// created it. Despite its name, a [`FileSlice`] may or may not directly map to an actual file
 /// on the filesystem.
 
@@ -24,13 +23,12 @@ pub trait FileHandle: 'static + Send + Sync + HasLen + fmt::Debug {
     /// This method may panic if the range requested is invalid.
     fn read_bytes(&self, range: Range<usize>) -> io::Result<OwnedBytes>;
 
-    #[cfg(feature = "quickwit")]
     #[doc(hidden)]
-    async fn read_bytes_async(
-        &self,
-        _byte_range: Range<usize>,
-    ) -> crate::AsyncIoResult<OwnedBytes> {
-        Err(crate::error::AsyncIoError::AsyncUnsupported)
+    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.",
+        ))
     }
 }
 
@@ -41,8 +39,7 @@ impl FileHandle for &'static [u8] {
         Ok(OwnedBytes::new(bytes))
     }
 
-    #[cfg(feature = "quickwit")]
-    async fn read_bytes_async(&self, byte_range: Range<usize>) -> crate::AsyncIoResult<OwnedBytes> {
+    async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
         Ok(self.read_bytes(byte_range)?)
     }
 }
@@ -70,6 +67,34 @@ 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.
+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() {
+            std::ops::Bound::Included(rel_start) => rel_start,
+            std::ops::Bound::Excluded(rel_start) => rel_start + 1,
+            std::ops::Bound::Unbounded => 0,
+        };
+    assert!(start <= orig_range.end);
+    let end: usize = match rel_range.end_bound().cloned() {
+        std::ops::Bound::Included(rel_end) => orig_range.start + rel_end + 1,
+        std::ops::Bound::Excluded(rel_end) => orig_range.start + rel_end,
+        std::ops::Bound::Unbounded => orig_range.end,
+    };
+    assert!(end >= start);
+    assert!(end <= orig_range.end);
+    start..end
+}
+
 impl FileSlice {
     /// Wraps a FileHandle.
     pub fn new(file_handle: Arc<dyn FileHandle>) -> Self {
@@ -93,11 +118,11 @@ impl FileSlice {
     ///
     /// Panics if `byte_range.end` exceeds the filesize.
     #[must_use]
-    pub fn slice(&self, byte_range: Range<usize>) -> FileSlice {
-        assert!(byte_range.end <= self.len());
+    #[inline]
+    pub fn slice<R: RangeBounds<usize>>(&self, byte_range: R) -> FileSlice {
         FileSlice {
             data: self.data.clone(),
-            range: self.range.start + byte_range.start..self.range.start + byte_range.end,
+            range: combine_ranges(self.range.clone(), byte_range),
         }
     }
 
@@ -117,9 +142,8 @@ impl FileSlice {
         self.data.read_bytes(self.range.clone())
     }
 
-    #[cfg(feature = "quickwit")]
     #[doc(hidden)]
-    pub async fn read_bytes_async(&self) -> crate::AsyncIoResult<OwnedBytes> {
+    pub async fn read_bytes_async(&self) -> io::Result<OwnedBytes> {
         self.data.read_bytes_async(self.range.clone()).await
     }
 
@@ -137,12 +161,8 @@ impl FileSlice {
             .read_bytes(self.range.start + range.start..self.range.start + range.end)
     }
 
-    #[cfg(feature = "quickwit")]
     #[doc(hidden)]
-    pub async fn read_bytes_slice_async(
-        &self,
-        byte_range: Range<usize>,
-    ) -> crate::AsyncIoResult<OwnedBytes> {
+    pub async fn read_bytes_slice_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
         assert!(
             self.range.start + byte_range.end <= self.range.end,
             "`to` exceeds the fileslice length"
@@ -204,8 +224,7 @@ impl FileHandle for FileSlice {
         self.read_bytes_slice(range)
     }
 
-    #[cfg(feature = "quickwit")]
-    async fn read_bytes_async(&self, byte_range: Range<usize>) -> crate::AsyncIoResult<OwnedBytes> {
+    async fn read_bytes_async(&self, byte_range: Range<usize>) -> io::Result<OwnedBytes> {
         self.read_bytes_slice_async(byte_range).await
     }
 }
@@ -222,21 +241,20 @@ impl FileHandle for OwnedBytes {
         Ok(self.slice(range))
     }
 
-    #[cfg(feature = "quickwit")]
-    async fn read_bytes_async(&self, range: Range<usize>) -> crate::AsyncIoResult<OwnedBytes> {
-        let bytes = self.read_bytes(range)?;
-        Ok(bytes)
+    async fn read_bytes_async(&self, range: Range<usize>) -> io::Result<OwnedBytes> {
+        self.read_bytes(range)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use std::io;
+    use std::ops::Bound;
     use std::sync::Arc;
 
-    use common::HasLen;
-
     use super::{FileHandle, FileSlice};
+    use crate::file_slice::combine_ranges;
+    use crate::HasLen;
 
     #[test]
     fn test_file_slice() -> io::Result<()> {
@@ -307,4 +325,23 @@ mod tests {
             b"bcd"
         );
     }
+
+    #[test]
+    fn test_combine_range() {
+        assert_eq!(combine_ranges(1..3, 0..1), 1..2);
+        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]
+    #[should_panic]
+    fn test_combine_range_panics() {
+        let _ = combine_ranges(3..5, 1..4);
+    }
 }

common/src/lib.rs

@@ -5,11 +5,12 @@ use std::ops::Deref;
 pub use byteorder::LittleEndian as Endianness;
 
 mod bitset;
+pub mod file_slice;
 mod serialize;
 mod vint;
 mod writer;
-
 pub use bitset::*;
+pub use ownedbytes::{OwnedBytes, StableDeref};
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
 pub use vint::{
     deserialize_vint_u128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u128,

fastfield_codecs/Cargo.toml

@@ -12,9 +12,8 @@ repository = "https://github.com/quickwit-oss/tantivy"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-common = { version = "0.4", path = "../common/", package = "tantivy-common" }
+common = { version = "0.5", path = "../common/", package = "tantivy-common" }
 tantivy-bitpacker = { version= "0.3", path = "../bitpacker/" }
-ownedbytes = { version = "0.4.0", path = "../ownedbytes" }
 prettytable-rs = {version="0.9.0", optional= true}
 rand = {version="0.8.3", optional= true}
 fastdivide = "0.4"

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 ownedbytes::OwnedBytes;
+use common::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::serialize::NormalizedHeader;

fastfield_codecs/src/blockwise_linear.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 use std::{io, iter};
 
-use common::{BinarySerializable, CountingWriter, DeserializeFrom};
-use ownedbytes::OwnedBytes;
+use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::line::Line;
@@ -47,7 +46,7 @@ impl FastFieldCodec for BlockwiseLinearCodec {
     type Reader = BlockwiseLinearReader;
 
     fn open_from_bytes(
-        bytes: ownedbytes::OwnedBytes,
+        bytes: common::OwnedBytes,
         normalized_header: NormalizedHeader,
     ) -> io::Result<Self::Reader> {
         let footer_len: u32 = (&bytes[bytes.len() - 4..]).deserialize()?;
@@ -171,15 +170,18 @@ 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

@@ -135,7 +135,7 @@ impl<'a, T: Copy + PartialOrd + Send + Sync> Column<T> for VecColumn<'a, T> {
     }
 }
 
-impl<'a, T: Copy + Ord + Default, V> From<&'a V> for VecColumn<'a, T>
+impl<'a, T: Copy + PartialOrd + 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,8 +17,7 @@ use std::{
     ops::{Range, RangeInclusive},
 };
 
-use common::{BinarySerializable, CountingWriter, VInt, VIntU128};
-use ownedbytes::OwnedBytes;
+use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt, VIntU128};
 use tantivy_bitpacker::{self, BitPacker, BitUnpacker};
 
 use crate::compact_space::build_compact_space::get_compact_space;

fastfield_codecs/src/format_version.rs

@@ -1,7 +1,6 @@
 use std::io;
 
-use common::BinarySerializable;
-use ownedbytes::OwnedBytes;
+use common::{BinarySerializable, 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 ownedbytes::OwnedBytes;
+    use common::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;
+use common::{BinarySerializable, OwnedBytes};
 use compact_space::CompactSpaceDecompressor;
 use format_version::read_format_version;
 use monotonic_mapping::{
@@ -26,7 +26,6 @@ use monotonic_mapping::{
     StrictlyMonotonicMappingToInternalBaseval, StrictlyMonotonicMappingToInternalGCDBaseval,
 };
 use null_index_footer::read_null_index_footer;
-use ownedbytes::OwnedBytes;
 use serialize::{Header, U128Header};
 
 mod bitpacked;
@@ -43,7 +42,7 @@ mod null_index_footer;
 
 mod column;
 mod gcd;
-mod serialize;
+pub mod serialize;
 
 use self::bitpacked::BitpackedCodec;
 use self::blockwise_linear::BlockwiseLinearCodec;
@@ -436,7 +435,7 @@ mod tests {
 mod bench {
     use std::sync::Arc;
 
-    use ownedbytes::OwnedBytes;
+    use common::OwnedBytes;
     use rand::rngs::StdRng;
     use rand::{Rng, SeedableRng};
     use test::{self, Bencher};

fastfield_codecs/src/linear.rs

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

@@ -56,10 +56,12 @@ 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)
     }
@@ -82,10 +84,12 @@ 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)
     }
@@ -95,10 +99,12 @@ 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)
     }
@@ -126,11 +132,13 @@ 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)
     }
@@ -141,6 +149,7 @@ pub(crate) struct StrictlyMonotonicMappingToInternalBaseval {
     min_value: u64,
 }
 impl StrictlyMonotonicMappingToInternalBaseval {
+    #[inline(always)]
     pub(crate) fn new(min_value: u64) -> Self {
         Self { min_value }
     }
@@ -149,20 +158,24 @@ 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
     }
@@ -192,11 +205,15 @@ 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)
     }

fastfield_codecs/src/null_index/dense.rs

@@ -1,9 +1,8 @@
 use std::convert::TryInto;
 use std::io::{self, Write};
 
-use common::BinarySerializable;
+use common::{BinarySerializable, OwnedBytes};
 use itertools::Itertools;
-use ownedbytes::OwnedBytes;
 
 use super::{get_bit_at, set_bit_at};
 

fastfield_codecs/src/null_index/sparse.rs

@@ -1,7 +1,6 @@
 use std::io::{self, Write};
 
-use common::BitSet;
-use ownedbytes::OwnedBytes;
+use common::{BitSet, OwnedBytes};
 
 use super::{serialize_dense_codec, DenseCodec};
 
@@ -59,6 +58,7 @@ 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,
@@ -160,7 +160,7 @@ fn deserialize_sparse_codec_block(data: &OwnedBytes) -> Vec<SparseCodecBlockVari
     // The number of vals so far
     let mut offset = 0;
     let mut sparse_codec_blocks = Vec::new();
-    let num_blocks = get_u16(&data, data.len() - 2);
+    let num_blocks = get_u16(data, data.len() - 2);
     let block_data_index_start =
         data.len() - 2 - num_blocks as usize * SERIALIZED_BLOCK_METADATA_SIZE;
     let mut byte_start = 0;

fastfield_codecs/src/null_index_footer.rs

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

fastfield_codecs/src/serialize.rs

@@ -21,9 +21,8 @@ use std::io;
 use std::num::NonZeroU64;
 use std::sync::Arc;
 
-use common::{BinarySerializable, VInt};
+use common::{BinarySerializable, OwnedBytes, VInt};
 use log::warn;
-use ownedbytes::OwnedBytes;
 
 use crate::bitpacked::BitpackedCodec;
 use crate::blockwise_linear::BlockwiseLinearCodec;
@@ -198,12 +197,13 @@ pub fn serialize_u128<F: Fn() -> I, I: Iterator<Item = u128>>(
 }
 
 #[allow(dead_code)]
-pub enum ValueIndexInfo {
-    MultiValue(Box<dyn MultiValueIndexInfo>),
-    SingleValue(Box<dyn SingleValueIndexInfo>),
+pub enum ValueIndexInfo<'a> {
+    MultiValue(Box<dyn MultiValueIndexInfo + 'a>),
+    SingleValue(Box<dyn SingleValueIndexInfo + 'a>),
 }
 
-impl Default for ValueIndexInfo {
+// TODO Remove me
+impl Default for ValueIndexInfo<'static> {
     fn default() -> Self {
         struct Dummy {}
         impl SingleValueIndexInfo for Dummy {
@@ -222,7 +222,7 @@ impl Default for ValueIndexInfo {
     }
 }
 
-impl ValueIndexInfo {
+impl<'a> ValueIndexInfo<'a> {
     fn get_cardinality(&self) -> FastFieldCardinality {
         match self {
             ValueIndexInfo::MultiValue(_) => FastFieldCardinality::Multi,
@@ -237,7 +237,7 @@ pub trait MultiValueIndexInfo {
     /// The number of values in the column.
     fn num_vals(&self) -> u32;
     /// Return the start index of the values for each doc
-    fn iter(&self) -> Box<dyn Iterator<Item = u32>>;
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_>;
 }
 
 pub trait SingleValueIndexInfo {
@@ -246,7 +246,7 @@ pub trait SingleValueIndexInfo {
     /// The number of non-null values in the column.
     fn num_non_nulls(&self) -> u32;
     /// Return a iterator of the positions of docs with a value
-    fn iter(&self) -> Box<dyn Iterator<Item = u32>>;
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_>;
 }
 
 /// Serializes u128 values with the compact space codec.

ownedbytes/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 authors = ["Paul Masurel <paul@quickwit.io>", "Pascal Seitz <pascal@quickwit.io>"]
 name = "ownedbytes"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 description = "Expose data as static slice"
 license = "MIT"

ownedbytes/src/lib.rs

@@ -3,7 +3,7 @@ use std::ops::{Deref, Range};
 use std::sync::Arc;
 use std::{fmt, io, mem};
 
-use stable_deref_trait::StableDeref;
+pub use stable_deref_trait::StableDeref;
 
 /// An OwnedBytes simply wraps an object that owns a slice of data and exposes
 /// this data as a slice.

src/core/inverted_index_reader.rs

@@ -200,10 +200,7 @@ impl InvertedIndexReader {
 
 #[cfg(feature = "quickwit")]
 impl InvertedIndexReader {
-    pub(crate) async fn get_term_info_async(
-        &self,
-        term: &Term,
-    ) -> crate::AsyncIoResult<Option<TermInfo>> {
+    pub(crate) async fn get_term_info_async(&self, term: &Term) -> io::Result<Option<TermInfo>> {
         self.termdict.get_async(term.value_bytes()).await
     }
 
@@ -211,12 +208,8 @@ impl InvertedIndexReader {
     /// This method is for an advanced usage only.
     ///
     /// Most users should prefer using [`Self::read_postings()`] instead.
-    pub async fn warm_postings(
-        &self,
-        term: &Term,
-        with_positions: bool,
-    ) -> crate::AsyncIoResult<()> {
-        let term_info_opt = self.get_term_info_async(term).await?;
+    pub async fn warm_postings(&self, term: &Term, with_positions: bool) -> io::Result<()> {
+        let term_info_opt: Option<TermInfo> = self.get_term_info_async(term).await?;
         if let Some(term_info) = term_info_opt {
             self.postings_file_slice
                 .read_bytes_slice_async(term_info.postings_range.clone())
@@ -234,7 +227,7 @@ impl InvertedIndexReader {
     /// This method is for an advanced usage only.
     ///
     /// If you know which terms to pre-load, prefer using [`Self::warm_postings`] instead.
-    pub async fn warm_postings_full(&self, with_positions: bool) -> crate::AsyncIoResult<()> {
+    pub async fn warm_postings_full(&self, with_positions: bool) -> io::Result<()> {
         self.postings_file_slice.read_bytes_async().await?;
         if with_positions {
             self.positions_file_slice.read_bytes_async().await?;
@@ -243,7 +236,7 @@ impl InvertedIndexReader {
     }
 
     /// Returns the number of documents containing the term asynchronously.
-    pub async fn doc_freq_async(&self, term: &Term) -> crate::AsyncIoResult<u32> {
+    pub async fn doc_freq_async(&self, term: &Term) -> io::Result<u32> {
         Ok(self
             .get_term_info_async(term)
             .await?

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

@@ -5,7 +5,6 @@ mod mmap_directory;
 
 mod directory;
 mod directory_lock;
-mod file_slice;
 mod file_watcher;
 mod footer;
 mod managed_directory;
@@ -20,13 +19,12 @@ mod composite_file;
 use std::io::BufWriter;
 use std::path::PathBuf;
 
-pub use common::{AntiCallToken, TerminatingWrite};
-pub use ownedbytes::OwnedBytes;
+pub use common::file_slice::{FileHandle, FileSlice};
+pub use common::{AntiCallToken, OwnedBytes, TerminatingWrite};
 
 pub(crate) use self::composite_file::{CompositeFile, CompositeWrite};
 pub use self::directory::{Directory, DirectoryClone, DirectoryLock};
 pub use self::directory_lock::{Lock, INDEX_WRITER_LOCK, META_LOCK};
-pub use self::file_slice::{FileHandle, FileSlice};
 pub use self::ram_directory::RamDirectory;
 pub use self::watch_event_router::{WatchCallback, WatchCallbackList, WatchHandle};
 

src/error.rs

@@ -104,28 +104,6 @@ pub enum TantivyError {
     InternalError(String),
 }
 
-#[cfg(feature = "quickwit")]
-#[derive(Error, Debug)]
-#[doc(hidden)]
-pub enum AsyncIoError {
-    #[error("io::Error `{0}`")]
-    Io(#[from] io::Error),
-    #[error("Asynchronous API is unsupported by this directory")]
-    AsyncUnsupported,
-}
-
-#[cfg(feature = "quickwit")]
-impl From<AsyncIoError> for TantivyError {
-    fn from(async_io_err: AsyncIoError) -> Self {
-        match async_io_err {
-            AsyncIoError::Io(io_err) => TantivyError::from(io_err),
-            AsyncIoError::AsyncUnsupported => {
-                TantivyError::SystemError(format!("{:?}", async_io_err))
-            }
-        }
-    }
-}
-
 impl From<io::Error> for TantivyError {
     fn from(io_err: io::Error) -> TantivyError {
         TantivyError::IoError(Arc::new(io_err))

src/fastfield/alive_bitset.rs

@@ -1,8 +1,7 @@
 use std::io;
 use std::io::Write;
 
-use common::{intersect_bitsets, BitSet, ReadOnlyBitSet};
-use ownedbytes::OwnedBytes;
+use common::{intersect_bitsets, BitSet, OwnedBytes, ReadOnlyBitSet};
 
 use crate::space_usage::ByteCount;
 use crate::DocId;

src/fastfield/multivalued/index.rs

@@ -80,6 +80,7 @@ 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) as u64
+            self.0.fetch_add(val, order)
         }
 
         pub fn revert(&self, val: u64, order: Ordering) -> u64 {

src/lib.rs

@@ -259,10 +259,6 @@ pub use crate::future_result::FutureResult;
 /// and instead, refer to this as `crate::Result<T>`.
 pub type Result<T> = std::result::Result<T, TantivyError>;
 
-/// Result for an Async io operation.
-#[cfg(feature = "quickwit")]
-pub type AsyncIoResult<T> = std::result::Result<T, crate::error::AsyncIoError>;
-
 mod core;
 mod indexer;
 

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 кeturns documents matching one or more wrapped queries,
+/// The disjunction max query returns 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

@@ -126,7 +126,7 @@ impl VecCursor {
     }
     #[inline]
     fn current(&self) -> Option<u32> {
-        self.docs.get(self.current_pos).map(|el| *el)
+        self.docs.get(self.current_pos).copied()
     }
     fn get_cleared_data(&mut self) -> &mut Vec<u32> {
         self.docs.clear();
@@ -280,10 +280,7 @@ impl DocSet for IpRangeDocSet {
 
     #[inline]
     fn doc(&self) -> DocId {
-        self.loaded_docs
-            .current()
-            .map(|el| el)
-            .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,9 +4,8 @@ use std::ops::{AddAssign, Range};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 
-use common::{BinarySerializable, HasLen};
+use common::{BinarySerializable, HasLen, OwnedBytes};
 use lru::LruCache;
-use ownedbytes::OwnedBytes;
 
 use super::footer::DocStoreFooter;
 use super::index::SkipIndex;
@@ -319,7 +318,7 @@ impl StoreReader {
     /// In most cases use [`get_async`](Self::get_async)
     ///
     /// Loads and decompresses a block asynchronously.
-    async fn read_block_async(&self, checkpoint: &Checkpoint) -> crate::AsyncIoResult<Block> {
+    async fn read_block_async(&self, checkpoint: &Checkpoint) -> io::Result<Block> {
         let cache_key = checkpoint.byte_range.start;
         if let Some(block) = self.cache.get_from_cache(checkpoint.byte_range.start) {
             return Ok(block);

src/termdict/fst_termdict/term_info_store.rs

@@ -121,7 +121,7 @@ fn extract_bits(data: &[u8], addr_bits: usize, num_bits: u8) -> u64 {
 }
 
 impl TermInfoStore {
-    pub fn open(term_info_store_file: FileSlice) -> crate::Result<TermInfoStore> {
+    pub fn open(term_info_store_file: FileSlice) -> io::Result<TermInfoStore> {
         let (len_slice, main_slice) = term_info_store_file.split(16);
         let mut bytes = len_slice.read_bytes()?;
         let len = u64::deserialize(&mut bytes)? as usize;

src/termdict/fst_termdict/termdict.rs

@@ -8,7 +8,6 @@ use tantivy_fst::Automaton;
 use super::term_info_store::{TermInfoStore, TermInfoStoreWriter};
 use super::{TermStreamer, TermStreamerBuilder};
 use crate::directory::{FileSlice, OwnedBytes};
-use crate::error::DataCorruption;
 use crate::postings::TermInfo;
 use crate::termdict::TermOrdinal;
 
@@ -55,7 +54,7 @@ where W: Write
     /// to insert_key and insert_value.
     ///
     /// Prefer using `.insert(key, value)`
-    pub(crate) fn insert_key(&mut self, key: &[u8]) -> io::Result<()> {
+    pub fn insert_key(&mut self, key: &[u8]) -> io::Result<()> {
         self.fst_builder
             .insert(key, self.term_ord)
             .map_err(convert_fst_error)?;
@@ -66,7 +65,7 @@ where W: Write
     /// # Warning
     ///
     /// Horribly dangerous internal API. See `.insert_key(...)`.
-    pub(crate) fn insert_value(&mut self, term_info: &TermInfo) -> io::Result<()> {
+    pub fn insert_value(&mut self, term_info: &TermInfo) -> io::Result<()> {
         self.term_info_store_writer.write_term_info(term_info)?;
         Ok(())
     }
@@ -86,10 +85,14 @@ where W: Write
     }
 }
 
-fn open_fst_index(fst_file: FileSlice) -> crate::Result<tantivy_fst::Map<OwnedBytes>> {
+fn open_fst_index(fst_file: FileSlice) -> io::Result<tantivy_fst::Map<OwnedBytes>> {
     let bytes = fst_file.read_bytes()?;
-    let fst = Fst::new(bytes)
-        .map_err(|err| DataCorruption::comment_only(format!("Fst data is corrupted: {:?}", err)))?;
+    let fst = Fst::new(bytes).map_err(|err| {
+        io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("Fst data is corrupted: {:?}", err),
+        )
+    })?;
     Ok(tantivy_fst::Map::from(fst))
 }
 
@@ -114,7 +117,7 @@ pub struct TermDictionary {
 
 impl TermDictionary {
     /// Opens a `TermDictionary`.
-    pub fn open(file: FileSlice) -> crate::Result<Self> {
+    pub fn open(file: FileSlice) -> io::Result<Self> {
         let (main_slice, footer_len_slice) = file.split_from_end(8);
         let mut footer_len_bytes = footer_len_slice.read_bytes()?;
         let footer_size = u64::deserialize(&mut footer_len_bytes)?;

src/termdict/sstable_termdict/mod.rs

@@ -1,49 +1,64 @@
 use std::io;
 
 mod merger;
-mod streamer;
-mod termdict;
 
 use std::iter::ExactSizeIterator;
 
 use common::VInt;
 use sstable::value::{ValueReader, ValueWriter};
-use sstable::{BlockReader, SSTable};
+use sstable::SSTable;
+use tantivy_fst::automaton::AlwaysMatch;
 
 pub use self::merger::TermMerger;
-pub use self::streamer::{TermStreamer, TermStreamerBuilder};
-pub use self::termdict::{TermDictionary, TermDictionaryBuilder};
 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 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 Reader = TermInfoReader;
-    type Writer = TermInfoWriter;
+    type ValueReader = TermInfoValueReader;
+    type ValueWriter = TermInfoValueWriter;
 }
 
 #[derive(Default)]
-pub struct TermInfoReader {
+pub struct TermInfoValueReader {
     term_infos: Vec<TermInfo>,
 }
 
-impl ValueReader for TermInfoReader {
+impl ValueReader for TermInfoValueReader {
     type Value = TermInfo;
 
+    #[inline(always)]
     fn value(&self, idx: usize) -> &TermInfo {
         &self.term_infos[idx]
     }
 
-    fn read(&mut self, reader: &mut BlockReader) -> io::Result<()> {
+    fn load(&mut self, mut data: &[u8]) -> io::Result<usize> {
+        let len_before = data.len();
         self.term_infos.clear();
-        let num_els = VInt::deserialize_u64(reader)?;
-        let mut postings_start = VInt::deserialize_u64(reader)? as usize;
-        let mut positions_start = VInt::deserialize_u64(reader)? as usize;
+        let num_els = VInt::deserialize_u64(&mut data)?;
+        let mut postings_start = VInt::deserialize_u64(&mut data)? as usize;
+        let mut positions_start = VInt::deserialize_u64(&mut data)? as usize;
         for _ in 0..num_els {
-            let doc_freq = VInt::deserialize_u64(reader)? as u32;
-            let postings_num_bytes = VInt::deserialize_u64(reader)?;
-            let positions_num_bytes = VInt::deserialize_u64(reader)?;
+            let doc_freq = VInt::deserialize_u64(&mut data)? as u32;
+            let postings_num_bytes = VInt::deserialize_u64(&mut data)?;
+            let positions_num_bytes = VInt::deserialize_u64(&mut data)?;
             let postings_end = postings_start + postings_num_bytes as usize;
             let positions_end = positions_start + positions_num_bytes as usize;
             let term_info = TermInfo {
@@ -55,23 +70,24 @@ impl ValueReader for TermInfoReader {
             postings_start = postings_end;
             positions_start = positions_end;
         }
-        Ok(())
+        let consumed_len = len_before - data.len();
+        Ok(consumed_len)
     }
 }
 
 #[derive(Default)]
-pub struct TermInfoWriter {
+pub struct TermInfoValueWriter {
     term_infos: Vec<TermInfo>,
 }
 
-impl ValueWriter for TermInfoWriter {
+impl ValueWriter for TermInfoValueWriter {
     type Value = TermInfo;
 
     fn write(&mut self, term_info: &TermInfo) {
         self.term_infos.push(term_info.clone());
     }
 
-    fn write_block(&mut self, buffer: &mut Vec<u8>) {
+    fn serialize_block(&self, buffer: &mut Vec<u8>) {
         VInt(self.term_infos.len() as u64).serialize_into_vec(buffer);
         if self.term_infos.is_empty() {
             return;
@@ -83,24 +99,23 @@ impl ValueWriter for TermInfoWriter {
             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();
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::io;
-
     use sstable::value::{ValueReader, ValueWriter};
 
-    use super::BlockReader;
-    use crate::directory::OwnedBytes;
     use crate::postings::TermInfo;
-    use crate::termdict::sstable_termdict::TermInfoReader;
+    use crate::termdict::sstable_termdict::TermInfoValueReader;
 
     #[test]
-    fn test_block_terminfos() -> io::Result<()> {
-        let mut term_info_writer = super::TermInfoWriter::default();
+    fn test_block_terminfos() {
+        let mut term_info_writer = super::TermInfoValueWriter::default();
         term_info_writer.write(&TermInfo {
             doc_freq: 120u32,
             postings_range: 17..45,
@@ -117,10 +132,9 @@ mod tests {
             positions_range: 1100..1302,
         });
         let mut buffer = Vec::new();
-        term_info_writer.write_block(&mut buffer);
-        let mut block_reader = make_block_reader(&buffer[..]);
-        let mut term_info_reader = TermInfoReader::default();
-        term_info_reader.read(&mut block_reader)?;
+        term_info_writer.serialize_block(&mut buffer);
+        let mut term_info_reader = TermInfoValueReader::default();
+        let num_bytes: usize = term_info_reader.load(&buffer[..]).unwrap();
         assert_eq!(
             term_info_reader.value(0),
             &TermInfo {
@@ -129,16 +143,6 @@ mod tests {
                 positions_range: 10..122
             }
         );
-        assert!(block_reader.buffer().is_empty());
-        Ok(())
-    }
-
-    fn make_block_reader(data: &[u8]) -> BlockReader {
-        let mut buffer = (data.len() as u32).to_le_bytes().to_vec();
-        buffer.extend_from_slice(data);
-        let owned_bytes = OwnedBytes::new(buffer);
-        let mut block_reader = BlockReader::new(Box::new(owned_bytes));
-        block_reader.read_block().unwrap();
-        block_reader
+        assert_eq!(buffer.len(), num_bytes);
     }
 }

src/termdict/sstable_termdict/termdict.rs

@@ -1,256 +0,0 @@
-use std::io;
-use std::sync::Arc;
-
-use common::BinarySerializable;
-use once_cell::sync::Lazy;
-use sstable::{BlockAddr, DeltaReader, Reader, SSTable, SSTableIndex, Writer};
-use tantivy_fst::automaton::AlwaysMatch;
-use tantivy_fst::Automaton;
-
-use crate::directory::{FileSlice, OwnedBytes};
-use crate::postings::TermInfo;
-use crate::termdict::sstable_termdict::{
-    TermInfoReader, TermInfoWriter, TermSSTable, TermStreamer, TermStreamerBuilder,
-};
-use crate::termdict::TermOrdinal;
-use crate::AsyncIoResult;
-
-pub struct TermInfoSSTable;
-impl SSTable for TermInfoSSTable {
-    type Value = TermInfo;
-    type Reader = TermInfoReader;
-    type Writer = TermInfoWriter;
-}
-
-/// Builder for the new term dictionary.
-pub struct TermDictionaryBuilder<W: io::Write> {
-    sstable_writer: Writer<W, TermInfoWriter>,
-}
-
-impl<W: io::Write> TermDictionaryBuilder<W> {
-    /// Creates a new `TermDictionaryBuilder`
-    pub fn create(w: W) -> io::Result<Self> {
-        let sstable_writer = TermSSTable::writer(w);
-        Ok(TermDictionaryBuilder { sstable_writer })
-    }
-
-    /// Inserts a `(key, value)` pair in the term dictionary.
-    ///
-    /// *Keys have to be inserted in order.*
-    pub fn insert<K: AsRef<[u8]>>(&mut self, key_ref: K, value: &TermInfo) -> io::Result<()> {
-        let key = key_ref.as_ref();
-        self.insert_key(key)?;
-        self.insert_value(value)?;
-        Ok(())
-    }
-
-    /// # Warning
-    /// Horribly dangerous internal API
-    ///
-    /// If used, it must be used by systematically alternating calls
-    /// to insert_key and insert_value.
-    ///
-    /// Prefer using `.insert(key, value)`
-    #[allow(clippy::unnecessary_wraps)]
-    pub(crate) fn insert_key(&mut self, key: &[u8]) -> io::Result<()> {
-        self.sstable_writer.write_key(key);
-        Ok(())
-    }
-
-    /// # Warning
-    ///
-    /// Horribly dangerous internal API. See `.insert_key(...)`.
-    pub(crate) fn insert_value(&mut self, term_info: &TermInfo) -> io::Result<()> {
-        self.sstable_writer.write_value(term_info)
-    }
-
-    /// Finalize writing the builder, and returns the underlying
-    /// `Write` object.
-    pub fn finish(self) -> io::Result<W> {
-        self.sstable_writer.finalize()
-    }
-}
-
-static EMPTY_TERM_DICT_FILE: Lazy<FileSlice> = Lazy::new(|| {
-    let term_dictionary_data: Vec<u8> = TermDictionaryBuilder::create(Vec::<u8>::new())
-        .expect("Creating a TermDictionaryBuilder in a Vec<u8> should never fail")
-        .finish()
-        .expect("Writing in a Vec<u8> should never fail");
-    FileSlice::from(term_dictionary_data)
-});
-
-/// 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 struct TermDictionary {
-    sstable_slice: FileSlice,
-    sstable_index: SSTableIndex,
-    num_terms: u64,
-}
-
-impl TermDictionary {
-    pub(crate) fn sstable_reader(&self) -> io::Result<Reader<'static, TermInfoReader>> {
-        let data = self.sstable_slice.read_bytes()?;
-        Ok(TermInfoSSTable::reader(data))
-    }
-
-    pub(crate) fn sstable_reader_block(
-        &self,
-        block_addr: BlockAddr,
-    ) -> io::Result<Reader<'static, TermInfoReader>> {
-        let data = self.sstable_slice.read_bytes_slice(block_addr.byte_range)?;
-        Ok(TermInfoSSTable::reader(data))
-    }
-
-    pub(crate) async fn sstable_reader_block_async(
-        &self,
-        block_addr: BlockAddr,
-    ) -> AsyncIoResult<Reader<'static, TermInfoReader>> {
-        let data = self
-            .sstable_slice
-            .read_bytes_slice_async(block_addr.byte_range)
-            .await?;
-        Ok(TermInfoSSTable::reader(data))
-    }
-
-    pub(crate) fn sstable_delta_reader(&self) -> io::Result<DeltaReader<'static, TermInfoReader>> {
-        let data = self.sstable_slice.read_bytes()?;
-        Ok(TermInfoSSTable::delta_reader(data))
-    }
-
-    /// Opens a `TermDictionary`.
-    pub fn open(term_dictionary_file: FileSlice) -> crate::Result<Self> {
-        let (main_slice, footer_len_slice) = term_dictionary_file.split_from_end(16);
-        let mut footer_len_bytes: OwnedBytes = footer_len_slice.read_bytes()?;
-        let index_offset = u64::deserialize(&mut footer_len_bytes)?;
-        let num_terms = u64::deserialize(&mut footer_len_bytes)?;
-        let (sstable_slice, index_slice) = main_slice.split(index_offset as usize);
-        let sstable_index_bytes = index_slice.read_bytes()?;
-        let sstable_index = SSTableIndex::load(sstable_index_bytes.as_slice())
-            .map_err(|_| crate::error::DataCorruption::comment_only("SSTable corruption"))?;
-        Ok(TermDictionary {
-            sstable_slice,
-            sstable_index,
-            num_terms,
-        })
-    }
-
-    /// Creates a term dictionary from the supplied bytes.
-    pub fn from_bytes(owned_bytes: OwnedBytes) -> crate::Result<TermDictionary> {
-        TermDictionary::open(FileSlice::new(Arc::new(owned_bytes)))
-    }
-
-    /// Creates an empty term dictionary which contains no terms.
-    pub fn empty() -> Self {
-        TermDictionary::open(EMPTY_TERM_DICT_FILE.clone()).unwrap()
-    }
-
-    /// Returns the number of terms in the dictionary.
-    /// Term ordinals range from 0 to `num_terms() - 1`.
-    pub fn num_terms(&self) -> usize {
-        self.num_terms as usize
-    }
-
-    /// Returns the ordinal associated with a given term.
-    pub fn term_ord<K: AsRef<[u8]>>(&self, key: K) -> io::Result<Option<TermOrdinal>> {
-        let mut term_ord = 0u64;
-        let key_bytes = key.as_ref();
-        let mut sstable_reader = self.sstable_reader()?;
-        while sstable_reader.advance().unwrap_or(false) {
-            if sstable_reader.key() == key_bytes {
-                return Ok(Some(term_ord));
-            }
-            term_ord += 1;
-        }
-        Ok(None)
-    }
-
-    /// Returns the term associated with a given term ordinal.
-    ///
-    /// Term ordinals are defined as the position of the term in
-    /// the sorted list of terms.
-    ///
-    /// Returns true if and only if the term has been found.
-    ///
-    /// Regardless of whether the term is found or not,
-    /// the buffer may be modified.
-    pub fn ord_to_term(&self, ord: TermOrdinal, bytes: &mut Vec<u8>) -> io::Result<bool> {
-        let mut sstable_reader = self.sstable_reader()?;
-        bytes.clear();
-        for _ in 0..(ord + 1) {
-            if !sstable_reader.advance().unwrap_or(false) {
-                return Ok(false);
-            }
-        }
-        bytes.extend_from_slice(sstable_reader.key());
-        Ok(true)
-    }
-
-    /// Returns the number of terms in the dictionary.
-    pub fn term_info_from_ord(&self, term_ord: TermOrdinal) -> io::Result<TermInfo> {
-        let mut sstable_reader = self.sstable_reader()?;
-        for _ in 0..(term_ord + 1) {
-            if !sstable_reader.advance().unwrap_or(false) {
-                return Ok(TermInfo::default());
-            }
-        }
-        Ok(sstable_reader.value().clone())
-    }
-
-    /// Lookups the value corresponding to the key.
-    pub fn get<K: AsRef<[u8]>>(&self, key: K) -> io::Result<Option<TermInfo>> {
-        if let Some(block_addr) = self.sstable_index.search(key.as_ref()) {
-            let mut sstable_reader = self.sstable_reader_block(block_addr)?;
-            let key_bytes = key.as_ref();
-            while sstable_reader.advance().unwrap_or(false) {
-                if sstable_reader.key() == key_bytes {
-                    let term_info = sstable_reader.value().clone();
-                    return Ok(Some(term_info));
-                }
-            }
-        }
-        Ok(None)
-    }
-
-    /// Lookups the value corresponding to the key.
-    pub async fn get_async<K: AsRef<[u8]>>(&self, key: K) -> AsyncIoResult<Option<TermInfo>> {
-        if let Some(block_addr) = self.sstable_index.search(key.as_ref()) {
-            let mut sstable_reader = self.sstable_reader_block_async(block_addr).await?;
-            let key_bytes = key.as_ref();
-            while sstable_reader.advance().unwrap_or(false) {
-                if sstable_reader.key() == key_bytes {
-                    let term_info = sstable_reader.value().clone();
-                    return Ok(Some(term_info));
-                }
-            }
-        }
-        Ok(None)
-    }
-
-    /// Returns a range builder, to stream all of the terms
-    /// within an interval.
-    pub fn range(&self) -> TermStreamerBuilder<'_> {
-        TermStreamerBuilder::new(self, AlwaysMatch)
-    }
-
-    /// A stream of all the sorted terms.
-    pub fn stream(&self) -> io::Result<TermStreamer<'_>> {
-        self.range().into_stream()
-    }
-
-    /// Returns a search builder, to stream all of the terms
-    /// within the Automaton
-    pub fn search<'a, A: Automaton + 'a>(&'a self, automaton: A) -> TermStreamerBuilder<'a, A>
-    where A::State: Clone {
-        TermStreamerBuilder::<A>::new(self, automaton)
-    }
-
-    #[doc(hidden)]
-    pub async fn warm_up_dictionary(&self) -> AsyncIoResult<()> {
-        self.sstable_slice.read_bytes_async().await?;
-        Ok(())
-    }
-}

src/termdict/tests.rs

@@ -1,5 +1,5 @@
 use std::path::PathBuf;
-use std::str;
+use std::{io, str};
 
 use super::{TermDictionary, TermDictionaryBuilder, TermStreamer};
 use crate::directory::{Directory, FileSlice, RamDirectory, TerminatingWrite};
@@ -247,7 +247,7 @@ fn test_empty_string() -> crate::Result<()> {
     Ok(())
 }
 
-fn stream_range_test_dict() -> crate::Result<TermDictionary> {
+fn stream_range_test_dict() -> io::Result<TermDictionary> {
     let buffer: Vec<u8> = {
         let mut term_dictionary_builder = TermDictionaryBuilder::create(Vec::new())?;
         for i in 0u8..10u8 {

sstable/Cargo.toml

@@ -2,12 +2,20 @@
 name = "tantivy-sstable"
 version = "0.1.0"
 edition = "2021"
+license = "MIT"
 
 [dependencies]
 common = {path="../common", package="tantivy-common"}
 ciborium = "0.2"
-byteorder = "1"
 serde = "1"
+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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,87 @@
+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,6 +1,5 @@
-use std::io::{self, Read};
-
-use byteorder::{LittleEndian, ReadBytesExt};
+use std::io;
+use std::ops::Range;
 
 pub struct BlockReader<'a> {
     buffer: Vec<u8>,
@@ -8,6 +7,13 @@ pub struct BlockReader<'a> {
     offset: usize,
 }
 
+#[inline]
+fn read_u32(read: &mut dyn io::Read) -> io::Result<u32> {
+    let mut buf = [0u8; 4];
+    read.read_exact(&mut buf)?;
+    Ok(u32::from_le_bytes(buf))
+}
+
 impl<'a> BlockReader<'a> {
     pub fn new(reader: Box<dyn io::Read + 'a>) -> BlockReader<'a> {
         BlockReader {
@@ -24,13 +30,13 @@ impl<'a> BlockReader<'a> {
     }
 
     #[inline(always)]
-    pub fn buffer_from_to(&self, start: usize, end: usize) -> &[u8] {
-        &self.buffer[start..end]
+    pub fn buffer_from_to(&self, range: Range<usize>) -> &[u8] {
+        &self.buffer[range]
     }
 
     pub fn read_block(&mut self) -> io::Result<bool> {
         self.offset = 0;
-        let block_len_res = self.reader.read_u32::<LittleEndian>();
+        let block_len_res = read_u32(self.reader.as_mut());
         if let Err(err) = &block_len_res {
             if err.kind() == io::ErrorKind::UnexpectedEof {
                 return Ok(false);
@@ -46,14 +52,17 @@ 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,6 +16,8 @@ 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>
@@ -28,6 +30,7 @@ where
             block: Vec::with_capacity(BLOCK_LEN * 2),
             write: CountingWriter::wrap(BufWriter::new(wrt)),
             value_writer: TValueWriter::default(),
+            stateless_buffer: Vec::new(),
         }
     }
 }
@@ -42,15 +45,16 @@ where
             return Ok(None);
         }
         let start_offset = self.write.written_bytes() as usize;
-        // TODO avoid buffer allocation
-        let mut buffer = Vec::new();
-        self.value_writer.write_block(&mut buffer);
+        let buffer: &mut Vec<u8> = &mut self.stateless_buffer;
+        self.value_writer.serialize_block(buffer);
+        self.value_writer.clear();
         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))
     }
 
@@ -84,15 +88,14 @@ where
         Ok(None)
     }
 
-    pub fn finalize(self) -> CountingWriter<BufWriter<W>> {
+    pub fn finish(self) -> CountingWriter<BufWriter<W>> {
         self.write
     }
 }
 
 pub struct DeltaReader<'a, TValueReader> {
     common_prefix_len: usize,
-    suffix_start: usize,
-    suffix_end: usize,
+    suffix_range: Range<usize>,
     value_reader: TValueReader,
     block_reader: BlockReader<'a>,
     idx: usize,
@@ -105,13 +108,16 @@ where TValueReader: value::ValueReader
         DeltaReader {
             idx: 0,
             common_prefix_len: 0,
-            suffix_start: 0,
-            suffix_end: 0,
+            suffix_range: 0..0,
             value_reader: TValueReader::default(),
             block_reader: BlockReader::new(Box::new(reader)),
         }
     }
 
+    pub fn empty() -> Self {
+        DeltaReader::new(&b""[..])
+    }
+
     fn deserialize_vint(&mut self) -> u64 {
         self.block_reader.deserialize_u64()
     }
@@ -140,15 +146,14 @@ where TValueReader: value::ValueReader
     }
 
     fn read_delta_key(&mut self) -> bool {
-        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
-        }
+        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
     }
 
     pub fn advance(&mut self) -> io::Result<bool> {
@@ -156,7 +161,8 @@ where TValueReader: value::ValueReader
             if !self.block_reader.read_block()? {
                 return Ok(false);
             }
-            self.value_reader.read(&mut self.block_reader)?;
+            let consumed_len = self.value_reader.load(self.block_reader.buffer())?;
+            self.block_reader.advance(consumed_len);
             self.idx = 0;
         } else {
             self.idx += 1;
@@ -167,16 +173,30 @@ 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_start, self.suffix_end)
+        self.block_reader.buffer_from_to(self.suffix_range.clone())
     }
 
+    #[inline(always)]
     pub fn value(&self) -> &TValueReader::Value {
         self.value_reader.value(self.idx)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DeltaReader;
+    use crate::value::U64MonotonicValueReader;
+
+    #[test]
+    fn test_empty() {
+        let mut delta_reader: DeltaReader<U64MonotonicValueReader> = DeltaReader::empty();
+        assert!(!delta_reader.advance().unwrap());
+    }
+}

sstable/src/dictionary.rs

@@ -0,0 +1,261 @@
+use std::io;
+use std::marker::PhantomData;
+use std::ops::{Bound, RangeBounds};
+use std::sync::Arc;
+
+use common::file_slice::FileSlice;
+use common::{BinarySerializable, OwnedBytes};
+use tantivy_fst::automaton::AlwaysMatch;
+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 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)
+pub struct Dictionary<TSSTable: SSTable> {
+    pub sstable_slice: FileSlice,
+    pub sstable_index: SSTableIndex,
+    num_terms: u64,
+    phantom_data: PhantomData<TSSTable>,
+}
+
+impl<TSSTable: SSTable> Dictionary<TSSTable> {
+    pub fn builder<W: io::Write>(wrt: W) -> io::Result<crate::Writer<W, TSSTable::ValueWriter>> {
+        Ok(TSSTable::writer(wrt))
+    }
+
+    pub(crate) fn sstable_reader(&self) -> io::Result<Reader<'static, TSSTable::ValueReader>> {
+        let data = self.sstable_slice.read_bytes()?;
+        Ok(TSSTable::reader(data))
+    }
+
+    pub(crate) fn sstable_reader_block(
+        &self,
+        block_addr: BlockAddr,
+    ) -> io::Result<Reader<'static, TSSTable::ValueReader>> {
+        let data = self.sstable_slice.read_bytes_slice(block_addr.byte_range)?;
+        Ok(TSSTable::reader(data))
+    }
+
+    pub(crate) async fn sstable_reader_block_async(
+        &self,
+        block_addr: BlockAddr,
+    ) -> io::Result<Reader<'static, TSSTable::ValueReader>> {
+        let data = self
+            .sstable_slice
+            .read_bytes_slice_async(block_addr.byte_range)
+            .await?;
+        Ok(TSSTable::reader(data))
+    }
+
+    pub(crate) fn sstable_delta_reader_for_key_range(
+        &self,
+        key_range: impl RangeBounds<[u8]>,
+    ) -> io::Result<DeltaReader<'static, TSSTable::ValueReader>> {
+        let slice = self.file_slice_for_range(key_range);
+        let data = slice.read_bytes()?;
+        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) => {
+                let Some(first_block_addr) = self.sstable_index.search_block(key) else {
+                    return FileSlice::empty();
+                };
+                Bound::Included(first_block_addr.byte_range.start)
+            }
+            Bound::Unbounded => Bound::Unbounded,
+        };
+        let end_bound: Bound<usize> = match key_range.end_bound() {
+            Bound::Included(key) | Bound::Excluded(key) => {
+                if let Some(block_addr) = self.sstable_index.search_block(key) {
+                    Bound::Excluded(block_addr.byte_range.end)
+                } else {
+                    Bound::Unbounded
+                }
+            }
+            Bound::Unbounded => Bound::Unbounded,
+        };
+        self.sstable_slice.slice((start_bound, end_bound))
+    }
+
+    /// Opens a `TermDictionary`.
+    pub fn open(term_dictionary_file: FileSlice) -> io::Result<Self> {
+        let (main_slice, footer_len_slice) = term_dictionary_file.split_from_end(16);
+        let mut footer_len_bytes: OwnedBytes = footer_len_slice.read_bytes()?;
+        let index_offset = u64::deserialize(&mut footer_len_bytes)?;
+        let num_terms = u64::deserialize(&mut footer_len_bytes)?;
+        let (sstable_slice, index_slice) = main_slice.split(index_offset as usize);
+        let sstable_index_bytes = index_slice.read_bytes()?;
+        let sstable_index = SSTableIndex::load(sstable_index_bytes.as_slice())
+            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "SSTable corruption"))?;
+        Ok(Dictionary {
+            sstable_slice,
+            sstable_index,
+            num_terms,
+            phantom_data: PhantomData,
+        })
+    }
+
+    /// Creates a term dictionary from the supplied bytes.
+    pub fn from_bytes(owned_bytes: OwnedBytes) -> io::Result<Self> {
+        Dictionary::open(FileSlice::new(Arc::new(owned_bytes)))
+    }
+
+    /// Creates an empty term dictionary which contains no terms.
+    pub fn empty() -> Self {
+        let term_dictionary_data: Vec<u8> = Self::builder(Vec::<u8>::new())
+            .expect("Creating a TermDictionaryBuilder in a Vec<u8> should never fail")
+            .finish()
+            .expect("Writing in a Vec<u8> should never fail");
+        let empty_dict_file = FileSlice::from(term_dictionary_data);
+        Dictionary::open(empty_dict_file).unwrap()
+    }
+
+    /// Returns the number of terms in the dictionary.
+    /// Term ordinals range from 0 to `num_terms() - 1`.
+    pub fn num_terms(&self) -> usize {
+        self.num_terms as usize
+    }
+
+    /// Returns the ordinal associated with a given term.
+    pub fn term_ord<K: AsRef<[u8]>>(&self, key: K) -> io::Result<Option<TermOrdinal>> {
+        let mut term_ord = 0u64;
+        let key_bytes = key.as_ref();
+        let mut sstable_reader = self.sstable_reader()?;
+        while sstable_reader.advance().unwrap_or(false) {
+            if sstable_reader.key() == key_bytes {
+                return Ok(Some(term_ord));
+            }
+            term_ord += 1;
+        }
+        Ok(None)
+    }
+
+    /// Returns the term associated with a given term ordinal.
+    ///
+    /// Term ordinals are defined as the position of the term in
+    /// the sorted list of terms.
+    ///
+    /// Returns true if and only if the term has been found.
+    ///
+    /// Regardless of whether the term is found or not,
+    /// the buffer may be modified.
+    pub fn ord_to_term(&self, ord: TermOrdinal, bytes: &mut Vec<u8>) -> io::Result<bool> {
+        let mut sstable_reader = self.sstable_reader()?;
+        bytes.clear();
+        for _ in 0..(ord + 1) {
+            if !sstable_reader.advance().unwrap_or(false) {
+                return Ok(false);
+            }
+        }
+        bytes.extend_from_slice(sstable_reader.key());
+        Ok(true)
+    }
+
+    /// Returns the number of terms in the dictionary.
+    pub fn term_info_from_ord(&self, term_ord: TermOrdinal) -> io::Result<Option<TSSTable::Value>> {
+        let mut sstable_reader = self.sstable_reader()?;
+        for _ in 0..(term_ord + 1) {
+            if !sstable_reader.advance().unwrap_or(false) {
+                return Ok(None);
+            }
+        }
+        Ok(Some(sstable_reader.value().clone()))
+    }
+
+    /// Lookups the value corresponding to the key.
+    pub fn get<K: AsRef<[u8]>>(&self, key: K) -> io::Result<Option<TSSTable::Value>> {
+        if let Some(block_addr) = self.sstable_index.search_block(key.as_ref()) {
+            let mut sstable_reader = self.sstable_reader_block(block_addr)?;
+            let key_bytes = key.as_ref();
+            while sstable_reader.advance().unwrap_or(false) {
+                if sstable_reader.key() == key_bytes {
+                    let value = sstable_reader.value().clone();
+                    return Ok(Some(value));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// Lookups the value corresponding to the key.
+    pub async fn get_async<K: AsRef<[u8]>>(&self, key: K) -> io::Result<Option<TSSTable::Value>> {
+        if let Some(block_addr) = self.sstable_index.search_block(key.as_ref()) {
+            let mut sstable_reader = self.sstable_reader_block_async(block_addr).await?;
+            let key_bytes = key.as_ref();
+            while sstable_reader.advance().unwrap_or(false) {
+                if sstable_reader.key() == key_bytes {
+                    let value = sstable_reader.value().clone();
+                    return Ok(Some(value));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// Returns a range builder, to stream all of the terms
+    /// within an interval.
+    pub fn range(&self) -> StreamerBuilder<'_, TSSTable> {
+        StreamerBuilder::new(self, AlwaysMatch)
+    }
+
+    /// A stream of all the sorted terms.
+    pub fn stream(&self) -> io::Result<Streamer<'_, TSSTable>> {
+        self.range().into_stream()
+    }
+
+    /// Returns a search builder, to stream all of the terms
+    /// within the Automaton
+    pub fn search<'a, A: Automaton + 'a>(
+        &'a self,
+        automaton: A,
+    ) -> StreamerBuilder<'a, TSSTable, A>
+    where
+        A::State: Clone,
+    {
+        StreamerBuilder::<TSSTable, A>::new(self, automaton)
+    }
+
+    #[doc(hidden)]
+    pub async fn warm_up_dictionary(&self) -> io::Result<()> {
+        self.sstable_slice.read_bytes_async().await?;
+        Ok(())
+    }
+}

sstable/src/lib.rs

@@ -1,24 +1,34 @@
 use std::io::{self, Write};
+use std::ops::Range;
 use std::usize;
 
 use merge::ValueMerger;
 
 mod delta;
+mod dictionary;
 pub mod merge;
+mod streamer;
 pub mod value;
 
 mod sstable_index;
 pub use sstable_index::{BlockAddr, SSTableIndex, SSTableIndexBuilder};
 pub(crate) mod vint;
+pub use dictionary::Dictionary;
+pub use streamer::{Streamer, StreamerBuilder};
 
 mod block_reader;
 pub use self::block_reader::BlockReader;
 pub use self::delta::{DeltaReader, DeltaWriter};
 pub use self::merge::VoidMerge;
-use self::value::{U64MonotonicReader, U64MonotonicWriter, ValueReader, ValueWriter};
+use self::value::{U64MonotonicValueReader, U64MonotonicValueWriter, ValueReader, ValueWriter};
+use crate::value::{RangeValueReader, RangeValueWriter};
+
+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()
@@ -30,36 +40,37 @@ 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;
-    type Reader: ValueReader<Value = Self::Value>;
-    type Writer: ValueWriter<Value = Self::Value>;
+    type Value: Clone;
+    type ValueReader: ValueReader<Value = Self::Value>;
+    type ValueWriter: ValueWriter<Value = Self::Value>;
 
-    fn delta_writer<W: io::Write>(write: W) -> DeltaWriter<W, Self::Writer> {
+    fn delta_writer<W: io::Write>(write: W) -> DeltaWriter<W, Self::ValueWriter> {
         DeltaWriter::new(write)
     }
 
-    fn writer<W: io::Write>(write: W) -> Writer<W, Self::Writer> {
-        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 writer<W: io::Write>(wrt: W) -> Writer<W, Self::ValueWriter> {
+        Writer::new(wrt)
     }
 
-    fn delta_reader<'a, R: io::Read + 'a>(reader: R) -> DeltaReader<'a, Self::Reader> {
+    fn delta_reader<'a, R: io::Read + 'a>(reader: R) -> DeltaReader<'a, Self::ValueReader> {
         DeltaReader::new(reader)
     }
 
-    fn reader<'a, R: io::Read + 'a>(reader: R) -> Reader<'a, Self::Reader> {
+    fn reader<'a, R: io::Read + 'a>(reader: R) -> Reader<'a, Self::ValueReader> {
         Reader {
             key: Vec::with_capacity(DEFAULT_KEY_CAPACITY),
             delta_reader: Self::delta_reader(reader),
         }
     }
 
+    /// Returns an empty static reader.
+    fn create_empty_reader() -> Reader<'static, Self::ValueReader> {
+        Self::reader(&b""[..])
+    }
+
     fn merge<R: io::Read, W: io::Write, M: ValueMerger<Self::Value>>(
         io_readers: Vec<R>,
         w: W,
@@ -76,21 +87,47 @@ pub struct VoidSSTable;
 
 impl SSTable for VoidSSTable {
     type Value = ();
-    type Reader = value::VoidReader;
-    type Writer = value::VoidWriter;
+    type ValueReader = value::VoidValueReader;
+    type ValueWriter = value::VoidValueWriter;
 }
 
+/// 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 SSTableMonotonicU64;
+pub struct MonotonicU64SSTable;
 
-impl SSTable for SSTableMonotonicU64 {
+impl SSTable for MonotonicU64SSTable {
     type Value = u64;
 
-    type Reader = U64MonotonicReader;
+    type ValueReader = U64MonotonicValueReader;
 
-    type Writer = U64MonotonicWriter;
+    type ValueWriter = U64MonotonicValueWriter;
 }
 
+/// 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;
+
+impl SSTable for RangeSSTable {
+    type Value = Range<u64>;
+
+    type ValueReader = RangeValueReader;
+
+    type ValueWriter = RangeValueWriter;
+}
+
+/// SSTable reader.
 pub struct Reader<'a, TValueReader> {
     key: Vec<u8>,
     delta_reader: DeltaReader<'a, TValueReader>,
@@ -111,16 +148,19 @@ 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
     }
@@ -141,11 +181,56 @@ where
     W: io::Write,
     TValueWriter: value::ValueWriter,
 {
-    pub(crate) fn current_key(&self) -> &[u8] {
+    /// 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 {
+            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] {
         &self.previous_key[..]
     }
 
-    pub fn write_key(&mut self, key: &[u8]) {
+    /// 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
         // shorten the last term in the last block.
         if self.first_ordinal_of_the_block == self.num_terms {
@@ -165,16 +250,15 @@ where
         self.previous_key.resize(key.len(), 0u8);
         self.previous_key[keep_len..].copy_from_slice(&key[keep_len..]);
         self.delta_writer.write_suffix(keep_len, &key[keep_len..]);
-    }
-
-    #[allow(dead_code)]
-    pub fn write(&mut self, key: &[u8], value: &TValueWriter::Value) -> io::Result<()> {
-        self.write_key(key);
-        self.write_value(value)?;
         Ok(())
     }
 
-    pub fn write_value(&mut self, value: &TValueWriter::Value) -> io::Result<()> {
+    /// # Warning
+    ///
+    /// Horribly dangerous internal API. See `.insert(...)`.
+    #[doc(hidden)]
+    #[inline]
+    pub fn insert_value(&mut self, value: &TValueWriter::Value) -> io::Result<()> {
         self.delta_writer.write_value(value);
         self.num_terms += 1u64;
         self.flush_block_if_required()
@@ -193,7 +277,7 @@ where
         Ok(())
     }
 
-    pub fn finalize(mut self) -> io::Result<W> {
+    pub fn finish(mut self) -> io::Result<W> {
         if let Some(byte_range) = self.delta_writer.flush_block()? {
             self.index_builder.add_block(
                 &self.previous_key[..],
@@ -202,7 +286,7 @@ where
             );
             self.first_ordinal_of_the_block = self.num_terms;
         }
-        let mut wrt = self.delta_writer.finalize();
+        let mut wrt = self.delta_writer.finish();
         wrt.write_all(&0u32.to_le_bytes())?;
 
         let offset = wrt.written_bytes();
@@ -214,11 +298,23 @@ 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, SSTable, SSTableMonotonicU64, VoidMerge, VoidSSTable};
+    use super::{common_prefix_len, MonotonicU64SSTable, SSTable, VoidMerge, VoidSSTable};
 
     fn aux_test_common_prefix_len(left: &str, right: &str, expect_len: usize) {
         assert_eq!(
@@ -246,10 +342,10 @@ mod test {
         let mut buffer = vec![];
         {
             let mut sstable_writer = VoidSSTable::writer(&mut buffer);
-            assert!(sstable_writer.write(&long_key[..], &()).is_ok());
-            assert!(sstable_writer.write(&[0, 3, 4], &()).is_ok());
-            assert!(sstable_writer.write(&long_key2[..], &()).is_ok());
-            assert!(sstable_writer.finalize().is_ok());
+            assert!(sstable_writer.insert(&long_key[..], &()).is_ok());
+            assert!(sstable_writer.insert(&[0, 3, 4], &()).is_ok());
+            assert!(sstable_writer.insert(&long_key2[..], &()).is_ok());
+            assert!(sstable_writer.finish().is_ok());
         }
         let mut sstable_reader = VoidSSTable::reader(&buffer[..]);
         assert!(sstable_reader.advance().unwrap());
@@ -266,10 +362,10 @@ mod test {
         let mut buffer = vec![];
         {
             let mut sstable_writer = VoidSSTable::writer(&mut buffer);
-            assert!(sstable_writer.write(&[17u8], &()).is_ok());
-            assert!(sstable_writer.write(&[17u8, 18u8, 19u8], &()).is_ok());
-            assert!(sstable_writer.write(&[17u8, 20u8], &()).is_ok());
-            assert!(sstable_writer.finalize().is_ok());
+            assert!(sstable_writer.insert(&[17u8], &()).is_ok());
+            assert!(sstable_writer.insert(&[17u8, 18u8, 19u8], &()).is_ok());
+            assert!(sstable_writer.insert(&[17u8, 20u8], &()).is_ok());
+            assert!(sstable_writer.finish().is_ok());
         }
         assert_eq!(
             &buffer,
@@ -304,8 +400,8 @@ mod test {
     fn test_simple_sstable_non_increasing_key() {
         let mut buffer = vec![];
         let mut sstable_writer = VoidSSTable::writer(&mut buffer);
-        assert!(sstable_writer.write(&[17u8], &()).is_ok());
-        assert!(sstable_writer.write(&[16u8], &()).is_ok());
+        assert!(sstable_writer.insert(&[17u8], &()).is_ok());
+        assert!(sstable_writer.insert(&[16u8], &()).is_ok());
     }
 
     #[test]
@@ -313,9 +409,9 @@ mod test {
         let mut buffer = Vec::new();
         {
             let mut writer = VoidSSTable::writer(&mut buffer);
-            writer.write(b"abcd", &()).unwrap();
-            writer.write(b"abe", &()).unwrap();
-            writer.finalize().unwrap();
+            writer.insert(b"abcd", &()).unwrap();
+            writer.insert(b"abe", &()).unwrap();
+            writer.finish().unwrap();
         }
         let mut output = Vec::new();
         assert!(VoidSSTable::merge(vec![&buffer[..], &buffer[..]], &mut output, VoidMerge).is_ok());
@@ -327,9 +423,12 @@ mod test {
         let mut buffer = Vec::new();
         {
             let mut writer = VoidSSTable::writer(&mut buffer);
-            writer.write(b"abcd", &()).unwrap();
-            writer.write(b"abe", &()).unwrap();
-            writer.finalize().unwrap();
+            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();
         assert!(VoidSSTable::merge(vec![&buffer[..], &buffer[..]], &mut output, VoidMerge).is_ok());
@@ -339,12 +438,12 @@ mod test {
     #[test]
     fn test_sstable_u64() -> io::Result<()> {
         let mut buffer = Vec::new();
-        let mut writer = SSTableMonotonicU64::writer(&mut buffer);
-        writer.write(b"abcd", &1u64)?;
-        writer.write(b"abe", &4u64)?;
-        writer.write(b"gogo", &4324234234234234u64)?;
-        writer.finalize()?;
-        let mut reader = SSTableMonotonicU64::reader(&buffer[..]);
+        let mut writer = MonotonicU64SSTable::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[..]);
         assert!(reader.advance()?);
         assert_eq!(reader.key(), b"abcd");
         assert_eq!(reader.value(), &1u64);
@@ -357,4 +456,75 @@ mod test {
         assert!(!reader.advance()?);
         Ok(())
     }
+
+    #[test]
+    fn test_sstable_empty() {
+        let mut sstable_range_empty = crate::RangeSSTable::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

@@ -28,11 +28,11 @@ impl<B: AsRef<[u8]>> PartialEq for HeapItem<B> {
 
 #[allow(dead_code)]
 pub fn merge_sstable<SST: SSTable, W: io::Write, M: ValueMerger<SST::Value>>(
-    readers: Vec<Reader<SST::Reader>>,
-    mut writer: Writer<W, SST::Writer>,
+    readers: Vec<Reader<SST::ValueReader>>,
+    mut writer: Writer<W, SST::ValueWriter>,
     mut merger: M,
 ) -> io::Result<()> {
-    let mut heap: BinaryHeap<HeapItem<Reader<SST::Reader>>> =
+    let mut heap: BinaryHeap<HeapItem<Reader<SST::ValueReader>>> =
         BinaryHeap::with_capacity(readers.len());
     for mut reader in readers {
         if reader.advance()? {
@@ -43,7 +43,7 @@ pub fn merge_sstable<SST: SSTable, W: io::Write, M: ValueMerger<SST::Value>>(
         let len = heap.len();
         let mut value_merger;
         if let Some(mut head) = heap.peek_mut() {
-            writer.write_key(head.0.key());
+            writer.insert_key(head.0.key()).unwrap();
             value_merger = merger.new_value(head.0.value());
             if !head.0.advance()? {
                 PeekMut::pop(head);
@@ -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.current_key() {
+                if head.0.key() == writer.last_inserted_key() {
                     value_merger.add(head.0.value());
                     if !head.0.advance()? {
                         PeekMut::pop(head);
@@ -64,9 +64,9 @@ pub fn merge_sstable<SST: SSTable, W: io::Write, M: ValueMerger<SST::Value>>(
             break;
         }
         let value = value_merger.finish();
-        writer.write_value(&value)?;
+        writer.insert_value(&value)?;
         writer.flush_block_if_required()?;
     }
-    writer.finalize()?;
+    writer.finish()?;
     Ok(())
 }

sstable/src/merge/mod.rs

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

sstable/src/sstable_index.rs

@@ -15,7 +15,7 @@ impl SSTableIndex {
         ciborium::de::from_reader(data).map_err(|_| SSTableDataCorruption)
     }
 
-    pub fn search(&self, key: &[u8]) -> Option<BlockAddr> {
+    pub fn search_block(&self, key: &[u8]) -> Option<BlockAddr> {
         self.blocks
             .iter()
             .find(|block| &block.last_key_or_greater[..] >= key)
@@ -105,7 +105,7 @@ mod tests {
         sstable_builder.serialize(&mut buffer).unwrap();
         let sstable_index = SSTableIndex::load(&buffer[..]).unwrap();
         assert_eq!(
-            sstable_index.search(b"bbbde"),
+            sstable_index.search_block(b"bbbde"),
             Some(BlockAddr {
                 first_ordinal: 10u64,
                 byte_range: 30..40

sstable/src/streamer.rs

@@ -4,31 +4,39 @@ use std::ops::Bound;
 use tantivy_fst::automaton::AlwaysMatch;
 use tantivy_fst::Automaton;
 
-use super::TermDictionary;
-use crate::postings::TermInfo;
-use crate::termdict::sstable_termdict::TermInfoReader;
-use crate::termdict::TermOrdinal;
+use crate::dictionary::Dictionary;
+use crate::{SSTable, TermOrdinal};
 
-/// `TermStreamerBuilder` is a helper object used to define
+/// `StreamerBuilder` is a helper object used to define
 /// a range of terms that should be streamed.
-pub struct TermStreamerBuilder<'a, A = AlwaysMatch>
+pub struct StreamerBuilder<'a, TSSTable, A = AlwaysMatch>
 where
     A: Automaton,
     A::State: Clone,
+    TSSTable: SSTable,
 {
-    term_dict: &'a TermDictionary,
+    term_dict: &'a Dictionary<TSSTable>,
     automaton: A,
     lower: Bound<Vec<u8>>,
     upper: Bound<Vec<u8>>,
 }
 
-impl<'a, A> TermStreamerBuilder<'a, A>
+fn bound_as_byte_slice(bound: &Bound<Vec<u8>>) -> Bound<&[u8]> {
+    match bound.as_ref() {
+        Bound::Included(key) => Bound::Included(key.as_slice()),
+        Bound::Excluded(key) => Bound::Excluded(key.as_slice()),
+        Bound::Unbounded => Bound::Unbounded,
+    }
+}
+
+impl<'a, TSSTable, A> StreamerBuilder<'a, TSSTable, A>
 where
     A: Automaton,
     A::State: Clone,
+    TSSTable: SSTable,
 {
-    pub(crate) fn new(term_dict: &'a TermDictionary, automaton: A) -> Self {
-        TermStreamerBuilder {
+    pub(crate) fn new(term_dict: &'a Dictionary<TSSTable>, automaton: A) -> Self {
+        StreamerBuilder {
             term_dict,
             automaton,
             lower: Bound::Unbounded,
@@ -61,12 +69,18 @@ where
     }
 
     /// Creates the stream corresponding to the range
-    /// of terms defined using the `TermStreamerBuilder`.
-    pub fn into_stream(self) -> io::Result<TermStreamer<'a, A>> {
+    /// of terms defined using the `StreamerBuilder`.
+    pub fn into_stream(self) -> io::Result<Streamer<'a, TSSTable, A>> {
         // TODO Optimize by skipping to the right first block.
         let start_state = self.automaton.start();
-        let delta_reader = self.term_dict.sstable_delta_reader()?;
-        Ok(TermStreamer {
+        let key_range = (
+            bound_as_byte_slice(&self.lower),
+            bound_as_byte_slice(&self.upper),
+        );
+        let delta_reader = self
+            .term_dict
+            .sstable_delta_reader_for_key_range(key_range)?;
+        Ok(Streamer {
             automaton: self.automaton,
             states: vec![start_state],
             delta_reader,
@@ -78,26 +92,28 @@ where
     }
 }
 
-/// `TermStreamer` acts as a cursor over a range of terms of a segment.
+/// `Streamer` acts as a cursor over a range of terms of a segment.
 /// Terms are guaranteed to be sorted.
-pub struct TermStreamer<'a, A = AlwaysMatch>
+pub struct Streamer<'a, TSSTable, A = AlwaysMatch>
 where
     A: Automaton,
     A::State: Clone,
+    TSSTable: SSTable,
 {
     automaton: A,
     states: Vec<A::State>,
-    delta_reader: sstable::DeltaReader<'a, TermInfoReader>,
+    delta_reader: crate::DeltaReader<'a, TSSTable::ValueReader>,
     key: Vec<u8>,
     term_ord: Option<TermOrdinal>,
     lower_bound: Bound<Vec<u8>>,
     upper_bound: Bound<Vec<u8>>,
 }
 
-impl<'a, A> TermStreamer<'a, A>
+impl<'a, TSSTable, A> Streamer<'a, TSSTable, A>
 where
     A: Automaton,
     A::State: Clone,
+    TSSTable: SSTable,
 {
     /// Advance position the stream on the next item.
     /// Before the first call to `.advance()`, the stream
@@ -174,13 +190,13 @@ where
     ///
     /// Calling `.value()` before the first call to `.advance()` returns
     /// `V::default()`.
-    pub fn value(&self) -> &TermInfo {
+    pub fn value(&self) -> &TSSTable::Value {
         self.delta_reader.value()
     }
 
     /// Return the next `(key, value)` pair.
     #[allow(clippy::should_implement_trait)]
-    pub fn next(&mut self) -> Option<(&[u8], &TermInfo)> {
+    pub fn next(&mut self) -> Option<(&[u8], &TSSTable::Value)> {
         if self.advance() {
             Some((self.key(), self.value()))
         } else {
@@ -191,60 +207,54 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::super::TermDictionary;
-    use crate::directory::OwnedBytes;
-    use crate::postings::TermInfo;
+    use std::io;
 
-    fn make_term_info(i: usize) -> TermInfo {
-        TermInfo {
-            doc_freq: 1000u32 + i as u32,
-            postings_range: (i + 10) * (i * 10)..((i + 1) + 10) * ((i + 1) * 10),
-            positions_range: i * 500..(i + 1) * 500,
-        }
-    }
+    use common::OwnedBytes;
 
-    fn create_test_term_dictionary() -> crate::Result<TermDictionary> {
-        let mut term_dict_builder = super::super::TermDictionaryBuilder::create(Vec::new())?;
-        term_dict_builder.insert(b"abaisance", &make_term_info(0))?;
-        term_dict_builder.insert(b"abalation", &make_term_info(1))?;
-        term_dict_builder.insert(b"abalienate", &make_term_info(2))?;
-        term_dict_builder.insert(b"abandon", &make_term_info(3))?;
-        let buffer = term_dict_builder.finish()?;
+    use crate::{Dictionary, MonotonicU64SSTable};
+
+    fn create_test_dictionary() -> io::Result<Dictionary<MonotonicU64SSTable>> {
+        let mut dict_builder = Dictionary::<MonotonicU64SSTable>::builder(Vec::new())?;
+        dict_builder.insert(b"abaisance", &0)?;
+        dict_builder.insert(b"abalation", &1)?;
+        dict_builder.insert(b"abalienate", &2)?;
+        dict_builder.insert(b"abandon", &3)?;
+        let buffer = dict_builder.finish()?;
         let owned_bytes = OwnedBytes::new(buffer);
-        TermDictionary::from_bytes(owned_bytes)
+        Dictionary::from_bytes(owned_bytes)
     }
 
     #[test]
-    fn test_sstable_stream() -> crate::Result<()> {
-        let term_dict = create_test_term_dictionary()?;
-        let mut term_streamer = term_dict.stream()?;
-        assert!(term_streamer.advance());
-        assert_eq!(term_streamer.key(), b"abaisance");
-        assert_eq!(term_streamer.value().doc_freq, 1000u32);
-        assert!(term_streamer.advance());
-        assert_eq!(term_streamer.key(), b"abalation");
-        assert_eq!(term_streamer.value().doc_freq, 1001u32);
-        assert!(term_streamer.advance());
-        assert_eq!(term_streamer.key(), b"abalienate");
-        assert_eq!(term_streamer.value().doc_freq, 1002u32);
-        assert!(term_streamer.advance());
-        assert_eq!(term_streamer.key(), b"abandon");
-        assert_eq!(term_streamer.value().doc_freq, 1003u32);
-        assert!(!term_streamer.advance());
+    fn test_sstable_stream() -> io::Result<()> {
+        let dict = create_test_dictionary()?;
+        let mut streamer = dict.stream()?;
+        assert!(streamer.advance());
+        assert_eq!(streamer.key(), b"abaisance");
+        assert_eq!(streamer.value(), &0);
+        assert!(streamer.advance());
+        assert_eq!(streamer.key(), b"abalation");
+        assert_eq!(streamer.value(), &1);
+        assert!(streamer.advance());
+        assert_eq!(streamer.key(), b"abalienate");
+        assert_eq!(streamer.value(), &2);
+        assert!(streamer.advance());
+        assert_eq!(streamer.key(), b"abandon");
+        assert_eq!(streamer.value(), &3);
+        assert!(!streamer.advance());
         Ok(())
     }
 
     #[test]
-    fn test_sstable_search() -> crate::Result<()> {
-        let term_dict = create_test_term_dictionary()?;
+    fn test_sstable_search() -> io::Result<()> {
+        let term_dict = create_test_dictionary()?;
         let ptn = tantivy_fst::Regex::new("ab.*t.*").unwrap();
         let mut term_streamer = term_dict.search(ptn).into_stream()?;
         assert!(term_streamer.advance());
         assert_eq!(term_streamer.key(), b"abalation");
-        assert_eq!(term_streamer.value().doc_freq, 1001u32);
+        assert_eq!(term_streamer.value(), &1u64);
         assert!(term_streamer.advance());
         assert_eq!(term_streamer.key(), b"abalienate");
-        assert_eq!(term_streamer.value().doc_freq, 1002u32);
+        assert_eq!(term_streamer.value(), &2u64);
         assert!(!term_streamer.advance());
         Ok(())
     }

sstable/src/value.rs

@@ -1,95 +0,0 @@
-use std::io;
-
-use super::{vint, BlockReader};
-
-pub trait ValueReader: Default {
-    type Value;
-
-    fn value(&self, idx: usize) -> &Self::Value;
-
-    fn read(&mut self, reader: &mut BlockReader) -> io::Result<()>;
-}
-
-pub trait ValueWriter: Default {
-    type Value;
-
-    fn write(&mut self, val: &Self::Value);
-
-    fn write_block(&mut self, writer: &mut Vec<u8>);
-}
-
-#[derive(Default)]
-pub struct VoidReader;
-
-impl ValueReader for VoidReader {
-    type Value = ();
-
-    fn value(&self, _idx: usize) -> &() {
-        &()
-    }
-
-    fn read(&mut self, _reader: &mut BlockReader) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[derive(Default)]
-pub struct VoidWriter;
-
-impl ValueWriter for VoidWriter {
-    type Value = ();
-
-    fn write(&mut self, _val: &()) {}
-
-    fn write_block(&mut self, _writer: &mut Vec<u8>) {}
-}
-
-#[derive(Default)]
-pub struct U64MonotonicWriter {
-    vals: Vec<u64>,
-}
-
-impl ValueWriter for U64MonotonicWriter {
-    type Value = u64;
-
-    fn write(&mut self, val: &Self::Value) {
-        self.vals.push(*val);
-    }
-
-    fn write_block(&mut self, writer: &mut Vec<u8>) {
-        let mut prev_val = 0u64;
-        vint::serialize_into_vec(self.vals.len() as u64, writer);
-        for &val in &self.vals {
-            let delta = val - prev_val;
-            vint::serialize_into_vec(delta, writer);
-            prev_val = val;
-        }
-        self.vals.clear();
-    }
-}
-
-#[derive(Default)]
-pub struct U64MonotonicReader {
-    vals: Vec<u64>,
-}
-
-impl ValueReader for U64MonotonicReader {
-    type Value = u64;
-
-    fn value(&self, idx: usize) -> &Self::Value {
-        &self.vals[idx]
-    }
-
-    fn read(&mut self, reader: &mut BlockReader) -> io::Result<()> {
-        let len = reader.deserialize_u64() as usize;
-        self.vals.clear();
-        let mut prev_val = 0u64;
-        for _ in 0..len {
-            let delta = reader.deserialize_u64();
-            let val = prev_val + delta;
-            self.vals.push(val);
-            prev_val = val;
-        }
-        Ok(())
-    }
-}

sstable/src/value/mod.rs

@@ -0,0 +1,82 @@
+mod range;
+mod u64_monotonic;
+mod void;
+
+use std::io;
+
+/// `ValueReader` is a trait describing the contract of something
+/// reading blocks of value, and offering random access within this values.
+pub trait ValueReader: Default {
+    /// Type of the value being read.
+    type Value;
+
+    /// Access the value at index `idx`, in the last block that was read
+    /// via a call to `ValueReader::read`.
+    fn value(&self, idx: usize) -> &Self::Value;
+
+    /// Loads a block.
+    ///
+    /// Returns the number of bytes that were written.
+    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`.
+    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);
+}
+
+pub use range::{RangeValueReader, RangeValueWriter};
+pub use u64_monotonic::{U64MonotonicValueReader, U64MonotonicValueWriter};
+pub use void::{VoidValueReader, VoidValueWriter};
+
+fn deserialize_vint_u64(data: &mut &[u8]) -> u64 {
+    let (num_bytes, val) = super::vint::deserialize_read(data);
+    *data = &data[num_bytes..];
+    val
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use std::fmt;
+
+    use super::{ValueReader, ValueWriter};
+
+    pub(crate) fn test_value_reader_writer<
+        V: Eq + fmt::Debug,
+        TReader: ValueReader<Value = V>,
+        TWriter: ValueWriter<Value = V>,
+    >(
+        value_block: &[V],
+    ) {
+        let mut buffer = Vec::new();
+        {
+            let mut writer = TWriter::default();
+            for value in value_block {
+                writer.write(value);
+            }
+            writer.serialize_block(&mut buffer);
+            writer.clear();
+        }
+        let data_len = buffer.len();
+        buffer.extend_from_slice(&b"extradata"[..]);
+        let mut reader = TReader::default();
+        assert_eq!(reader.load(&buffer[..]).unwrap(), data_len);
+        for (i, val) in value_block.iter().enumerate() {
+            assert_eq!(reader.value(i), val);
+        }
+    }
+}

sstable/src/value/range.rs

@@ -0,0 +1,113 @@
+use std::io;
+use std::ops::Range;
+
+use crate::value::{deserialize_vint_u64, ValueReader, ValueWriter};
+
+/// See module comment.
+#[derive(Default)]
+pub struct RangeValueReader {
+    vals: Vec<Range<u64>>,
+}
+
+impl ValueReader for RangeValueReader {
+    type Value = Range<u64>;
+
+    #[inline(always)]
+    fn value(&self, idx: usize) -> &Range<u64> {
+        &self.vals[idx]
+    }
+
+    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;
+        if len != 0 {
+            let mut prev_val = deserialize_vint_u64(&mut data);
+            for _ in 1..len {
+                let next_val = prev_val + deserialize_vint_u64(&mut data);
+                self.vals.push(prev_val..next_val);
+                prev_val = next_val;
+            }
+        }
+        Ok(original_num_bytes - data.len())
+    }
+}
+
+/// 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 {
+    vals: Vec<u64>,
+}
+
+impl ValueWriter for RangeValueWriter {
+    type Value = Range<u64>;
+
+    fn write(&mut self, val: &Range<u64>) {
+        if let Some(previous_offset) = self.vals.last().copied() {
+            assert_eq!(previous_offset, val.start);
+            self.vals.push(val.end);
+        } else {
+            self.vals.push(val.start);
+            self.vals.push(val.end)
+        }
+    }
+
+    fn serialize_block(&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 {
+            let delta = val - prev_val;
+            crate::vint::serialize_into_vec(delta, writer);
+            prev_val = val;
+        }
+    }
+
+    fn clear(&mut self) {
+        self.vals.clear();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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>(&[
+            0..3,
+            3..10,
+        ]);
+        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+            0..0,
+            0..10,
+        ]);
+        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+            100..110,
+            110..121,
+            121..1250,
+        ]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_range_reader_writer_panics() {
+        crate::value::tests::test_value_reader_writer::<_, RangeValueReader, RangeValueWriter>(&[
+            1..3,
+            4..10,
+        ]);
+    }
+}

sstable/src/value/u64_monotonic.rs

@@ -0,0 +1,83 @@
+use std::io;
+
+use crate::value::{deserialize_vint_u64, ValueReader, ValueWriter};
+use crate::vint;
+
+#[derive(Default)]
+pub struct U64MonotonicValueReader {
+    vals: Vec<u64>,
+}
+
+impl ValueReader for U64MonotonicValueReader {
+    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;
+        self.vals.clear();
+        let mut prev_val = 0u64;
+        for _ in 0..num_vals {
+            let delta = deserialize_vint_u64(&mut data);
+            let val = prev_val + delta;
+            self.vals.push(val);
+            prev_val = val;
+        }
+        Ok(original_num_bytes - data.len())
+    }
+}
+
+#[derive(Default)]
+pub struct U64MonotonicValueWriter {
+    vals: Vec<u64>,
+}
+
+impl ValueWriter for U64MonotonicValueWriter {
+    type Value = u64;
+
+    fn write(&mut self, val: &Self::Value) {
+        self.vals.push(*val);
+    }
+
+    fn serialize_block(&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 {
+            let delta = val - prev_val;
+            vint::serialize_into_vec(delta, output);
+            prev_val = val;
+        }
+    }
+
+    fn clear(&mut self) {
+        self.vals.clear();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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]);
+    }
+}

sstable/src/value/void.rs

@@ -0,0 +1,48 @@
+use std::io;
+
+use crate::value::{ValueReader, ValueWriter};
+
+#[derive(Default)]
+pub struct VoidValueReader;
+
+impl ValueReader for VoidValueReader {
+    type Value = ();
+
+    #[inline(always)]
+    fn value(&self, _idx: usize) -> &() {
+        &()
+    }
+
+    fn load(&mut self, _data: &[u8]) -> io::Result<usize> {
+        Ok(0)
+    }
+}
+
+#[derive(Default)]
+pub struct VoidValueWriter;
+
+impl ValueWriter for VoidValueWriter {
+    type Value = ();
+
+    fn write(&mut self, _val: &()) {}
+
+    fn serialize_block(&self, _output: &mut Vec<u8>) {}
+
+    fn clear(&mut self) {}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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>(&[
+            (),
+            (),
+            (),
+        ]);
+    }
+}

stacker/Cargo.toml

@@ -2,8 +2,9 @@
 name = "tantivy-stacker"
 version = "0.1.0"
 edition = "2021"
+license = "MIT"
 
 [dependencies]
 murmurhash32 = "0.2"
 byteorder = "1"
-common = { version = "0.4", path = "../common/", package = "tantivy-common" }
+common = { version = "0.5", path = "../common/", package = "tantivy-common" }