Removing Deserializer trait

And renaming the `Serializer` trait `FastFieldCodec`.

ARCHITECTURE.md

@@ -95,7 +95,7 @@ called [`Directory`](src/directory/directory.rs).
 Contrary to Lucene however, "files" are quite different from some kind of `io::Read` object.
 Check out [`src/directory/directory.rs`](src/directory/directory.rs) trait for more details.
 
-Tantivy ships two main directory implementation: the `MmapDirectory` and the `RamDirectory`,
+Tantivy ships two main directory implementation: the `MMapDirectory` and the `RAMDirectory`,
 but users can extend tantivy with their own implementation.
 
 ## [schema/](src/schema): What are documents?

Cargo.toml

@@ -30,7 +30,7 @@ log = "0.4.16"
 serde = { version = "1.0.136", features = ["derive"] }
 serde_json = "1.0.79"
 num_cpus = "1.13.1"
-fs2 = { version = "0.4.3", optional = true }
+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"
@@ -56,6 +56,7 @@ lru = "0.7.5"
 fastdivide = "0.4.0"
 itertools = "0.10.3"
 measure_time = "0.8.2"
+pretty_assertions = "1.2.1"
 serde_cbor = { version = "0.11.2", optional = true }
 async-trait = "0.1.53"
 arc-swap = "1.5.0"
@@ -67,7 +68,6 @@ winapi = "0.3.9"
 rand = "0.8.5"
 maplit = "1.0.2"
 matches = "0.1.9"
-pretty_assertions = "1.2.1"
 proptest = "1.0.0"
 criterion = "0.3.5"
 test-log = "0.2.10"

README.md

@@ -127,7 +127,6 @@ $ gdb run
 # Companies Using Tantivy
 
 <p align="left">
-<img align="center" src="doc/assets/images/etsy.png" alt="Etsy" height="25" width="auto" />&nbsp;
 <img align="center" src="doc/assets/images/Nuclia.png#gh-light-mode-only" alt="Nuclia" height="25" width="auto" /> &nbsp;
 <img align="center" src="doc/assets/images/humanfirst.png#gh-light-mode-only" alt="Humanfirst.ai" height="30" width="auto" />
 <img align="center" src="doc/assets/images/element.io.svg#gh-light-mode-only" alt="Element.io" height="25" width="auto" />

common/src/lib.rs

@@ -11,10 +11,7 @@ mod writer;
 
 pub use bitset::*;
 pub use serialize::{BinarySerializable, DeserializeFrom, FixedSize};
-pub use vint::{
+pub use vint::{read_u32_vint, read_u32_vint_no_advance, serialize_vint_u32, write_u32_vint, VInt};
-    deserialize_vint_u128, read_u32_vint, read_u32_vint_no_advance, serialize_vint_u128,
-    serialize_vint_u32, write_u32_vint, VInt, VIntU128,
-};
 pub use writer::{AntiCallToken, CountingWriter, TerminatingWrite};
 
 /// Has length trait
@@ -55,13 +52,13 @@ const HIGHEST_BIT: u64 = 1 << 63;
 /// to values over 2^63, and all values end up requiring 64 bits.
 ///
 /// # See also
-/// The reverse mapping is [`u64_to_i64()`].
+/// The [reverse mapping is `u64_to_i64`](./fn.u64_to_i64.html).
 #[inline]
 pub fn i64_to_u64(val: i64) -> u64 {
     (val as u64) ^ HIGHEST_BIT
 }
 
-/// Reverse the mapping given by [`i64_to_u64()`].
+/// Reverse the mapping given by [`i64_to_u64`](./fn.i64_to_u64.html).
 #[inline]
 pub fn u64_to_i64(val: u64) -> i64 {
     (val ^ HIGHEST_BIT) as i64
@@ -83,7 +80,7 @@ pub fn u64_to_i64(val: u64) -> i64 {
 /// explains the mapping in a clear manner.
 ///
 /// # See also
-/// The reverse mapping is [`u64_to_f64()`].
+/// The [reverse mapping is `u64_to_f64`](./fn.u64_to_f64.html).
 #[inline]
 pub fn f64_to_u64(val: f64) -> u64 {
     let bits = val.to_bits();
@@ -94,7 +91,7 @@ pub fn f64_to_u64(val: f64) -> u64 {
     }
 }
 
-/// Reverse the mapping given by [`f64_to_u64()`].
+/// Reverse the mapping given by [`i64_to_u64`](./fn.i64_to_u64.html).
 #[inline]
 pub fn u64_to_f64(val: u64) -> f64 {
     f64::from_bits(if val & HIGHEST_BIT != 0 {

common/src/vint.rs

@@ -5,75 +5,6 @@ use byteorder::{ByteOrder, LittleEndian};
 
 use super::BinarySerializable;
 
-/// Variable int serializes a u128 number
-pub fn serialize_vint_u128(mut val: u128, output: &mut Vec<u8>) {
-    loop {
-        let next_byte: u8 = (val % 128u128) as u8;
-        val /= 128u128;
-        if val == 0 {
-            output.push(next_byte | STOP_BIT);
-            return;
-        } else {
-            output.push(next_byte);
-        }
-    }
-}
-
-/// Deserializes a u128 number
-///
-/// Returns the number and the slice after the vint
-pub fn deserialize_vint_u128(data: &[u8]) -> io::Result<(u128, &[u8])> {
-    let mut result = 0u128;
-    let mut shift = 0u64;
-    for i in 0..19 {
-        let b = data[i];
-        result |= u128::from(b % 128u8) << shift;
-        if b >= STOP_BIT {
-            return Ok((result, &data[i + 1..]));
-        }
-        shift += 7;
-    }
-    Err(io::Error::new(
-        io::ErrorKind::InvalidData,
-        "Failed to deserialize u128 vint",
-    ))
-}
-
-///   Wrapper over a `u128` that serializes as a variable int.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct VIntU128(pub u128);
-
-impl BinarySerializable for VIntU128 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
-        let mut buffer = vec![];
-        serialize_vint_u128(self.0, &mut buffer);
-        writer.write_all(&buffer)
-    }
-
-    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        let mut bytes = reader.bytes();
-        let mut result = 0u128;
-        let mut shift = 0u64;
-        loop {
-            match bytes.next() {
-                Some(Ok(b)) => {
-                    result |= u128::from(b % 128u8) << shift;
-                    if b >= STOP_BIT {
-                        return Ok(VIntU128(result));
-                    }
-                    shift += 7;
-                }
-                _ => {
-                    return Err(io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        "Reach end of buffer while reading VInt",
-                    ));
-                }
-            }
-        }
-    }
-}
-
 ///   Wrapper over a `u64` that serializes as a variable int.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct VInt(pub u64);
@@ -245,7 +176,6 @@ impl BinarySerializable for VInt {
 mod tests {
 
     use super::{serialize_vint_u32, BinarySerializable, VInt};
-    use crate::vint::{deserialize_vint_u128, serialize_vint_u128, VIntU128};
 
     fn aux_test_vint(val: u64) {
         let mut v = [14u8; 10];
@@ -287,26 +217,6 @@ mod tests {
         assert_eq!(&buffer[..len_vint], res2, "array wrong for {}", val);
     }
 
-    fn aux_test_vint_u128(val: u128) {
-        let mut data = vec![];
-        serialize_vint_u128(val, &mut data);
-        let (deser_val, _data) = deserialize_vint_u128(&data).unwrap();
-        assert_eq!(val, deser_val);
-
-        let mut out = vec![];
-        VIntU128(val).serialize(&mut out).unwrap();
-        let deser_val = VIntU128::deserialize(&mut &out[..]).unwrap();
-        assert_eq!(val, deser_val.0);
-    }
-
-    #[test]
-    fn test_vint_u128() {
-        aux_test_vint_u128(0);
-        aux_test_vint_u128(1);
-        aux_test_vint_u128(u128::MAX / 3);
-        aux_test_vint_u128(u128::MAX);
-    }
-
     #[test]
     fn test_vint_u32() {
         aux_test_serialize_vint_u32(0);

common/src/writer.rs

@@ -55,14 +55,14 @@ impl<W: TerminatingWrite> TerminatingWrite for CountingWriter<W> {
 }
 
 /// Struct used to prevent from calling
-/// [`terminate_ref`](TerminatingWrite::terminate_ref) directly
+/// [`terminate_ref`](trait.TerminatingWrite.html#tymethod.terminate_ref) directly
 ///
 /// The point is that while the type is public, it cannot be built by anyone
 /// outside of this module.
 pub struct AntiCallToken(());
 
 /// Trait used to indicate when no more write need to be done on a writer
-pub trait TerminatingWrite: Write + Send + Sync {
+pub trait TerminatingWrite: Write + Send {
     /// Indicate that the writer will no longer be used. Internally call terminate_ref.
     fn terminate(mut self) -> io::Result<()>
     where Self: Sized {

examples/custom_collector.rs

@@ -7,12 +7,10 @@
 // Of course, you can have a look at the tantivy's built-in collectors
 // such as the `CountCollector` for more examples.
 
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
 // ---
 // Importing tantivy...
 use tantivy::collector::{Collector, SegmentCollector};
+use tantivy::fastfield::{DynamicFastFieldReader, FastFieldReader};
 use tantivy::query::QueryParser;
 use tantivy::schema::{Field, Schema, FAST, INDEXED, TEXT};
 use tantivy::{doc, Index, Score, SegmentReader};
@@ -97,7 +95,7 @@ impl Collector for StatsCollector {
 }
 
 struct StatsSegmentCollector {
-    fast_field_reader: Arc<dyn Column<u64>>,
+    fast_field_reader: DynamicFastFieldReader<u64>,
     stats: Stats,
 }
 
@@ -105,7 +103,7 @@ impl SegmentCollector for StatsSegmentCollector {
     type Fruit = Option<Stats>;
 
     fn collect(&mut self, doc: u32, _score: Score) {
-        let value = self.fast_field_reader.get_val(doc as u64) as f64;
+        let value = self.fast_field_reader.get(doc) as f64;
         self.stats.count += 1;
         self.stats.sum += value;
         self.stats.squared_sum += value * value;

examples/custom_tokenizer.rs

@@ -36,7 +36,8 @@ fn main() -> tantivy::Result<()> {
     // need to be able to be able to retrieve it
     // for our application.
     //
-    // We can make our index lighter by omitting the `STORED` flag.
+    // We can make our index lighter and
+    // by omitting `STORED` flag.
     let body = schema_builder.add_text_field("body", TEXT);
 
     let schema = schema_builder.build();

examples/warmer.rs

@@ -3,6 +3,7 @@ use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, RwLock, Weak};
 
 use tantivy::collector::TopDocs;
+use tantivy::fastfield::FastFieldReader;
 use tantivy::query::QueryParser;
 use tantivy::schema::{Field, Schema, FAST, TEXT};
 use tantivy::{
@@ -51,7 +52,7 @@ impl Warmer for DynamicPriceColumn {
             let product_id_reader = segment.fast_fields().u64(self.field)?;
             let product_ids: Vec<ProductId> = segment
                 .doc_ids_alive()
-                .map(|doc| product_id_reader.get_val(doc as u64))
+                .map(|doc| product_id_reader.get(doc))
                 .collect();
             let mut prices_it = self.price_fetcher.fetch_prices(&product_ids).into_iter();
             let mut price_vals: Vec<Price> = Vec::new();

fastfield_codecs/Cargo.toml

@@ -14,10 +14,6 @@ tantivy-bitpacker = { version="0.2", path = "../bitpacker/" }
 ownedbytes = { version = "0.3.0", path = "../ownedbytes" }
 prettytable-rs = {version="0.9.0", optional= true}
 rand = {version="0.8.3", optional= true}
-fastdivide = "0.4"
-log = "0.4"
-itertools = { version = "0.10.3" }
-measure_time = { version="0.8.2", optional=true}
 
 [dev-dependencies]
 more-asserts = "0.3.0"
@@ -25,7 +21,6 @@ proptest = "1.0.0"
 rand = "0.8.3"
 
 [features]
-bin = ["prettytable-rs", "rand", "measure_time"]
+bin = ["prettytable-rs", "rand"]
 default = ["bin"]
-unstable = []
 

fastfield_codecs/benches/bench.rs

@@ -4,222 +4,88 @@ extern crate test;
 
 #[cfg(test)]
 mod tests {
-    use std::iter;
+    use fastfield_codecs::bitpacked::BitpackedCodec;
-    use std::sync::Arc;
+    use fastfield_codecs::blockwise_linear::BlockwiseLinearCodec;
-
+    use fastfield_codecs::linear::LinearCodec;
     use fastfield_codecs::*;
-    use ownedbytes::OwnedBytes;
-    use rand::prelude::*;
-    use test::Bencher;
 
-    use super::*;
+    fn get_data() -> Vec<u64> {
-
+        let mut data: Vec<_> = (100..55000_u64)
-    // Warning: this generates the same permutation at each call
+            .map(|num| num + rand::random::<u8>() as u64)
-    fn generate_permutation() -> Vec<u64> {
-        let mut permutation: Vec<u64> = (0u64..100_000u64).collect();
-        permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
-        permutation
-    }
-
-    fn generate_random() -> Vec<u64> {
-        let mut permutation: Vec<u64> = (0u64..100_000u64)
-            .map(|el| el + random::<u16>() as u64)
             .collect();
-        permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
+        data.push(99_000);
-        permutation
+        data.insert(1000, 2000);
-    }
+        data.insert(2000, 100);
-
+        data.insert(3000, 4100);
-    // Warning: this generates the same permutation at each call
+        data.insert(4000, 100);
-    fn generate_permutation_gcd() -> Vec<u64> {
+        data.insert(5000, 800);
-        let mut permutation: Vec<u64> = (1u64..100_000u64).map(|el| el * 1000).collect();
-        permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
-        permutation
-    }
-
-    pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default>(
-        column: &[T],
-    ) -> Arc<dyn Column<T>> {
-        let mut buffer = Vec::new();
-        serialize(VecColumn::from(&column), &mut buffer, &ALL_CODEC_TYPES).unwrap();
-        open(OwnedBytes::new(buffer)).unwrap()
-    }
-
-    #[bench]
-    fn bench_intfastfield_jumpy_veclookup(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        b.iter(|| {
-            let mut a = 0u64;
-            for _ in 0..n {
-                a = permutation[a as usize];
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_jumpy_fflookup(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for _ in 0..n {
-                a = column.get_val(a as u64);
-            }
-            a
-        });
-    }
-
-    fn get_exp_data() -> Vec<u64> {
-        let mut data = vec![];
-        for i in 0..100 {
-            let num = i * i;
-            data.extend(iter::repeat(i as u64).take(num));
-        }
-        data.shuffle(&mut StdRng::from_seed([1u8; 32]));
-
-        // lengt = 328350
         data
     }
 
-    fn get_data_50percent_item() -> (u128, u128, Vec<u128>) {
+    fn value_iter() -> impl Iterator<Item = u64> {
-        let mut permutation = get_exp_data();
+        0..20_000
-        let major_item = 20;
-        let minor_item = 10;
-        permutation.extend(iter::repeat(major_item).take(permutation.len()));
-        permutation.shuffle(&mut StdRng::from_seed([1u8; 32]));
-        let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
-        (major_item as u128, minor_item as u128, permutation)
     }
-    fn get_u128_column_random() -> Arc<dyn Column<u128>> {
+    fn bench_get<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
-        let permutation = generate_random();
+        let mut bytes = vec![];
-        let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
+        Codec::serialize(&mut bytes, &data).unwrap();
-        get_u128_column_from_data(&permutation)
+        let reader = Codec::open_from_bytes(OwnedBytes::new(bytes)).unwrap();
-    }
-
-    fn get_u128_column_from_data(data: &[u128]) -> Arc<dyn Column<u128>> {
-        let mut out = vec![];
-        serialize_u128(VecColumn::from(&data), &mut out).unwrap();
-        let out = OwnedBytes::new(out);
-        open_u128(out).unwrap()
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
-        let (major_item, _minor_item, data) = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| column.get_between_vals(major_item..=major_item));
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
-        let (_major_item, minor_item, data) = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| column.get_between_vals(minor_item..=minor_item));
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
-        let (_major_item, _minor_item, data) = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| column.get_between_vals(0..=u128::MAX));
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {
-        let column = get_u128_column_random();
-
         b.iter(|| {
-            let mut a = 0u128;
+            let mut sum = 0u64;
-            for i in 0u64..column.num_vals() as u64 {
+            for pos in value_iter() {
-                a += column.get_val(i);
+                let val = reader.get_val(pos as u64);
+                debug_assert_eq!(data[pos as usize], val);
+                sum = sum.wrapping_add(val);
             }
-            a
+            sum
+        });
+    }
+    fn bench_create<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
+        let mut bytes = Vec::new();
+        b.iter(|| {
+            bytes.clear();
+            Codec::serialize(&mut bytes, &data).unwrap();
         });
     }
 
+    use ownedbytes::OwnedBytes;
+    use test::Bencher;
     #[bench]
-    fn bench_intfastfield_jumpy_stride5_u128(b: &mut Bencher) {
+    fn bench_fastfield_bitpack_create(b: &mut Bencher) {
-        let column = get_u128_column_random();
+        let data: Vec<_> = get_data();
-
+        bench_create::<BitpackedCodec>(b, &data);
-        b.iter(|| {
-            let n = column.num_vals();
-            let mut a = 0u128;
-            for i in (0..n / 5).map(|val| val * 5) {
-                a += column.get_val(i as u64);
-            }
-            a
-        });
     }
-
     #[bench]
-    fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
+    fn bench_fastfield_linearinterpol_create(b: &mut Bencher) {
-        let permutation = generate_permutation();
+        let data: Vec<_> = get_data();
-        let n = permutation.len();
+        bench_create::<LinearCodec>(b, &data);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in (0..n / 7).map(|val| val * 7) {
-                a += permutation[i as usize];
-            }
-            a
-        });
     }
-
     #[bench]
-    fn bench_intfastfield_stride7_fflookup(b: &mut Bencher) {
+    fn bench_fastfield_multilinearinterpol_create(b: &mut Bencher) {
-        let permutation = generate_permutation();
+        let data: Vec<_> = get_data();
-        let n = permutation.len();
+        bench_create::<BlockwiseLinearCodec>(b, &data);
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in (0..n / 7).map(|val| val * 7) {
-                a += column.get_val(i as u64);
-            }
-            a
-        });
     }
-
     #[bench]
-    fn bench_intfastfield_scan_all_fflookup(b: &mut Bencher) {
+    fn bench_fastfield_bitpack_get(b: &mut Bencher) {
-        let permutation = generate_permutation();
+        let data: Vec<_> = get_data();
-        let n = permutation.len();
+        bench_get::<BitpackedCodec>(b, &data);
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0u64..n as u64 {
-                a += column.get_val(i);
-            }
-            a
-        });
     }
-
     #[bench]
-    fn bench_intfastfield_scan_all_fflookup_gcd(b: &mut Bencher) {
+    fn bench_fastfield_linearinterpol_get(b: &mut Bencher) {
-        let permutation = generate_permutation_gcd();
+        let data: Vec<_> = get_data();
-        let n = permutation.len();
+        bench_get::<LinearCodec>(b, &data);
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0..n as u64 {
-                a += column.get_val(i);
-            }
-            a
-        });
     }
-
     #[bench]
-    fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
+    fn bench_fastfield_multilinearinterpol_get(b: &mut Bencher) {
-        let permutation = generate_permutation();
+        let data: Vec<_> = get_data();
-        b.iter(|| {
+        bench_get::<BlockwiseLinearCodec>(b, &data);
-            let mut a = 0u64;
+    }
-            for i in 0..permutation.len() {
+    pub fn stats_from_vec(data: &[u64]) -> FastFieldStats {
-                a += permutation[i as usize] as u64;
+        let min_value = data.iter().cloned().min().unwrap_or(0);
-            }
+        let max_value = data.iter().cloned().max().unwrap_or(0);
-            a
+        FastFieldStats {
-        });
+            min_value,
+            max_value,
+            num_vals: data.len() as u64,
+        }
     }
 }

fastfield_codecs/src/bitpacked.rs

@@ -1,10 +1,10 @@
 use std::io::{self, Write};
 
+use common::BinarySerializable;
 use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use crate::serialize::NormalizedHeader;
+use crate::{FastFieldCodec, FastFieldCodecType, FastFieldDataAccess};
-use crate::{Column, FastFieldCodec, FastFieldCodecType};
 
 /// Depending on the field type, a different
 /// fast field is required.
@@ -12,26 +12,80 @@ use crate::{Column, FastFieldCodec, FastFieldCodecType};
 pub struct BitpackedReader {
     data: OwnedBytes,
     bit_unpacker: BitUnpacker,
-    normalized_header: NormalizedHeader,
+    min_value_u64: u64,
+    max_value_u64: u64,
+    num_vals: u64,
 }
 
-impl Column for BitpackedReader {
+impl FastFieldDataAccess for BitpackedReader {
     #[inline]
     fn get_val(&self, doc: u64) -> u64 {
-        self.bit_unpacker.get(doc, &self.data)
+        self.min_value_u64 + self.bit_unpacker.get(doc, &self.data)
     }
     #[inline]
     fn min_value(&self) -> u64 {
-        // The BitpackedReader assumes a normalized vector.
+        self.min_value_u64
-        0
     }
     #[inline]
     fn max_value(&self) -> u64 {
-        self.normalized_header.max_value
+        self.max_value_u64
     }
     #[inline]
     fn num_vals(&self) -> u64 {
-        self.normalized_header.num_vals
+        self.num_vals
+    }
+}
+pub struct BitpackedSerializerLegacy<'a, W: 'a + Write> {
+    bit_packer: BitPacker,
+    write: &'a mut W,
+    min_value: u64,
+    num_vals: u64,
+    amplitude: u64,
+    num_bits: u8,
+}
+
+impl<'a, W: Write> BitpackedSerializerLegacy<'a, W> {
+    /// Creates a new fast field serializer.
+    ///
+    /// The serializer in fact encode the values by bitpacking
+    /// `(val - min_value)`.
+    ///
+    /// It requires a `min_value` and a `max_value` to compute
+    /// compute the minimum number of bits required to encode
+    /// values.
+    pub fn open(
+        write: &'a mut W,
+        min_value: u64,
+        max_value: u64,
+    ) -> io::Result<BitpackedSerializerLegacy<'a, W>> {
+        assert!(min_value <= max_value);
+        let amplitude = max_value - min_value;
+        let num_bits = compute_num_bits(amplitude);
+        let bit_packer = BitPacker::new();
+        Ok(BitpackedSerializerLegacy {
+            bit_packer,
+            write,
+            min_value,
+            num_vals: 0,
+            amplitude,
+            num_bits,
+        })
+    }
+    /// Pushes a new value to the currently open u64 fast field.
+    #[inline]
+    pub fn add_val(&mut self, val: u64) -> io::Result<()> {
+        let val_to_write: u64 = val - self.min_value;
+        self.bit_packer
+            .write(val_to_write, self.num_bits, &mut self.write)?;
+        self.num_vals += 1;
+        Ok(())
+    }
+    pub fn close_field(mut self) -> io::Result<()> {
+        self.bit_packer.close(&mut self.write)?;
+        self.min_value.serialize(&mut self.write)?;
+        self.amplitude.serialize(&mut self.write)?;
+        self.num_vals.serialize(&mut self.write)?;
+        Ok(())
     }
 }
 
@@ -44,50 +98,64 @@ impl FastFieldCodec for BitpackedCodec {
     type Reader = BitpackedReader;
 
     /// Opens a fast field given a file.
-    fn open_from_bytes(
+    fn open_from_bytes(bytes: OwnedBytes) -> io::Result<Self::Reader> {
-        data: OwnedBytes,
+        let footer_offset = bytes.len() - 24;
-        normalized_header: NormalizedHeader,
+        let (data, mut footer) = bytes.split(footer_offset);
-    ) -> io::Result<Self::Reader> {
+        let min_value = u64::deserialize(&mut footer)?;
-        let num_bits = compute_num_bits(normalized_header.max_value);
+        let amplitude = u64::deserialize(&mut footer)?;
+        let num_vals = u64::deserialize(&mut footer)?;
+        let max_value = min_value + amplitude;
+        let num_bits = compute_num_bits(amplitude);
         let bit_unpacker = BitUnpacker::new(num_bits);
         Ok(BitpackedReader {
             data,
             bit_unpacker,
-            normalized_header,
+            min_value_u64: min_value,
+            max_value_u64: max_value,
+            num_vals,
         })
     }
 
     /// Serializes data with the BitpackedFastFieldSerializer.
     ///
-    /// The bitpacker assumes that the column has been normalized.
+    /// The serializer in fact encode the values by bitpacking
-    /// i.e. It has already been shifted by its minimum value, so that its
+    /// `(val - min_value)`.
-    /// current minimum value is 0.
     ///
-    /// Ideally, we made a shift upstream on the column so that `col.min_value() == 0`.
+    /// It requires a `min_value` and a `max_value` to compute
-    fn serialize(column: &dyn Column, write: &mut impl Write) -> io::Result<()> {
+    /// compute the minimum number of bits required to encode
-        assert_eq!(column.min_value(), 0u64);
+    /// values.
-        let num_bits = compute_num_bits(column.max_value());
+    fn serialize(
-        let mut bit_packer = BitPacker::new();
+        write: &mut impl Write,
-        let mut reader = column.reader();
+        fastfield_accessor: &dyn FastFieldDataAccess,
-        while reader.advance() {
+    ) -> io::Result<()> {
-            let val = reader.get();
+        let mut serializer = BitpackedSerializerLegacy::open(
-            bit_packer.write(val, num_bits, write)?;
+            write,
+            fastfield_accessor.min_value(),
+            fastfield_accessor.max_value(),
+        )?;
+
+        for val in fastfield_accessor.iter() {
+            serializer.add_val(val)?;
         }
-        bit_packer.close(write)?;
+        serializer.close_field()?;
+
         Ok(())
     }
-
+    fn is_applicable(_fastfield_accessor: &impl FastFieldDataAccess) -> bool {
-    fn estimate(column: &impl Column) -> Option<f32> {
+        true
-        let num_bits = compute_num_bits(column.max_value());
+    }
+    fn estimate(fastfield_accessor: &impl FastFieldDataAccess) -> f32 {
+        let amplitude = fastfield_accessor.max_value() - fastfield_accessor.min_value();
+        let num_bits = compute_num_bits(amplitude);
         let num_bits_uncompressed = 64;
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
+        num_bits as f32 / num_bits_uncompressed as f32
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tests::get_codec_test_datasets;
+    use crate::tests::get_codec_test_data_sets;
 
     fn create_and_validate(data: &[u64], name: &str) {
         crate::tests::create_and_validate::<BitpackedCodec>(data, name);
@@ -95,7 +163,7 @@ mod tests {
 
     #[test]
     fn test_with_codec_data_sets() {
-        let data_sets = get_codec_test_datasets();
+        let data_sets = get_codec_test_data_sets();
         for (mut data, name) in data_sets {
             create_and_validate(&data, name);
             data.reverse();

fastfield_codecs/src/blockwise_linear.rs

@@ -1,188 +1,439 @@
-use std::sync::Arc;
+//! The BlockwiseLinear codec uses linear interpolation to guess a values and stores the
-use std::{io, iter};
+//! offset, but in blocks of 512.
+//!
+//! With a CHUNK_SIZE of 512 and 29 byte metadata per block, we get a overhead for metadata of 232 /
+//! 512 = 0,45 bits per element. The additional space required per element in a block is the the
+//! maximum deviation of the linear interpolation estimation function.
+//!
+//! E.g. if the maximum deviation of an element is 12, all elements cost 4bits.
+//!
+//! Size per block:
+//! Num Elements * Maximum Deviation from Interpolation + 29 Byte Metadata
+
+use std::io::{self, Read, Write};
+use std::ops::Sub;
 
 use common::{BinarySerializable, CountingWriter, DeserializeFrom};
 use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use crate::line::Line;
+use crate::linear::{get_calculated_value, get_slope};
-use crate::serialize::NormalizedHeader;
+use crate::{FastFieldCodec, FastFieldCodecType, FastFieldDataAccess};
-use crate::{Column, FastFieldCodec, FastFieldCodecType, VecColumn};
 
-const CHUNK_SIZE: usize = 512;
+const CHUNK_SIZE: u64 = 512;
 
-#[derive(Debug, Default)]
+/// Depending on the field type, a different
-struct Block {
+/// fast field is required.
-    line: Line,
+#[derive(Clone)]
-    bit_unpacker: BitUnpacker,
+pub struct BlockwiseLinearReader {
-    data_start_offset: usize,
+    data: OwnedBytes,
+    pub footer: BlockwiseLinearFooter,
 }
 
-impl BinarySerializable for Block {
+#[derive(Clone, Debug, Default)]
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+struct Function {
-        self.line.serialize(writer)?;
+    // The offset in the data is required, because we have different bit_widths per block
-        self.bit_unpacker.bit_width().serialize(writer)?;
+    data_start_offset: u64,
+    // start_pos in the block will be CHUNK_SIZE * BLOCK_NUM
+    start_pos: u64,
+    // only used during serialization, 0 after deserialization
+    end_pos: u64,
+    // only used during serialization, 0 after deserialization
+    value_start_pos: u64,
+    // only used during serialization, 0 after deserialization
+    value_end_pos: u64,
+    slope: f32,
+    // The offset so that all values are positive when writing them
+    positive_val_offset: u64,
+    num_bits: u8,
+    bit_unpacker: BitUnpacker,
+}
+
+impl Function {
+    fn calc_slope(&mut self) {
+        let num_vals = self.end_pos - self.start_pos;
+        self.slope = get_slope(self.value_start_pos, self.value_end_pos, num_vals);
+    }
+    // split the interpolation into two function, change self and return the second split
+    fn split(&mut self, split_pos: u64, split_pos_value: u64) -> Function {
+        let mut new_function = Function {
+            start_pos: split_pos,
+            end_pos: self.end_pos,
+            value_start_pos: split_pos_value,
+            value_end_pos: self.value_end_pos,
+            ..Default::default()
+        };
+        new_function.calc_slope();
+        self.end_pos = split_pos;
+        self.value_end_pos = split_pos_value;
+        self.calc_slope();
+        new_function
+    }
+}
+
+impl BinarySerializable for Function {
+    fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
+        self.data_start_offset.serialize(write)?;
+        self.value_start_pos.serialize(write)?;
+        self.positive_val_offset.serialize(write)?;
+        self.slope.serialize(write)?;
+        self.num_bits.serialize(write)?;
         Ok(())
     }
 
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Function> {
-        let line = Line::deserialize(reader)?;
+        let data_start_offset = u64::deserialize(reader)?;
-        let bit_width = u8::deserialize(reader)?;
+        let value_start_pos = u64::deserialize(reader)?;
-        Ok(Block {
+        let offset = u64::deserialize(reader)?;
-            line,
+        let slope = f32::deserialize(reader)?;
-            bit_unpacker: BitUnpacker::new(bit_width),
+        let num_bits = u8::deserialize(reader)?;
-            data_start_offset: 0,
+        let interpolation = Function {
-        })
+            data_start_offset,
+            value_start_pos,
+            positive_val_offset: offset,
+            num_bits,
+            bit_unpacker: BitUnpacker::new(num_bits),
+            slope,
+            ..Default::default()
+        };
+
+        Ok(interpolation)
     }
 }
 
-fn compute_num_blocks(num_vals: u64) -> usize {
+#[derive(Clone, Debug)]
-    (num_vals as usize + CHUNK_SIZE - 1) / CHUNK_SIZE
+pub struct BlockwiseLinearFooter {
+    pub num_vals: u64,
+    pub min_value: u64,
+    pub max_value: u64,
+    interpolations: Vec<Function>,
 }
 
+impl BinarySerializable for BlockwiseLinearFooter {
+    fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
+        let mut out = vec![];
+        self.num_vals.serialize(&mut out)?;
+        self.min_value.serialize(&mut out)?;
+        self.max_value.serialize(&mut out)?;
+        self.interpolations.serialize(&mut out)?;
+        write.write_all(&out)?;
+        (out.len() as u32).serialize(write)?;
+        Ok(())
+    }
+
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<BlockwiseLinearFooter> {
+        let mut footer = BlockwiseLinearFooter {
+            num_vals: u64::deserialize(reader)?,
+            min_value: u64::deserialize(reader)?,
+            max_value: u64::deserialize(reader)?,
+            interpolations: Vec::<Function>::deserialize(reader)?,
+        };
+        for (num, interpol) in footer.interpolations.iter_mut().enumerate() {
+            interpol.start_pos = CHUNK_SIZE * num as u64;
+        }
+        Ok(footer)
+    }
+}
+
+#[inline]
+fn get_interpolation_position(doc: u64) -> usize {
+    let index = doc / CHUNK_SIZE;
+    index as usize
+}
+
+#[inline]
+fn get_interpolation_function(doc: u64, interpolations: &[Function]) -> &Function {
+    &interpolations[get_interpolation_position(doc)]
+}
+
+impl FastFieldDataAccess for BlockwiseLinearReader {
+    #[inline]
+    fn get_val(&self, idx: u64) -> u64 {
+        let interpolation = get_interpolation_function(idx, &self.footer.interpolations);
+        let in_block_idx = idx - interpolation.start_pos;
+        let calculated_value = get_calculated_value(
+            interpolation.value_start_pos,
+            in_block_idx,
+            interpolation.slope,
+        );
+        let diff = interpolation.bit_unpacker.get(
+            in_block_idx,
+            &self.data[interpolation.data_start_offset as usize..],
+        );
+        (calculated_value + diff) - interpolation.positive_val_offset
+    }
+
+    #[inline]
+    fn min_value(&self) -> u64 {
+        self.footer.min_value
+    }
+    #[inline]
+    fn max_value(&self) -> u64 {
+        self.footer.max_value
+    }
+    #[inline]
+    fn num_vals(&self) -> u64 {
+        self.footer.num_vals
+    }
+}
+
+/// Same as LinearSerializer, but working on chunks of CHUNK_SIZE elements.
 pub struct BlockwiseLinearCodec;
 
 impl FastFieldCodec for BlockwiseLinearCodec {
-    const CODEC_TYPE: crate::FastFieldCodecType = FastFieldCodecType::BlockwiseLinear;
+    const CODEC_TYPE: FastFieldCodecType = FastFieldCodecType::BlockwiseLinear;
+
     type Reader = BlockwiseLinearReader;
 
-    fn open_from_bytes(
+    /// Opens a fast field given a file.
-        bytes: ownedbytes::OwnedBytes,
+    fn open_from_bytes(bytes: OwnedBytes) -> io::Result<Self::Reader> {
-        normalized_header: NormalizedHeader,
-    ) -> io::Result<Self::Reader> {
         let footer_len: u32 = (&bytes[bytes.len() - 4..]).deserialize()?;
         let footer_offset = bytes.len() - 4 - footer_len as usize;
         let (data, mut footer) = bytes.split(footer_offset);
-        let num_blocks = compute_num_blocks(normalized_header.num_vals);
+        let footer = BlockwiseLinearFooter::deserialize(&mut footer)?;
-        let mut blocks: Vec<Block> = iter::repeat_with(|| Block::deserialize(&mut footer))
+        Ok(BlockwiseLinearReader { data, footer })
-            .take(num_blocks)
-            .collect::<io::Result<_>>()?;
-
-        let mut start_offset = 0;
-        for block in &mut blocks {
-            block.data_start_offset = start_offset;
-            start_offset += (block.bit_unpacker.bit_width() as usize) * CHUNK_SIZE / 8;
-        }
-        Ok(BlockwiseLinearReader {
-            blocks: Arc::new(blocks),
-            data,
-            normalized_header,
-        })
     }
 
-    // Estimate first_chunk and extrapolate
+    /// Creates a new fast field serializer.
-    fn estimate(column: &impl crate::Column) -> Option<f32> {
+    fn serialize(
-        if column.num_vals() < 10 * CHUNK_SIZE as u64 {
+        write: &mut impl Write,
-            return None;
+        fastfield_accessor: &dyn FastFieldDataAccess,
+    ) -> io::Result<()> {
+        assert!(fastfield_accessor.min_value() <= fastfield_accessor.max_value());
+
+        let first_val = fastfield_accessor.get_val(0);
+        let last_val = fastfield_accessor.get_val(fastfield_accessor.num_vals() as u64 - 1);
+
+        let mut first_function = Function {
+            end_pos: fastfield_accessor.num_vals(),
+            value_start_pos: first_val,
+            value_end_pos: last_val,
+            ..Default::default()
+        };
+        first_function.calc_slope();
+        let mut interpolations = vec![first_function];
+
+        // Since we potentially apply multiple passes over the data, the data is cached.
+        // Multiple iteration can be expensive (merge with index sorting can add lot of overhead per
+        // iteration)
+        let data = fastfield_accessor.iter().collect::<Vec<_>>();
+
+        //// let's split this into chunks of CHUNK_SIZE
+        for data_pos in (0..data.len() as u64).step_by(CHUNK_SIZE as usize).skip(1) {
+            let new_fun = {
+                let current_interpolation = interpolations.last_mut().unwrap();
+                current_interpolation.split(data_pos, data[data_pos as usize])
+            };
+            interpolations.push(new_fun);
         }
-        let mut first_chunk: Vec<u64> = crate::iter_from_reader(column.reader())
+        // calculate offset and max (-> numbits) for each function
-            .take(CHUNK_SIZE as usize)
+        for interpolation in &mut interpolations {
-            .collect();
+            let mut offset = 0;
-        let line = Line::train(&VecColumn::from(&first_chunk));
+            let mut rel_positive_max = 0;
-        for (i, buffer_val) in first_chunk.iter_mut().enumerate() {
+            for (pos, actual_value) in data
-            let interpolated_val = line.eval(i as u64);
+                [interpolation.start_pos as usize..interpolation.end_pos as usize]
-            *buffer_val = buffer_val.wrapping_sub(interpolated_val);
+                .iter()
+                .cloned()
+                .enumerate()
+            {
+                let calculated_value = get_calculated_value(
+                    interpolation.value_start_pos,
+                    pos as u64,
+                    interpolation.slope,
+                );
+                if calculated_value > actual_value {
+                    // negative value we need to apply an offset
+                    // we ignore negative values in the max value calculation, because negative
+                    // values will be offset to 0
+                    offset = offset.max(calculated_value - actual_value);
+                } else {
+                    // positive value no offset reuqired
+                    rel_positive_max = rel_positive_max.max(actual_value - calculated_value);
+                }
+            }
+
+            interpolation.positive_val_offset = offset;
+            interpolation.num_bits = compute_num_bits(rel_positive_max + offset);
         }
-        let estimated_bit_width = first_chunk
+        let mut bit_packer = BitPacker::new();
+
+        let write = &mut CountingWriter::wrap(write);
+        for interpolation in &mut interpolations {
+            interpolation.data_start_offset = write.written_bytes();
+            let num_bits = interpolation.num_bits;
+            for (pos, actual_value) in data
+                [interpolation.start_pos as usize..interpolation.end_pos as usize]
+                .iter()
+                .cloned()
+                .enumerate()
+            {
+                let calculated_value = get_calculated_value(
+                    interpolation.value_start_pos,
+                    pos as u64,
+                    interpolation.slope,
+                );
+                let diff = (actual_value + interpolation.positive_val_offset) - calculated_value;
+                bit_packer.write(diff, num_bits, write)?;
+            }
+            bit_packer.flush(write)?;
+        }
+        bit_packer.close(write)?;
+
+        let footer = BlockwiseLinearFooter {
+            num_vals: fastfield_accessor.num_vals(),
+            min_value: fastfield_accessor.min_value(),
+            max_value: fastfield_accessor.max_value(),
+            interpolations,
+        };
+        footer.serialize(write)?;
+        Ok(())
+    }
+
+    fn is_applicable(fastfield_accessor: &impl FastFieldDataAccess) -> bool {
+        if fastfield_accessor.num_vals() < 5_000 {
+            return false;
+        }
+        // On serialization the offset is added to the actual value.
+        // We need to make sure this won't run into overflow calculation issues.
+        // For this we take the maximum theroretical offset and add this to the max value.
+        // If this doesn't overflow the algorithm should be fine
+        let theorethical_maximum_offset =
+            fastfield_accessor.max_value() - fastfield_accessor.min_value();
+        if fastfield_accessor
+            .max_value()
+            .checked_add(theorethical_maximum_offset)
+            .is_none()
+        {
+            return false;
+        }
+        true
+    }
+    /// estimation for linear interpolation is hard because, you don't know
+    /// where the local maxima are for the deviation of the calculated value and
+    /// the offset is also unknown.
+    fn estimate(fastfield_accessor: &impl FastFieldDataAccess) -> f32 {
+        let first_val_in_first_block = fastfield_accessor.get_val(0);
+        let last_elem_in_first_chunk = CHUNK_SIZE.min(fastfield_accessor.num_vals());
+        let last_val_in_first_block =
+            fastfield_accessor.get_val(last_elem_in_first_chunk as u64 - 1);
+        let slope = get_slope(
+            first_val_in_first_block,
+            last_val_in_first_block,
+            fastfield_accessor.num_vals(),
+        );
+
+        // let's sample at 0%, 5%, 10% .. 95%, 100%, but for the first block only
+        let sample_positions = (0..20)
+            .map(|pos| (last_elem_in_first_chunk as f32 / 100.0 * pos as f32 * 5.0) as usize)
+            .collect::<Vec<_>>();
+
+        let max_distance = sample_positions
             .iter()
-            .map(|el| ((el + 1) as f32 * 3.0) as u64)
+            .map(|pos| {
-            .map(compute_num_bits)
+                let calculated_value =
+                    get_calculated_value(first_val_in_first_block, *pos as u64, slope);
+                let actual_value = fastfield_accessor.get_val(*pos as u64);
+                distance(calculated_value, actual_value)
+            })
             .max()
             .unwrap();
 
-        let metadata_per_block = {
+        // Estimate one block and extrapolate the cost to all blocks.
-            let mut out = vec![];
+        // the theory would be that we don't have the actual max_distance, but we are close within
-            Block::default().serialize(&mut out).unwrap();
+        // 50% threshold.
-            out.len()
+        // It is multiplied by 2 because in a log case scenario the line would be as much above as
-        };
+        // below. So the offset would = max_distance
-        let num_bits = estimated_bit_width as u64 * column.num_vals() as u64
+        //
+        let relative_max_value = (max_distance as f32 * 1.5) * 2.0;
+
+        let num_bits = compute_num_bits(relative_max_value as u64) as u64 * fastfield_accessor.num_vals() as u64
             // function metadata per block
-            + metadata_per_block as u64 * (column.num_vals() / CHUNK_SIZE as u64);
+            + 29 * (fastfield_accessor.num_vals() / CHUNK_SIZE);
-        let num_bits_uncompressed = 64 * column.num_vals();
+        let num_bits_uncompressed = 64 * fastfield_accessor.num_vals();
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
+        num_bits as f32 / num_bits_uncompressed as f32
+    }
+}
+
+fn distance<T: Sub<Output = T> + Ord>(x: T, y: T) -> T {
+    if x < y {
+        y - x
+    } else {
+        x - y
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tests::get_codec_test_data_sets;
+
+    fn create_and_validate(data: &[u64], name: &str) -> (f32, f32) {
+        crate::tests::create_and_validate::<BlockwiseLinearCodec, BlockwiseLinearReader>(data, name)
     }
 
-    fn serialize(column: &dyn crate::Column, wrt: &mut impl io::Write) -> io::Result<()> {
+    const HIGHEST_BIT: u64 = 1 << 63;
-        // The BitpackedReader assumes a normalized vector.
+    pub fn i64_to_u64(val: i64) -> u64 {
-        assert_eq!(column.min_value(), 0);
+        (val as u64) ^ HIGHEST_BIT
-        let mut buffer = Vec::with_capacity(CHUNK_SIZE);
+    }
-        let num_vals = column.num_vals();
 
-        let num_blocks = compute_num_blocks(num_vals);
+    #[test]
-        let mut blocks = Vec::with_capacity(num_blocks);
+    fn test_compression_i64() {
+        let data = (i64::MAX - 600_000..=i64::MAX - 550_000)
+            .map(i64_to_u64)
+            .collect::<Vec<_>>();
+        let (estimate, actual_compression) =
+            create_and_validate(&data, "simple monotonically large i64");
+        assert!(actual_compression < 0.2);
+        assert!(estimate < 0.20);
+        assert!(estimate > 0.15);
+        assert!(actual_compression > 0.01);
+    }
 
-        let mut vals = crate::iter_from_reader(column.reader());
+    #[test]
+    fn test_compression() {
+        let data = (10..=6_000_u64).collect::<Vec<_>>();
+        let (estimate, actual_compression) =
+            create_and_validate(&data, "simple monotonically large");
+        assert!(actual_compression < 0.2);
+        assert!(estimate < 0.20);
+        assert!(estimate > 0.15);
+        assert!(actual_compression > 0.01);
+    }
 
-        let mut bit_packer = BitPacker::new();
+    #[test]
-
+    fn test_with_codec_data_sets() {
-        for _ in 0..num_blocks {
+        let data_sets = get_codec_test_data_sets();
-            buffer.clear();
+        for (mut data, name) in data_sets {
-            buffer.extend((&mut vals).take(CHUNK_SIZE));
+            create_and_validate(&data, name);
-            let line = Line::train(&VecColumn::from(&buffer));
+            data.reverse();
-
+            create_and_validate(&data, name);
-            assert!(!buffer.is_empty());
-
-            for (i, buffer_val) in buffer.iter_mut().enumerate() {
-                let interpolated_val = line.eval(i as u64);
-                *buffer_val = buffer_val.wrapping_sub(interpolated_val);
-            }
-            let bit_width = buffer.iter().copied().map(compute_num_bits).max().unwrap();
-
-            for &buffer_val in &buffer {
-                bit_packer.write(buffer_val, bit_width, wrt)?;
-            }
-
-            blocks.push(Block {
-                line,
-                bit_unpacker: BitUnpacker::new(bit_width),
-                data_start_offset: 0,
-            });
         }
+    }
+    #[test]
+    fn test_simple() {
+        let data = (10..=20_u64).collect::<Vec<_>>();
+        create_and_validate(&data, "simple monotonically");
+    }
 
-        bit_packer.close(wrt)?;
+    #[test]
-
+    fn border_cases_1() {
-        assert_eq!(blocks.len(), compute_num_blocks(num_vals));
+        let data = (0..1024).collect::<Vec<_>>();
-
+        create_and_validate(&data, "border case");
-        let mut counting_wrt = CountingWriter::wrap(wrt);
+    }
-        for block in &blocks {
+    #[test]
-            block.serialize(&mut counting_wrt)?;
+    fn border_case_2() {
+        let data = (0..1025).collect::<Vec<_>>();
+        create_and_validate(&data, "border case");
+    }
+    #[test]
+    fn rand() {
+        for _ in 0..10 {
+            let mut data = (5_000..20_000)
+                .map(|_| rand::random::<u32>() as u64)
+                .collect::<Vec<_>>();
+            let _ = create_and_validate(&data, "random");
+            data.reverse();
+            create_and_validate(&data, "random");
         }
-        let footer_len = counting_wrt.written_bytes();
-        (footer_len as u32).serialize(&mut counting_wrt)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-pub struct BlockwiseLinearReader {
-    blocks: Arc<Vec<Block>>,
-    normalized_header: NormalizedHeader,
-    data: OwnedBytes,
-}
-
-impl Column for BlockwiseLinearReader {
-    #[inline(always)]
-    fn get_val(&self, idx: u64) -> u64 {
-        let block_id = (idx / CHUNK_SIZE as u64) as usize;
-        let idx_within_block = idx % (CHUNK_SIZE as u64);
-        let block = &self.blocks[block_id];
-        let interpoled_val: u64 = block.line.eval(idx_within_block);
-        let block_bytes = &self.data[block.data_start_offset..];
-        let bitpacked_diff = block.bit_unpacker.get(idx_within_block, block_bytes);
-        interpoled_val.wrapping_add(bitpacked_diff)
-    }
-
-    fn min_value(&self) -> u64 {
-        // The BlockwiseLinearReader assumes a normalized vector.
-        0u64
-    }
-
-    fn max_value(&self) -> u64 {
-        self.normalized_header.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.normalized_header.num_vals
     }
 }

fastfield_codecs/src/column.rs

@@ -1,382 +0,0 @@
-use std::marker::PhantomData;
-use std::ops::RangeInclusive;
-
-use tantivy_bitpacker::minmax;
-
-pub trait Column<T: PartialOrd + Copy + 'static = u64>: Send + Sync {
-    /// Return a `ColumnReader`.
-    fn reader(&self) -> Box<dyn ColumnReader<T> + '_> {
-        // Box::new(ColumnReaderAdapter { column: self, idx: 0,  })
-        Box::new(ColumnReaderAdapter::from(self))
-    }
-
-    /// Return the value associated to the given idx.
-    ///
-    /// This accessor should return as fast as possible.
-    ///
-    /// # Panics
-    ///
-    /// May panic if `idx` is greater than the column length.
-    ///
-    /// TODO remove to force people to use `.reader()`.
-    fn get_val(&self, idx: u64) -> T;
-
-    /// Fills an output buffer with the fast field values
-    /// associated with the `DocId` going from
-    /// `start` to `start + output.len()`.
-    ///
-    /// # Panics
-    ///
-    /// Must panic if `start + output.len()` is greater than
-    /// the segment's `maxdoc`.
-    #[inline]
-    fn get_range(&self, start: u64, output: &mut [T]) {
-        for (out, idx) in output.iter_mut().zip(start..) {
-            *out = self.get_val(idx);
-        }
-    }
-
-    /// Return the positions of values which are in the provided range.
-    #[inline]
-    fn get_between_vals(&self, range: RangeInclusive<T>) -> Vec<u64> {
-        let mut vals = Vec::new();
-        for idx in 0..self.num_vals() {
-            let val = self.get_val(idx);
-            if range.contains(&val) {
-                vals.push(idx);
-            }
-        }
-        vals
-    }
-
-    /// Returns the minimum value for this fast field.
-    ///
-    /// This min_value may not be exact.
-    /// For instance, the min value does not take in account of possible
-    /// deleted document. All values are however guaranteed to be higher than
-    /// `.min_value()`.
-    fn min_value(&self) -> T;
-
-    /// Returns the maximum value for this fast field.
-    ///
-    /// This max_value may not be exact.
-    /// For instance, the max value does not take in account of possible
-    /// deleted document. All values are however guaranteed to be higher than
-    /// `.max_value()`.
-    fn max_value(&self) -> T;
-
-    fn num_vals(&self) -> u64;
-}
-
-/// `ColumnReader` makes it possible to read forward through a column.
-pub trait ColumnReader<T = u64> {
-    /// Advance the reader to the target_idx.
-    ///
-    /// After a successful call to seek,
-    /// `.get()` should returns `column.get_val(target_idx)`.
-    fn seek(&mut self, target_idx: u64) -> T;
-
-    fn advance(&mut self) -> bool;
-
-    /// Get the current value without advancing the reader
-    fn get(&self) -> T;
-}
-
-pub fn iter_from_reader<'a, T: 'static>(
-    mut column_reader: Box<dyn ColumnReader<T> + 'a>,
-) -> impl Iterator<Item = T> + 'a {
-    std::iter::from_fn(move || {
-        if !column_reader.advance() {
-            return None;
-        }
-        Some(column_reader.get())
-    })
-}
-
-pub(crate) struct ColumnReaderAdapter<'a, C: ?Sized, T> {
-    column: &'a C,
-    idx: u64,
-    len: u64,
-    _phantom: PhantomData<T>,
-}
-
-impl<'a, C: Column<T> + ?Sized, T: Copy + PartialOrd + 'static> From<&'a C>
-    for ColumnReaderAdapter<'a, C, T>
-{
-    fn from(column: &'a C) -> Self {
-        ColumnReaderAdapter {
-            column,
-            idx: u64::MAX,
-            len: column.num_vals(),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<'a, T, C: ?Sized> ColumnReader<T> for ColumnReaderAdapter<'a, C, T>
-where
-    C: Column<T>,
-    T: PartialOrd<T> + Copy + 'static,
-{
-    fn seek(&mut self, idx: u64) -> T {
-        self.idx = idx;
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        self.idx = self.idx.wrapping_add(1);
-        self.idx < self.len
-    }
-
-    fn get(&self) -> T {
-        self.column.get_val(self.idx)
-    }
-}
-
-pub struct VecColumn<'a, T = u64> {
-    values: &'a [T],
-    min_value: T,
-    max_value: T,
-}
-
-impl<'a, C: Column<T>, T> Column<T> for &'a C
-where T: Copy + PartialOrd + 'static
-{
-    fn get_val(&self, idx: u64) -> T {
-        (*self).get_val(idx)
-    }
-
-    fn min_value(&self) -> T {
-        (*self).min_value()
-    }
-
-    fn max_value(&self) -> T {
-        (*self).max_value()
-    }
-
-    fn num_vals(&self) -> u64 {
-        (*self).num_vals()
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader<T> + '_> {
-        (*self).reader()
-    }
-
-    fn get_range(&self, start: u64, output: &mut [T]) {
-        (*self).get_range(start, output)
-    }
-}
-
-impl<'a, T: Copy + PartialOrd + Send + Sync + 'static> Column<T> for VecColumn<'a, T> {
-    fn get_val(&self, position: u64) -> T {
-        self.values[position as usize]
-    }
-
-    fn min_value(&self) -> T {
-        self.min_value
-    }
-
-    fn max_value(&self) -> T {
-        self.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.values.len() as u64
-    }
-
-    fn get_range(&self, start: u64, output: &mut [T]) {
-        output.copy_from_slice(&self.values[start as usize..][..output.len()])
-    }
-}
-
-impl<'a, T: Copy + Ord + Default, V> From<&'a V> for VecColumn<'a, T>
-where V: AsRef<[T]> + ?Sized
-{
-    fn from(values: &'a V) -> Self {
-        let values = values.as_ref();
-        let (min_value, max_value) = minmax(values.iter().copied()).unwrap_or_default();
-        Self {
-            values,
-            min_value,
-            max_value,
-        }
-    }
-}
-
-struct MonotonicMappingColumn<C, T, Input> {
-    from_column: C,
-    monotonic_mapping: T,
-    _phantom: PhantomData<Input>,
-}
-
-/// Creates a view of a column transformed by a monotonic mapping.
-pub fn monotonic_map_column<C, T, Input: PartialOrd + Copy, Output: PartialOrd + Copy>(
-    from_column: C,
-    monotonic_mapping: T,
-) -> impl Column<Output>
-where
-    C: Column<Input>,
-    T: Fn(Input) -> Output + Send + Sync,
-    Input: Send + Sync + 'static,
-    Output: Send + Sync + 'static,
-{
-    MonotonicMappingColumn {
-        from_column,
-        monotonic_mapping,
-        _phantom: PhantomData,
-    }
-}
-
-impl<C, T, Input: PartialOrd + Copy, Output: PartialOrd + Copy> Column<Output>
-    for MonotonicMappingColumn<C, T, Input>
-where
-    C: Column<Input>,
-    T: Fn(Input) -> Output + Send + Sync,
-    Input: Send + Sync + 'static,
-    Output: Send + Sync + 'static,
-{
-    #[inline]
-    fn get_val(&self, idx: u64) -> Output {
-        let from_val = self.from_column.get_val(idx);
-        (self.monotonic_mapping)(from_val)
-    }
-
-    fn min_value(&self) -> Output {
-        let from_min_value = self.from_column.min_value();
-        (self.monotonic_mapping)(from_min_value)
-    }
-
-    fn max_value(&self) -> Output {
-        let from_max_value = self.from_column.max_value();
-        (self.monotonic_mapping)(from_max_value)
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.from_column.num_vals()
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader<Output> + '_> {
-        Box::new(MonotonicMappingColumnReader {
-            col_reader: self.from_column.reader(),
-            monotonic_mapping: &self.monotonic_mapping,
-            intermdiary_type: PhantomData,
-        })
-    }
-
-    // We voluntarily do not implement get_range as it yields a regression,
-    // and we do not have any specialized implementation anyway.
-}
-
-struct MonotonicMappingColumnReader<'a, Transform, U> {
-    col_reader: Box<dyn ColumnReader<U> + 'a>,
-    monotonic_mapping: &'a Transform,
-    intermdiary_type: PhantomData<U>,
-}
-
-impl<'a, U, V, Transform> ColumnReader<V> for MonotonicMappingColumnReader<'a, Transform, U>
-where
-    U: Copy,
-    V: Copy,
-    Transform: Fn(U) -> V,
-{
-    fn seek(&mut self, idx: u64) -> V {
-        let intermediary_value = self.col_reader.seek(idx);
-        (*self.monotonic_mapping)(intermediary_value)
-    }
-
-    fn advance(&mut self) -> bool {
-        self.col_reader.advance()
-    }
-
-    fn get(&self) -> V {
-        (*self.monotonic_mapping)(self.col_reader.get())
-    }
-}
-
-pub struct IterColumn<T>(T);
-
-impl<T> From<T> for IterColumn<T>
-where T: Iterator + Clone + ExactSizeIterator
-{
-    fn from(iter: T) -> Self {
-        IterColumn(iter)
-    }
-}
-
-impl<T> Column<T::Item> for IterColumn<T>
-where
-    T: Iterator + Clone + ExactSizeIterator + Send + Sync,
-    T::Item: PartialOrd + Copy + 'static,
-{
-    fn get_val(&self, idx: u64) -> T::Item {
-        self.0.clone().nth(idx as usize).unwrap()
-    }
-
-    fn min_value(&self) -> T::Item {
-        self.0.clone().next().unwrap()
-    }
-
-    fn max_value(&self) -> T::Item {
-        self.0.clone().last().unwrap()
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.0.len() as u64
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::MonotonicallyMappableToU64;
-
-    #[test]
-    fn test_monotonic_mapping() {
-        let vals = &[1u64, 3u64][..];
-        let col = VecColumn::from(vals);
-        let mapped = monotonic_map_column(col, |el| el + 4);
-        assert_eq!(mapped.min_value(), 5u64);
-        assert_eq!(mapped.max_value(), 7u64);
-        assert_eq!(mapped.num_vals(), 2);
-        assert_eq!(mapped.num_vals(), 2);
-        assert_eq!(mapped.get_val(0), 5);
-        assert_eq!(mapped.get_val(1), 7);
-    }
-
-    #[test]
-    fn test_range_as_col() {
-        let col = IterColumn::from(10..100);
-        assert_eq!(col.num_vals(), 90);
-        assert_eq!(col.max_value(), 99);
-    }
-
-    #[test]
-    fn test_monotonic_mapping_iter() {
-        let vals: Vec<u64> = (-1..99).map(i64::to_u64).collect();
-        let col = VecColumn::from(&vals);
-        let mapped = monotonic_map_column(col, |el| i64::from_u64(el) * 10i64);
-        let val_i64s: Vec<i64> = crate::iter_from_reader(mapped.reader()).collect();
-        for i in 0..100 {
-            assert_eq!(val_i64s[i as usize], mapped.get_val(i));
-        }
-    }
-
-    #[test]
-    fn test_monotonic_mapping_get_range() {
-        let vals: Vec<u64> = (-1..99).map(i64::to_u64).collect();
-        let col = VecColumn::from(&vals);
-        let mapped = monotonic_map_column(col, |el| i64::from_u64(el) * 10i64);
-        assert_eq!(mapped.min_value(), -10i64);
-        assert_eq!(mapped.max_value(), 980i64);
-        assert_eq!(mapped.num_vals(), 100);
-        let val_i64s: Vec<i64> = crate::iter_from_reader(mapped.reader()).collect();
-        assert_eq!(val_i64s.len(), 100);
-        for i in 0..100 {
-            assert_eq!(val_i64s[i as usize], mapped.get_val(i));
-            assert_eq!(val_i64s[i as usize], i64::from_u64(vals[i as usize]) * 10);
-        }
-        let mut buf = [0i64; 20];
-        mapped.get_range(7, &mut buf[..]);
-        assert_eq!(&val_i64s[7..][..20], &buf);
-    }
-}

fastfield_codecs/src/compact_space/blank_range.rs

@@ -1,43 +0,0 @@
-use std::ops::RangeInclusive;
-
-/// The range of a blank in value space.
-///
-/// A blank is an unoccupied space in the data.
-/// Use try_into() to construct.
-/// A range has to have at least length of 3. Invalid ranges will be rejected.
-///
-/// Ordered by range length.
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub(crate) struct BlankRange {
-    blank_range: RangeInclusive<u128>,
-}
-impl TryFrom<RangeInclusive<u128>> for BlankRange {
-    type Error = &'static str;
-    fn try_from(range: RangeInclusive<u128>) -> Result<Self, Self::Error> {
-        let blank_size = range.end().saturating_sub(*range.start());
-        if blank_size < 2 {
-            Err("invalid range")
-        } else {
-            Ok(BlankRange { blank_range: range })
-        }
-    }
-}
-impl BlankRange {
-    pub(crate) fn blank_size(&self) -> u128 {
-        self.blank_range.end() - self.blank_range.start() + 1
-    }
-    pub(crate) fn blank_range(&self) -> RangeInclusive<u128> {
-        self.blank_range.clone()
-    }
-}
-
-impl Ord for BlankRange {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.blank_size().cmp(&other.blank_size())
-    }
-}
-impl PartialOrd for BlankRange {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.blank_size().cmp(&other.blank_size()))
-    }
-}

fastfield_codecs/src/compact_space/build_compact_space.rs

@@ -1,231 +0,0 @@
-use std::collections::{BTreeSet, BinaryHeap};
-use std::iter;
-use std::ops::RangeInclusive;
-
-use itertools::Itertools;
-
-use super::blank_range::BlankRange;
-use super::{CompactSpace, RangeMapping};
-
-/// Put the blanks for the sorted values into a binary heap
-fn get_blanks(values_sorted: &BTreeSet<u128>) -> BinaryHeap<BlankRange> {
-    let mut blanks: BinaryHeap<BlankRange> = BinaryHeap::new();
-    for (first, second) in values_sorted.iter().tuple_windows() {
-        // Correctness Overflow: the values are deduped and sorted (BTreeSet property), that means
-        // there's always space between two values.
-        let blank_range = first + 1..=second - 1;
-        let blank_range: Result<BlankRange, _> = blank_range.try_into();
-        if let Ok(blank_range) = blank_range {
-            blanks.push(blank_range);
-        }
-    }
-
-    blanks
-}
-
-struct BlankCollector {
-    blanks: Vec<BlankRange>,
-    staged_blanks_sum: u128,
-}
-impl BlankCollector {
-    fn new() -> Self {
-        Self {
-            blanks: vec![],
-            staged_blanks_sum: 0,
-        }
-    }
-    fn stage_blank(&mut self, blank: BlankRange) {
-        self.staged_blanks_sum += blank.blank_size();
-        self.blanks.push(blank);
-    }
-    fn drain(&mut self) -> impl Iterator<Item = BlankRange> + '_ {
-        self.staged_blanks_sum = 0;
-        self.blanks.drain(..)
-    }
-    fn staged_blanks_sum(&self) -> u128 {
-        self.staged_blanks_sum
-    }
-    fn num_staged_blanks(&self) -> usize {
-        self.blanks.len()
-    }
-}
-fn num_bits(val: u128) -> u8 {
-    (128u32 - val.leading_zeros()) as u8
-}
-
-/// Will collect blanks and add them to compact space if more bits are saved than cost from
-/// metadata.
-pub fn get_compact_space(
-    values_deduped_sorted: &BTreeSet<u128>,
-    total_num_values: u64,
-    cost_per_blank: usize,
-) -> CompactSpace {
-    let mut compact_space_builder = CompactSpaceBuilder::new();
-    if values_deduped_sorted.is_empty() {
-        return compact_space_builder.finish();
-    }
-
-    let mut blanks: BinaryHeap<BlankRange> = get_blanks(values_deduped_sorted);
-    // Replace after stabilization of https://github.com/rust-lang/rust/issues/62924
-
-    // We start by space that's limited to min_value..=max_value
-    let min_value = *values_deduped_sorted.iter().next().unwrap_or(&0);
-    let max_value = *values_deduped_sorted.iter().last().unwrap_or(&0);
-
-    // +1 for null, in case min and max covers the whole space, we are off by one.
-    let mut amplitude_compact_space = (max_value - min_value).saturating_add(1);
-    if min_value != 0 {
-        compact_space_builder.add_blanks(iter::once(0..=min_value - 1));
-    }
-    if max_value != u128::MAX {
-        compact_space_builder.add_blanks(iter::once(max_value + 1..=u128::MAX));
-    }
-
-    let mut amplitude_bits: u8 = num_bits(amplitude_compact_space);
-
-    let mut blank_collector = BlankCollector::new();
-    // We will stage blanks until they reduce the compact space by at least 1 bit and then flush
-    // them if the metadata cost is lower than the total number of saved bits.
-    // Binary heap to process the gaps by their size
-    while let Some(blank_range) = blanks.pop() {
-        blank_collector.stage_blank(blank_range);
-
-        let staged_spaces_sum: u128 = blank_collector.staged_blanks_sum();
-        let amplitude_new_compact_space = amplitude_compact_space - staged_spaces_sum;
-        let amplitude_new_bits = num_bits(amplitude_new_compact_space);
-        if amplitude_bits == amplitude_new_bits {
-            continue;
-        }
-        let saved_bits = (amplitude_bits - amplitude_new_bits) as usize * total_num_values as usize;
-        // TODO: Maybe calculate exact cost of blanks and run this more expensive computation only,
-        // when amplitude_new_bits changes
-        let cost = blank_collector.num_staged_blanks() * cost_per_blank;
-        if cost >= saved_bits {
-            // Continue here, since although we walk over the blanks by size,
-            // we can potentially save a lot at the last bits, which are smaller blanks
-            //
-            // E.g. if the first range reduces the compact space by 1000 from 2000 to 1000, which
-            // saves 11-10=1 bit and the next range reduces the compact space by 950 to
-            // 50, which saves 10-6=4 bit
-            continue;
-        }
-
-        amplitude_compact_space = amplitude_new_compact_space;
-        amplitude_bits = amplitude_new_bits;
-        compact_space_builder.add_blanks(blank_collector.drain().map(|blank| blank.blank_range()));
-    }
-
-    // special case, when we don't collected any blanks because:
-    // * the data is empty (early exit)
-    // * the algorithm did decide it's not worth the cost, which can be the case for single values
-    //
-    // We drain one collected blank unconditionally, so the empty case is reserved for empty
-    // data, and therefore empty compact_space means the data is empty and no data is covered
-    // (conversely to all data) and we can assign null to it.
-    if compact_space_builder.is_empty() {
-        compact_space_builder.add_blanks(
-            blank_collector
-                .drain()
-                .map(|blank| blank.blank_range())
-                .take(1),
-        );
-    }
-
-    let compact_space = compact_space_builder.finish();
-    if max_value - min_value != u128::MAX {
-        debug_assert_eq!(
-            compact_space.amplitude_compact_space(),
-            amplitude_compact_space
-        );
-    }
-    compact_space
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-struct CompactSpaceBuilder {
-    blanks: Vec<RangeInclusive<u128>>,
-}
-
-impl CompactSpaceBuilder {
-    /// Creates a new compact space builder which will initially cover the whole space.
-    fn new() -> Self {
-        Self { blanks: Vec::new() }
-    }
-
-    /// Assumes that repeated add_blank calls don't overlap and are not adjacent,
-    /// e.g. [3..=5, 5..=10] is not allowed
-    ///
-    /// Both of those assumptions are true when blanks are produced from sorted values.
-    fn add_blanks(&mut self, blank: impl Iterator<Item = RangeInclusive<u128>>) {
-        self.blanks.extend(blank);
-    }
-
-    fn is_empty(&self) -> bool {
-        self.blanks.is_empty()
-    }
-
-    /// Convert blanks to covered space and assign null value
-    fn finish(mut self) -> CompactSpace {
-        // sort by start. ranges are not allowed to overlap
-        self.blanks.sort_unstable_by_key(|blank| *blank.start());
-
-        let mut covered_space = Vec::with_capacity(self.blanks.len());
-
-        // begining of the blanks
-        if let Some(first_blank_start) = self.blanks.first().map(RangeInclusive::start) {
-            if *first_blank_start != 0 {
-                covered_space.push(0..=first_blank_start - 1);
-            }
-        }
-
-        // Between the blanks
-        let between_blanks = self.blanks.iter().tuple_windows().map(|(left, right)| {
-            assert!(
-                left.end() < right.start(),
-                "overlapping or adjacent ranges detected"
-            );
-            *left.end() + 1..=*right.start() - 1
-        });
-        covered_space.extend(between_blanks);
-
-        // end of the blanks
-        if let Some(last_blank_end) = self.blanks.last().map(RangeInclusive::end) {
-            if *last_blank_end != u128::MAX {
-                covered_space.push(last_blank_end + 1..=u128::MAX);
-            }
-        }
-
-        if covered_space.is_empty() {
-            covered_space.push(0..=0); // empty data case
-        };
-
-        let mut compact_start: u64 = 1; // 0 is reserved for `null`
-        let mut ranges_mapping: Vec<RangeMapping> = Vec::with_capacity(covered_space.len());
-        for cov in covered_space {
-            let range_mapping = super::RangeMapping {
-                value_range: cov,
-                compact_start,
-            };
-            let covered_range_len = range_mapping.range_length();
-            ranges_mapping.push(range_mapping);
-            compact_start += covered_range_len as u64;
-        }
-        // println!("num ranges {}", ranges_mapping.len());
-        CompactSpace { ranges_mapping }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_binary_heap_pop_order() {
-        let mut blanks: BinaryHeap<BlankRange> = BinaryHeap::new();
-        blanks.push((0..=10).try_into().unwrap());
-        blanks.push((100..=200).try_into().unwrap());
-        blanks.push((100..=110).try_into().unwrap());
-        assert_eq!(blanks.pop().unwrap().blank_size(), 101);
-        assert_eq!(blanks.pop().unwrap().blank_size(), 11);
-    }
-}

fastfield_codecs/src/compact_space/mod.rs

@@ -1,689 +0,0 @@
-/// This codec takes a large number space (u128) and reduces it to a compact number space.
-///
-/// It will find spaces in the number range. For example:
-///
-/// 100, 101, 102, 103, 104, 50000, 50001
-/// could be mapped to
-/// 100..104 -> 0..4
-/// 50000..50001 -> 5..6
-///
-/// Compact space 0..=6 requires much less bits than 100..=50001
-///
-/// The codec is created to compress ip addresses, but may be employed in other use cases.
-use std::{
-    cmp::Ordering,
-    collections::BTreeSet,
-    io::{self, Write},
-    ops::RangeInclusive,
-};
-
-use common::{BinarySerializable, CountingWriter, VInt, VIntU128};
-use ownedbytes::OwnedBytes;
-use tantivy_bitpacker::{self, BitPacker, BitUnpacker};
-
-use crate::compact_space::build_compact_space::get_compact_space;
-use crate::{iter_from_reader, Column, ColumnReader};
-
-mod blank_range;
-mod build_compact_space;
-
-/// The cost per blank is quite hard actually, since blanks are delta encoded, the actual cost of
-/// blanks depends on the number of blanks.
-///
-/// The number is taken by looking at a real dataset. It is optimized for larger datasets.
-const COST_PER_BLANK_IN_BITS: usize = 36;
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct CompactSpace {
-    ranges_mapping: Vec<RangeMapping>,
-}
-
-/// Maps the range from the original space to compact_start + range.len()
-#[derive(Debug, Clone, Eq, PartialEq)]
-struct RangeMapping {
-    value_range: RangeInclusive<u128>,
-    compact_start: u64,
-}
-impl RangeMapping {
-    fn range_length(&self) -> u64 {
-        (self.value_range.end() - self.value_range.start()) as u64 + 1
-    }
-
-    // The last value of the compact space in this range
-    fn compact_end(&self) -> u64 {
-        self.compact_start + self.range_length() - 1
-    }
-}
-
-impl BinarySerializable for CompactSpace {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        VInt(self.ranges_mapping.len() as u64).serialize(writer)?;
-
-        let mut prev_value = 0;
-        for value_range in self
-            .ranges_mapping
-            .iter()
-            .map(|range_mapping| &range_mapping.value_range)
-        {
-            let blank_delta_start = value_range.start() - prev_value;
-            VIntU128(blank_delta_start).serialize(writer)?;
-            prev_value = *value_range.start();
-
-            let blank_delta_end = value_range.end() - prev_value;
-            VIntU128(blank_delta_end).serialize(writer)?;
-            prev_value = *value_range.end();
-        }
-
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let num_ranges = VInt::deserialize(reader)?.0;
-        let mut ranges_mapping: Vec<RangeMapping> = vec![];
-        let mut value = 0u128;
-        let mut compact_start = 1u64; // 0 is reserved for `null`
-        for _ in 0..num_ranges {
-            let blank_delta_start = VIntU128::deserialize(reader)?.0;
-            value += blank_delta_start;
-            let blank_start = value;
-
-            let blank_delta_end = VIntU128::deserialize(reader)?.0;
-            value += blank_delta_end;
-            let blank_end = value;
-
-            let range_mapping = RangeMapping {
-                value_range: blank_start..=blank_end,
-                compact_start,
-            };
-            let range_length = range_mapping.range_length();
-            ranges_mapping.push(range_mapping);
-            compact_start += range_length as u64;
-        }
-
-        Ok(Self { ranges_mapping })
-    }
-}
-
-impl CompactSpace {
-    /// Amplitude is the value range of the compact space including the sentinel value used to
-    /// identify null values. The compact space is 0..=amplitude .
-    ///
-    /// It's only used to verify we don't exceed u64 number space, which would indicate a bug.
-    fn amplitude_compact_space(&self) -> u128 {
-        self.ranges_mapping
-            .last()
-            .map(|last_range| last_range.compact_end() as u128)
-            .unwrap_or(1) // compact space starts at 1, 0 == null
-    }
-
-    fn get_range_mapping(&self, pos: usize) -> &RangeMapping {
-        &self.ranges_mapping[pos]
-    }
-
-    /// Returns either Ok(the value in the compact space) or if it is outside the compact space the
-    /// Err(position where it would be inserted)
-    fn u128_to_compact(&self, value: u128) -> Result<u64, usize> {
-        self.ranges_mapping
-            .binary_search_by(|probe| {
-                let value_range = &probe.value_range;
-                if value < *value_range.start() {
-                    Ordering::Greater
-                } else if value > *value_range.end() {
-                    Ordering::Less
-                } else {
-                    Ordering::Equal
-                }
-            })
-            .map(|pos| {
-                let range_mapping = &self.ranges_mapping[pos];
-                let pos_in_range = (value - range_mapping.value_range.start()) as u64;
-                range_mapping.compact_start + pos_in_range
-            })
-    }
-
-    /// Unpacks a value from compact space u64 to u128 space
-    fn compact_to_u128(&self, compact: u64) -> u128 {
-        let pos = self
-            .ranges_mapping
-            .binary_search_by_key(&compact, |range_mapping| range_mapping.compact_start)
-            // Correctness: Overflow. The first range starts at compact space 0, the error from
-            // binary search can never be 0
-            .map_or_else(|e| e - 1, |v| v);
-
-        let range_mapping = &self.ranges_mapping[pos];
-        let diff = compact - range_mapping.compact_start;
-        range_mapping.value_range.start() + diff as u128
-    }
-}
-
-pub struct CompactSpaceCompressor {
-    params: IPCodecParams,
-}
-#[derive(Debug, Clone)]
-pub struct IPCodecParams {
-    compact_space: CompactSpace,
-    bit_unpacker: BitUnpacker,
-    min_value: u128,
-    max_value: u128,
-    num_vals: u64,
-    num_bits: u8,
-}
-
-impl CompactSpaceCompressor {
-    /// Taking the vals as Vec may cost a lot of memory. It is used to sort the vals.
-    pub fn train_from(column: &impl Column<u128>) -> Self {
-        let mut values_sorted = BTreeSet::new();
-
-        let total_num_values = column.num_vals();
-
-        values_sorted.extend(iter_from_reader(column.reader()));
-
-        let compact_space =
-            get_compact_space(&values_sorted, total_num_values, COST_PER_BLANK_IN_BITS);
-
-        let amplitude_compact_space = compact_space.amplitude_compact_space();
-
-        assert!(
-            amplitude_compact_space <= u64::MAX as u128,
-            "case unsupported."
-        );
-
-        let num_bits = tantivy_bitpacker::compute_num_bits(amplitude_compact_space as u64);
-        let min_value = *values_sorted.iter().next().unwrap_or(&0);
-        let max_value = *values_sorted.iter().last().unwrap_or(&0);
-        assert_eq!(
-            compact_space
-                .u128_to_compact(max_value)
-                .expect("could not convert max value to compact space"),
-            amplitude_compact_space as u64
-        );
-        CompactSpaceCompressor {
-            params: IPCodecParams {
-                compact_space,
-                bit_unpacker: BitUnpacker::new(num_bits),
-                min_value,
-                max_value,
-                num_vals: total_num_values as u64,
-                num_bits,
-            },
-        }
-    }
-
-    fn write_footer(self, writer: &mut impl Write) -> io::Result<()> {
-        let writer = &mut CountingWriter::wrap(writer);
-        self.params.serialize(writer)?;
-
-        let footer_len = writer.written_bytes() as u32;
-        footer_len.serialize(writer)?;
-
-        Ok(())
-    }
-
-    pub fn compress_into(
-        self,
-        mut vals: Box<dyn ColumnReader<u128> + '_>,
-        write: &mut impl Write,
-    ) -> io::Result<()> {
-        let mut bitpacker = BitPacker::default();
-        while vals.advance() {
-            let val = vals.get();
-            let compact = self
-                .params
-                .compact_space
-                .u128_to_compact(val)
-                .map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        "Could not convert value to compact_space. This is a bug.",
-                    )
-                })?;
-            bitpacker.write(compact, self.params.num_bits, write)?;
-        }
-        bitpacker.close(write)?;
-        self.write_footer(write)?;
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CompactSpaceDecompressor {
-    data: OwnedBytes,
-    params: IPCodecParams,
-}
-
-impl BinarySerializable for IPCodecParams {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        // header flags for future optional dictionary encoding
-        let footer_flags = 0u64;
-        footer_flags.serialize(writer)?;
-
-        VIntU128(self.min_value).serialize(writer)?;
-        VIntU128(self.max_value).serialize(writer)?;
-        VIntU128(self.num_vals as u128).serialize(writer)?;
-        self.num_bits.serialize(writer)?;
-
-        self.compact_space.serialize(writer)?;
-
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let _header_flags = u64::deserialize(reader)?;
-        let min_value = VIntU128::deserialize(reader)?.0;
-        let max_value = VIntU128::deserialize(reader)?.0;
-        let num_vals = VIntU128::deserialize(reader)?.0 as u64;
-        let num_bits = u8::deserialize(reader)?;
-        let compact_space = CompactSpace::deserialize(reader)?;
-
-        Ok(Self {
-            compact_space,
-            bit_unpacker: BitUnpacker::new(num_bits),
-            min_value,
-            max_value,
-            num_vals,
-            num_bits,
-        })
-    }
-}
-
-impl Column<u128> for CompactSpaceDecompressor {
-    #[inline]
-    fn get_val(&self, doc: u64) -> u128 {
-        self.get(doc)
-    }
-
-    fn min_value(&self) -> u128 {
-        self.min_value()
-    }
-
-    fn max_value(&self) -> u128 {
-        self.max_value()
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.params.num_vals
-    }
-
-    fn get_between_vals(&self, range: RangeInclusive<u128>) -> Vec<u64> {
-        self.get_between_vals(range)
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader<u128> + '_> {
-        Box::new(self.specialized_reader())
-    }
-}
-
-impl CompactSpaceDecompressor {
-    pub fn open(data: OwnedBytes) -> io::Result<CompactSpaceDecompressor> {
-        let (data_slice, footer_len_bytes) = data.split_at(data.len() - 4);
-        let footer_len = u32::deserialize(&mut &footer_len_bytes[..])?;
-
-        let data_footer = &data_slice[data_slice.len() - footer_len as usize..];
-        let params = IPCodecParams::deserialize(&mut &data_footer[..])?;
-        let decompressor = CompactSpaceDecompressor { data, params };
-
-        Ok(decompressor)
-    }
-
-    /// Converting to compact space for the decompressor is more complex, since we may get values
-    /// which are outside the compact space. e.g. if we map
-    /// 1000 => 5
-    /// 2000 => 6
-    ///
-    /// and we want a mapping for 1005, there is no equivalent compact space. We instead return an
-    /// error with the index of the next range.
-    fn u128_to_compact(&self, value: u128) -> Result<u64, usize> {
-        self.params.compact_space.u128_to_compact(value)
-    }
-
-    fn compact_to_u128(&self, compact: u64) -> u128 {
-        self.params.compact_space.compact_to_u128(compact)
-    }
-
-    /// Comparing on compact space: Random dataset 0,24 (50% random hit) - 1.05 GElements/s
-    /// Comparing on compact space: Real dataset 1.08 GElements/s
-    ///
-    /// Comparing on original space: Real dataset .06 GElements/s (not completely optimized)
-    pub fn get_between_vals(&self, range: RangeInclusive<u128>) -> Vec<u64> {
-        if range.start() > range.end() {
-            return Vec::new();
-        }
-        let from_value = *range.start();
-        let to_value = *range.end();
-        assert!(to_value >= from_value);
-        let compact_from = self.u128_to_compact(from_value);
-        let compact_to = self.u128_to_compact(to_value);
-
-        // Quick return, if both ranges fall into the same non-mapped space, the range can't cover
-        // any values, so we can early exit
-        match (compact_to, compact_from) {
-            (Err(pos1), Err(pos2)) if pos1 == pos2 => return Vec::new(),
-            _ => {}
-        }
-
-        let compact_from = compact_from.unwrap_or_else(|pos| {
-            // Correctness: Out of bounds, if this value is Err(last_index + 1), we early exit,
-            // since the to_value also mapps into the same non-mapped space
-            let range_mapping = self.params.compact_space.get_range_mapping(pos);
-            range_mapping.compact_start
-        });
-        // If there is no compact space, we go to the closest upperbound compact space
-        let compact_to = compact_to.unwrap_or_else(|pos| {
-            // Correctness: Overflow, if this value is Err(0), we early exit,
-            // since the from_value also mapps into the same non-mapped space
-
-            // Get end of previous range
-            let pos = pos - 1;
-            let range_mapping = self.params.compact_space.get_range_mapping(pos);
-            range_mapping.compact_end()
-        });
-
-        let range = compact_from..=compact_to;
-        let mut positions = Vec::new();
-
-        let step_size = 4;
-        let cutoff = self.params.num_vals - self.params.num_vals % step_size;
-
-        let mut push_if_in_range = |idx, val| {
-            if range.contains(&val) {
-                positions.push(idx);
-            }
-        };
-        let get_val = |idx| self.params.bit_unpacker.get(idx as u64, &self.data);
-        // unrolled loop
-        for idx in (0..cutoff).step_by(step_size as usize) {
-            let idx1 = idx;
-            let idx2 = idx + 1;
-            let idx3 = idx + 2;
-            let idx4 = idx + 3;
-            let val1 = get_val(idx1);
-            let val2 = get_val(idx2);
-            let val3 = get_val(idx3);
-            let val4 = get_val(idx4);
-            push_if_in_range(idx1, val1);
-            push_if_in_range(idx2, val2);
-            push_if_in_range(idx3, val3);
-            push_if_in_range(idx4, val4);
-        }
-
-        // handle rest
-        for idx in cutoff..self.params.num_vals {
-            push_if_in_range(idx, get_val(idx));
-        }
-
-        positions
-    }
-
-    fn specialized_reader(&self) -> CompactSpaceReader<'_> {
-        CompactSpaceReader {
-            data: self.data.as_slice(),
-            params: &self.params,
-            idx: 0u64,
-            len: self.params.num_vals,
-        }
-    }
-
-    #[inline]
-    pub fn get(&self, idx: u64) -> u128 {
-        let compact = self.params.bit_unpacker.get(idx, &self.data);
-        self.compact_to_u128(compact)
-    }
-
-    pub fn min_value(&self) -> u128 {
-        self.params.min_value
-    }
-
-    pub fn max_value(&self) -> u128 {
-        self.params.max_value
-    }
-}
-
-pub struct CompactSpaceReader<'a> {
-    data: &'a [u8],
-    params: &'a IPCodecParams,
-    idx: u64,
-    len: u64,
-}
-
-impl<'a> ColumnReader<u128> for CompactSpaceReader<'a> {
-    fn seek(&mut self, target_idx: u64) -> u128 {
-        self.idx = target_idx;
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        self.idx = self.idx.wrapping_add(1);
-        self.idx < self.len
-    }
-
-    fn get(&self) -> u128 {
-        let compact_code = self.params.bit_unpacker.get(self.idx, self.data);
-        self.params.compact_space.compact_to_u128(compact_code)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::*;
-    use crate::{open_u128, serialize_u128, VecColumn};
-
-    #[test]
-    fn compact_space_test() {
-        let ips = &[
-            2u128, 4u128, 1000, 1001, 1002, 1003, 1004, 1005, 1008, 1010, 1012, 1260,
-        ]
-        .into_iter()
-        .collect();
-        let compact_space = get_compact_space(ips, ips.len() as u64, 11);
-        let amplitude = compact_space.amplitude_compact_space();
-        assert_eq!(amplitude, 17);
-        assert_eq!(1, compact_space.u128_to_compact(2).unwrap());
-        assert_eq!(2, compact_space.u128_to_compact(3).unwrap());
-        assert_eq!(compact_space.u128_to_compact(100).unwrap_err(), 1);
-
-        for (num1, num2) in (0..3).tuple_windows() {
-            assert_eq!(
-                compact_space.get_range_mapping(num1).compact_end() + 1,
-                compact_space.get_range_mapping(num2).compact_start
-            );
-        }
-
-        let mut output: Vec<u8> = Vec::new();
-        compact_space.serialize(&mut output).unwrap();
-
-        assert_eq!(
-            compact_space,
-            CompactSpace::deserialize(&mut &output[..]).unwrap()
-        );
-
-        for ip in ips {
-            let compact = compact_space.u128_to_compact(*ip).unwrap();
-            assert_eq!(compact_space.compact_to_u128(compact), *ip);
-        }
-    }
-
-    #[test]
-    fn compact_space_amplitude_test() {
-        let ips = &[100000u128, 1000000].into_iter().collect();
-        let compact_space = get_compact_space(ips, ips.len() as u64, 1);
-        let amplitude = compact_space.amplitude_compact_space();
-        assert_eq!(amplitude, 2);
-    }
-
-    fn test_all(data: OwnedBytes, expected: &[u128]) {
-        let decompressor = CompactSpaceDecompressor::open(data).unwrap();
-        for (idx, expected_val) in expected.iter().cloned().enumerate() {
-            let val = decompressor.get(idx as u64);
-            assert_eq!(val, expected_val);
-
-            let test_range = |range: RangeInclusive<u128>| {
-                let expected_positions = expected
-                    .iter()
-                    .positions(|val| range.contains(val))
-                    .map(|pos| pos as u64)
-                    .collect::<Vec<_>>();
-                let positions = decompressor.get_between_vals(range);
-                assert_eq!(positions, expected_positions);
-            };
-
-            test_range(expected_val.saturating_sub(1)..=expected_val);
-            test_range(expected_val..=expected_val);
-            test_range(expected_val..=expected_val.saturating_add(1));
-            test_range(expected_val.saturating_sub(1)..=expected_val.saturating_add(1));
-        }
-    }
-
-    fn test_aux_vals(u128_vals: &[u128]) -> OwnedBytes {
-        let mut out = Vec::new();
-        serialize_u128(VecColumn::from(u128_vals), &mut out).unwrap();
-
-        let data = OwnedBytes::new(out);
-        test_all(data.clone(), u128_vals);
-        data
-    }
-
-    #[test]
-    fn test_range_1() {
-        let vals = &[
-            1u128,
-            100u128,
-            3u128,
-            99999u128,
-            100000u128,
-            100001u128,
-            4_000_211_221u128,
-            4_000_211_222u128,
-            333u128,
-        ];
-        let data = test_aux_vals(vals);
-        let decomp = CompactSpaceDecompressor::open(data).unwrap();
-        let positions = decomp.get_between_vals(0..=1);
-        assert_eq!(positions, vec![0]);
-        let positions = decomp.get_between_vals(0..=2);
-        assert_eq!(positions, vec![0]);
-        let positions = decomp.get_between_vals(0..=3);
-        assert_eq!(positions, vec![0, 2]);
-        assert_eq!(decomp.get_between_vals(99999u128..=99999u128), vec![3]);
-        assert_eq!(decomp.get_between_vals(99999u128..=100000u128), vec![3, 4]);
-        assert_eq!(decomp.get_between_vals(99998u128..=100000u128), vec![3, 4]);
-        assert_eq!(decomp.get_between_vals(99998u128..=99999u128), vec![3]);
-        assert_eq!(decomp.get_between_vals(99998u128..=99998u128), vec![]);
-        assert_eq!(decomp.get_between_vals(333u128..=333u128), vec![8]);
-        assert_eq!(decomp.get_between_vals(332u128..=333u128), vec![8]);
-        assert_eq!(decomp.get_between_vals(332u128..=334u128), vec![8]);
-        assert_eq!(decomp.get_between_vals(333u128..=334u128), vec![8]);
-
-        assert_eq!(
-            decomp.get_between_vals(4_000_211_221u128..=5_000_000_000u128),
-            vec![6, 7]
-        );
-    }
-
-    #[test]
-    fn test_empty() {
-        let vals = &[];
-        let data = test_aux_vals(vals);
-        let _decomp = CompactSpaceDecompressor::open(data).unwrap();
-    }
-
-    #[test]
-    fn test_range_2() {
-        let vals = &[
-            100u128,
-            99999u128,
-            100000u128,
-            100001u128,
-            4_000_211_221u128,
-            4_000_211_222u128,
-            333u128,
-        ];
-        let data = test_aux_vals(vals);
-        let decomp = CompactSpaceDecompressor::open(data).unwrap();
-        let positions = decomp.get_between_vals(0..=5);
-        assert_eq!(positions, vec![]);
-        let positions = decomp.get_between_vals(0..=100);
-        assert_eq!(positions, vec![0]);
-        let positions = decomp.get_between_vals(0..=105);
-        assert_eq!(positions, vec![0]);
-    }
-
-    #[test]
-    fn test_range_3() {
-        let vals = &[
-            200u128,
-            201,
-            202,
-            203,
-            204,
-            204,
-            206,
-            207,
-            208,
-            209,
-            210,
-            1_000_000,
-            5_000_000_000,
-        ];
-        let mut out = Vec::new();
-        serialize_u128(VecColumn::from(vals), &mut out).unwrap();
-        let decomp = open_u128(OwnedBytes::new(out)).unwrap();
-
-        assert_eq!(decomp.get_between_vals(199..=200), vec![0]);
-        assert_eq!(decomp.get_between_vals(199..=201), vec![0, 1]);
-        assert_eq!(decomp.get_between_vals(200..=200), vec![0]);
-        assert_eq!(decomp.get_between_vals(1_000_000..=1_000_000), vec![11]);
-    }
-
-    #[test]
-    fn test_bug1() {
-        let vals = &[9223372036854775806];
-        let _data = test_aux_vals(vals);
-    }
-
-    #[test]
-    fn test_bug2() {
-        let vals = &[340282366920938463463374607431768211455u128];
-        let _data = test_aux_vals(vals);
-    }
-
-    #[test]
-    fn test_bug3() {
-        let vals = &[340282366920938463463374607431768211454];
-        let _data = test_aux_vals(vals);
-    }
-
-    #[test]
-    fn test_bug4() {
-        let vals = &[340282366920938463463374607431768211455, 0];
-        let _data = test_aux_vals(vals);
-    }
-
-    #[test]
-    fn test_first_large_gaps() {
-        let vals = &[1_000_000_000u128; 100];
-        let _data = test_aux_vals(vals);
-    }
-    use itertools::Itertools;
-    use proptest::prelude::*;
-
-    fn num_strategy() -> impl Strategy<Value = u128> {
-        prop_oneof![
-            1 => prop::num::u128::ANY.prop_map(|num| u128::MAX - (num % 10) ),
-            1 => prop::num::u128::ANY.prop_map(|num| i64::MAX as u128 + 5 - (num % 10) ),
-            1 => prop::num::u128::ANY.prop_map(|num| i128::MAX as u128 + 5 - (num % 10) ),
-            1 => prop::num::u128::ANY.prop_map(|num| num % 10 ),
-            20 => prop::num::u128::ANY,
-        ]
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(10))]
-
-            #[test]
-            fn compress_decompress_random(vals in proptest::collection::vec(num_strategy()
-    , 1..1000)) {
-                let _data = test_aux_vals(&vals);
-            }
-        }
-}

fastfield_codecs/src/gcd.rs

@@ -1,170 +0,0 @@
-use std::num::NonZeroU64;
-
-use fastdivide::DividerU64;
-
-/// Compute the gcd of two non null numbers.
-///
-/// It is recommended, but not required, to feed values such that `large >= small`.
-fn compute_gcd(mut large: NonZeroU64, mut small: NonZeroU64) -> NonZeroU64 {
-    loop {
-        let rem: u64 = large.get() % small;
-        if let Some(new_small) = NonZeroU64::new(rem) {
-            (large, small) = (small, new_small);
-        } else {
-            return small;
-        }
-    }
-}
-
-// Find GCD for iterator of numbers
-pub fn find_gcd(numbers: impl Iterator<Item = u64>) -> Option<NonZeroU64> {
-    let mut numbers = numbers.flat_map(NonZeroU64::new);
-    let mut gcd: NonZeroU64 = numbers.next()?;
-    if gcd.get() == 1 {
-        return Some(gcd);
-    }
-
-    let mut gcd_divider = DividerU64::divide_by(gcd.get());
-    for val in numbers {
-        let remainder = val.get() - (gcd_divider.divide(val.get())) * gcd.get();
-        if remainder == 0 {
-            continue;
-        }
-        gcd = compute_gcd(val, gcd);
-        if gcd.get() == 1 {
-            return Some(gcd);
-        }
-
-        gcd_divider = DividerU64::divide_by(gcd.get());
-    }
-    Some(gcd)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io;
-    use std::num::NonZeroU64;
-
-    use ownedbytes::OwnedBytes;
-
-    use crate::gcd::{compute_gcd, find_gcd};
-    use crate::{FastFieldCodecType, VecColumn};
-
-    fn test_fastfield_gcd_i64_with_codec(
-        codec_type: FastFieldCodecType,
-        num_vals: usize,
-    ) -> io::Result<()> {
-        let mut vals: Vec<i64> = (-4..=(num_vals as i64) - 5).map(|val| val * 1000).collect();
-        let mut buffer: Vec<u8> = Vec::new();
-        crate::serialize(VecColumn::from(&vals), &mut buffer, &[codec_type])?;
-        let buffer = OwnedBytes::new(buffer);
-        let column = crate::open::<i64>(buffer.clone())?;
-        assert_eq!(column.get_val(0), -4000i64);
-        assert_eq!(column.get_val(1), -3000i64);
-        assert_eq!(column.get_val(2), -2000i64);
-        assert_eq!(column.max_value(), (num_vals as i64 - 5) * 1000);
-        assert_eq!(column.min_value(), -4000i64);
-
-        // Can't apply gcd
-        let mut buffer_without_gcd = Vec::new();
-        vals.pop();
-        vals.push(1001i64);
-        crate::serialize(
-            VecColumn::from(&vals),
-            &mut buffer_without_gcd,
-            &[codec_type],
-        )?;
-        let buffer_without_gcd = OwnedBytes::new(buffer_without_gcd);
-        assert!(buffer_without_gcd.len() > buffer.len());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_fastfield_gcd_i64() -> io::Result<()> {
-        for &codec_type in &[
-            FastFieldCodecType::Bitpacked,
-            FastFieldCodecType::BlockwiseLinear,
-            FastFieldCodecType::Linear,
-        ] {
-            test_fastfield_gcd_i64_with_codec(codec_type, 5500)?;
-        }
-        Ok(())
-    }
-
-    fn test_fastfield_gcd_u64_with_codec(
-        codec_type: FastFieldCodecType,
-        num_vals: usize,
-    ) -> io::Result<()> {
-        let mut vals: Vec<u64> = (1..=num_vals).map(|i| i as u64 * 1000u64).collect();
-        let mut buffer: Vec<u8> = Vec::new();
-        crate::serialize(VecColumn::from(&vals), &mut buffer, &[codec_type])?;
-        let buffer = OwnedBytes::new(buffer);
-        let column = crate::open::<u64>(buffer.clone())?;
-        assert_eq!(column.get_val(0), 1000u64);
-        assert_eq!(column.get_val(1), 2000u64);
-        assert_eq!(column.get_val(2), 3000u64);
-        assert_eq!(column.max_value(), num_vals as u64 * 1000);
-        assert_eq!(column.min_value(), 1000u64);
-
-        // Can't apply gcd
-        let mut buffer_without_gcd = Vec::new();
-        vals.pop();
-        vals.push(1001u64);
-        crate::serialize(
-            VecColumn::from(&vals),
-            &mut buffer_without_gcd,
-            &[codec_type],
-        )?;
-        let buffer_without_gcd = OwnedBytes::new(buffer_without_gcd);
-        assert!(buffer_without_gcd.len() > buffer.len());
-        Ok(())
-    }
-
-    #[test]
-    fn test_fastfield_gcd_u64() -> io::Result<()> {
-        for &codec_type in &[
-            FastFieldCodecType::Bitpacked,
-            FastFieldCodecType::BlockwiseLinear,
-            FastFieldCodecType::Linear,
-        ] {
-            test_fastfield_gcd_u64_with_codec(codec_type, 5500)?;
-        }
-        Ok(())
-    }
-
-    #[test]
-    pub fn test_fastfield2() {
-        let test_fastfield = crate::serialize_and_load(&[100u64, 200u64, 300u64]);
-        assert_eq!(test_fastfield.get_val(0), 100);
-        assert_eq!(test_fastfield.get_val(1), 200);
-        assert_eq!(test_fastfield.get_val(2), 300);
-    }
-
-    #[test]
-    fn test_compute_gcd() {
-        let test_compute_gcd_aux = |large, small, expected| {
-            let large = NonZeroU64::new(large).unwrap();
-            let small = NonZeroU64::new(small).unwrap();
-            let expected = NonZeroU64::new(expected).unwrap();
-            assert_eq!(compute_gcd(small, large), expected);
-            assert_eq!(compute_gcd(large, small), expected);
-        };
-        test_compute_gcd_aux(1, 4, 1);
-        test_compute_gcd_aux(2, 4, 2);
-        test_compute_gcd_aux(10, 25, 5);
-        test_compute_gcd_aux(25, 25, 25);
-    }
-
-    #[test]
-    fn find_gcd_test() {
-        assert_eq!(find_gcd([0].into_iter()), None);
-        assert_eq!(find_gcd([0, 10].into_iter()), NonZeroU64::new(10));
-        assert_eq!(find_gcd([10, 0].into_iter()), NonZeroU64::new(10));
-        assert_eq!(find_gcd([].into_iter()), None);
-        assert_eq!(find_gcd([15, 30, 5, 10].into_iter()), NonZeroU64::new(5));
-        assert_eq!(find_gcd([15, 16, 10].into_iter()), NonZeroU64::new(1));
-        assert_eq!(find_gcd([0, 5, 5, 5].into_iter()), NonZeroU64::new(5));
-        assert_eq!(find_gcd([0, 0].into_iter()), None);
-    }
-}

fastfield_codecs/src/lib.rs

@@ -1,40 +1,27 @@
-#![cfg_attr(all(feature = "unstable", test), feature(test))]
-
 #[cfg(test)]
 #[macro_use]
 extern crate more_asserts;
 
-#[cfg(all(test, feature = "unstable"))]
-extern crate test;
-
 use std::io;
 use std::io::Write;
-use std::sync::Arc;
 
 use common::BinarySerializable;
-use compact_space::CompactSpaceDecompressor;
 use ownedbytes::OwnedBytes;
-use serialize::Header;
 
-mod bitpacked;
+pub mod bitpacked;
-mod blockwise_linear;
+pub mod blockwise_linear;
-mod compact_space;
+pub mod linear;
-mod line;
-mod linear;
-mod monotonic_mapping;
 
-mod column;
+pub trait FastFieldDataAccess {
-mod gcd;
+    fn get_val(&self, doc: u64) -> u64;
-mod serialize;
+    fn min_value(&self) -> u64;
-
+    fn max_value(&self) -> u64;
-use self::bitpacked::BitpackedCodec;
+    fn num_vals(&self) -> u64;
-use self::blockwise_linear::BlockwiseLinearCodec;
+    /// Returns a iterator over the data
-pub use self::column::{iter_from_reader, monotonic_map_column, Column, ColumnReader, VecColumn};
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = u64> + 'a> {
-use self::linear::LinearCodec;
+        Box::new((0..self.num_vals()).map(|idx| self.get_val(idx)))
-pub use self::monotonic_mapping::MonotonicallyMappableToU64;
+    }
-pub use self::serialize::{
+}
-    estimate, serialize, serialize_and_load, serialize_u128, NormalizedHeader,
-};
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
 #[repr(u8)]
@@ -42,6 +29,7 @@ pub enum FastFieldCodecType {
     Bitpacked = 1,
     Linear = 2,
     BlockwiseLinear = 3,
+    Gcd = 4,
 }
 
 impl BinarySerializable for FastFieldCodecType {
@@ -67,169 +55,148 @@ impl FastFieldCodecType {
             1 => Some(Self::Bitpacked),
             2 => Some(Self::Linear),
             3 => Some(Self::BlockwiseLinear),
+            4 => Some(Self::Gcd),
             _ => None,
         }
     }
 }
 
-/// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open_u128(bytes: OwnedBytes) -> io::Result<Arc<dyn Column<u128>>> {
-    Ok(Arc::new(CompactSpaceDecompressor::open(bytes)?))
-}
-
-/// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open<T: MonotonicallyMappableToU64>(
-    mut bytes: OwnedBytes,
-) -> io::Result<Arc<dyn Column<T>>> {
-    let header = Header::deserialize(&mut bytes)?;
-    match header.codec_type {
-        FastFieldCodecType::Bitpacked => open_specific_codec::<BitpackedCodec, _>(bytes, &header),
-        FastFieldCodecType::Linear => open_specific_codec::<LinearCodec, _>(bytes, &header),
-        FastFieldCodecType::BlockwiseLinear => {
-            open_specific_codec::<BlockwiseLinearCodec, _>(bytes, &header)
-        }
-    }
-}
-
-fn open_specific_codec<C: FastFieldCodec, Item: MonotonicallyMappableToU64>(
-    bytes: OwnedBytes,
-    header: &Header,
-) -> io::Result<Arc<dyn Column<Item>>> {
-    let normalized_header = header.normalized();
-    let reader = C::open_from_bytes(bytes, normalized_header)?;
-    let min_value = header.min_value;
-    if let Some(gcd) = header.gcd {
-        let monotonic_mapping = move |val: u64| Item::from_u64(min_value + val * gcd.get());
-        Ok(Arc::new(monotonic_map_column(reader, monotonic_mapping)))
-    } else {
-        let monotonic_mapping = move |val: u64| Item::from_u64(min_value + val);
-        Ok(Arc::new(monotonic_map_column(reader, monotonic_mapping)))
-    }
-}
-
 /// The FastFieldSerializerEstimate trait is required on all variants
 /// of fast field compressions, to decide which one to choose.
-trait FastFieldCodec: 'static {
+pub trait FastFieldCodec {
     /// A codex needs to provide a unique name and id, which is
     /// used for debugging and de/serialization.
     const CODEC_TYPE: FastFieldCodecType;
 
-    type Reader: Column<u64> + 'static;
+    type Reader: FastFieldDataAccess;
 
     /// Reads the metadata and returns the CodecReader
-    fn open_from_bytes(bytes: OwnedBytes, header: NormalizedHeader) -> io::Result<Self::Reader>;
+    fn open_from_bytes(bytes: OwnedBytes) -> io::Result<Self::Reader>;
 
     /// Serializes the data using the serializer into write.
     ///
-    /// The column iterator should be preferred over using column `get_val` method for
+    /// The fastfield_accessor iterator should be preferred over using fastfield_accessor for
     /// performance reasons.
-    fn serialize(column: &dyn Column<u64>, write: &mut impl Write) -> io::Result<()>;
+    fn serialize(
+        write: &mut impl Write,
+        fastfield_accessor: &dyn FastFieldDataAccess,
+    ) -> io::Result<()>;
+
+    /// Check if the Codec is able to compress the data
+    fn is_applicable(fastfield_accessor: &impl FastFieldDataAccess) -> bool;
 
     /// Returns an estimate of the compression ratio.
-    /// If the codec is not applicable, returns `None`.
-    ///
     /// The baseline is uncompressed 64bit data.
     ///
     /// It could make sense to also return a value representing
     /// computational complexity.
-    fn estimate(column: &impl Column) -> Option<f32>;
+    fn estimate(fastfield_accessor: &impl FastFieldDataAccess) -> f32;
 }
 
-pub const ALL_CODEC_TYPES: [FastFieldCodecType; 3] = [
+#[derive(Debug, Clone)]
-    FastFieldCodecType::Bitpacked,
+/// Statistics are used in codec detection and stored in the fast field footer.
-    FastFieldCodecType::BlockwiseLinear,
+pub struct FastFieldStats {
-    FastFieldCodecType::Linear,
+    pub min_value: u64,
-];
+    pub max_value: u64,
+    pub num_vals: u64,
+}
+
+impl<'a> FastFieldDataAccess for &'a [u64] {
+    fn get_val(&self, position: u64) -> u64 {
+        self[position as usize]
+    }
+
+    fn iter<'b>(&'b self) -> Box<dyn Iterator<Item = u64> + 'b> {
+        Box::new((self as &[u64]).iter().cloned())
+    }
+
+    fn min_value(&self) -> u64 {
+        self.iter().min().unwrap_or(0)
+    }
+
+    fn max_value(&self) -> u64 {
+        self.iter().max().unwrap_or(0)
+    }
+
+    fn num_vals(&self) -> u64 {
+        self.len() as u64
+    }
+}
+
+impl FastFieldDataAccess for Vec<u64> {
+    fn get_val(&self, position: u64) -> u64 {
+        self[position as usize]
+    }
+    fn iter<'b>(&'b self) -> Box<dyn Iterator<Item = u64> + 'b> {
+        Box::new((self as &[u64]).iter().cloned())
+    }
+    fn min_value(&self) -> u64 {
+        self.iter().min().unwrap_or(0)
+    }
+
+    fn max_value(&self) -> u64 {
+        self.iter().max().unwrap_or(0)
+    }
+
+    fn num_vals(&self) -> u64 {
+        self.len() as u64
+    }
+}
 
 #[cfg(test)]
 mod tests {
-    use proptest::prelude::*;
+    use proptest::arbitrary::any;
-    use proptest::strategy::Strategy;
+    use proptest::proptest;
-    use proptest::{prop_oneof, proptest};
 
     use crate::bitpacked::BitpackedCodec;
     use crate::blockwise_linear::BlockwiseLinearCodec;
     use crate::linear::LinearCodec;
-    use crate::serialize::Header;
 
-    pub(crate) fn create_and_validate<Codec: FastFieldCodec>(
+    pub fn create_and_validate<Codec: FastFieldCodec>(data: &[u64], name: &str) -> (f32, f32) {
-        data: &[u64],
+        if !Codec::is_applicable(&data) {
-        name: &str,
+            return (f32::MAX, 0.0);
-    ) -> Option<(f32, f32)> {
+        }
-        let col = &VecColumn::from(data);
+        let estimation = Codec::estimate(&data);
-        let header = Header::compute_header(col, &[Codec::CODEC_TYPE])?;
+        let mut out: Vec<u8> = Vec::new();
-        let normalized_col = header.normalize_column(col);
+        Codec::serialize(&mut out, &data).unwrap();
-        let estimation = Codec::estimate(&normalized_col)?;
-
-        let mut out = Vec::new();
-        let col = VecColumn::from(data);
-        serialize(col, &mut out, &[Codec::CODEC_TYPE]).unwrap();
 
         let actual_compression = out.len() as f32 / (data.len() as f32 * 8.0);
 
-        let reader = crate::open::<u64>(OwnedBytes::new(out)).unwrap();
+        let reader = Codec::open_from_bytes(OwnedBytes::new(out)).unwrap();
         assert_eq!(reader.num_vals(), data.len() as u64);
-        for (doc, orig_val) in data.iter().copied().enumerate() {
+        for (doc, orig_val) in data.iter().enumerate() {
             let val = reader.get_val(doc as u64);
-            assert_eq!(
+            if val != *orig_val {
-                val, orig_val,
+                panic!(
-                "val `{val}` does not match orig_val {orig_val:?}, in data set {name}, data \
+                    "val {val:?} does not match orig_val {orig_val:?}, in data set {name}, data \
-                 `{data:?}`",
+                     {data:?}",
-            );
+                );
+            }
         }
-        Some((estimation, actual_compression))
+        (estimation, actual_compression)
     }
 
     proptest! {
-        #![proptest_config(ProptestConfig::with_cases(100))]
-
         #[test]
-        fn test_proptest_small_bitpacked(data in proptest::collection::vec(num_strategy(), 1..10)) {
+        fn test_proptest_small(data in proptest::collection::vec(any::<u64>(), 1..10)) {
+            create_and_validate::<LinearCodec>(&data, "proptest linearinterpol");
+            create_and_validate::<BlockwiseLinearCodec>(&data, "proptest multilinearinterpol");
             create_and_validate::<BitpackedCodec>(&data, "proptest bitpacked");
         }
 
         #[test]
-        fn test_proptest_small_linear(data in proptest::collection::vec(num_strategy(), 1..10)) {
+        fn test_proptest_large(data in proptest::collection::vec(any::<u64>(), 1..6000)) {
             create_and_validate::<LinearCodec>(&data, "proptest linearinterpol");
-        }
-
-        #[test]
-        fn test_proptest_small_blockwise_linear(data in proptest::collection::vec(num_strategy(), 1..10)) {
             create_and_validate::<BlockwiseLinearCodec>(&data, "proptest multilinearinterpol");
-        }
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(10))]
-
-        #[test]
-        fn test_proptest_large_bitpacked(data in proptest::collection::vec(num_strategy(), 1..6000)) {
             create_and_validate::<BitpackedCodec>(&data, "proptest bitpacked");
         }
 
-        #[test]
-        fn test_proptest_large_linear(data in proptest::collection::vec(num_strategy(), 1..6000)) {
-            create_and_validate::<LinearCodec>(&data, "proptest linearinterpol");
-        }
-
-        #[test]
-        fn test_proptest_large_blockwise_linear(data in proptest::collection::vec(num_strategy(), 1..6000)) {
-            create_and_validate::<BlockwiseLinearCodec>(&data, "proptest multilinearinterpol");
-        }
     }
 
-    fn num_strategy() -> impl Strategy<Value = u64> {
+    pub fn get_codec_test_data_sets() -> Vec<(Vec<u64>, &'static str)> {
-        prop_oneof![
-            1 => prop::num::u64::ANY.prop_map(|num| u64::MAX - (num % 10) ),
-            1 => prop::num::u64::ANY.prop_map(|num| num % 10 ),
-            20 => prop::num::u64::ANY,
-        ]
-    }
-
-    pub fn get_codec_test_datasets() -> Vec<(Vec<u64>, &'static str)> {
         let mut data_and_names = vec![];
 
-        let data = (10..=10_000_u64).collect::<Vec<_>>();
+        let data = (10..=20_u64).collect::<Vec<_>>();
         data_and_names.push((data, "simple monotonically increasing"));
 
         data_and_names.push((
@@ -239,23 +206,17 @@ mod tests {
         data_and_names.push((vec![5, 50, 3, 13, 1, 1000, 35], "rand small"));
         data_and_names.push((vec![10], "single value"));
 
-        data_and_names.push((
-            vec![1572656989877777, 1170935903116329, 720575940379279, 0],
-            "overflow error",
-        ));
-
         data_and_names
     }
 
     fn test_codec<C: FastFieldCodec>() {
         let codec_name = format!("{:?}", C::CODEC_TYPE);
-        for (data, dataset_name) in get_codec_test_datasets() {
+        for (data, dataset_name) in get_codec_test_data_sets() {
-            let estimate_actual_opt: Option<(f32, f32)> =
+            let (estimate, actual) = crate::tests::create_and_validate::<C>(&data, dataset_name);
-                crate::tests::create_and_validate::<C>(&data, dataset_name);
+            let result = if estimate == f32::MAX {
-            let result = if let Some((estimate, actual)) = estimate_actual_opt {
-                format!("Estimate `{estimate}` Actual `{actual}`")
-            } else {
                 "Disabled".to_string()
+            } else {
+                format!("Estimate `{estimate}` Actual `{actual}`")
             };
             println!("Codec {codec_name}, DataSet {dataset_name}, {result}");
         }
@@ -278,50 +239,38 @@ mod tests {
     #[test]
     fn estimation_good_interpolation_case() {
         let data = (10..=20000_u64).collect::<Vec<_>>();
-        let data: VecColumn = data.as_slice().into();
 
-        let linear_interpol_estimation = LinearCodec::estimate(&data).unwrap();
+        let linear_interpol_estimation = LinearCodec::estimate(&data);
         assert_le!(linear_interpol_estimation, 0.01);
 
-        let multi_linear_interpol_estimation = BlockwiseLinearCodec::estimate(&data).unwrap();
+        let multi_linear_interpol_estimation = BlockwiseLinearCodec::estimate(&data);
         assert_le!(multi_linear_interpol_estimation, 0.2);
-        assert_lt!(linear_interpol_estimation, multi_linear_interpol_estimation);
+        assert_le!(linear_interpol_estimation, multi_linear_interpol_estimation);
 
-        let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+        let bitpacked_estimation = BitpackedCodec::estimate(&data);
-        assert_lt!(linear_interpol_estimation, bitpacked_estimation);
+        assert_le!(linear_interpol_estimation, bitpacked_estimation);
     }
     #[test]
     fn estimation_test_bad_interpolation_case() {
-        let data: &[u64] = &[200, 10, 10, 10, 10, 1000, 20];
+        let data = vec![200, 10, 10, 10, 10, 1000, 20];
 
-        let data: VecColumn = data.into();
+        let linear_interpol_estimation = LinearCodec::estimate(&data);
-        let linear_interpol_estimation = LinearCodec::estimate(&data).unwrap();
+        assert_le!(linear_interpol_estimation, 0.32);
-        assert_le!(linear_interpol_estimation, 0.34);
 
-        let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+        let bitpacked_estimation = BitpackedCodec::estimate(&data);
-        assert_lt!(bitpacked_estimation, linear_interpol_estimation);
+        assert_le!(bitpacked_estimation, linear_interpol_estimation);
     }
-
-    #[test]
-    fn estimation_prefer_bitpacked() {
-        let data = VecColumn::from(&[10, 10, 10, 10]);
-        let linear_interpol_estimation = LinearCodec::estimate(&data).unwrap();
-        let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
-        assert_lt!(bitpacked_estimation, linear_interpol_estimation);
-    }
-
     #[test]
     fn estimation_test_bad_interpolation_case_monotonically_increasing() {
-        let mut data: Vec<u64> = (200..=20000_u64).collect();
+        let mut data = (200..=20000_u64).collect::<Vec<_>>();
         data.push(1_000_000);
-        let data: VecColumn = data.as_slice().into();
 
         // in this case the linear interpolation can't in fact not be worse than bitpacking,
         // but the estimator adds some threshold, which leads to estimated worse behavior
-        let linear_interpol_estimation = LinearCodec::estimate(&data).unwrap();
+        let linear_interpol_estimation = LinearCodec::estimate(&data);
         assert_le!(linear_interpol_estimation, 0.35);
 
-        let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+        let bitpacked_estimation = BitpackedCodec::estimate(&data);
         assert_le!(bitpacked_estimation, 0.32);
         assert_le!(bitpacked_estimation, linear_interpol_estimation);
     }
@@ -335,134 +284,6 @@ mod tests {
                 count_codec += 1;
             }
         }
-        assert_eq!(count_codec, 3);
+        assert_eq!(count_codec, 4);
-    }
-}
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-    use std::sync::Arc;
-
-    use ownedbytes::OwnedBytes;
-    use rand::rngs::StdRng;
-    use rand::{Rng, SeedableRng};
-    use test::{self, Bencher};
-
-    use super::*;
-    use crate::Column;
-
-    fn get_data() -> Vec<u64> {
-        let mut rng = StdRng::seed_from_u64(2u64);
-        let mut data: Vec<_> = (100..55000_u64)
-            .map(|num| num + rng.gen::<u8>() as u64)
-            .collect();
-        data.push(99_000);
-        data.insert(1000, 2000);
-        data.insert(2000, 100);
-        data.insert(3000, 4100);
-        data.insert(4000, 100);
-        data.insert(5000, 800);
-        data
-    }
-
-    #[inline(never)]
-    fn value_iter() -> impl Iterator<Item = u64> {
-        0..20_000
-    }
-    fn get_reader_for_bench<Codec: FastFieldCodec>(data: &[u64]) -> Codec::Reader {
-        let mut bytes = Vec::new();
-        let min_value = *data.iter().min().unwrap();
-        let data = data.iter().map(|el| *el - min_value).collect::<Vec<_>>();
-        let col = VecColumn::from(&data);
-        let normalized_header = crate::NormalizedHeader {
-            num_vals: col.num_vals(),
-            max_value: col.max_value(),
-        };
-        Codec::serialize(&VecColumn::from(&data), &mut bytes).unwrap();
-        Codec::open_from_bytes(OwnedBytes::new(bytes), normalized_header).unwrap()
-    }
-    fn bench_get<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
-        let col = get_reader_for_bench::<Codec>(data);
-        b.iter(|| {
-            let mut sum = 0u64;
-            for pos in value_iter() {
-                let val = col.get_val(pos as u64);
-                sum = sum.wrapping_add(val);
-            }
-            sum
-        });
-    }
-
-    #[inline(never)]
-    fn bench_get_dynamic_helper(b: &mut Bencher, col: Arc<dyn Column>) {
-        b.iter(|| {
-            let mut sum = 0u64;
-            for pos in value_iter() {
-                let val = col.get_val(pos as u64);
-                sum = sum.wrapping_add(val);
-            }
-            sum
-        });
-    }
-
-    fn bench_get_dynamic<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
-        let col = Arc::new(get_reader_for_bench::<Codec>(data));
-        bench_get_dynamic_helper(b, col);
-    }
-    fn bench_create<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
-        let min_value = *data.iter().min().unwrap();
-        let data = data.iter().map(|el| *el - min_value).collect::<Vec<_>>();
-
-        let mut bytes = Vec::new();
-        b.iter(|| {
-            bytes.clear();
-            Codec::serialize(&VecColumn::from(&data), &mut bytes).unwrap();
-        });
-    }
-
-    #[bench]
-    fn bench_fastfield_bitpack_create(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_create::<BitpackedCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_linearinterpol_create(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_create::<LinearCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_multilinearinterpol_create(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_create::<BlockwiseLinearCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_bitpack_get(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get::<BitpackedCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_bitpack_get_dynamic(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get_dynamic::<BitpackedCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_linearinterpol_get(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get::<LinearCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_linearinterpol_get_dynamic(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get_dynamic::<LinearCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_multilinearinterpol_get(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get::<BlockwiseLinearCodec>(b, &data);
-    }
-    #[bench]
-    fn bench_fastfield_multilinearinterpol_get_dynamic(b: &mut Bencher) {
-        let data: Vec<_> = get_data();
-        bench_get_dynamic::<BlockwiseLinearCodec>(b, &data);
     }
 }

fastfield_codecs/src/line.rs

@@ -1,206 +0,0 @@
-use std::io;
-use std::num::NonZeroU64;
-
-use common::{BinarySerializable, VInt};
-
-use crate::Column;
-
-const MID_POINT: u64 = (1u64 << 32) - 1u64;
-
-/// `Line` describes a line function `y: ax + b` using integer
-/// arithmetics.
-///
-/// The slope is in fact a decimal split into a 32 bit integer value,
-/// and a 32-bit decimal value.
-///
-/// The multiplication then becomes.
-/// `y = m * x >> 32 + b`
-#[derive(Debug, Clone, Copy, Default)]
-pub struct Line {
-    slope: u64,
-    intercept: u64,
-}
-
-/// Compute the line slope.
-///
-/// This function has the nice property of being
-/// invariant by translation.
-/// `
-///   compute_slope(y0, y1)
-/// = compute_slope(y0 + X % 2^64, y1 + X % 2^64)
-/// `
-fn compute_slope(y0: u64, y1: u64, num_vals: NonZeroU64) -> u64 {
-    let dy = y1.wrapping_sub(y0);
-    let sign = dy <= (1 << 63);
-    let abs_dy = if sign {
-        y1.wrapping_sub(y0)
-    } else {
-        y0.wrapping_sub(y1)
-    };
-    if abs_dy >= 1 << 32 {
-        // This is outside of realm we handle.
-        // Let's just bail.
-        return 0u64;
-    }
-
-    let abs_slope = (abs_dy << 32) / num_vals.get();
-    if sign {
-        abs_slope
-    } else {
-        // The complement does indeed create the
-        // opposite decreasing slope...
-        //
-        // Intuitively (without the bitshifts and % u64::MAX)
-        // ```
-        //    (x + shift)*(u64::MAX - abs_slope)
-        // -  (x * (u64::MAX - abs_slope))
-        // = - shift * abs_slope
-        // ```
-        u64::MAX - abs_slope
-    }
-}
-
-impl Line {
-    #[inline(always)]
-    pub fn eval(&self, x: u64) -> u64 {
-        let linear_part = (x.wrapping_mul(self.slope) >> 32) as i32 as u64;
-        self.intercept.wrapping_add(linear_part)
-    }
-
-    // Same as train, but the intercept is only estimated from provided sample positions
-    pub fn estimate(ys: &dyn Column, sample_positions: &[u64]) -> Self {
-        Self::train_from(ys, sample_positions.iter().cloned())
-    }
-
-    // Intercept is only computed from provided positions
-    fn train_from(ys: &dyn Column, positions: impl Iterator<Item = u64>) -> Self {
-        let last_idx = if let Some(last_idx) = NonZeroU64::new(ys.num_vals() - 1) {
-            last_idx
-        } else {
-            return Line::default();
-        };
-
-        let mut ys_reader = ys.reader();
-        let y0 = ys_reader.seek(0);
-        let y1 = ys_reader.seek(last_idx.get());
-
-        // We first independently pick our slope.
-        let slope = compute_slope(y0, y1, last_idx);
-
-        // We picked our slope. Note that it does not have to be perfect.
-        // Now we need to compute the best intercept.
-        //
-        // Intuitively, the best intercept is such that line passes through one of the
-        // `(i, ys[])`.
-        //
-        // The best intercept therefore has the form
-        // `y[i] - line.eval(i)` (using wrapping arithmetics).
-        // In other words, the best intercept is one of the `y - Line::eval(ys[i])`
-        // and our task is just to pick the one that minimizes our error.
-        //
-        // Without sorting our values, this is a difficult problem.
-        // We however rely on the following trick...
-        //
-        // We only focus on the case where the interpolation is half decent.
-        // If the line interpolation is doing its job on a dataset suited for it,
-        // we can hope that the maximum error won't be larger than `u64::MAX / 2`.
-        //
-        // In other words, even without the intercept the values `y - Line::eval(ys[i])` will all be
-        // within an interval that takes less than half of the modulo space of `u64`.
-        //
-        // Our task is therefore to identify this interval.
-        // Here we simply translate all of our values by `y0 - 2^63` and pick the min.
-        let mut line = Line {
-            slope,
-            intercept: 0,
-        };
-        let heuristic_shift = y0.wrapping_sub(MID_POINT);
-        let mut ys_reader = ys.reader();
-        line.intercept = positions
-            .map(|pos| {
-                let y = ys_reader.seek(pos);
-                y.wrapping_sub(line.eval(pos))
-            })
-            .min_by_key(|&val| val.wrapping_sub(heuristic_shift))
-            .unwrap_or(0u64); //< Never happens.
-        line
-    }
-
-    /// Returns a line that attemps to approximate a function
-    /// f: i in 0..[ys.num_vals()) -> ys[i].
-    ///
-    /// - The approximation is always lower than the actual value.
-    /// Or more rigorously, formally `f(i).wrapping_sub(ys[i])` is small
-    /// for any i in [0..ys.len()).
-    /// - It computes without panicking for any value of it.
-    ///
-    /// This function is only invariable by translation if all of the
-    /// `ys` are packaged into half of the space. (See heuristic below)
-    pub fn train(ys: &dyn Column) -> Self {
-        Self::train_from(ys, 0..ys.num_vals())
-    }
-}
-
-impl BinarySerializable for Line {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        VInt(self.slope).serialize(writer)?;
-        VInt(self.intercept).serialize(writer)?;
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let slope = VInt::deserialize(reader)?.0;
-        let intercept = VInt::deserialize(reader)?.0;
-        Ok(Line { slope, intercept })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::VecColumn;
-
-    /// Test training a line and ensuring that the maximum difference between
-    /// the data points and the line is `expected`.
-    ///
-    /// This function operates translation over the data for better coverage.
-    #[track_caller]
-    fn test_line_interpol_with_translation(ys: &[u64], expected: Option<u64>) {
-        let mut translations = vec![0, 100, u64::MAX / 2, u64::MAX, u64::MAX - 1];
-        translations.extend_from_slice(ys);
-        for translation in translations {
-            let translated_ys: Vec<u64> = ys
-                .iter()
-                .copied()
-                .map(|y| y.wrapping_add(translation))
-                .collect();
-            let largest_err = test_eval_max_err(&translated_ys);
-            assert_eq!(largest_err, expected);
-        }
-    }
-
-    fn test_eval_max_err(ys: &[u64]) -> Option<u64> {
-        let line = Line::train(&VecColumn::from(&ys));
-        ys.iter()
-            .enumerate()
-            .map(|(x, y)| y.wrapping_sub(line.eval(x as u64)))
-            .max()
-    }
-
-    #[test]
-    fn test_train() {
-        test_line_interpol_with_translation(&[11, 11, 11, 12, 12, 13], Some(1));
-        test_line_interpol_with_translation(&[13, 12, 12, 11, 11, 11], Some(1));
-        test_line_interpol_with_translation(&[13, 13, 12, 11, 11, 11], Some(1));
-        test_line_interpol_with_translation(&[13, 13, 12, 11, 11, 11], Some(1));
-        test_line_interpol_with_translation(&[u64::MAX - 1, 0, 0, 1], Some(1));
-        test_line_interpol_with_translation(&[u64::MAX - 1, u64::MAX, 0, 1], Some(0));
-        test_line_interpol_with_translation(&[0, 1, 2, 3, 5], Some(0));
-        test_line_interpol_with_translation(&[1, 2, 3, 4], Some(0));
-
-        let data: Vec<u64> = (0..255).collect();
-        test_line_interpol_with_translation(&data, Some(0));
-        let data: Vec<u64> = (0..255).map(|el| el * 2).collect();
-        test_line_interpol_with_translation(&data, Some(0));
-    }
-}

fastfield_codecs/src/linear.rs

@@ -1,44 +1,80 @@
-use std::io::{self, Write};
+use std::io::{self, Read, Write};
+use std::ops::Sub;
 
-use common::BinarySerializable;
+use common::{BinarySerializable, FixedSize};
 use ownedbytes::OwnedBytes;
 use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
-use crate::line::Line;
+use crate::{FastFieldCodec, FastFieldCodecType, FastFieldDataAccess};
-use crate::serialize::NormalizedHeader;
-use crate::{Column, FastFieldCodec, FastFieldCodecType};
 
 /// Depending on the field type, a different
 /// fast field is required.
 #[derive(Clone)]
 pub struct LinearReader {
     data: OwnedBytes,
-    linear_params: LinearParams,
+    bit_unpacker: BitUnpacker,
-    header: NormalizedHeader,
+    pub footer: LinearFooter,
+    pub slope: f32,
 }
 
-impl Column for LinearReader {
+#[derive(Clone, Debug)]
+pub struct LinearFooter {
+    pub relative_max_value: u64,
+    pub offset: u64,
+    pub first_val: u64,
+    pub last_val: u64,
+    pub num_vals: u64,
+    pub min_value: u64,
+    pub max_value: u64,
+}
+
+impl BinarySerializable for LinearFooter {
+    fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
+        self.relative_max_value.serialize(write)?;
+        self.offset.serialize(write)?;
+        self.first_val.serialize(write)?;
+        self.last_val.serialize(write)?;
+        self.num_vals.serialize(write)?;
+        self.min_value.serialize(write)?;
+        self.max_value.serialize(write)?;
+        Ok(())
+    }
+
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<LinearFooter> {
+        Ok(LinearFooter {
+            relative_max_value: u64::deserialize(reader)?,
+            offset: u64::deserialize(reader)?,
+            first_val: u64::deserialize(reader)?,
+            last_val: u64::deserialize(reader)?,
+            num_vals: u64::deserialize(reader)?,
+            min_value: u64::deserialize(reader)?,
+            max_value: u64::deserialize(reader)?,
+        })
+    }
+}
+
+impl FixedSize for LinearFooter {
+    const SIZE_IN_BYTES: usize = 56;
+}
+
+impl FastFieldDataAccess for LinearReader {
     #[inline]
     fn get_val(&self, doc: u64) -> u64 {
-        let interpoled_val: u64 = self.linear_params.line.eval(doc);
+        let calculated_value = get_calculated_value(self.footer.first_val, doc, self.slope);
-        let bitpacked_diff = self.linear_params.bit_unpacker.get(doc, &self.data);
+        (calculated_value + self.bit_unpacker.get(doc, &self.data)) - self.footer.offset
-        interpoled_val.wrapping_add(bitpacked_diff)
     }
 
     #[inline]
     fn min_value(&self) -> u64 {
-        // The LinearReader assumes a normalized vector.
+        self.footer.min_value
-        0u64
     }
-
     #[inline]
     fn max_value(&self) -> u64 {
-        self.header.max_value
+        self.footer.max_value
     }
-
     #[inline]
     fn num_vals(&self) -> u64 {
-        self.header.num_vals
+        self.footer.num_vals
     }
 }
 
@@ -46,26 +82,42 @@ impl Column for LinearReader {
 /// and stores the difference bitpacked.
 pub struct LinearCodec;
 
-#[derive(Debug, Clone)]
+#[inline]
-struct LinearParams {
+pub(crate) fn get_slope(first_val: u64, last_val: u64, num_vals: u64) -> f32 {
-    line: Line,
+    if num_vals <= 1 {
-    bit_unpacker: BitUnpacker,
+        return 0.0;
+    }
+    //  We calculate the slope with f64 high precision and use the result in lower precision f32
+    //  This is done in order to handle estimations for very large values like i64::MAX
+    let diff = diff(last_val, first_val);
+    (diff / (num_vals - 1) as f64) as f32
 }
 
-impl BinarySerializable for LinearParams {
+/// Delay the cast, to improve precision for very large u64 values.
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+///
-        self.line.serialize(writer)?;
+/// Since i64 is mapped monotonically to u64 space, 0i64 is after the mapping i64::MAX.
-        self.bit_unpacker.bit_width().serialize(writer)?;
+/// So very large values are not uncommon.
-        Ok(())
+///
+/// ```rust
+///     let val1 = i64::MAX;
+///     let val2 = i64::MAX - 100;
+///     assert_eq!(val1 - val2, 100);
+///     assert_eq!(val1 as f64 - val2 as f64, 0.0);
+/// ```
+fn diff(val1: u64, val2: u64) -> f64 {
+    if val1 >= val2 {
+        (val1 - val2) as f64
+    } else {
+        (val2 - val1) as f64 * -1.0
     }
+}
 
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+#[inline]
-        let line = Line::deserialize(reader)?;
+pub fn get_calculated_value(first_val: u64, pos: u64, slope: f32) -> u64 {
-        let bit_width = u8::deserialize(reader)?;
+    if slope < 0.0 {
-        Ok(Self {
+        first_val - (pos as f32 * -slope) as u64
-            line,
+    } else {
-            bit_unpacker: BitUnpacker::new(bit_width),
+        first_val + (pos as f32 * slope) as u64
-        })
     }
 }
 
@@ -75,112 +127,180 @@ impl FastFieldCodec for LinearCodec {
     type Reader = LinearReader;
 
     /// Opens a fast field given a file.
-    fn open_from_bytes(mut data: OwnedBytes, header: NormalizedHeader) -> io::Result<Self::Reader> {
+    fn open_from_bytes(bytes: OwnedBytes) -> io::Result<Self::Reader> {
-        let linear_params = LinearParams::deserialize(&mut data)?;
+        let footer_offset = bytes.len() - LinearFooter::SIZE_IN_BYTES;
+        let (data, mut footer) = bytes.split(footer_offset);
+        let footer = LinearFooter::deserialize(&mut footer)?;
+        let slope = get_slope(footer.first_val, footer.last_val, footer.num_vals);
+        let num_bits = compute_num_bits(footer.relative_max_value);
+        let bit_unpacker = BitUnpacker::new(num_bits);
         Ok(LinearReader {
             data,
-            linear_params,
+            bit_unpacker,
-            header,
+            footer,
+            slope,
         })
     }
 
     /// Creates a new fast field serializer.
-    fn serialize(column: &dyn Column, write: &mut impl Write) -> io::Result<()> {
+    fn serialize(
-        assert_eq!(column.min_value(), 0);
+        write: &mut impl Write,
-        let line = Line::train(column);
+        fastfield_accessor: &dyn FastFieldDataAccess,
+    ) -> io::Result<()> {
+        assert!(fastfield_accessor.min_value() <= fastfield_accessor.max_value());
 
-        let max_offset_from_line = crate::iter_from_reader(column.reader())
+        let first_val = fastfield_accessor.get_val(0);
-            .enumerate()
+        let last_val = fastfield_accessor.get_val(fastfield_accessor.num_vals() as u64 - 1);
-            .map(|(pos, actual_value)| {
+        let slope = get_slope(first_val, last_val, fastfield_accessor.num_vals());
-                let calculated_value = line.eval(pos as u64);
+        // calculate offset to ensure all values are positive
-                actual_value.wrapping_sub(calculated_value)
+        let mut offset = 0;
-            })
+        let mut rel_positive_max = 0;
-            .max()
+        for (pos, actual_value) in fastfield_accessor.iter().enumerate() {
-            .unwrap();
+            let calculated_value = get_calculated_value(first_val, pos as u64, slope);
-
+            if calculated_value > actual_value {
-        let num_bits = compute_num_bits(max_offset_from_line);
+                // negative value we need to apply an offset
-        let linear_params = LinearParams {
+                // we ignore negative values in the max value calculation, because negative values
-            line,
+                // will be offset to 0
-            bit_unpacker: BitUnpacker::new(num_bits),
+                offset = offset.max(calculated_value - actual_value);
-        };
+            } else {
-        linear_params.serialize(write)?;
+                // positive value no offset reuqired
-
+                rel_positive_max = rel_positive_max.max(actual_value - calculated_value);
-        let mut bit_packer = BitPacker::new();
-        let mut col_reader = column.reader();
-        for pos in 0.. {
-            if !col_reader.advance() {
-                break;
             }
-            let actual_value = col_reader.get();
+        }
-            let calculated_value = line.eval(pos as u64);
+
-            let offset = actual_value.wrapping_sub(calculated_value);
+        // rel_positive_max will be adjusted by offset
-            bit_packer.write(offset, num_bits, write)?;
+        let relative_max_value = rel_positive_max + offset;
+
+        let num_bits = compute_num_bits(relative_max_value);
+        let mut bit_packer = BitPacker::new();
+        for (pos, val) in fastfield_accessor.iter().enumerate() {
+            let calculated_value = get_calculated_value(first_val, pos as u64, slope);
+            let diff = (val + offset) - calculated_value;
+            bit_packer.write(diff, num_bits, write)?;
         }
         bit_packer.close(write)?;
 
+        let footer = LinearFooter {
+            relative_max_value,
+            offset,
+            first_val,
+            last_val,
+            num_vals: fastfield_accessor.num_vals(),
+            min_value: fastfield_accessor.min_value(),
+            max_value: fastfield_accessor.max_value(),
+        };
+        footer.serialize(write)?;
         Ok(())
     }
-
+    fn is_applicable(fastfield_accessor: &impl FastFieldDataAccess) -> bool {
+        if fastfield_accessor.num_vals() < 3 {
+            return false; // disable compressor for this case
+        }
+        // On serialisation the offset is added to the actual value.
+        // We need to make sure this won't run into overflow calculation issues.
+        // For this we take the maximum theroretical offset and add this to the max value.
+        // If this doesn't overflow the algorithm should be fine
+        let theorethical_maximum_offset =
+            fastfield_accessor.max_value() - fastfield_accessor.min_value();
+        if fastfield_accessor
+            .max_value()
+            .checked_add(theorethical_maximum_offset)
+            .is_none()
+        {
+            return false;
+        }
+        true
+    }
     /// estimation for linear interpolation is hard because, you don't know
     /// where the local maxima for the deviation of the calculated value are and
     /// the offset to shift all values to >=0 is also unknown.
-    #[allow(clippy::question_mark)]
+    fn estimate(fastfield_accessor: &impl FastFieldDataAccess) -> f32 {
-    fn estimate(column: &impl Column) -> Option<f32> {
+        let first_val = fastfield_accessor.get_val(0);
-        if column.num_vals() < 3 {
+        let last_val = fastfield_accessor.get_val(fastfield_accessor.num_vals() as u64 - 1);
-            return None; // disable compressor for this case
+        let slope = get_slope(first_val, last_val, fastfield_accessor.num_vals());
-        }
 
         // let's sample at 0%, 5%, 10% .. 95%, 100%
-        let num_vals = column.num_vals() as f32 / 100.0;
+        let num_vals = fastfield_accessor.num_vals() as f32 / 100.0;
         let sample_positions = (0..20)
-            .map(|pos| (num_vals * pos as f32 * 5.0) as u64)
+            .map(|pos| (num_vals * pos as f32 * 5.0) as usize)
             .collect::<Vec<_>>();
 
-        let line = Line::estimate(column, &sample_positions);
+        let max_distance = sample_positions
-
+            .iter()
-        let mut column_reader = column.reader();
-        let estimated_bit_width = sample_positions
-            .into_iter()
             .map(|pos| {
-                let actual_value = column_reader.seek(pos);
+                let calculated_value = get_calculated_value(first_val, *pos as u64, slope);
-                let interpolated_val = line.eval(pos as u64);
+                let actual_value = fastfield_accessor.get_val(*pos as u64);
-                actual_value.wrapping_sub(interpolated_val)
+                distance(calculated_value, actual_value)
             })
-            .map(|diff| ((diff as f32 * 1.5) * 2.0) as u64)
-            .map(compute_num_bits)
             .max()
             .unwrap_or(0);
 
-        let num_bits = (estimated_bit_width as u64 * column.num_vals() as u64) + 64;
+        // the theory would be that we don't have the actual max_distance, but we are close within
-        let num_bits_uncompressed = 64 * column.num_vals();
+        // 50% threshold.
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
+        // It is multiplied by 2 because in a log case scenario the line would be as much above as
+        // below. So the offset would = max_distance
+        //
+        let relative_max_value = (max_distance as f32 * 1.5) * 2.0;
+
+        let num_bits = compute_num_bits(relative_max_value as u64) as u64
+            * fastfield_accessor.num_vals()
+            + LinearFooter::SIZE_IN_BYTES as u64;
+        let num_bits_uncompressed = 64 * fastfield_accessor.num_vals();
+        num_bits as f32 / num_bits_uncompressed as f32
+    }
+}
+
+#[inline]
+fn distance<T: Sub<Output = T> + Ord>(x: T, y: T) -> T {
+    if x < y {
+        y - x
+    } else {
+        x - y
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use rand::RngCore;
-
     use super::*;
-    use crate::tests::get_codec_test_datasets;
+    use crate::tests::get_codec_test_data_sets;
 
-    fn create_and_validate(data: &[u64], name: &str) -> Option<(f32, f32)> {
+    fn create_and_validate(data: &[u64], name: &str) -> (f32, f32) {
-        crate::tests::create_and_validate::<LinearCodec>(data, name)
+        crate::tests::create_and_validate::<LinearCodec, LinearReader>(data, name)
+    }
+
+    #[test]
+    fn get_calculated_value_test() {
+        // pos slope
+        assert_eq!(get_calculated_value(100, 10, 5.0), 150);
+
+        // neg slope
+        assert_eq!(get_calculated_value(100, 10, -5.0), 50);
+
+        // pos slope, very high values
+        assert_eq!(
+            get_calculated_value(i64::MAX as u64, 10, 5.0),
+            i64::MAX as u64 + 50
+        );
+        // neg slope, very high values
+        assert_eq!(
+            get_calculated_value(i64::MAX as u64, 10, -5.0),
+            i64::MAX as u64 - 50
+        );
     }
 
     #[test]
     fn test_compression() {
         let data = (10..=6_000_u64).collect::<Vec<_>>();
         let (estimate, actual_compression) =
-            create_and_validate(&data, "simple monotonically large").unwrap();
+            create_and_validate(&data, "simple monotonically large");
 
-        assert_le!(actual_compression, 0.001);
+        assert!(actual_compression < 0.01);
-        assert_le!(estimate, 0.02);
+        assert!(estimate < 0.01);
     }
 
     #[test]
-    fn test_with_codec_datasets() {
+    fn test_with_codec_data_sets() {
-        let data_sets = get_codec_test_datasets();
+        let data_sets = get_codec_test_data_sets();
         for (mut data, name) in data_sets {
             create_and_validate(&data, name);
             data.reverse();
@@ -197,13 +317,6 @@ mod tests {
 
         create_and_validate(&data, "large amplitude");
     }
-
-    #[test]
-    fn overflow_error_test() {
-        let data = vec![1572656989877777, 1170935903116329, 720575940379279, 0];
-        create_and_validate(&data, "overflow test");
-    }
-
     #[test]
     fn linear_interpol_fast_concave_data() {
         let data = vec![0, 1, 2, 5, 8, 10, 20, 50];
@@ -217,15 +330,16 @@ mod tests {
     #[test]
     fn linear_interpol_fast_field_test_simple() {
         let data = (10..=20_u64).collect::<Vec<_>>();
+
         create_and_validate(&data, "simple monotonically");
     }
 
     #[test]
     fn linear_interpol_fast_field_rand() {
-        let mut rng = rand::thread_rng();
+        for _ in 0..5000 {
-        for _ in 0..50 {
+            let mut data = (0..50).map(|_| rand::random::<u64>()).collect::<Vec<_>>();
-            let mut data = (0..10_000).map(|_| rng.next_u64()).collect::<Vec<_>>();
             create_and_validate(&data, "random");
+
             data.reverse();
             create_and_validate(&data, "random");
         }

fastfield_codecs/src/main.rs

@@ -1,159 +1,48 @@
 #[macro_use]
 extern crate prettytable;
-use std::collections::HashSet;
+use fastfield_codecs::blockwise_linear::BlockwiseLinearCodec;
-use std::env;
+use fastfield_codecs::linear::LinearCodec;
-use std::io::BufRead;
+use fastfield_codecs::{FastFieldCodec, FastFieldCodecType, FastFieldStats};
-use std::net::{IpAddr, Ipv6Addr};
-use std::str::FromStr;
-
-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]) {
-    println!("NumIps\t{}", ip_addrs.len());
-    let ip_addr_set: HashSet<u128> = ip_addrs.iter().cloned().collect();
-    println!("NumUniqueIps\t{}", ip_addr_set.len());
-    let ratio_unique = ip_addr_set.len() as f64 / ip_addrs.len() as f64;
-    println!("RatioUniqueOverTotal\t{ratio_unique:.4}");
-
-    // histogram
-    let mut ip_addrs = ip_addrs.to_vec();
-    ip_addrs.sort();
-    let mut cnts: Vec<usize> = ip_addrs
-        .into_iter()
-        .dedup_with_count()
-        .map(|(cnt, _)| cnt)
-        .collect();
-    cnts.sort();
-
-    let top_256_cnt: usize = cnts.iter().rev().take(256).sum();
-    let top_128_cnt: usize = cnts.iter().rev().take(128).sum();
-    let top_64_cnt: usize = cnts.iter().rev().take(64).sum();
-    let top_8_cnt: usize = cnts.iter().rev().take(8).sum();
-    let total: usize = cnts.iter().sum();
-
-    println!("{}", total);
-    println!("{}", top_256_cnt);
-    println!("{}", top_128_cnt);
-    println!("Percentage Top8 {:02}", top_8_cnt as f32 / total as f32);
-    println!("Percentage Top64 {:02}", top_64_cnt as f32 / total as f32);
-    println!("Percentage Top128 {:02}", top_128_cnt as f32 / total as f32);
-    println!("Percentage Top256 {:02}", top_256_cnt as f32 / total as f32);
-
-    let mut cnts: Vec<(usize, usize)> = cnts.into_iter().dedup_with_count().collect();
-    cnts.sort_by(|a, b| {
-        if a.1 == b.1 {
-            a.0.cmp(&b.0)
-        } else {
-            b.1.cmp(&a.1)
-        }
-    });
-}
-
-fn ip_dataset() -> Vec<u128> {
-    let mut ip_addr_v4 = 0;
-
-    let stdin = std::io::stdin();
-    let ip_addrs: Vec<u128> = stdin
-        .lock()
-        .lines()
-        .flat_map(|line| {
-            let line = line.unwrap();
-            let line = line.trim();
-            let ip_addr = IpAddr::from_str(line.trim()).ok()?;
-            if ip_addr.is_ipv4() {
-                ip_addr_v4 += 1;
-            }
-            let ip_addr_v6: Ipv6Addr = match ip_addr {
-                IpAddr::V4(v4) => v4.to_ipv6_mapped(),
-                IpAddr::V6(v6) => v6,
-            };
-            Some(ip_addr_v6)
-        })
-        .map(|ip_v6| u128::from_be_bytes(ip_v6.octets()))
-        .collect();
-
-    println!("IpAddrsAny\t{}", ip_addrs.len());
-    println!("IpAddrsV4\t{}", ip_addr_v4);
-
-    ip_addrs
-}
-
-fn bench_ip() {
-    let dataset = ip_dataset();
-    print_set_stats(&dataset);
-
-    // Chunks
-    {
-        let mut data = vec![];
-        for dataset in dataset.chunks(500_000) {
-            serialize_u128(VecColumn::from(dataset), &mut data).unwrap();
-        }
-        let compression = data.len() as f64 / (dataset.len() * 16) as f64;
-        println!("Compression 50_000 chunks {:.4}", compression);
-        println!(
-            "Num Bits per elem {:.2}",
-            (data.len() * 8) as f32 / dataset.len() as f32
-        );
-    }
-
-    let mut data = vec![];
-    serialize_u128(VecColumn::from(&dataset), &mut data).unwrap();
-
-    let compression = data.len() as f64 / (dataset.len() * 16) as f64;
-    println!("Compression {:.2}", compression);
-    println!(
-        "Num Bits per elem {:.2}",
-        (data.len() * 8) as f32 / dataset.len() as f32
-    );
-
-    let decompressor = open_u128(OwnedBytes::new(data)).unwrap();
-    // Sample some ranges
-    for value in dataset.iter().take(1110).skip(1100).cloned() {
-        print_time!("get range");
-        let doc_values = decompressor.get_between_vals(value..=value);
-        println!("{:?}", doc_values.len());
-    }
-}
-
 fn main() {
-    if env::args().nth(1).unwrap() == "bench_ip" {
-        bench_ip();
-        return;
-    }
-
     let mut table = Table::new();
 
     // Add a row per time
     table.add_row(row!["", "Compression Ratio", "Compression Estimation"]);
 
     for (data, data_set_name) in get_codec_test_data_sets() {
-        let results: Vec<(f32, f32, FastFieldCodecType)> = [
+        let mut results = vec![];
-            serialize_with_codec(&data, FastFieldCodecType::Bitpacked),
+        let res = serialize_with_codec::<LinearCodec>(&data);
-            serialize_with_codec(&data, FastFieldCodecType::Linear),
+        results.push(res);
-            serialize_with_codec(&data, FastFieldCodecType::BlockwiseLinear),
+        let res = serialize_with_codec::<BlockwiseLinearCodec>(&data);
-        ]
+        results.push(res);
-        .into_iter()
+        let res = serialize_with_codec::<fastfield_codecs::bitpacked::BitpackedCodec>(&data);
-        .flatten()
+        results.push(res);
-        .collect();
+
+        // let best_estimation_codec = results
+        //.iter()
+        //.min_by(|res1, res2| res1.partial_cmp(&res2).unwrap())
+        //.unwrap();
         let best_compression_ratio_codec = results
             .iter()
-            .min_by(|&res1, &res2| res1.partial_cmp(res2).unwrap())
+            .min_by(|res1, res2| res1.partial_cmp(res2).unwrap())
             .cloned()
             .unwrap();
 
         table.add_row(Row::new(vec![Cell::new(data_set_name).style_spec("Bbb")]));
-        for (est, comp, codec_type) in results {
+        for (is_applicable, est, comp, codec_type) in results {
-            let est_cell = est.to_string();
+            let (est_cell, ratio_cell) = if !is_applicable {
-            let ratio_cell = comp.to_string();
+                ("Codec Disabled".to_string(), "".to_string())
+            } else {
+                (est.to_string(), comp.to_string())
+            };
             let style = if comp == best_compression_ratio_codec.1 {
                 "Fb"
             } else {
                 ""
             };
+
             table.add_row(Row::new(vec![
                 Cell::new(&format!("{codec_type:?}")).style_spec("bFg"),
                 Cell::new(&ratio_cell).style_spec(style),
@@ -200,14 +89,27 @@ pub fn get_codec_test_data_sets() -> Vec<(Vec<u64>, &'static str)> {
     data_and_names
 }
 
-pub fn serialize_with_codec(
+pub fn serialize_with_codec<C: FastFieldCodec>(
     data: &[u64],
-    codec_type: FastFieldCodecType,
+) -> (bool, f32, f32, FastFieldCodecType) {
-) -> Option<(f32, f32, FastFieldCodecType)> {
+    let is_applicable = C::is_applicable(&data);
-    let col = VecColumn::from(data);
+    if !is_applicable {
-    let estimation = fastfield_codecs::estimate(&col, codec_type)?;
+        return (false, 0.0, 0.0, C::CODEC_TYPE);
-    let mut out = Vec::new();
+    }
-    fastfield_codecs::serialize(&col, &mut out, &[codec_type]).ok()?;
+    let estimation = C::estimate(&data);
-    let actual_compression = out.len() as f32 / (col.num_vals() * 8) as f32;
+    let mut out = vec![];
-    Some((estimation, actual_compression, codec_type))
+    C::serialize(&mut out, &data).unwrap();
+
+    let actual_compression = out.len() as f32 / (data.len() * 8) as f32;
+    (true, estimation, actual_compression, C::CODEC_TYPE)
+}
+
+pub fn stats_from_vec(data: &[u64]) -> FastFieldStats {
+    let min_value = data.iter().cloned().min().unwrap_or(0);
+    let max_value = data.iter().cloned().max().unwrap_or(0);
+    FastFieldStats {
+        min_value,
+        max_value,
+        num_vals: data.len() as u64,
+    }
 }

fastfield_codecs/src/monotonic_mapping.rs

@@ -1,60 +0,0 @@
-pub trait MonotonicallyMappableToU64: 'static + PartialOrd + Copy + Send + Sync {
-    /// Converts a value to u64.
-    ///
-    /// Internally all fast field values are encoded as u64.
-    fn to_u64(self) -> u64;
-
-    /// Converts a value from u64
-    ///
-    /// Internally all fast field values are encoded as u64.
-    /// **Note: To be used for converting encoded Term, Posting values.**
-    fn from_u64(val: u64) -> Self;
-}
-
-impl MonotonicallyMappableToU64 for u64 {
-    fn to_u64(self) -> u64 {
-        self
-    }
-
-    fn from_u64(val: u64) -> Self {
-        val
-    }
-}
-
-impl MonotonicallyMappableToU64 for i64 {
-    #[inline(always)]
-    fn to_u64(self) -> u64 {
-        common::i64_to_u64(self)
-    }
-
-    #[inline(always)]
-    fn from_u64(val: u64) -> Self {
-        common::u64_to_i64(val)
-    }
-}
-
-impl MonotonicallyMappableToU64 for bool {
-    #[inline(always)]
-    fn to_u64(self) -> u64 {
-        if self {
-            1
-        } else {
-            0
-        }
-    }
-
-    #[inline(always)]
-    fn from_u64(val: u64) -> Self {
-        val > 0
-    }
-}
-
-impl MonotonicallyMappableToU64 for f64 {
-    fn to_u64(self) -> u64 {
-        common::f64_to_u64(self)
-    }
-
-    fn from_u64(val: u64) -> Self {
-        common::u64_to_f64(val)
-    }
-}

fastfield_codecs/src/serialize.rs

@@ -1,276 +0,0 @@
-// Copyright (C) 2022 Quickwit, Inc.
-//
-// Quickwit is offered under the AGPL v3.0 and as commercial software.
-// For commercial licensing, contact us at hello@quickwit.io.
-//
-// AGPL:
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-use std::io;
-use std::num::NonZeroU64;
-use std::sync::Arc;
-
-use common::{BinarySerializable, VInt};
-use fastdivide::DividerU64;
-use log::warn;
-use ownedbytes::OwnedBytes;
-
-use crate::bitpacked::BitpackedCodec;
-use crate::blockwise_linear::BlockwiseLinearCodec;
-use crate::compact_space::CompactSpaceCompressor;
-use crate::linear::LinearCodec;
-use crate::{
-    iter_from_reader, monotonic_map_column, Column, FastFieldCodec, FastFieldCodecType,
-    MonotonicallyMappableToU64, VecColumn, ALL_CODEC_TYPES,
-};
-
-/// The normalized header gives some parameters after applying the following
-/// normalization of the vector:
-/// val -> (val - min_value) / gcd
-///
-/// By design, after normalization, `min_value = 0` and `gcd = 1`.
-#[derive(Debug, Copy, Clone)]
-pub struct NormalizedHeader {
-    pub num_vals: u64,
-    pub max_value: u64,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct Header {
-    pub num_vals: u64,
-    pub min_value: u64,
-    pub max_value: u64,
-    pub gcd: Option<NonZeroU64>,
-    pub codec_type: FastFieldCodecType,
-}
-
-impl Header {
-    pub fn normalized(self) -> NormalizedHeader {
-        let max_value =
-            (self.max_value - self.min_value) / self.gcd.map(|gcd| gcd.get()).unwrap_or(1);
-        NormalizedHeader {
-            num_vals: self.num_vals,
-            max_value,
-        }
-    }
-
-    pub fn normalize_column<C: Column>(&self, from_column: C) -> impl Column {
-        let min_value = self.min_value;
-        let gcd = self.gcd.map(|gcd| gcd.get()).unwrap_or(1);
-        let divider = DividerU64::divide_by(gcd);
-        monotonic_map_column(from_column, move |val| divider.divide(val - min_value))
-    }
-
-    pub fn compute_header(
-        column: impl Column<u64>,
-        codecs: &[FastFieldCodecType],
-    ) -> Option<Header> {
-        let num_vals = column.num_vals();
-        let min_value = column.min_value();
-        let max_value = column.max_value();
-        let gcd =
-            crate::gcd::find_gcd(iter_from_reader(column.reader()).map(|val| val - min_value))
-                .filter(|gcd| gcd.get() > 1u64);
-        let divider = DividerU64::divide_by(gcd.map(|gcd| gcd.get()).unwrap_or(1u64));
-        let shifted_column = monotonic_map_column(&column, |val| divider.divide(val - min_value));
-        let codec_type = detect_codec(shifted_column, codecs)?;
-        Some(Header {
-            num_vals,
-            min_value,
-            max_value,
-            gcd,
-            codec_type,
-        })
-    }
-}
-
-impl BinarySerializable for Header {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        VInt(self.num_vals).serialize(writer)?;
-        VInt(self.min_value).serialize(writer)?;
-        VInt(self.max_value - self.min_value).serialize(writer)?;
-        if let Some(gcd) = self.gcd {
-            VInt(gcd.get()).serialize(writer)?;
-        } else {
-            VInt(0u64).serialize(writer)?;
-        }
-        self.codec_type.serialize(writer)?;
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let num_vals = VInt::deserialize(reader)?.0;
-        let min_value = VInt::deserialize(reader)?.0;
-        let amplitude = VInt::deserialize(reader)?.0;
-        let max_value = min_value + amplitude;
-        let gcd_u64 = VInt::deserialize(reader)?.0;
-        let codec_type = FastFieldCodecType::deserialize(reader)?;
-        Ok(Header {
-            num_vals,
-            min_value,
-            max_value,
-            gcd: NonZeroU64::new(gcd_u64),
-            codec_type,
-        })
-    }
-}
-
-pub fn estimate<T: MonotonicallyMappableToU64>(
-    typed_column: impl Column<T>,
-    codec_type: FastFieldCodecType,
-) -> Option<f32> {
-    let column = monotonic_map_column(typed_column, T::to_u64);
-    let min_value = column.min_value();
-    let gcd = crate::gcd::find_gcd(iter_from_reader(column.reader()).map(|val| val - min_value))
-        .filter(|gcd| gcd.get() > 1u64);
-    let divider = DividerU64::divide_by(gcd.map(|gcd| gcd.get()).unwrap_or(1u64));
-    let normalized_column = monotonic_map_column(&column, |val| divider.divide(val - min_value));
-    match codec_type {
-        FastFieldCodecType::Bitpacked => BitpackedCodec::estimate(&normalized_column),
-        FastFieldCodecType::Linear => LinearCodec::estimate(&normalized_column),
-        FastFieldCodecType::BlockwiseLinear => BlockwiseLinearCodec::estimate(&normalized_column),
-    }
-}
-
-pub fn serialize_u128(
-    typed_column: impl Column<u128>,
-    output: &mut impl io::Write,
-) -> io::Result<()> {
-    // TODO write header, to later support more codecs
-    let compressor = CompactSpaceCompressor::train_from(&typed_column);
-    compressor
-        .compress_into(typed_column.reader(), output)
-        .unwrap();
-
-    Ok(())
-}
-
-pub fn serialize<T: MonotonicallyMappableToU64>(
-    typed_column: impl Column<T>,
-    output: &mut impl io::Write,
-    codecs: &[FastFieldCodecType],
-) -> io::Result<()> {
-    let column = monotonic_map_column(typed_column, T::to_u64);
-    let header = Header::compute_header(&column, codecs).ok_or_else(|| {
-        io::Error::new(
-            io::ErrorKind::InvalidInput,
-            format!(
-                "Data cannot be serialized with this list of codec. {:?}",
-                codecs
-            ),
-        )
-    })?;
-    header.serialize(output)?;
-    let normalized_column = header.normalize_column(column);
-    assert_eq!(normalized_column.min_value(), 0u64);
-    serialize_given_codec(normalized_column, header.codec_type, output)?;
-    Ok(())
-}
-
-fn detect_codec(
-    column: impl Column<u64>,
-    codecs: &[FastFieldCodecType],
-) -> Option<FastFieldCodecType> {
-    let mut estimations = Vec::new();
-    for &codec in codecs {
-        let estimation_opt = match codec {
-            FastFieldCodecType::Bitpacked => BitpackedCodec::estimate(&column),
-            FastFieldCodecType::Linear => LinearCodec::estimate(&column),
-            FastFieldCodecType::BlockwiseLinear => BlockwiseLinearCodec::estimate(&column),
-        };
-        if let Some(estimation) = estimation_opt {
-            estimations.push((estimation, codec));
-        }
-    }
-    if let Some(broken_estimation) = estimations.iter().find(|estimation| estimation.0.is_nan()) {
-        warn!(
-            "broken estimation for fast field codec {:?}",
-            broken_estimation.1
-        );
-    }
-    // removing nan values for codecs with broken calculations, and max values which disables
-    // codecs
-    estimations.retain(|estimation| !estimation.0.is_nan() && estimation.0 != f32::MAX);
-    estimations.sort_by(|(score_left, _), (score_right, _)| score_left.total_cmp(score_right));
-    Some(estimations.first()?.1)
-}
-
-fn serialize_given_codec(
-    column: impl Column<u64>,
-    codec_type: FastFieldCodecType,
-    output: &mut impl io::Write,
-) -> io::Result<()> {
-    match codec_type {
-        FastFieldCodecType::Bitpacked => {
-            BitpackedCodec::serialize(&column, output)?;
-        }
-        FastFieldCodecType::Linear => {
-            LinearCodec::serialize(&column, output)?;
-        }
-        FastFieldCodecType::BlockwiseLinear => {
-            BlockwiseLinearCodec::serialize(&column, output)?;
-        }
-    }
-    output.flush()?;
-    Ok(())
-}
-
-pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default>(
-    column: &[T],
-) -> Arc<dyn Column<T>> {
-    let mut buffer = Vec::new();
-    super::serialize(VecColumn::from(&column), &mut buffer, &ALL_CODEC_TYPES).unwrap();
-    super::open(OwnedBytes::new(buffer)).unwrap()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_serialize_deserialize() {
-        let original = [1u64, 5u64, 10u64];
-        let restored: Vec<u64> =
-            crate::iter_from_reader(serialize_and_load(&original[..]).reader()).collect();
-        assert_eq!(&restored, &original[..]);
-    }
-
-    #[test]
-    fn test_fastfield_bool_size_bitwidth_1() {
-        let mut buffer = Vec::new();
-        let col = VecColumn::from(&[false, true][..]);
-        serialize(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
-        // 5 bytes of header, 1 byte of value, 7 bytes of padding.
-        assert_eq!(buffer.len(), 5 + 8);
-    }
-
-    #[test]
-    fn test_fastfield_bool_bit_size_bitwidth_0() {
-        let mut buffer = Vec::new();
-        let col = VecColumn::from(&[true][..]);
-        serialize(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
-        // 5 bytes of header, 0 bytes of value, 7 bytes of padding.
-        assert_eq!(buffer.len(), 5 + 7);
-    }
-
-    #[test]
-    fn test_fastfield_gcd() {
-        let mut buffer = Vec::new();
-        let vals: Vec<u64> = (0..80).map(|val| (val % 7) * 1_000u64).collect();
-        let col = VecColumn::from(&vals[..]);
-        serialize(col, &mut buffer, &[FastFieldCodecType::Bitpacked]).unwrap();
-        // Values are stored over 3 bits.
-        assert_eq!(buffer.len(), 7 + (3 * 80 / 8) + 7);
-    }
-}

ownedbytes/src/lib.rs

@@ -6,7 +6,7 @@ use std::{fmt, io, mem};
 use stable_deref_trait::StableDeref;
 
 /// An OwnedBytes simply wraps an object that owns a slice of data and exposes
-/// this data as a slice.
+/// this data as a static slice.
 ///
 /// The backing object is required to be `StableDeref`.
 #[derive(Clone)]

query-grammar/src/query_grammar.rs

@@ -23,7 +23,7 @@ const ESCAPED_SPECIAL_CHARS_PATTERN: &str = r#"\\(\+|\^|`|:|\{|\}|"|\[|\]|\(|\)|
 /// Parses a field_name
 /// A field name must have at least one character and be followed by a colon.
 /// All characters are allowed including special characters `SPECIAL_CHARS`, but these
-/// need to be escaped with a backslash character '\'.
+/// need to be escaped with a backslack character '\'.
 fn field_name<'a>() -> impl Parser<&'a str, Output = String> {
     static ESCAPED_SPECIAL_CHARS_RE: Lazy<Regex> =
         Lazy::new(|| Regex::new(ESCAPED_SPECIAL_CHARS_PATTERN).unwrap());
@@ -68,7 +68,7 @@ fn word<'a>() -> impl Parser<&'a str, Output = String> {
 ///
 /// NOTE: also accepts 999999-99-99T99:99:99.266051969+99:99
 /// We delegate rejecting such invalid dates to the logical AST computation code
-/// which invokes `time::OffsetDateTime::parse(..., &Rfc3339)` on the value to actually parse
+/// which invokes time::OffsetDateTime::parse(..., &Rfc3339) on the value to actually parse
 /// it (instead of merely extracting the datetime value as string as done here).
 fn date_time<'a>() -> impl Parser<&'a str, Output = String> {
     let two_digits = || recognize::<String, _, _>((digit(), digit()));

src/aggregation/agg_req.rs

@@ -1,7 +1,7 @@
 //! Contains the aggregation request tree. Used to build an
-//! [`AggregationCollector`](super::AggregationCollector).
+//! [AggregationCollector](super::AggregationCollector).
 //!
-//! [`Aggregations`] is the top level entry point to create a request, which is a `HashMap<String,
+//! [Aggregations] is the top level entry point to create a request, which is a `HashMap<String,
 //! Aggregation>`.
 //!
 //! Requests are compatible with the json format of elasticsearch.
@@ -54,8 +54,8 @@ use super::bucket::{HistogramAggregation, TermsAggregation};
 use super::metric::{AverageAggregation, StatsAggregation};
 use super::VecWithNames;
 
-/// The top-level aggregation request structure, which contains [`Aggregation`] and their user
+/// The top-level aggregation request structure, which contains [Aggregation] and their user defined
-/// defined names. It is also used in [buckets](BucketAggregation) to define sub-aggregations.
+/// names. It is also used in [buckets](BucketAggregation) to define sub-aggregations.
 ///
 /// The key is the user defined name of the aggregation.
 pub type Aggregations = HashMap<String, Aggregation>;
@@ -139,15 +139,15 @@ pub fn get_fast_field_names(aggs: &Aggregations) -> HashSet<String> {
     fast_field_names
 }
 
-/// Aggregation request of [`BucketAggregation`] or [`MetricAggregation`].
+/// Aggregation request of [BucketAggregation] or [MetricAggregation].
 ///
 /// An aggregation is either a bucket or a metric.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Aggregation {
-    /// Bucket aggregation, see [`BucketAggregation`] for details.
+    /// Bucket aggregation, see [BucketAggregation] for details.
     Bucket(BucketAggregation),
-    /// Metric aggregation, see [`MetricAggregation`] for details.
+    /// Metric aggregation, see [MetricAggregation] for details.
     Metric(MetricAggregation),
 }
 

src/aggregation/agg_req_with_accessor.rs

@@ -4,14 +4,14 @@ use std::rc::Rc;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 
-use fastfield_codecs::Column;
-
 use super::agg_req::{Aggregation, Aggregations, BucketAggregationType, MetricAggregation};
 use super::bucket::{HistogramAggregation, RangeAggregation, TermsAggregation};
 use super::metric::{AverageAggregation, StatsAggregation};
 use super::segment_agg_result::BucketCount;
 use super::VecWithNames;
-use crate::fastfield::{type_and_cardinality, FastType, MultiValuedFastFieldReader};
+use crate::fastfield::{
+    type_and_cardinality, DynamicFastFieldReader, FastType, MultiValuedFastFieldReader,
+};
 use crate::schema::{Cardinality, Type};
 use crate::{InvertedIndexReader, SegmentReader, TantivyError};
 
@@ -37,16 +37,10 @@ impl AggregationsWithAccessor {
 #[derive(Clone)]
 pub(crate) enum FastFieldAccessor {
     Multi(MultiValuedFastFieldReader<u64>),
-    Single(Arc<dyn Column<u64>>),
+    Single(DynamicFastFieldReader<u64>),
 }
 impl FastFieldAccessor {
-    pub fn as_single(&self) -> Option<&dyn Column<u64>> {
+    pub fn as_single(&self) -> Option<&DynamicFastFieldReader<u64>> {
-        match self {
-            FastFieldAccessor::Multi(_) => None,
-            FastFieldAccessor::Single(reader) => Some(&**reader),
-        }
-    }
-    pub fn into_single(self) -> Option<Arc<dyn Column<u64>>> {
         match self {
             FastFieldAccessor::Multi(_) => None,
             FastFieldAccessor::Single(reader) => Some(reader),
@@ -124,7 +118,7 @@ impl BucketAggregationWithAccessor {
 pub struct MetricAggregationWithAccessor {
     pub metric: MetricAggregation,
     pub field_type: Type,
-    pub accessor: Arc<dyn Column>,
+    pub accessor: DynamicFastFieldReader<u64>,
 }
 
 impl MetricAggregationWithAccessor {
@@ -140,8 +134,9 @@ impl MetricAggregationWithAccessor {
 
                 Ok(MetricAggregationWithAccessor {
                     accessor: accessor
-                        .into_single()
+                        .as_single()
-                        .expect("unexpected fast field cardinality"),
+                        .expect("unexpected fast field cardinality")
+                        .clone(),
                     field_type,
                     metric: metric.clone(),
                 })

src/aggregation/agg_result.rs

@@ -113,14 +113,14 @@ pub enum BucketResult {
         ///
         /// If there are holes depends on the request, if min_doc_count is 0, then there are no
         /// holes between the first and last bucket.
-        /// See [`HistogramAggregation`](super::bucket::HistogramAggregation)
+        /// See [HistogramAggregation](super::bucket::HistogramAggregation)
         buckets: BucketEntries<BucketEntry>,
     },
     /// This is the term result
     Terms {
         /// The buckets.
         ///
-        /// See [`TermsAggregation`](super::bucket::TermsAggregation)
+        /// See [TermsAggregation](super::bucket::TermsAggregation)
         buckets: Vec<BucketEntry>,
         /// The number of documents that didn’t make it into to TOP N due to shard_size or size
         sum_other_doc_count: u64,
@@ -234,10 +234,10 @@ pub struct RangeBucketEntry {
     #[serde(flatten)]
     /// sub-aggregations in this bucket.
     pub sub_aggregation: AggregationResults,
-    /// The from range of the bucket. Equals `f64::MIN` when `None`.
+    /// The from range of the bucket. Equals f64::MIN when None.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub from: Option<f64>,
-    /// The to range of the bucket. Equals `f64::MAX` when `None`.
+    /// The to range of the bucket. Equals f64::MAX when None.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub to: Option<f64>,
 }

src/aggregation/bucket/histogram/histogram.rs

@@ -1,7 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt::Display;
 
-use fastfield_codecs::Column;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
@@ -15,6 +14,7 @@ use crate::aggregation::intermediate_agg_result::{
     IntermediateAggregationResults, IntermediateBucketResult, IntermediateHistogramBucketEntry,
 };
 use crate::aggregation::segment_agg_result::SegmentAggregationResultsCollector;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader};
 use crate::schema::Type;
 use crate::{DocId, TantivyError};
 
@@ -37,14 +37,14 @@ use crate::{DocId, TantivyError};
 /// [hard_bounds](HistogramAggregation::hard_bounds).
 ///
 /// # Result
-/// Result type is [`BucketResult`](crate::aggregation::agg_result::BucketResult) with
+/// Result type is [BucketResult](crate::aggregation::agg_result::BucketResult) with
-/// [`BucketEntry`](crate::aggregation::agg_result::BucketEntry) on the
+/// [BucketEntry](crate::aggregation::agg_result::BucketEntry) on the
-/// `AggregationCollector`.
+/// AggregationCollector.
 ///
 /// Result type is
-/// [`IntermediateBucketResult`](crate::aggregation::intermediate_agg_result::IntermediateBucketResult) with
+/// [crate::aggregation::intermediate_agg_result::IntermediateBucketResult] with
-/// [`IntermediateHistogramBucketEntry`](crate::aggregation::intermediate_agg_result::IntermediateHistogramBucketEntry) on the
+/// [crate::aggregation::intermediate_agg_result::IntermediateHistogramBucketEntry] on the
-/// `DistributedAggregationCollector`.
+/// DistributedAggregationCollector.
 ///
 /// # Limitations/Compatibility
 ///
@@ -61,7 +61,7 @@ use crate::{DocId, TantivyError};
 /// ```
 ///
 /// Response
-/// See [`BucketEntry`](crate::aggregation::agg_result::BucketEntry)
+/// See [BucketEntry](crate::aggregation::agg_result::BucketEntry)
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct HistogramAggregation {
@@ -263,7 +263,7 @@ impl SegmentHistogramCollector {
         req: &HistogramAggregation,
         sub_aggregation: &AggregationsWithAccessor,
         field_type: Type,
-        accessor: &dyn Column<u64>,
+        accessor: &DynamicFastFieldReader<u64>,
     ) -> crate::Result<Self> {
         req.validate()?;
         let min = f64_from_fastfield_u64(accessor.min_value(), &field_type);
@@ -331,10 +331,10 @@ impl SegmentHistogramCollector {
             .expect("unexpected fast field cardinatility");
         let mut iter = doc.chunks_exact(4);
         for docs in iter.by_ref() {
-            let val0 = self.f64_from_fastfield_u64(accessor.get_val(docs[0] as u64));
+            let val0 = self.f64_from_fastfield_u64(accessor.get(docs[0]));
-            let val1 = self.f64_from_fastfield_u64(accessor.get_val(docs[1] as u64));
+            let val1 = self.f64_from_fastfield_u64(accessor.get(docs[1]));
-            let val2 = self.f64_from_fastfield_u64(accessor.get_val(docs[2] as u64));
+            let val2 = self.f64_from_fastfield_u64(accessor.get(docs[2]));
-            let val3 = self.f64_from_fastfield_u64(accessor.get_val(docs[3] as u64));
+            let val3 = self.f64_from_fastfield_u64(accessor.get(docs[3]));
 
             let bucket_pos0 = get_bucket_num(val0);
             let bucket_pos1 = get_bucket_num(val1);
@@ -370,8 +370,8 @@ impl SegmentHistogramCollector {
                 &bucket_with_accessor.sub_aggregation,
             )?;
         }
-        for &doc in iter.remainder() {
+        for doc in iter.remainder() {
-            let val = f64_from_fastfield_u64(accessor.get_val(doc as u64), &self.field_type);
+            let val = f64_from_fastfield_u64(accessor.get(*doc), &self.field_type);
             if !bounds.contains(val) {
                 continue;
             }
@@ -382,7 +382,7 @@ impl SegmentHistogramCollector {
                 self.buckets[bucket_pos].key,
                 get_bucket_val(val, self.interval, self.offset) as f64
             );
-            self.increment_bucket(bucket_pos, doc, &bucket_with_accessor.sub_aggregation)?;
+            self.increment_bucket(bucket_pos, *doc, &bucket_with_accessor.sub_aggregation)?;
         }
         if force_flush {
             if let Some(sub_aggregations) = self.sub_aggregations.as_mut() {
@@ -518,7 +518,7 @@ pub(crate) fn intermediate_histogram_buckets_to_final_buckets(
 
 /// Applies req extended_bounds/hard_bounds on the min_max value
 ///
-/// May return `(f64::MAX, f64::MIN)`, if there is no range.
+/// May return (f64::MAX, f64::MIN), if there is no range.
 fn get_req_min_max(req: &HistogramAggregation, min_max: Option<(f64, f64)>) -> (f64, f64) {
     let (mut min, mut max) = min_max.unwrap_or((f64::MAX, f64::MIN));
 

src/aggregation/bucket/mod.rs

@@ -1,11 +1,11 @@
 //! Module for all bucket aggregations.
 //!
 //! BucketAggregations create buckets of documents
-//! [`BucketAggregation`](super::agg_req::BucketAggregation).
+//! [BucketAggregation](super::agg_req::BucketAggregation).
 //!
-//! Results of final buckets are [`BucketResult`](super::agg_result::BucketResult).
+//! Results of final buckets are [BucketResult](super::agg_result::BucketResult).
 //! Results of intermediate buckets are
-//! [`IntermediateBucketResult`](super::intermediate_agg_result::IntermediateBucketResult)
+//! [IntermediateBucketResult](super::intermediate_agg_result::IntermediateBucketResult)
 
 mod histogram;
 mod range;

src/aggregation/bucket/range.rs

@@ -12,6 +12,7 @@ use crate::aggregation::intermediate_agg_result::{
 };
 use crate::aggregation::segment_agg_result::{BucketCount, SegmentAggregationResultsCollector};
 use crate::aggregation::{f64_from_fastfield_u64, f64_to_fastfield_u64, Key, SerializedKey};
+use crate::fastfield::FastFieldReader;
 use crate::schema::Type;
 use crate::{DocId, TantivyError};
 
@@ -22,14 +23,14 @@ use crate::{DocId, TantivyError};
 /// against each bucket range. Note that this aggregation includes the from value and excludes the
 /// to value for each range.
 ///
-/// Result type is [`BucketResult`](crate::aggregation::agg_result::BucketResult) with
+/// Result type is [BucketResult](crate::aggregation::agg_result::BucketResult) with
-/// [`RangeBucketEntry`](crate::aggregation::agg_result::RangeBucketEntry) on the
+/// [RangeBucketEntry](crate::aggregation::agg_result::RangeBucketEntry) on the
-/// `AggregationCollector`.
+/// AggregationCollector.
 ///
 /// Result type is
-/// [`IntermediateBucketResult`](crate::aggregation::intermediate_agg_result::IntermediateBucketResult) with
+/// [crate::aggregation::intermediate_agg_result::IntermediateBucketResult] with
-/// [`IntermediateRangeBucketEntry`](crate::aggregation::intermediate_agg_result::IntermediateRangeBucketEntry) on the
+/// [crate::aggregation::intermediate_agg_result::IntermediateRangeBucketEntry] on the
-/// `DistributedAggregationCollector`.
+/// DistributedAggregationCollector.
 ///
 /// # Limitations/Compatibility
 /// Overlapping ranges are not yet supported.
@@ -67,11 +68,11 @@ pub struct RangeAggregationRange {
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub key: Option<String>,
     /// The from range value, which is inclusive in the range.
-    /// `None` equals to an open ended interval.
+    /// None equals to an open ended interval.
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub from: Option<f64>,
     /// The to range value, which is not inclusive in the range.
-    /// `None` equals to an open ended interval.
+    /// None equals to an open ended interval.
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub to: Option<f64>,
 }
@@ -101,7 +102,7 @@ impl From<Range<f64>> for RangeAggregationRange {
 pub(crate) struct InternalRangeAggregationRange {
     /// Custom key for the range bucket
     key: Option<String>,
-    /// `u64` range value
+    /// u64 range value
     range: Range<u64>,
 }
 
@@ -131,9 +132,9 @@ pub(crate) struct SegmentRangeBucketEntry {
     pub key: Key,
     pub doc_count: u64,
     pub sub_aggregation: Option<SegmentAggregationResultsCollector>,
-    /// The from range of the bucket. Equals `f64::MIN` when `None`.
+    /// The from range of the bucket. Equals f64::MIN when None.
     pub from: Option<f64>,
-    /// The to range of the bucket. Equals `f64::MAX` when `None`. Open interval, `to` is not
+    /// The to range of the bucket. Equals f64::MAX when None. Open interval, `to` is not
     /// inclusive.
     pub to: Option<f64>,
 }
@@ -261,12 +262,12 @@ impl SegmentRangeCollector {
         let accessor = bucket_with_accessor
             .accessor
             .as_single()
-            .expect("unexpected fast field cardinality");
+            .expect("unexpected fast field cardinatility");
         for docs in iter.by_ref() {
-            let val1 = accessor.get_val(docs[0] as u64);
+            let val1 = accessor.get(docs[0]);
-            let val2 = accessor.get_val(docs[1] as u64);
+            let val2 = accessor.get(docs[1]);
-            let val3 = accessor.get_val(docs[2] as u64);
+            let val3 = accessor.get(docs[2]);
-            let val4 = accessor.get_val(docs[3] as u64);
+            let val4 = accessor.get(docs[3]);
             let bucket_pos1 = self.get_bucket_pos(val1);
             let bucket_pos2 = self.get_bucket_pos(val2);
             let bucket_pos3 = self.get_bucket_pos(val3);
@@ -277,10 +278,10 @@ impl SegmentRangeCollector {
             self.increment_bucket(bucket_pos3, docs[2], &bucket_with_accessor.sub_aggregation)?;
             self.increment_bucket(bucket_pos4, docs[3], &bucket_with_accessor.sub_aggregation)?;
         }
-        for &doc in iter.remainder() {
+        for doc in iter.remainder() {
-            let val = accessor.get_val(doc as u64);
+            let val = accessor.get(*doc);
             let bucket_pos = self.get_bucket_pos(val);
-            self.increment_bucket(bucket_pos, doc, &bucket_with_accessor.sub_aggregation)?;
+            self.increment_bucket(bucket_pos, *doc, &bucket_with_accessor.sub_aggregation)?;
         }
         if force_flush {
             for bucket in &mut self.buckets {
@@ -423,13 +424,12 @@ pub(crate) fn range_to_key(range: &Range<u64>, field_type: &Type) -> Key {
 #[cfg(test)]
 mod tests {
 
-    use fastfield_codecs::MonotonicallyMappableToU64;
-
     use super::*;
     use crate::aggregation::agg_req::{
         Aggregation, Aggregations, BucketAggregation, BucketAggregationType,
     };
     use crate::aggregation::tests::{exec_request_with_query, get_test_index_with_num_docs};
+    use crate::fastfield::FastValue;
 
     pub fn get_collector_from_ranges(
         ranges: Vec<RangeAggregationRange>,

src/aggregation/bucket/term_agg.rs

@@ -31,7 +31,7 @@ use crate::{DocId, TantivyError};
 ///
 /// Even with a larger `segment_size` value, doc_count values for a terms aggregation may be
 /// approximate. As a result, any sub-aggregations on the terms aggregation may also be approximate.
-/// `sum_other_doc_count` is the number of documents that didn’t make it into the top size
+/// `sum_other_doc_count` is the number of documents that didn’t make it into the the top size
 /// terms. If this is greater than 0, you can be sure that the terms agg had to throw away some
 /// buckets, either because they didn’t fit into size on the root node or they didn’t fit into
 /// `segment_size` on the segment node.
@@ -42,14 +42,14 @@ use crate::{DocId, TantivyError};
 /// each segment. It’s the sum of the size of the largest bucket on each segment that didn’t fit
 /// into segment_size.
 ///
-/// Result type is [`BucketResult`](crate::aggregation::agg_result::BucketResult) with
+/// Result type is [BucketResult](crate::aggregation::agg_result::BucketResult) with
-/// [`TermBucketEntry`](crate::aggregation::agg_result::BucketEntry) on the
+/// [TermBucketEntry](crate::aggregation::agg_result::BucketEntry) on the
-/// `AggregationCollector`.
+/// AggregationCollector.
 ///
 /// Result type is
-/// [`IntermediateBucketResult`](crate::aggregation::intermediate_agg_result::IntermediateBucketResult) with
+/// [crate::aggregation::intermediate_agg_result::IntermediateBucketResult] with
-/// [`IntermediateTermBucketEntry`](crate::aggregation::intermediate_agg_result::IntermediateTermBucketEntry) on the
+/// [crate::aggregation::intermediate_agg_result::IntermediateTermBucketEntry] on the
-/// `DistributedAggregationCollector`.
+/// DistributedAggregationCollector.
 ///
 /// # Limitations/Compatibility
 ///

src/aggregation/collector.rs

@@ -131,7 +131,7 @@ fn merge_fruits(
     }
 }
 
-/// `AggregationSegmentCollector` does the aggregation collection on a segment.
+/// AggregationSegmentCollector does the aggregation collection on a segment.
 pub struct AggregationSegmentCollector {
     aggs_with_accessor: AggregationsWithAccessor,
     result: SegmentAggregationResultsCollector,
@@ -139,8 +139,8 @@ pub struct AggregationSegmentCollector {
 }
 
 impl AggregationSegmentCollector {
-    /// Creates an `AggregationSegmentCollector from` an [`Aggregations`] request and a segment
+    /// Creates an AggregationSegmentCollector from an [Aggregations] request and a segment reader.
-    /// reader. Also includes validation, e.g. checking field types and existence.
+    /// Also includes validation, e.g. checking field types and existence.
     pub fn from_agg_req_and_reader(
         agg: &Aggregations,
         reader: &SegmentReader,

src/aggregation/intermediate_agg_result.rs

@@ -108,10 +108,10 @@ impl IntermediateAggregationResults {
         Self { metrics, buckets }
     }
 
-    /// Merge another intermediate aggregation result into this result.
+    /// Merge an other intermediate aggregation result into this result.
     ///
     /// The order of the values need to be the same on both results. This is ensured when the same
-    /// (key values) are present on the underlying `VecWithNames` struct.
+    /// (key values) are present on the underlying VecWithNames struct.
     pub fn merge_fruits(&mut self, other: IntermediateAggregationResults) {
         if let (Some(buckets_left), Some(buckets_right)) = (&mut self.buckets, other.buckets) {
             for (bucket_left, bucket_right) in
@@ -560,10 +560,10 @@ pub struct IntermediateRangeBucketEntry {
     pub doc_count: u64,
     /// The sub_aggregation in this bucket.
     pub sub_aggregation: IntermediateAggregationResults,
-    /// The from range of the bucket. Equals `f64::MIN` when `None`.
+    /// The from range of the bucket. Equals f64::MIN when None.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub from: Option<f64>,
-    /// The to range of the bucket. Equals `f64::MAX` when `None`.
+    /// The to range of the bucket. Equals f64::MAX when None.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub to: Option<f64>,
 }

src/aggregation/metric/average.rs

@@ -1,9 +1,9 @@
 use std::fmt::Debug;
 
-use fastfield_codecs::Column;
 use serde::{Deserialize, Serialize};
 
 use crate::aggregation::f64_from_fastfield_u64;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader};
 use crate::schema::Type;
 use crate::DocId;
 
@@ -57,13 +57,13 @@ impl SegmentAverageCollector {
             data: Default::default(),
         }
     }
-    pub(crate) fn collect_block(&mut self, doc: &[DocId], field: &dyn Column<u64>) {
+    pub(crate) fn collect_block(&mut self, doc: &[DocId], field: &DynamicFastFieldReader<u64>) {
         let mut iter = doc.chunks_exact(4);
         for docs in iter.by_ref() {
-            let val1 = field.get_val(docs[0] as u64);
+            let val1 = field.get(docs[0]);
-            let val2 = field.get_val(docs[1] as u64);
+            let val2 = field.get(docs[1]);
-            let val3 = field.get_val(docs[2] as u64);
+            let val3 = field.get(docs[2]);
-            let val4 = field.get_val(docs[3] as u64);
+            let val4 = field.get(docs[3]);
             let val1 = f64_from_fastfield_u64(val1, &self.field_type);
             let val2 = f64_from_fastfield_u64(val2, &self.field_type);
             let val3 = f64_from_fastfield_u64(val3, &self.field_type);
@@ -73,8 +73,8 @@ impl SegmentAverageCollector {
             self.data.collect(val3);
             self.data.collect(val4);
         }
-        for &doc in iter.remainder() {
+        for doc in iter.remainder() {
-            let val = field.get_val(doc as u64);
+            let val = field.get(*doc);
             let val = f64_from_fastfield_u64(val, &self.field_type);
             self.data.collect(val);
         }

src/aggregation/metric/stats.rs

@@ -1,14 +1,14 @@
-use fastfield_codecs::Column;
 use serde::{Deserialize, Serialize};
 
 use crate::aggregation::f64_from_fastfield_u64;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader};
 use crate::schema::Type;
 use crate::{DocId, TantivyError};
 
 /// A multi-value metric aggregation that computes stats of numeric values that are
 /// extracted from the aggregated documents.
-/// Supported field types are `u64`, `i64`, and `f64`.
+/// Supported field types are u64, i64, and f64.
-/// See [`Stats`] for returned statistics.
+/// See [Stats] for returned statistics.
 ///
 /// # JSON Format
 /// ```json
@@ -43,13 +43,13 @@ pub struct Stats {
     pub count: usize,
     /// The sum of the fast field values.
     pub sum: f64,
-    /// The standard deviation of the fast field values. `None` for count == 0.
+    /// The standard deviation of the fast field values. None for count == 0.
     pub standard_deviation: Option<f64>,
     /// The min value of the fast field values.
     pub min: Option<f64>,
     /// The max value of the fast field values.
     pub max: Option<f64>,
-    /// The average of the values. `None` for count == 0.
+    /// The average of the values. None for count == 0.
     pub avg: Option<f64>,
 }
 
@@ -70,7 +70,7 @@ impl Stats {
     }
 }
 
-/// `IntermediateStats` contains the mergeable version for stats.
+/// IntermediateStats contains the mergeable version for stats.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct IntermediateStats {
     count: usize,
@@ -163,13 +163,13 @@ impl SegmentStatsCollector {
             stats: IntermediateStats::default(),
         }
     }
-    pub(crate) fn collect_block(&mut self, doc: &[DocId], field: &dyn Column<u64>) {
+    pub(crate) fn collect_block(&mut self, doc: &[DocId], field: &DynamicFastFieldReader<u64>) {
         let mut iter = doc.chunks_exact(4);
         for docs in iter.by_ref() {
-            let val1 = field.get_val(docs[0] as u64);
+            let val1 = field.get(docs[0]);
-            let val2 = field.get_val(docs[1] as u64);
+            let val2 = field.get(docs[1]);
-            let val3 = field.get_val(docs[2] as u64);
+            let val3 = field.get(docs[2]);
-            let val4 = field.get_val(docs[3] as u64);
+            let val4 = field.get(docs[3]);
             let val1 = f64_from_fastfield_u64(val1, &self.field_type);
             let val2 = f64_from_fastfield_u64(val2, &self.field_type);
             let val3 = f64_from_fastfield_u64(val3, &self.field_type);
@@ -179,8 +179,8 @@ impl SegmentStatsCollector {
             self.stats.collect(val3);
             self.stats.collect(val4);
         }
-        for &doc in iter.remainder() {
+        for doc in iter.remainder() {
-            let val = field.get_val(doc as u64);
+            let val = field.get(*doc);
             let val = f64_from_fastfield_u64(val, &self.field_type);
             self.stats.collect(val);
         }

src/aggregation/mod.rs

@@ -14,14 +14,13 @@
 //!
 //!
 //! To use aggregations, build an aggregation request by constructing
-//! [`Aggregations`](agg_req::Aggregations).
+//! [Aggregations](agg_req::Aggregations).
-//! Create an [`AggregationCollector`] from this request. `AggregationCollector` implements the
+//! Create an [AggregationCollector] from this request. AggregationCollector implements the
-//! [`Collector`](crate::collector::Collector) trait and can be passed as collector into
+//! `Collector` trait and can be passed as collector into `searcher.search()`.
-//! [`Searcher::search()`](crate::Searcher::search).
 //!
 //! #### Limitations
 //!
-//! Currently aggregations work only on single value fast fields of type `u64`, `f64`, `i64` and
+//! Currently aggregations work only on single value fast fields of type u64, f64, i64 and
 //! fast fields on text fields.
 //!
 //! # JSON Format
@@ -45,8 +44,8 @@
 //!     - [Stats](metric::StatsAggregation)
 //!
 //! # Example
-//! Compute the average metric, by building [`agg_req::Aggregations`], which is built from an
+//! Compute the average metric, by building [agg_req::Aggregations], which is built from an (String,
-//! `(String, agg_req::Aggregation)` iterator.
+//! [agg_req::Aggregation]) iterator.
 //!
 //! ```
 //! use tantivy::aggregation::agg_req::{Aggregations, Aggregation, MetricAggregation};
@@ -144,15 +143,15 @@
 //! ```
 //!
 //! # Distributed Aggregation
-//! When the data is distributed on different [`Index`](crate::Index) instances, the
+//! When the data is distributed on different [crate::Index] instances, the
-//! [`DistributedAggregationCollector`] provides functionality to merge data between independent
+//! [DistributedAggregationCollector] provides functionality to merge data between independent
 //! search calls by returning
-//! [`IntermediateAggregationResults`](intermediate_agg_result::IntermediateAggregationResults).
+//! [IntermediateAggregationResults](intermediate_agg_result::IntermediateAggregationResults).
-//! `IntermediateAggregationResults` provides the
+//! IntermediateAggregationResults provides the
-//! [`merge_fruits`](intermediate_agg_result::IntermediateAggregationResults::merge_fruits) method
+//! [merge_fruits](intermediate_agg_result::IntermediateAggregationResults::merge_fruits) method to
-//! to merge multiple results. The merged result can then be converted into
+//! merge multiple results. The merged result can then be converted into
-//! [`AggregationResults`](agg_result::AggregationResults) via the
+//! [agg_result::AggregationResults] via the
-//! [`into_final_bucket_result`](intermediate_agg_result::IntermediateAggregationResults::into_final_bucket_result) method.
+//! [agg_result::AggregationResults::from_intermediate_and_req] method.
 
 pub mod agg_req;
 mod agg_req_with_accessor;
@@ -162,6 +161,7 @@ mod collector;
 pub mod intermediate_agg_result;
 pub mod metric;
 mod segment_agg_result;
+
 use std::collections::HashMap;
 use std::fmt::Display;
 
@@ -169,10 +169,10 @@ pub use collector::{
     AggregationCollector, AggregationSegmentCollector, DistributedAggregationCollector,
     MAX_BUCKET_COUNT,
 };
-use fastfield_codecs::MonotonicallyMappableToU64;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
+use crate::fastfield::FastValue;
 use crate::schema::Type;
 
 /// Represents an associative array `(key => values)` in a very efficient manner.
@@ -260,7 +260,7 @@ impl<T: Clone> VecWithNames<T> {
     }
 }
 
-/// The serialized key is used in a `HashMap`.
+/// The serialized key is used in a HashMap.
 pub type SerializedKey = String;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, PartialOrd)]
@@ -269,7 +269,7 @@ pub type SerializedKey = String;
 pub enum Key {
     /// String key
     Str(String),
-    /// `f64` key
+    /// f64 key
     F64(f64),
 }
 
@@ -282,10 +282,10 @@ impl Display for Key {
     }
 }
 
-/// Inverse of `to_fastfield_u64`. Used to convert to `f64` for metrics.
+/// Invert of to_fastfield_u64. Used to convert to f64 for metrics.
 ///
 /// # Panics
-/// Only `u64`, `f64`, and `i64` are supported.
+/// Only u64, f64, i64 is supported
 pub(crate) fn f64_from_fastfield_u64(val: u64, field_type: &Type) -> f64 {
     match field_type {
         Type::U64 => val as f64,
@@ -297,15 +297,15 @@ pub(crate) fn f64_from_fastfield_u64(val: u64, field_type: &Type) -> f64 {
     }
 }
 
-/// Converts the `f64` value to fast field value space.
+/// Converts the f64 value to fast field value space.
 ///
-/// If the fast field has `u64`, values are stored as `u64` in the fast field.
+/// If the fast field has u64, values are stored as u64 in the fast field.
-/// A `f64` value of e.g. `2.0` therefore needs to be converted to `1u64`.
+/// A f64 value of e.g. 2.0 therefore needs to be converted to 1u64
 ///
-/// If the fast field has `f64` values are converted and stored to `u64` using a
+/// If the fast field has f64 values are converted and stored to u64 using a
 /// monotonic mapping.
-/// A `f64` value of e.g. `2.0` needs to be converted using the same monotonic
+/// A f64 value of e.g. 2.0 needs to be converted using the same monotonic
-/// conversion function, so that the value matches the `u64` value stored in the fast
+/// conversion function, so that the value matches the u64 value stored in the fast
 /// field.
 pub(crate) fn f64_to_fastfield_u64(val: f64, field_type: &Type) -> Option<u64> {
     match field_type {

src/aggregation/segment_agg_result.rs

@@ -185,10 +185,10 @@ impl SegmentMetricResultCollector {
     pub(crate) fn collect_block(&mut self, doc: &[DocId], metric: &MetricAggregationWithAccessor) {
         match self {
             SegmentMetricResultCollector::Average(avg_collector) => {
-                avg_collector.collect_block(doc, &*metric.accessor);
+                avg_collector.collect_block(doc, &metric.accessor);
             }
             SegmentMetricResultCollector::Stats(stats_collector) => {
-                stats_collector.collect_block(doc, &*metric.accessor);
+                stats_collector.collect_block(doc, &metric.accessor);
             }
         }
     }

src/collector/custom_score_top_collector.rs

@@ -24,7 +24,7 @@ where TScore: Clone + PartialOrd
 /// A custom segment scorer makes it possible to define any kind of score
 /// for a given document belonging to a specific segment.
 ///
-/// It is the segment local version of the [`CustomScorer`].
+/// It is the segment local version of the [`CustomScorer`](./trait.CustomScorer.html).
 pub trait CustomSegmentScorer<TScore>: 'static {
     /// Computes the score of a specific `doc`.
     fn score(&mut self, doc: DocId) -> TScore;
@@ -36,7 +36,7 @@ pub trait CustomSegmentScorer<TScore>: 'static {
 /// Instead, it helps constructing `Self::Child` instances that will compute
 /// the score at a segment scale.
 pub trait CustomScorer<TScore>: Sync {
-    /// Type of the associated [`CustomSegmentScorer`].
+    /// Type of the associated [`CustomSegmentScorer`](./trait.CustomSegmentScorer.html).
     type Child: CustomSegmentScorer<TScore>;
     /// Builds a child scorer for a specific segment. The child scorer is associated to
     /// a specific segment.

src/collector/facet_collector.rs

@@ -67,10 +67,10 @@ fn facet_depth(facet_bytes: &[u8]) -> usize {
 /// (e.g. `/category/fiction`, `/category/biography`, `/category/personal_development`).
 ///
 /// Once collection is finished, you can harvest its results in the form
-/// of a [`FacetCounts`] object, and extract your facet counts from it.
+/// of a `FacetCounts` object, and extract your face                t counts from it.
 ///
 /// This implementation assumes you are working with a number of facets that
-/// is many hundreds of times smaller than your number of documents.
+/// is much hundreds of time lower than your number of documents.
 ///
 ///
 /// ```rust
@@ -231,7 +231,7 @@ impl FacetCollector {
     ///
     /// Adding two facets within which one is the prefix of the other is forbidden.
     /// If you need the correct number of unique documents for two such facets,
-    /// just add them in a separate `FacetCollector`.
+    /// just add them in separate `FacetCollector`.
     pub fn add_facet<T>(&mut self, facet_from: T)
     where Facet: From<T> {
         let facet = Facet::from(facet_from);
@@ -391,7 +391,7 @@ impl<'a> Iterator for FacetChildIterator<'a> {
 
 impl FacetCounts {
     /// Returns an iterator over all of the facet count pairs inside this result.
-    /// See the documentation for [`FacetCollector`] for a usage example.
+    /// See the documentation for [FacetCollector] for a usage example.
     pub fn get<T>(&self, facet_from: T) -> FacetChildIterator<'_>
     where Facet: From<T> {
         let facet = Facet::from(facet_from);
@@ -410,7 +410,7 @@ impl FacetCounts {
     }
 
     /// Returns a vector of top `k` facets with their counts, sorted highest-to-lowest by counts.
-    /// See the documentation for [`FacetCollector`] for a usage example.
+    /// See the documentation for [FacetCollector] for a usage example.
     pub fn top_k<T>(&self, facet: T, k: usize) -> Vec<(&Facet, u64)>
     where Facet: From<T> {
         let mut heap = BinaryHeap::with_capacity(k);

src/collector/filter_collector_wrapper.rs

@@ -10,12 +10,9 @@
 // ---
 // Importing tantivy...
 use std::marker::PhantomData;
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
 
 use crate::collector::{Collector, SegmentCollector};
-use crate::fastfield::FastValue;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader, FastValue};
 use crate::schema::Field;
 use crate::{Score, SegmentReader, TantivyError};
 
@@ -161,7 +158,7 @@ where
     TPredicate: 'static,
     TPredicateValue: FastValue,
 {
-    fast_field_reader: Arc<dyn Column<TPredicateValue>>,
+    fast_field_reader: DynamicFastFieldReader<TPredicateValue>,
     segment_collector: TSegmentCollector,
     predicate: TPredicate,
     t_predicate_value: PhantomData<TPredicateValue>,
@@ -177,7 +174,7 @@ where
     type Fruit = TSegmentCollector::Fruit;
 
     fn collect(&mut self, doc: u32, score: Score) {
-        let value = self.fast_field_reader.get_val(doc as u64);
+        let value = self.fast_field_reader.get(doc);
         if (self.predicate)(value) {
             self.segment_collector.collect(doc, score)
         }

src/collector/histogram_collector.rs

@@ -1,10 +1,7 @@
-use std::sync::Arc;
-
 use fastdivide::DividerU64;
-use fastfield_codecs::Column;
 
 use crate::collector::{Collector, SegmentCollector};
-use crate::fastfield::FastValue;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader, FastValue};
 use crate::schema::{Field, Type};
 use crate::{DocId, Score};
 
@@ -87,14 +84,14 @@ impl HistogramComputer {
 }
 pub struct SegmentHistogramCollector {
     histogram_computer: HistogramComputer,
-    ff_reader: Arc<dyn Column<u64>>,
+    ff_reader: DynamicFastFieldReader<u64>,
 }
 
 impl SegmentCollector for SegmentHistogramCollector {
     type Fruit = Vec<u64>;
 
     fn collect(&mut self, doc: DocId, _score: Score) {
-        let value = self.ff_reader.get_val(doc as u64);
+        let value = self.ff_reader.get(doc);
         self.histogram_computer.add_value(value);
     }
 

src/collector/mod.rs

@@ -4,13 +4,13 @@
 //! In tantivy jargon, we call this information your search "fruit".
 //!
 //! Your fruit could for instance be :
-//! - [the count of matching documents](crate::collector::Count)
+//! - [the count of matching documents](./struct.Count.html)
-//! - [the top 10 documents, by relevancy or by a fast field](crate::collector::TopDocs)
+//! - [the top 10 documents, by relevancy or by a fast field](./struct.TopDocs.html)
-//! - [facet counts](FacetCollector)
+//! - [facet counts](./struct.FacetCollector.html)
 //!
-//! At some point in your code, you will trigger the actual search operation by calling
+//! At one point in your code, you will trigger the actual search operation by calling
-//! [`Searcher::search()`](crate::Searcher::search).
+//! [the `search(...)` method of your `Searcher` object](../struct.Searcher.html#method.search).
-//! This call will look like this:
+//! This call will look like this.
 //!
 //! ```verbatim
 //! let fruit = searcher.search(&query, &collector)?;
@@ -64,7 +64,7 @@
 //!
 //! The `Collector` trait is implemented for up to 4 collectors.
 //! If you have more than 4 collectors, you can either group them into
-//! tuples of tuples `(a,(b,(c,d)))`, or rely on [`MultiCollector`].
+//! tuples of tuples `(a,(b,(c,d)))`, or rely on [`MultiCollector`](./struct.MultiCollector.html).
 //!
 //! # Combining several collectors dynamically
 //!
@@ -74,7 +74,7 @@
 //!
 //! Unfortunately it requires you to know at compile time your collector types.
 //! If on the other hand, the collectors depend on some query parameter,
-//! you can rely on [`MultiCollector`]'s.
+//! you can rely on `MultiCollector`'s.
 //!
 //!
 //! # Implementing your own collectors.

src/collector/tests.rs

@@ -1,11 +1,7 @@
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
-
 use super::*;
 use crate::collector::{Count, FilterCollector, TopDocs};
 use crate::core::SegmentReader;
-use crate::fastfield::BytesFastFieldReader;
+use crate::fastfield::{BytesFastFieldReader, DynamicFastFieldReader, FastFieldReader};
 use crate::query::{AllQuery, QueryParser};
 use crate::schema::{Field, Schema, FAST, TEXT};
 use crate::time::format_description::well_known::Rfc3339;
@@ -160,7 +156,7 @@ pub struct FastFieldTestCollector {
 
 pub struct FastFieldSegmentCollector {
     vals: Vec<u64>,
-    reader: Arc<dyn Column<u64>>,
+    reader: DynamicFastFieldReader<u64>,
 }
 
 impl FastFieldTestCollector {
@@ -201,7 +197,7 @@ impl SegmentCollector for FastFieldSegmentCollector {
     type Fruit = Vec<u64>;
 
     fn collect(&mut self, doc: DocId, _score: Score) {
-        let val = self.reader.get_val(doc as u64);
+        let val = self.reader.get(doc);
         self.vals.push(val);
     }
 

src/collector/top_score_collector.rs

@@ -1,9 +1,6 @@
 use std::collections::BinaryHeap;
 use std::fmt;
 use std::marker::PhantomData;
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
 
 use super::Collector;
 use crate::collector::custom_score_top_collector::CustomScoreTopCollector;
@@ -12,7 +9,7 @@ use crate::collector::tweak_score_top_collector::TweakedScoreTopCollector;
 use crate::collector::{
     CustomScorer, CustomSegmentScorer, ScoreSegmentTweaker, ScoreTweaker, SegmentCollector,
 };
-use crate::fastfield::FastValue;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader, FastValue};
 use crate::query::Weight;
 use crate::schema::Field;
 use crate::{DocAddress, DocId, Score, SegmentOrdinal, SegmentReader, TantivyError};
@@ -132,12 +129,12 @@ impl fmt::Debug for TopDocs {
 }
 
 struct ScorerByFastFieldReader {
-    ff_reader: Arc<dyn Column<u64>>,
+    ff_reader: DynamicFastFieldReader<u64>,
 }
 
 impl CustomSegmentScorer<u64> for ScorerByFastFieldReader {
     fn score(&mut self, doc: DocId) -> u64 {
-        self.ff_reader.get_val(doc as u64)
+        self.ff_reader.get(doc)
     }
 }
 
@@ -287,7 +284,7 @@ impl TopDocs {
     /// # See also
     ///
     /// To comfortably work with `u64`s, `i64`s, `f64`s, or `date`s, please refer to
-    /// the [.order_by_fast_field(...)](TopDocs::order_by_fast_field) method.
+    /// [.order_by_fast_field(...)](#method.order_by_fast_field) method.
     pub fn order_by_u64_field(
         self,
         field: Field,
@@ -384,7 +381,7 @@ impl TopDocs {
     ///
     /// This method offers a convenient way to tweak or replace
     /// the documents score. As suggested by the prototype you can
-    /// manually define your own [`ScoreTweaker`]
+    /// manually define your own [`ScoreTweaker`](./trait.ScoreTweaker.html)
     /// and pass it as an argument, but there is a much simpler way to
     /// tweak your score: you can use a closure as in the following
     /// example.
@@ -401,7 +398,7 @@ impl TopDocs {
     /// In the following example will will tweak our ranking a bit by
     /// boosting popular products a notch.
     ///
-    /// In more serious application, this tweaking could involve running a
+    /// In more serious application, this tweaking could involved running a
     /// learning-to-rank model over various features
     ///
     /// ```rust
@@ -410,6 +407,7 @@ impl TopDocs {
     /// # use tantivy::query::QueryParser;
     /// use tantivy::SegmentReader;
     /// use tantivy::collector::TopDocs;
+    /// use tantivy::fastfield::FastFieldReader;
     /// use tantivy::schema::Field;
     ///
     /// fn create_schema() -> Schema {
@@ -458,7 +456,7 @@ impl TopDocs {
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId, original_score: Score| {
-    ///                 let popularity: u64 = popularity_reader.get_val(doc as u64);
+    ///                 let popularity: u64 = popularity_reader.get(doc);
     ///                 // Well.. For the sake of the example we use a simple logarithm
     ///                 // function.
     ///                 let popularity_boost_score = ((2u64 + popularity) as Score).log2();
@@ -474,7 +472,7 @@ impl TopDocs {
     /// ```
     ///
     /// # See also
-    /// - [custom_score(...)](TopDocs::custom_score)
+    /// [custom_score(...)](#method.custom_score).
     pub fn tweak_score<TScore, TScoreSegmentTweaker, TScoreTweaker>(
         self,
         score_tweaker: TScoreTweaker,
@@ -491,7 +489,8 @@ impl TopDocs {
     ///
     /// This method offers a convenient way to use a different score.
     ///
-    /// As suggested by the prototype you can manually define your own [`CustomScorer`]
+    /// As suggested by the prototype you can manually define your
+    /// own [`CustomScorer`](./trait.CustomScorer.html)
     /// and pass it as an argument, but there is a much simpler way to
     /// tweak your score: you can use a closure as in the following
     /// example.
@@ -516,6 +515,7 @@ impl TopDocs {
     /// use tantivy::SegmentReader;
     /// use tantivy::collector::TopDocs;
     /// use tantivy::schema::Field;
+    /// use tantivy::fastfield::FastFieldReader;
     ///
     /// # fn create_schema() -> Schema {
     /// #    let mut schema_builder = Schema::builder();
@@ -567,8 +567,8 @@ impl TopDocs {
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId| {
-    ///                 let popularity: u64 = popularity_reader.get_val(doc as u64);
+    ///                 let popularity: u64 = popularity_reader.get(doc);
-    ///                 let boosted: u64 = boosted_reader.get_val(doc as u64);
+    ///                 let boosted: u64 = boosted_reader.get(doc);
     ///                 // Score do not have to be `f64` in tantivy.
     ///                 // Here we return a couple to get lexicographical order
     ///                 // for free.
@@ -587,7 +587,7 @@ impl TopDocs {
     /// ```
     ///
     /// # See also
-    /// - [tweak_score(...)](TopDocs::tweak_score)
+    /// [tweak_score(...)](#method.tweak_score).
     pub fn custom_score<TScore, TCustomSegmentScorer, TCustomScorer>(
         self,
         custom_score: TCustomScorer,

src/collector/tweak_score_top_collector.rs

@@ -24,7 +24,7 @@ where TScore: Clone + PartialOrd
 /// A `ScoreSegmentTweaker` makes it possible to modify the default score
 /// for a given document belonging to a specific segment.
 ///
-/// It is the segment local version of the [`ScoreTweaker`].
+/// It is the segment local version of the [`ScoreTweaker`](./trait.ScoreTweaker.html).
 pub trait ScoreSegmentTweaker<TScore>: 'static {
     /// Tweak the given `score` for the document `doc`.
     fn score(&mut self, doc: DocId, score: Score) -> TScore;
@@ -37,7 +37,7 @@ pub trait ScoreSegmentTweaker<TScore>: 'static {
 /// Instead, it helps constructing `Self::Child` instances that will compute
 /// the score at a segment scale.
 pub trait ScoreTweaker<TScore>: Sync {
-    /// Type of the associated [`ScoreSegmentTweaker`].
+    /// Type of the associated [`ScoreSegmentTweaker`](./trait.ScoreSegmentTweaker.html).
     type Child: ScoreSegmentTweaker<TScore>;
 
     /// Builds a child tweaker for a specific segment. The child scorer is associated to

src/core/index.rs

@@ -7,7 +7,6 @@ use std::sync::Arc;
 
 use super::segment::Segment;
 use super::IndexSettings;
-use crate::core::single_segment_index_writer::SingleSegmentIndexWriter;
 use crate::core::{
     Executor, IndexMeta, SegmentId, SegmentMeta, SegmentMetaInventory, META_FILEPATH,
 };
@@ -17,7 +16,7 @@ use crate::directory::MmapDirectory;
 use crate::directory::{Directory, ManagedDirectory, RamDirectory, INDEX_WRITER_LOCK};
 use crate::error::{DataCorruption, TantivyError};
 use crate::indexer::index_writer::{MAX_NUM_THREAD, MEMORY_ARENA_NUM_BYTES_MIN};
-use crate::indexer::segment_updater::save_metas;
+use crate::indexer::segment_updater::save_new_metas;
 use crate::reader::{IndexReader, IndexReaderBuilder};
 use crate::schema::{Field, FieldType, Schema};
 use crate::tokenizer::{TextAnalyzer, TokenizerManager};
@@ -48,38 +47,10 @@ fn load_metas(
         .map_err(From::from)
 }
 
-/// Save the index meta file.
-/// This operation is atomic :
-/// Either
-///  - it fails, in which case an error is returned,
-/// and the `meta.json` remains untouched,
-/// - it succeeds, and `meta.json` is written
-/// and flushed.
-///
-/// This method is not part of tantivy's public API
-fn save_new_metas(
-    schema: Schema,
-    index_settings: IndexSettings,
-    directory: &dyn Directory,
-) -> crate::Result<()> {
-    save_metas(
-        &IndexMeta {
-            index_settings,
-            segments: Vec::new(),
-            schema,
-            opstamp: 0u64,
-            payload: None,
-        },
-        directory,
-    )?;
-    directory.sync_directory()?;
-    Ok(())
-}
-
 /// IndexBuilder can be used to create an index.
 ///
-/// Use in conjunction with [`SchemaBuilder`][crate::schema::SchemaBuilder].
+/// Use in conjunction with `SchemaBuilder`. Global index settings
-/// Global index settings can be configured with [`IndexSettings`].
+/// can be configured with `IndexSettings`
 ///
 /// # Examples
 ///
@@ -97,13 +68,7 @@ fn save_new_metas(
 /// );
 ///
 /// let schema = schema_builder.build();
-/// let settings = IndexSettings{
+/// let settings = IndexSettings{sort_by_field: Some(IndexSortByField{field:"number".to_string(), order:Order::Asc}), ..Default::default()};
-///     sort_by_field: Some(IndexSortByField{
-///         field: "number".to_string(),
-///         order: Order::Asc
-///     }),
-///     ..Default::default()
-/// };
 /// let index = Index::builder().schema(schema).settings(settings).create_in_ram();
 /// ```
 pub struct IndexBuilder {
@@ -146,7 +111,7 @@ impl IndexBuilder {
         self
     }
 
-    /// Creates a new index using the [`RamDirectory`].
+    /// Creates a new index using the `RAMDirectory`.
     ///
     /// The index will be allocated in anonymous memory.
     /// This should only be used for unit tests.
@@ -154,14 +119,13 @@ impl IndexBuilder {
         let ram_directory = RamDirectory::create();
         Ok(self
             .create(ram_directory)
-            .expect("Creating a RamDirectory should never fail"))
+            .expect("Creating a RAMDirectory should never fail"))
     }
 
     /// Creates a new index in a given filepath.
-    /// The index will use the [`MmapDirectory`].
+    /// The index will use the `MMapDirectory`.
     ///
-    /// If a previous index was in this directory, it returns an
+    /// If a previous index was in this directory, it returns an `IndexAlreadyExists` error.
-    /// [`TantivyError::IndexAlreadyExists`] error.
     #[cfg(feature = "mmap")]
     pub fn create_in_dir<P: AsRef<Path>>(self, directory_path: P) -> crate::Result<Index> {
         let mmap_directory: Box<dyn Directory> = Box::new(MmapDirectory::open(directory_path)?);
@@ -171,34 +135,14 @@ impl IndexBuilder {
         self.create(mmap_directory)
     }
 
-    /// Dragons ahead!!!
-    ///
-    /// The point of this API is to let users create a simple index with a single segment
-    /// and without starting any thread.
-    ///
-    /// Do not use this method if you are not sure what you are doing.
-    ///
-    /// It expects an originally empty directory, and will not run any GC operation.
-    #[doc(hidden)]
-    pub fn single_segment_index_writer(
-        self,
-        dir: impl Into<Box<dyn Directory>>,
-        mem_budget: usize,
-    ) -> crate::Result<SingleSegmentIndexWriter> {
-        let index = self.create(dir)?;
-        let index_simple_writer = SingleSegmentIndexWriter::new(index, mem_budget)?;
-        Ok(index_simple_writer)
-    }
-
     /// Creates a new index in a temp directory.
     ///
-    /// The index will use the [`MmapDirectory`] in a newly created directory.
+    /// The index will use the `MMapDirectory` in a newly created directory.
-    /// The temp directory will be destroyed automatically when the [`Index`] object
+    /// The temp directory will be destroyed automatically when the `Index` object
     /// is destroyed.
     ///
-    /// The temp directory is only used for testing the [`MmapDirectory`].
+    /// The temp directory is only used for testing the `MmapDirectory`.
-    /// For other unit tests, prefer the [`RamDirectory`], see:
+    /// For other unit tests, prefer the `RAMDirectory`, see: `create_in_ram`.
-    /// [`IndexBuilder::create_in_ram()`].
     #[cfg(feature = "mmap")]
     pub fn create_from_tempdir(self) -> crate::Result<Index> {
         let mmap_directory: Box<dyn Directory> = Box::new(MmapDirectory::create_from_tempdir()?);
@@ -294,7 +238,7 @@ impl Index {
         self.set_multithread_executor(default_num_threads)
     }
 
-    /// Creates a new index using the [`RamDirectory`].
+    /// Creates a new index using the `RamDirectory`.
     ///
     /// The index will be allocated in anonymous memory.
     /// This is useful for indexing small set of documents
@@ -304,10 +248,9 @@ impl Index {
     }
 
     /// Creates a new index in a given filepath.
-    /// The index will use the [`MmapDirectory`].
+    /// The index will use the `MMapDirectory`.
     ///
-    /// If a previous index was in this directory, then it returns
+    /// If a previous index was in this directory, then it returns  an `IndexAlreadyExists` error.
-    /// a [`TantivyError::IndexAlreadyExists`] error.
     #[cfg(feature = "mmap")]
     pub fn create_in_dir<P: AsRef<Path>>(
         directory_path: P,
@@ -329,13 +272,12 @@ impl Index {
 
     /// Creates a new index in a temp directory.
     ///
-    /// The index will use the [`MmapDirectory`] in a newly created directory.
+    /// The index will use the `MMapDirectory` in a newly created directory.
-    /// The temp directory will be destroyed automatically when the [`Index`] object
+    /// The temp directory will be destroyed automatically when the `Index` object
     /// is destroyed.
     ///
-    /// The temp directory is only used for testing the [`MmapDirectory`].
+    /// The temp directory is only used for testing the `MmapDirectory`.
-    /// For other unit tests, prefer the [`RamDirectory`],
+    /// For other unit tests, prefer the `RamDirectory`, see: `create_in_ram`.
-    /// see: [`IndexBuilder::create_in_ram()`].
     #[cfg(feature = "mmap")]
     pub fn create_from_tempdir(schema: Schema) -> crate::Result<Index> {
         IndexBuilder::new().schema(schema).create_from_tempdir()
@@ -355,7 +297,7 @@ impl Index {
         builder.create(dir)
     }
 
-    /// Creates a new index given a directory and an [`IndexMeta`].
+    /// Creates a new index given a directory and an `IndexMeta`.
     fn open_from_metas(
         directory: ManagedDirectory,
         metas: &IndexMeta,
@@ -382,7 +324,7 @@ impl Index {
         &self.tokenizers
     }
 
-    /// Get the tokenizer associated with a specific field.
+    /// Helper to access the tokenizer associated to a specific field.
     pub fn tokenizer_for_field(&self, field: Field) -> crate::Result<TextAnalyzer> {
         let field_entry = self.schema.get_field_entry(field);
         let field_type = field_entry.field_type();
@@ -414,14 +356,14 @@ impl Index {
             })
     }
 
-    /// Create a default [`IndexReader`] for the given index.
+    /// Create a default `IndexReader` for the given index.
     ///
-    /// See [`Index.reader_builder()`].
+    /// See [`Index.reader_builder()`](#method.reader_builder).
     pub fn reader(&self) -> crate::Result<IndexReader> {
         self.reader_builder().try_into()
     }
 
-    /// Create a [`IndexReader`] for the given index.
+    /// Create a `IndexReader` for the given index.
     ///
     /// Most project should create at most one reader for a given index.
     /// This method is typically called only once per `Index` instance.
@@ -638,12 +580,10 @@ impl fmt::Debug for Index {
 
 #[cfg(test)]
 mod tests {
-    use crate::collector::Count;
     use crate::directory::{RamDirectory, WatchCallback};
-    use crate::query::TermQuery;
+    use crate::schema::{Field, Schema, INDEXED, TEXT};
-    use crate::schema::{Field, IndexRecordOption, Schema, INDEXED, TEXT};
     use crate::tokenizer::TokenizerManager;
-    use crate::{Directory, Index, IndexBuilder, IndexReader, IndexSettings, ReloadPolicy, Term};
+    use crate::{Directory, Index, IndexBuilder, IndexReader, IndexSettings, ReloadPolicy};
 
     #[test]
     fn test_indexer_for_field() {
@@ -909,28 +849,4 @@ mod tests {
         );
         Ok(())
     }
-
-    #[test]
-    fn test_single_segment_index_writer() -> crate::Result<()> {
-        let mut schema_builder = Schema::builder();
-        let text_field = schema_builder.add_text_field("text", TEXT);
-        let schema = schema_builder.build();
-        let directory = RamDirectory::default();
-        let mut single_segment_index_writer = Index::builder()
-            .schema(schema)
-            .single_segment_index_writer(directory, 10_000_000)?;
-        for _ in 0..10 {
-            let doc = doc!(text_field=>"hello");
-            single_segment_index_writer.add_document(doc)?;
-        }
-        let index = single_segment_index_writer.finalize()?;
-        let searcher = index.reader()?.searcher();
-        let term_query = TermQuery::new(
-            Term::from_field_text(text_field, "hello"),
-            IndexRecordOption::Basic,
-        );
-        let count = searcher.search(&term_query, &Count)?;
-        assert_eq!(count, 10);
-        Ok(())
-    }
 }

src/core/index_meta.rs

@@ -235,14 +235,6 @@ impl InnerSegmentMeta {
     }
 }
 
-fn return_true() -> bool {
-    true
-}
-
-fn is_true(val: &bool) -> bool {
-    *val
-}
-
 /// Search Index Settings.
 ///
 /// Contains settings which are applied on the whole
@@ -256,12 +248,6 @@ pub struct IndexSettings {
     /// The `Compressor` used to compress the doc store.
     #[serde(default)]
     pub docstore_compression: Compressor,
-    /// If set to true, docstore compression will happen on a dedicated thread.
-    /// (defaults: true)
-    #[doc(hidden)]
-    #[serde(default = "return_true")]
-    #[serde(skip_serializing_if = "is_true")]
-    pub docstore_compress_dedicated_thread: bool,
     #[serde(default = "default_docstore_blocksize")]
     /// The size of each block that will be compressed and written to disk
     pub docstore_blocksize: usize,
@@ -278,7 +264,6 @@ impl Default for IndexSettings {
             sort_by_field: None,
             docstore_compression: Compressor::default(),
             docstore_blocksize: default_docstore_blocksize(),
-            docstore_compress_dedicated_thread: true,
         }
     }
 }
@@ -410,7 +395,7 @@ mod tests {
     use super::IndexMeta;
     use crate::core::index_meta::UntrackedIndexMeta;
     use crate::schema::{Schema, TEXT};
-    use crate::store::{Compressor, ZstdCompressor};
+    use crate::store::ZstdCompressor;
     use crate::{IndexSettings, IndexSortByField, Order};
 
     #[test]
@@ -462,7 +447,6 @@ mod tests {
                     compression_level: Some(4),
                 }),
                 docstore_blocksize: 1_000_000,
-                docstore_compress_dedicated_thread: true,
             },
             segments: Vec::new(),
             schema,
@@ -501,47 +485,4 @@ mod tests {
             "unknown zstd option \"bla\" at line 1 column 103".to_string()
         );
     }
-
-    #[test]
-    #[cfg(feature = "lz4-compression")]
-    fn test_index_settings_default() {
-        let mut index_settings = IndexSettings::default();
-        assert_eq!(
-            index_settings,
-            IndexSettings {
-                sort_by_field: None,
-                docstore_compression: Compressor::default(),
-                docstore_compress_dedicated_thread: true,
-                docstore_blocksize: 16_384
-            }
-        );
-        {
-            let index_settings_json = serde_json::to_value(&index_settings).unwrap();
-            assert_eq!(
-                index_settings_json,
-                serde_json::json!({
-                    "docstore_compression": "lz4",
-                    "docstore_blocksize": 16384
-                })
-            );
-            let index_settings_deser: IndexSettings =
-                serde_json::from_value(index_settings_json).unwrap();
-            assert_eq!(index_settings_deser, index_settings);
-        }
-        {
-            index_settings.docstore_compress_dedicated_thread = false;
-            let index_settings_json = serde_json::to_value(&index_settings).unwrap();
-            assert_eq!(
-                index_settings_json,
-                serde_json::json!({
-                    "docstore_compression": "lz4",
-                    "docstore_blocksize": 16384,
-                    "docstore_compress_dedicated_thread": false,
-                })
-            );
-            let index_settings_deser: IndexSettings =
-                serde_json::from_value(index_settings_json).unwrap();
-            assert_eq!(index_settings_deser, index_settings);
-        }
-    }
 }

src/core/mod.rs

@@ -7,7 +7,6 @@ mod segment;
 mod segment_component;
 mod segment_id;
 mod segment_reader;
-mod single_segment_index_writer;
 
 use std::path::Path;
 
@@ -24,7 +23,6 @@ pub use self::segment::Segment;
 pub use self::segment_component::SegmentComponent;
 pub use self::segment_id::SegmentId;
 pub use self::segment_reader::SegmentReader;
-pub use self::single_segment_index_writer::SingleSegmentIndexWriter;
 
 /// The meta file contains all the information about the list of segments and the schema
 /// of the index.

src/core/searcher.rs

@@ -10,12 +10,12 @@ use crate::space_usage::SearcherSpaceUsage;
 use crate::store::{CacheStats, StoreReader};
 use crate::{DocAddress, Index, Opstamp, SegmentId, TrackedObject};
 
-/// Identifies the searcher generation accessed by a [`Searcher`].
+/// Identifies the searcher generation accessed by a [Searcher].
 ///
-/// While this might seem redundant, a [`SearcherGeneration`] contains
+/// While this might seem redundant, a [SearcherGeneration] contains
 /// both a `generation_id` AND a list of `(SegmentId, DeleteOpstamp)`.
 ///
-/// This is on purpose. This object is used by the [`Warmer`](crate::reader::Warmer) API.
+/// This is on purpose. This object is used by the `Warmer` API.
 /// Having both information makes it possible to identify which
 /// artifact should be refreshed or garbage collected.
 ///
@@ -74,15 +74,15 @@ impl Searcher {
         &self.inner.index
     }
 
-    /// [`SearcherGeneration`] which identifies the version of the snapshot held by this `Searcher`.
+    /// [SearcherGeneration] which identifies the version of the snapshot held by this `Searcher`.
     pub fn generation(&self) -> &SearcherGeneration {
         self.inner.generation.as_ref()
     }
 
-    /// Fetches a document from tantivy's store given a [`DocAddress`].
+    /// Fetches a document from tantivy's store given a `DocAddress`.
     ///
     /// The searcher uses the segment ordinal to route the
-    /// request to the right `Segment`.
+    /// the request to the right `Segment`.
     pub fn doc(&self, doc_address: DocAddress) -> crate::Result<Document> {
         let store_reader = &self.inner.store_readers[doc_address.segment_ord as usize];
         store_reader.get(doc_address.doc_id)
@@ -180,7 +180,7 @@ impl Searcher {
         self.search_with_executor(query, collector, executor)
     }
 
-    /// Same as [`search(...)`](Searcher::search) but multithreaded.
+    /// Same as [`search(...)`](#method.search) but multithreaded.
     ///
     /// The current implementation is rather naive :
     /// multithreading is by splitting search into as many task

src/core/single_segment_index_writer.rs

@@ -1,51 +0,0 @@
-use crate::indexer::operation::AddOperation;
-use crate::indexer::segment_updater::save_metas;
-use crate::indexer::SegmentWriter;
-use crate::{Directory, Document, Index, IndexMeta, Opstamp, Segment};
-
-#[doc(hidden)]
-pub struct SingleSegmentIndexWriter {
-    segment_writer: SegmentWriter,
-    segment: Segment,
-    opstamp: Opstamp,
-}
-
-impl SingleSegmentIndexWriter {
-    pub fn new(index: Index, mem_budget: usize) -> crate::Result<Self> {
-        let segment = index.new_segment();
-        let segment_writer = SegmentWriter::for_segment(mem_budget, segment.clone())?;
-        Ok(Self {
-            segment_writer,
-            segment,
-            opstamp: 0,
-        })
-    }
-
-    pub fn mem_usage(&self) -> usize {
-        self.segment_writer.mem_usage()
-    }
-
-    pub fn add_document(&mut self, document: Document) -> crate::Result<()> {
-        let opstamp = self.opstamp;
-        self.opstamp += 1;
-        self.segment_writer
-            .add_document(AddOperation { opstamp, document })
-    }
-
-    pub fn finalize(self) -> crate::Result<Index> {
-        let max_doc = self.segment_writer.max_doc();
-        self.segment_writer.finalize()?;
-        let segment: Segment = self.segment.with_max_doc(max_doc);
-        let index = segment.index();
-        let index_meta = IndexMeta {
-            index_settings: index.settings().clone(),
-            segments: vec![segment.meta().clone()],
-            schema: index.schema(),
-            opstamp: 0,
-            payload: None,
-        };
-        save_metas(&index_meta, index.directory())?;
-        index.directory().sync_directory()?;
-        Ok(segment.index().clone())
-    }
-}

src/directory/directory.rs

@@ -117,9 +117,9 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     /// change.
     ///
     /// Specifically, subsequent writes or flushes should
-    /// have no effect on the returned [`FileSlice`] object.
+    /// have no effect on the returned `FileSlice` object.
     ///
-    /// You should only use this to read files create with [`Directory::open_write()`].
+    /// You should only use this to read files create with [Directory::open_write].
     fn open_read(&self, path: &Path) -> Result<FileSlice, OpenReadError> {
         let file_handle = self.get_file_handle(path)?;
         Ok(FileSlice::new(file_handle))
@@ -128,28 +128,27 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     /// Removes a file
     ///
     /// Removing a file will not affect an eventual
-    /// existing [`FileSlice`] pointing to it.
+    /// existing FileSlice pointing to it.
     ///
-    /// Removing a nonexistent file, returns a
+    /// Removing a nonexistent file, yields a
-    /// [`DeleteError::FileDoesNotExist`].
+    /// `DeleteError::DoesNotExist`.
     fn delete(&self, path: &Path) -> Result<(), DeleteError>;
 
     /// Returns true if and only if the file exists
     fn exists(&self, path: &Path) -> Result<bool, OpenReadError>;
 
     /// Opens a writer for the *virtual file* associated with
-    /// a [`Path`].
+    /// a Path.
     ///
     /// Right after this call, for the span of the execution of the program
-    /// the file should be created and any subsequent call to
+    /// the file should be created and any subsequent call to `open_read` for the
-    /// [`Directory::open_read()`] for the same path should return
+    /// same path should return a `FileSlice`.
-    /// a [`FileSlice`].
     ///
     /// However, depending on the directory implementation,
-    /// it might be required to call [`Directory::sync_directory()`] to ensure
+    /// it might be required to call `sync_directory` to ensure
     /// that the file is durably created.
     /// (The semantics here are the same when dealing with
-    /// a POSIX filesystem.)
+    /// a posix filesystem.)
     ///
     /// Write operations may be aggressively buffered.
     /// The client of this trait is responsible for calling flush
@@ -158,19 +157,19 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     ///
     /// Flush operation should also be persistent.
     ///
-    /// The user shall not rely on [`Drop`] triggering `flush`.
+    /// The user shall not rely on `Drop` triggering `flush`.
-    /// Note that [`RamDirectory`][crate::directory::RamDirectory] will
+    /// Note that `RamDirectory` will panic! if `flush`
-    /// panic! if `flush` was not called.
+    /// was not called.
     ///
     /// The file may not previously exist.
     fn open_write(&self, path: &Path) -> Result<WritePtr, OpenWriteError>;
 
     /// Reads the full content file that has been written using
-    /// [`Directory::atomic_write()`].
+    /// atomic_write.
     ///
     /// This should only be used for small files.
     ///
-    /// You should only use this to read files create with [`Directory::atomic_write()`].
+    /// You should only use this to read files create with [Directory::atomic_write].
     fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError>;
 
     /// Atomically replace the content of a file with data.
@@ -187,9 +186,9 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     /// effectively stored durably.
     fn sync_directory(&self) -> io::Result<()>;
 
-    /// Acquire a lock in the directory given in the [`Lock`].
+    /// Acquire a lock in the given directory.
     ///
-    /// The method is blocking or not depending on the [`Lock`] object.
+    /// The method is blocking or not depending on the `Lock` object.
     fn acquire_lock(&self, lock: &Lock) -> Result<DirectoryLock, LockError> {
         let mut box_directory = self.box_clone();
         let mut retry_policy = retry_policy(lock.is_blocking);
@@ -211,15 +210,15 @@ pub trait Directory: DirectoryClone + fmt::Debug + Send + Sync + 'static {
     }
 
     /// Registers a callback that will be called whenever a change on the `meta.json`
-    /// using the [`Directory::atomic_write()`] API is detected.
+    /// using the `atomic_write` API is detected.
     ///
-    /// The behavior when using `.watch()` on a file using [`Directory::open_write()`] is, on the
+    /// The behavior when using `.watch()` on a file using [Directory::open_write] is, on the other
-    /// other hand, undefined.
+    /// hand, undefined.
     ///
     /// The file will be watched for the lifetime of the returned `WatchHandle`. The caller is
     /// required to keep it.
     /// It does not override previous callbacks. When the file is modified, all callback that are
-    /// registered (and whose [`WatchHandle`] is still alive) are triggered.
+    /// registered (and whose `WatchHandle` is still alive) are triggered.
     ///
     /// Internally, tantivy only uses this API to detect new commits to implement the
     /// `OnCommit` `ReloadPolicy`. Not implementing watch in a `Directory` only prevents the

src/directory/directory_lock.rs

@@ -4,14 +4,12 @@ use once_cell::sync::Lazy;
 
 /// A directory lock.
 ///
-/// A lock is associated with a specific path.
+/// A lock is associated to a specific path and some
-///
+/// [`LockParams`](./enum.LockParams.html).
-/// The lock will be passed to [`Directory::acquire_lock`](crate::Directory::acquire_lock).
-///
 /// Tantivy itself uses only two locks but client application
 /// can use the directory facility to define their own locks.
-/// - [`INDEX_WRITER_LOCK`]
+/// - [INDEX_WRITER_LOCK]
-/// - [`META_LOCK`]
+/// - [META_LOCK]
 ///
 /// Check out these locks documentation for more information.
 #[derive(Debug)]
@@ -20,21 +18,19 @@ pub struct Lock {
     /// Depending on the platform, the lock might rely on the creation
     /// and deletion of this filepath.
     pub filepath: PathBuf,
-    /// `is_blocking` describes whether acquiring the lock is meant
+    /// `lock_params` describes whether acquiring the lock is meant
     /// to be a blocking operation or a non-blocking.
     ///
     /// Acquiring a blocking lock blocks until the lock is
     /// available.
-    ///
+    /// Acquiring a blocking lock returns rapidly, either successfully
-    /// Acquiring a non-blocking lock returns rapidly, either successfully
     /// or with an error signifying that someone is already holding
     /// the lock.
     pub is_blocking: bool,
 }
 
 /// Only one process should be able to write tantivy's index at a time.
-/// This lock file, when present, is in charge of preventing other processes to open an
+/// This lock file, when present, is in charge of preventing other processes to open an IndexWriter.
-/// `IndexWriter`.
 ///
 /// If the process is killed and this file remains, it is safe to remove it manually.
 ///

src/directory/error.rs

@@ -4,9 +4,7 @@ use std::{fmt, io};
 
 use crate::Version;
 
-/// Error while trying to acquire a directory [lock](crate::directory::Lock).
+/// Error while trying to acquire a directory lock.
-///
-/// This is returned from [`Directory::acquire_lock`](crate::Directory::acquire_lock).
 #[derive(Debug, Clone, Error)]
 pub enum LockError {
     /// Failed to acquired a lock as it is already held by another

src/directory/mmap_directory.rs

@@ -27,7 +27,7 @@ pub(crate) fn make_io_err(msg: String) -> io::Error {
     io::Error::new(io::ErrorKind::Other, msg)
 }
 
-/// Returns `None` iff the file exists, can be read, but is empty (and hence
+/// Returns None iff the file exists, can be read, but is empty (and hence
 /// cannot be mmapped)
 fn open_mmap(full_path: &Path) -> result::Result<Option<Mmap>, OpenReadError> {
     let file = File::open(full_path).map_err(|io_err| {
@@ -56,10 +56,10 @@ fn open_mmap(full_path: &Path) -> result::Result<Option<Mmap>, OpenReadError> {
 
 #[derive(Default, Clone, Debug, Serialize, Deserialize)]
 pub struct CacheCounters {
-    /// Number of time the cache prevents to call `mmap`
+    // Number of time the cache prevents to call `mmap`
     pub hit: usize,
-    /// Number of time tantivy had to call `mmap`
+    // Number of time tantivy had to call `mmap`
-    /// as no entry was in the cache.
+    // as no entry was in the cache.
     pub miss: usize,
 }
 

src/directory/ram_directory.rs

@@ -15,7 +15,7 @@ use crate::directory::{
     WatchHandle, WritePtr,
 };
 
-/// Writer associated with the [`RamDirectory`].
+/// Writer associated with the `RamDirectory`
 ///
 /// The Writer just writes a buffer.
 struct VecWriter {
@@ -137,17 +137,17 @@ impl RamDirectory {
     }
 
     /// Returns the sum of the size of the different files
-    /// in the [`RamDirectory`].
+    /// in the RamDirectory.
     pub fn total_mem_usage(&self) -> usize {
         self.fs.read().unwrap().total_mem_usage()
     }
 
-    /// Write a copy of all of the files saved in the [`RamDirectory`] in the target [`Directory`].
+    /// Write a copy of all of the files saved in the RamDirectory in the target `Directory`.
     ///
-    /// Files are all written using the [`Directory::open_write()`] meaning, even if they were
+    /// Files are all written using the `Directory::write` meaning, even if they were
-    /// written using the [`Directory::atomic_write()`] api.
+    /// written using the `atomic_write` api.
     ///
-    /// If an error is encountered, files may be persisted partially.
+    /// If an error is encounterred, files may be persisted partially.
     pub fn persist(&self, dest: &dyn Directory) -> crate::Result<()> {
         let wlock = self.fs.write().unwrap();
         for (path, file) in wlock.fs.iter() {

src/docset.rs

@@ -3,10 +3,10 @@ use std::borrow::{Borrow, BorrowMut};
 use crate::fastfield::AliveBitSet;
 use crate::DocId;
 
-/// Sentinel value returned when a [`DocSet`] has been entirely consumed.
+/// Sentinel value returned when a DocSet has been entirely consumed.
 ///
-/// This is not `u32::MAX` as one would have expected, due to the lack of SSE2 instructions
+/// This is not u32::MAX as one would have expected, due to the lack of SSE2 instructions
-/// to compare `[u32; 4]`.
+/// to compare [u32; 4].
 pub const TERMINATED: DocId = i32::MAX as u32;
 
 /// Represents an iterable set of sorted doc ids.
@@ -20,21 +20,21 @@ pub trait DocSet: Send {
     /// assert_eq!(doc, docset.doc());
     /// ```
     ///
-    /// If we reached the end of the `DocSet`, [`TERMINATED`] should be returned.
+    /// If we reached the end of the DocSet, TERMINATED should be returned.
     ///
-    /// Calling `.advance()` on a terminated `DocSet` should be supported, and [`TERMINATED`] should
+    /// Calling `.advance()` on a terminated DocSet should be supported, and TERMINATED should
     /// be returned.
     fn advance(&mut self) -> DocId;
 
-    /// Advances the `DocSet` forward until reaching the target, or going to the
+    /// Advances the DocSet forward until reaching the target, or going to the
-    /// lowest [`DocId`] greater than the target.
+    /// lowest DocId greater than the target.
     ///
-    /// If the end of the `DocSet` is reached, [`TERMINATED`] is returned.
+    /// If the end of the DocSet is reached, TERMINATED is returned.
     ///
-    /// Calling `.seek(target)` on a terminated `DocSet` is legal. Implementation
+    /// Calling `.seek(target)` on a terminated DocSet is legal. Implementation
-    /// of `DocSet` should support it.
+    /// of DocSet should support it.
     ///
-    /// Calling `seek(TERMINATED)` is also legal and is the normal way to consume a `DocSet`.
+    /// Calling `seek(TERMINATED)` is also legal and is the normal way to consume a DocSet.
     fn seek(&mut self, target: DocId) -> DocId {
         let mut doc = self.doc();
         debug_assert!(doc <= target);
@@ -73,9 +73,9 @@ pub trait DocSet: Send {
     }
 
     /// Returns the current document
-    /// Right after creating a new `DocSet`, the docset points to the first document.
+    /// Right after creating a new DocSet, the docset points to the first document.
     ///
-    /// If the `DocSet` is empty, `.doc()` should return [`TERMINATED`].
+    /// If the DocSet is empty, .doc() should return `TERMINATED`.
     fn doc(&self) -> DocId;
 
     /// Returns a best-effort hint of the

src/fastfield/bytes/reader.rs

@@ -1,9 +1,5 @@
-use std::sync::Arc;
-
-use fastfield_codecs::Column;
-
 use crate::directory::{FileSlice, OwnedBytes};
-use crate::fastfield::MultiValueLength;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader, MultiValueLength};
 use crate::DocId;
 
 /// Reader for byte array fast fields
@@ -18,13 +14,13 @@ use crate::DocId;
 /// and the start index for the next document, and keeping the bytes in between.
 #[derive(Clone)]
 pub struct BytesFastFieldReader {
-    idx_reader: Arc<dyn Column<u64>>,
+    idx_reader: DynamicFastFieldReader<u64>,
     values: OwnedBytes,
 }
 
 impl BytesFastFieldReader {
     pub(crate) fn open(
-        idx_reader: Arc<dyn Column<u64>>,
+        idx_reader: DynamicFastFieldReader<u64>,
         values_file: FileSlice,
     ) -> crate::Result<BytesFastFieldReader> {
         let values = values_file.read_bytes()?;
@@ -32,9 +28,8 @@ impl BytesFastFieldReader {
     }
 
     fn range(&self, doc: DocId) -> (usize, usize) {
-        let idx = doc as u64;
+        let start = self.idx_reader.get(doc) as usize;
-        let start = self.idx_reader.get_val(idx) as usize;
+        let stop = self.idx_reader.get(doc + 1) as usize;
-        let stop = self.idx_reader.get_val(idx + 1) as usize;
         (start, stop)
     }
 

src/fastfield/bytes/writer.rs

@@ -1,9 +1,6 @@
-use std::io::{self, Write};
+use std::io;
-
-use fastfield_codecs::VecColumn;
 
 use crate::fastfield::serializer::CompositeFastFieldSerializer;
-use crate::fastfield::MultivalueStartIndex;
 use crate::indexer::doc_id_mapping::DocIdMapping;
 use crate::schema::{Document, Field, Value};
 use crate::DocId;
@@ -13,17 +10,15 @@ use crate::DocId;
 /// This `BytesFastFieldWriter` is only useful for advanced users.
 /// The normal way to get your associated bytes in your index
 /// is to
-/// - declare your field with fast set to
+/// - declare your field with fast set to `Cardinality::SingleValue`
-/// [`Cardinality::SingleValue`](crate::schema::Cardinality::SingleValue)
 /// in your schema
 /// - add your document simply by calling `.add_document(...)` with associating bytes to the field.
 ///
 /// The `BytesFastFieldWriter` can be acquired from the
 /// fast field writer by calling
-/// [`.get_bytes_writer_mut(...)`](crate::fastfield::FastFieldsWriter::get_bytes_writer_mut).
+/// [`.get_bytes_writer(...)`](./struct.FastFieldsWriter.html#method.get_bytes_writer).
 ///
-/// Once acquired, writing is done by calling
+/// Once acquired, writing is done by calling `.add_document_val(&[u8])`
-/// [`.add_document_val(&[u8])`](BytesFastFieldWriter::add_document_val)
 /// once per document, even if there are no bytes associated to it.
 pub struct BytesFastFieldWriter {
     field: Field,
@@ -109,27 +104,22 @@ impl BytesFastFieldWriter {
 
     /// Serializes the fast field values by pushing them to the `FastFieldSerializer`.
     pub fn serialize(
-        mut self,
+        &self,
         serializer: &mut CompositeFastFieldSerializer,
         doc_id_map: Option<&DocIdMapping>,
     ) -> io::Result<()> {
         // writing the offset index
-        {
+        let mut doc_index_serializer =
-            self.doc_index.push(self.vals.len() as u64);
+            serializer.new_u64_fast_field_with_idx(self.field, 0, self.vals.len() as u64, 0)?;
-            let col = VecColumn::from(&self.doc_index[..]);
+        let mut offset = 0;
-            if let Some(doc_id_map) = doc_id_map {
+        for vals in self.get_ordered_values(doc_id_map) {
-                let multi_value_start_index = MultivalueStartIndex::new(&col, doc_id_map);
+            doc_index_serializer.add_val(offset)?;
-                serializer.create_auto_detect_u64_fast_field_with_idx(
+            offset += vals.len() as u64;
-                    self.field,
-                    multi_value_start_index,
-                    0,
-                )?;
-            } else {
-                serializer.create_auto_detect_u64_fast_field_with_idx(self.field, col, 0)?;
-            }
         }
+        doc_index_serializer.add_val(self.vals.len() as u64)?;
+        doc_index_serializer.close_field()?;
         // writing the values themselves
-        let mut value_serializer = serializer.new_bytes_fast_field(self.field);
+        let mut value_serializer = serializer.new_bytes_fast_field_with_idx(self.field, 1);
         // the else could be removed, but this is faster (difference not benchmarked)
         if let Some(doc_id_map) = doc_id_map {
             for vals in self.get_ordered_values(Some(doc_id_map)) {

src/fastfield/gcd.rs

@@ -0,0 +1,360 @@
+use std::io::{self, Write};
+use std::num::NonZeroU64;
+
+use common::BinarySerializable;
+use fastdivide::DividerU64;
+use fastfield_codecs::{FastFieldCodec, FastFieldDataAccess};
+use ownedbytes::OwnedBytes;
+
+pub const GCD_DEFAULT: u64 = 1;
+
+/// Wrapper for accessing a fastfield.
+///
+/// Holds the data and the codec to the read the data.
+#[derive(Clone)]
+pub struct GCDReader<CodecReader: FastFieldDataAccess> {
+    gcd_params: GCDParams,
+    reader: CodecReader,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct GCDParams {
+    gcd: u64,
+    min_value: u64,
+    num_vals: u64,
+}
+
+impl GCDParams {
+    pub fn eval(&self, val: u64) -> u64 {
+        self.min_value + self.gcd * val
+    }
+}
+
+impl BinarySerializable for GCDParams {
+    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+        self.gcd.serialize(writer)?;
+        self.min_value.serialize(writer)?;
+        self.num_vals.serialize(writer)?;
+        Ok(())
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let gcd: u64 = u64::deserialize(reader)?;
+        let min_value: u64 = u64::deserialize(reader)?;
+        let num_vals: u64 = u64::deserialize(reader)?;
+        Ok(Self {
+            gcd,
+            min_value,
+            num_vals,
+        })
+    }
+}
+
+pub fn open_gcd_from_bytes<WrappedCodec: FastFieldCodec>(
+    bytes: OwnedBytes,
+) -> io::Result<GCDReader<WrappedCodec::Reader>> {
+    let footer_offset = bytes.len() - 24;
+    let (body, mut footer) = bytes.split(footer_offset);
+    let gcd_params = GCDParams::deserialize(&mut footer)?;
+    let reader: WrappedCodec::Reader = WrappedCodec::open_from_bytes(body)?;
+    Ok(GCDReader { gcd_params, reader })
+}
+
+impl<C: FastFieldDataAccess + Clone> FastFieldDataAccess for GCDReader<C> {
+    #[inline]
+    fn get_val(&self, doc: u64) -> u64 {
+        let val = self.reader.get_val(doc);
+        self.gcd_params.eval(val)
+    }
+
+    fn min_value(&self) -> u64 {
+        self.gcd_params.eval(self.reader.min_value())
+    }
+
+    fn max_value(&self) -> u64 {
+        self.gcd_params.eval(self.reader.max_value())
+    }
+    fn num_vals(&self) -> u64 {
+        self.gcd_params.num_vals
+    }
+}
+
+pub fn write_gcd_header<W: Write>(
+    field_write: &mut W,
+    min_value: u64,
+    gcd: u64,
+    num_vals: u64,
+) -> io::Result<()> {
+    gcd.serialize(field_write)?;
+    min_value.serialize(field_write)?;
+    num_vals.serialize(field_write)?;
+    Ok(())
+}
+
+/// Compute the gcd of two non null numbers.
+///
+/// It is recommended, but not required, to feed values such that `large >= small`.
+fn compute_gcd(mut large: NonZeroU64, mut small: NonZeroU64) -> NonZeroU64 {
+    loop {
+        let rem: u64 = large.get() % small;
+        if let Some(new_small) = NonZeroU64::new(rem) {
+            (large, small) = (small, new_small);
+        } else {
+            return small;
+        }
+    }
+}
+
+// Find GCD for iterator of numbers
+pub fn find_gcd(numbers: impl Iterator<Item = u64>) -> Option<NonZeroU64> {
+    let mut numbers = numbers.flat_map(NonZeroU64::new);
+    let mut gcd: NonZeroU64 = numbers.next()?;
+    if gcd.get() == 1 {
+        return Some(gcd);
+    }
+
+    let mut gcd_divider = DividerU64::divide_by(gcd.get());
+    for val in numbers {
+        let remainder = val.get() - (gcd_divider.divide(val.get())) * gcd.get();
+        if remainder == 0 {
+            continue;
+        }
+        gcd = compute_gcd(val, gcd);
+        if gcd.get() == 1 {
+            return Some(gcd);
+        }
+
+        gcd_divider = DividerU64::divide_by(gcd.get());
+    }
+    Some(gcd)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::num::NonZeroU64;
+    use std::path::Path;
+    use std::time::{Duration, SystemTime};
+
+    use common::HasLen;
+
+    use crate::directory::{CompositeFile, RamDirectory, WritePtr};
+    use crate::fastfield::gcd::compute_gcd;
+    use crate::fastfield::serializer::FastFieldCodecEnableCheck;
+    use crate::fastfield::tests::{FIELD, FIELDI64, SCHEMA, SCHEMAI64};
+    use crate::fastfield::{
+        find_gcd, CompositeFastFieldSerializer, DynamicFastFieldReader, FastFieldCodecType,
+        FastFieldReader, FastFieldsWriter, ALL_CODECS,
+    };
+    use crate::schema::{Cardinality, Schema};
+    use crate::{DateOptions, DatePrecision, DateTime, Directory};
+
+    fn get_index(
+        docs: &[crate::Document],
+        schema: &Schema,
+        codec_enable_checker: FastFieldCodecEnableCheck,
+    ) -> crate::Result<RamDirectory> {
+        let directory: RamDirectory = RamDirectory::create();
+        {
+            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
+            let mut serializer =
+                CompositeFastFieldSerializer::from_write_with_codec(write, codec_enable_checker)
+                    .unwrap();
+            let mut fast_field_writers = FastFieldsWriter::from_schema(schema);
+            for doc in docs {
+                fast_field_writers.add_document(doc);
+            }
+            fast_field_writers
+                .serialize(&mut serializer, &HashMap::new(), None)
+                .unwrap();
+            serializer.close().unwrap();
+        }
+        Ok(directory)
+    }
+
+    fn test_fastfield_gcd_i64_with_codec(
+        code_type: FastFieldCodecType,
+        num_vals: usize,
+    ) -> crate::Result<()> {
+        let path = Path::new("test");
+        let mut docs = vec![];
+        for i in 1..=num_vals {
+            let val = (i as i64 - 5) * 1000i64;
+            docs.push(doc!(*FIELDI64=>val));
+        }
+        let directory = get_index(&docs, &SCHEMAI64, code_type.into())?;
+        let file = directory.open_read(path).unwrap();
+        let composite_file = CompositeFile::open(&file)?;
+        let file = composite_file.open_read(*FIELD).unwrap();
+        let fast_field_reader = DynamicFastFieldReader::<i64>::open(file)?;
+
+        assert_eq!(fast_field_reader.get(0), -4000i64);
+        assert_eq!(fast_field_reader.get(1), -3000i64);
+        assert_eq!(fast_field_reader.get(2), -2000i64);
+        assert_eq!(fast_field_reader.max_value(), (num_vals as i64 - 5) * 1000);
+        assert_eq!(fast_field_reader.min_value(), -4000i64);
+        let file = directory.open_read(path).unwrap();
+
+        // Can't apply gcd
+        let path = Path::new("test");
+        docs.pop();
+        docs.push(doc!(*FIELDI64=>2001i64));
+        let directory = get_index(&docs, &SCHEMAI64, code_type.into())?;
+        let file2 = directory.open_read(path).unwrap();
+        assert!(file2.len() > file.len());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_fastfield_gcd_i64() -> crate::Result<()> {
+        for &code_type in ALL_CODECS {
+            test_fastfield_gcd_i64_with_codec(code_type, 5005)?;
+        }
+        Ok(())
+    }
+
+    fn test_fastfield_gcd_u64_with_codec(
+        code_type: FastFieldCodecType,
+        num_vals: usize,
+    ) -> crate::Result<()> {
+        let path = Path::new("test");
+        let mut docs = vec![];
+        for i in 1..=num_vals {
+            let val = i as u64 * 1000u64;
+            docs.push(doc!(*FIELD=>val));
+        }
+        let directory = get_index(&docs, &SCHEMA, code_type.into())?;
+        let file = directory.open_read(path).unwrap();
+        let composite_file = CompositeFile::open(&file)?;
+        let file = composite_file.open_read(*FIELD).unwrap();
+        let fast_field_reader = DynamicFastFieldReader::<u64>::open(file)?;
+        assert_eq!(fast_field_reader.get(0), 1000u64);
+        assert_eq!(fast_field_reader.get(1), 2000u64);
+        assert_eq!(fast_field_reader.get(2), 3000u64);
+        assert_eq!(fast_field_reader.max_value(), num_vals as u64 * 1000);
+        assert_eq!(fast_field_reader.min_value(), 1000u64);
+        let file = directory.open_read(path).unwrap();
+
+        // Can't apply gcd
+        let path = Path::new("test");
+        docs.pop();
+        docs.push(doc!(*FIELDI64=>2001u64));
+        let directory = get_index(&docs, &SCHEMA, code_type.into())?;
+        let file2 = directory.open_read(path).unwrap();
+        assert!(file2.len() > file.len());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_fastfield_gcd_u64() -> crate::Result<()> {
+        for &code_type in ALL_CODECS {
+            test_fastfield_gcd_u64_with_codec(code_type, 5005)?;
+        }
+        Ok(())
+    }
+
+    #[test]
+    pub fn test_fastfield2() {
+        let test_fastfield = DynamicFastFieldReader::<u64>::from(vec![100, 200, 300]);
+        assert_eq!(test_fastfield.get(0), 100);
+        assert_eq!(test_fastfield.get(1), 200);
+        assert_eq!(test_fastfield.get(2), 300);
+    }
+
+    #[test]
+    pub fn test_gcd_date() -> crate::Result<()> {
+        let size_prec_sec =
+            test_gcd_date_with_codec(FastFieldCodecType::Bitpacked, DatePrecision::Seconds)?;
+        let size_prec_micro =
+            test_gcd_date_with_codec(FastFieldCodecType::Bitpacked, DatePrecision::Microseconds)?;
+        assert!(size_prec_sec < size_prec_micro);
+
+        let size_prec_sec =
+            test_gcd_date_with_codec(FastFieldCodecType::Linear, DatePrecision::Seconds)?;
+        let size_prec_micro =
+            test_gcd_date_with_codec(FastFieldCodecType::Linear, DatePrecision::Microseconds)?;
+        assert!(size_prec_sec < size_prec_micro);
+
+        Ok(())
+    }
+
+    fn test_gcd_date_with_codec(
+        codec_type: FastFieldCodecType,
+        precision: DatePrecision,
+    ) -> crate::Result<usize> {
+        let time1 = DateTime::from_timestamp_micros(
+            SystemTime::now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as i64,
+        );
+        let time2 = DateTime::from_timestamp_micros(
+            SystemTime::now()
+                .checked_sub(Duration::from_micros(4111))
+                .unwrap()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as i64,
+        );
+
+        let time3 = DateTime::from_timestamp_micros(
+            SystemTime::now()
+                .checked_sub(Duration::from_millis(2000))
+                .unwrap()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as i64,
+        );
+
+        let mut schema_builder = Schema::builder();
+        let date_options = DateOptions::default()
+            .set_fast(Cardinality::SingleValue)
+            .set_precision(precision);
+        let field = schema_builder.add_date_field("field", date_options);
+        let schema = schema_builder.build();
+
+        let docs = vec![doc!(field=>time1), doc!(field=>time2), doc!(field=>time3)];
+
+        let directory = get_index(&docs, &schema, codec_type.into())?;
+        let path = Path::new("test");
+        let file = directory.open_read(path).unwrap();
+        let composite_file = CompositeFile::open(&file)?;
+        let file = composite_file.open_read(*FIELD).unwrap();
+        let len = file.len();
+        let test_fastfield = DynamicFastFieldReader::<DateTime>::open(file)?;
+
+        assert_eq!(test_fastfield.get(0), time1.truncate(precision));
+        assert_eq!(test_fastfield.get(1), time2.truncate(precision));
+        assert_eq!(test_fastfield.get(2), time3.truncate(precision));
+        Ok(len)
+    }
+
+    #[test]
+    fn test_compute_gcd() {
+        let test_compute_gcd_aux = |large, small, expected| {
+            let large = NonZeroU64::new(large).unwrap();
+            let small = NonZeroU64::new(small).unwrap();
+            let expected = NonZeroU64::new(expected).unwrap();
+            assert_eq!(compute_gcd(small, large), expected);
+            assert_eq!(compute_gcd(large, small), expected);
+        };
+        test_compute_gcd_aux(1, 4, 1);
+        test_compute_gcd_aux(2, 4, 2);
+        test_compute_gcd_aux(10, 25, 5);
+        test_compute_gcd_aux(25, 25, 25);
+    }
+
+    #[test]
+    fn find_gcd_test() {
+        assert_eq!(find_gcd([0].into_iter()), None);
+        assert_eq!(find_gcd([0, 10].into_iter()), NonZeroU64::new(10));
+        assert_eq!(find_gcd([10, 0].into_iter()), NonZeroU64::new(10));
+        assert_eq!(find_gcd([].into_iter()), None);
+        assert_eq!(find_gcd([15, 30, 5, 10].into_iter()), NonZeroU64::new(5));
+        assert_eq!(find_gcd([15, 16, 10].into_iter()), NonZeroU64::new(1));
+        assert_eq!(find_gcd([0, 5, 5, 5].into_iter()), NonZeroU64::new(5));
+        assert_eq!(find_gcd([0, 0].into_iter()), None);
+    }
+}

src/fastfield/mod.rs

@@ -20,31 +20,39 @@
 //!
 //! Read access performance is comparable to that of an array lookup.
 
-use fastfield_codecs::MonotonicallyMappableToU64;
+use fastfield_codecs::FastFieldCodecType;
 
 pub use self::alive_bitset::{intersect_alive_bitsets, write_alive_bitset, AliveBitSet};
 pub use self::bytes::{BytesFastFieldReader, BytesFastFieldWriter};
 pub use self::error::{FastFieldNotAvailableError, Result};
 pub use self::facet_reader::FacetReader;
-pub(crate) use self::multivalued::MultivalueStartIndex;
+pub(crate) use self::gcd::{find_gcd, GCDReader, GCD_DEFAULT};
 pub use self::multivalued::{MultiValuedFastFieldReader, MultiValuedFastFieldWriter};
+pub use self::reader::{DynamicFastFieldReader, FastFieldReader};
 pub use self::readers::FastFieldReaders;
 pub(crate) use self::readers::{type_and_cardinality, FastType};
-pub use self::serializer::{Column, CompositeFastFieldSerializer};
+pub use self::serializer::{CompositeFastFieldSerializer, FastFieldDataAccess, FastFieldStats};
 pub use self::writer::{FastFieldsWriter, IntFastFieldWriter};
-use crate::schema::{Type, Value};
+use crate::schema::{Cardinality, FieldType, Type, Value};
 use crate::{DateTime, DocId};
 
 mod alive_bitset;
 mod bytes;
 mod error;
 mod facet_reader;
+mod gcd;
 mod multivalued;
+mod reader;
 mod readers;
-mod remapped_column;
 mod serializer;
 mod writer;
 
+pub(crate) const ALL_CODECS: &[FastFieldCodecType; 3] = &[
+    FastFieldCodecType::Bitpacked,
+    FastFieldCodecType::Linear,
+    FastFieldCodecType::BlockwiseLinear,
+];
+
 /// Trait for `BytesFastFieldReader` and `MultiValuedFastFieldReader` to return the length of data
 /// for a doc_id
 pub trait MultiValueLength {
@@ -56,64 +64,169 @@ pub trait MultiValueLength {
 
 /// Trait for types that are allowed for fast fields:
 /// (u64, i64 and f64, bool, DateTime).
-pub trait FastValue:
+pub trait FastValue: Clone + Copy + Send + Sync + PartialOrd + 'static {
-    MonotonicallyMappableToU64 + Copy + Send + Sync + PartialOrd + 'static
+    /// Converts a value from u64
-{
+    ///
-    /// Returns the `schema::Type` for this FastValue.
+    /// Internally all fast field values are encoded as u64.
-    fn to_type() -> Type;
+    /// **Note: To be used for converting encoded Term, Posting values.**
+    fn from_u64(val: u64) -> Self;
+
+    /// Converts a value to u64.
+    ///
+    /// Internally all fast field values are encoded as u64.
+    fn to_u64(&self) -> u64;
+
+    /// Returns the fast field cardinality that can be extracted from the given
+    /// `FieldType`.
+    ///
+    /// If the type is not a fast field, `None` is returned.
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality>;
+
+    /// Cast value to `u64`.
+    /// The value is just reinterpreted in memory.
+    fn as_u64(&self) -> u64;
 
     /// Build a default value. This default value is never used, so the value does not
     /// really matter.
     fn make_zero() -> Self {
-        Self::from_u64(0u64)
+        Self::from_u64(0i64.to_u64())
     }
+
+    /// Returns the `schema::Type` for this FastValue.
+    fn to_type() -> Type;
 }
 
 impl FastValue for u64 {
+    fn from_u64(val: u64) -> Self {
+        val
+    }
+
+    fn to_u64(&self) -> u64 {
+        *self
+    }
+
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
+        match *field_type {
+            FieldType::U64(ref integer_options) => integer_options.get_fastfield_cardinality(),
+            FieldType::Facet(_) => Some(Cardinality::MultiValues),
+            _ => None,
+        }
+    }
+
+    fn as_u64(&self) -> u64 {
+        *self
+    }
+
     fn to_type() -> Type {
         Type::U64
     }
 }
 
 impl FastValue for i64 {
+    fn from_u64(val: u64) -> Self {
+        common::u64_to_i64(val)
+    }
+
+    fn to_u64(&self) -> u64 {
+        common::i64_to_u64(*self)
+    }
+
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
+        match *field_type {
+            FieldType::I64(ref integer_options) => integer_options.get_fastfield_cardinality(),
+            _ => None,
+        }
+    }
+
+    fn as_u64(&self) -> u64 {
+        *self as u64
+    }
+
     fn to_type() -> Type {
         Type::I64
     }
 }
 
 impl FastValue for f64 {
+    fn from_u64(val: u64) -> Self {
+        common::u64_to_f64(val)
+    }
+
+    fn to_u64(&self) -> u64 {
+        common::f64_to_u64(*self)
+    }
+
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
+        match *field_type {
+            FieldType::F64(ref integer_options) => integer_options.get_fastfield_cardinality(),
+            _ => None,
+        }
+    }
+
+    fn as_u64(&self) -> u64 {
+        self.to_bits()
+    }
+
     fn to_type() -> Type {
         Type::F64
     }
 }
 
 impl FastValue for bool {
+    fn from_u64(val: u64) -> Self {
+        val != 0u64
+    }
+
+    fn to_u64(&self) -> u64 {
+        match self {
+            false => 0,
+            true => 1,
+        }
+    }
+
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
+        match *field_type {
+            FieldType::Bool(ref integer_options) => integer_options.get_fastfield_cardinality(),
+            _ => None,
+        }
+    }
+
+    fn as_u64(&self) -> u64 {
+        *self as u64
+    }
+
     fn to_type() -> Type {
         Type::Bool
     }
 }
 
-impl MonotonicallyMappableToU64 for DateTime {
-    fn to_u64(self) -> u64 {
-        self.timestamp_micros.to_u64()
-    }
-
-    fn from_u64(val: u64) -> Self {
-        let timestamp_micros = i64::from_u64(val);
-        DateTime { timestamp_micros }
-    }
-}
-
 impl FastValue for DateTime {
+    /// Converts a timestamp microseconds into DateTime.
+    ///
+    /// **Note the timestamps is expected to be in microseconds.**
+    fn from_u64(timestamp_micros_u64: u64) -> Self {
+        let timestamp_micros = i64::from_u64(timestamp_micros_u64);
+        Self::from_timestamp_micros(timestamp_micros)
+    }
+
+    fn to_u64(&self) -> u64 {
+        common::i64_to_u64(self.into_timestamp_micros())
+    }
+
+    fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
+        match *field_type {
+            FieldType::Date(ref options) => options.get_fastfield_cardinality(),
+            _ => None,
+        }
+    }
+
+    fn as_u64(&self) -> u64 {
+        self.into_timestamp_micros().as_u64()
+    }
+
     fn to_type() -> Type {
         Type::Date
     }
-
-    fn make_zero() -> Self {
-        DateTime {
-            timestamp_micros: 0,
-        }
-    }
 }
 
 fn value_to_u64(value: &Value) -> u64 {
@@ -153,19 +266,17 @@ mod tests {
     use std::collections::HashMap;
     use std::ops::Range;
     use std::path::Path;
-    use std::sync::Arc;
 
     use common::HasLen;
-    use fastfield_codecs::{open, FastFieldCodecType};
     use once_cell::sync::Lazy;
     use rand::prelude::SliceRandom;
     use rand::rngs::StdRng;
-    use rand::{Rng, SeedableRng};
+    use rand::SeedableRng;
 
     use super::*;
     use crate::directory::{CompositeFile, Directory, RamDirectory, WritePtr};
     use crate::merge_policy::NoMergePolicy;
-    use crate::schema::{Cardinality, Document, Field, Schema, SchemaBuilder, FAST, STRING, TEXT};
+    use crate::schema::{Document, Field, Schema, FAST, STRING, TEXT};
     use crate::time::OffsetDateTime;
     use crate::{DateOptions, DatePrecision, Index, SegmentId, SegmentReader};
 
@@ -174,14 +285,22 @@ mod tests {
         schema_builder.add_u64_field("field", FAST);
         schema_builder.build()
     });
+
+    pub static SCHEMAI64: Lazy<Schema> = Lazy::new(|| {
+        let mut schema_builder = Schema::builder();
+        schema_builder.add_i64_field("field", FAST);
+        schema_builder.build()
+    });
+
     pub static FIELD: Lazy<Field> = Lazy::new(|| SCHEMA.get_field("field").unwrap());
+    pub static FIELDI64: Lazy<Field> = Lazy::new(|| SCHEMAI64.get_field("field").unwrap());
 
     #[test]
     pub fn test_fastfield() {
-        let test_fastfield = fastfield_codecs::serialize_and_load(&[100u64, 200u64, 300u64][..]);
+        let test_fastfield = DynamicFastFieldReader::<u64>::from(vec![100, 200, 300]);
-        assert_eq!(test_fastfield.get_val(0u64), 100);
+        assert_eq!(test_fastfield.get(0), 100);
-        assert_eq!(test_fastfield.get_val(1u64), 200);
+        assert_eq!(test_fastfield.get(1), 200);
-        assert_eq!(test_fastfield.get_val(2u64), 300);
+        assert_eq!(test_fastfield.get(2), 300);
     }
 
     #[test]
@@ -207,13 +326,13 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 25);
+        assert_eq!(file.len(), 45);
         let composite_file = CompositeFile::open(&file)?;
-        let fast_field_bytes = composite_file.open_read(*FIELD).unwrap().read_bytes()?;
+        let file = composite_file.open_read(*FIELD).unwrap();
-        let fast_field_reader = open::<u64>(fast_field_bytes)?;
+        let fast_field_reader = DynamicFastFieldReader::<u64>::open(file)?;
-        assert_eq!(fast_field_reader.get_val(0), 13u64);
+        assert_eq!(fast_field_reader.get(0), 13u64);
-        assert_eq!(fast_field_reader.get_val(1), 14u64);
+        assert_eq!(fast_field_reader.get(1), 14u64);
-        assert_eq!(fast_field_reader.get_val(2), 2u64);
+        assert_eq!(fast_field_reader.get(2), 2u64);
         Ok(())
     }
 
@@ -238,23 +357,20 @@ mod tests {
             serializer.close()?;
         }
         let file = directory.open_read(path)?;
-        assert_eq!(file.len(), 53);
+        assert_eq!(file.len(), 70);
         {
             let fast_fields_composite = CompositeFile::open(&file)?;
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-                .open_read(*FIELD)
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data)?;
-                .unwrap()
+            assert_eq!(fast_field_reader.get(0), 4u64);
-                .read_bytes()?;
+            assert_eq!(fast_field_reader.get(1), 14_082_001u64);
-            let fast_field_reader = open::<u64>(data)?;
+            assert_eq!(fast_field_reader.get(2), 3_052u64);
-            assert_eq!(fast_field_reader.get_val(0), 4u64);
+            assert_eq!(fast_field_reader.get(3), 9002u64);
-            assert_eq!(fast_field_reader.get_val(1), 14_082_001u64);
+            assert_eq!(fast_field_reader.get(4), 15_001u64);
-            assert_eq!(fast_field_reader.get_val(2), 3_052u64);
+            assert_eq!(fast_field_reader.get(5), 777u64);
-            assert_eq!(fast_field_reader.get_val(3), 9002u64);
+            assert_eq!(fast_field_reader.get(6), 1_002u64);
-            assert_eq!(fast_field_reader.get_val(4), 15_001u64);
+            assert_eq!(fast_field_reader.get(7), 1_501u64);
-            assert_eq!(fast_field_reader.get_val(5), 777u64);
+            assert_eq!(fast_field_reader.get(8), 215u64);
-            assert_eq!(fast_field_reader.get_val(6), 1_002u64);
-            assert_eq!(fast_field_reader.get_val(7), 1_501u64);
-            assert_eq!(fast_field_reader.get_val(8), 215u64);
         }
         Ok(())
     }
@@ -277,16 +393,13 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 26);
+        assert_eq!(file.len(), 43);
         {
             let fast_fields_composite = CompositeFile::open(&file).unwrap();
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-                .open_read(*FIELD)
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data)?;
-                .unwrap()
-                .read_bytes()?;
-            let fast_field_reader = open::<u64>(data)?;
             for doc in 0..10_000 {
-                assert_eq!(fast_field_reader.get_val(doc), 100_000u64);
+                assert_eq!(fast_field_reader.get(doc), 100_000u64);
             }
         }
         Ok(())
@@ -312,18 +425,15 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 80040);
+        assert_eq!(file.len(), 80051);
         {
             let fast_fields_composite = CompositeFile::open(&file)?;
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-                .open_read(*FIELD)
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data)?;
-                .unwrap()
+            assert_eq!(fast_field_reader.get(0), 0u64);
-                .read_bytes()?;
-            let fast_field_reader = open::<u64>(data)?;
-            assert_eq!(fast_field_reader.get_val(0), 0u64);
             for doc in 1..10_001 {
                 assert_eq!(
-                    fast_field_reader.get_val(doc),
+                    fast_field_reader.get(doc),
                     5_000_000_000_000_000_000u64 + doc as u64 - 1u64
                 );
             }
@@ -354,20 +464,18 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 40_usize);
+        // assert_eq!(file.len(), 17710 as usize); //bitpacked size
-
+        // assert_eq!(file.len(), 10175_usize); // linear interpol size
+        assert_eq!(file.len(), 75_usize); // linear interpol size after calc improvement
         {
             let fast_fields_composite = CompositeFile::open(&file)?;
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(i64_field).unwrap();
-                .open_read(i64_field)
+            let fast_field_reader = DynamicFastFieldReader::<i64>::open(data)?;
-                .unwrap()
-                .read_bytes()?;
-            let fast_field_reader = open::<i64>(data)?;
 
             assert_eq!(fast_field_reader.min_value(), -100i64);
             assert_eq!(fast_field_reader.max_value(), 9_999i64);
             for (doc, i) in (-100i64..10_000i64).enumerate() {
-                assert_eq!(fast_field_reader.get_val(doc as u64), i);
+                assert_eq!(fast_field_reader.get(doc as u32), i);
             }
             let mut buffer = vec![0i64; 100];
             fast_field_reader.get_range(53, &mut buffer[..]);
@@ -401,12 +509,9 @@ mod tests {
         let file = directory.open_read(path).unwrap();
         {
             let fast_fields_composite = CompositeFile::open(&file).unwrap();
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(i64_field).unwrap();
-                .open_read(i64_field)
+            let fast_field_reader = DynamicFastFieldReader::<i64>::open(data)?;
-                .unwrap()
+            assert_eq!(fast_field_reader.get(0u32), 0i64);
-                .read_bytes()?;
-            let fast_field_reader = open::<i64>(data)?;
-            assert_eq!(fast_field_reader.get_val(0), 0i64);
         }
         Ok(())
     }
@@ -425,7 +530,7 @@ mod tests {
         permutation
     }
 
-    fn test_intfastfield_permutation_with_data(permutation: &[u64]) -> crate::Result<()> {
+    fn test_intfastfield_permutation_with_data(permutation: Vec<u64>) -> crate::Result<()> {
         let path = Path::new("test");
         let n = permutation.len();
         let directory = RamDirectory::create();
@@ -433,7 +538,7 @@ mod tests {
             let write: WritePtr = directory.open_write(Path::new("test"))?;
             let mut serializer = CompositeFastFieldSerializer::from_write(write)?;
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
-            for &x in permutation {
+            for &x in &permutation {
                 fast_field_writers.add_document(&doc!(*FIELD=>x));
             }
             fast_field_writers.serialize(&mut serializer, &HashMap::new(), None)?;
@@ -442,36 +547,27 @@ mod tests {
         let file = directory.open_read(path)?;
         {
             let fast_fields_composite = CompositeFile::open(&file)?;
-            let data = fast_fields_composite
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-                .open_read(*FIELD)
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data)?;
-                .unwrap()
+
-                .read_bytes()?;
-            let fast_field_reader = open::<u64>(data)?;
             for a in 0..n {
-                assert_eq!(fast_field_reader.get_val(a as u64), permutation[a as usize]);
+                assert_eq!(fast_field_reader.get(a as u32), permutation[a as usize]);
             }
         }
         Ok(())
     }
 
     #[test]
-    fn test_intfastfield_simple() -> crate::Result<()> {
+    fn test_intfastfield_permutation_gcd() -> crate::Result<()> {
-        let permutation = &[1, 2, 3];
+        let permutation = generate_permutation_gcd();
-        test_intfastfield_permutation_with_data(&permutation[..])?;
+        test_intfastfield_permutation_with_data(permutation)?;
         Ok(())
     }
 
     #[test]
     fn test_intfastfield_permutation() -> crate::Result<()> {
         let permutation = generate_permutation();
-        test_intfastfield_permutation_with_data(&permutation)?;
+        test_intfastfield_permutation_with_data(permutation)?;
-        Ok(())
-    }
-
-    #[test]
-    fn test_intfastfield_permutation_gcd() -> crate::Result<()> {
-        let permutation = generate_permutation_gcd();
-        test_intfastfield_permutation_with_data(&permutation)?;
         Ok(())
     }
 
@@ -511,7 +607,7 @@ mod tests {
         let mut all = vec![];
 
         for doc in docs {
-            let mut out: Vec<u64> = vec![];
+            let mut out = vec![];
             ff.get_vals(doc, &mut out);
             all.extend(out);
         }
@@ -708,6 +804,7 @@ mod tests {
 
     #[test]
     fn test_datefastfield() -> crate::Result<()> {
+        use crate::fastfield::FastValue;
         let mut schema_builder = Schema::builder();
         let date_field = schema_builder.add_date_field(
             "date",
@@ -745,19 +842,19 @@ mod tests {
         let dates_fast_field = fast_fields.dates(multi_date_field).unwrap();
         let mut dates = vec![];
         {
-            assert_eq!(date_fast_field.get_val(0).into_timestamp_micros(), 1i64);
+            assert_eq!(date_fast_field.get(0u32).into_timestamp_micros(), 1i64);
             dates_fast_field.get_vals(0u32, &mut dates);
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_micros(), 2i64);
             assert_eq!(dates[1].into_timestamp_micros(), 3i64);
         }
         {
-            assert_eq!(date_fast_field.get_val(1).into_timestamp_micros(), 4i64);
+            assert_eq!(date_fast_field.get(1u32).into_timestamp_micros(), 4i64);
             dates_fast_field.get_vals(1u32, &mut dates);
             assert!(dates.is_empty());
         }
         {
-            assert_eq!(date_fast_field.get_val(2).into_timestamp_micros(), 0i64);
+            assert_eq!(date_fast_field.get(2u32).into_timestamp_micros(), 0i64);
             dates_fast_field.get_vals(2u32, &mut dates);
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_micros(), 5i64);
@@ -768,12 +865,11 @@ mod tests {
 
     #[test]
     pub fn test_fastfield_bool() {
-        let test_fastfield: Arc<dyn Column<bool>> =
+        let test_fastfield = DynamicFastFieldReader::<bool>::from(vec![true, false, true, false]);
-            fastfield_codecs::serialize_and_load::<bool>(&[true, false, true, false]);
+        assert_eq!(test_fastfield.get(0), true);
-        assert_eq!(test_fastfield.get_val(0), true);
+        assert_eq!(test_fastfield.get(1), false);
-        assert_eq!(test_fastfield.get_val(1), false);
+        assert_eq!(test_fastfield.get(2), true);
-        assert_eq!(test_fastfield.get_val(2), true);
+        assert_eq!(test_fastfield.get(3), false);
-        assert_eq!(test_fastfield.get_val(3), false);
     }
 
     #[test]
@@ -800,14 +896,14 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 24);
+        assert_eq!(file.len(), 44);
         let composite_file = CompositeFile::open(&file)?;
-        let data = composite_file.open_read(field).unwrap().read_bytes()?;
+        let file = composite_file.open_read(field).unwrap();
-        let fast_field_reader = open::<bool>(data)?;
+        let fast_field_reader = DynamicFastFieldReader::<bool>::open(file)?;
-        assert_eq!(fast_field_reader.get_val(0), true);
+        assert_eq!(fast_field_reader.get(0), true);
-        assert_eq!(fast_field_reader.get_val(1), false);
+        assert_eq!(fast_field_reader.get(1), false);
-        assert_eq!(fast_field_reader.get_val(2), true);
+        assert_eq!(fast_field_reader.get(2), true);
-        assert_eq!(fast_field_reader.get_val(3), false);
+        assert_eq!(fast_field_reader.get(3), false);
 
         Ok(())
     }
@@ -836,13 +932,13 @@ mod tests {
             serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 36);
+        assert_eq!(file.len(), 56);
         let composite_file = CompositeFile::open(&file)?;
-        let data = composite_file.open_read(field).unwrap().read_bytes()?;
+        let file = composite_file.open_read(field).unwrap();
-        let fast_field_reader = open::<bool>(data)?;
+        let fast_field_reader = DynamicFastFieldReader::<bool>::open(file)?;
         for i in 0..25 {
-            assert_eq!(fast_field_reader.get_val(i * 2), true);
+            assert_eq!(fast_field_reader.get(i * 2), true);
-            assert_eq!(fast_field_reader.get_val(i * 2 + 1), false);
+            assert_eq!(fast_field_reader.get(i * 2 + 1), false);
         }
 
         Ok(())
@@ -854,95 +950,168 @@ mod tests {
         let directory: RamDirectory = RamDirectory::create();
 
         let mut schema_builder = Schema::builder();
-        let field = schema_builder.add_bool_field("field_bool", FAST);
+        schema_builder.add_bool_field("field_bool", FAST);
         let schema = schema_builder.build();
+        let field = schema.get_field("field_bool").unwrap();
 
         {
             let write: WritePtr = directory.open_write(path).unwrap();
-            let mut serializer = CompositeFastFieldSerializer::from_write(write)?;
+            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             let doc = Document::default();
             fast_field_writers.add_document(&doc);
-            fast_field_writers.serialize(&mut serializer, &HashMap::new(), None)?;
+            fast_field_writers
-            serializer.close()?;
+                .serialize(&mut serializer, &HashMap::new(), None)
+                .unwrap();
+            serializer.close().unwrap();
         }
         let file = directory.open_read(path).unwrap();
+        assert_eq!(file.len(), 43);
         let composite_file = CompositeFile::open(&file)?;
-        assert_eq!(file.len(), 23);
+        let file = composite_file.open_read(field).unwrap();
-        let data = composite_file.open_read(field).unwrap().read_bytes()?;
+        let fast_field_reader = DynamicFastFieldReader::<bool>::open(file)?;
-        let fast_field_reader = open::<bool>(data)?;
+        assert_eq!(fast_field_reader.get(0), false);
-        assert_eq!(fast_field_reader.get_val(0), false);
 
         Ok(())
     }
+}
 
-    fn get_index(
+#[cfg(all(test, feature = "unstable"))]
-        docs: &[crate::Document],
+mod bench {
-        schema: &Schema,
+    use std::collections::HashMap;
-        codec_types: &[FastFieldCodecType],
+    use std::path::Path;
-    ) -> crate::Result<RamDirectory> {
+
+    use test::{self, Bencher};
+
+    use super::tests::{generate_permutation, FIELD, SCHEMA};
+    use super::*;
+    use crate::directory::{CompositeFile, Directory, RamDirectory, WritePtr};
+    use crate::fastfield::tests::generate_permutation_gcd;
+    use crate::fastfield::FastFieldReader;
+
+    #[bench]
+    fn bench_intfastfield_linear_veclookup(b: &mut Bencher) {
+        let permutation = generate_permutation();
+        b.iter(|| {
+            let n = test::black_box(7000u32);
+            let mut a = 0u64;
+            for i in (0u32..n / 7).map(|v| v * 7) {
+                a ^= permutation[i as usize];
+            }
+            a
+        });
+    }
+
+    #[bench]
+    fn bench_intfastfield_veclookup(b: &mut Bencher) {
+        let permutation = generate_permutation();
+        b.iter(|| {
+            let n = test::black_box(1000u32);
+            let mut a = 0u64;
+            for _ in 0u32..n {
+                a = permutation[a as usize];
+            }
+            a
+        });
+    }
+
+    #[bench]
+    fn bench_intfastfield_linear_fflookup(b: &mut Bencher) {
+        let path = Path::new("test");
+        let permutation = generate_permutation();
         let directory: RamDirectory = RamDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer =
+            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
-                CompositeFastFieldSerializer::from_write_with_codec(write, codec_types).unwrap();
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
-            let mut fast_field_writers = FastFieldsWriter::from_schema(schema);
+            for &x in &permutation {
-            for doc in docs {
+                fast_field_writers.add_document(&doc!(*FIELD=>x));
-                fast_field_writers.add_document(doc);
             }
             fast_field_writers
                 .serialize(&mut serializer, &HashMap::new(), None)
                 .unwrap();
             serializer.close().unwrap();
         }
-        Ok(directory)
+        let file = directory.open_read(&path).unwrap();
-    }
+        {
+            let fast_fields_composite = CompositeFile::open(&file).unwrap();
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data).unwrap();
 
-    #[test]
+            b.iter(|| {
-    pub fn test_gcd_date() -> crate::Result<()> {
+                let n = test::black_box(7000u32);
-        let size_prec_sec =
+                let mut a = 0u64;
-            test_gcd_date_with_codec(FastFieldCodecType::Bitpacked, DatePrecision::Seconds)?;
+                for i in (0u32..n / 7).map(|val| val * 7) {
-        assert_eq!(size_prec_sec, 28 + (1_000 * 13) / 8); // 13 bits per val = ceil(log_2(number of seconds in 2hours);
+                    a ^= fast_field_reader.get(i);
-        let size_prec_micro =
+                }
-            test_gcd_date_with_codec(FastFieldCodecType::Bitpacked, DatePrecision::Microseconds)?;
+                a
-        assert_eq!(size_prec_micro, 26 + (1_000 * 33) / 8); // 33 bits per val = ceil(log_2(number of microsecsseconds in 2hours);
+            });
-        Ok(())
+        }
-    }
+    }
-
+
-    fn test_gcd_date_with_codec(
+    #[bench]
-        codec_type: FastFieldCodecType,
+    fn bench_intfastfield_fflookup(b: &mut Bencher) {
-        precision: DatePrecision,
+        let path = Path::new("test");
-    ) -> crate::Result<usize> {
+        let permutation = generate_permutation();
-        let mut rng = StdRng::seed_from_u64(2u64);
+        let directory: RamDirectory = RamDirectory::create();
-        const T0: i64 = 1_662_345_825_012_529i64;
+        {
-        const ONE_HOUR_IN_MICROSECS: i64 = 3_600 * 1_000_000;
+            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-        let times: Vec<DateTime> = std::iter::repeat_with(|| {
+            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
-            // +- One hour.
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
-            let t = T0 + rng.gen_range(-ONE_HOUR_IN_MICROSECS..ONE_HOUR_IN_MICROSECS);
+            for &x in &permutation {
-            DateTime::from_timestamp_micros(t)
+                fast_field_writers.add_document(&doc!(*FIELD=>x));
-        })
+            }
-        .take(1_000)
+            fast_field_writers
-        .collect();
+                .serialize(&mut serializer, &HashMap::new(), None)
-        let date_options = DateOptions::default()
+                .unwrap();
-            .set_fast(Cardinality::SingleValue)
+            serializer.close().unwrap();
-            .set_precision(precision);
+        }
-        let mut schema_builder = SchemaBuilder::default();
+        let file = directory.open_read(&path).unwrap();
-        let field = schema_builder.add_date_field("field", date_options);
+        {
-        let schema = schema_builder.build();
+            let fast_fields_composite = CompositeFile::open(&file).unwrap();
-
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
-        let docs: Vec<Document> = times.iter().map(|time| doc!(field=>*time)).collect();
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data).unwrap();
-
+
-        let directory = get_index(&docs[..], &schema, &[codec_type])?;
+            b.iter(|| {
-        let path = Path::new("test");
+                let mut a = 0u32;
-        let file = directory.open_read(path).unwrap();
+                for i in 0u32..permutation.len() as u32 {
-        let composite_file = CompositeFile::open(&file)?;
+                    a = fast_field_reader.get(i) as u32;
-        let file = composite_file.open_read(*FIELD).unwrap();
+                }
-        let len = file.len();
+                a
-        let test_fastfield = open::<DateTime>(file.read_bytes()?)?;
+            });
-
+        }
-        for (i, time) in times.iter().enumerate() {
+    }
-            assert_eq!(test_fastfield.get_val(i as u64), time.truncate(precision));
+
+    #[bench]
+    fn bench_intfastfield_fflookup_gcd(b: &mut Bencher) {
+        let path = Path::new("test");
+        let permutation = generate_permutation_gcd();
+        let directory: RamDirectory = RamDirectory::create();
+        {
+            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
+            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            for &x in &permutation {
+                fast_field_writers.add_document(&doc!(*FIELD=>x));
+            }
+            fast_field_writers
+                .serialize(&mut serializer, &HashMap::new(), None)
+                .unwrap();
+            serializer.close().unwrap();
+        }
+        let file = directory.open_read(&path).unwrap();
+        {
+            let fast_fields_composite = CompositeFile::open(&file).unwrap();
+            let data = fast_fields_composite.open_read(*FIELD).unwrap();
+            let fast_field_reader = DynamicFastFieldReader::<u64>::open(data).unwrap();
+
+            b.iter(|| {
+                let mut a = 0u32;
+                for i in 0u32..permutation.len() as u32 {
+                    a = fast_field_reader.get(i) as u32;
+                }
+                a
+            });
         }
-        Ok(len)
     }
 }

src/fastfield/multivalued/mod.rs

@@ -1,8 +1,6 @@
-mod multivalue_start_index;
 mod reader;
 mod writer;
 
-pub(crate) use self::multivalue_start_index::MultivalueStartIndex;
 pub use self::reader::MultiValuedFastFieldReader;
 pub use self::writer::MultiValuedFastFieldWriter;
 
@@ -343,13 +341,11 @@ mod tests {
     }
 
     proptest! {
-        #![proptest_config(proptest::prelude::ProptestConfig::with_cases(5))]
         #[test]
         fn test_multivalued_proptest(ops in proptest::collection::vec(operation_strategy(), 1..10)) {
             assert!(test_multivalued_no_panic(&ops[..]).is_ok());
         }
     }
-
     #[test]
     fn test_multivalued_proptest_gcd() {
         use IndexingOp::*;
@@ -388,151 +384,3 @@ mod tests {
         Ok(())
     }
 }
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-    use std::collections::HashMap;
-    use std::path::Path;
-
-    use test::{self, Bencher};
-
-    use super::*;
-    use crate::directory::{CompositeFile, Directory, RamDirectory, WritePtr};
-    use crate::fastfield::{CompositeFastFieldSerializer, FastFieldsWriter};
-    use crate::indexer::doc_id_mapping::DocIdMapping;
-    use crate::schema::{Cardinality, NumericOptions, Schema};
-    use crate::Document;
-
-    fn multi_values(num_docs: usize, vals_per_doc: usize) -> Vec<Vec<u64>> {
-        let mut vals = vec![];
-        for _i in 0..num_docs {
-            let mut block = vec![];
-            for j in 0..vals_per_doc {
-                block.push(j as u64);
-            }
-            vals.push(block);
-        }
-
-        vals
-    }
-
-    #[bench]
-    fn bench_multi_value_fflookup(b: &mut Bencher) {
-        let num_docs = 100_000;
-
-        let path = Path::new("test");
-        let directory: RamDirectory = RamDirectory::create();
-        let field = {
-            let options = NumericOptions::default().set_fast(Cardinality::MultiValues);
-            let mut schema_builder = Schema::builder();
-            let field = schema_builder.add_u64_field("field", options);
-            let schema = schema_builder.build();
-
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
-            for block in &multi_values(num_docs, 3) {
-                let mut doc = Document::new();
-                for val in block {
-                    doc.add_u64(field, *val);
-                }
-                fast_field_writers.add_document(&doc);
-            }
-            fast_field_writers
-                .serialize(&mut serializer, &HashMap::new(), None)
-                .unwrap();
-            serializer.close().unwrap();
-            field
-        };
-        let file = directory.open_read(&path).unwrap();
-        {
-            let fast_fields_composite = CompositeFile::open(&file).unwrap();
-            let data_idx = fast_fields_composite
-                .open_read_with_idx(field, 0)
-                .unwrap()
-                .read_bytes()
-                .unwrap();
-            let idx_reader = fastfield_codecs::open(data_idx).unwrap();
-
-            let data_vals = fast_fields_composite
-                .open_read_with_idx(field, 1)
-                .unwrap()
-                .read_bytes()
-                .unwrap();
-            let vals_reader = fastfield_codecs::open(data_vals).unwrap();
-            let fast_field_reader = MultiValuedFastFieldReader::open(idx_reader, vals_reader);
-            b.iter(|| {
-                let mut sum = 0u64;
-                let mut data = Vec::with_capacity(10);
-                for i in 0u32..num_docs as u32 {
-                    fast_field_reader.get_vals(i, &mut data);
-                    sum += data.iter().sum::<u64>();
-                }
-                sum
-            });
-        }
-    }
-
-    #[bench]
-    fn bench_multi_value_ff_creation(b: &mut Bencher) {
-        // 3 million ff entries
-        let num_docs = 1_000_000;
-        let multi_values = multi_values(num_docs, 3);
-
-        b.iter(|| {
-            let directory: RamDirectory = RamDirectory::create();
-            let options = NumericOptions::default().set_fast(Cardinality::MultiValues);
-            let mut schema_builder = Schema::builder();
-            let field = schema_builder.add_u64_field("field", options);
-            let schema = schema_builder.build();
-
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
-            for block in &multi_values {
-                let mut doc = Document::new();
-                for val in block {
-                    doc.add_u64(field, *val);
-                }
-                fast_field_writers.add_document(&doc);
-            }
-            fast_field_writers
-                .serialize(&mut serializer, &HashMap::new(), None)
-                .unwrap();
-            serializer.close().unwrap();
-        });
-    }
-
-    #[bench]
-    fn bench_multi_value_ff_creation_with_sorting(b: &mut Bencher) {
-        // 3 million ff entries
-        let num_docs = 1_000_000;
-        let multi_values = multi_values(num_docs, 3);
-
-        let doc_id_mapping =
-            DocIdMapping::from_new_id_to_old_id((0..1_000_000).collect::<Vec<_>>());
-
-        b.iter(|| {
-            let directory: RamDirectory = RamDirectory::create();
-            let options = NumericOptions::default().set_fast(Cardinality::MultiValues);
-            let mut schema_builder = Schema::builder();
-            let field = schema_builder.add_u64_field("field", options);
-            let schema = schema_builder.build();
-
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = CompositeFastFieldSerializer::from_write(write).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
-            for block in &multi_values {
-                let mut doc = Document::new();
-                for val in block {
-                    doc.add_u64(field, *val);
-                }
-                fast_field_writers.add_document(&doc);
-            }
-            fast_field_writers
-                .serialize(&mut serializer, &HashMap::new(), Some(&doc_id_mapping))
-                .unwrap();
-            serializer.close().unwrap();
-        });
-    }
-}

src/fastfield/multivalued/multivalue_start_index.rs

@@ -1,195 +0,0 @@
-use fastfield_codecs::{Column, ColumnReader};
-
-use crate::indexer::doc_id_mapping::DocIdMapping;
-use crate::DocId;
-
-pub(crate) struct MultivalueStartIndex<'a, C: Column> {
-    column: &'a C,
-    doc_id_map: &'a DocIdMapping,
-    min_value: u64,
-    max_value: u64,
-}
-
-struct MultivalueStartIndexReader<'a, C: Column> {
-    column: &'a C,
-    doc_id_map: &'a DocIdMapping,
-    idx: u64,
-    val: u64,
-    len: u64,
-}
-
-impl<'a, C: Column> MultivalueStartIndexReader<'a, C> {
-    fn new(column: &'a C, doc_id_map: &'a DocIdMapping) -> Self {
-        Self {
-            column,
-            doc_id_map,
-            idx: u64::MAX,
-            val: 0,
-            len: doc_id_map.num_new_doc_ids() as u64 + 1,
-        }
-    }
-
-    fn reset(&mut self) {
-        self.idx = u64::MAX;
-        self.val = 0;
-    }
-}
-
-impl<'a, C: Column> ColumnReader for MultivalueStartIndexReader<'a, C> {
-    fn seek(&mut self, idx: u64) -> u64 {
-        if self.idx > idx {
-            self.reset();
-            self.advance();
-        }
-        for _ in self.idx..idx {
-            self.advance();
-        }
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        if self.idx == u64::MAX {
-            self.idx = 0;
-            self.val = 0;
-            return true;
-        }
-        let new_doc_id: DocId = self.idx as DocId;
-        self.idx += 1;
-        if self.idx >= self.len {
-            self.idx = self.len;
-            return false;
-        }
-        let old_doc: DocId = self.doc_id_map.get_old_doc_id(new_doc_id);
-        let num_vals_for_doc =
-            self.column.get_val(old_doc as u64 + 1) - self.column.get_val(old_doc as u64);
-        self.val += num_vals_for_doc;
-        true
-    }
-
-    fn get(&self) -> u64 {
-        self.val
-    }
-}
-
-impl<'a, C: Column> MultivalueStartIndex<'a, C> {
-    pub fn new(column: &'a C, doc_id_map: &'a DocIdMapping) -> Self {
-        assert_eq!(column.num_vals(), doc_id_map.num_old_doc_ids() as u64 + 1);
-        let iter = MultivalueStartIndexIter::new(column, doc_id_map);
-        let (min_value, max_value) = tantivy_bitpacker::minmax(iter).unwrap_or((0, 0));
-        MultivalueStartIndex {
-            column,
-            doc_id_map,
-            min_value,
-            max_value,
-        }
-    }
-
-    fn specialized_reader(&self) -> MultivalueStartIndexReader<'a, C> {
-        MultivalueStartIndexReader::new(self.column, self.doc_id_map)
-    }
-}
-impl<'a, C: Column> Column for MultivalueStartIndex<'a, C> {
-    fn reader(&self) -> Box<dyn ColumnReader + '_> {
-        Box::new(self.specialized_reader())
-    }
-
-    fn get_val(&self, idx: u64) -> u64 {
-        let mut reader = self.specialized_reader();
-        reader.seek(idx)
-    }
-
-    fn min_value(&self) -> u64 {
-        self.min_value
-    }
-
-    fn max_value(&self) -> u64 {
-        self.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        (self.doc_id_map.num_new_doc_ids() + 1) as u64
-    }
-}
-
-struct MultivalueStartIndexIter<'a, C: Column> {
-    column: &'a C,
-    doc_id_map: &'a DocIdMapping,
-    new_doc_id: usize,
-    offset: u64,
-}
-
-impl<'a, C: Column> MultivalueStartIndexIter<'a, C> {
-    fn new(column: &'a C, doc_id_map: &'a DocIdMapping) -> Self {
-        Self {
-            column,
-            doc_id_map,
-            new_doc_id: 0,
-            offset: 0,
-        }
-    }
-}
-
-impl<'a, C: Column> Iterator for MultivalueStartIndexIter<'a, C> {
-    type Item = u64;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.new_doc_id > self.doc_id_map.num_new_doc_ids() {
-            return None;
-        }
-        let new_doc_id = self.new_doc_id;
-        self.new_doc_id += 1;
-        let start_offset = self.offset;
-        if new_doc_id < self.doc_id_map.num_new_doc_ids() {
-            let old_doc = self.doc_id_map.get_old_doc_id(new_doc_id as u32) as u64;
-            let num_vals_for_doc = self.column.get_val(old_doc + 1) - self.column.get_val(old_doc);
-            self.offset += num_vals_for_doc;
-        }
-        Some(start_offset)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use fastfield_codecs::VecColumn;
-
-    use super::*;
-
-    #[test]
-    fn test_multivalue_start_index() {
-        let doc_id_mapping = DocIdMapping::from_new_id_to_old_id(vec![4, 1, 2]);
-        assert_eq!(doc_id_mapping.num_old_doc_ids(), 5);
-        let col = VecColumn::from(&[0u64, 3, 5, 10, 12, 16][..]);
-        let multivalue_start_index = MultivalueStartIndex::new(
-            &col, // 3, 2, 5, 2, 4
-            &doc_id_mapping,
-        );
-        assert_eq!(multivalue_start_index.num_vals(), 4);
-        assert_eq!(
-            fastfield_codecs::iter_from_reader(multivalue_start_index.reader())
-                .collect::<Vec<u64>>(),
-            vec![0, 4, 6, 11]
-        ); // 4, 2, 5
-    }
-
-    #[test]
-    fn test_multivalue_get_vals() {
-        let doc_id_mapping =
-            DocIdMapping::from_new_id_to_old_id(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        assert_eq!(doc_id_mapping.num_old_doc_ids(), 10);
-        let col = VecColumn::from(&[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55][..]);
-        let multivalue_start_index = MultivalueStartIndex::new(&col, &doc_id_mapping);
-        assert_eq!(
-            fastfield_codecs::iter_from_reader(multivalue_start_index.reader())
-                .collect::<Vec<u64>>(),
-            vec![0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
-        );
-        assert_eq!(multivalue_start_index.num_vals(), 11);
-        let mut multivalue_start_index_reader = multivalue_start_index.reader();
-        assert_eq!(multivalue_start_index_reader.seek(3), 2);
-        assert_eq!(multivalue_start_index_reader.seek(5), 5);
-        assert_eq!(multivalue_start_index_reader.seek(8), 21);
-        assert_eq!(multivalue_start_index_reader.seek(4), 3);
-        assert_eq!(multivalue_start_index_reader.seek(0), 0);
-        assert_eq!(multivalue_start_index_reader.seek(10), 55);
-    }
-}

src/fastfield/multivalued/reader.rs

@@ -1,9 +1,6 @@
 use std::ops::Range;
-use std::sync::Arc;
 
-use fastfield_codecs::Column;
+use crate::fastfield::{DynamicFastFieldReader, FastFieldReader, FastValue, MultiValueLength};
-
-use crate::fastfield::{FastValue, MultiValueLength};
 use crate::DocId;
 
 /// Reader for a multivalued `u64` fast field.
@@ -15,14 +12,14 @@ use crate::DocId;
 /// The `idx_reader` associated, for each document, the index of its first value.
 #[derive(Clone)]
 pub struct MultiValuedFastFieldReader<Item: FastValue> {
-    idx_reader: Arc<dyn Column<u64>>,
+    idx_reader: DynamicFastFieldReader<u64>,
-    vals_reader: Arc<dyn Column<Item>>,
+    vals_reader: DynamicFastFieldReader<Item>,
 }
 
 impl<Item: FastValue> MultiValuedFastFieldReader<Item> {
     pub(crate) fn open(
-        idx_reader: Arc<dyn Column<u64>>,
+        idx_reader: DynamicFastFieldReader<u64>,
-        vals_reader: Arc<dyn Column<Item>>,
+        vals_reader: DynamicFastFieldReader<Item>,
     ) -> MultiValuedFastFieldReader<Item> {
         MultiValuedFastFieldReader {
             idx_reader,
@@ -34,9 +31,8 @@ impl<Item: FastValue> MultiValuedFastFieldReader<Item> {
     /// to the given document are `start..end`.
     #[inline]
     fn range(&self, doc: DocId) -> Range<u64> {
-        let idx = doc as u64;
+        let start = self.idx_reader.get(doc);
-        let start = self.idx_reader.get_val(idx);
+        let end = self.idx_reader.get(doc + 1);
-        let end = self.idx_reader.get_val(idx + 1);
         start..end
     }
 

src/fastfield/multivalued/writer.rs

@@ -1,11 +1,10 @@
 use std::io;
 
-use fastfield_codecs::{MonotonicallyMappableToU64, VecColumn};
 use fnv::FnvHashMap;
+use tantivy_bitpacker::minmax;
 
-use crate::fastfield::{
+use crate::fastfield::serializer::BitpackedSerializerLegacy;
-    value_to_u64, CompositeFastFieldSerializer, FastFieldType, MultivalueStartIndex,
+use crate::fastfield::{value_to_u64, CompositeFastFieldSerializer, FastFieldType, FastValue};
-};
 use crate::indexer::doc_id_mapping::DocIdMapping;
 use crate::postings::UnorderedTermId;
 use crate::schema::{Document, Field, Value};
@@ -18,15 +17,17 @@ use crate::{DatePrecision, DocId};
 /// This `Writer` is only useful for advanced users.
 /// The normal way to get your multivalued int in your index
 /// is to
-/// - declare your field with fast set to
+/// - declare your field with fast set to `Cardinality::MultiValues`
-///   [`Cardinality::MultiValues`](crate::schema::Cardinality::MultiValues) in your schema
+/// in your schema
 /// - add your document simply by calling `.add_document(...)`.
 ///
-/// The `MultiValuedFastFieldWriter` can be acquired from the fastfield writer, by calling
+/// The `MultiValuedFastFieldWriter` can be acquired from the
-/// [`FastFieldWriter::get_multivalue_writer_mut()`](crate::fastfield::FastFieldsWriter::get_multivalue_writer_mut).
+/// fastfield writer, by calling
+/// [`.get_multivalue_writer_mut(...)`](./struct.FastFieldsWriter.html#method.
+/// get_multivalue_writer_mut).
 ///
 /// Once acquired, writing is done by calling
-/// [`.add_document(&Document)`](MultiValuedFastFieldWriter::add_document) once per value.
+/// [`.add_document_vals(&[u64])`](MultiValuedFastFieldWriter::add_document_vals) once per document.
 ///
 /// The serializer makes it possible to remap all of the values
 /// that were pushed to the writer using a mapping.
@@ -100,6 +101,16 @@ impl MultiValuedFastFieldWriter {
         }
     }
 
+    /// Register all of the values associated to a document.
+    ///
+    /// The method returns the `DocId` of the document that was
+    /// just written.
+    pub fn add_document_vals(&mut self, vals: &[UnorderedTermId]) -> DocId {
+        let doc = self.doc_index.len() as DocId;
+        self.next_doc();
+        self.vals.extend_from_slice(vals);
+        doc
+    }
     /// Returns an iterator over values per doc_id in ascending doc_id order.
     ///
     /// Normally the order is simply iterating self.doc_id_index.
@@ -139,64 +150,72 @@ impl MultiValuedFastFieldWriter {
     /// `tantivy` builds a mapping to convert this `UnorderedTermId` into
     /// term ordinals.
     pub fn serialize(
-        mut self,
+        &self,
         serializer: &mut CompositeFastFieldSerializer,
-        term_mapping_opt: Option<&FnvHashMap<UnorderedTermId, TermOrdinal>>,
+        mapping_opt: Option<&FnvHashMap<UnorderedTermId, TermOrdinal>>,
         doc_id_map: Option<&DocIdMapping>,
     ) -> io::Result<()> {
         {
-            self.doc_index.push(self.vals.len() as u64);
+            // writing the offset index
-            let col = VecColumn::from(&self.doc_index[..]);
+            let mut doc_index_serializer =
-            if let Some(doc_id_map) = doc_id_map {
+                serializer.new_u64_fast_field_with_idx(self.field, 0, self.vals.len() as u64, 0)?;
-                let multi_value_start_index = MultivalueStartIndex::new(&col, doc_id_map);
+
-                serializer.create_auto_detect_u64_fast_field_with_idx(
+            let mut offset = 0;
-                    self.field,
+            for vals in self.get_ordered_values(doc_id_map) {
-                    multi_value_start_index,
+                doc_index_serializer.add_val(offset)?;
-                    0,
+                offset += vals.len() as u64;
-                )?;
-            } else {
-                serializer.create_auto_detect_u64_fast_field_with_idx(self.field, col, 0)?;
             }
+            doc_index_serializer.add_val(self.vals.len() as u64)?;
+
+            doc_index_serializer.close_field()?;
         }
         {
-            // Writing the values themselves.
+            // writing the values themselves.
-            // TODO FIXME: Use less memory.
+            let mut value_serializer: BitpackedSerializerLegacy<'_, _>;
-            let mut values: Vec<u64> = Vec::new();
+            if let Some(mapping) = mapping_opt {
-            if let Some(term_mapping) = term_mapping_opt {
+                value_serializer = serializer.new_u64_fast_field_with_idx(
+                    self.field,
+                    0u64,
+                    mapping.len() as u64,
+                    1,
+                )?;
+
                 if self.fast_field_type.is_facet() {
                     let mut doc_vals: Vec<u64> = Vec::with_capacity(100);
                     for vals in self.get_ordered_values(doc_id_map) {
-                        // In the case of facets, we want a vec of facet ord that is sorted.
                         doc_vals.clear();
                         let remapped_vals = vals
                             .iter()
-                            .map(|val| *term_mapping.get(val).expect("Missing term ordinal"));
+                            .map(|val| *mapping.get(val).expect("Missing term ordinal"));
                         doc_vals.extend(remapped_vals);
                         doc_vals.sort_unstable();
                         for &val in &doc_vals {
-                            values.push(val);
+                            value_serializer.add_val(val)?;
                         }
                     }
                 } else {
                     for vals in self.get_ordered_values(doc_id_map) {
                         let remapped_vals = vals
                             .iter()
-                            .map(|val| *term_mapping.get(val).expect("Missing term ordinal"));
+                            .map(|val| *mapping.get(val).expect("Missing term ordinal"));
                         for val in remapped_vals {
-                            values.push(val);
+                            value_serializer.add_val(val)?;
                         }
                     }
                 }
             } else {
+                let val_min_max = minmax(self.vals.iter().cloned());
+                let (val_min, val_max) = val_min_max.unwrap_or((0u64, 0u64));
+                value_serializer =
+                    serializer.new_u64_fast_field_with_idx(self.field, val_min, val_max, 1)?;
                 for vals in self.get_ordered_values(doc_id_map) {
                     // sort values in case of remapped doc_ids?
                     for &val in vals {
-                        values.push(val);
+                        value_serializer.add_val(val)?;
                     }
                 }
             }
-            let col = VecColumn::from(&values[..]);
+            value_serializer.close_field()?;
-            serializer.create_auto_detect_u64_fast_field_with_idx(self.field, col, 1)?;
         }
         Ok(())
     }

src/fastfield/reader.rs

@@ -0,0 +1,307 @@
+use std::collections::HashMap;
+use std::marker::PhantomData;
+use std::path::Path;
+
+use common::BinarySerializable;
+use fastfield_codecs::bitpacked::{BitpackedCodec, BitpackedReader};
+use fastfield_codecs::blockwise_linear::{BlockwiseLinearCodec, BlockwiseLinearReader};
+use fastfield_codecs::linear::{LinearCodec, LinearReader};
+use fastfield_codecs::{FastFieldCodec, FastFieldCodecType, FastFieldDataAccess};
+
+use super::gcd::open_gcd_from_bytes;
+use super::FastValue;
+use crate::directory::{CompositeFile, Directory, FileSlice, OwnedBytes, RamDirectory, WritePtr};
+use crate::error::DataCorruption;
+use crate::fastfield::{CompositeFastFieldSerializer, FastFieldsWriter, GCDReader};
+use crate::schema::{Schema, FAST};
+use crate::DocId;
+
+/// FastFieldReader is the trait to access fast field data.
+pub trait FastFieldReader<Item: FastValue>: Clone {
+    /// Return the value associated to the given document.
+    ///
+    /// This accessor should return as fast as possible.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `doc` is greater than the segment
+    fn get(&self, doc: DocId) -> Item;
+
+    /// Fills an output buffer with the fast field values
+    /// associated with the `DocId` going from
+    /// `start` to `start + output.len()`.
+    ///
+    /// Regardless of the type of `Item`, this method works
+    /// - transmuting the output array
+    /// - extracting the `Item`s as if they were `u64`
+    /// - possibly converting the `u64` value to the right type.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `start + output.len()` is greater than
+    /// the segment's `maxdoc`.
+    fn get_range(&self, start: u64, output: &mut [Item]);
+
+    /// Returns the minimum value for this fast field.
+    ///
+    /// The min value does not take in account of possible
+    /// deleted document, and should be considered as a lower bound
+    /// of the actual minimum value.
+    fn min_value(&self) -> Item;
+
+    /// Returns the maximum value for this fast field.
+    ///
+    /// The max value does not take in account of possible
+    /// deleted document, and should be considered as an upper bound
+    /// of the actual maximum value.
+    fn max_value(&self) -> Item;
+}
+
+#[derive(Clone)]
+/// DynamicFastFieldReader wraps different readers to access
+/// the various encoded fastfield data
+pub enum DynamicFastFieldReader<Item: FastValue> {
+    /// Bitpacked compressed fastfield data.
+    Bitpacked(FastFieldReaderCodecWrapper<Item, BitpackedReader>),
+    /// Linear interpolated values + bitpacked
+    Linear(FastFieldReaderCodecWrapper<Item, LinearReader>),
+    /// Blockwise linear interpolated values + bitpacked
+    BlockwiseLinear(FastFieldReaderCodecWrapper<Item, BlockwiseLinearReader>),
+
+    /// GCD and Bitpacked compressed fastfield data.
+    BitpackedGCD(FastFieldReaderCodecWrapper<Item, GCDReader<BitpackedReader>>),
+    /// GCD and Linear interpolated values + bitpacked
+    LinearGCD(FastFieldReaderCodecWrapper<Item, GCDReader<LinearReader>>),
+    /// GCD and Blockwise linear interpolated values + bitpacked
+    BlockwiseLinearGCD(FastFieldReaderCodecWrapper<Item, GCDReader<BlockwiseLinearReader>>),
+}
+
+impl<Item: FastValue> DynamicFastFieldReader<Item> {
+    /// Returns correct the reader wrapped in the `DynamicFastFieldReader` enum for the data.
+    pub fn open_from_id(
+        mut bytes: OwnedBytes,
+        codec_type: FastFieldCodecType,
+    ) -> crate::Result<DynamicFastFieldReader<Item>> {
+        let reader = match codec_type {
+            FastFieldCodecType::Bitpacked => {
+                DynamicFastFieldReader::Bitpacked(BitpackedCodec::open_from_bytes(bytes)?.into())
+            }
+            FastFieldCodecType::Linear => {
+                DynamicFastFieldReader::Linear(LinearCodec::open_from_bytes(bytes)?.into())
+            }
+            FastFieldCodecType::BlockwiseLinear => DynamicFastFieldReader::BlockwiseLinear(
+                BlockwiseLinearCodec::open_from_bytes(bytes)?.into(),
+            ),
+            FastFieldCodecType::Gcd => {
+                let codec_type = FastFieldCodecType::deserialize(&mut bytes)?;
+                match codec_type {
+                    FastFieldCodecType::Bitpacked => DynamicFastFieldReader::BitpackedGCD(
+                        open_gcd_from_bytes::<BitpackedCodec>(bytes)?.into(),
+                    ),
+                    FastFieldCodecType::Linear => DynamicFastFieldReader::LinearGCD(
+                        open_gcd_from_bytes::<LinearCodec>(bytes)?.into(),
+                    ),
+                    FastFieldCodecType::BlockwiseLinear => {
+                        DynamicFastFieldReader::BlockwiseLinearGCD(
+                            open_gcd_from_bytes::<BlockwiseLinearCodec>(bytes)?.into(),
+                        )
+                    }
+                    FastFieldCodecType::Gcd => {
+                        return Err(DataCorruption::comment_only(
+                            "Gcd codec wrapped into another gcd codec. This combination is not \
+                             allowed.",
+                        )
+                        .into())
+                    }
+                }
+            }
+        };
+        Ok(reader)
+    }
+
+    /// Returns correct the reader wrapped in the `DynamicFastFieldReader` enum for the data.
+    pub fn open(file: FileSlice) -> crate::Result<DynamicFastFieldReader<Item>> {
+        let mut bytes = file.read_bytes()?;
+        let codec_type = FastFieldCodecType::deserialize(&mut bytes)?;
+        Self::open_from_id(bytes, codec_type)
+    }
+}
+
+impl<Item: FastValue> FastFieldReader<Item> for DynamicFastFieldReader<Item> {
+    #[inline]
+    fn get(&self, doc: DocId) -> Item {
+        match self {
+            Self::Bitpacked(reader) => reader.get(doc),
+            Self::Linear(reader) => reader.get(doc),
+            Self::BlockwiseLinear(reader) => reader.get(doc),
+            Self::BitpackedGCD(reader) => reader.get(doc),
+            Self::LinearGCD(reader) => reader.get(doc),
+            Self::BlockwiseLinearGCD(reader) => reader.get(doc),
+        }
+    }
+    #[inline]
+    fn get_range(&self, start: u64, output: &mut [Item]) {
+        match self {
+            Self::Bitpacked(reader) => reader.get_range(start, output),
+            Self::Linear(reader) => reader.get_range(start, output),
+            Self::BlockwiseLinear(reader) => reader.get_range(start, output),
+            Self::BitpackedGCD(reader) => reader.get_range(start, output),
+            Self::LinearGCD(reader) => reader.get_range(start, output),
+            Self::BlockwiseLinearGCD(reader) => reader.get_range(start, output),
+        }
+    }
+    fn min_value(&self) -> Item {
+        match self {
+            Self::Bitpacked(reader) => reader.min_value(),
+            Self::Linear(reader) => reader.min_value(),
+            Self::BlockwiseLinear(reader) => reader.min_value(),
+            Self::BitpackedGCD(reader) => reader.min_value(),
+            Self::LinearGCD(reader) => reader.min_value(),
+            Self::BlockwiseLinearGCD(reader) => reader.min_value(),
+        }
+    }
+    fn max_value(&self) -> Item {
+        match self {
+            Self::Bitpacked(reader) => reader.max_value(),
+            Self::Linear(reader) => reader.max_value(),
+            Self::BlockwiseLinear(reader) => reader.max_value(),
+            Self::BitpackedGCD(reader) => reader.max_value(),
+            Self::LinearGCD(reader) => reader.max_value(),
+            Self::BlockwiseLinearGCD(reader) => reader.max_value(),
+        }
+    }
+}
+
+/// Wrapper for accessing a fastfield.
+///
+/// Holds the data and the codec to the read the data.
+#[derive(Clone)]
+pub struct FastFieldReaderCodecWrapper<Item: FastValue, CodecReader> {
+    reader: CodecReader,
+    _phantom: PhantomData<Item>,
+}
+
+impl<Item: FastValue, CodecReader> From<CodecReader>
+    for FastFieldReaderCodecWrapper<Item, CodecReader>
+{
+    fn from(reader: CodecReader) -> Self {
+        FastFieldReaderCodecWrapper {
+            reader,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<Item: FastValue, D: FastFieldDataAccess> FastFieldReaderCodecWrapper<Item, D> {
+    #[inline]
+    pub(crate) fn get_u64(&self, doc: u64) -> Item {
+        let data = self.reader.get_val(doc);
+        Item::from_u64(data)
+    }
+
+    /// Internally `multivalued` also use SingleValue Fast fields.
+    /// It works as follows... A first column contains the list of start index
+    /// for each document, a second column contains the actual values.
+    ///
+    /// The values associated to a given doc, are then
+    ///  `second_column[first_column.get(doc)..first_column.get(doc+1)]`.
+    ///
+    /// Which means single value fast field reader can be indexed internally with
+    /// something different from a `DocId`. For this use case, we want to use `u64`
+    /// values.
+    ///
+    /// See `get_range` for an actual documentation about this method.
+    pub(crate) fn get_range_u64(&self, start: u64, output: &mut [Item]) {
+        for (i, out) in output.iter_mut().enumerate() {
+            *out = self.get_u64(start + (i as u64));
+        }
+    }
+}
+
+impl<Item: FastValue, C: FastFieldDataAccess + Clone> FastFieldReader<Item>
+    for FastFieldReaderCodecWrapper<Item, C>
+{
+    /// Return the value associated to the given document.
+    ///
+    /// This accessor should return as fast as possible.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `doc` is greater than the segment
+    // `maxdoc`.
+    fn get(&self, doc: DocId) -> Item {
+        self.get_u64(u64::from(doc))
+    }
+
+    /// Fills an output buffer with the fast field values
+    /// associated with the `DocId` going from
+    /// `start` to `start + output.len()`.
+    ///
+    /// Regardless of the type of `Item`, this method works
+    /// - transmuting the output array
+    /// - extracting the `Item`s as if they were `u64`
+    /// - possibly converting the `u64` value to the right type.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `start + output.len()` is greater than
+    /// the segment's `maxdoc`.
+    fn get_range(&self, start: u64, output: &mut [Item]) {
+        self.get_range_u64(start, output);
+    }
+
+    /// Returns the minimum value for this fast field.
+    ///
+    /// The max value does not take in account of possible
+    /// deleted document, and should be considered as an upper bound
+    /// of the actual maximum value.
+    fn min_value(&self) -> Item {
+        Item::from_u64(self.reader.min_value())
+    }
+
+    /// Returns the maximum value for this fast field.
+    ///
+    /// The max value does not take in account of possible
+    /// deleted document, and should be considered as an upper bound
+    /// of the actual maximum value.
+    fn max_value(&self) -> Item {
+        Item::from_u64(self.reader.max_value())
+    }
+}
+
+impl<Item: FastValue> From<Vec<Item>> for DynamicFastFieldReader<Item> {
+    fn from(vals: Vec<Item>) -> DynamicFastFieldReader<Item> {
+        let mut schema_builder = Schema::builder();
+        let field = schema_builder.add_u64_field("field", FAST);
+        let schema = schema_builder.build();
+        let path = Path::new("__dummy__");
+        let directory: RamDirectory = RamDirectory::create();
+        {
+            let write: WritePtr = directory
+                .open_write(path)
+                .expect("With a RamDirectory, this should never fail.");
+            let mut serializer = CompositeFastFieldSerializer::from_write(write)
+                .expect("With a RamDirectory, this should never fail.");
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            {
+                let fast_field_writer = fast_field_writers
+                    .get_field_writer_mut(field)
+                    .expect("With a RamDirectory, this should never fail.");
+                for val in vals {
+                    fast_field_writer.add_val(val.to_u64());
+                }
+            }
+            fast_field_writers
+                .serialize(&mut serializer, &HashMap::new(), None)
+                .unwrap();
+            serializer.close().unwrap();
+        }
+
+        let file = directory.open_read(path).expect("Failed to open the file");
+        let composite_file = CompositeFile::open(&file).expect("Failed to read the composite file");
+        let field_file = composite_file
+            .open_read(field)
+            .expect("File component not found");
+        DynamicFastFieldReader::open(field_file).unwrap()
+    }
+}

src/fastfield/readers.rs

@@ -1,7 +1,4 @@
-use std::sync::Arc;
+use super::reader::DynamicFastFieldReader;
-
-use fastfield_codecs::{open, Column};
-
 use crate::directory::{CompositeFile, FileSlice};
 use crate::fastfield::{
     BytesFastFieldReader, FastFieldNotAvailableError, FastValue, MultiValuedFastFieldReader,
@@ -112,17 +109,14 @@ impl FastFieldReaders {
         &self,
         field: Field,
         index: usize,
-    ) -> crate::Result<Arc<dyn Column<TFastValue>>> {
+    ) -> crate::Result<DynamicFastFieldReader<TFastValue>> {
         let fast_field_slice = self.fast_field_data(field, index)?;
-        let bytes = fast_field_slice.read_bytes()?;
+        DynamicFastFieldReader::open(fast_field_slice)
-        let column = fastfield_codecs::open(bytes)?;
-        Ok(column)
     }
-
     pub(crate) fn typed_fast_field_reader<TFastValue: FastValue>(
         &self,
         field: Field,
-    ) -> crate::Result<Arc<dyn Column<TFastValue>>> {
+    ) -> crate::Result<DynamicFastFieldReader<TFastValue>> {
         self.typed_fast_field_reader_with_idx(field, 0)
     }
 
@@ -138,7 +132,7 @@ impl FastFieldReaders {
     /// Returns the `u64` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u64 fast field, this method returns an Error.
-    pub fn u64(&self, field: Field) -> crate::Result<Arc<dyn Column<u64>>> {
+    pub fn u64(&self, field: Field) -> crate::Result<DynamicFastFieldReader<u64>> {
         self.check_type(field, FastType::U64, Cardinality::SingleValue)?;
         self.typed_fast_field_reader(field)
     }
@@ -148,14 +142,14 @@ impl FastFieldReaders {
     ///
     /// If not, the fastfield reader will returns the u64-value associated to the original
     /// FastValue.
-    pub fn u64_lenient(&self, field: Field) -> crate::Result<Arc<dyn Column<u64>>> {
+    pub fn u64_lenient(&self, field: Field) -> crate::Result<DynamicFastFieldReader<u64>> {
         self.typed_fast_field_reader(field)
     }
 
     /// Returns the `i64` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a i64 fast field, this method returns an Error.
-    pub fn i64(&self, field: Field) -> crate::Result<Arc<dyn Column<i64>>> {
+    pub fn i64(&self, field: Field) -> crate::Result<DynamicFastFieldReader<i64>> {
         self.check_type(field, FastType::I64, Cardinality::SingleValue)?;
         self.typed_fast_field_reader(field)
     }
@@ -163,7 +157,7 @@ impl FastFieldReaders {
     /// Returns the `date` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a date fast field, this method returns an Error.
-    pub fn date(&self, field: Field) -> crate::Result<Arc<dyn Column<DateTime>>> {
+    pub fn date(&self, field: Field) -> crate::Result<DynamicFastFieldReader<DateTime>> {
         self.check_type(field, FastType::Date, Cardinality::SingleValue)?;
         self.typed_fast_field_reader(field)
     }
@@ -171,7 +165,7 @@ impl FastFieldReaders {
     /// Returns the `f64` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a f64 fast field, this method returns an Error.
-    pub fn f64(&self, field: Field) -> crate::Result<Arc<dyn Column<f64>>> {
+    pub fn f64(&self, field: Field) -> crate::Result<DynamicFastFieldReader<f64>> {
         self.check_type(field, FastType::F64, Cardinality::SingleValue)?;
         self.typed_fast_field_reader(field)
     }
@@ -179,7 +173,7 @@ impl FastFieldReaders {
     /// Returns the `bool` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a bool fast field, this method returns an Error.
-    pub fn bool(&self, field: Field) -> crate::Result<Arc<dyn Column<bool>>> {
+    pub fn bool(&self, field: Field) -> crate::Result<DynamicFastFieldReader<bool>> {
         self.check_type(field, FastType::Bool, Cardinality::SingleValue)?;
         self.typed_fast_field_reader(field)
     }
@@ -247,8 +241,7 @@ impl FastFieldReaders {
                 )));
             }
             let fast_field_idx_file = self.fast_field_data(field, 0)?;
-            let fast_field_idx_bytes = fast_field_idx_file.read_bytes()?;
+            let idx_reader = DynamicFastFieldReader::open(fast_field_idx_file)?;
-            let idx_reader = open(fast_field_idx_bytes)?;
             let data = self.fast_field_data(field, 1)?;
             BytesFastFieldReader::open(idx_reader, data)
         } else {

src/fastfield/remapped_column.rs

@@ -1,112 +0,0 @@
-use fastfield_codecs::{Column, ColumnReader};
-use tantivy_bitpacker::BlockedBitpacker;
-
-use crate::indexer::doc_id_mapping::DocIdMapping;
-use crate::DocId;
-
-#[derive(Clone)]
-pub(crate) struct WriterFastFieldColumn<'map, 'bitp> {
-    pub(crate) doc_id_mapping_opt: Option<&'map DocIdMapping>,
-    pub(crate) vals: &'bitp BlockedBitpacker,
-    pub(crate) min_value: u64,
-    pub(crate) max_value: u64,
-    pub(crate) num_vals: u64,
-}
-
-impl<'map, 'bitp> Column for WriterFastFieldColumn<'map, 'bitp> {
-    /// Return the value associated to the given doc.
-    ///
-    /// Whenever possible use the Iterator passed to the fastfield creation instead, for performance
-    /// reasons.
-    ///
-    /// # Panics
-    ///
-    /// May panic if `doc` is greater than the index.
-    fn get_val(&self, doc: u64) -> u64 {
-        if let Some(doc_id_map) = self.doc_id_mapping_opt {
-            self.vals
-                .get(doc_id_map.get_old_doc_id(doc as u32) as usize) // consider extra
-                                                                     // FastFieldReader wrapper for
-                                                                     // non doc_id_map
-        } else {
-            self.vals.get(doc as usize)
-        }
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader + '_> {
-        if let Some(doc_id_mapping) = self.doc_id_mapping_opt {
-            Box::new(RemappedColumnReader {
-                doc_id_mapping,
-                vals: self.vals,
-                idx: u64::MAX,
-                len: doc_id_mapping.num_new_doc_ids() as u64,
-            })
-        } else {
-            Box::new(BitpackedColumnReader {
-                vals: self.vals,
-                idx: u64::MAX,
-                len: self.num_vals,
-            })
-        }
-    }
-
-    fn min_value(&self) -> u64 {
-        self.min_value
-    }
-
-    fn max_value(&self) -> u64 {
-        self.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.num_vals
-    }
-}
-
-struct RemappedColumnReader<'a> {
-    doc_id_mapping: &'a DocIdMapping,
-    vals: &'a BlockedBitpacker,
-    idx: u64,
-    len: u64,
-}
-
-impl<'a> ColumnReader for RemappedColumnReader<'a> {
-    fn seek(&mut self, target_idx: u64) -> u64 {
-        assert!(target_idx < self.len);
-        self.idx = target_idx;
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        self.idx = self.idx.wrapping_add(1);
-        self.idx < self.len
-    }
-
-    fn get(&self) -> u64 {
-        let old_doc_id: DocId = self.doc_id_mapping.get_old_doc_id(self.idx as DocId);
-        self.vals.get(old_doc_id as usize)
-    }
-}
-
-struct BitpackedColumnReader<'a> {
-    vals: &'a BlockedBitpacker,
-    idx: u64,
-    len: u64,
-}
-
-impl<'a> ColumnReader for BitpackedColumnReader<'a> {
-    fn seek(&mut self, target_idx: u64) -> u64 {
-        assert!(target_idx < self.len);
-        self.idx = target_idx;
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        self.idx = self.idx.wrapping_add(1);
-        self.idx < self.len
-    }
-
-    fn get(&self) -> u64 {
-        self.vals.get(self.idx as usize)
-    }
-}

src/fastfield/serializer/mod.rs

@@ -1,9 +1,17 @@
 use std::io::{self, Write};
+use std::num::NonZeroU64;
 
-pub use fastfield_codecs::Column;
+use common::{BinarySerializable, CountingWriter};
-use fastfield_codecs::{FastFieldCodecType, MonotonicallyMappableToU64, ALL_CODEC_TYPES};
+use fastdivide::DividerU64;
+pub use fastfield_codecs::bitpacked::{BitpackedCodec, BitpackedSerializerLegacy};
+use fastfield_codecs::blockwise_linear::BlockwiseLinearCodec;
+use fastfield_codecs::linear::LinearCodec;
+use fastfield_codecs::FastFieldCodecType;
+pub use fastfield_codecs::{FastFieldCodec, FastFieldDataAccess, FastFieldStats};
 
+use super::{find_gcd, ALL_CODECS, GCD_DEFAULT};
 use crate::directory::{CompositeWrite, WritePtr};
+use crate::fastfield::gcd::write_gcd_header;
 use crate::schema::Field;
 
 /// `CompositeFastFieldSerializer` is in charge of serializing
@@ -15,68 +23,274 @@ use crate::schema::Field;
 /// the serializer.
 /// The serializer expects to receive the following calls.
 ///
-/// * `create_auto_detect_u64_fast_field(...)`
+/// * `new_u64_fast_field(...)`
-/// * `create_auto_detect_u64_fast_field(...)`
+/// * `add_val(...)`
+/// * `add_val(...)`
+/// * `add_val(...)`
 /// * ...
-/// * `let bytes_fastfield = new_bytes_fast_field(...)`
+/// * `close_field()`
-/// * `bytes_fastfield.write_all(...)`
+/// * `new_u64_fast_field(...)`
-/// * `bytes_fastfield.write_all(...)`
+/// * `add_val(...)`
-/// * `bytes_fastfield.flush()`
 /// * ...
+/// * `close_field()`
 /// * `close()`
 pub struct CompositeFastFieldSerializer {
     composite_write: CompositeWrite<WritePtr>,
-    codec_types: Vec<FastFieldCodecType>,
+    codec_enable_checker: FastFieldCodecEnableCheck,
+}
+
+#[derive(Debug, Clone)]
+pub struct FastFieldCodecEnableCheck {
+    enabled_codecs: Vec<FastFieldCodecType>,
+}
+impl FastFieldCodecEnableCheck {
+    fn allow_all() -> Self {
+        FastFieldCodecEnableCheck {
+            enabled_codecs: ALL_CODECS.to_vec(),
+        }
+    }
+    fn is_enabled(&self, code_type: FastFieldCodecType) -> bool {
+        self.enabled_codecs.contains(&code_type)
+    }
+}
+
+impl From<FastFieldCodecType> for FastFieldCodecEnableCheck {
+    fn from(code_type: FastFieldCodecType) -> Self {
+        FastFieldCodecEnableCheck {
+            enabled_codecs: vec![code_type],
+        }
+    }
+}
+
+// use this, when this is merged and stabilized explicit_generic_args_with_impl_trait
+// https://github.com/rust-lang/rust/pull/86176
+fn codec_estimation<C: FastFieldCodec, A: FastFieldDataAccess>(
+    fastfield_accessor: &A,
+    estimations: &mut Vec<(f32, FastFieldCodecType)>,
+) {
+    if !C::is_applicable(fastfield_accessor) {
+        return;
+    }
+    let ratio = C::estimate(fastfield_accessor);
+    estimations.push((ratio, C::CODEC_TYPE));
 }
 
 impl CompositeFastFieldSerializer {
-    /// New fast field serializer with all codec types
+    /// Constructor
     pub fn from_write(write: WritePtr) -> io::Result<CompositeFastFieldSerializer> {
-        Self::from_write_with_codec(write, &ALL_CODEC_TYPES)
+        Self::from_write_with_codec(write, FastFieldCodecEnableCheck::allow_all())
     }
 
-    /// New fast field serializer with allowed codec types
+    /// Constructor
     pub fn from_write_with_codec(
         write: WritePtr,
-        codec_types: &[FastFieldCodecType],
+        codec_enable_checker: FastFieldCodecEnableCheck,
     ) -> io::Result<CompositeFastFieldSerializer> {
+        // just making room for the pointer to header.
         let composite_write = CompositeWrite::wrap(write);
         Ok(CompositeFastFieldSerializer {
             composite_write,
-            codec_types: codec_types.to_vec(),
+            codec_enable_checker,
         })
     }
 
     /// Serialize data into a new u64 fast field. The best compression codec will be chosen
     /// automatically.
-    pub fn create_auto_detect_u64_fast_field<T: MonotonicallyMappableToU64>(
+    pub fn create_auto_detect_u64_fast_field(
         &mut self,
         field: Field,
-        fastfield_accessor: impl Column<T>,
+        fastfield_accessor: impl FastFieldDataAccess,
     ) -> io::Result<()> {
         self.create_auto_detect_u64_fast_field_with_idx(field, fastfield_accessor, 0)
     }
 
     /// Serialize data into a new u64 fast field. The best compression codec will be chosen
     /// automatically.
-    pub fn create_auto_detect_u64_fast_field_with_idx<T: MonotonicallyMappableToU64>(
+    pub fn write_header<W: Write>(
-        &mut self,
+        field_write: &mut W,
-        field: Field,
+        codec_type: FastFieldCodecType,
-        fastfield_accessor: impl Column<T>,
-        idx: usize,
     ) -> io::Result<()> {
-        let field_write = self.composite_write.for_field_with_idx(field, idx);
+        codec_type.to_code().serialize(field_write)?;
-        fastfield_codecs::serialize(fastfield_accessor, field_write, &self.codec_types)?;
         Ok(())
     }
 
-    /// Start serializing a new [u8] fast field. Use the returned writer to write data into the
+    /// Serialize data into a new u64 fast field. The best compression codec will be chosen
-    /// bytes field. To associate the bytes with documents a seperate index must be created on
+    /// automatically.
-    /// index 0. See bytes/writer.rs::serialize for an example.
+    pub fn create_auto_detect_u64_fast_field_with_idx(
-    ///
+        &mut self,
-    /// The bytes will be stored as is, no compression will be applied.
+        field: Field,
-    pub fn new_bytes_fast_field(&mut self, field: Field) -> impl Write + '_ {
+        fastfield_accessor: impl FastFieldDataAccess,
-        self.composite_write.for_field_with_idx(field, 1)
+        idx: usize,
+    ) -> io::Result<()> {
+        let min_value = fastfield_accessor.min_value();
+        let field_write = self.composite_write.for_field_with_idx(field, idx);
+        let gcd = find_gcd(fastfield_accessor.iter().map(|val| val - min_value))
+            .map(NonZeroU64::get)
+            .unwrap_or(GCD_DEFAULT);
+
+        if gcd == 1 {
+            return Self::create_auto_detect_u64_fast_field_with_idx_gcd(
+                self.codec_enable_checker.clone(),
+                field,
+                field_write,
+                fastfield_accessor,
+            );
+        }
+
+        Self::write_header(field_write, FastFieldCodecType::Gcd)?;
+        struct GCDWrappedFFAccess<T: FastFieldDataAccess> {
+            fastfield_accessor: T,
+            base_value: u64,
+            max_value: u64,
+            num_vals: u64,
+            gcd: DividerU64,
+        }
+
+        impl<T: FastFieldDataAccess> FastFieldDataAccess for GCDWrappedFFAccess<T> {
+            fn get_val(&self, position: u64) -> u64 {
+                self.gcd
+                    .divide(self.fastfield_accessor.get_val(position) - self.base_value)
+            }
+            fn iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+                Box::new(
+                    self.fastfield_accessor
+                        .iter()
+                        .map(|val| self.gcd.divide(val - self.base_value)),
+                )
+            }
+            fn min_value(&self) -> u64 {
+                0
+            }
+
+            fn max_value(&self) -> u64 {
+                self.max_value
+            }
+
+            fn num_vals(&self) -> u64 {
+                self.num_vals
+            }
+        }
+
+        let num_vals = fastfield_accessor.num_vals();
+        let base_value = fastfield_accessor.min_value();
+        let max_value = (fastfield_accessor.max_value() - fastfield_accessor.min_value()) / gcd;
+
+        let fastfield_accessor = GCDWrappedFFAccess {
+            fastfield_accessor,
+            base_value,
+            max_value,
+            num_vals,
+            gcd: DividerU64::divide_by(gcd),
+        };
+
+        Self::create_auto_detect_u64_fast_field_with_idx_gcd(
+            self.codec_enable_checker.clone(),
+            field,
+            field_write,
+            fastfield_accessor,
+        )?;
+        write_gcd_header(field_write, base_value, gcd, num_vals)?;
+        Ok(())
+    }
+
+    /// Serialize data into a new u64 fast field. The best compression codec will be chosen
+    /// automatically.
+    pub fn create_auto_detect_u64_fast_field_with_idx_gcd<W: Write>(
+        codec_enable_checker: FastFieldCodecEnableCheck,
+        field: Field,
+        field_write: &mut CountingWriter<W>,
+        fastfield_accessor: impl FastFieldDataAccess,
+    ) -> io::Result<()> {
+        let mut estimations = vec![];
+
+        if codec_enable_checker.is_enabled(FastFieldCodecType::Bitpacked) {
+            codec_estimation::<BitpackedCodec, _>(&fastfield_accessor, &mut estimations);
+        }
+        if codec_enable_checker.is_enabled(FastFieldCodecType::Linear) {
+            codec_estimation::<LinearCodec, _>(&fastfield_accessor, &mut estimations);
+        }
+        if codec_enable_checker.is_enabled(FastFieldCodecType::BlockwiseLinear) {
+            codec_estimation::<BlockwiseLinearCodec, _>(&fastfield_accessor, &mut estimations);
+        }
+        if let Some(broken_estimation) = estimations.iter().find(|estimation| estimation.0.is_nan())
+        {
+            warn!(
+                "broken estimation for fast field codec {:?}",
+                broken_estimation.1
+            );
+        }
+        // removing nan values for codecs with broken calculations, and max values which disables
+        // codecs
+        estimations.retain(|estimation| !estimation.0.is_nan() && estimation.0 != f32::MAX);
+        estimations.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+        let (_ratio, codec_type) = estimations[0];
+        debug!("choosing fast field codec {codec_type:?} for field_id {field:?}"); // todo print actual field name
+
+        Self::write_header(field_write, codec_type)?;
+        match codec_type {
+            FastFieldCodecType::Bitpacked => {
+                BitpackedCodec::serialize(field_write, &fastfield_accessor)?;
+            }
+            FastFieldCodecType::Linear => {
+                LinearCodec::serialize(field_write, &fastfield_accessor)?;
+            }
+            FastFieldCodecType::BlockwiseLinear => {
+                BlockwiseLinearCodec::serialize(field_write, &fastfield_accessor)?;
+            }
+            FastFieldCodecType::Gcd => {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "GCD codec not supported.",
+                ));
+            }
+        }
+        field_write.flush()?;
+
+        Ok(())
+    }
+
+    /// Start serializing a new u64 fast field
+    pub fn serialize_into(
+        &mut self,
+        field: Field,
+        min_value: u64,
+        max_value: u64,
+    ) -> io::Result<BitpackedSerializerLegacy<'_, CountingWriter<WritePtr>>> {
+        self.new_u64_fast_field_with_idx(field, min_value, max_value, 0)
+    }
+
+    /// Start serializing a new u64 fast field
+    pub fn new_u64_fast_field(
+        &mut self,
+        field: Field,
+        min_value: u64,
+        max_value: u64,
+    ) -> io::Result<BitpackedSerializerLegacy<'_, CountingWriter<WritePtr>>> {
+        self.new_u64_fast_field_with_idx(field, min_value, max_value, 0)
+    }
+
+    /// Start serializing a new u64 fast field
+    pub fn new_u64_fast_field_with_idx(
+        &mut self,
+        field: Field,
+        min_value: u64,
+        max_value: u64,
+        idx: usize,
+    ) -> io::Result<BitpackedSerializerLegacy<'_, CountingWriter<WritePtr>>> {
+        let field_write = self.composite_write.for_field_with_idx(field, idx);
+        // Prepend codec id to field data for compatibility with DynamicFastFieldReader.
+        FastFieldCodecType::Bitpacked.serialize(field_write)?;
+        BitpackedSerializerLegacy::open(field_write, min_value, max_value)
+    }
+
+    /// Start serializing a new [u8] fast field
+    pub fn new_bytes_fast_field_with_idx(
+        &mut self,
+        field: Field,
+        idx: usize,
+    ) -> FastBytesFieldSerializer<'_, CountingWriter<WritePtr>> {
+        let field_write = self.composite_write.for_field_with_idx(field, idx);
+        FastBytesFieldSerializer { write: field_write }
     }
 
     /// Closes the serializer
@@ -86,3 +300,17 @@ impl CompositeFastFieldSerializer {
         self.composite_write.close()
     }
 }
+
+pub struct FastBytesFieldSerializer<'a, W: Write> {
+    write: &'a mut W,
+}
+
+impl<'a, W: Write> FastBytesFieldSerializer<'a, W> {
+    pub fn write_all(&mut self, vals: &[u8]) -> io::Result<()> {
+        self.write.write_all(vals)
+    }
+
+    pub fn flush(&mut self) -> io::Result<()> {
+        self.write.flush()
+    }
+}

src/fastfield/writer.rs

@@ -2,13 +2,13 @@ use std::collections::HashMap;
 use std::io;
 
 use common;
-use fastfield_codecs::MonotonicallyMappableToU64;
+use fastfield_codecs::FastFieldDataAccess;
 use fnv::FnvHashMap;
 use tantivy_bitpacker::BlockedBitpacker;
 
 use super::multivalued::MultiValuedFastFieldWriter;
-use super::FastFieldType;
+use super::serializer::FastFieldStats;
-use crate::fastfield::remapped_column::WriterFastFieldColumn;
+use super::{FastFieldType, FastValue};
 use crate::fastfield::{BytesFastFieldWriter, CompositeFastFieldSerializer};
 use crate::indexer::doc_id_mapping::DocIdMapping;
 use crate::postings::UnorderedTermId;
@@ -169,7 +169,7 @@ impl FastFieldsWriter {
 
     /// Returns the fast field multi-value writer for the given field.
     ///
-    /// Returns `None` if the field does not exist, or is not
+    /// Returns None if the field does not exist, or is not
     /// configured as a multivalued fastfield in the schema.
     pub fn get_multivalue_writer_mut(
         &mut self,
@@ -183,7 +183,7 @@ impl FastFieldsWriter {
 
     /// Returns the bytes fast field writer for the given field.
     ///
-    /// Returns `None` if the field does not exist, or is not
+    /// Returns None if the field does not exist, or is not
     /// configured as a bytes fastfield in the schema.
     pub fn get_bytes_writer_mut(&mut self, field: Field) -> Option<&mut BytesFastFieldWriter> {
         // TODO optimize
@@ -211,12 +211,12 @@ impl FastFieldsWriter {
     /// Serializes all of the `FastFieldWriter`s by pushing them in
     /// order to the fast field serializer.
     pub fn serialize(
-        self,
+        &self,
         serializer: &mut CompositeFastFieldSerializer,
         mapping: &HashMap<Field, FnvHashMap<UnorderedTermId, TermOrdinal>>,
         doc_id_map: Option<&DocIdMapping>,
     ) -> io::Result<()> {
-        for field_writer in self.term_id_writers {
+        for field_writer in &self.term_id_writers {
             let field = field_writer.field();
             field_writer.serialize(serializer, mapping.get(&field), doc_id_map)?;
         }
@@ -224,11 +224,11 @@ impl FastFieldsWriter {
             field_writer.serialize(serializer, doc_id_map)?;
         }
 
-        for field_writer in self.multi_values_writers {
+        for field_writer in &self.multi_values_writers {
             let field = field_writer.field();
             field_writer.serialize(serializer, mapping.get(&field), doc_id_map)?;
         }
-        for field_writer in self.bytes_value_writers {
+        for field_writer in &self.bytes_value_writers {
             field_writer.serialize(serializer, doc_id_map)?;
         }
         Ok(())
@@ -352,7 +352,7 @@ impl IntFastFieldWriter {
     pub fn serialize(
         &self,
         serializer: &mut CompositeFastFieldSerializer,
-        doc_id_mapping_opt: Option<&DocIdMapping>,
+        doc_id_map: Option<&DocIdMapping>,
     ) -> io::Result<()> {
         let (min, max) = if self.val_min > self.val_max {
             (0, 0)
@@ -360,16 +360,71 @@ impl IntFastFieldWriter {
             (self.val_min, self.val_max)
         };
 
-        let fastfield_accessor = WriterFastFieldColumn {
+        let stats = FastFieldStats {
-            doc_id_mapping_opt,
-            vals: &self.vals,
             min_value: min,
             max_value: max,
             num_vals: self.val_count as u64,
         };
 
+        let fastfield_accessor = WriterFastFieldAccessProvider {
+            doc_id_map,
+            vals: &self.vals,
+            stats,
+        };
+
         serializer.create_auto_detect_u64_fast_field(self.field, fastfield_accessor)?;
 
         Ok(())
     }
 }
+
+#[derive(Clone)]
+struct WriterFastFieldAccessProvider<'map, 'bitp> {
+    doc_id_map: Option<&'map DocIdMapping>,
+    vals: &'bitp BlockedBitpacker,
+    stats: FastFieldStats,
+}
+impl<'map, 'bitp> FastFieldDataAccess for WriterFastFieldAccessProvider<'map, 'bitp> {
+    /// Return the value associated to the given doc.
+    ///
+    /// Whenever possible use the Iterator passed to the fastfield creation instead, for performance
+    /// reasons.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `doc` is greater than the index.
+    fn get_val(&self, doc: u64) -> u64 {
+        if let Some(doc_id_map) = self.doc_id_map {
+            self.vals
+                .get(doc_id_map.get_old_doc_id(doc as u32) as usize) // consider extra
+                                                                     // FastFieldReader wrapper for
+                                                                     // non doc_id_map
+        } else {
+            self.vals.get(doc as usize)
+        }
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+        if let Some(doc_id_map) = self.doc_id_map {
+            Box::new(
+                doc_id_map
+                    .iter_old_doc_ids()
+                    .map(|doc_id| self.vals.get(doc_id as usize)),
+            )
+        } else {
+            Box::new(self.vals.iter())
+        }
+    }
+
+    fn min_value(&self) -> u64 {
+        self.stats.min_value
+    }
+
+    fn max_value(&self) -> u64 {
+        self.stats.max_value
+    }
+
+    fn num_vals(&self) -> u64 {
+        self.stats.num_vals
+    }
+}

src/indexer/delete_queue.rs

@@ -178,7 +178,7 @@ pub struct DeleteCursor {
 impl DeleteCursor {
     /// Skips operations and position it so that
     /// - either all of the delete operation currently in the queue are consume and the next get
-    ///   will return `None`.
+    ///   will return None.
     /// - the next get will return the first operation with an
     /// `opstamp >= target_opstamp`.
     pub fn skip_to(&mut self, target_opstamp: Opstamp) {

src/indexer/doc_id_mapping.rs

@@ -91,12 +91,6 @@ impl DocIdMapping {
             .map(|old_doc| els[*old_doc as usize])
             .collect()
     }
-    pub fn num_new_doc_ids(&self) -> usize {
-        self.new_doc_id_to_old.len()
-    }
-    pub fn num_old_doc_ids(&self) -> usize {
-        self.old_doc_id_to_new.len()
-    }
 }
 
 pub(crate) fn expect_field_id_for_sort_field(
@@ -150,6 +144,7 @@ pub(crate) fn get_doc_id_mapping_from_field(
 #[cfg(test)]
 mod tests_indexsorting {
     use crate::collector::TopDocs;
+    use crate::fastfield::FastFieldReader;
     use crate::indexer::doc_id_mapping::DocIdMapping;
     use crate::query::QueryParser;
     use crate::schema::{Schema, *};
@@ -469,9 +464,9 @@ mod tests_indexsorting {
         let my_number = index.schema().get_field("my_number").unwrap();
 
         let fast_field = fast_fields.u64(my_number).unwrap();
-        assert_eq!(fast_field.get_val(0), 10u64);
+        assert_eq!(fast_field.get(0u32), 10u64);
-        assert_eq!(fast_field.get_val(1), 20u64);
+        assert_eq!(fast_field.get(1u32), 20u64);
-        assert_eq!(fast_field.get_val(2), 30u64);
+        assert_eq!(fast_field.get(2u32), 30u64);
 
         let multi_numbers = index.schema().get_field("multi_numbers").unwrap();
         let multifield = fast_fields.u64s(multi_numbers).unwrap();

src/indexer/index_writer.rs

@@ -31,7 +31,7 @@ pub const MARGIN_IN_BYTES: usize = 1_000_000;
 pub const MEMORY_ARENA_NUM_BYTES_MIN: usize = ((MARGIN_IN_BYTES as u32) * 3u32) as usize;
 pub const MEMORY_ARENA_NUM_BYTES_MAX: usize = u32::MAX as usize - MARGIN_IN_BYTES;
 
-// We impose the number of index writer threads to be at most this.
+// We impose the number of index writer thread to be at most this.
 pub const MAX_NUM_THREAD: usize = 8;
 
 // Add document will block if the number of docs waiting in the queue to be indexed
@@ -40,7 +40,7 @@ const PIPELINE_MAX_SIZE_IN_DOCS: usize = 10_000;
 
 fn error_in_index_worker_thread(context: &str) -> TantivyError {
     TantivyError::ErrorInThread(format!(
-        "{}. A worker thread encountered an error (io::Error most likely) or panicked.",
+        "{}. A worker thread encounterred an error (io::Error most likely) or panicked.",
         context
     ))
 }
@@ -49,7 +49,7 @@ fn error_in_index_worker_thread(context: &str) -> TantivyError {
 ///
 /// It manages a small number of indexing thread, as well as a shared
 /// indexing queue.
-/// Each indexing thread builds its own independent [`Segment`], via
+/// Each indexing thread builds its own independent `Segment`, via
 /// a `SegmentWriter` object.
 pub struct IndexWriter {
     // the lock is just used to bind the
@@ -174,7 +174,9 @@ fn index_documents(
     segment_updater: &mut SegmentUpdater,
     mut delete_cursor: DeleteCursor,
 ) -> crate::Result<()> {
-    let mut segment_writer = SegmentWriter::for_segment(memory_budget, segment.clone())?;
+    let schema = segment.schema();
+
+    let mut segment_writer = SegmentWriter::for_segment(memory_budget, segment.clone(), schema)?;
     for document_group in grouped_document_iterator {
         for doc in document_group {
             segment_writer.add_document(doc)?;
@@ -385,8 +387,8 @@ impl IndexWriter {
             .operation_receiver()
             .ok_or_else(|| {
                 crate::TantivyError::ErrorInThread(
-                    "The index writer was killed. It can happen if an indexing worker encountered \
+                    "The index writer was killed. It can happen if an indexing worker \
-                     an Io error for instance."
+                     encounterred an Io error for instance."
                         .to_string(),
                 )
             })
@@ -510,12 +512,10 @@ impl IndexWriter {
         Ok(self.committed_opstamp)
     }
 
-    /// Merges a given list of segments.
+    /// Merges a given list of segments
-    ///
-    /// If all segments are empty no new segment will be created.
     ///
     /// `segment_ids` is required to be non-empty.
-    pub fn merge(&mut self, segment_ids: &[SegmentId]) -> FutureResult<Option<SegmentMeta>> {
+    pub fn merge(&mut self, segment_ids: &[SegmentId]) -> FutureResult<SegmentMeta> {
         let merge_operation = self.segment_updater.make_merge_operation(segment_ids);
         let segment_updater = self.segment_updater.clone();
         segment_updater.start_merge(merge_operation)
@@ -595,14 +595,14 @@ impl IndexWriter {
     /// * `.commit()`: to accept this commit
     /// * `.abort()`: to cancel this commit.
     ///
-    /// In the current implementation, [`PreparedCommit`] borrows
+    /// In the current implementation, `PreparedCommit` borrows
-    /// the [`IndexWriter`] mutably so we are guaranteed that no new
+    /// the `IndexWriter` mutably so we are guaranteed that no new
     /// document can be added as long as it is committed or is
     /// dropped.
     ///
     /// It is also possible to add a payload to the `commit`
     /// using this API.
-    /// See [`PreparedCommit::set_payload()`].
+    /// See [`PreparedCommit::set_payload()`](PreparedCommit.html)
     pub fn prepare_commit(&mut self) -> crate::Result<PreparedCommit> {
         // Here, because we join all of the worker threads,
         // all of the segment update for this commit have been
@@ -785,6 +785,7 @@ mod tests {
     use crate::collector::TopDocs;
     use crate::directory::error::LockError;
     use crate::error::*;
+    use crate::fastfield::FastFieldReader;
     use crate::indexer::NoMergePolicy;
     use crate::query::{QueryParser, TermQuery};
     use crate::schema::{
@@ -1013,92 +1014,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_merge_on_empty_segments_single_segment() -> crate::Result<()> {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        let reader = index
-            .reader_builder()
-            .reload_policy(ReloadPolicy::Manual)
-            .try_into()?;
-        let num_docs_containing = |s: &str| {
-            let term_a = Term::from_field_text(text_field, s);
-            reader.searcher().doc_freq(&term_a).unwrap()
-        };
-        // writing the segment
-        let mut index_writer = index.writer(12_000_000).unwrap();
-        index_writer.add_document(doc!(text_field=>"a"))?;
-        index_writer.commit()?;
-        //  this should create 1 segment
-
-        let segments = index.searchable_segment_ids().unwrap();
-        assert_eq!(segments.len(), 1);
-
-        reader.reload().unwrap();
-        assert_eq!(num_docs_containing("a"), 1);
-
-        index_writer.delete_term(Term::from_field_text(text_field, "a"));
-        index_writer.commit()?;
-
-        reader.reload().unwrap();
-        assert_eq!(num_docs_containing("a"), 0);
-
-        index_writer.merge(&segments);
-        index_writer.wait_merging_threads().unwrap();
-
-        let segments = index.searchable_segment_ids().unwrap();
-        assert_eq!(segments.len(), 0);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_merge_on_empty_segments() -> crate::Result<()> {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        let reader = index
-            .reader_builder()
-            .reload_policy(ReloadPolicy::Manual)
-            .try_into()?;
-        let num_docs_containing = |s: &str| {
-            let term_a = Term::from_field_text(text_field, s);
-            reader.searcher().doc_freq(&term_a).unwrap()
-        };
-        // writing the segment
-        let mut index_writer = index.writer(12_000_000).unwrap();
-        index_writer.add_document(doc!(text_field=>"a"))?;
-        index_writer.commit()?;
-        index_writer.add_document(doc!(text_field=>"a"))?;
-        index_writer.commit()?;
-        index_writer.add_document(doc!(text_field=>"a"))?;
-        index_writer.commit()?;
-        index_writer.add_document(doc!(text_field=>"a"))?;
-        index_writer.commit()?;
-        //  this should create 4 segments
-
-        let segments = index.searchable_segment_ids().unwrap();
-        assert_eq!(segments.len(), 4);
-
-        reader.reload().unwrap();
-        assert_eq!(num_docs_containing("a"), 4);
-
-        index_writer.delete_term(Term::from_field_text(text_field, "a"));
-        index_writer.commit()?;
-
-        reader.reload().unwrap();
-        assert_eq!(num_docs_containing("a"), 0);
-
-        index_writer.merge(&segments);
-        index_writer.wait_merging_threads().unwrap();
-
-        let segments = index.searchable_segment_ids().unwrap();
-        assert_eq!(segments.len(), 0);
-
-        Ok(())
-    }
-
     #[test]
     fn test_with_merges() -> crate::Result<()> {
         let mut schema_builder = schema::Schema::builder();
@@ -1412,7 +1327,7 @@ mod tests {
         let fast_field_reader = segment_reader.fast_fields().u64(id_field)?;
         let in_order_alive_ids: Vec<u64> = segment_reader
             .doc_ids_alive()
-            .map(|doc| fast_field_reader.get_val(doc as u64))
+            .map(|doc| fast_field_reader.get(doc))
             .collect();
         assert_eq!(&in_order_alive_ids[..], &[9, 8, 7, 6, 5, 4, 1, 0]);
         Ok(())
@@ -1578,7 +1493,7 @@ mod tests {
                 let ff_reader = segment_reader.fast_fields().u64(id_field).unwrap();
                 segment_reader
                     .doc_ids_alive()
-                    .map(move |doc| ff_reader.get_val(doc as u64))
+                    .map(move |doc| ff_reader.get(doc))
             })
             .collect();
 
@@ -1589,7 +1504,7 @@ mod tests {
                 let ff_reader = segment_reader.fast_fields().u64(id_field).unwrap();
                 segment_reader
                     .doc_ids_alive()
-                    .map(move |doc| ff_reader.get_val(doc as u64))
+                    .map(move |doc| ff_reader.get(doc))
             })
             .collect();
 
@@ -1617,7 +1532,6 @@ mod tests {
 
         // multivalue fast field tests
         for segment_reader in searcher.segment_readers().iter() {
-            let id_reader = segment_reader.fast_fields().u64(id_field).unwrap();
             let ff_reader = segment_reader.fast_fields().u64s(multi_numbers).unwrap();
             let bool_ff_reader = segment_reader.fast_fields().bools(multi_bools).unwrap();
             for doc in segment_reader.doc_ids_alive() {
@@ -1625,7 +1539,6 @@ mod tests {
                 ff_reader.get_vals(doc, &mut vals);
                 assert_eq!(vals.len(), 2);
                 assert_eq!(vals[0], vals[1]);
-                assert_eq!(id_reader.get_val(doc as u64), vals[0]);
 
                 let mut bool_vals = vec![];
                 bool_ff_reader.get_vals(doc, &mut bool_vals);
@@ -1709,7 +1622,7 @@ mod tests {
                 facet_reader
                     .facet_from_ord(facet_ords[0], &mut facet)
                     .unwrap();
-                let id = ff_reader.get_val(doc_id as u64);
+                let id = ff_reader.get(doc_id);
                 let facet_expected = Facet::from(&("/cola/".to_string() + &id.to_string()));
 
                 assert_eq!(facet, facet_expected);

src/indexer/index_writer_status.rs

@@ -15,7 +15,7 @@ impl IndexWriterStatus {
     }
 
     /// Returns a copy of the operation receiver.
-    /// If the index writer was killed, returns `None`.
+    /// If the index writer was killed, returns None.
     pub fn operation_receiver(&self) -> Option<AddBatchReceiver> {
         let rlock = self
             .inner

src/indexer/json_term_writer.rs

@@ -1,4 +1,3 @@
-use fastfield_codecs::MonotonicallyMappableToU64;
 use fnv::FnvHashMap;
 use murmurhash32::murmurhash2;
 

src/indexer/merger.rs

@@ -1,21 +1,20 @@
+use std::cmp;
 use std::collections::HashMap;
-use std::io::Write;
 use std::sync::Arc;
 
-use fastfield_codecs::VecColumn;
 use itertools::Itertools;
 use measure_time::debug_time;
+use tantivy_bitpacker::minmax;
 
 use crate::core::{Segment, SegmentReader};
 use crate::docset::{DocSet, TERMINATED};
 use crate::error::DataCorruption;
 use crate::fastfield::{
-    AliveBitSet, Column, CompositeFastFieldSerializer, MultiValueLength, MultiValuedFastFieldReader,
+    AliveBitSet, CompositeFastFieldSerializer, DynamicFastFieldReader, FastFieldDataAccess,
+    FastFieldReader, FastFieldStats, MultiValueLength, MultiValuedFastFieldReader,
 };
 use crate::fieldnorm::{FieldNormReader, FieldNormReaders, FieldNormsSerializer, FieldNormsWriter};
 use crate::indexer::doc_id_mapping::{expect_field_id_for_sort_field, SegmentDocIdMapping};
-use crate::indexer::sorted_doc_id_column::SortedDocIdColumn;
-use crate::indexer::sorted_doc_id_multivalue_column::SortedDocIdMultiValueColumn;
 use crate::indexer::SegmentSerializer;
 use crate::postings::{InvertedIndexSerializer, Postings, SegmentPostings};
 use crate::schema::{Cardinality, Field, FieldType, Schema};
@@ -88,6 +87,28 @@ pub struct IndexMerger {
     max_doc: u32,
 }
 
+fn compute_min_max_val(
+    u64_reader: &impl FastFieldReader<u64>,
+    segment_reader: &SegmentReader,
+) -> Option<(u64, u64)> {
+    if segment_reader.max_doc() == 0 {
+        return None;
+    }
+
+    if segment_reader.alive_bitset().is_none() {
+        // no deleted documents,
+        // we can use the previous min_val, max_val.
+        return Some((u64_reader.min_value(), u64_reader.max_value()));
+    }
+    // some deleted documents,
+    // we need to recompute the max / min
+    minmax(
+        segment_reader
+            .doc_ids_alive()
+            .map(|doc_id| u64_reader.get(doc_id)),
+    )
+}
+
 struct TermOrdinalMapping {
     per_segment_new_term_ordinals: Vec<Vec<TermOrdinal>>,
 }
@@ -109,6 +130,14 @@ impl TermOrdinalMapping {
     fn get_segment(&self, segment_ord: usize) -> &[TermOrdinal] {
         &(self.per_segment_new_term_ordinals[segment_ord])[..]
     }
+
+    fn max_term_ord(&self) -> TermOrdinal {
+        self.per_segment_new_term_ordinals
+            .iter()
+            .flat_map(|term_ordinals| term_ordinals.iter().max())
+            .max()
+            .unwrap_or_default()
+    }
 }
 
 struct DeltaComputer {
@@ -171,7 +200,6 @@ impl IndexMerger {
                 readers.push(reader);
             }
         }
-
         let max_doc = readers.iter().map(|reader| reader.num_docs()).sum();
         if let Some(sort_by_field) = index_settings.sort_by_field.as_ref() {
             readers = Self::sort_readers_by_min_sort_field(readers, sort_by_field)?;
@@ -310,8 +338,82 @@ impl IndexMerger {
         fast_field_serializer: &mut CompositeFastFieldSerializer,
         doc_id_mapping: &SegmentDocIdMapping,
     ) -> crate::Result<()> {
-        let fast_field_accessor = SortedDocIdColumn::new(&self.readers, doc_id_mapping, field);
+        let (min_value, max_value) = self
-        fast_field_serializer.create_auto_detect_u64_fast_field(field, fast_field_accessor)?;
+            .readers
+            .iter()
+            .filter_map(|reader| {
+                let u64_reader: DynamicFastFieldReader<u64> =
+                    reader.fast_fields().typed_fast_field_reader(field).expect(
+                        "Failed to find a reader for single fast field. This is a tantivy bug and \
+                         it should never happen.",
+                    );
+                compute_min_max_val(&u64_reader, reader)
+            })
+            .reduce(|a, b| (a.0.min(b.0), a.1.max(b.1)))
+            .expect("Unexpected error, empty readers in IndexMerger");
+
+        let fast_field_readers = self
+            .readers
+            .iter()
+            .map(|reader| {
+                let u64_reader: DynamicFastFieldReader<u64> =
+                    reader.fast_fields().typed_fast_field_reader(field).expect(
+                        "Failed to find a reader for single fast field. This is a tantivy bug and \
+                         it should never happen.",
+                    );
+                u64_reader
+            })
+            .collect::<Vec<_>>();
+
+        let stats = FastFieldStats {
+            min_value,
+            max_value,
+            num_vals: doc_id_mapping.len() as u64,
+        };
+        #[derive(Clone)]
+        struct SortedDocIdFieldAccessProvider<'a> {
+            doc_id_mapping: &'a SegmentDocIdMapping,
+            fast_field_readers: &'a Vec<DynamicFastFieldReader<u64>>,
+            stats: FastFieldStats,
+        }
+        impl<'a> FastFieldDataAccess for SortedDocIdFieldAccessProvider<'a> {
+            fn get_val(&self, doc: u64) -> u64 {
+                let DocAddress {
+                    doc_id,
+                    segment_ord,
+                } = self.doc_id_mapping.get_old_doc_addr(doc as u32);
+                self.fast_field_readers[segment_ord as usize].get(doc_id)
+            }
+
+            fn iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+                Box::new(
+                    self.doc_id_mapping
+                        .iter_old_doc_addrs()
+                        .map(|old_doc_addr| {
+                            let fast_field_reader =
+                                &self.fast_field_readers[old_doc_addr.segment_ord as usize];
+                            fast_field_reader.get(old_doc_addr.doc_id)
+                        }),
+                )
+            }
+            fn min_value(&self) -> u64 {
+                self.stats.min_value
+            }
+
+            fn max_value(&self) -> u64 {
+                self.stats.max_value
+            }
+
+            fn num_vals(&self) -> u64 {
+                self.stats.num_vals
+            }
+        }
+        let fastfield_accessor = SortedDocIdFieldAccessProvider {
+            doc_id_mapping,
+            fast_field_readers: &fast_field_readers,
+            stats,
+        };
+        fast_field_serializer.create_auto_detect_u64_fast_field(field, fastfield_accessor)?;
 
         Ok(())
     }
@@ -327,7 +429,7 @@ impl IndexMerger {
 
         let everything_is_in_order = reader_ordinal_and_field_accessors
             .into_iter()
-            .map(|(_, col)| Arc::new(col))
+            .map(|reader| reader.1)
             .tuple_windows()
             .all(|(field_accessor1, field_accessor2)| {
                 if sort_by_field.order.is_asc() {
@@ -342,7 +444,7 @@ impl IndexMerger {
     pub(crate) fn get_sort_field_accessor(
         reader: &SegmentReader,
         sort_by_field: &IndexSortByField,
-    ) -> crate::Result<Arc<dyn Column>> {
+    ) -> crate::Result<impl FastFieldReader<u64>> {
         let field_id = expect_field_id_for_sort_field(reader.schema(), sort_by_field)?; // for now expect fastfield, but not strictly required
         let value_accessor = reader.fast_fields().u64_lenient(field_id)?;
         Ok(value_accessor)
@@ -351,7 +453,7 @@ impl IndexMerger {
     pub(crate) fn get_reader_with_sort_field_accessor(
         &self,
         sort_by_field: &IndexSortByField,
-    ) -> crate::Result<Vec<(SegmentOrdinal, Arc<dyn Column>)>> {
+    ) -> crate::Result<Vec<(SegmentOrdinal, impl FastFieldReader<u64> + Clone)>> {
         let reader_ordinal_and_field_accessors = self
             .readers
             .iter()
@@ -404,8 +506,8 @@ impl IndexMerger {
             doc_id_reader_pair
                 .into_iter()
                 .kmerge_by(|a, b| {
-                    let val1 = a.2.get_val(a.0 as u64);
+                    let val1 = a.2.get(a.0);
-                    let val2 = b.2.get_val(b.0 as u64);
+                    let val2 = b.2.get(b.0);
                     if sort_by_field.order == Order::Asc {
                         val1 < val2
                     } else {
@@ -429,6 +531,31 @@ impl IndexMerger {
         doc_id_mapping: &SegmentDocIdMapping,
         reader_and_field_accessors: &[(&SegmentReader, T)],
     ) -> crate::Result<Vec<u64>> {
+        let mut total_num_vals = 0u64;
+        // In the first pass, we compute the total number of vals.
+        //
+        // This is required by the bitpacker, as it needs to know
+        // what should be the bit length use for bitpacking.
+        let mut num_docs = 0;
+        for (reader, u64s_reader) in reader_and_field_accessors.iter() {
+            if let Some(alive_bitset) = reader.alive_bitset() {
+                num_docs += alive_bitset.num_alive_docs() as u64;
+                for doc in reader.doc_ids_alive() {
+                    let num_vals = u64s_reader.get_len(doc) as u64;
+                    total_num_vals += num_vals;
+                }
+            } else {
+                num_docs += reader.max_doc() as u64;
+                total_num_vals += u64s_reader.get_total_len();
+            }
+        }
+
+        let stats = FastFieldStats {
+            max_value: total_num_vals,
+            // The fastfield offset index contains (num_docs + 1) values.
+            num_vals: num_docs + 1,
+            min_value: 0,
+        };
         // We can now create our `idx` serializer, and in a second pass,
         // can effectively push the different indexes.
 
@@ -446,7 +573,35 @@ impl IndexMerger {
         }
         offsets.push(offset);
 
-        let fastfield_accessor = VecColumn::from(&offsets[..]);
+        #[derive(Clone)]
+        struct FieldIndexAccessProvider<'a> {
+            offsets: &'a [u64],
+            stats: FastFieldStats,
+        }
+        impl<'a> FastFieldDataAccess for FieldIndexAccessProvider<'a> {
+            fn get_val(&self, doc: u64) -> u64 {
+                self.offsets[doc as usize]
+            }
+
+            fn iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+                Box::new(self.offsets.iter().cloned())
+            }
+            fn min_value(&self) -> u64 {
+                self.stats.min_value
+            }
+
+            fn max_value(&self) -> u64 {
+                self.stats.max_value
+            }
+
+            fn num_vals(&self) -> u64 {
+                self.stats.num_vals
+            }
+        }
+        let fastfield_accessor = FieldIndexAccessProvider {
+            offsets: &offsets,
+            stats,
+        };
 
         fast_field_serializer.create_auto_detect_u64_fast_field(field, fastfield_accessor)?;
         Ok(offsets)
@@ -464,7 +619,7 @@ impl IndexMerger {
             .map(|reader| {
                 let u64s_reader: MultiValuedFastFieldReader<u64> = reader
                     .fast_fields()
-                    .typed_fast_field_multi_reader::<u64>(field)
+                    .typed_fast_field_multi_reader(field)
                     .expect(
                         "Failed to find index for multivalued field. This is a bug in tantivy, \
                          please report.",
@@ -510,23 +665,25 @@ impl IndexMerger {
             .collect::<Vec<_>>();
         // We can now write the actual fast field values.
         // In the case of hierarchical facets, they are actually term ordinals.
+        let max_term_ord = term_ordinal_mappings.max_term_ord();
         {
-            let mut vals = Vec::new();
+            let mut serialize_vals =
-            let mut buffer = Vec::new();
+                fast_field_serializer.new_u64_fast_field_with_idx(field, 0u64, max_term_ord, 1)?;
+            let mut vals = Vec::with_capacity(100);
+
             for old_doc_addr in doc_id_mapping.iter_old_doc_addrs() {
                 let term_ordinal_mapping: &[TermOrdinal] =
                     term_ordinal_mappings.get_segment(old_doc_addr.segment_ord as usize);
 
                 let ff_reader = &fast_field_reader[old_doc_addr.segment_ord as usize];
-                ff_reader.get_vals(old_doc_addr.doc_id, &mut buffer);
+                ff_reader.get_vals(old_doc_addr.doc_id, &mut vals);
-                for &prev_term_ord in &buffer {
+                for &prev_term_ord in &vals {
                     let new_term_ord = term_ordinal_mapping[prev_term_ord as usize];
-                    vals.push(new_term_ord);
+                    serialize_vals.add_val(new_term_ord)?;
                 }
             }
 
-            let col = VecColumn::from(&vals[..]);
+            serialize_vals.close_field()?;
-            fast_field_serializer.create_auto_detect_u64_fast_field_with_idx(field, col, 1)?;
         }
         Ok(())
     }
@@ -569,8 +726,115 @@ impl IndexMerger {
         let offsets =
             self.write_multi_value_fast_field_idx(field, fast_field_serializer, doc_id_mapping)?;
 
-        let fastfield_accessor =
+        let mut min_value = u64::MAX;
-            SortedDocIdMultiValueColumn::new(&self.readers, doc_id_mapping, &offsets, field);
+        let mut max_value = u64::MIN;
+        let mut num_vals = 0;
+
+        let mut vals = Vec::with_capacity(100);
+
+        let mut ff_readers = Vec::new();
+
+        // Our values are bitpacked and we need to know what should be
+        // our bitwidth and our minimum value before serializing any values.
+        //
+        // Computing those is non-trivial if some documents are deleted.
+        // We go through a complete first pass to compute the minimum and the
+        // maximum value and initialize our Serializer.
+        for reader in &self.readers {
+            let ff_reader: MultiValuedFastFieldReader<u64> = reader
+                .fast_fields()
+                .typed_fast_field_multi_reader(field)
+                .expect(
+                    "Failed to find multivalued fast field reader. This is a bug in tantivy. \
+                     Please report.",
+                );
+            for doc in reader.doc_ids_alive() {
+                ff_reader.get_vals(doc, &mut vals);
+                for &val in &vals {
+                    min_value = cmp::min(val, min_value);
+                    max_value = cmp::max(val, max_value);
+                }
+                num_vals += vals.len();
+            }
+            ff_readers.push(ff_reader);
+            // TODO optimize when no deletes
+        }
+
+        if min_value > max_value {
+            min_value = 0;
+            max_value = 0;
+        }
+
+        // We can now initialize our serializer, and push it the different values
+        let stats = FastFieldStats {
+            max_value,
+            num_vals: num_vals as u64,
+            min_value,
+        };
+
+        struct SortedDocIdMultiValueAccessProvider<'a> {
+            doc_id_mapping: &'a SegmentDocIdMapping,
+            fast_field_readers: &'a Vec<MultiValuedFastFieldReader<u64>>,
+            offsets: Vec<u64>,
+            stats: FastFieldStats,
+        }
+        impl<'a> FastFieldDataAccess for SortedDocIdMultiValueAccessProvider<'a> {
+            fn get_val(&self, pos: u64) -> u64 {
+                // use the offsets index to find the doc_id which will contain the position.
+                // the offsets are strictly increasing so we can do a simple search on it.
+                let new_doc_id: DocId =
+                    self.offsets
+                        .iter()
+                        .position(|offset| offset > pos)
+                        .expect("pos is out of bounds") as DocId
+                        - 1u32;
+
+                // now we need to find the position of `pos` in the multivalued bucket
+                let num_pos_covered_until_now = self.offsets[new_doc_id as usize];
+                let pos_in_values = pos - num_pos_covered_until_now;
+
+                let old_doc_addr = self.doc_id_mapping.get_old_doc_addr(new_doc_id);
+                let num_vals = self.fast_field_readers[old_doc_addr.segment_ord as usize]
+                    .get_len(old_doc_addr.doc_id);
+                assert!(num_vals >= pos_in_values);
+                let mut vals = Vec::new();
+                self.fast_field_readers[old_doc_addr.segment_ord as usize]
+                    .get_vals(old_doc_addr.doc_id, &mut vals);
+
+                vals[pos_in_values as usize]
+            }
+
+            fn iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+                Box::new(
+                    self.doc_id_mapping
+                        .iter_old_doc_addrs()
+                        .flat_map(|old_doc_addr| {
+                            let ff_reader =
+                                &self.fast_field_readers[old_doc_addr.segment_ord as usize];
+                            let mut vals = Vec::new();
+                            ff_reader.get_vals(old_doc_addr.doc_id, &mut vals);
+                            vals.into_iter()
+                        }),
+                )
+            }
+            fn min_value(&self) -> u64 {
+                self.stats.min_value
+            }
+
+            fn max_value(&self) -> u64 {
+                self.stats.max_value
+            }
+
+            fn num_vals(&self) -> u64 {
+                self.stats.num_vals
+            }
+        }
+        let fastfield_accessor = SortedDocIdMultiValueAccessProvider {
+            doc_id_mapping,
+            fast_field_readers: &ff_readers,
+            offsets,
+            stats,
+        };
         fast_field_serializer.create_auto_detect_u64_fast_field_with_idx(
             field,
             fastfield_accessor,
@@ -604,7 +868,7 @@ impl IndexMerger {
             doc_id_mapping,
             &reader_and_field_accessors,
         )?;
-        let mut serialize_vals = fast_field_serializer.new_bytes_fast_field(field);
+        let mut serialize_vals = fast_field_serializer.new_bytes_fast_field_with_idx(field, 1);
 
         for old_doc_addr in doc_id_mapping.iter_old_doc_addrs() {
             let bytes_reader = &reader_and_field_accessors[old_doc_addr.segment_ord as usize].1;
@@ -943,6 +1207,7 @@ mod tests {
     };
     use crate::collector::{Count, FacetCollector};
     use crate::core::Index;
+    use crate::fastfield::FastFieldReader;
     use crate::query::{AllQuery, BooleanQuery, Scorer, TermQuery};
     use crate::schema::{
         Cardinality, Document, Facet, FacetOptions, IndexRecordOption, NumericOptions, Term,

src/indexer/merger_sorted_index_test.rs

@@ -2,7 +2,7 @@
 mod tests {
     use crate::collector::TopDocs;
     use crate::core::Index;
-    use crate::fastfield::{AliveBitSet, MultiValuedFastFieldReader};
+    use crate::fastfield::{AliveBitSet, FastFieldReader, MultiValuedFastFieldReader};
     use crate::query::QueryParser;
     use crate::schema::{
         self, BytesOptions, Cardinality, Facet, FacetOptions, IndexRecordOption, NumericOptions,
@@ -186,17 +186,17 @@ mod tests {
 
         let fast_fields = segment_reader.fast_fields();
         let fast_field = fast_fields.u64(int_field).unwrap();
-        assert_eq!(fast_field.get_val(5), 1u64);
+        assert_eq!(fast_field.get(5u32), 1u64);
-        assert_eq!(fast_field.get_val(4), 2u64);
+        assert_eq!(fast_field.get(4u32), 2u64);
-        assert_eq!(fast_field.get_val(3), 3u64);
+        assert_eq!(fast_field.get(3u32), 3u64);
         if force_disjunct_segment_sort_values {
-            assert_eq!(fast_field.get_val(2u64), 20u64);
+            assert_eq!(fast_field.get(2u32), 20u64);
-            assert_eq!(fast_field.get_val(1u64), 100u64);
+            assert_eq!(fast_field.get(1u32), 100u64);
         } else {
-            assert_eq!(fast_field.get_val(2u64), 10u64);
+            assert_eq!(fast_field.get(2u32), 10u64);
-            assert_eq!(fast_field.get_val(1u64), 20u64);
+            assert_eq!(fast_field.get(1u32), 20u64);
         }
-        assert_eq!(fast_field.get_val(0u64), 1_000u64);
+        assert_eq!(fast_field.get(0u32), 1_000u64);
 
         // test new field norm mapping
         {
@@ -373,12 +373,12 @@ mod tests {
 
         let fast_fields = segment_reader.fast_fields();
         let fast_field = fast_fields.u64(int_field).unwrap();
-        assert_eq!(fast_field.get_val(0), 1u64);
+        assert_eq!(fast_field.get(0u32), 1u64);
-        assert_eq!(fast_field.get_val(1), 2u64);
+        assert_eq!(fast_field.get(1u32), 2u64);
-        assert_eq!(fast_field.get_val(2), 3u64);
+        assert_eq!(fast_field.get(2u32), 3u64);
-        assert_eq!(fast_field.get_val(3), 10u64);
+        assert_eq!(fast_field.get(3u32), 10u64);
-        assert_eq!(fast_field.get_val(4), 20u64);
+        assert_eq!(fast_field.get(4u32), 20u64);
-        assert_eq!(fast_field.get_val(5), 1_000u64);
+        assert_eq!(fast_field.get(5u32), 1_000u64);
 
         let get_vals = |fast_field: &MultiValuedFastFieldReader<u64>, doc_id: u32| -> Vec<u64> {
             let mut vals = vec![];
@@ -478,12 +478,11 @@ mod tests {
 #[cfg(all(test, feature = "unstable"))]
 mod bench_sorted_index_merge {
 
-    use std::sync::Arc;
-
-    use fastfield_codecs::Column;
     use test::{self, Bencher};
 
     use crate::core::Index;
+    // use cratedoc_id, readerdoc_id_mappinglet vals = reader.fate::schema;
+    use crate::fastfield::{DynamicFastFieldReader, FastFieldReader};
     use crate::indexer::merger::IndexMerger;
     use crate::schema::{Cardinality, NumericOptions, Schema};
     use crate::{IndexSettings, IndexSortByField, IndexWriter, Order};
@@ -535,7 +534,7 @@ mod bench_sorted_index_merge {
         b.iter(|| {
             let sorted_doc_ids = doc_id_mapping.iter_old_doc_addrs().map(|doc_addr| {
                 let reader = &merger.readers[doc_addr.segment_ord as usize];
-                let u64_reader: Arc<dyn Column<u64>> =
+                let u64_reader: DynamicFastFieldReader<u64> =
                     reader.fast_fields().typed_fast_field_reader(field).expect(
                         "Failed to find a reader for single fast field. This is a tantivy bug and \
                          it should never happen.",
@@ -545,7 +544,7 @@ mod bench_sorted_index_merge {
             // add values in order of the new doc_ids
             let mut val = 0;
             for (doc_id, _reader, field_reader) in sorted_doc_ids {
-                val = field_reader.get_val(doc_id as u64);
+                val = field_reader.get(doc_id);
             }
 
             val

src/indexer/mod.rs

@@ -19,8 +19,6 @@ mod segment_register;
 pub mod segment_serializer;
 pub mod segment_updater;
 mod segment_writer;
-mod sorted_doc_id_column;
-mod sorted_doc_id_multivalue_column;
 mod stamper;
 
 use crossbeam_channel as channel;

src/indexer/segment_manager.rs

@@ -173,7 +173,6 @@ impl SegmentManager {
                 .to_string();
             return Err(TantivyError::InvalidArgument(error_msg));
         }
-
         Ok(segment_entries)
     }
 
@@ -187,7 +186,7 @@ impl SegmentManager {
     pub(crate) fn end_merge(
         &self,
         before_merge_segment_ids: &[SegmentId],
-        after_merge_segment_entry: Option<SegmentEntry>,
+        after_merge_segment_entry: SegmentEntry,
     ) -> crate::Result<SegmentsStatus> {
         let mut registers_lock = self.write();
         let segments_status = registers_lock
@@ -208,9 +207,7 @@ impl SegmentManager {
         for segment_id in before_merge_segment_ids {
             target_register.remove_segment(segment_id);
         }
-        if let Some(entry) = after_merge_segment_entry {
+        target_register.add_segment_entry(after_merge_segment_entry);
-            target_register.add_segment_entry(entry);
-        }
         Ok(segments_status)
     }
 

src/indexer/segment_serializer.rs

@@ -38,16 +38,11 @@ impl SegmentSerializer {
         let fieldnorms_serializer = FieldNormsSerializer::from_write(fieldnorms_write)?;
 
         let postings_serializer = InvertedIndexSerializer::open(&mut segment)?;
-        let settings = segment.index().settings();
+        let compressor = segment.index().settings().docstore_compression;
-        let store_writer = StoreWriter::new(
+        let blocksize = segment.index().settings().docstore_blocksize;
-            store_write,
-            settings.docstore_compression,
-            settings.docstore_blocksize,
-            settings.docstore_compress_dedicated_thread,
-        )?;
         Ok(SegmentSerializer {
             segment,
-            store_writer,
+            store_writer: StoreWriter::new(store_write, compressor, blocksize)?,
             fast_field_serializer,
             fieldnorms_serializer: Some(fieldnorms_serializer),
             postings_serializer,

src/indexer/segment_updater.rs

@@ -25,10 +25,39 @@ use crate::indexer::{
     DefaultMergePolicy, MergeCandidate, MergeOperation, MergePolicy, SegmentEntry,
     SegmentSerializer,
 };
+use crate::schema::Schema;
 use crate::{FutureResult, Opstamp};
 
 const NUM_MERGE_THREADS: usize = 4;
 
+/// Save the index meta file.
+/// This operation is atomic :
+/// Either
+///  - it fails, in which case an error is returned,
+/// and the `meta.json` remains untouched,
+/// - it succeeds, and `meta.json` is written
+/// and flushed.
+///
+/// This method is not part of tantivy's public API
+pub fn save_new_metas(
+    schema: Schema,
+    index_settings: IndexSettings,
+    directory: &dyn Directory,
+) -> crate::Result<()> {
+    save_metas(
+        &IndexMeta {
+            index_settings,
+            segments: Vec::new(),
+            schema,
+            opstamp: 0u64,
+            payload: None,
+        },
+        directory,
+    )?;
+    directory.sync_directory()?;
+    Ok(())
+}
+
 /// Save the index meta file.
 /// This operation is atomic:
 /// Either
@@ -38,7 +67,7 @@ const NUM_MERGE_THREADS: usize = 4;
 /// and flushed.
 ///
 /// This method is not part of tantivy's public API
-pub(crate) fn save_metas(metas: &IndexMeta, directory: &dyn Directory) -> crate::Result<()> {
+fn save_metas(metas: &IndexMeta, directory: &dyn Directory) -> crate::Result<()> {
     info!("save metas");
     let mut buffer = serde_json::to_vec_pretty(metas)?;
     // Just adding a new line at the end of the buffer.
@@ -91,15 +120,7 @@ fn merge(
     index: &Index,
     mut segment_entries: Vec<SegmentEntry>,
     target_opstamp: Opstamp,
-) -> crate::Result<Option<SegmentEntry>> {
+) -> crate::Result<SegmentEntry> {
-    let num_docs = segment_entries
-        .iter()
-        .map(|segment| segment.meta().num_docs() as u64)
-        .sum::<u64>();
-    if num_docs == 0 {
-        return Ok(None);
-    }
-
     // first we need to apply deletes to our segment.
     let merged_segment = index.new_segment();
 
@@ -128,7 +149,7 @@ fn merge(
     let merged_segment_id = merged_segment.id();
 
     let segment_meta = index.new_segment_meta(merged_segment_id, num_docs);
-    Ok(Some(SegmentEntry::new(segment_meta, delete_cursor, None)))
+    Ok(SegmentEntry::new(segment_meta, delete_cursor, None))
 }
 
 /// Advanced: Merges a list of segments from different indices in a new index.
@@ -483,10 +504,7 @@ impl SegmentUpdater {
     // suggested and the moment when it ended up being executed.)
     //
     // `segment_ids` is required to be non-empty.
-    pub fn start_merge(
+    pub fn start_merge(&self, merge_operation: MergeOperation) -> FutureResult<SegmentMeta> {
-        &self,
-        merge_operation: MergeOperation,
-    ) -> FutureResult<Option<SegmentMeta>> {
         assert!(
             !merge_operation.segment_ids().is_empty(),
             "Segment_ids cannot be empty."
@@ -523,8 +541,9 @@ impl SegmentUpdater {
                 merge_operation.target_opstamp(),
             ) {
                 Ok(after_merge_segment_entry) => {
-                    let res = segment_updater.end_merge(merge_operation, after_merge_segment_entry);
+                    let segment_meta_res =
-                    let _send_result = merging_future_send.send(res);
+                        segment_updater.end_merge(merge_operation, after_merge_segment_entry);
+                    let _send_result = merging_future_send.send(segment_meta_res);
                 }
                 Err(merge_error) => {
                     warn!(
@@ -532,10 +551,8 @@ impl SegmentUpdater {
                         merge_operation.segment_ids().to_vec(),
                         merge_error
                     );
-                    if cfg!(test) {
-                        panic!("{:?}", merge_error);
-                    }
                     let _send_result = merging_future_send.send(Err(merge_error));
+                    assert!(!cfg!(test), "Merge failed.");
                 }
             }
         });
@@ -585,42 +602,35 @@ impl SegmentUpdater {
     fn end_merge(
         &self,
         merge_operation: MergeOperation,
-        mut after_merge_segment_entry: Option<SegmentEntry>,
+        mut after_merge_segment_entry: SegmentEntry,
-    ) -> crate::Result<Option<SegmentMeta>> {
+    ) -> crate::Result<SegmentMeta> {
         let segment_updater = self.clone();
-        let after_merge_segment_meta = after_merge_segment_entry
+        let after_merge_segment_meta = after_merge_segment_entry.meta().clone();
-            .as_ref()
-            .map(|after_merge_segment_entry| after_merge_segment_entry.meta().clone());
         self.schedule_task(move || {
-            info!(
+            info!("End merge {:?}", after_merge_segment_entry.meta());
-                "End merge {:?}",
-                after_merge_segment_entry.as_ref().map(|entry| entry.meta())
-            );
             {
-                if let Some(after_merge_segment_entry) = after_merge_segment_entry.as_mut() {
+                let mut delete_cursor = after_merge_segment_entry.delete_cursor().clone();
-                    let mut delete_cursor = after_merge_segment_entry.delete_cursor().clone();
+                if let Some(delete_operation) = delete_cursor.get() {
-                    if let Some(delete_operation) = delete_cursor.get() {
+                    let committed_opstamp = segment_updater.load_meta().opstamp;
-                        let committed_opstamp = segment_updater.load_meta().opstamp;
+                    if delete_operation.opstamp < committed_opstamp {
-                        if delete_operation.opstamp < committed_opstamp {
+                        let index = &segment_updater.index;
-                            let index = &segment_updater.index;
+                        let segment = index.segment(after_merge_segment_entry.meta().clone());
-                            let segment = index.segment(after_merge_segment_entry.meta().clone());
+                        if let Err(advance_deletes_err) = advance_deletes(
-                            if let Err(advance_deletes_err) = advance_deletes(
+                            segment,
-                                segment,
+                            &mut after_merge_segment_entry,
-                                after_merge_segment_entry,
+                            committed_opstamp,
-                                committed_opstamp,
+                        ) {
-                            ) {
+                            error!(
-                                error!(
+                                "Merge of {:?} was cancelled (advancing deletes failed): {:?}",
-                                    "Merge of {:?} was cancelled (advancing deletes failed): {:?}",
+                                merge_operation.segment_ids(),
-                                    merge_operation.segment_ids(),
+                                advance_deletes_err
-                                    advance_deletes_err
+                            );
-                                );
+                            assert!(!cfg!(test), "Merge failed.");
-                                assert!(!cfg!(test), "Merge failed.");
 
-                                // ... cancel merge
+                            // ... cancel merge
-                                // `merge_operations` are tracked. As it is dropped, the
+                            // `merge_operations` are tracked. As it is dropped, the
-                                // the segment_ids will be available again for merge.
+                            // the segment_ids will be available again for merge.
-                                return Err(advance_deletes_err);
+                            return Err(advance_deletes_err);
-                            }
                         }
                     }
                 }

src/indexer/segment_writer.rs

@@ -1,9 +1,7 @@
-use fastfield_codecs::MonotonicallyMappableToU64;
-
 use super::doc_id_mapping::{get_doc_id_mapping_from_field, DocIdMapping};
 use super::operation::AddOperation;
 use crate::core::Segment;
-use crate::fastfield::FastFieldsWriter;
+use crate::fastfield::{FastFieldsWriter, FastValue as _};
 use crate::fieldnorm::{FieldNormReaders, FieldNormsWriter};
 use crate::indexer::json_term_writer::index_json_values;
 use crate::indexer::segment_serializer::SegmentSerializer;
@@ -82,8 +80,8 @@ impl SegmentWriter {
     pub fn for_segment(
         memory_budget_in_bytes: usize,
         segment: Segment,
+        schema: Schema,
     ) -> crate::Result<SegmentWriter> {
-        let schema = segment.schema();
         let tokenizer_manager = segment.index().tokenizers().clone();
         let table_size = compute_initial_table_size(memory_budget_in_bytes)?;
         let segment_serializer = SegmentSerializer::for_segment(segment, false)?;
@@ -138,7 +136,7 @@ impl SegmentWriter {
         remap_and_write(
             &self.per_field_postings_writers,
             self.ctx,
-            self.fast_field_writers,
+            &self.fast_field_writers,
             &self.fieldnorms_writer,
             &self.schema,
             self.segment_serializer,
@@ -345,7 +343,7 @@ impl SegmentWriter {
 fn remap_and_write(
     per_field_postings_writers: &PerFieldPostingsWriter,
     ctx: IndexingContext,
-    fast_field_writers: FastFieldsWriter,
+    fast_field_writers: &FastFieldsWriter,
     fieldnorms_writer: &FieldNormsWriter,
     schema: &Schema,
     mut serializer: SegmentSerializer,
@@ -380,14 +378,12 @@ fn remap_and_write(
         let store_write = serializer
             .segment_mut()
             .open_write(SegmentComponent::Store)?;
-        let settings = serializer.segment().index().settings();
+        let compressor = serializer.segment().index().settings().docstore_compression;
-        let store_writer = StoreWriter::new(
+        let block_size = serializer.segment().index().settings().docstore_blocksize;
-            store_write,
+        let old_store_writer = std::mem::replace(
-            settings.docstore_compression,
+            &mut serializer.store_writer,
-            settings.docstore_blocksize,
+            StoreWriter::new(store_write, compressor, block_size)?,
-            settings.docstore_compress_dedicated_thread,
+        );
-        )?;
-        let old_store_writer = std::mem::replace(&mut serializer.store_writer, store_writer);
         old_store_writer.close()?;
         let store_read = StoreReader::open(
             serializer

src/indexer/sorted_doc_id_column.rs

@@ -1,133 +0,0 @@
-use std::sync::Arc;
-
-use fastfield_codecs::{Column, ColumnReader};
-use itertools::Itertools;
-
-use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
-use crate::schema::Field;
-use crate::{DocAddress, DocId, SegmentReader};
-
-pub(crate) struct SortedDocIdColumn<'a> {
-    doc_id_mapping: &'a SegmentDocIdMapping,
-    fast_field_readers: Vec<Arc<dyn Column<u64>>>,
-    min_value: u64,
-    max_value: u64,
-    num_vals: u64,
-}
-
-fn compute_min_max_val(
-    u64_reader: &dyn Column<u64>,
-    segment_reader: &SegmentReader,
-) -> Option<(u64, u64)> {
-    if segment_reader.max_doc() == 0 {
-        return None;
-    }
-
-    if segment_reader.alive_bitset().is_none() {
-        // no deleted documents,
-        // we can use the previous min_val, max_val.
-        return Some((u64_reader.min_value(), u64_reader.max_value()));
-    }
-    // some deleted documents,
-    // we need to recompute the max / min
-    segment_reader
-        .doc_ids_alive()
-        .map(|doc_id| u64_reader.get_val(doc_id as u64))
-        .minmax()
-        .into_option()
-}
-
-impl<'a> SortedDocIdColumn<'a> {
-    pub(crate) fn new(
-        readers: &'a [SegmentReader],
-        doc_id_mapping: &'a SegmentDocIdMapping,
-        field: Field,
-    ) -> Self {
-        let (min_value, max_value) = readers
-            .iter()
-            .filter_map(|reader| {
-                let u64_reader: Arc<dyn Column<u64>> =
-                    reader.fast_fields().typed_fast_field_reader(field).expect(
-                        "Failed to find a reader for single fast field. This is a tantivy bug and \
-                         it should never happen.",
-                    );
-                compute_min_max_val(&*u64_reader, reader)
-            })
-            .reduce(|a, b| (a.0.min(b.0), a.1.max(b.1)))
-            .expect("Unexpected error, empty readers in IndexMerger");
-
-        let fast_field_readers = readers
-            .iter()
-            .map(|reader| {
-                let u64_reader: Arc<dyn Column<u64>> =
-                    reader.fast_fields().typed_fast_field_reader(field).expect(
-                        "Failed to find a reader for single fast field. This is a tantivy bug and \
-                         it should never happen.",
-                    );
-                u64_reader
-            })
-            .collect::<Vec<_>>();
-
-        SortedDocIdColumn {
-            doc_id_mapping,
-            fast_field_readers,
-            min_value,
-            max_value,
-            num_vals: doc_id_mapping.len() as u64,
-        }
-    }
-}
-
-impl<'a> Column for SortedDocIdColumn<'a> {
-    fn get_val(&self, doc: u64) -> u64 {
-        let DocAddress {
-            doc_id,
-            segment_ord,
-        } = self.doc_id_mapping.get_old_doc_addr(doc as u32);
-        self.fast_field_readers[segment_ord as usize].get_val(doc_id as u64)
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader<u64> + '_> {
-        Box::new(SortedDocIdColumnReader {
-            doc_id_mapping: self.doc_id_mapping,
-            fast_field_readers: &self.fast_field_readers[..],
-            new_doc_id: u32::MAX,
-        })
-    }
-
-    fn min_value(&self) -> u64 {
-        self.min_value
-    }
-
-    fn max_value(&self) -> u64 {
-        self.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.num_vals
-    }
-}
-
-struct SortedDocIdColumnReader<'a> {
-    doc_id_mapping: &'a SegmentDocIdMapping,
-    fast_field_readers: &'a [Arc<dyn Column>],
-    new_doc_id: DocId,
-}
-
-impl<'a> ColumnReader for SortedDocIdColumnReader<'a> {
-    fn seek(&mut self, target_idx: u64) -> u64 {
-        assert!(target_idx < self.doc_id_mapping.len() as u64);
-        self.new_doc_id = target_idx as u32;
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        self.new_doc_id = self.new_doc_id.wrapping_add(1);
-        self.new_doc_id < self.doc_id_mapping.len() as u32
-    }
-
-    fn get(&self) -> u64 {
-        let old_doc = self.doc_id_mapping.get_old_doc_addr(self.new_doc_id);
-        self.fast_field_readers[old_doc.segment_ord as usize].get_val(old_doc.doc_id as u64)
-    }
-}

src/indexer/sorted_doc_id_multivalue_column.rs

@@ -1,185 +0,0 @@
-use std::cmp;
-
-use fastfield_codecs::{Column, ColumnReader};
-
-use crate::fastfield::{MultiValueLength, MultiValuedFastFieldReader};
-use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
-use crate::schema::Field;
-use crate::{DocId, SegmentReader};
-
-// We can now initialize our serializer, and push it the different values
-pub(crate) struct SortedDocIdMultiValueColumn<'a> {
-    doc_id_mapping: &'a SegmentDocIdMapping,
-    fast_field_readers: Vec<MultiValuedFastFieldReader<u64>>,
-    offsets: &'a [u64],
-    min_value: u64,
-    max_value: u64,
-    num_vals: u64,
-}
-
-impl<'a> SortedDocIdMultiValueColumn<'a> {
-    pub(crate) fn new(
-        readers: &'a [SegmentReader],
-        doc_id_mapping: &'a SegmentDocIdMapping,
-        offsets: &'a [u64],
-        field: Field,
-    ) -> Self {
-        // Our values are bitpacked and we need to know what should be
-        // our bitwidth and our minimum value before serializing any values.
-        //
-        // Computing those is non-trivial if some documents are deleted.
-        // We go through a complete first pass to compute the minimum and the
-        // maximum value and initialize our Serializer.
-        let mut num_vals = 0;
-        let mut min_value = u64::MAX;
-        let mut max_value = u64::MIN;
-        let mut vals = Vec::new();
-        let mut fast_field_readers = Vec::with_capacity(readers.len());
-        for reader in readers {
-            let ff_reader: MultiValuedFastFieldReader<u64> = reader
-                .fast_fields()
-                .typed_fast_field_multi_reader::<u64>(field)
-                .expect(
-                    "Failed to find multivalued fast field reader. This is a bug in tantivy. \
-                     Please report.",
-                );
-            for doc in reader.doc_ids_alive() {
-                ff_reader.get_vals(doc, &mut vals);
-                for &val in &vals {
-                    min_value = cmp::min(val, min_value);
-                    max_value = cmp::max(val, max_value);
-                }
-                num_vals += vals.len();
-            }
-            fast_field_readers.push(ff_reader);
-            // TODO optimize when no deletes
-        }
-        if min_value > max_value {
-            min_value = 0;
-            max_value = 0;
-        }
-        SortedDocIdMultiValueColumn {
-            doc_id_mapping,
-            fast_field_readers,
-            offsets,
-            min_value,
-            max_value,
-            num_vals: num_vals as u64,
-        }
-    }
-}
-
-impl<'a> Column for SortedDocIdMultiValueColumn<'a> {
-    fn get_val(&self, pos: u64) -> u64 {
-        // use the offsets index to find the doc_id which will contain the position.
-        // the offsets are strictly increasing so we can do a simple search on it.
-        let new_doc_id: DocId = self
-            .offsets
-            .iter()
-            .position(|&offset| offset > pos)
-            .expect("pos is out of bounds") as DocId
-            - 1u32;
-
-        // now we need to find the position of `pos` in the multivalued bucket
-        let num_pos_covered_until_now = self.offsets[new_doc_id as usize];
-        let pos_in_values = pos - num_pos_covered_until_now;
-
-        let old_doc_addr = self.doc_id_mapping.get_old_doc_addr(new_doc_id);
-        let num_vals =
-            self.fast_field_readers[old_doc_addr.segment_ord as usize].get_len(old_doc_addr.doc_id);
-        assert!(num_vals >= pos_in_values);
-        let mut vals = Vec::new();
-        self.fast_field_readers[old_doc_addr.segment_ord as usize]
-            .get_vals(old_doc_addr.doc_id, &mut vals);
-
-        vals[pos_in_values as usize]
-    }
-
-    fn min_value(&self) -> u64 {
-        self.min_value
-    }
-
-    fn max_value(&self) -> u64 {
-        self.max_value
-    }
-
-    fn num_vals(&self) -> u64 {
-        self.num_vals
-    }
-
-    fn reader(&self) -> Box<dyn ColumnReader<u64> + '_> {
-        let mut reader = SortedDocMultiValueColumnReader {
-            doc_id_mapping: self.doc_id_mapping,
-            fast_field_readers: &self.fast_field_readers[..],
-            new_doc_id: u32::MAX,
-            in_buffer_idx: 0,
-            buffer: Vec::new(),
-            idx: u64::MAX,
-        };
-        reader.reset();
-        Box::new(reader)
-    }
-}
-
-struct SortedDocMultiValueColumnReader<'a> {
-    doc_id_mapping: &'a SegmentDocIdMapping,
-    fast_field_readers: &'a [MultiValuedFastFieldReader<u64>],
-
-    new_doc_id: DocId,
-    in_buffer_idx: usize,
-    buffer: Vec<u64>,
-    idx: u64,
-}
-
-impl<'a> SortedDocMultiValueColumnReader<'a> {
-    fn fill(&mut self) {
-        let old_doc = self.doc_id_mapping.get_old_doc_addr(self.new_doc_id);
-        let ff_reader = &self.fast_field_readers[old_doc.segment_ord as usize];
-        ff_reader.get_vals(old_doc.doc_id, &mut self.buffer);
-        self.in_buffer_idx = 0;
-    }
-
-    fn reset(&mut self) {
-        self.buffer.clear();
-        self.idx = u64::MAX;
-        self.in_buffer_idx = 0;
-        self.new_doc_id = u32::MAX;
-    }
-}
-
-impl<'a> ColumnReader for SortedDocMultiValueColumnReader<'a> {
-    fn seek(&mut self, target_idx: u64) -> u64 {
-        if target_idx < self.idx {
-            self.reset();
-            self.advance();
-        }
-        for _ in self.idx..target_idx {
-            // TODO could be optimized.
-            assert!(self.advance());
-        }
-        self.get()
-    }
-
-    fn advance(&mut self) -> bool {
-        loop {
-            self.in_buffer_idx += 1;
-            if self.in_buffer_idx < self.buffer.len() {
-                self.idx = self.idx.wrapping_add(1);
-                return true;
-            }
-            self.new_doc_id = self.new_doc_id.wrapping_add(1);
-            if self.new_doc_id >= self.doc_id_mapping.len() as u32 {
-                return false;
-            }
-            self.fill();
-            if !self.buffer.is_empty() {
-                self.idx = self.idx.wrapping_add(1);
-                return true;
-            }
-        }
-    }
-
-    fn get(&self) -> u64 {
-        self.buffer[self.in_buffer_idx]
-    }
-}

src/lib.rs

@@ -301,7 +301,7 @@ pub use self::docset::{DocSet, TERMINATED};
 pub use crate::core::{
     Executor, Index, IndexBuilder, IndexMeta, IndexSettings, IndexSortByField, InvertedIndexReader,
     Order, Searcher, SearcherGeneration, Segment, SegmentComponent, SegmentId, SegmentMeta,
-    SegmentReader, SingleSegmentIndexWriter,
+    SegmentReader,
 };
 pub use crate::directory::Directory;
 pub use crate::indexer::demuxer::*;
@@ -429,6 +429,7 @@ pub mod tests {
     use crate::collector::tests::TEST_COLLECTOR_WITH_SCORE;
     use crate::core::SegmentReader;
     use crate::docset::{DocSet, TERMINATED};
+    use crate::fastfield::FastFieldReader;
     use crate::merge_policy::NoMergePolicy;
     use crate::query::BooleanQuery;
     use crate::schema::*;
@@ -1035,21 +1036,21 @@ pub mod tests {
             let fast_field_reader_opt = segment_reader.fast_fields().u64(fast_field_unsigned);
             assert!(fast_field_reader_opt.is_ok());
             let fast_field_reader = fast_field_reader_opt.unwrap();
-            assert_eq!(fast_field_reader.get_val(0), 4u64)
+            assert_eq!(fast_field_reader.get(0), 4u64)
         }
 
         {
             let fast_field_reader_res = segment_reader.fast_fields().i64(fast_field_signed);
             assert!(fast_field_reader_res.is_ok());
             let fast_field_reader = fast_field_reader_res.unwrap();
-            assert_eq!(fast_field_reader.get_val(0), 4i64)
+            assert_eq!(fast_field_reader.get(0), 4i64)
         }
 
         {
             let fast_field_reader_res = segment_reader.fast_fields().f64(fast_field_float);
             assert!(fast_field_reader_res.is_ok());
             let fast_field_reader = fast_field_reader_res.unwrap();
-            assert_eq!(fast_field_reader.get_val(0), 4f64)
+            assert_eq!(fast_field_reader.get(0), 4f64)
         }
         Ok(())
     }

src/positions/mod.rs

@@ -1,18 +1,18 @@
 //! Tantivy can (if instructed to do so in the schema) store the term positions in a given field.
 //! This position is expressed as token ordinal. For instance,
-//! In "The beauty and the beast", the term "the" appears in position 0 and position 3.
+//! In "The beauty and the beast", the term "the" appears in position 0 and position 4.
 //! This information is useful to run phrase queries.
 //!
-//! The [position](crate::SegmentComponent::Positions) file contains all of the
+//! The [position](../enum.SegmentComponent.html#variant.Positions) file contains all of the
 //! bitpacked positions delta, for all terms of a given field, one term after the other.
 //!
 //! Each term is encoded independently.
-//! Like for posting lists, tantivy relies on simd bitpacking to encode the positions delta in
+//! Like for positing lists, tantivy relies on simd bitpacking to encode the positions delta in
-//! blocks of 128 deltas. Because we rarely have a multiple of 128, the final block encodes
+//! blocks of 128 deltas. Because we rarely have a multiple of 128, a final block may encode the
-//! the remaining values with variable int encoding.
+//! remaining values variable byte encoding.
 //!
-//! In order to make reading possible, the term delta positions first encode the number of
+//! In order to make reading possible, the term delta positions first encodes the number of
-//! bitpacked blocks, then the bitwidth for each block, then the actual bitpacked blocks and finally
+//! bitpacked blocks, then the bitwidth for each blocks, then the actual bitpacked block and finally
 //! the final variable int encoded block.
 //!
 //! Contrary to postings list, the reader does not have access on the number of positions that is

src/postings/block_search.rs

@@ -12,7 +12,7 @@ use crate::postings::compression::COMPRESSION_BLOCK_SIZE;
 /// ```
 /// 
 /// the `start` argument is just used to hint that the response is
-/// greater than beyond `start`. The implementation may or may not use
+/// greater than beyond `start`. the implementation may or may not use
 /// it for optimization.
 ///
 /// # Assumption

src/postings/mod.rs

@@ -222,12 +222,12 @@ pub mod tests {
         let mut schema_builder = Schema::builder();
         let text_field = schema_builder.add_text_field("text", TEXT);
         let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
+        let index = Index::create_in_ram(schema.clone());
         let segment = index.new_segment();
 
         {
             let mut segment_writer =
-                SegmentWriter::for_segment(3_000_000, segment.clone()).unwrap();
+                SegmentWriter::for_segment(3_000_000, segment.clone(), schema).unwrap();
             {
                 // checking that position works if the field has two values
                 let op = AddOperation {

src/postings/postings_writer.rs

@@ -116,7 +116,7 @@ pub(crate) struct IndexingPosition {
 /// and building a `Segment` in anonymous memory.
 ///
 /// `PostingsWriter` writes in a `MemoryArena`.
-pub(crate) trait PostingsWriter: Send + Sync {
+pub(crate) trait PostingsWriter {
     /// Record that a document contains a term at a given position.
     ///
     /// * doc  - the document id

src/postings/recorder.rs

@@ -56,7 +56,7 @@ impl<'a> Iterator for VInt32Reader<'a> {
 ///   * the document id
 ///   * the term frequency
 ///   * the term positions
-pub(crate) trait Recorder: Copy + Default + Send + Sync + 'static {
+pub(crate) trait Recorder: Copy + Default + 'static {
     /// Returns the current document
     fn current_doc(&self) -> u32;
     /// Starts recording information about a new document

src/query/boolean_query/block_wand.rs

@@ -12,7 +12,7 @@ use crate::{DocId, DocSet, Score, TERMINATED};
 ///
 /// We always have `before_pivot_len` < `pivot_len`.
 ///
-/// `None` is returned if we establish that no document can exceed the threshold.
+/// None is returned if we establish that no document can exceed the threshold.
 fn find_pivot_doc(
     term_scorers: &[TermScorerWithMaxScore],
     threshold: Score,

src/query/phrase_query/phrase_query.rs

@@ -72,7 +72,7 @@ impl PhraseQuery {
         self.slop = value;
     }
 
-    /// The [`Field`] this `PhraseQuery` is targeting.
+    /// The `Field` this `PhraseQuery` is targeting.
     pub fn field(&self) -> Field {
         self.field
     }
@@ -85,10 +85,10 @@ impl PhraseQuery {
             .collect::<Vec<Term>>()
     }
 
-    /// Returns the [`PhraseWeight`] for the given phrase query given a specific `searcher`.
+    /// Returns the `PhraseWeight` for the given phrase query given a specific `searcher`.
     ///
-    /// This function is the same as [`Query::weight()`] except it returns
+    /// This function is the same as `.weight(...)` except it returns
-    /// a specialized type [`PhraseWeight`] instead of a Boxed trait.
+    /// a specialized type `PhraseWeight` instead of a Boxed trait.
     pub(crate) fn phrase_weight(
         &self,
         searcher: &Searcher,
@@ -121,7 +121,7 @@ impl PhraseQuery {
 impl Query for PhraseQuery {
     /// Create the weight associated to a query.
     ///
-    /// See [`Weight`].
+    /// See [`Weight`](./trait.Weight.html).
     fn weight(&self, searcher: &Searcher, scoring_enabled: bool) -> crate::Result<Box<dyn Weight>> {
         let phrase_weight = self.phrase_weight(searcher, scoring_enabled)?;
         Ok(Box::new(phrase_weight))

src/query/query.rs

@@ -15,39 +15,38 @@ use crate::{DocAddress, Term};
 /// - a set of documents
 /// - a way to score these documents
 ///
-/// When performing a [search](Searcher::search), these documents will then
+/// When performing a [search](Searcher::search),  these documents will then
-/// be pushed to a [`Collector`](crate::collector::Collector),
+/// be pushed to a [Collector](../collector/trait.Collector.html),
 /// which will in turn be in charge of deciding what to do with them.
 ///
 /// Concretely, this scored docset is represented by the
-/// [`Scorer`] trait.
+/// [`Scorer`](./trait.Scorer.html) trait.
 ///
 /// Because our index is actually split into segments, the
-/// query does not actually directly creates [`DocSet`](crate::DocSet) object.
+/// query does not actually directly creates `DocSet` object.
-/// Instead, the query creates a [`Weight`] object for a given searcher.
+/// Instead, the query creates a [`Weight`](./trait.Weight.html)
+/// object for a given searcher.
 ///
 /// The weight object, in turn, makes it possible to create
-/// a scorer for a specific [`SegmentReader`].
+/// a scorer for a specific [`SegmentReader`](../struct.SegmentReader.html).
 ///
 /// So to sum it up :
-/// - a `Query` is a recipe to define a set of documents as well the way to score them.
+/// - a `Query` is recipe to define a set of documents as well the way to score them.
-/// - a [`Weight`] is this recipe tied to a specific [`Searcher`]. It may for instance
+/// - a `Weight` is this recipe tied to a specific `Searcher`. It may for instance
 /// hold statistics about the different term of the query. It is created by the query.
-/// - a [`Scorer`] is a cursor over the set of matching documents, for a specific
+/// - a `Scorer` is a cursor over the set of matching documents, for a specific
-/// [`SegmentReader`]. It is created by the [`Weight`].
+/// [`SegmentReader`](../struct.SegmentReader.html). It is created by the
+/// [`Weight`](./trait.Weight.html).
 ///
 /// When implementing a new type of `Query`, it is normal to implement a
-/// dedicated `Query`, [`Weight`] and [`Scorer`].
+/// dedicated `Query`, `Weight` and `Scorer`.
-///
-/// [`Scorer`]: crate::query::Scorer
-/// [`SegmentReader`]: crate::SegmentReader
 pub trait Query: QueryClone + Send + Sync + downcast_rs::Downcast + fmt::Debug {
     /// Create the weight associated to a query.
     ///
     /// If scoring is not required, setting `scoring_enabled` to `false`
     /// can increase performances.
     ///
-    /// See [`Weight`].
+    /// See [`Weight`](./trait.Weight.html).
     fn weight(&self, searcher: &Searcher, scoring_enabled: bool) -> crate::Result<Box<dyn Weight>>;
 
     /// Returns an `Explanation` for the score of the document.

src/query/query_parser/query_parser.rs

@@ -113,8 +113,8 @@ fn trim_ast(logical_ast: LogicalAst) -> Option<LogicalAst> {
 /// The language covered by the current parser is extremely simple.
 ///
 /// * simple terms: "e.g.: `Barack Obama` are simply tokenized using tantivy's
-///   [`SimpleTokenizer`](crate::tokenizer::SimpleTokenizer), hence becoming `["barack", "obama"]`.
+///   [`SimpleTokenizer`](../tokenizer/struct.SimpleTokenizer.html), hence becoming `["barack",
-///   The terms are then searched within the default terms of the query parser.
+///   "obama"]`. The terms are then searched within the default terms of the query parser.
 ///
 ///   e.g. If `body` and `title` are default fields, our example terms are
 ///   `["title:barack", "body:barack", "title:obama", "body:obama"]`.
@@ -166,8 +166,8 @@ fn trim_ast(logical_ast: LogicalAst) -> Option<LogicalAst> {
 /// devops. Negative boosts are not allowed.
 ///
 /// It is also possible to define a boost for a some specific field, at the query parser level.
-/// (See [`set_field_boost(...)`](QueryParser::set_field_boost)). Typically you may want to boost a
+/// (See [`set_boost(...)`](#method.set_field_boost) ). Typically you may want to boost a title
-/// title field.
+/// field.
 ///
 /// Phrase terms support the `~` slop operator which allows to set the phrase's matching
 /// distance in words. `"big wolf"~1` will return documents containing the phrase `"big bad wolf"`.

src/query/scorer.rs

@@ -7,7 +7,7 @@ use crate::Score;
 
 /// Scored set of documents matching a query within a specific segment.
 ///
-/// See [`Query`](crate::query::Query).
+/// See [`Query`](./trait.Query.html).
 pub trait Scorer: downcast_rs::Downcast + DocSet + 'static {
     /// Returns the score.
     ///

src/query/weight.rs

@@ -19,7 +19,7 @@ pub(crate) fn for_each_scorer<TScorer: Scorer + ?Sized>(
 /// Calls `callback` with all of the `(doc, score)` for which score
 /// is exceeding a given threshold.
 ///
-/// This method is useful for the [`TopDocs`](crate::collector::TopDocs) collector.
+/// This method is useful for the TopDocs collector.
 /// For all docsets, the blanket implementation has the benefit
 /// of prefiltering (doc, score) pairs, avoiding the
 /// virtual dispatch cost.
@@ -41,22 +41,22 @@ pub(crate) fn for_each_pruning_scorer<TScorer: Scorer + ?Sized>(
     }
 }
 
-/// A Weight is the specialization of a `Query`
+/// A Weight is the specialization of a Query
 /// for a given set of segments.
 ///
-/// See [`Query`](crate::query::Query).
+/// See [`Query`](./trait.Query.html).
 pub trait Weight: Send + Sync + 'static {
     /// Returns the scorer for the given segment.
     ///
     /// `boost` is a multiplier to apply to the score.
     ///
-    /// See [`Query`](crate::query::Query).
+    /// See [`Query`](./trait.Query.html).
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>>;
 
-    /// Returns an [`Explanation`] for the given document.
+    /// Returns an `Explanation` for the given document.
     fn explain(&self, reader: &SegmentReader, doc: DocId) -> crate::Result<Explanation>;
 
-    /// Returns the number documents within the given [`SegmentReader`].
+    /// Returns the number documents within the given `SegmentReader`.
     fn count(&self, reader: &SegmentReader) -> crate::Result<u32> {
         let mut scorer = self.scorer(reader, 1.0)?;
         if let Some(alive_bitset) = reader.alive_bitset() {
@@ -81,7 +81,7 @@ pub trait Weight: Send + Sync + 'static {
     /// Calls `callback` with all of the `(doc, score)` for which score
     /// is exceeding a given threshold.
     ///
-    /// This method is useful for the [`TopDocs`](crate::collector::TopDocs) collector.
+    /// This method is useful for the TopDocs collector.
     /// For all docsets, the blanket implementation has the benefit
     /// of prefiltering (doc, score) pairs, avoiding the
     /// virtual dispatch cost.

src/reader/mod.rs

@@ -23,7 +23,7 @@ pub enum ReloadPolicy {
     /// The index is entirely reloaded manually.
     /// All updates of the index should be manual.
     ///
-    /// No change is reflected automatically. You are required to call [`IndexReader::reload()`]
+    /// No change is reflected automatically. You are required to call `IndexReader::reload()`
     /// manually.
     Manual,
     /// The index is reloaded within milliseconds after a new commit is available.
@@ -31,11 +31,11 @@ pub enum ReloadPolicy {
     OnCommit, // TODO add NEAR_REAL_TIME(target_ms)
 }
 
-/// [`IndexReader`] builder
+/// [IndexReader] builder
 ///
 /// It makes it possible to configure:
-/// - [`ReloadPolicy`] defining when new index versions are detected
+/// - [ReloadPolicy] defining when new index versions are detected
-/// - [`Warmer`] implementations
+/// - [Warmer] implementations
 /// - number of warming threads, for parallelizing warming work
 /// - The cache size of the underlying doc store readers.
 #[derive(Clone)]
@@ -108,7 +108,7 @@ impl IndexReaderBuilder {
 
     /// Sets the reload_policy.
     ///
-    /// See [`ReloadPolicy`] for more details.
+    /// See [`ReloadPolicy`](./enum.ReloadPolicy.html) for more details.
     #[must_use]
     pub fn reload_policy(mut self, reload_policy: ReloadPolicy) -> IndexReaderBuilder {
         self.reload_policy = reload_policy;
@@ -124,7 +124,7 @@ impl IndexReaderBuilder {
         self
     }
 
-    /// Set the [`Warmer`]s that are invoked when reloading searchable segments.
+    /// Set the [Warmer]s that are invoked when reloading searchable segments.
     #[must_use]
     pub fn warmers(mut self, warmers: Vec<Weak<dyn Warmer>>) -> IndexReaderBuilder {
         self.warmers = warmers;
@@ -133,8 +133,8 @@ impl IndexReaderBuilder {
 
     /// Sets the number of warming threads.
     ///
-    /// This allows parallelizing warming work when there are multiple [`Warmer`] registered with
+    /// This allows parallelizing warming work when there are multiple [Warmer] registered with the
-    /// the [`IndexReader`].
+    /// [IndexReader].
     #[must_use]
     pub fn num_warming_threads(mut self, num_warming_threads: usize) -> IndexReaderBuilder {
         self.num_warming_threads = num_warming_threads;
@@ -186,7 +186,7 @@ impl InnerIndexReader {
             searcher_generation_inventory,
         })
     }
-    /// Opens the freshest segments [`SegmentReader`].
+    /// Opens the freshest segments `SegmentReader`.
     ///
     /// This function acquires a lot to prevent GC from removing files
     /// as we are opening our index.
@@ -264,7 +264,7 @@ impl InnerIndexReader {
 /// you instances of `Searcher` for the last loaded version.
 ///
 /// `Clone` does not clone the different pool of searcher. `IndexReader`
-/// just wraps an `Arc`.
+/// just wraps and `Arc`.
 #[derive(Clone)]
 pub struct IndexReader {
     inner: Arc<InnerIndexReader>,
@@ -280,7 +280,7 @@ impl IndexReader {
     /// Update searchers so that they reflect the state of the last
     /// `.commit()`.
     ///
-    /// If you set up the [`ReloadPolicy::OnCommit`] (which is the default)
+    /// If you set up the `OnCommit` `ReloadPolicy` (which is the default)
     /// every commit should be rapidly reflected on your `IndexReader` and you should
     /// not need to call `reload()` at all.
     ///

src/reader/warming.rs

@@ -10,12 +10,12 @@ pub const GC_INTERVAL: Duration = Duration::from_secs(1);
 
 /// `Warmer` can be used to maintain segment-level state e.g. caches.
 ///
-/// They must be registered with the [`IndexReaderBuilder`](super::IndexReaderBuilder).
+/// They must be registered with the [super::IndexReaderBuilder].
 pub trait Warmer: Sync + Send {
-    /// Perform any warming work using the provided [`Searcher`].
+    /// Perform any warming work using the provided [Searcher].
     fn warm(&self, searcher: &Searcher) -> crate::Result<()>;
 
-    /// Discards internal state for any [`SearcherGeneration`] not provided.
+    /// Discards internal state for any [SearcherGeneration] not provided.
     fn garbage_collect(&self, live_generations: &[&SearcherGeneration]);
 }
 
@@ -38,11 +38,11 @@ impl WarmingState {
         }))))
     }
 
-    /// Start tracking a new generation of [`Searcher`], and [`Warmer::warm`] it if there are active
+    /// Start tracking a new generation of [Searcher], and [Warmer::warm] it if there are active
     /// warmers.
     ///
-    /// A background GC thread for [`Warmer::garbage_collect`] calls is uniquely created if there
+    /// A background GC thread for [Warmer::garbage_collect] calls is uniquely created if there are
-    /// are active warmers.
+    /// active warmers.
     pub fn warm_new_searcher_generation(&self, searcher: &Searcher) -> crate::Result<()> {
         self.0
             .lock()
@@ -90,7 +90,7 @@ impl WarmingStateInner {
         Ok(())
     }
 
-    /// Attempt to upgrade the weak `Warmer` references, pruning those which cannot be upgraded.
+    /// Attempt to upgrade the weak Warmer references, pruning those which cannot be upgraded.
     /// Return the strong references.
     fn pruned_warmers(&mut self) -> Vec<Arc<dyn Warmer>> {
         let strong_warmers = self
@@ -102,7 +102,7 @@ impl WarmingStateInner {
         strong_warmers
     }
 
-    /// [`Warmer::garbage_collect`] active warmers if some searcher generation is observed to have
+    /// [Warmer::garbage_collect] active warmers if some searcher generation is observed to have
     /// been dropped.
     fn gc_maybe(&mut self) -> bool {
         let live_generations = self.searcher_generation_inventory.list();
@@ -144,8 +144,8 @@ impl WarmingStateInner {
         Ok(true)
     }
 
-    /// Every [`GC_INTERVAL`] attempt to GC, with panics caught and logged using
+    /// Every [GC_INTERVAL] attempt to GC, with panics caught and logged using
-    /// [`std::panic::catch_unwind`].
+    /// [std::panic::catch_unwind].
     fn gc_loop(inner: Weak<Mutex<WarmingStateInner>>) {
         for _ in crossbeam_channel::tick(GC_INTERVAL) {
             if let Some(inner) = inner.upgrade() {