Fixing compile

Fixing unit tests.
Fixing gcd
stats isolation

Cargo.toml

@@ -61,7 +61,6 @@ tantivy-query-grammar = { version= "0.19.0", path="./query-grammar" }
 tantivy-bitpacker = 		{ version= "0.3", path="./bitpacker" }
 columnar = 		{ version= "0.1", path="./columnar", package="tantivy-columnar" }
 common = 								{ version= "0.5", path = "./common/", package = "tantivy-common" }
-fastfield_codecs = 			{ version= "0.3", path="./fastfield_codecs", default-features = false }
 tokenizer-api = { version="0.1", path="./tokenizer-api", package="tantivy-tokenizer-api" }
 
 [target.'cfg(windows)'.dependencies]
@@ -108,7 +107,7 @@ unstable = [] # useful for benches.
 quickwit = ["sstable"]
 
 [workspace]
-members = ["query-grammar", "bitpacker", "common", "fastfield_codecs", "ownedbytes", "stacker", "sstable", "tokenizer-api", "columnar"]
+members = ["query-grammar", "bitpacker", "common", "ownedbytes", "stacker", "sstable", "tokenizer-api", "columnar"]
 
 # Following the "fail" crate best practises, we isolate
 # tests that define specific behavior in fail check points

bitpacker/src/bitpacker.rs

@@ -19,7 +19,7 @@ impl BitPacker {
     }
 
     #[inline]
-    pub fn write<TWrite: io::Write>(
+    pub fn write<TWrite: io::Write + ?Sized>(
         &mut self,
         val: u64,
         num_bits: u8,
@@ -43,7 +43,7 @@ impl BitPacker {
         Ok(())
     }
 
-    pub fn flush<TWrite: io::Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
+    pub fn flush<TWrite: io::Write + ?Sized>(&mut self, output: &mut TWrite) -> io::Result<()> {
         if self.mini_buffer_written > 0 {
             let num_bytes = (self.mini_buffer_written + 7) / 8;
             let bytes = self.mini_buffer.to_le_bytes();
@@ -54,7 +54,7 @@ impl BitPacker {
         Ok(())
     }
 
-    pub fn close<TWrite: io::Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
+    pub fn close<TWrite: io::Write + ?Sized>(&mut self, output: &mut TWrite) -> io::Result<()> {
         self.flush(output)?;
         Ok(())
     }

columnar/benches/bench.rs

@@ -1,311 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-
-#[cfg(test)]
-mod tests {
-    use std::ops::RangeInclusive;
-    use std::sync::Arc;
-
-    use common::OwnedBytes;
-    use rand::prelude::*;
-    use tantivy_columnar::*;
-    use test::Bencher;
-
-    use super::*;
-
-    // Warning: this generates the same permutation at each call
-    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]));
-        permutation
-    }
-
-    // Warning: this generates the same permutation at each call
-    fn generate_permutation_gcd() -> Vec<u64> {
-        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 u32);
-            }
-            a
-        });
-    }
-
-    const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
-    const SINGLE_ITEM: u64 = 90;
-    const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
-    const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
-    fn get_data_50percent_item() -> Vec<u128> {
-        let mut rng = StdRng::from_seed([1u8; 32]);
-
-        let mut data = vec![];
-        for _ in 0..300_000 {
-            let val = rng.gen_range(1..=100);
-            data.push(val);
-        }
-        data.push(SINGLE_ITEM);
-
-        data.shuffle(&mut rng);
-        let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
-        data
-    }
-    fn get_u128_column_random() -> Arc<dyn Column<u128>> {
-        let permutation = generate_random();
-        let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
-        get_u128_column_from_data(&permutation)
-    }
-
-    fn get_u128_column_from_data(data: &[u128]) -> Arc<dyn Column<u128>> {
-        let mut out = vec![];
-        let iter_gen = || data.iter().cloned();
-        serialize_u128(iter_gen, data.len() as u32, &mut out).unwrap();
-        let out = OwnedBytes::new(out);
-        open_u128::<u128>(out).unwrap()
-    }
-
-    // U64 RANGE START
-    #[bench]
-    fn bench_intfastfield_getrange_u64_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                FIFTY_PERCENT_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_1percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                ONE_PERCENT_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                SINGLE_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(0..=u64::MAX, 0..data.len() as u32, &mut positions);
-            positions
-        });
-    }
-    // U64 RANGE END
-
-    // U128 RANGE START
-    #[bench]
-    fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                *SINGLE_ITEM_RANGE.start() as u128..=*SINGLE_ITEM_RANGE.end() as u128,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(0..=u128::MAX, 0..data.len() as u32, &mut positions);
-            positions
-        });
-    }
-    // U128 RANGE END
-
-    #[bench]
-    fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {
-        let column = get_u128_column_random();
-
-        b.iter(|| {
-            let mut a = 0u128;
-            for i in 0u64..column.num_vals() as u64 {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_jumpy_stride5_u128(b: &mut Bencher) {
-        let column = get_u128_column_random();
-
-        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);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        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) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0;
-            for i in (0..n / 7).map(|val| val * 7) {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_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 i in 0u32..n as u32 {
-                a += column.get_val(i);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_fflookup_gcd(b: &mut Bencher) {
-        let permutation = generate_permutation_gcd();
-        let n = permutation.len();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0..n {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0..permutation.len() {
-                a += permutation[i as usize] as u64;
-            }
-            a
-        });
-    }
-}

columnar/benches/bench_u128.rs

@@ -0,0 +1,129 @@
+#![feature(test)]
+
+use std::ops::RangeInclusive;
+use std::sync::Arc;
+
+use common::OwnedBytes;
+use rand::rngs::StdRng;
+use rand::seq::SliceRandom;
+use rand::{random, Rng, SeedableRng};
+use tantivy_columnar::ColumnValues;
+use test::Bencher;
+extern crate test;
+
+// TODO does this make sense for IPv6 ?
+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]));
+    permutation
+}
+
+fn get_u128_column_random() -> Arc<dyn ColumnValues<u128>> {
+    let permutation = generate_random();
+    let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
+    get_u128_column_from_data(&permutation)
+}
+
+fn get_u128_column_from_data(data: &[u128]) -> Arc<dyn ColumnValues<u128>> {
+    let mut out = vec![];
+    tantivy_columnar::column_values::serialize_column_values_u128(
+        &(|| data.iter().copied()),
+        data.len() as u32,
+        &mut out,
+    )
+    .unwrap();
+    let out = OwnedBytes::new(out);
+    tantivy_columnar::column_values::open_u128_mapped::<u128>(out).unwrap()
+}
+
+const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
+const SINGLE_ITEM: u64 = 90;
+const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
+const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
+fn get_data_50percent_item() -> Vec<u128> {
+    let mut rng = StdRng::from_seed([1u8; 32]);
+
+    let mut data = vec![];
+    for _ in 0..300_000 {
+        let val = rng.gen_range(1..=100);
+        data.push(val);
+    }
+    data.push(SINGLE_ITEM);
+    data.shuffle(&mut rng);
+    let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
+    data
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let column = get_u128_column_from_data(&data);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(
+            *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let column = get_u128_column_from_data(&data);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(
+            *SINGLE_ITEM_RANGE.start() as u128..=*SINGLE_ITEM_RANGE.end() as u128,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let column = get_u128_column_from_data(&data);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(0..=u128::MAX, 0..data.len() as u32, &mut positions);
+        positions
+    });
+}
+// U128 RANGE END
+
+#[bench]
+fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {
+    let column = get_u128_column_random();
+
+    b.iter(|| {
+        let mut a = 0u128;
+        for i in 0u64..column.num_vals() as u64 {
+            a += column.get_val(i as u32);
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_jumpy_stride5_u128(b: &mut Bencher) {
+    let column = get_u128_column_random();
+
+    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);
+        }
+        a
+    });
+}

columnar/benches/bench_u64.rs

@@ -0,0 +1,213 @@
+#![feature(test)]
+extern crate test;
+
+use std::ops::RangeInclusive;
+use std::sync::Arc;
+
+use rand::prelude::*;
+use tantivy_columnar::column_values::{
+    serialize_and_load_u64_based_column_values, CodecType, ALL_U64_CODEC_TYPES,
+};
+use tantivy_columnar::*;
+use test::Bencher;
+
+// Warning: this generates the same permutation at each call
+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]));
+    permutation
+}
+
+// Warning: this generates the same permutation at each call
+fn generate_permutation_gcd() -> Vec<u64> {
+    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(column: &[u64], codec_type: CodecType) -> Arc<dyn ColumnValues<u64>> {
+    serialize_and_load_u64_based_column_values(&column, &[codec_type])
+}
+
+#[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_bitpacked(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut a = 0u64;
+        for _ in 0..n {
+            a = column.get_val(a as u32);
+        }
+        a
+    });
+}
+
+const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
+const SINGLE_ITEM: u64 = 90;
+const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
+const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
+fn get_data_50percent_item() -> Vec<u128> {
+    let mut rng = StdRng::from_seed([1u8; 32]);
+
+    let mut data = vec![];
+    for _ in 0..300_000 {
+        let val = rng.gen_range(1..=100);
+        data.push(val);
+    }
+    data.push(SINGLE_ITEM);
+
+    data.shuffle(&mut rng);
+    let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
+    data
+}
+
+// U64 RANGE START
+#[bench]
+fn bench_intfastfield_getrange_u64_50percent_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(
+            FIFTY_PERCENT_RANGE,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u64_1percent_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(
+            ONE_PERCENT_ITEM_RANGE,
+            0..data.len() as u32,
+            &mut positions,
+        );
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u64_single_hit(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(SINGLE_ITEM_RANGE, 0..data.len() as u32, &mut positions);
+        positions
+    });
+}
+
+#[bench]
+fn bench_intfastfield_getrange_u64_hit_all(b: &mut Bencher) {
+    let data = get_data_50percent_item();
+    let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&data, CodecType::Bitpacked);
+
+    b.iter(|| {
+        let mut positions = Vec::new();
+        column.get_docids_for_value_range(0..=u64::MAX, 0..data.len() as u32, &mut positions);
+        positions
+    });
+}
+// U64 RANGE END
+
+#[bench]
+fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    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) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut a = 0;
+        for i in (0..n / 7).map(|val| val * 7) {
+            a += column.get_val(i as u32);
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_scan_all_fflookup(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    let column_ref = column.as_ref();
+    b.iter(|| {
+        let mut a = 0u64;
+        for i in 0u32..n as u32 {
+            a += column.get_val(i);
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_scan_all_fflookup_gcd(b: &mut Bencher) {
+    let permutation = generate_permutation_gcd();
+    let n = permutation.len();
+    let column: Arc<dyn ColumnValues<u64>> = serialize_and_load(&permutation, CodecType::Bitpacked);
+    b.iter(|| {
+        let mut a = 0u64;
+        for i in 0..n {
+            a += column.get_val(i as u32);
+        }
+        a
+    });
+}
+
+#[bench]
+fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
+    let permutation = generate_permutation();
+    b.iter(|| {
+        let mut a = 0u64;
+        for i in 0..permutation.len() {
+            a += permutation[i as usize] as u64;
+        }
+        a
+    });
+}

columnar/src/TODO.md

@@ -1,17 +1,12 @@
 # zero to one
-* merges
-* full still needs a num_values
-* replug u128
-* add dictionary encoded stuff
-* fix multivalued
-* find a way to make columnar work with strict types
-* plug to tantivy
-    - indexing
-    - aggregations
-    - merge
-* replug facets
-* replug range queries
-+ mutlivaued range queries restrat frm the beginning all of the time.
+* merges with non trivial mapping (deletes / sort)
+* emission of the sort mapping.
++ muttivaued range queries restrat frm the beginning all of the time.
+* revisit line codec
+* removal of all rows of a column in the schema due to deletes
+* Plugging JSON
+replug examples
+
 
 # Perf and Size
 * re-add ZSTD compression for dictionaries
@@ -19,7 +14,6 @@ no systematic monotonic mapping
 consider removing multilinear
 f32?
 adhoc solution for bool?
-
 add metrics helper for aggregate. sum(row_id)
 review inline absence/presence
 improv perf of select using PDEP
@@ -29,7 +23,6 @@ Add alignment?
 Consider another codec to bridge the gap between few and 5k elements
 
 # Cleanup and rationalization
-remove the 6 bit limitation of columntype. use 4 + 4 bits instead.
 in benchmark, unify percent vs ratio, f32 vs f64.
 investigate if should have better errors? io::Error is overused at the moment.
 rename rank/select in unit tests
@@ -40,16 +33,13 @@ use the rank & select naming in unit tests branch.
 multi-linear -> blockwise
 linear codec -> simply a multiplication for the index column
 rename columnar to something more explicit, like column_dictionary or columnar_table
-remove old column from the fast field API.
-remove the Column traits alias.
 rename fastfield -> column
 document changes
 rationalization FastFieldValue, HasColumnType
-
+isolate u128_based and uniform naming
 
 # Other
 fix enhance column-cli
 
 # Santa claus
-
 autodetect datetime ipaddr, plug customizable tokenizer.

columnar/src/column/dictionary_encoded.rs

@@ -62,12 +62,24 @@ impl From<BytesColumn> for StrColumn {
     }
 }
 
+impl From<StrColumn> for BytesColumn {
+    fn from(str_column: StrColumn) -> BytesColumn {
+        str_column.0
+    }
+}
+
 impl StrColumn {
+    pub fn dictionary(&self) -> &Dictionary<VoidSSTable> {
+        self.0.dictionary.as_ref()
+    }
+
     /// Fills the buffer
     pub fn ord_to_str(&self, term_ord: u64, output: &mut String) -> io::Result<bool> {
         unsafe {
             let buf = output.as_mut_vec();
-            self.0.dictionary.ord_to_term(term_ord, buf)?;
+            if !self.0.dictionary.ord_to_term(term_ord, buf)? {
+                return Ok(false);
+            }
             // TODO consider remove checks if it hurts performance.
             if std::str::from_utf8(buf.as_slice()).is_err() {
                 buf.clear();

columnar/src/column/mod.rs

@@ -2,6 +2,7 @@ mod dictionary_encoded;
 mod serialize;
 
 use std::fmt::Debug;
+use std::io::Write;
 use std::ops::Deref;
 use std::sync::Arc;
 
@@ -13,16 +14,33 @@ pub use serialize::{
 };
 
 use crate::column_index::ColumnIndex;
-use crate::column_values::ColumnValues;
-use crate::{Cardinality, RowId};
+use crate::column_values::monotonic_mapping::StrictlyMonotonicMappingToInternal;
+use crate::column_values::{monotonic_map_column, ColumnValues};
+use crate::{Cardinality, MonotonicallyMappableToU64, RowId};
 
 #[derive(Clone)]
-pub struct Column<T> {
+pub struct Column<T = u64> {
     pub idx: ColumnIndex,
     pub values: Arc<dyn ColumnValues<T>>,
 }
 
+impl<T: MonotonicallyMappableToU64> Column<T> {
+    pub fn to_u64_monotonic(self) -> Column<u64> {
+        let values = Arc::new(monotonic_map_column(
+            self.values,
+            StrictlyMonotonicMappingToInternal::<T>::new(),
+        ));
+        Column {
+            idx: self.idx,
+            values,
+        }
+    }
+}
+
 impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
+    pub fn get_cardinality(&self) -> Cardinality {
+        self.idx.get_cardinality()
+    }
     pub fn num_rows(&self) -> RowId {
         match &self.idx {
             ColumnIndex::Full => self.values.num_vals() as u32,
@@ -69,7 +87,7 @@ impl<T> Deref for Column<T> {
 }
 
 impl BinarySerializable for Cardinality {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> std::io::Result<()> {
         self.to_code().serialize(writer)
     }
 

columnar/src/column/serialize.rs

@@ -9,43 +9,31 @@ use sstable::Dictionary;
 use crate::column::{BytesColumn, Column};
 use crate::column_index::{serialize_column_index, SerializableColumnIndex};
 use crate::column_values::serialize::serialize_column_values_u128;
-use crate::column_values::{
-    serialize_column_values, ColumnValues, FastFieldCodecType, MonotonicallyMappableToU128,
-    MonotonicallyMappableToU64,
-};
+use crate::column_values::u64_based::{serialize_u64_based_column_values, CodecType};
+use crate::column_values::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
+use crate::iterable::Iterable;
 
-pub fn serialize_column_mappable_to_u128<
-    F: Fn() -> I,
-    I: Iterator<Item = T>,
-    T: MonotonicallyMappableToU128,
->(
+pub fn serialize_column_mappable_to_u128<T: MonotonicallyMappableToU128>(
     column_index: SerializableColumnIndex<'_>,
-    column_values: F,
+    iterable: &dyn Iterable<T>,
     num_vals: u32,
     output: &mut impl Write,
 ) -> io::Result<()> {
     let column_index_num_bytes = serialize_column_index(column_index, output)?;
-    serialize_column_values_u128(
-        || column_values().map(|val| val.to_u128()),
-        num_vals,
-        output,
-    )?;
+    serialize_column_values_u128(iterable, num_vals, output)?;
     output.write_all(&column_index_num_bytes.to_le_bytes())?;
     Ok(())
 }
 
 pub fn serialize_column_mappable_to_u64<T: MonotonicallyMappableToU64 + Debug>(
     column_index: SerializableColumnIndex<'_>,
-    column_values: &impl ColumnValues<T>,
+    column_values: &impl Iterable<T>,
     output: &mut impl Write,
 ) -> io::Result<()> {
     let column_index_num_bytes = serialize_column_index(column_index, output)?;
-    serialize_column_values(
+    serialize_u64_based_column_values(
         column_values,
-        &[
-            FastFieldCodecType::Bitpacked,
-            FastFieldCodecType::BlockwiseLinear,
-        ],
+        &[CodecType::Bitpacked, CodecType::BlockwiseLinear],
         output,
     )?;
     output.write_all(&column_index_num_bytes.to_le_bytes())?;
@@ -62,7 +50,8 @@ pub fn open_column_u64<T: MonotonicallyMappableToU64>(bytes: OwnedBytes) -> io::
     );
     let (column_index_data, column_values_data) = body.split(column_index_num_bytes as usize);
     let column_index = crate::column_index::open_column_index(column_index_data)?;
-    let column_values = crate::column_values::open_u64_mapped(column_values_data)?;
+    let column_values =
+        crate::column_values::u64_based::load_u64_based_column_values(column_values_data)?;
     Ok(Column {
         idx: column_index,
         values: column_values,

columnar/src/column_index/merge.rs

@@ -0,0 +1,171 @@
+use std::iter;
+
+use crate::column_index::{
+    multivalued_index, serialize_column_index, SerializableColumnIndex, Set,
+};
+use crate::iterable::Iterable;
+use crate::{Cardinality, ColumnIndex, MergeRowOrder, RowId, StackMergeOrder};
+
+fn detect_cardinality(columns: &[Option<ColumnIndex>]) -> Cardinality {
+    columns
+        .iter()
+        .flatten()
+        .map(ColumnIndex::get_cardinality)
+        .max()
+        .unwrap_or(Cardinality::Full)
+}
+
+pub fn stack_column_index<'a>(
+    columns: &'a [Option<ColumnIndex>],
+    merge_row_order: &'a MergeRowOrder,
+) -> SerializableColumnIndex<'a> {
+    let MergeRowOrder::Stack(stack_merge_order) = merge_row_order else {
+        panic!("only supporting stacking at the moment.");
+    };
+    let cardinality = detect_cardinality(columns);
+    match cardinality {
+        Cardinality::Full => SerializableColumnIndex::Full,
+        Cardinality::Optional => SerializableColumnIndex::Optional {
+            non_null_row_ids: Box::new(StackedOptionalIndex {
+                columns,
+                stack_merge_order,
+            }),
+            num_rows: stack_merge_order.num_rows(),
+        },
+        Cardinality::Multivalued => {
+            let stacked_multivalued_index = StackedMultivaluedIndex {
+                columns,
+                stack_merge_order,
+            };
+            SerializableColumnIndex::Multivalued(Box::new(stacked_multivalued_index))
+        }
+    }
+}
+
+struct StackedOptionalIndex<'a> {
+    columns: &'a [Option<ColumnIndex>],
+    stack_merge_order: &'a StackMergeOrder,
+}
+
+impl<'a> Iterable<RowId> for StackedOptionalIndex<'a> {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = RowId> + 'a> {
+        Box::new(
+            self.columns
+                .iter()
+                .enumerate()
+                .flat_map(|(columnar_id, column_index_opt)| {
+                    let columnar_row_range = self.stack_merge_order.columnar_range(columnar_id);
+                    let rows_it: Box<dyn Iterator<Item = RowId>> = match column_index_opt {
+                        Some(ColumnIndex::Full) => Box::new(columnar_row_range),
+                        Some(ColumnIndex::Optional(optional_index)) => Box::new(
+                            optional_index
+                                .iter_rows()
+                                .map(move |row_id: RowId| row_id + columnar_row_range.start),
+                        ),
+                        Some(ColumnIndex::Multivalued(_)) => {
+                            panic!("No multivalued index is allowed when stacking column index");
+                        }
+                        None => Box::new(std::iter::empty()),
+                    };
+                    rows_it
+                }),
+        )
+    }
+}
+
+#[derive(Clone, Copy)]
+struct StackedMultivaluedIndex<'a> {
+    columns: &'a [Option<ColumnIndex>],
+    stack_merge_order: &'a StackMergeOrder,
+}
+
+fn convert_column_opt_to_multivalued_index<'a>(
+    column_index_opt: Option<&'a ColumnIndex>,
+    num_rows: RowId,
+) -> Box<dyn Iterator<Item = RowId> + 'a> {
+    match column_index_opt {
+        None => Box::new(iter::repeat(0u32).take(num_rows as usize + 1)),
+        Some(ColumnIndex::Full) => Box::new(0..num_rows + 1),
+        Some(ColumnIndex::Optional(optional_index)) => {
+            Box::new(
+                (0..num_rows)
+                    // TODO optimize
+                    .map(|row_id| optional_index.rank(row_id))
+                    .chain(std::iter::once(optional_index.num_non_nulls())),
+            )
+        }
+        Some(ColumnIndex::Multivalued(multivalued_index)) => {
+            multivalued_index.start_index_column.iter()
+        }
+    }
+}
+
+impl<'a> Iterable<RowId> for StackedMultivaluedIndex<'a> {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = RowId> + '_> {
+        let multivalued_indexes =
+            self.columns
+                .iter()
+                .map(Option::as_ref)
+                .enumerate()
+                .map(|(columnar_id, column_opt)| {
+                    let num_rows =
+                        self.stack_merge_order.columnar_range(columnar_id).len() as RowId;
+                    convert_column_opt_to_multivalued_index(column_opt, num_rows)
+                });
+        stack_multivalued_indexes(multivalued_indexes)
+    }
+}
+
+// Refactor me
+fn stack_multivalued_indexes<'a>(
+    mut multivalued_indexes: impl Iterator<Item = Box<dyn Iterator<Item = RowId> + 'a>> + 'a,
+) -> Box<dyn Iterator<Item = RowId> + 'a> {
+    let mut offset = 0;
+    let mut last_row_id = 0;
+    let mut current_it = multivalued_indexes.next();
+    Box::new(std::iter::from_fn(move || loop {
+        let Some(multivalued_index) = current_it.as_mut() else {
+            return None;
+        };
+        if let Some(row_id) = multivalued_index.next() {
+            last_row_id = offset + row_id;
+            return Some(last_row_id);
+        }
+        offset = last_row_id;
+        loop {
+            current_it = multivalued_indexes.next();
+            if current_it.as_mut()?.next().is_some() {
+                break;
+            }
+        }
+    }))
+}
+
+fn stack_multivalued_index<'a>(
+    columns: &'a [Option<ColumnIndex>],
+    stack_merge_order: &StackMergeOrder,
+) -> Box<dyn Iterable<RowId> + 'a> {
+    todo!()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::RowId;
+
+    fn it<'a>(row_ids: &'a [RowId]) -> Box<dyn Iterator<Item = RowId> + 'a> {
+        Box::new(row_ids.iter().copied())
+    }
+
+    #[test]
+    fn test_stack() {
+        let columns = [
+            it(&[0u32, 0u32]),
+            it(&[0u32, 1u32, 1u32, 4u32]),
+            it(&[0u32, 3u32, 5u32]),
+            it(&[0u32, 4u32]),
+        ]
+        .into_iter();
+        let start_offsets: Vec<RowId> = super::stack_multivalued_indexes(columns).collect();
+        assert_eq!(start_offsets, &[0, 0, 1, 1, 4, 7, 9, 13]);
+    }
+}

columnar/src/column_index/mod.rs

@@ -1,10 +1,12 @@
+mod merge;
 mod multivalued_index;
 mod optional_index;
 mod serialize;
 
 use std::ops::Range;
 
-pub use optional_index::{OptionalIndex, SerializableOptionalIndex, Set};
+pub use merge::stack_column_index;
+pub use optional_index::{OptionalIndex, Set};
 pub use serialize::{open_column_index, serialize_column_index, SerializableColumnIndex};
 
 use crate::column_index::multivalued_index::MultiValueIndex;

columnar/src/column_index/multivalued_index.rs

@@ -5,16 +5,18 @@ use std::sync::Arc;
 
 use common::OwnedBytes;
 
-use crate::column_values::{ColumnValues, FastFieldCodecType};
+use crate::column_values::u64_based::CodecType;
+use crate::column_values::ColumnValues;
+use crate::iterable::Iterable;
 use crate::RowId;
 
 pub fn serialize_multivalued_index(
-    multivalued_index: &dyn ColumnValues<RowId>,
+    multivalued_index: &dyn Iterable<RowId>,
     output: &mut impl Write,
 ) -> io::Result<()> {
-    crate::column_values::serialize_column_values(
-        &*multivalued_index,
-        &[FastFieldCodecType::Bitpacked, FastFieldCodecType::Linear],
+    crate::column_values::u64_based::serialize_u64_based_column_values(
+        multivalued_index,
+        &[CodecType::Bitpacked, CodecType::Linear],
         output,
     )?;
     Ok(())
@@ -22,7 +24,7 @@ pub fn serialize_multivalued_index(
 
 pub fn open_multivalued_index(bytes: OwnedBytes) -> io::Result<MultiValueIndex> {
     let start_index_column: Arc<dyn ColumnValues<RowId>> =
-        crate::column_values::open_u64_mapped(bytes)?;
+        crate::column_values::u64_based::load_u64_based_column_values(bytes)?;
     Ok(MultiValueIndex { start_index_column })
 }
 
@@ -30,7 +32,7 @@ pub fn open_multivalued_index(bytes: OwnedBytes) -> io::Result<MultiValueIndex>
 /// Index to resolve value range for given doc_id.
 /// Starts at 0.
 pub struct MultiValueIndex {
-    start_index_column: Arc<dyn crate::ColumnValues<RowId>>,
+    pub start_index_column: Arc<dyn crate::ColumnValues<RowId>>,
 }
 
 impl From<Arc<dyn ColumnValues<RowId>>> for MultiValueIndex {

columnar/src/column_index/optional_index/mod.rs

@@ -1,5 +1,4 @@
 use std::io::{self, Write};
-use std::ops::Range;
 use std::sync::Arc;
 
 mod set;
@@ -11,6 +10,7 @@ use set_block::{
     DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec, DENSE_BLOCK_NUM_BYTES,
 };
 
+use crate::iterable::Iterable;
 use crate::{InvalidData, RowId};
 
 /// The threshold for for number of elements after which we switch to dense block encoding.
@@ -96,6 +96,12 @@ impl OptionalIndex {
     pub fn num_non_nulls(&self) -> RowId {
         self.num_non_null_rows
     }
+
+    pub fn iter_rows<'a>(&'a self) -> impl Iterator<Item = RowId> + 'a {
+        // TODO optimize
+        let mut select_batch = self.select_cursor();
+        (0..self.num_non_null_rows).map(move |rank| select_batch.select(rank))
+    }
 }
 
 /// Splits a value address into lower and upper 16bits.
@@ -186,6 +192,21 @@ impl Set<RowId> for OptionalIndex {
         }
     }
 
+    #[inline]
+    fn rank(&self, row_id: RowId) -> RowId {
+        let RowAddr {
+            block_id,
+            in_block_row_id,
+        } = row_addr_from_row_id(row_id);
+        let block_meta = self.block_metas[block_id as usize];
+        let block = self.block(block_meta);
+        let block_offset_row_id = match block {
+            Block::Dense(dense_block) => dense_block.rank(in_block_row_id),
+            Block::Sparse(sparse_block) => sparse_block.rank(in_block_row_id),
+        } as u32;
+        block_meta.non_null_rows_before_block + block_offset_row_id
+    }
+
     #[inline]
     fn rank_if_exists(&self, row_id: RowId) -> Option<RowId> {
         let RowAddr {
@@ -300,7 +321,7 @@ impl OptionalIndexCodec {
 }
 
 impl BinarySerializable for OptionalIndexCodec {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_all(&[self.to_code()])
     }
 
@@ -322,12 +343,13 @@ fn serialize_optional_index_block(block_els: &[u16], out: &mut impl io::Write) -
 }
 
 pub fn serialize_optional_index<'a, W: io::Write>(
-    serializable_optional_index: &dyn SerializableOptionalIndex<'a>,
+    non_null_rows: &dyn Iterable<RowId>,
+    num_rows: RowId,
     output: &mut W,
 ) -> io::Result<()> {
-    VInt(serializable_optional_index.num_rows() as u64).serialize(output)?;
+    VInt(num_rows as u64).serialize(output)?;
 
-    let mut rows_it = serializable_optional_index.non_null_rows();
+    let mut rows_it = non_null_rows.boxed_iter();
     let mut block_metadata: Vec<SerializedBlockMeta> = Vec::new();
     let mut current_block = Vec::new();
 
@@ -480,19 +502,5 @@ pub fn open_optional_index(bytes: OwnedBytes) -> io::Result<OptionalIndex> {
     Ok(optional_index)
 }
 
-pub trait SerializableOptionalIndex<'a> {
-    fn num_rows(&self) -> RowId;
-    fn non_null_rows(&self) -> Box<dyn Iterator<Item = RowId> + 'a>;
-}
-
-impl SerializableOptionalIndex<'static> for Range<u32> {
-    fn num_rows(&self) -> RowId {
-        self.end
-    }
-    fn non_null_rows(&self) -> Box<dyn Iterator<Item = RowId> + 'static> {
-        Box::new(self.clone())
-    }
-}
-
 #[cfg(test)]
 mod tests;

columnar/src/column_index/optional_index/set.rs

@@ -28,7 +28,10 @@ pub trait Set<T> {
     /// Returns true if the elements is contained in the Set
     fn contains(&self, el: T) -> bool;
 
-    /// If the set contains `el` returns its position in the sortd set of elements.
+    /// Returns the number of rows in the set that are < `el`
+    fn rank(&self, el: T) -> T;
+
+    /// If the set contains `el` returns the element rank.
     /// If the set does not contain the element, it returns `None`.
     fn rank_if_exists(&self, el: T) -> Option<T>;
 

columnar/src/column_index/optional_index/set_block/dense.rs

@@ -148,6 +148,15 @@ impl<'a> Set<u16> for DenseBlock<'a> {
         }
     }
 
+    #[inline(always)]
+    fn rank(&self, el: u16) -> u16 {
+        let block_pos = el / ELEMENTS_PER_MINI_BLOCK;
+        let index_block = self.mini_block(block_pos);
+        let pos_in_block_bit_vec = el % ELEMENTS_PER_MINI_BLOCK;
+        let ones_in_block = rank_u64(index_block.bitvec, pos_in_block_bit_vec);
+        index_block.rank + ones_in_block
+    }
+
     #[inline(always)]
     fn select(&self, rank: u16) -> u16 {
         let block_id = self.find_miniblock_containing_rank(rank, 0).unwrap();

columnar/src/column_index/optional_index/set_block/sparse.rs

@@ -44,6 +44,11 @@ impl<'a> Set<u16> for SparseBlock<'a> {
         self.binary_search(el).ok()
     }
 
+    #[inline(always)]
+    fn rank(&self, el: u16) -> u16 {
+        self.binary_search(el).unwrap_or_else(|el| el)
+    }
+
     #[inline(always)]
     fn select(&self, rank: u16) -> u16 {
         let offset = rank as usize * 2;

columnar/src/column_index/optional_index/set_block/tests.rs

@@ -17,6 +17,10 @@ fn test_set_helper<C: SetCodec<Item = u16>>(vals: &[u16]) -> usize {
     for val in 0u16..=u16::MAX {
         assert_eq!(tested_set.contains(val), hash_set.contains_key(&val));
         assert_eq!(tested_set.rank_if_exists(val), hash_set.get(&val).copied());
+        assert_eq!(
+            tested_set.rank(val),
+            vals.iter().cloned().take_while(|v| *v < val).count() as u16
+        );
     }
     for rank in 0..vals.len() {
         assert_eq!(tested_set.select(rank as u16), vals[rank]);

columnar/src/column_index/optional_index/tests.rs

@@ -37,7 +37,7 @@ proptest! {
 fn test_with_random_sets_simple() {
     let vals = 10..BLOCK_SIZE * 2;
     let mut out: Vec<u8> = Vec::new();
-    serialize_optional_index(&vals.clone(), &mut out).unwrap();
+    serialize_optional_index(&vals.clone(), 100, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     let ranks: Vec<u32> = (65_472u32..65_473u32).collect();
     let els: Vec<u32> = ranks.iter().copied().map(|rank| rank + 10).collect();
@@ -66,12 +66,8 @@ fn test_optional_index_one_block_true() {
     test_null_index(&iter[..]);
 }
 
-impl<'a> SerializableOptionalIndex<'a> for &'a [bool] {
-    fn num_rows(&self) -> RowId {
-        self.len() as u32
-    }
-
-    fn non_null_rows(&self) -> Box<dyn Iterator<Item = RowId> + 'a> {
+impl<'a> Iterable<RowId> for &'a [bool] {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = RowId> + 'a> {
         Box::new(
             self.iter()
                 .cloned()
@@ -84,7 +80,7 @@ impl<'a> SerializableOptionalIndex<'a> for &'a [bool] {
 
 fn test_null_index(data: &[bool]) {
     let mut out: Vec<u8> = Vec::new();
-    serialize_optional_index(&data, &mut out).unwrap();
+    serialize_optional_index(&data, data.len() as RowId, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     let orig_idx_with_value: Vec<u32> = data
         .iter()
@@ -113,7 +109,7 @@ fn test_null_index(data: &[bool]) {
 fn test_optional_index_test_translation() {
     let mut out = vec![];
     let iter = &[true, false, true, false];
-    serialize_optional_index(&&iter[..], &mut out).unwrap();
+    serialize_optional_index(&&iter[..], iter.len() as u32, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     let mut select_cursor = null_index.select_cursor();
     assert_eq!(select_cursor.select(0), 0);
@@ -124,7 +120,7 @@ fn test_optional_index_test_translation() {
 fn test_optional_index_translate() {
     let mut out = vec![];
     let iter = &[true, false, true, false];
-    serialize_optional_index(&&iter[..], &mut out).unwrap();
+    serialize_optional_index(&&iter[..], iter.len() as RowId, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     assert_eq!(null_index.rank_if_exists(0), Some(0));
     assert_eq!(null_index.rank_if_exists(2), Some(1));
@@ -134,7 +130,7 @@ fn test_optional_index_translate() {
 fn test_optional_index_small() {
     let mut out = vec![];
     let iter = &[true, false, true, false];
-    serialize_optional_index(&&iter[..], &mut out).unwrap();
+    serialize_optional_index(&&iter[..], iter.len() as RowId, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     assert!(null_index.contains(0));
     assert!(!null_index.contains(1));
@@ -149,7 +145,7 @@ fn test_optional_index_large() {
     docs.extend((0..=1).map(|_idx| true));
 
     let mut out = vec![];
-    serialize_optional_index(&&docs[..], &mut out).unwrap();
+    serialize_optional_index(&&docs[..], docs.len() as RowId, &mut out).unwrap();
     let null_index = open_optional_index(OwnedBytes::new(out)).unwrap();
     assert!(!null_index.contains(0));
     assert!(!null_index.contains(100));
@@ -158,6 +154,59 @@ fn test_optional_index_large() {
     assert!(null_index.contains(ELEMENTS_PER_BLOCK + 1));
 }
 
+fn test_optional_index_iter_aux(row_ids: &[RowId], num_rows: RowId) {
+    let mut buffer: Vec<u8> = Vec::new();
+    serialize_optional_index(&row_ids, num_rows, &mut buffer).unwrap();
+    let null_index = open_optional_index(OwnedBytes::new(buffer)).unwrap();
+    assert_eq!(null_index.num_rows(), num_rows);
+    assert!(null_index.iter_rows().eq(row_ids.iter().copied()));
+}
+
+#[test]
+fn test_optional_index_iter_empty() {
+    test_optional_index_iter_aux(&[], 0u32);
+}
+
+fn test_optional_index_rank_aux(row_ids: &[RowId]) {
+    let mut buffer: Vec<u8> = Vec::new();
+    let num_rows = row_ids.last().copied().unwrap_or(0u32) + 1;
+    serialize_optional_index(&row_ids, num_rows, &mut buffer).unwrap();
+    let null_index = open_optional_index(OwnedBytes::new(buffer)).unwrap();
+    assert_eq!(null_index.num_rows(), num_rows);
+    for (row_id, row_val) in row_ids.iter().copied().enumerate() {
+        assert_eq!(null_index.rank(row_val), row_id as u32);
+        assert_eq!(null_index.rank_if_exists(row_val), Some(row_id as u32));
+        if row_val > 0 && !null_index.contains(&row_val - 1) {
+            assert_eq!(null_index.rank(row_val - 1), row_id as u32);
+        }
+        assert_eq!(null_index.rank(row_val + 1), row_id as u32 + 1);
+    }
+}
+
+#[test]
+fn test_optional_index_rank() {
+    test_optional_index_rank_aux(&[1u32]);
+    test_optional_index_rank_aux(&[0u32, 1u32]);
+    let mut block = Vec::new();
+    block.push(3u32);
+    block.extend((0..BLOCK_SIZE).map(|i| i + BLOCK_SIZE + 1));
+    test_optional_index_rank_aux(&block);
+}
+
+#[test]
+fn test_optional_index_iter_empty_one() {
+    test_optional_index_iter_aux(&[1], 2u32);
+    test_optional_index_iter_aux(&[100_000], 200_000u32);
+}
+
+#[test]
+fn test_optional_index_iter_dense_block() {
+    let mut block = Vec::new();
+    block.push(3u32);
+    block.extend((0..BLOCK_SIZE).map(|i| i + BLOCK_SIZE + 1));
+    test_optional_index_iter_aux(&block, 3 * BLOCK_SIZE);
+}
+
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
 

columnar/src/column_index/serialize.rs

@@ -5,23 +5,26 @@ use common::{CountingWriter, OwnedBytes};
 
 use crate::column_index::multivalued_index::serialize_multivalued_index;
 use crate::column_index::optional_index::serialize_optional_index;
-use crate::column_index::{ColumnIndex, SerializableOptionalIndex};
-use crate::column_values::ColumnValues;
+use crate::column_index::ColumnIndex;
+use crate::iterable::Iterable;
 use crate::{Cardinality, RowId};
 
 pub enum SerializableColumnIndex<'a> {
     Full,
-    Optional(Box<dyn SerializableOptionalIndex<'a> + 'a>),
+    Optional {
+        non_null_row_ids: Box<dyn Iterable<RowId> + 'a>,
+        num_rows: RowId,
+    },
     // TODO remove the Arc<dyn> apart from serialization this is not
     // dynamic at all.
-    Multivalued(Box<dyn ColumnValues<RowId> + 'a>),
+    Multivalued(Box<dyn Iterable<RowId> + 'a>),
 }
 
 impl<'a> SerializableColumnIndex<'a> {
     pub fn get_cardinality(&self) -> Cardinality {
         match self {
             SerializableColumnIndex::Full => Cardinality::Full,
-            SerializableColumnIndex::Optional(_) => Cardinality::Optional,
+            SerializableColumnIndex::Optional { .. } => Cardinality::Optional,
             SerializableColumnIndex::Multivalued(_) => Cardinality::Multivalued,
         }
     }
@@ -36,9 +39,10 @@ pub fn serialize_column_index(
     output.write_all(&[cardinality])?;
     match column_index {
         SerializableColumnIndex::Full => {}
-        SerializableColumnIndex::Optional(optional_index) => {
-            serialize_optional_index(&*optional_index, &mut output)?
-        }
+        SerializableColumnIndex::Optional {
+            non_null_row_ids,
+            num_rows,
+        } => serialize_optional_index(non_null_row_ids.as_ref(), num_rows, &mut output)?,
         SerializableColumnIndex::Multivalued(multivalued_index) => {
             serialize_multivalued_index(&*multivalued_index, &mut output)?
         }

columnar/src/column_values/bitpacked.rs

@@ -1,115 +0,0 @@
-use std::io::{self, Write};
-
-use common::OwnedBytes;
-use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
-
-use super::serialize::NormalizedHeader;
-use super::{ColumnValues, FastFieldCodec, FastFieldCodecType};
-
-/// Depending on the field type, a different
-/// fast field is required.
-#[derive(Clone)]
-pub struct BitpackedReader {
-    data: OwnedBytes,
-    bit_unpacker: BitUnpacker,
-    normalized_header: NormalizedHeader,
-}
-
-impl ColumnValues for BitpackedReader {
-    #[inline]
-    fn get_val(&self, doc: u32) -> u64 {
-        self.bit_unpacker.get(doc, &self.data)
-    }
-    #[inline]
-    fn min_value(&self) -> u64 {
-        // The BitpackedReader assumes a normalized vector.
-        0
-    }
-    #[inline]
-    fn max_value(&self) -> u64 {
-        self.normalized_header.max_value
-    }
-    #[inline]
-    fn num_vals(&self) -> u32 {
-        self.normalized_header.num_vals
-    }
-}
-
-pub struct BitpackedCodec;
-
-impl FastFieldCodec for BitpackedCodec {
-    /// The CODEC_TYPE is an enum value used for serialization.
-    const CODEC_TYPE: FastFieldCodecType = FastFieldCodecType::Bitpacked;
-
-    type Reader = BitpackedReader;
-
-    /// Opens a fast field given a file.
-    fn open_from_bytes(
-        data: OwnedBytes,
-        normalized_header: NormalizedHeader,
-    ) -> io::Result<Self::Reader> {
-        let num_bits = compute_num_bits(normalized_header.max_value);
-        let bit_unpacker = BitUnpacker::new(num_bits);
-        Ok(BitpackedReader {
-            data,
-            bit_unpacker,
-            normalized_header,
-        })
-    }
-
-    /// Serializes data with the BitpackedFastFieldSerializer.
-    ///
-    /// The bitpacker assumes that the column has been normalized.
-    /// i.e. It has already been shifted by its minimum value, so that its
-    /// current minimum value is 0.
-    ///
-    /// Ideally, we made a shift upstream on the column so that `col.min_value() == 0`.
-    fn serialize(column: &dyn ColumnValues, write: &mut impl Write) -> io::Result<()> {
-        assert_eq!(column.min_value(), 0u64);
-        let num_bits = compute_num_bits(column.max_value());
-        let mut bit_packer = BitPacker::new();
-        for val in column.iter() {
-            bit_packer.write(val, num_bits, write)?;
-        }
-        bit_packer.close(write)?;
-        Ok(())
-    }
-
-    fn estimate(column: &dyn ColumnValues) -> Option<f32> {
-        let num_bits = compute_num_bits(column.max_value());
-        let num_bits_uncompressed = 64;
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::column_values::tests::create_and_validate;
-
-    fn create_and_validate_bitpacked_codec(data: &[u64], name: &str) {
-        create_and_validate::<BitpackedCodec>(data, name);
-    }
-
-    #[test]
-    fn test_with_codec_data_sets() {
-        let data_sets = crate::column_values::tests::get_codec_test_datasets();
-        for (mut data, name) in data_sets {
-            create_and_validate_bitpacked_codec(&data, name);
-            data.reverse();
-            create_and_validate::<BitpackedCodec>(&data, name);
-        }
-    }
-
-    #[test]
-    fn bitpacked_fast_field_rand() {
-        for _ in 0..500 {
-            let mut data = (0..1 + rand::random::<u8>() as usize)
-                .map(|_| rand::random::<i64>() as u64 / 2)
-                .collect::<Vec<_>>();
-            create_and_validate_bitpacked_codec(&data, "rand");
-            data.reverse();
-            create_and_validate::<BitpackedCodec>(&data, "rand");
-        }
-    }
-}

columnar/src/column_values/blockwise_linear.rs

@@ -1,188 +0,0 @@
-use std::sync::Arc;
-use std::{io, iter};
-
-use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
-use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
-
-use crate::column_values::line::Line;
-use crate::column_values::serialize::NormalizedHeader;
-use crate::column_values::{ColumnValues, FastFieldCodec, FastFieldCodecType, VecColumn};
-
-const CHUNK_SIZE: usize = 512;
-
-#[derive(Debug, Default)]
-struct Block {
-    line: Line,
-    bit_unpacker: BitUnpacker,
-    data_start_offset: usize,
-}
-
-impl BinarySerializable for Block {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        self.line.serialize(writer)?;
-        self.bit_unpacker.bit_width().serialize(writer)?;
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let line = Line::deserialize(reader)?;
-        let bit_width = u8::deserialize(reader)?;
-        Ok(Block {
-            line,
-            bit_unpacker: BitUnpacker::new(bit_width),
-            data_start_offset: 0,
-        })
-    }
-}
-
-fn compute_num_blocks(num_vals: u32) -> usize {
-    (num_vals as usize + CHUNK_SIZE - 1) / CHUNK_SIZE
-}
-
-pub struct BlockwiseLinearCodec;
-
-impl FastFieldCodec for BlockwiseLinearCodec {
-    const CODEC_TYPE: FastFieldCodecType = FastFieldCodecType::BlockwiseLinear;
-    type Reader = BlockwiseLinearReader;
-
-    fn open_from_bytes(
-        bytes: common::OwnedBytes,
-        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 mut blocks: Vec<Block> = iter::repeat_with(|| Block::deserialize(&mut 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
-    fn estimate(column: &dyn ColumnValues) -> Option<f32> {
-        if column.num_vals() < 10 * CHUNK_SIZE as u32 {
-            return None;
-        }
-        let mut first_chunk: Vec<u64> = column.iter().take(CHUNK_SIZE).collect();
-        let line = Line::train(&VecColumn::from(&first_chunk));
-        for (i, buffer_val) in first_chunk.iter_mut().enumerate() {
-            let interpolated_val = line.eval(i as u32);
-            *buffer_val = buffer_val.wrapping_sub(interpolated_val);
-        }
-        let estimated_bit_width = first_chunk
-            .iter()
-            .map(|el| ((el + 1) as f32 * 3.0) as u64)
-            .map(compute_num_bits)
-            .max()
-            .unwrap();
-
-        let metadata_per_block = {
-            let mut out = vec![];
-            Block::default().serialize(&mut out).unwrap();
-            out.len()
-        };
-        let num_bits = estimated_bit_width as u64 * column.num_vals() as u64
-            // function metadata per block
-            + metadata_per_block as u64 * (column.num_vals() as u64 / CHUNK_SIZE as u64);
-        let num_bits_uncompressed = 64 * column.num_vals();
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
-    }
-
-    fn serialize(column: &dyn ColumnValues, wrt: &mut impl io::Write) -> io::Result<()> {
-        // The BitpackedReader assumes a normalized vector.
-        assert_eq!(column.min_value(), 0);
-        let mut buffer = Vec::with_capacity(CHUNK_SIZE);
-        let num_vals = column.num_vals();
-
-        let num_blocks = compute_num_blocks(num_vals);
-        let mut blocks = Vec::with_capacity(num_blocks);
-
-        let mut vals = column.iter();
-
-        let mut bit_packer = BitPacker::new();
-
-        for _ in 0..num_blocks {
-            buffer.clear();
-            buffer.extend((&mut vals).take(CHUNK_SIZE));
-            let line = Line::train(&VecColumn::from(&buffer));
-
-            assert!(!buffer.is_empty());
-
-            for (i, buffer_val) in buffer.iter_mut().enumerate() {
-                let interpolated_val = line.eval(i as u32);
-                *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,
-            });
-        }
-
-        bit_packer.close(wrt)?;
-
-        assert_eq!(blocks.len(), compute_num_blocks(num_vals));
-
-        let mut counting_wrt = CountingWriter::wrap(wrt);
-        for block in &blocks {
-            block.serialize(&mut counting_wrt)?;
-        }
-        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 ColumnValues for BlockwiseLinearReader {
-    #[inline(always)]
-    fn get_val(&self, idx: u32) -> u64 {
-        let block_id = (idx / CHUNK_SIZE as u32) as usize;
-        let idx_within_block = idx % (CHUNK_SIZE as u32);
-        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)
-    }
-
-    #[inline(always)]
-    fn min_value(&self) -> u64 {
-        // The BlockwiseLinearReader assumes a normalized vector.
-        0u64
-    }
-
-    #[inline(always)]
-    fn max_value(&self) -> u64 {
-        self.normalized_header.max_value
-    }
-
-    #[inline(always)]
-    fn num_vals(&self) -> u32 {
-        self.normalized_header.num_vals
-    }
-}

columnar/src/column_values/column.rs

@@ -1,15 +1,17 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Range, RangeInclusive};
+use std::sync::Arc;
 
 use tantivy_bitpacker::minmax;
 
 use crate::column_values::monotonic_mapping::StrictlyMonotonicFn;
+use crate::iterable::Iterable;
 
 /// `ColumnValues` provides access to a dense field column.
 ///
 /// `Column` are just a wrapper over `ColumnValues` and a `ColumnIndex`.
-pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
+pub trait ColumnValues<T: PartialOrd = u64>: Send + Sync {
     /// Return the value associated with the given idx.
     ///
     /// This accessor should return as fast as possible.
@@ -27,7 +29,7 @@ pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
     ///
     /// Must panic if `start + output.len()` is greater than
     /// the segment's `maxdoc`.
-    #[inline]
+    #[inline(always)]
     fn get_range(&self, start: u64, output: &mut [T]) {
         for (out, idx) in output.iter_mut().zip(start..) {
             *out = self.get_val(idx as u32);
@@ -37,7 +39,7 @@ pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
     /// Get the positions of values which are in the provided value range.
     ///
     /// Note that position == docid for single value fast fields
-    #[inline]
+    #[inline(always)]
     fn get_docids_for_value_range(
         &self,
         value_range: RangeInclusive<T>,
@@ -78,27 +80,39 @@ pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
     }
 }
 
-impl<T: Copy + PartialOrd + Debug> ColumnValues<T> for std::sync::Arc<dyn ColumnValues<T>> {
+impl<'a, T: PartialOrd> Iterable<T> for &'a [Arc<dyn ColumnValues<T>>] {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = T> + '_> {
+        Box::new(self.iter().flat_map(|column_value| column_value.iter()))
+    }
+}
+
+impl<T: Copy + PartialOrd + Debug> ColumnValues<T> for Arc<dyn ColumnValues<T>> {
+    #[inline(always)]
     fn get_val(&self, idx: u32) -> T {
         self.as_ref().get_val(idx)
     }
 
+    #[inline(always)]
     fn min_value(&self) -> T {
         self.as_ref().min_value()
     }
 
+    #[inline(always)]
     fn max_value(&self) -> T {
         self.as_ref().max_value()
     }
 
+    #[inline(always)]
     fn num_vals(&self) -> u32 {
         self.as_ref().num_vals()
     }
 
+    #[inline(always)]
     fn iter<'b>(&'b self) -> Box<dyn Iterator<Item = T> + 'b> {
         self.as_ref().iter()
     }
 
+    #[inline(always)]
     fn get_range(&self, start: u64, output: &mut [T]) {
         self.as_ref().get_range(start, output)
     }

columnar/src/column_values/compact_space/mod.rs

@@ -55,7 +55,7 @@ impl RangeMapping {
 }
 
 impl BinarySerializable for CompactSpace {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         VInt(self.ranges_mapping.len() as u64).serialize(writer)?;
 
         let mut prev_value = 0;
@@ -247,7 +247,7 @@ pub struct CompactSpaceDecompressor {
 }
 
 impl BinarySerializable for IPCodecParams {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         // header flags for future optional dictionary encoding
         let footer_flags = 0u64;
         footer_flags.serialize(writer)?;

columnar/src/column_values/gcd.rs

@@ -1,75 +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::num::NonZeroU64;
-
-    use crate::column_values::gcd::{compute_gcd, find_gcd};
-
-    #[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);
-    }
-}

columnar/src/column_values/linear.rs

@@ -1,230 +0,0 @@
-use std::io::{self, Write};
-
-use common::{BinarySerializable, OwnedBytes};
-use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
-
-use super::line::Line;
-use super::serialize::NormalizedHeader;
-use super::{ColumnValues, FastFieldCodec, FastFieldCodecType};
-
-/// Depending on the field type, a different
-/// fast field is required.
-#[derive(Clone)]
-pub struct LinearReader {
-    data: OwnedBytes,
-    linear_params: LinearParams,
-    header: NormalizedHeader,
-}
-
-impl ColumnValues for LinearReader {
-    #[inline]
-    fn get_val(&self, doc: u32) -> u64 {
-        let interpoled_val: u64 = self.linear_params.line.eval(doc);
-        let bitpacked_diff = self.linear_params.bit_unpacker.get(doc, &self.data);
-        interpoled_val.wrapping_add(bitpacked_diff)
-    }
-
-    #[inline(always)]
-    fn min_value(&self) -> u64 {
-        // The LinearReader assumes a normalized vector.
-        0u64
-    }
-
-    #[inline(always)]
-    fn max_value(&self) -> u64 {
-        self.header.max_value
-    }
-
-    #[inline]
-    fn num_vals(&self) -> u32 {
-        self.header.num_vals
-    }
-}
-
-/// Fastfield serializer, which tries to guess values by linear interpolation
-/// and stores the difference bitpacked.
-pub struct LinearCodec;
-
-#[derive(Debug, Clone)]
-struct LinearParams {
-    line: Line,
-    bit_unpacker: BitUnpacker,
-}
-
-impl BinarySerializable for LinearParams {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        self.line.serialize(writer)?;
-        self.bit_unpacker.bit_width().serialize(writer)?;
-        Ok(())
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let line = Line::deserialize(reader)?;
-        let bit_width = u8::deserialize(reader)?;
-        Ok(Self {
-            line,
-            bit_unpacker: BitUnpacker::new(bit_width),
-        })
-    }
-}
-
-impl FastFieldCodec for LinearCodec {
-    const CODEC_TYPE: FastFieldCodecType = FastFieldCodecType::Linear;
-
-    type Reader = LinearReader;
-
-    /// Opens a fast field given a file.
-    fn open_from_bytes(mut data: OwnedBytes, header: NormalizedHeader) -> io::Result<Self::Reader> {
-        let linear_params = LinearParams::deserialize(&mut data)?;
-        Ok(LinearReader {
-            data,
-            linear_params,
-            header,
-        })
-    }
-
-    /// Creates a new fast field serializer.
-    fn serialize(column: &dyn ColumnValues, write: &mut impl Write) -> io::Result<()> {
-        assert_eq!(column.min_value(), 0);
-        let line = Line::train(column);
-
-        let max_offset_from_line = column
-            .iter()
-            .enumerate()
-            .map(|(pos, actual_value)| {
-                let calculated_value = line.eval(pos as u32);
-                actual_value.wrapping_sub(calculated_value)
-            })
-            .max()
-            .unwrap();
-
-        let num_bits = compute_num_bits(max_offset_from_line);
-        let linear_params = LinearParams {
-            line,
-            bit_unpacker: BitUnpacker::new(num_bits),
-        };
-        linear_params.serialize(write)?;
-
-        let mut bit_packer = BitPacker::new();
-        for (pos, actual_value) in column.iter().enumerate() {
-            let calculated_value = line.eval(pos as u32);
-            let offset = actual_value.wrapping_sub(calculated_value);
-            bit_packer.write(offset, num_bits, write)?;
-        }
-        bit_packer.close(write)?;
-
-        Ok(())
-    }
-
-    /// 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(column: &dyn ColumnValues) -> Option<f32> {
-        if column.num_vals() < 3 {
-            return None; // disable compressor for this case
-        }
-
-        let limit_num_vals = column.num_vals().min(100_000);
-
-        let num_samples = 100;
-        let step_size = (limit_num_vals / num_samples).max(1); // 20 samples
-        let mut sample_positions_and_values: Vec<_> = Vec::new();
-        for (pos, val) in column.iter().enumerate().step_by(step_size as usize) {
-            sample_positions_and_values.push((pos as u64, val));
-        }
-
-        let line = Line::estimate(&sample_positions_and_values);
-
-        let estimated_bit_width = sample_positions_and_values
-            .into_iter()
-            .map(|(pos, actual_value)| {
-                let interpolated_val = line.eval(pos as u32);
-                actual_value.wrapping_sub(interpolated_val)
-            })
-            .map(|diff| ((diff as f32 * 1.5) * 2.0) as u64)
-            .map(compute_num_bits)
-            .max()
-            .unwrap_or(0);
-
-        // Extrapolate to whole column
-        let num_bits = (estimated_bit_width as u64 * column.num_vals() as u64) + 64;
-        let num_bits_uncompressed = 64 * column.num_vals();
-        Some(num_bits as f32 / num_bits_uncompressed as f32)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rand::RngCore;
-
-    use super::*;
-    use crate::column_values::tests;
-
-    fn create_and_validate(data: &[u64], name: &str) -> Option<(f32, f32)> {
-        tests::create_and_validate::<LinearCodec>(data, name)
-    }
-
-    #[test]
-    fn test_compression() {
-        let data = (10..=6_000_u64).collect::<Vec<_>>();
-        let (estimate, actual_compression) =
-            create_and_validate(&data, "simple monotonically large").unwrap();
-
-        assert_le!(actual_compression, 0.001);
-        assert_le!(estimate, 0.02);
-    }
-
-    #[test]
-    fn test_with_codec_datasets() {
-        let data_sets = tests::get_codec_test_datasets();
-        for (mut data, name) in data_sets {
-            create_and_validate(&data, name);
-            data.reverse();
-            create_and_validate(&data, name);
-        }
-    }
-    #[test]
-    fn linear_interpol_fast_field_test_large_amplitude() {
-        let data = vec![
-            i64::MAX as u64 / 2,
-            i64::MAX as u64 / 3,
-            i64::MAX as u64 / 2,
-        ];
-
-        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];
-        create_and_validate(&data, "concave data");
-    }
-    #[test]
-    fn linear_interpol_fast_convex_data() {
-        let data = vec![0, 40, 60, 70, 75, 77];
-        create_and_validate(&data, "convex data");
-    }
-    #[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..50 {
-            let mut data = (0..10_000).map(|_| rng.next_u64()).collect::<Vec<_>>();
-            create_and_validate(&data, "random");
-            data.reverse();
-            create_and_validate(&data, "random");
-        }
-    }
-}

columnar/src/column_values/mod.rs

@@ -7,9 +7,6 @@
 //! - Encode data in different codecs.
 //! - Monotonically map values to u64/u128
 
-#[cfg(test)]
-mod tests;
-
 use std::fmt::Debug;
 use std::io;
 use std::io::Write;
@@ -18,75 +15,27 @@ use std::sync::Arc;
 use common::{BinarySerializable, OwnedBytes};
 use compact_space::CompactSpaceDecompressor;
 pub use monotonic_mapping::{MonotonicallyMappableToU64, StrictlyMonotonicFn};
-use monotonic_mapping::{
-    StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
-    StrictlyMonotonicMappingToInternalBaseval, StrictlyMonotonicMappingToInternalGCDBaseval,
-};
+use monotonic_mapping::{StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal};
 pub use monotonic_mapping_u128::MonotonicallyMappableToU128;
-use serialize::{Header, U128Header};
+use serialize::U128Header;
 
-mod bitpacked;
-mod blockwise_linear;
 mod compact_space;
-mod line;
-mod linear;
 pub(crate) mod monotonic_mapping;
 pub(crate) mod monotonic_mapping_u128;
+mod stats;
+pub(crate) mod u64_based;
 
 mod column;
-mod gcd;
 pub mod serialize;
 
+pub use serialize::serialize_column_values_u128;
+pub use stats::Stats;
+pub use u64_based::{
+    load_u64_based_column_values, serialize_and_load_u64_based_column_values,
+    serialize_u64_based_column_values, CodecType, ALL_U64_CODEC_TYPES,
+};
+
 pub use self::column::{monotonic_map_column, ColumnValues, IterColumn, VecColumn};
-#[cfg(test)]
-pub use self::serialize::tests::serialize_and_load;
-pub use self::serialize::{serialize_column_values, NormalizedHeader};
-use crate::column_values::bitpacked::BitpackedCodec;
-use crate::column_values::blockwise_linear::BlockwiseLinearCodec;
-use crate::column_values::linear::LinearCodec;
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
-#[repr(u8)]
-/// Available codecs to use to encode the u64 (via [`MonotonicallyMappableToU64`]) converted data.
-pub enum FastFieldCodecType {
-    /// Bitpack all values in the value range. The number of bits is defined by the amplitude
-    /// `column.max_value() - column.min_value()`
-    Bitpacked = 1,
-    /// Linear interpolation puts a line between the first and last value and then bitpacks the
-    /// values by the offset from the line. The number of bits is defined by the max deviation from
-    /// the line.
-    Linear = 2,
-    /// Same as [`FastFieldCodecType::Linear`], but encodes in blocks of 512 elements.
-    BlockwiseLinear = 3,
-}
-
-impl BinarySerializable for FastFieldCodecType {
-    fn serialize<W: Write>(&self, wrt: &mut W) -> io::Result<()> {
-        self.to_code().serialize(wrt)
-    }
-
-    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let code = u8::deserialize(reader)?;
-        let codec_type: Self = Self::from_code(code)
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "Unknown code `{code}.`"))?;
-        Ok(codec_type)
-    }
-}
-
-impl FastFieldCodecType {
-    pub(crate) fn to_code(self) -> u8 {
-        self as u8
-    }
-
-    pub(crate) fn from_code(code: u8) -> Option<Self> {
-        match code {
-            1 => Some(Self::Bitpacked),
-            2 => Some(Self::Linear),
-            3 => Some(Self::BlockwiseLinear),
-            _ => None,
-        }
-    }
-}
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
 #[repr(u8)]
@@ -98,7 +47,7 @@ pub enum U128FastFieldCodecType {
 }
 
 impl BinarySerializable for U128FastFieldCodecType {
-    fn serialize<W: Write>(&self, wrt: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, wrt: &mut W) -> io::Result<()> {
         self.to_code().serialize(wrt)
     }
 
@@ -136,68 +85,6 @@ pub fn open_u128_mapped<T: MonotonicallyMappableToU128 + Debug>(
     Ok(Arc::new(monotonic_map_column(reader, inverted)))
 }
 
-/// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open_u64_mapped<T: MonotonicallyMappableToU64 + Debug>(
-    mut bytes: OwnedBytes,
-) -> io::Result<Arc<dyn ColumnValues<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 + Debug>(
-    bytes: OwnedBytes,
-    header: &Header,
-) -> io::Result<Arc<dyn ColumnValues<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 mapping = StrictlyMonotonicMappingInverter::from(
-            StrictlyMonotonicMappingToInternalGCDBaseval::new(gcd.get(), min_value),
-        );
-        Ok(Arc::new(monotonic_map_column(reader, mapping)))
-    } else {
-        let mapping = StrictlyMonotonicMappingInverter::from(
-            StrictlyMonotonicMappingToInternalBaseval::new(min_value),
-        );
-        Ok(Arc::new(monotonic_map_column(reader, mapping)))
-    }
-}
-
-/// The FastFieldSerializerEstimate trait is required on all variants
-/// of fast field compressions, to decide which one to choose.
-pub(crate) trait FastFieldCodec: 'static {
-    /// A codex needs to provide a unique name and id, which is
-    /// used for debugging and de/serialization.
-    const CODEC_TYPE: FastFieldCodecType;
-
-    type Reader: ColumnValues<u64> + 'static;
-
-    /// Reads the metadata and returns the CodecReader
-    fn open_from_bytes(bytes: OwnedBytes, header: NormalizedHeader) -> 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
-    /// performance reasons.
-    fn serialize(column: &dyn ColumnValues, write: &mut impl Write) -> io::Result<()>;
-
-    /// 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: &dyn ColumnValues) -> Option<f32>;
-}
-
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
     use std::sync::Arc;

columnar/src/column_values/serialize.rs

@@ -1,22 +1,12 @@
 use std::fmt::Debug;
 use std::io;
-use std::num::NonZeroU64;
 
 use common::{BinarySerializable, VInt};
-use log::warn;
 
-use super::bitpacked::BitpackedCodec;
-use super::blockwise_linear::BlockwiseLinearCodec;
-use super::linear::LinearCodec;
-use super::monotonic_mapping::{
-    StrictlyMonotonicFn, StrictlyMonotonicMappingToInternal,
-    StrictlyMonotonicMappingToInternalGCDBaseval,
-};
-use super::{
-    monotonic_map_column, ColumnValues, FastFieldCodec, FastFieldCodecType,
-    MonotonicallyMappableToU64, U128FastFieldCodecType,
-};
 use crate::column_values::compact_space::CompactSpaceCompressor;
+use crate::column_values::U128FastFieldCodecType;
+use crate::iterable::Iterable;
+use crate::MonotonicallyMappableToU128;
 
 /// The normalized header gives some parameters after applying the following
 /// normalization of the vector:
@@ -31,53 +21,6 @@ pub struct NormalizedHeader {
     pub max_value: u64,
 }
 
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct Header {
-    pub num_vals: u32,
-    pub min_value: u64,
-    pub max_value: u64,
-    pub gcd: Option<NonZeroU64>,
-    pub codec_type: FastFieldCodecType,
-}
-
-impl Header {
-    pub fn normalized(self) -> NormalizedHeader {
-        let gcd = self.gcd.map(|gcd| gcd.get()).unwrap_or(1);
-        let gcd_min_val_mapping =
-            StrictlyMonotonicMappingToInternalGCDBaseval::new(gcd, self.min_value);
-
-        let max_value = gcd_min_val_mapping.mapping(self.max_value);
-        NormalizedHeader {
-            num_vals: self.num_vals,
-            max_value,
-        }
-    }
-
-    pub(crate) fn normalize_column<C: ColumnValues>(&self, from_column: C) -> impl ColumnValues {
-        normalize_column(from_column, self.min_value, self.gcd)
-    }
-
-    pub fn compute_header(
-        column: impl ColumnValues<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 = super::gcd::find_gcd(column.iter().map(|val| val - min_value))
-            .filter(|gcd| gcd.get() > 1u64);
-        let normalized_column = normalize_column(column, min_value, gcd);
-        let codec_type = detect_codec(normalized_column, codecs)?;
-        Some(Header {
-            num_vals,
-            min_value,
-            max_value,
-            gcd,
-            codec_type,
-        })
-    }
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) struct U128Header {
     pub num_vals: u32,
@@ -85,7 +28,7 @@ pub(crate) struct U128Header {
 }
 
 impl BinarySerializable for U128Header {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         VInt(self.num_vals as u64).serialize(writer)?;
         self.codec_type.serialize(writer)?;
         Ok(())
@@ -101,50 +44,9 @@ impl BinarySerializable for U128Header {
     }
 }
 
-fn normalize_column<C: ColumnValues>(
-    from_column: C,
-    min_value: u64,
-    gcd: Option<NonZeroU64>,
-) -> impl ColumnValues {
-    let gcd = gcd.map(|gcd| gcd.get()).unwrap_or(1);
-    let mapping = StrictlyMonotonicMappingToInternalGCDBaseval::new(gcd, min_value);
-    monotonic_map_column(from_column, mapping)
-}
-
-impl BinarySerializable for Header {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
-        VInt(self.num_vals as u64).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 as u32;
-        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,
-        })
-    }
-}
-
 /// Serializes u128 values with the compact space codec.
-pub fn serialize_column_values_u128<F: Fn() -> I, I: Iterator<Item = u128>>(
-    iter_gen: F,
+pub fn serialize_column_values_u128<T: MonotonicallyMappableToU128>(
+    iterable: &dyn Iterable<T>,
     num_vals: u32,
     output: &mut impl io::Write,
 ) -> io::Result<()> {
@@ -153,105 +55,30 @@ pub fn serialize_column_values_u128<F: Fn() -> I, I: Iterator<Item = u128>>(
         codec_type: U128FastFieldCodecType::CompactSpace,
     };
     header.serialize(output)?;
-    let compressor = CompactSpaceCompressor::train_from(iter_gen(), num_vals);
-    compressor.compress_into(iter_gen(), output)?;
-
-    Ok(())
-}
-
-/// Serializes the column with the codec with the best estimate on the data.
-pub fn serialize_column_values<T: MonotonicallyMappableToU64 + Debug>(
-    typed_column: impl ColumnValues<T>,
-    codecs: &[FastFieldCodecType],
-    output: &mut impl io::Write,
-) -> io::Result<()> {
-    let column = monotonic_map_column(typed_column, StrictlyMonotonicMappingToInternal::<T>::new());
-    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 ColumnValues<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)
-}
-
-pub(crate) fn serialize_given_codec(
-    column: impl ColumnValues<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)?;
-        }
-    }
+    let compressor = CompactSpaceCompressor::train_from(
+        iterable
+            .boxed_iter()
+            .map(MonotonicallyMappableToU128::to_u128),
+        num_vals,
+    );
+    compressor.compress_into(
+        iterable
+            .boxed_iter()
+            .map(MonotonicallyMappableToU128::to_u128),
+        output,
+    )?;
     Ok(())
 }
 
 #[cfg(test)]
 pub mod tests {
-    use std::sync::Arc;
-
-    use common::OwnedBytes;
-
     use super::*;
-    use crate::column_values::{open_u64_mapped, VecColumn};
+    use crate::column_values::u64_based::{
+        self, serialize_and_load_u64_based_column_values, serialize_u64_based_column_values,
+        ALL_U64_CODEC_TYPES,
+    };
+    use crate::column_values::CodecType;
 
-    const ALL_CODEC_TYPES: [FastFieldCodecType; 3] = [
-        FastFieldCodecType::Bitpacked,
-        FastFieldCodecType::Linear,
-        FastFieldCodecType::BlockwiseLinear,
-    ];
-
-    /// Helper function to serialize a column (autodetect from all codecs) and then open it
-    pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default>(
-        column: &[T],
-    ) -> Arc<dyn ColumnValues<T>> {
-        let mut buffer = Vec::new();
-        serialize_column_values(&VecColumn::from(&column), &ALL_CODEC_TYPES, &mut buffer).unwrap();
-        open_u64_mapped(OwnedBytes::new(buffer)).unwrap()
-    }
     #[test]
     fn test_serialize_deserialize_u128_header() {
         let original = U128Header {
@@ -267,15 +94,22 @@ pub mod tests {
     #[test]
     fn test_serialize_deserialize() {
         let original = [1u64, 5u64, 10u64];
-        let restored: Vec<u64> = serialize_and_load(&original[..]).iter().collect();
+        let restored: Vec<u64> =
+            serialize_and_load_u64_based_column_values(&&original[..], &ALL_U64_CODEC_TYPES)
+                .iter()
+                .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_column_values(&col, &ALL_CODEC_TYPES, &mut buffer).unwrap();
+        serialize_u64_based_column_values::<bool>(
+            &&[false, true][..],
+            &ALL_U64_CODEC_TYPES,
+            &mut buffer,
+        )
+        .unwrap();
         // TODO put the header as a footer so that it serves as a padding.
         // 5 bytes of header, 1 byte of value, 7 bytes of padding.
         assert_eq!(buffer.len(), 5 + 1);
@@ -284,19 +118,23 @@ pub mod tests {
     #[test]
     fn test_fastfield_bool_bit_size_bitwidth_0() {
         let mut buffer = Vec::new();
-        let col = VecColumn::from(&[true][..]);
-        serialize_column_values(&col, &ALL_CODEC_TYPES, &mut buffer).unwrap();
-        // 5 bytes of header, 0 bytes of value, 7 bytes of padding.
-        assert_eq!(buffer.len(), 5);
+        serialize_u64_based_column_values::<bool>(
+            &&[false, true][..],
+            &ALL_U64_CODEC_TYPES,
+            &mut buffer,
+        )
+        .unwrap();
+        // 6 bytes of header, 0 bytes of value, 7 bytes of padding.
+        assert_eq!(buffer.len(), 6);
     }
 
     #[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_column_values(&col, &[FastFieldCodecType::Bitpacked], &mut buffer).unwrap();
+        serialize_u64_based_column_values(&&vals[..], &[CodecType::Bitpacked], &mut buffer)
+            .unwrap();
         // Values are stored over 3 bits.
-        assert_eq!(buffer.len(), 7 + (3 * 80 / 8));
+        assert_eq!(buffer.len(), 6 + (3 * 80 / 8));
     }
 }

columnar/src/column_values/stats.rs

@@ -0,0 +1,96 @@
+use std::io;
+use std::io::Write;
+use std::num::NonZeroU64;
+
+use common::{BinarySerializable, VInt};
+
+use crate::RowId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Stats {
+    pub gcd: NonZeroU64,
+    pub min_value: u64,
+    pub max_value: u64,
+    pub num_rows: RowId,
+}
+
+impl Stats {
+    pub fn amplitude(&self) -> u64 {
+        self.max_value - self.min_value
+    }
+}
+
+impl BinarySerializable for Stats {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
+        VInt(self.min_value).serialize(writer)?;
+        VInt(self.gcd.get()).serialize(writer)?;
+        VInt(self.amplitude() / self.gcd).serialize(writer)?;
+        VInt(self.num_rows as u64).serialize(writer)?;
+        Ok(())
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let min_value = VInt::deserialize(reader)?.0;
+        let gcd = VInt::deserialize(reader)?.0;
+        let gcd = NonZeroU64::new(gcd)
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "GCD of 0 is forbidden"))?;
+        let amplitude = VInt::deserialize(reader)?.0 * gcd.get();
+        let max_value = min_value + amplitude;
+        let num_rows = VInt::deserialize(reader)?.0 as RowId;
+        Ok(Stats {
+            min_value,
+            max_value,
+            num_rows,
+            gcd,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::num::NonZeroU64;
+
+    use common::BinarySerializable;
+
+    use crate::column_values::Stats;
+
+    #[track_caller]
+    fn test_stats_ser_deser_aux(stats: &Stats, num_bytes: usize) {
+        let mut buffer: Vec<u8> = Vec::new();
+        stats.serialize(&mut buffer).unwrap();
+        assert_eq!(buffer.len(), num_bytes);
+        let deser_stats = Stats::deserialize(&mut &buffer[..]).unwrap();
+        assert_eq!(stats, &deser_stats);
+    }
+
+    #[test]
+    fn test_stats_serialization() {
+        test_stats_ser_deser_aux(
+            &(Stats {
+                gcd: NonZeroU64::new(3).unwrap(),
+                min_value: 1,
+                max_value: 3001,
+                num_rows: 10,
+            }),
+            5,
+        );
+        test_stats_ser_deser_aux(
+            &(Stats {
+                gcd: NonZeroU64::new(1_000).unwrap(),
+                min_value: 1,
+                max_value: 3001,
+                num_rows: 10,
+            }),
+            5,
+        );
+        test_stats_ser_deser_aux(
+            &(Stats {
+                gcd: NonZeroU64::new(1).unwrap(),
+                min_value: 0,
+                max_value: 0,
+                num_rows: 0,
+            }),
+            4,
+        );
+    }
+}

columnar/src/column_values/u64_based/bitpacked.rs

@@ -0,0 +1,127 @@
+use std::io::{self, Write};
+
+use common::{BinarySerializable, OwnedBytes};
+use fastdivide::DividerU64;
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, Stats};
+use crate::{ColumnValues, RowId};
+
+/// Depending on the field type, a different
+/// fast field is required.
+#[derive(Clone)]
+pub struct BitpackedReader {
+    data: OwnedBytes,
+    bit_unpacker: BitUnpacker,
+    stats: Stats,
+}
+
+impl ColumnValues for BitpackedReader {
+    #[inline(always)]
+    fn get_val(&self, doc: u32) -> u64 {
+        self.stats.min_value + self.stats.gcd.get() * self.bit_unpacker.get(doc, &self.data)
+    }
+
+    #[inline]
+    fn min_value(&self) -> u64 {
+        self.stats.min_value
+    }
+    #[inline]
+    fn max_value(&self) -> u64 {
+        self.stats.max_value
+    }
+    #[inline]
+    fn num_vals(&self) -> RowId {
+        self.stats.num_rows
+    }
+}
+
+fn num_bits(stats: &Stats) -> u8 {
+    compute_num_bits(stats.amplitude() / stats.gcd)
+}
+
+#[derive(Default)]
+pub struct BitpackedCodecEstimator;
+
+impl ColumnCodecEstimator for BitpackedCodecEstimator {
+    fn collect(&mut self, _value: u64) {}
+
+    fn estimate(&self, stats: &Stats) -> Option<u64> {
+        let num_bits_per_value = num_bits(stats);
+        Some(stats.num_bytes() + (stats.num_rows as u64 * (num_bits_per_value as u64) + 7) / 8)
+    }
+
+    fn serialize(
+        &self,
+        stats: &Stats,
+        vals: &mut dyn Iterator<Item = u64>,
+        wrt: &mut dyn Write,
+    ) -> io::Result<()> {
+        stats.serialize(wrt)?;
+        let num_bits = num_bits(stats);
+        let mut bit_packer = BitPacker::new();
+        let divider = DividerU64::divide_by(stats.gcd.get());
+        for val in vals {
+            bit_packer.write(divider.divide(val - stats.min_value), num_bits, wrt)?;
+        }
+        bit_packer.close(wrt)?;
+        Ok(())
+    }
+}
+
+pub struct BitpackedCodec;
+
+impl ColumnCodec for BitpackedCodec {
+    type Reader = BitpackedReader;
+    type Estimator = BitpackedCodecEstimator;
+
+    /// Opens a fast field given a file.
+    fn load(mut data: OwnedBytes) -> io::Result<Self::Reader> {
+        let stats = Stats::deserialize(&mut data)?;
+        let num_bits = num_bits(&stats);
+        let bit_unpacker = BitUnpacker::new(num_bits);
+        Ok(BitpackedReader {
+            data,
+            bit_unpacker,
+            stats,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::column_values::u64_based::tests::create_and_validate;
+
+    #[test]
+    fn test_with_codec_data_sets_simple() {
+        create_and_validate::<BitpackedCodec>(&[4, 3, 12], "name");
+    }
+
+    #[test]
+    fn test_with_codec_data_sets_simple_gcd() {
+        create_and_validate::<BitpackedCodec>(&[1000, 2000, 3000], "name");
+    }
+
+    #[test]
+    fn test_with_codec_data_sets() {
+        let data_sets = crate::column_values::u64_based::tests::get_codec_test_datasets();
+        for (mut data, name) in data_sets {
+            create_and_validate::<BitpackedCodec>(&data, name);
+            data.reverse();
+            create_and_validate::<BitpackedCodec>(&data, name);
+        }
+    }
+
+    #[test]
+    fn bitpacked_fast_field_rand() {
+        for _ in 0..500 {
+            let mut data = (0..1 + rand::random::<u8>() as usize)
+                .map(|_| rand::random::<i64>() as u64 / 2)
+                .collect::<Vec<_>>();
+            create_and_validate::<BitpackedCodec>(&data, "rand");
+            data.reverse();
+            create_and_validate::<BitpackedCodec>(&data, "rand");
+        }
+    }
+}

columnar/src/column_values/u64_based/blockwise_linear.rs

@@ -0,0 +1,281 @@
+use std::io::Write;
+use std::sync::Arc;
+use std::{io, iter};
+
+use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
+use fastdivide::DividerU64;
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use crate::column_values::u64_based::line::Line;
+use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, Stats};
+use crate::column_values::{ColumnValues, VecColumn};
+use crate::MonotonicallyMappableToU64;
+
+const BLOCK_SIZE: u32 = 512u32;
+
+#[derive(Debug, Default)]
+struct Block {
+    line: Line,
+    bit_unpacker: BitUnpacker,
+    data_start_offset: usize,
+}
+
+impl BinarySerializable for Block {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
+        self.line.serialize(writer)?;
+        self.bit_unpacker.bit_width().serialize(writer)?;
+        Ok(())
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let line = Line::deserialize(reader)?;
+        let bit_width = u8::deserialize(reader)?;
+        Ok(Block {
+            line,
+            bit_unpacker: BitUnpacker::new(bit_width),
+            data_start_offset: 0,
+        })
+    }
+}
+
+fn compute_num_blocks(num_vals: u32) -> u32 {
+    (num_vals + BLOCK_SIZE - 1) / BLOCK_SIZE
+}
+
+pub struct BlockwiseLinearEstimator {
+    block: Vec<u64>,
+    values_num_bytes: u64,
+    meta_num_bytes: u64,
+}
+
+impl Default for BlockwiseLinearEstimator {
+    fn default() -> Self {
+        Self {
+            block: Vec::with_capacity(BLOCK_SIZE as usize),
+            values_num_bytes: 0u64,
+            meta_num_bytes: 0u64,
+        }
+    }
+}
+
+impl BlockwiseLinearEstimator {
+    fn flush_block_estimate(&mut self) {
+        if self.block.is_empty() {
+            return;
+        }
+        let line = Line::train(&VecColumn::from(&self.block));
+        let mut max_value = 0u64;
+        for (i, buffer_val) in self.block.iter().enumerate() {
+            let interpolated_val = line.eval(i as u32);
+            let val = buffer_val.wrapping_sub(interpolated_val);
+            max_value = val.max(max_value);
+        }
+        let bit_width = compute_num_bits(max_value) as usize;
+        self.values_num_bytes += (bit_width * self.block.len() + 7) as u64 / 8;
+        self.meta_num_bytes += 1 + line.num_bytes();
+    }
+}
+
+impl ColumnCodecEstimator for BlockwiseLinearEstimator {
+    fn collect(&mut self, value: u64) {
+        self.block.push(value);
+        if self.block.len() == BLOCK_SIZE as usize {
+            self.flush_block_estimate();
+            self.block.clear();
+        }
+    }
+    fn estimate(&self, stats: &Stats) -> Option<u64> {
+        let mut estimate = 4 + stats.num_bytes() + self.meta_num_bytes + self.values_num_bytes;
+        if stats.gcd.get() > 1 {
+            let estimate_gain_from_gcd =
+                (stats.gcd.get() as f32).log2().floor() * stats.num_rows as f32 / 8.0f32;
+            estimate = estimate.saturating_sub(estimate_gain_from_gcd as u64);
+        }
+        Some(estimate)
+    }
+
+    fn finalize(&mut self) {
+        self.flush_block_estimate();
+    }
+
+    fn serialize(
+        &self,
+        stats: &Stats,
+        mut vals: &mut dyn Iterator<Item = u64>,
+        wrt: &mut dyn Write,
+    ) -> io::Result<()> {
+        stats.serialize(wrt)?;
+        let mut buffer = Vec::with_capacity(BLOCK_SIZE as usize);
+        let num_blocks = compute_num_blocks(stats.num_rows) as usize;
+        let mut blocks = Vec::with_capacity(num_blocks);
+
+        let mut bit_packer = BitPacker::new();
+
+        let gcd_divider = DividerU64::divide_by(stats.gcd.get());
+
+        for _ in 0..num_blocks {
+            buffer.clear();
+            buffer.extend(
+                (&mut vals)
+                    .map(MonotonicallyMappableToU64::to_u64)
+                    .take(BLOCK_SIZE as usize),
+            );
+
+            for buffer_val in buffer.iter_mut() {
+                *buffer_val = gcd_divider.divide(*buffer_val - stats.min_value);
+            }
+
+            let line = Line::train(&VecColumn::from(&buffer));
+
+            assert!(!buffer.is_empty());
+
+            for (i, buffer_val) in buffer.iter_mut().enumerate() {
+                let interpolated_val = line.eval(i as u32);
+                *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,
+            });
+        }
+
+        bit_packer.close(wrt)?;
+
+        assert_eq!(blocks.len(), num_blocks);
+
+        let mut counting_wrt = CountingWriter::wrap(wrt);
+        for block in &blocks {
+            block.serialize(&mut counting_wrt)?;
+        }
+        let footer_len = counting_wrt.written_bytes();
+        (footer_len as u32).serialize(&mut counting_wrt)?;
+
+        Ok(())
+    }
+}
+
+pub struct BlockwiseLinearCodec;
+
+impl ColumnCodec<u64> for BlockwiseLinearCodec {
+    type Reader = BlockwiseLinearReader;
+
+    type Estimator = BlockwiseLinearEstimator;
+
+    fn load(mut bytes: OwnedBytes) -> io::Result<Self::Reader> {
+        let stats = Stats::deserialize(&mut bytes)?;
+        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(stats.num_rows);
+        let mut blocks: Vec<Block> = iter::repeat_with(|| Block::deserialize(&mut footer))
+            .take(num_blocks as usize)
+            .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) * BLOCK_SIZE as usize / 8;
+        }
+        Ok(BlockwiseLinearReader {
+            blocks: blocks.into_boxed_slice().into(),
+            data,
+            stats,
+        })
+    }
+}
+
+#[derive(Clone)]
+pub struct BlockwiseLinearReader {
+    blocks: Arc<[Block]>,
+    data: OwnedBytes,
+    stats: Stats,
+}
+
+impl ColumnValues for BlockwiseLinearReader {
+    #[inline(always)]
+    fn get_val(&self, idx: u32) -> u64 {
+        let block_id = (idx / BLOCK_SIZE as u32) as usize;
+        let idx_within_block = idx % (BLOCK_SIZE as u32);
+        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);
+        // TODO optimize me! the line parameters could be tweaked to include the multiplication and
+        // remove the dependency.
+        self.stats.min_value
+            + self
+                .stats
+                .gcd
+                .get()
+                .wrapping_mul(interpoled_val.wrapping_add(bitpacked_diff))
+    }
+
+    #[inline(always)]
+    fn min_value(&self) -> u64 {
+        self.stats.min_value
+    }
+
+    #[inline(always)]
+    fn max_value(&self) -> u64 {
+        self.stats.max_value
+    }
+
+    #[inline(always)]
+    fn num_vals(&self) -> u32 {
+        self.stats.num_rows
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::column_values::u64_based::tests::create_and_validate;
+
+    #[test]
+    fn test_with_codec_data_sets_simple() {
+        create_and_validate::<BlockwiseLinearCodec>(
+            &[11, 20, 40, 20, 10, 10, 10, 10, 10, 10],
+            "simple test",
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn test_with_codec_data_sets_simple_gcd() {
+        let (_, actual_compression_rate) = create_and_validate::<BlockwiseLinearCodec>(
+            &[10, 20, 40, 20, 10, 10, 10, 10, 10, 10],
+            "name",
+        )
+        .unwrap();
+        assert_eq!(actual_compression_rate, 0.175);
+    }
+
+    #[test]
+    fn test_with_codec_data_sets() {
+        let data_sets = crate::column_values::u64_based::tests::get_codec_test_datasets();
+        for (mut data, name) in data_sets {
+            create_and_validate::<BlockwiseLinearCodec>(&data, name);
+            data.reverse();
+            create_and_validate::<BlockwiseLinearCodec>(&data, name);
+        }
+    }
+
+    #[test]
+    fn test_blockwise_linear_fast_field_rand() {
+        for _ in 0..500 {
+            let mut data = (0..1 + rand::random::<u8>() as usize)
+                .map(|_| rand::random::<i64>() as u64 / 2)
+                .collect::<Vec<_>>();
+            create_and_validate::<BlockwiseLinearCodec>(&data, "rand");
+            data.reverse();
+            create_and_validate::<BlockwiseLinearCodec>(&data, "rand");
+        }
+    }
+}

columnar/src/column_values/u64_based/line.rs

@@ -17,8 +17,8 @@ const MID_POINT: u64 = (1u64 << 32) - 1u64;
 /// `y = m * x >> 32 + b`
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Line {
-    slope: u64,
-    intercept: u64,
+    pub(crate) slope: u64,
+    pub(crate) intercept: u64,
 }
 
 /// Compute the line slope.
@@ -81,7 +81,7 @@ impl Line {
     }
 
     // Intercept is only computed from provided positions
-    fn train_from(
+    pub fn train_from(
         first_val: u64,
         last_val: u64,
         num_vals: u32,
@@ -145,6 +145,7 @@ impl Line {
     ///
     /// This function is only invariable by translation if all of the
     /// `ys` are packaged into half of the space. (See heuristic below)
+    /// TODO USE array
     pub fn train(ys: &dyn ColumnValues) -> Self {
         let first_val = ys.iter().next().unwrap();
         let last_val = ys.iter().nth(ys.num_vals() as usize - 1).unwrap();
@@ -158,7 +159,7 @@ impl Line {
 }
 
 impl BinarySerializable for Line {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         VInt(self.slope).serialize(writer)?;
         VInt(self.intercept).serialize(writer)?;
         Ok(())

columnar/src/column_values/u64_based/linear.rs

@@ -0,0 +1,277 @@
+use std::io;
+
+use common::{BinarySerializable, OwnedBytes};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use super::line::Line;
+use super::ColumnValues;
+use crate::column_values::u64_based::{ColumnCodec, ColumnCodecEstimator, Stats};
+use crate::column_values::VecColumn;
+use crate::{MonotonicallyMappableToU64, RowId};
+
+const HALF_SPACE: u64 = u64::MAX / 2;
+const LINE_ESTIMATION_BLOCK_LEN: usize = 512;
+
+/// Depending on the field type, a different
+/// fast field is required.
+#[derive(Clone)]
+pub struct LinearReader {
+    data: OwnedBytes,
+    linear_params: LinearParams,
+    stats: Stats,
+}
+
+impl ColumnValues for LinearReader {
+    #[inline]
+    fn get_val(&self, doc: u32) -> u64 {
+        let interpoled_val: u64 = self.linear_params.line.eval(doc);
+        let bitpacked_diff = self.linear_params.bit_unpacker.get(doc, &self.data);
+        interpoled_val.wrapping_add(bitpacked_diff)
+    }
+
+    #[inline(always)]
+    fn min_value(&self) -> u64 {
+        self.stats.min_value
+    }
+
+    #[inline(always)]
+    fn max_value(&self) -> u64 {
+        self.stats.max_value
+    }
+
+    #[inline]
+    fn num_vals(&self) -> u32 {
+        self.stats.num_rows
+    }
+}
+
+/// Fastfield serializer, which tries to guess values by linear interpolation
+/// and stores the difference bitpacked.
+pub struct LinearCodec;
+
+#[derive(Debug, Clone)]
+struct LinearParams {
+    line: Line,
+    bit_unpacker: BitUnpacker,
+}
+
+impl BinarySerializable for LinearParams {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
+        self.line.serialize(writer)?;
+        self.bit_unpacker.bit_width().serialize(writer)?;
+        Ok(())
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let line = Line::deserialize(reader)?;
+        let bit_width = u8::deserialize(reader)?;
+        Ok(Self {
+            line,
+            bit_unpacker: BitUnpacker::new(bit_width),
+        })
+    }
+}
+
+pub struct LinearCodecEstimator {
+    block: Vec<u64>,
+    line: Option<Line>,
+    row_id: RowId,
+    min_deviation: u64,
+    max_deviation: u64,
+    first_val: u64,
+    last_val: u64,
+}
+
+impl Default for LinearCodecEstimator {
+    fn default() -> LinearCodecEstimator {
+        LinearCodecEstimator {
+            block: Vec::with_capacity(LINE_ESTIMATION_BLOCK_LEN),
+            line: None,
+            row_id: 0,
+            min_deviation: u64::MAX,
+            max_deviation: u64::MIN,
+            first_val: 0u64,
+            last_val: 0u64,
+        }
+    }
+}
+
+impl ColumnCodecEstimator for LinearCodecEstimator {
+    fn finalize(&mut self) {
+        if let Some(line) = self.line.as_mut() {
+            line.intercept = line
+                .intercept
+                .wrapping_add(self.min_deviation)
+                .wrapping_sub(HALF_SPACE);
+        }
+    }
+
+    fn estimate(&self, stats: &Stats) -> Option<u64> {
+        let line = self.line?;
+        let amplitude = self.max_deviation - self.min_deviation;
+        let num_bits = compute_num_bits(amplitude);
+        let linear_params = LinearParams {
+            line,
+            bit_unpacker: BitUnpacker::new(num_bits),
+        };
+        Some(
+            stats.num_bytes()
+                + linear_params.num_bytes()
+                + (num_bits as u64 * stats.num_rows as u64 + 7) / 8,
+        )
+    }
+
+    fn serialize(
+        &self,
+        stats: &Stats,
+        vals: &mut dyn Iterator<Item = u64>,
+        wrt: &mut dyn io::Write,
+    ) -> io::Result<()> {
+        stats.serialize(wrt)?;
+        let line = self.line.unwrap();
+        let amplitude = self.max_deviation - self.min_deviation;
+        let num_bits = compute_num_bits(amplitude);
+        let linear_params = LinearParams {
+            line,
+            bit_unpacker: BitUnpacker::new(num_bits),
+        };
+        linear_params.serialize(wrt)?;
+        let mut bit_packer = BitPacker::new();
+        for (pos, value) in vals.enumerate() {
+            let calculated_value = line.eval(pos as u32);
+            let offset = value.wrapping_sub(calculated_value);
+            bit_packer.write(offset, num_bits, wrt)?;
+        }
+        bit_packer.close(wrt)?;
+        Ok(())
+    }
+
+    fn collect(&mut self, value: u64) {
+        if let Some(line) = self.line {
+            self.collect_after_line_estimation(&line, value);
+        } else {
+            self.collect_before_line_estimation(value);
+        }
+    }
+}
+
+impl LinearCodecEstimator {
+    #[inline]
+    fn collect_after_line_estimation(&mut self, line: &Line, value: u64) {
+        let interpoled_val: u64 = line.eval(self.row_id);
+        let deviation = value.wrapping_add(HALF_SPACE).wrapping_sub(interpoled_val);
+        self.min_deviation = self.min_deviation.min(deviation);
+        self.max_deviation = self.max_deviation.max(deviation);
+        if self.row_id == 0 {
+            self.first_val = value;
+        }
+        self.last_val = value;
+        self.row_id += 1u32;
+    }
+
+    #[inline]
+    fn collect_before_line_estimation(&mut self, value: u64) {
+        self.block.push(value);
+        if self.block.len() == LINE_ESTIMATION_BLOCK_LEN {
+            let line = Line::train(&VecColumn::from(&self.block));
+            let block = std::mem::take(&mut self.block);
+            for val in block {
+                self.collect_after_line_estimation(&line, val);
+            }
+            self.line = Some(line);
+        }
+    }
+}
+
+impl ColumnCodec for LinearCodec {
+    type Reader = LinearReader;
+
+    type Estimator = LinearCodecEstimator;
+
+    fn load(mut data: OwnedBytes) -> io::Result<Self::Reader> {
+        let stats = Stats::deserialize(&mut data)?;
+        let linear_params = LinearParams::deserialize(&mut data)?;
+        Ok(LinearReader {
+            stats,
+            linear_params,
+            data,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rand::RngCore;
+
+    use super::*;
+    use crate::column_values::u64_based::tests::{create_and_validate, get_codec_test_datasets};
+
+    #[test]
+    fn test_compression_simple() {
+        let vals = (100u64..)
+            .take(super::LINE_ESTIMATION_BLOCK_LEN)
+            .collect::<Vec<_>>();
+        create_and_validate::<LinearCodec>(&vals, "simple monotonically large").unwrap();
+    }
+
+    #[test]
+    fn test_compression() {
+        let data = (10..=6_000_u64).collect::<Vec<_>>();
+        let (estimate, actual_compression) =
+            create_and_validate::<LinearCodec>(&data, "simple monotonically large").unwrap();
+        assert_le!(actual_compression, 0.001);
+        assert_le!(estimate, 0.02);
+    }
+
+    #[test]
+    fn test_with_codec_datasets() {
+        let data_sets = get_codec_test_datasets();
+        for (mut data, name) in data_sets {
+            create_and_validate::<LinearCodec>(&data, name);
+            data.reverse();
+            create_and_validate::<LinearCodec>(&data, name);
+        }
+    }
+    #[test]
+    fn linear_interpol_fast_field_test_large_amplitude() {
+        let data = vec![
+            i64::MAX as u64 / 2,
+            i64::MAX as u64 / 3,
+            i64::MAX as u64 / 2,
+        ];
+        create_and_validate::<LinearCodec>(&data, "large amplitude");
+    }
+
+    #[test]
+    fn overflow_error_test() {
+        let data = vec![1572656989877777, 1170935903116329, 720575940379279, 0];
+        create_and_validate::<LinearCodec>(&data, "overflow test");
+    }
+
+    #[test]
+    fn linear_interpol_fast_concave_data() {
+        let data = vec![0, 1, 2, 5, 8, 10, 20, 50];
+        create_and_validate::<LinearCodec>(&data, "concave data");
+    }
+    #[test]
+    fn linear_interpol_fast_convex_data() {
+        let data = vec![0, 40, 60, 70, 75, 77];
+        create_and_validate::<LinearCodec>(&data, "convex data");
+    }
+    #[test]
+    fn linear_interpol_fast_field_test_simple() {
+        let data = (10..=20_u64).collect::<Vec<_>>();
+        create_and_validate::<LinearCodec>(&data, "simple monotonically");
+    }
+
+    #[test]
+    fn linear_interpol_fast_field_rand() {
+        let mut rng = rand::thread_rng();
+        for _ in 0..50 {
+            let mut data = (0..10_000).map(|_| rng.next_u64()).collect::<Vec<_>>();
+            create_and_validate::<LinearCodec>(&data, "random");
+            data.reverse();
+            create_and_validate::<LinearCodec>(&data, "random");
+        }
+    }
+}

columnar/src/column_values/u64_based/mod.rs

@@ -0,0 +1,182 @@
+mod bitpacked;
+mod blockwise_linear;
+mod line;
+mod linear;
+mod stats_collector;
+
+use std::io;
+use std::io::Write;
+use std::sync::Arc;
+
+use common::{BinarySerializable, OwnedBytes};
+
+use crate::column_values::monotonic_mapping::{
+    StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
+};
+use crate::column_values::u64_based::bitpacked::BitpackedCodec;
+use crate::column_values::u64_based::blockwise_linear::BlockwiseLinearCodec;
+use crate::column_values::u64_based::linear::LinearCodec;
+use crate::column_values::u64_based::stats_collector::StatsCollector;
+use crate::column_values::{monotonic_map_column, Stats};
+use crate::iterable::Iterable;
+use crate::{ColumnValues, MonotonicallyMappableToU64};
+
+pub trait ColumnCodecEstimator<T = u64>: 'static {
+    fn collect(&mut self, value: u64);
+    fn estimate(&self, stats: &Stats) -> Option<u64>;
+    fn finalize(&mut self) {}
+    fn serialize(
+        &self,
+        stats: &Stats,
+        vals: &mut dyn Iterator<Item = T>,
+        wrt: &mut dyn io::Write,
+    ) -> io::Result<()>;
+}
+
+pub trait ColumnCodec<T: PartialOrd = u64> {
+    type Reader: ColumnValues<T> + 'static;
+    type Estimator: ColumnCodecEstimator + Default;
+
+    fn load(bytes: OwnedBytes) -> io::Result<Self::Reader>;
+
+    fn estimator() -> Self::Estimator {
+        Self::Estimator::default()
+    }
+    fn boxed_estimator() -> Box<dyn ColumnCodecEstimator> {
+        Box::new(Self::estimator())
+    }
+}
+
+/// Available codecs to use to encode the u64 (via [`MonotonicallyMappableToU64`]) converted data.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
+#[repr(u8)]
+pub enum CodecType {
+    /// Bitpack all values in the value range. The number of bits is defined by the amplitude
+    /// `column.max_value() - column.min_value()`
+    Bitpacked = 0u8,
+    /// Linear interpolation puts a line between the first and last value and then bitpacks the
+    /// values by the offset from the line. The number of bits is defined by the max deviation from
+    /// the line.
+    Linear = 1u8,
+    /// Same as [`CodecType::Linear`], but encodes in blocks of 512 elements.
+    BlockwiseLinear = 2u8,
+}
+
+pub const ALL_U64_CODEC_TYPES: [CodecType; 3] = [
+    CodecType::Bitpacked,
+    CodecType::Linear,
+    CodecType::BlockwiseLinear,
+];
+
+impl CodecType {
+    fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    fn try_from_code(code: u8) -> Option<CodecType> {
+        match code {
+            0u8 => Some(CodecType::Bitpacked),
+            1u8 => Some(CodecType::Linear),
+            2u8 => Some(CodecType::BlockwiseLinear),
+            _ => None,
+        }
+    }
+
+    fn load<T: MonotonicallyMappableToU64>(
+        &self,
+        bytes: OwnedBytes,
+    ) -> io::Result<Arc<dyn ColumnValues<T>>> {
+        match self {
+            CodecType::Bitpacked => load_specific_codec::<BitpackedCodec, T>(bytes),
+            CodecType::Linear => load_specific_codec::<LinearCodec, T>(bytes),
+            CodecType::BlockwiseLinear => load_specific_codec::<BlockwiseLinearCodec, T>(bytes),
+        }
+    }
+}
+
+fn load_specific_codec<C: ColumnCodec, T: MonotonicallyMappableToU64>(
+    bytes: OwnedBytes,
+) -> io::Result<Arc<dyn ColumnValues<T>>> {
+    let reader = C::load(bytes)?;
+    let reader_typed = monotonic_map_column(
+        reader,
+        StrictlyMonotonicMappingInverter::from(StrictlyMonotonicMappingToInternal::<T>::new()),
+    );
+    Ok(Arc::new(reader_typed))
+}
+
+impl CodecType {
+    pub fn estimator(&self) -> Box<dyn ColumnCodecEstimator> {
+        match self {
+            CodecType::Bitpacked => BitpackedCodec::boxed_estimator(),
+            CodecType::Linear => LinearCodec::boxed_estimator(),
+            CodecType::BlockwiseLinear => BlockwiseLinearCodec::boxed_estimator(),
+        }
+    }
+}
+
+pub fn serialize_u64_based_column_values<'a, T: MonotonicallyMappableToU64>(
+    vals: &dyn Iterable<T>,
+    codec_types: &[CodecType],
+    wrt: &mut dyn Write,
+) -> io::Result<()> {
+    let mut stats_collector = StatsCollector::default();
+    let mut estimators: Vec<(CodecType, Box<dyn ColumnCodecEstimator>)> =
+        Vec::with_capacity(codec_types.len());
+    for &codec_type in codec_types {
+        estimators.push((codec_type, codec_type.estimator()));
+    }
+    for val in vals.boxed_iter() {
+        let val_u64 = val.to_u64();
+        stats_collector.collect(val_u64);
+        for (_, estimator) in &mut estimators {
+            estimator.collect(val_u64);
+        }
+    }
+    for (_, estimator) in &mut estimators {
+        estimator.finalize();
+    }
+    let stats = stats_collector.stats();
+    let (_, best_codec, best_codec_estimator) = estimators
+        .into_iter()
+        .flat_map(|(codec_type, estimator)| {
+            let num_bytes = estimator.estimate(&stats)?;
+            Some((num_bytes, codec_type, estimator))
+        })
+        .min_by_key(|(num_bytes, _, _)| *num_bytes)
+        .ok_or_else(|| {
+            io::Error::new(io::ErrorKind::InvalidData, "No available applicable codec.")
+        })?;
+    best_codec.to_code().serialize(wrt)?;
+    best_codec_estimator.serialize(
+        &stats,
+        &mut vals.boxed_iter().map(MonotonicallyMappableToU64::to_u64),
+        wrt,
+    )?;
+    Ok(())
+}
+
+pub fn load_u64_based_column_values<T: MonotonicallyMappableToU64>(
+    mut bytes: OwnedBytes,
+) -> io::Result<Arc<dyn ColumnValues<T>>> {
+    let codec_type: CodecType = bytes
+        .get(0)
+        .copied()
+        .and_then(CodecType::try_from_code)
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "Failed to read codec type"))?;
+    bytes.advance(1);
+    codec_type.load(bytes)
+}
+
+/// Helper function to serialize a column (autodetect from all codecs) and then open it
+pub fn serialize_and_load_u64_based_column_values<T: MonotonicallyMappableToU64>(
+    vals: &dyn Iterable,
+    codec_types: &[CodecType],
+) -> Arc<dyn ColumnValues<T>> {
+    let mut buffer = Vec::new();
+    serialize_u64_based_column_values(vals, codec_types, &mut buffer).unwrap();
+    load_u64_based_column_values::<T>(OwnedBytes::new(buffer)).unwrap()
+}
+
+#[cfg(test)]
+mod tests;

columnar/src/column_values/u64_based/stats_collector.rs

@@ -0,0 +1,200 @@
+use std::num::NonZeroU64;
+
+use fastdivide::DividerU64;
+
+use crate::column_values::Stats;
+use crate::RowId;
+
+/// 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;
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct StatsCollector {
+    min_max_opt: Option<(u64, u64)>,
+    num_rows: RowId,
+    // We measure the GCD of the difference between the values and the minimal value.
+    // This is the same as computing the difference between the values and the first value.
+    //
+    // This way, we can compress i64-converted-to-u64 (e.g. timestamp that were supplied in
+    // seconds, only to be converted in microseconds).
+    increment_gcd_opt: Option<(NonZeroU64, DividerU64)>,
+    first_value_opt: Option<u64>,
+}
+
+impl StatsCollector {
+    pub fn stats(&self) -> Stats {
+        let (min_value, max_value) = self.min_max_opt.unwrap_or((0u64, 0u64));
+        let increment_gcd = if let Some((increment_gcd, _)) = self.increment_gcd_opt {
+            increment_gcd
+        } else {
+            NonZeroU64::new(1u64).unwrap()
+        };
+        Stats {
+            min_value,
+            max_value,
+            num_rows: self.num_rows,
+            gcd: increment_gcd,
+        }
+    }
+
+    #[inline]
+    fn update_increment_gcd(&mut self, value: u64) {
+        let Some(first_value) = self.first_value_opt else {
+            // We set the first value and just quit.
+            self.first_value_opt = Some(value);
+            return;
+        };
+        let Some(non_zero_value) = NonZeroU64::new(value.abs_diff(first_value)) else {
+            // We can simply skip 0 values.
+            return;
+        };
+        let Some((gcd, gcd_divider)) = self.increment_gcd_opt else {
+            self.set_increment_gcd(non_zero_value);
+            return;
+        };
+        if gcd.get() == 1 {
+            // It won't see any update now.
+            return;
+        }
+        let remainder =
+            non_zero_value.get() - (gcd_divider.divide(non_zero_value.get())) * gcd.get();
+        if remainder == 0 {
+            return;
+        }
+        let new_gcd = compute_gcd(non_zero_value, gcd);
+        self.set_increment_gcd(new_gcd);
+    }
+
+    fn set_increment_gcd(&mut self, gcd: NonZeroU64) {
+        let new_divider = DividerU64::divide_by(gcd.get());
+        self.increment_gcd_opt = Some((gcd, new_divider));
+    }
+
+    pub fn collect(&mut self, value: u64) {
+        self.min_max_opt = Some(if let Some((min, max)) = self.min_max_opt {
+            (min.min(value), max.max(value))
+        } else {
+            (value, value)
+        });
+        self.num_rows += 1;
+        self.update_increment_gcd(value);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::num::NonZeroU64;
+
+    use crate::column_values::u64_based::stats_collector::{compute_gcd, StatsCollector};
+    use crate::column_values::u64_based::Stats;
+
+    fn compute_stats(vals: impl Iterator<Item = u64>) -> Stats {
+        let mut stats_collector = StatsCollector::default();
+        for val in vals {
+            stats_collector.collect(val);
+        }
+        stats_collector.stats()
+    }
+
+    fn find_gcd(vals: impl Iterator<Item = u64>) -> u64 {
+        compute_stats(vals).gcd.get()
+    }
+
+    #[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 test_gcd() {
+        assert_eq!(find_gcd([0].into_iter()), 1);
+        assert_eq!(find_gcd([0, 10].into_iter()), 10);
+        assert_eq!(find_gcd([10, 0].into_iter()), 10);
+        assert_eq!(find_gcd([].into_iter()), 1);
+        assert_eq!(find_gcd([15, 30, 5, 10].into_iter()), 5);
+        assert_eq!(find_gcd([15, 16, 10].into_iter()), 1);
+        assert_eq!(find_gcd([0, 5, 5, 5].into_iter()), 5);
+        assert_eq!(find_gcd([0, 0].into_iter()), 1);
+        assert_eq!(find_gcd([1, 10, 4, 1, 7, 10].into_iter()), 3);
+        assert_eq!(find_gcd([1, 10, 0, 4, 1, 7, 10].into_iter()), 1);
+    }
+
+    #[test]
+    fn test_stats() {
+        assert_eq!(
+            compute_stats([].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(1).unwrap(),
+                min_value: 0,
+                max_value: 0,
+                num_rows: 0
+            }
+        );
+        assert_eq!(
+            compute_stats([0, 1].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(1).unwrap(),
+                min_value: 0,
+                max_value: 1,
+                num_rows: 2
+            }
+        );
+        assert_eq!(
+            compute_stats([0, 1].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(1).unwrap(),
+                min_value: 0,
+                max_value: 1,
+                num_rows: 2
+            }
+        );
+        assert_eq!(
+            compute_stats([10, 20, 30].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(10).unwrap(),
+                min_value: 10,
+                max_value: 30,
+                num_rows: 3
+            }
+        );
+        assert_eq!(
+            compute_stats([10, 50, 10, 30].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(20).unwrap(),
+                min_value: 10,
+                max_value: 50,
+                num_rows: 4
+            }
+        );
+        assert_eq!(
+            compute_stats([10, 0, 30].into_iter()),
+            Stats {
+                gcd: NonZeroU64::new(10).unwrap(),
+                min_value: 0,
+                max_value: 30,
+                num_rows: 3
+            }
+        );
+    }
+}

columnar/src/column_values/u64_based/tests.rs

@@ -2,53 +2,88 @@ use proptest::prelude::*;
 use proptest::strategy::Strategy;
 use proptest::{prop_oneof, proptest};
 
-use super::bitpacked::BitpackedCodec;
-use super::blockwise_linear::BlockwiseLinearCodec;
-use super::linear::LinearCodec;
-use super::serialize::Header;
-
-pub(crate) fn create_and_validate<Codec: FastFieldCodec>(
-    data: &[u64],
+#[test]
+fn test_serialize_and_load_simple() {
+    let mut buffer = Vec::new();
+    let vals = &[1u64, 2u64, 5u64];
+    serialize_u64_based_column_values(
+        &&vals[..],
+        &[CodecType::Bitpacked, CodecType::BlockwiseLinear],
+        &mut buffer,
+    )
+    .unwrap();
+    assert_eq!(buffer.len(), 7);
+    let col = load_u64_based_column_values::<u64>(OwnedBytes::new(buffer)).unwrap();
+    assert_eq!(col.num_vals(), 3);
+    assert_eq!(col.get_val(0), 1);
+    assert_eq!(col.get_val(1), 2);
+    assert_eq!(col.get_val(2), 5);
+}
+pub(crate) fn create_and_validate<TColumnCodec: ColumnCodec>(
+    vals: &[u64],
     name: &str,
 ) -> Option<(f32, f32)> {
-    let col = &VecColumn::from(data);
-    let header = Header::compute_header(col, &[Codec::CODEC_TYPE])?;
-    let normalized_col = header.normalize_column(col);
-    let estimation = Codec::estimate(&normalized_col)?;
+    let mut stats_collector = StatsCollector::default();
+    let mut codec_estimator: TColumnCodec::Estimator = Default::default();
 
-    let mut out = Vec::new();
-    let col = VecColumn::from(data);
-    serialize_column_values(&col, &[Codec::CODEC_TYPE], &mut out).unwrap();
+    for val in vals.boxed_iter() {
+        stats_collector.collect(val);
+        codec_estimator.collect(val);
+    }
+    codec_estimator.finalize();
+    let stats = stats_collector.stats();
+    let estimation = codec_estimator.estimate(&stats)?;
 
-    let actual_compression = out.len() as f32 / (data.len() as f32 * 8.0);
+    let mut buffer = Vec::new();
+    codec_estimator
+        .serialize(&stats, vals.boxed_iter().as_mut(), &mut buffer)
+        .unwrap();
 
-    let reader = super::open_u64_mapped::<u64>(OwnedBytes::new(out)).unwrap();
-    assert_eq!(reader.num_vals(), data.len() as u32);
-    for (doc, orig_val) in data.iter().copied().enumerate() {
+    let actual_compression = buffer.len() as u64;
+
+    let reader = TColumnCodec::load(OwnedBytes::new(buffer)).unwrap();
+    assert_eq!(reader.num_vals(), vals.len() as u32);
+    for (doc, orig_val) in vals.iter().copied().enumerate() {
         let val = reader.get_val(doc as u32);
         assert_eq!(
             val, orig_val,
-            "val `{val}` does not match orig_val {orig_val:?}, in data set {name}, data `{data:?}`",
+            "val `{val}` does not match orig_val {orig_val:?}, in data set {name}, data `{vals:?}`",
         );
     }
 
-    if !data.is_empty() {
-        let test_rand_idx = rand::thread_rng().gen_range(0..=data.len() - 1);
-        let expected_positions: Vec<u32> = data
+    if !vals.is_empty() {
+        let test_rand_idx = rand::thread_rng().gen_range(0..=vals.len() - 1);
+        let expected_positions: Vec<u32> = vals
             .iter()
             .enumerate()
-            .filter(|(_, el)| **el == data[test_rand_idx])
+            .filter(|(_, el)| **el == vals[test_rand_idx])
             .map(|(pos, _)| pos as u32)
             .collect();
         let mut positions = Vec::new();
         reader.get_docids_for_value_range(
-            data[test_rand_idx]..=data[test_rand_idx],
-            0..data.len() as u32,
+            vals[test_rand_idx]..=vals[test_rand_idx],
+            0..vals.len() as u32,
             &mut positions,
         );
         assert_eq!(expected_positions, positions);
     }
-    Some((estimation, actual_compression))
+    if actual_compression > 1000 {
+        assert!(relative_difference(estimation, actual_compression) < 0.10f32);
+    }
+    Some((
+        compression_rate(estimation, stats.num_rows),
+        compression_rate(actual_compression, stats.num_rows),
+    ))
+}
+
+fn compression_rate(num_bytes: u64, num_values: u32) -> f32 {
+    num_bytes as f32 / (num_values as f32 * 8.0)
+}
+
+fn relative_difference(left: u64, right: u64) -> f32 {
+    let left = left as f32;
+    let right = right as f32;
+    2.0f32 * (left - right).abs() / (left + right)
 }
 
 proptest! {
@@ -64,12 +99,21 @@ proptest! {
         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");
     }
 }
 
+#[test]
+fn test_small_blockwise_linear_example() {
+    create_and_validate::<BlockwiseLinearCodec>(
+        &[9223372036854775808, 9223370937344622593],
+        "proptest multilinearinterpol",
+    );
+}
+
 proptest! {
     #![proptest_config(ProptestConfig::with_cases(10))]
 
@@ -118,8 +162,8 @@ pub fn get_codec_test_datasets() -> Vec<(Vec<u64>, &'static str)> {
     data_and_names
 }
 
-fn test_codec<C: FastFieldCodec>() {
-    let codec_name = format!("{:?}", C::CODEC_TYPE);
+fn test_codec<C: ColumnCodec>() {
+    let codec_name = std::any::type_name::<C>();
     for (data, dataset_name) in get_codec_test_datasets() {
         let estimate_actual_opt: Option<(f32, f32)> =
             tests::create_and_validate::<C>(&data, dataset_name);
@@ -146,53 +190,48 @@ fn test_codec_multi_interpolation() {
 
 use super::*;
 
+fn estimate<C: ColumnCodec>(vals: &[u64]) -> Option<f32> {
+    let mut stats_collector = StatsCollector::default();
+    let mut estimator = C::Estimator::default();
+    for &val in vals {
+        stats_collector.collect(val);
+        estimator.collect(val);
+    }
+    estimator.finalize();
+    let stats = stats_collector.stats();
+    let num_bytes = estimator.estimate(&stats)?;
+    if stats.num_rows == 0 {
+        return None;
+    }
+    Some(num_bytes as f32 / (8.0 * stats.num_rows as f32))
+}
+
 #[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 = estimate::<LinearCodec>(&data).unwrap();
     assert_le!(linear_interpol_estimation, 0.01);
 
-    let multi_linear_interpol_estimation = BlockwiseLinearCodec::estimate(&data).unwrap();
+    let multi_linear_interpol_estimation = estimate::<BlockwiseLinearCodec>(&data).unwrap();
     assert_le!(multi_linear_interpol_estimation, 0.2);
     assert_lt!(linear_interpol_estimation, multi_linear_interpol_estimation);
 
-    let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+    let bitpacked_estimation = estimate::<BitpackedCodec>(&data).unwrap();
     assert_lt!(linear_interpol_estimation, bitpacked_estimation);
 }
-#[test]
-fn estimation_test_bad_interpolation_case() {
-    let data: &[u64] = &[200, 10, 10, 10, 10, 1000, 20];
-
-    let data: VecColumn = data.into();
-    let linear_interpol_estimation = LinearCodec::estimate(&data).unwrap();
-    assert_le!(linear_interpol_estimation, 0.34);
-
-    let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
-    assert_lt!(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> = (201..=20000_u64).collect();
     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 = estimate::<LinearCodec>(&data[..]).unwrap();
     assert_le!(linear_interpol_estimation, 0.35);
 
-    let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+    let bitpacked_estimation = estimate::<BitpackedCodec>(&data).unwrap();
     assert_le!(bitpacked_estimation, 0.32);
     assert_le!(bitpacked_estimation, linear_interpol_estimation);
 }
@@ -201,7 +240,7 @@ fn estimation_test_bad_interpolation_case_monotonically_increasing() {
 fn test_fast_field_codec_type_to_code() {
     let mut count_codec = 0;
     for code in 0..=255 {
-        if let Some(codec_type) = FastFieldCodecType::from_code(code) {
+        if let Some(codec_type) = CodecType::try_from_code(code) {
             assert_eq!(codec_type.to_code(), code);
             count_codec += 1;
         }
@@ -209,19 +248,16 @@ fn test_fast_field_codec_type_to_code() {
     assert_eq!(count_codec, 3);
 }
 
-fn test_fastfield_gcd_i64_with_codec(
-    codec_type: FastFieldCodecType,
-    num_vals: usize,
-) -> io::Result<()> {
+fn test_fastfield_gcd_i64_with_codec(codec_type: CodecType, 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::column_values::serialize_column_values(
-        &VecColumn::from(&vals),
+    crate::column_values::serialize_u64_based_column_values(
+        &&vals[..],
         &[codec_type],
         &mut buffer,
     )?;
     let buffer = OwnedBytes::new(buffer);
-    let column = crate::column_values::open_u64_mapped::<i64>(buffer.clone())?;
+    let column = crate::column_values::load_u64_based_column_values::<i64>(buffer.clone())?;
     assert_eq!(column.get_val(0), -4000i64);
     assert_eq!(column.get_val(1), -3000i64);
     assert_eq!(column.get_val(2), -2000i64);
@@ -232,8 +268,8 @@ fn test_fastfield_gcd_i64_with_codec(
     let mut buffer_without_gcd = Vec::new();
     vals.pop();
     vals.push(1001i64);
-    crate::column_values::serialize_column_values(
-        &VecColumn::from(&vals),
+    crate::column_values::serialize_u64_based_column_values(
+        &&vals[..],
         &[codec_type],
         &mut buffer_without_gcd,
     )?;
@@ -246,28 +282,25 @@ fn test_fastfield_gcd_i64_with_codec(
 #[test]
 fn test_fastfield_gcd_i64() -> io::Result<()> {
     for &codec_type in &[
-        FastFieldCodecType::Bitpacked,
-        FastFieldCodecType::BlockwiseLinear,
-        FastFieldCodecType::Linear,
+        CodecType::Bitpacked,
+        CodecType::BlockwiseLinear,
+        CodecType::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<()> {
+fn test_fastfield_gcd_u64_with_codec(codec_type: CodecType, 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::column_values::serialize_column_values(
-        &VecColumn::from(&vals),
+    crate::column_values::serialize_u64_based_column_values(
+        &&vals[..],
         &[codec_type],
         &mut buffer,
     )?;
     let buffer = OwnedBytes::new(buffer);
-    let column = crate::column_values::open_u64_mapped::<u64>(buffer.clone())?;
+    let column = crate::column_values::load_u64_based_column_values::<u64>(buffer.clone())?;
     assert_eq!(column.get_val(0), 1000u64);
     assert_eq!(column.get_val(1), 2000u64);
     assert_eq!(column.get_val(2), 3000u64);
@@ -278,8 +311,8 @@ fn test_fastfield_gcd_u64_with_codec(
     let mut buffer_without_gcd = Vec::new();
     vals.pop();
     vals.push(1001u64);
-    crate::column_values::serialize_column_values(
-        &VecColumn::from(&vals),
+    crate::column_values::serialize_u64_based_column_values(
+        &&vals[..],
         &[codec_type],
         &mut buffer_without_gcd,
     )?;
@@ -291,9 +324,9 @@ fn test_fastfield_gcd_u64_with_codec(
 #[test]
 fn test_fastfield_gcd_u64() -> io::Result<()> {
     for &codec_type in &[
-        FastFieldCodecType::Bitpacked,
-        FastFieldCodecType::BlockwiseLinear,
-        FastFieldCodecType::Linear,
+        CodecType::Bitpacked,
+        CodecType::BlockwiseLinear,
+        CodecType::Linear,
     ] {
         test_fastfield_gcd_u64_with_codec(codec_type, 5500)?;
     }
@@ -302,7 +335,10 @@ fn test_fastfield_gcd_u64() -> io::Result<()> {
 
 #[test]
 pub fn test_fastfield2() {
-    let test_fastfield = crate::column_values::serialize_and_load(&[100u64, 200u64, 300u64]);
+    let test_fastfield = crate::column_values::serialize_and_load_u64_based_column_values::<u64>(
+        &&[100u64, 200u64, 300u64][..],
+        &ALL_U64_CODEC_TYPES,
+    );
     assert_eq!(test_fastfield.get_val(0), 100);
     assert_eq!(test_fastfield.get_val(1), 200);
     assert_eq!(test_fastfield.get_val(2), 300);

columnar/src/columnar/column_type.rs

@@ -8,7 +8,7 @@ use crate::InvalidData;
 ///
 /// - bits[0..3]: Column category type.
 /// - bits[3..6]: Numerical type if necessary.
-#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
+#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy, Ord, PartialOrd)]
 #[repr(u8)]
 pub enum ColumnType {
     I64 = 0u8,
@@ -65,18 +65,6 @@ impl From<NumericalType> for ColumnType {
 }
 
 impl ColumnType {
-    /// get column type category
-    pub(crate) fn column_type_category(self) -> ColumnTypeCategory {
-        match self {
-            ColumnType::I64 | ColumnType::U64 | ColumnType::F64 => ColumnTypeCategory::Numerical,
-            ColumnType::Bytes => ColumnTypeCategory::Bytes,
-            ColumnType::Str => ColumnTypeCategory::Str,
-            ColumnType::Bool => ColumnTypeCategory::Bool,
-            ColumnType::IpAddr => ColumnTypeCategory::IpAddr,
-            ColumnType::DateTime => ColumnTypeCategory::DateTime,
-        }
-    }
-
     pub fn numerical_type(&self) -> Option<NumericalType> {
         match self {
             ColumnType::I64 => Some(NumericalType::I64),

columnar/src/columnar/merge.rs

@@ -1,176 +0,0 @@
-use std::collections::HashMap;
-use std::io;
-
-use super::column_type::ColumnTypeCategory;
-use crate::columnar::ColumnarReader;
-use crate::dynamic_column::DynamicColumn;
-
-pub enum MergeDocOrder {
-    /// Columnar tables are simply stacked one above the other.
-    /// If the i-th columnar_readers has n_rows_i rows, then
-    /// in the resulting columnar,
-    /// rows [r0..n_row_0) contains the row of columnar_readers[0], in ordder
-    /// rows [n_row_0..n_row_0 + n_row_1 contains the row of columnar_readers[1], in order.
-    /// ..
-    Stack,
-    /// Some more complex mapping, that can interleaves rows from the different readers and
-    /// possibly drop rows.
-    Complex(()),
-}
-
-pub fn merge_columnar(
-    _columnar_readers: &[ColumnarReader],
-    mapping: MergeDocOrder,
-    _output: &mut impl io::Write,
-) -> io::Result<()> {
-    match mapping {
-        MergeDocOrder::Stack => {
-            // implement me :)
-            todo!();
-        }
-        MergeDocOrder::Complex(_) => {
-            // for later
-            todo!();
-        }
-    }
-}
-
-pub fn collect_columns(
-    columnar_readers: &[&ColumnarReader],
-) -> io::Result<HashMap<String, HashMap<ColumnTypeCategory, Vec<DynamicColumn>>>> {
-    // Each column name may have multiple types of column associated.
-    // For merging we are interested in the same column type category since they can be merged.
-    let mut field_name_to_group: HashMap<String, HashMap<ColumnTypeCategory, Vec<DynamicColumn>>> =
-        HashMap::new();
-
-    for columnar_reader in columnar_readers {
-        let column_name_and_handle = columnar_reader.list_columns()?;
-        for (column_name, handle) in column_name_and_handle {
-            let column_type_to_handles = field_name_to_group
-                .entry(column_name.to_string())
-                .or_default();
-
-            let columns = column_type_to_handles
-                .entry(handle.column_type().column_type_category())
-                .or_default();
-            columns.push(handle.open()?);
-        }
-    }
-
-    normalize_columns(&mut field_name_to_group);
-
-    Ok(field_name_to_group)
-}
-
-/// Cast numerical type columns to the same type
-pub(crate) fn normalize_columns(
-    map: &mut HashMap<String, HashMap<ColumnTypeCategory, Vec<DynamicColumn>>>,
-) {
-    for (_field_name, type_category_to_columns) in map.iter_mut() {
-        for (type_category, columns) in type_category_to_columns {
-            if type_category == &ColumnTypeCategory::Numerical {
-                let casted_columns = cast_to_common_numerical_column(&columns);
-                *columns = casted_columns;
-            }
-        }
-    }
-}
-
-/// Receives a list of columns of numerical types (u64, i64, f64)
-///
-/// Returns a list of `DynamicColumn` which are all of the same numerical type
-fn cast_to_common_numerical_column(columns: &[DynamicColumn]) -> Vec<DynamicColumn> {
-    assert!(columns
-        .iter()
-        .all(|column| column.column_type().numerical_type().is_some()));
-    let coerce_to_i64: Vec<_> = columns
-        .iter()
-        .map(|column| column.clone().coerce_to_i64())
-        .collect();
-
-    if coerce_to_i64.iter().all(|column| column.is_some()) {
-        return coerce_to_i64
-            .into_iter()
-            .map(|column| column.unwrap())
-            .collect();
-    }
-
-    let coerce_to_u64: Vec<_> = columns
-        .iter()
-        .map(|column| column.clone().coerce_to_u64())
-        .collect();
-
-    if coerce_to_u64.iter().all(|column| column.is_some()) {
-        return coerce_to_u64
-            .into_iter()
-            .map(|column| column.unwrap())
-            .collect();
-    }
-
-    columns
-        .iter()
-        .map(|column| {
-            column
-                .clone()
-                .coerce_to_f64()
-                .expect("couldn't cast column to f64")
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ColumnarWriter;
-
-    #[test]
-    fn test_column_coercion() {
-        // i64 type
-        let columnar1 = {
-            let mut dataframe_writer = ColumnarWriter::default();
-            dataframe_writer.record_numerical(1u32, "numbers", 1i64);
-            let mut buffer: Vec<u8> = Vec::new();
-            dataframe_writer.serialize(2, &mut buffer).unwrap();
-            ColumnarReader::open(buffer).unwrap()
-        };
-        // u64 type
-        let columnar2 = {
-            let mut dataframe_writer = ColumnarWriter::default();
-            dataframe_writer.record_numerical(1u32, "numbers", u64::MAX - 100);
-            let mut buffer: Vec<u8> = Vec::new();
-            dataframe_writer.serialize(2, &mut buffer).unwrap();
-            ColumnarReader::open(buffer).unwrap()
-        };
-
-        // f64 type
-        let columnar3 = {
-            let mut dataframe_writer = ColumnarWriter::default();
-            dataframe_writer.record_numerical(1u32, "numbers", 30.5);
-            let mut buffer: Vec<u8> = Vec::new();
-            dataframe_writer.serialize(2, &mut buffer).unwrap();
-            ColumnarReader::open(buffer).unwrap()
-        };
-
-        let column_map = collect_columns(&[&columnar1, &columnar2, &columnar3]).unwrap();
-        assert_eq!(column_map.len(), 1);
-        let cat_to_columns = column_map.get("numbers").unwrap();
-        assert_eq!(cat_to_columns.len(), 1);
-
-        let numerical = cat_to_columns.get(&ColumnTypeCategory::Numerical).unwrap();
-        assert!(numerical.iter().all(|column| column.is_f64()));
-
-        let column_map = collect_columns(&[&columnar1, &columnar1]).unwrap();
-        assert_eq!(column_map.len(), 1);
-        let cat_to_columns = column_map.get("numbers").unwrap();
-        assert_eq!(cat_to_columns.len(), 1);
-        let numerical = cat_to_columns.get(&ColumnTypeCategory::Numerical).unwrap();
-        assert!(numerical.iter().all(|column| column.is_i64()));
-
-        let column_map = collect_columns(&[&columnar2, &columnar2]).unwrap();
-        assert_eq!(column_map.len(), 1);
-        let cat_to_columns = column_map.get("numbers").unwrap();
-        assert_eq!(cat_to_columns.len(), 1);
-        let numerical = cat_to_columns.get(&ColumnTypeCategory::Numerical).unwrap();
-        assert!(numerical.iter().all(|column| column.is_u64()));
-    }
-}

columnar/src/columnar/merge/merge_dict_column.rs

@@ -0,0 +1,106 @@
+use std::io::{self, Write};
+
+use common::CountingWriter;
+use sstable::{SSTable, TermOrdinal};
+
+use super::term_merger::TermMerger;
+use crate::column::serialize_column_mappable_to_u64;
+use crate::column_index::SerializableColumnIndex;
+use crate::iterable::Iterable;
+use crate::BytesColumn;
+
+// Serialize [Dictionary, Column, dictionary num bytes U32::LE]
+// Column: [Column Index, Column Values, column index num bytes U32::LE]
+pub fn merge_bytes_or_str_column(
+    column_index: SerializableColumnIndex<'_>,
+    bytes_columns: &[BytesColumn],
+    output: &mut impl Write,
+) -> io::Result<()> {
+    // Serialize dict and generate mapping for values
+    let mut output = CountingWriter::wrap(output);
+    let term_ord_mapping = serialize_merged_dict(bytes_columns, &mut output)?;
+    let dictionary_num_bytes: u32 = output.written_bytes() as u32;
+    let output = output.finish();
+    let remapped_term_ordinals_values = RemappedTermOrdinalsValues {
+        bytes_columns,
+        term_ord_mapping: &term_ord_mapping,
+    };
+    serialize_column_mappable_to_u64(column_index, &remapped_term_ordinals_values, output)?;
+    // serialize_bytes_or_str_column(column_index, bytes_columns, &term_ord_mapping, output)?;
+    output.write_all(&dictionary_num_bytes.to_le_bytes())?;
+    Ok(())
+}
+
+struct RemappedTermOrdinalsValues<'a> {
+    bytes_columns: &'a [BytesColumn],
+    term_ord_mapping: &'a TermOrdinalMapping,
+}
+
+impl<'a> Iterable for RemappedTermOrdinalsValues<'a> {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = u64> + '_> {
+        let iter = self
+            .bytes_columns
+            .iter()
+            .enumerate()
+            .flat_map(|(segment_ord, byte_column)| {
+                let segment_ord = self.term_ord_mapping.get_segment(segment_ord);
+                byte_column
+                    .ords()
+                    .values
+                    .iter()
+                    .map(move |term_ord| segment_ord[term_ord as usize])
+            });
+        // TODO see if we can better decompose the mapping / and the stacking
+        Box::new(iter)
+    }
+}
+
+fn serialize_merged_dict(
+    bytes_columns: &[BytesColumn],
+    output: &mut impl Write,
+) -> io::Result<TermOrdinalMapping> {
+    let mut term_ord_mapping = TermOrdinalMapping::default();
+
+    let mut field_term_streams = Vec::new();
+    for column in bytes_columns {
+        term_ord_mapping.add_segment(column.dictionary.num_terms());
+        let terms = column.dictionary.stream()?;
+        field_term_streams.push(terms);
+    }
+
+    let mut merged_terms = TermMerger::new(field_term_streams);
+    let mut sstable_builder = sstable::VoidSSTable::writer(output);
+
+    let mut current_term_ord = 0;
+    while merged_terms.advance() {
+        let term_bytes: &[u8] = merged_terms.key();
+
+        sstable_builder.insert(term_bytes, &())?;
+        for (segment_ord, from_term_ord) in merged_terms.matching_segments() {
+            term_ord_mapping.register_from_to(segment_ord, from_term_ord, current_term_ord);
+        }
+        current_term_ord += 1;
+    }
+    sstable_builder.finish()?;
+    Ok(term_ord_mapping)
+}
+
+#[derive(Default)]
+struct TermOrdinalMapping {
+    per_segment_new_term_ordinals: Vec<Vec<TermOrdinal>>,
+}
+
+impl TermOrdinalMapping {
+    fn add_segment(&mut self, max_term_ord: usize) {
+        self.per_segment_new_term_ordinals
+            .push(vec![TermOrdinal::default(); max_term_ord as usize]);
+    }
+
+    fn register_from_to(&mut self, segment_ord: usize, from_ord: TermOrdinal, to_ord: TermOrdinal) {
+        self.per_segment_new_term_ordinals[segment_ord][from_ord as usize] = to_ord;
+    }
+
+    fn get_segment(&self, segment_ord: usize) -> &[TermOrdinal] {
+        &(self.per_segment_new_term_ordinals[segment_ord])[..]
+    }
+}

columnar/src/columnar/merge/merge_mapping.rs

@@ -0,0 +1,60 @@
+use std::ops::Range;
+
+use crate::{column, ColumnarReader, RowId};
+
+pub struct StackMergeOrder {
+    // This does not start at 0. The first row is the number of
+    // rows in the first columnar.
+    cumulated_row_ids: Vec<RowId>,
+}
+
+impl StackMergeOrder {
+    pub fn stack(columnars: &[&ColumnarReader]) -> StackMergeOrder {
+        let mut cumulated_row_ids: Vec<RowId> = Vec::with_capacity(columnars.len());
+        let mut cumulated_row_id = 0;
+        for columnar in columnars {
+            cumulated_row_id += columnar.num_rows();
+            cumulated_row_ids.push(cumulated_row_id);
+        }
+        StackMergeOrder { cumulated_row_ids }
+    }
+
+    pub fn num_rows(&self) -> RowId {
+        self.cumulated_row_ids.last().copied().unwrap_or(0)
+    }
+
+    pub fn offset(&self, columnar_id: usize) -> RowId {
+        if columnar_id == 0 {
+            return 0;
+        }
+        self.cumulated_row_ids[columnar_id - 1]
+    }
+
+    pub fn columnar_range(&self, columnar_id: usize) -> Range<RowId> {
+        self.offset(columnar_id)..self.offset(columnar_id + 1)
+    }
+}
+
+pub enum MergeRowOrder {
+    /// Columnar tables are simply stacked one above the other.
+    /// If the i-th columnar_readers has n_rows_i rows, then
+    /// in the resulting columnar,
+    /// rows [r0..n_row_0) contains the row of columnar_readers[0], in ordder
+    /// rows [n_row_0..n_row_0 + n_row_1 contains the row of columnar_readers[1], in order.
+    /// ..
+    Stack(StackMergeOrder),
+    /// Some more complex mapping, that can interleaves rows from the different readers and
+    /// possibly drop rows.
+    Complex(()),
+}
+
+impl MergeRowOrder {
+    pub fn num_rows(&self) -> RowId {
+        match self {
+            MergeRowOrder::Stack(stack_row_order) => stack_row_order.num_rows(),
+            MergeRowOrder::Complex(_) => {
+                todo!()
+            }
+        }
+    }
+}

columnar/src/columnar/merge/mod.rs

@@ -0,0 +1,225 @@
+mod merge_dict_column;
+mod merge_mapping;
+mod term_merger;
+
+// mod sorted_doc_id_column;
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::io;
+use std::net::Ipv6Addr;
+use std::sync::Arc;
+
+pub use merge_mapping::{MergeRowOrder, StackMergeOrder};
+
+use super::writer::ColumnarSerializer;
+use crate::column::{serialize_column_mappable_to_u128, serialize_column_mappable_to_u64};
+use crate::column_index::stack_column_index;
+use crate::columnar::column_type::ColumnTypeCategory;
+use crate::columnar::merge::merge_dict_column::merge_bytes_or_str_column;
+use crate::columnar::writer::CompatibleNumericalTypes;
+use crate::columnar::ColumnarReader;
+use crate::dynamic_column::DynamicColumn;
+use crate::{
+    BytesColumn, Column, ColumnIndex, ColumnType, ColumnValues, MonotonicallyMappableToU128,
+    NumericalType, NumericalValue,
+};
+
+pub fn merge_columnar(
+    columnar_readers: &[&ColumnarReader],
+    mapping: MergeRowOrder,
+    output: &mut impl io::Write,
+) -> io::Result<()> {
+    let mut serializer = ColumnarSerializer::new(output);
+
+    let columns_to_merge = group_columns_for_merge(columnar_readers)?;
+    for ((column_name, column_type), columns) in columns_to_merge {
+        let mut column_serializer =
+            serializer.serialize_column(column_name.as_bytes(), column_type);
+        merge_column(column_type, columns, &mapping, &mut column_serializer)?;
+    }
+    serializer.finalize(mapping.num_rows())?;
+
+    Ok(())
+}
+
+fn dynamic_column_to_u64_monotonic(dynamic_column: DynamicColumn) -> Option<Column<u64>> {
+    match dynamic_column {
+        DynamicColumn::Bool(column) => Some(column.to_u64_monotonic()),
+        DynamicColumn::I64(column) => Some(column.to_u64_monotonic()),
+        DynamicColumn::U64(column) => Some(column.to_u64_monotonic()),
+        DynamicColumn::F64(column) => Some(column.to_u64_monotonic()),
+        DynamicColumn::DateTime(column) => Some(column.to_u64_monotonic()),
+        DynamicColumn::IpAddr(_) | DynamicColumn::Bytes(_) | DynamicColumn::Str(_) => None,
+    }
+}
+
+pub fn merge_column(
+    column_type: ColumnType,
+    columns: Vec<Option<DynamicColumn>>,
+    merge_row_order: &MergeRowOrder,
+    wrt: &mut impl io::Write,
+) -> io::Result<()> {
+    match column_type {
+        ColumnType::I64
+        | ColumnType::U64
+        | ColumnType::F64
+        | ColumnType::DateTime
+        | ColumnType::Bool => {
+            let mut column_indexes: Vec<Option<ColumnIndex>> = Vec::with_capacity(columns.len());
+            let mut column_values: Vec<Arc<dyn ColumnValues>> = Vec::with_capacity(columns.len());
+            for dynamic_column_opt in columns {
+                if let Some(Column { idx, values }) =
+                    dynamic_column_opt.and_then(dynamic_column_to_u64_monotonic)
+                {
+                    column_indexes.push(Some(idx));
+                    column_values.push(values);
+                } else {
+                    column_indexes.push(None);
+                }
+            }
+            let merged_column_index =
+                crate::column_index::stack_column_index(&column_indexes[..], merge_row_order);
+            serialize_column_mappable_to_u64(merged_column_index, &&column_values[..], wrt)?;
+        }
+        ColumnType::IpAddr => {
+            let mut column_indexes: Vec<Option<ColumnIndex>> = Vec::with_capacity(columns.len());
+            let mut column_values: Vec<Arc<dyn ColumnValues<Ipv6Addr>>> =
+                Vec::with_capacity(columns.len());
+            let mut num_values = 0;
+            for dynamic_column_opt in columns {
+                if let Some(DynamicColumn::IpAddr(Column { idx, values })) = dynamic_column_opt {
+                    num_values += values.num_vals();
+                    column_indexes.push(Some(idx));
+                    column_values.push(values);
+                } else {
+                    column_indexes.push(None);
+                }
+            }
+            let merged_column_index =
+                crate::column_index::stack_column_index(&column_indexes[..], merge_row_order);
+            serialize_column_mappable_to_u128(
+                merged_column_index,
+                &&column_values[..],
+                num_values,
+                wrt,
+            )?;
+        }
+        ColumnType::Bytes | ColumnType::Str => {
+            let mut column_indexes: Vec<Option<ColumnIndex>> = Vec::with_capacity(columns.len());
+            let mut bytes_columns: Vec<BytesColumn> = Vec::with_capacity(columns.len());
+            for dynamic_column_opt in columns {
+                match dynamic_column_opt {
+                    Some(DynamicColumn::Str(str_column)) => {
+                        column_indexes.push(Some(str_column.term_ord_column.idx.clone()));
+                        bytes_columns.push(str_column.into());
+                    }
+                    Some(DynamicColumn::Bytes(bytes_column)) => {
+                        column_indexes.push(Some(bytes_column.term_ord_column.idx.clone()));
+                        bytes_columns.push(bytes_column);
+                    }
+                    _ => column_indexes.push(None),
+                }
+            }
+            let merged_column_index =
+                crate::column_index::stack_column_index(&column_indexes[..], merge_row_order);
+            merge_bytes_or_str_column(merged_column_index, &bytes_columns, wrt)?;
+        }
+    }
+    Ok(())
+}
+
+fn group_columns_for_merge(
+    columnar_readers: &[&ColumnarReader],
+) -> io::Result<BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>>> {
+    // Each column name may have multiple types of column associated.
+    // For merging we are interested in the same column type category since they can be merged.
+    let mut columns_grouped: HashMap<(String, ColumnTypeCategory), Vec<Option<DynamicColumn>>> =
+        HashMap::new();
+
+    let num_columnars = columnar_readers.len();
+
+    for (columnar_id, columnar_reader) in columnar_readers.iter().enumerate() {
+        let column_name_and_handle = columnar_reader.list_columns()?;
+        for (column_name, handle) in column_name_and_handle {
+            let column_type_category: ColumnTypeCategory = handle.column_type().into();
+            let columns = columns_grouped
+                .entry((column_name, column_type_category))
+                .or_insert_with(|| vec![None; num_columnars]);
+            let column = handle.open()?;
+            columns[columnar_id] = Some(column);
+        }
+    }
+
+    let mut merge_columns: BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>> =
+        BTreeMap::default();
+
+    for ((column_name, col_category), mut columns) in columns_grouped {
+        if col_category == ColumnTypeCategory::Numerical {
+            coerce_numerical_columns_to_same_type(&mut columns);
+        }
+        let column_type = columns
+            .iter()
+            .flatten()
+            .map(|col| col.column_type())
+            .next()
+            .unwrap();
+        merge_columns.insert((column_name, column_type), columns);
+    }
+
+    Ok(merge_columns)
+}
+
+/// Coerce a set of numerical columns to the same type.
+///
+/// If all columns are already from the same type, keep this type
+/// (even if they could all be coerced to i64).
+fn coerce_numerical_columns_to_same_type(columns: &mut [Option<DynamicColumn>]) {
+    let mut column_types: HashSet<NumericalType> = HashSet::default();
+    let mut compatible_numerical_types = CompatibleNumericalTypes::default();
+    for column in columns.iter().flatten() {
+        let min_value: NumericalValue;
+        let max_value: NumericalValue;
+        match column {
+            DynamicColumn::I64(column) => {
+                min_value = column.min_value().into();
+                max_value = column.max_value().into();
+            }
+            DynamicColumn::U64(column) => {
+                min_value = column.min_value().into();
+                max_value = column.min_value().into();
+            }
+            DynamicColumn::F64(column) => {
+                min_value = column.min_value().into();
+                max_value = column.min_value().into();
+            }
+            DynamicColumn::Bool(_)
+            | DynamicColumn::IpAddr(_)
+            | DynamicColumn::DateTime(_)
+            | DynamicColumn::Bytes(_)
+            | DynamicColumn::Str(_) => {
+                panic!("We expected only numerical columns.");
+            }
+        }
+        column_types.insert(column.column_type().numerical_type().unwrap());
+        compatible_numerical_types.accept_value(min_value);
+        compatible_numerical_types.accept_value(max_value);
+    }
+    if column_types.len() <= 1 {
+        // No need to do anything. The columns are already all from the same type.
+        // This is necessary to let use force a given type.
+
+        // TODO This works in a world where we do not allow a change of schema,
+        // but in the future, we will have to pass some kind of schema to enforce
+        // the logic.
+        return;
+    }
+    let coerce_type = compatible_numerical_types.to_numerical_type();
+    for column_opt in columns.iter_mut() {
+        if let Some(column) = column_opt.take() {
+            *column_opt = column.coerce_numerical(coerce_type);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

columnar/src/columnar/merge/term_merger.rs

@@ -0,0 +1,107 @@
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+
+use sstable::TermOrdinal;
+
+use crate::Streamer;
+
+pub struct HeapItem<'a> {
+    pub streamer: Streamer<'a>,
+    pub segment_ord: usize,
+}
+
+impl<'a> PartialEq for HeapItem<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        self.segment_ord == other.segment_ord
+    }
+}
+
+impl<'a> Eq for HeapItem<'a> {}
+
+impl<'a> PartialOrd for HeapItem<'a> {
+    fn partial_cmp(&self, other: &HeapItem<'a>) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<'a> Ord for HeapItem<'a> {
+    fn cmp(&self, other: &HeapItem<'a>) -> Ordering {
+        (&other.streamer.key(), &other.segment_ord).cmp(&(&self.streamer.key(), &self.segment_ord))
+    }
+}
+
+/// Given a list of sorted term streams,
+/// returns an iterator over sorted unique terms.
+///
+/// The item yield is actually a pair with
+/// - the term
+/// - a slice with the ordinal of the segments containing
+/// the terms.
+pub struct TermMerger<'a> {
+    heap: BinaryHeap<HeapItem<'a>>,
+    current_streamers: Vec<HeapItem<'a>>,
+}
+
+impl<'a> TermMerger<'a> {
+    /// Stream of merged term dictionary
+    pub fn new(streams: Vec<Streamer<'a>>) -> TermMerger<'a> {
+        TermMerger {
+            heap: BinaryHeap::new(),
+            current_streamers: streams
+                .into_iter()
+                .enumerate()
+                .map(|(ord, streamer)| HeapItem {
+                    streamer,
+                    segment_ord: ord,
+                })
+                .collect(),
+        }
+    }
+
+    pub(crate) fn matching_segments<'b: 'a>(
+        &'b self,
+    ) -> impl 'b + Iterator<Item = (usize, TermOrdinal)> {
+        self.current_streamers
+            .iter()
+            .map(|heap_item| (heap_item.segment_ord, heap_item.streamer.term_ord()))
+    }
+
+    fn advance_segments(&mut self) {
+        let streamers = &mut self.current_streamers;
+        let heap = &mut self.heap;
+        for mut heap_item in streamers.drain(..) {
+            if heap_item.streamer.advance() {
+                heap.push(heap_item);
+            }
+        }
+    }
+
+    /// Advance the term iterator to the next term.
+    /// Returns true if there is indeed another term
+    /// False if there is none.
+    pub fn advance(&mut self) -> bool {
+        self.advance_segments();
+        if let Some(head) = self.heap.pop() {
+            self.current_streamers.push(head);
+            while let Some(next_streamer) = self.heap.peek() {
+                if self.current_streamers[0].streamer.key() != next_streamer.streamer.key() {
+                    break;
+                }
+                let next_heap_it = self.heap.pop().unwrap(); // safe : we peeked beforehand
+                self.current_streamers.push(next_heap_it);
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Returns the current term.
+    ///
+    /// This method may be called
+    /// if and only if advance() has been called before
+    /// and "true" was returned.
+    pub fn key(&self) -> &[u8] {
+        self.current_streamers[0].streamer.key()
+    }
+}

columnar/src/columnar/merge/tests.rs

@@ -0,0 +1,252 @@
+use super::*;
+use crate::{Cardinality, ColumnarWriter, HasAssociatedColumnType, RowId};
+
+fn make_columnar<T: Into<NumericalValue> + HasAssociatedColumnType + Copy>(
+    column_name: &str,
+    vals: &[T],
+) -> ColumnarReader {
+    let mut dataframe_writer = ColumnarWriter::default();
+    dataframe_writer.record_column_type(column_name, T::column_type(), false);
+    for (row_id, val) in vals.iter().copied().enumerate() {
+        dataframe_writer.record_numerical(row_id as RowId, column_name, val.into());
+    }
+    let mut buffer: Vec<u8> = Vec::new();
+    dataframe_writer
+        .serialize(vals.len() as RowId, &mut buffer)
+        .unwrap();
+    ColumnarReader::open(buffer).unwrap()
+}
+
+#[test]
+fn test_column_coercion_to_u64() {
+    // i64 type
+    let columnar1 = make_columnar("numbers", &[1i64]);
+    // u64 type
+    let columnar2 = make_columnar("numbers", &[u64::MAX]);
+    let column_map: BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>> =
+        group_columns_for_merge(&[&columnar1, &columnar2]).unwrap();
+    assert_eq!(column_map.len(), 1);
+    assert!(column_map.contains_key(&("numbers".to_string(), ColumnType::U64)));
+}
+
+#[test]
+fn test_column_no_coercion_if_all_the_same() {
+    let columnar1 = make_columnar("numbers", &[1u64]);
+    let columnar2 = make_columnar("numbers", &[2u64]);
+    let column_map: BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>> =
+        group_columns_for_merge(&[&columnar1, &columnar2]).unwrap();
+    assert_eq!(column_map.len(), 1);
+    assert!(column_map.contains_key(&("numbers".to_string(), ColumnType::U64)));
+}
+
+#[test]
+fn test_column_coercion_to_i64() {
+    let columnar1 = make_columnar("numbers", &[-1i64]);
+    let columnar2 = make_columnar("numbers", &[2u64]);
+    let column_map: BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>> =
+        group_columns_for_merge(&[&columnar1, &columnar2]).unwrap();
+    assert_eq!(column_map.len(), 1);
+    assert!(column_map.contains_key(&("numbers".to_string(), ColumnType::I64)));
+}
+
+#[test]
+fn test_missing_column() {
+    let columnar1 = make_columnar("numbers", &[-1i64]);
+    let columnar2 = make_columnar("numbers2", &[2u64]);
+    let column_map: BTreeMap<(String, ColumnType), Vec<Option<DynamicColumn>>> =
+        group_columns_for_merge(&[&columnar1, &columnar2]).unwrap();
+    assert_eq!(column_map.len(), 2);
+    assert!(column_map.contains_key(&("numbers".to_string(), ColumnType::I64)));
+    {
+        let columns = column_map
+            .get(&("numbers".to_string(), ColumnType::I64))
+            .unwrap();
+        assert!(columns[0].is_some());
+        assert!(columns[1].is_none());
+    }
+    {
+        let columns = column_map
+            .get(&("numbers2".to_string(), ColumnType::U64))
+            .unwrap();
+        assert!(columns[0].is_none());
+        assert!(columns[1].is_some());
+    }
+}
+
+fn make_numerical_columnar_multiple_columns(
+    columns: &[(&str, &[&[NumericalValue]])],
+) -> ColumnarReader {
+    let mut dataframe_writer = ColumnarWriter::default();
+    for (column_name, column_values) in columns {
+        for (row_id, vals) in column_values.iter().enumerate() {
+            for val in vals.iter() {
+                dataframe_writer.record_numerical(row_id as u32, column_name, *val);
+            }
+        }
+    }
+    let num_rows = columns
+        .iter()
+        .map(|(_, val_rows)| val_rows.len() as RowId)
+        .max()
+        .unwrap_or(0u32);
+    let mut buffer: Vec<u8> = Vec::new();
+    dataframe_writer.serialize(num_rows, &mut buffer).unwrap();
+    ColumnarReader::open(buffer).unwrap()
+}
+
+fn make_byte_columnar_multiple_columns(columns: &[(&str, &[&[&[u8]]])]) -> ColumnarReader {
+    let mut dataframe_writer = ColumnarWriter::default();
+    for (column_name, column_values) in columns {
+        for (row_id, vals) in column_values.iter().enumerate() {
+            for val in vals.iter() {
+                dataframe_writer.record_bytes(row_id as u32, column_name, *val);
+            }
+        }
+    }
+    let num_rows = columns
+        .iter()
+        .map(|(_, val_rows)| val_rows.len() as RowId)
+        .max()
+        .unwrap_or(0u32);
+    let mut buffer: Vec<u8> = Vec::new();
+    dataframe_writer.serialize(num_rows, &mut buffer).unwrap();
+    ColumnarReader::open(buffer).unwrap()
+}
+
+fn make_text_columnar_multiple_columns(columns: &[(&str, &[&[&str]])]) -> ColumnarReader {
+    let mut dataframe_writer = ColumnarWriter::default();
+    for (column_name, column_values) in columns {
+        for (row_id, vals) in column_values.iter().enumerate() {
+            for val in vals.iter() {
+                dataframe_writer.record_str(row_id as u32, column_name, *val);
+            }
+        }
+    }
+    let num_rows = columns
+        .iter()
+        .map(|(_, val_rows)| val_rows.len() as RowId)
+        .max()
+        .unwrap_or(0u32);
+    let mut buffer: Vec<u8> = Vec::new();
+    dataframe_writer.serialize(num_rows, &mut buffer).unwrap();
+    ColumnarReader::open(buffer).unwrap()
+}
+
+#[test]
+fn test_merge_columnar_numbers() {
+    let columnar1 =
+        make_numerical_columnar_multiple_columns(&[("numbers", &[&[NumericalValue::from(-1f64)]])]);
+    let columnar2 = make_numerical_columnar_multiple_columns(&[(
+        "numbers",
+        &[&[], &[NumericalValue::from(-3f64)]],
+    )]);
+    let mut buffer = Vec::new();
+    let columnars = &[&columnar1, &columnar2];
+    let stack_merge_order = StackMergeOrder::stack(columnars);
+    crate::columnar::merge_columnar(
+        columnars,
+        MergeRowOrder::Stack(stack_merge_order),
+        &mut buffer,
+    )
+    .unwrap();
+    let columnar_reader = ColumnarReader::open(buffer).unwrap();
+    assert_eq!(columnar_reader.num_rows(), 3);
+    assert_eq!(columnar_reader.num_columns(), 1);
+    let cols = columnar_reader.read_columns("numbers").unwrap();
+    let dynamic_column = cols[0].open().unwrap();
+    let DynamicColumn::F64(vals) = dynamic_column else { panic!() };
+    assert_eq!(vals.get_cardinality(), Cardinality::Optional);
+    assert_eq!(vals.first(0u32), Some(-1f64));
+    assert_eq!(vals.first(1u32), None);
+    assert_eq!(vals.first(2u32), Some(-3f64));
+}
+
+#[test]
+fn test_merge_columnar_texts() {
+    let columnar1 = make_text_columnar_multiple_columns(&[("texts", &[&["a"]])]);
+    let columnar2 = make_text_columnar_multiple_columns(&[("texts", &[&[], &["b"]])]);
+    let mut buffer = Vec::new();
+    let columnars = &[&columnar1, &columnar2];
+    let stack_merge_order = StackMergeOrder::stack(columnars);
+    crate::columnar::merge_columnar(
+        columnars,
+        MergeRowOrder::Stack(stack_merge_order),
+        &mut buffer,
+    )
+    .unwrap();
+    let columnar_reader = ColumnarReader::open(buffer).unwrap();
+    assert_eq!(columnar_reader.num_rows(), 3);
+    assert_eq!(columnar_reader.num_columns(), 1);
+    let cols = columnar_reader.read_columns("texts").unwrap();
+    let dynamic_column = cols[0].open().unwrap();
+    let DynamicColumn::Str(vals) = dynamic_column else { panic!() };
+    let get_str_for_ord = |ord| {
+        let mut out = String::new();
+        vals.ord_to_str(ord, &mut out).unwrap();
+        out
+    };
+
+    assert_eq!(vals.dictionary.num_terms(), 2);
+    assert_eq!(get_str_for_ord(0), "a");
+    assert_eq!(get_str_for_ord(1), "b");
+
+    let get_str_for_row = |row_id| {
+        let term_ords: Vec<u64> = vals.term_ords(row_id).collect();
+        assert!(term_ords.len() <= 1);
+        let mut out = String::new();
+        if term_ords.len() == 1 {
+            vals.ord_to_str(term_ords[0], &mut out).unwrap();
+        }
+        out
+    };
+
+    assert_eq!(get_str_for_row(0), "a");
+    assert_eq!(get_str_for_row(1), "");
+    assert_eq!(get_str_for_row(2), "b");
+}
+
+#[test]
+fn test_merge_columnar_byte() {
+    let columnar1 = make_byte_columnar_multiple_columns(&[("bytes", &[&[b"bbbb"], &[b"baaa"]])]);
+    let columnar2 = make_byte_columnar_multiple_columns(&[("bytes", &[&[], &[b"a"]])]);
+    let mut buffer = Vec::new();
+    let columnars = &[&columnar1, &columnar2];
+    let stack_merge_order = StackMergeOrder::stack(columnars);
+    crate::columnar::merge_columnar(
+        columnars,
+        MergeRowOrder::Stack(stack_merge_order),
+        &mut buffer,
+    )
+    .unwrap();
+    let columnar_reader = ColumnarReader::open(buffer).unwrap();
+    assert_eq!(columnar_reader.num_rows(), 4);
+    assert_eq!(columnar_reader.num_columns(), 1);
+    let cols = columnar_reader.read_columns("bytes").unwrap();
+    let dynamic_column = cols[0].open().unwrap();
+    let DynamicColumn::Bytes(vals) = dynamic_column else { panic!() };
+    let get_bytes_for_ord = |ord| {
+        let mut out = Vec::new();
+        vals.ord_to_bytes(ord, &mut out).unwrap();
+        out
+    };
+
+    assert_eq!(vals.dictionary.num_terms(), 3);
+    assert_eq!(get_bytes_for_ord(0), b"a");
+    assert_eq!(get_bytes_for_ord(1), b"baaa");
+    assert_eq!(get_bytes_for_ord(2), b"bbbb");
+
+    let get_bytes_for_row = |row_id| {
+        let term_ords: Vec<u64> = vals.term_ords(row_id).collect();
+        assert!(term_ords.len() <= 1);
+        let mut out = Vec::new();
+        if term_ords.len() == 1 {
+            vals.ord_to_bytes(term_ords[0], &mut out).unwrap();
+        }
+        out
+    };
+
+    assert_eq!(get_bytes_for_row(0), b"bbbb");
+    assert_eq!(get_bytes_for_row(1), b"baaa");
+    assert_eq!(get_bytes_for_row(2), b"");
+    assert_eq!(get_bytes_for_row(3), b"a");
+}

columnar/src/columnar/merge_index.rs

@@ -0,0 +1 @@
+

columnar/src/columnar/mod.rs

@@ -1,10 +1,11 @@
 mod column_type;
 mod format_version;
 mod merge;
+mod merge_index;
 mod reader;
 mod writer;
 
 pub use column_type::{ColumnType, HasAssociatedColumnType};
-pub use merge::{merge_columnar, MergeDocOrder};
+pub use merge::{merge_columnar, MergeRowOrder, StackMergeOrder};
 pub use reader::ColumnarReader;
 pub use writer::ColumnarWriter;

columnar/src/columnar/reader/mod.rs

@@ -6,6 +6,7 @@ use sstable::{Dictionary, RangeSSTable};
 
 use crate::columnar::{format_version, ColumnType};
 use crate::dynamic_column::DynamicColumnHandle;
+use crate::RowId;
 
 fn io_invalid_data(msg: String) -> io::Error {
     io::Error::new(io::ErrorKind::InvalidData, msg)
@@ -13,9 +14,11 @@ fn io_invalid_data(msg: String) -> io::Error {
 
 /// The ColumnarReader makes it possible to access a set of columns
 /// associated to field names.
+#[derive(Clone)]
 pub struct ColumnarReader {
     column_dictionary: Dictionary<RangeSSTable>,
     column_data: FileSlice,
+    num_rows: RowId,
 }
 
 impl ColumnarReader {
@@ -27,23 +30,27 @@ impl ColumnarReader {
 
     fn open_inner(file_slice: FileSlice) -> io::Result<ColumnarReader> {
         let (file_slice_without_sstable_len, footer_slice) = file_slice
-            .split_from_end(mem::size_of::<u64>() + format_version::VERSION_FOOTER_NUM_BYTES);
+            .split_from_end(mem::size_of::<u64>() + 4 + format_version::VERSION_FOOTER_NUM_BYTES);
         let footer_bytes = footer_slice.read_bytes()?;
-        let (mut sstable_len_bytes, version_footer_bytes) =
-            footer_bytes.rsplit(format_version::VERSION_FOOTER_NUM_BYTES);
+        let sstable_len = u64::deserialize(&mut &footer_bytes[0..8])?;
+        let num_rows = u32::deserialize(&mut &footer_bytes[8..12])?;
         let version_footer_bytes: [u8; format_version::VERSION_FOOTER_NUM_BYTES] =
-            version_footer_bytes.as_slice().try_into().unwrap();
+            footer_bytes[12..].try_into().unwrap();
         let _version = format_version::parse_footer(version_footer_bytes)?;
-        let sstable_len = u64::deserialize(&mut sstable_len_bytes)?;
         let (column_data, sstable) =
             file_slice_without_sstable_len.split_from_end(sstable_len as usize);
         let column_dictionary = Dictionary::open(sstable)?;
         Ok(ColumnarReader {
             column_dictionary,
             column_data,
+            num_rows,
         })
     }
 
+    pub fn num_rows(&self) -> RowId {
+        self.num_rows
+    }
+
     // TODO Add unit tests
     pub fn list_columns(&self) -> io::Result<Vec<(String, DynamicColumnHandle)>> {
         let mut stream = self.column_dictionary.stream()?;

columnar/src/columnar/writer/column_writers.rs

@@ -114,7 +114,7 @@ impl NumericalColumnWriter {
 /// State used to store what types are still acceptable
 /// after having seen a set of numerical values.
 #[derive(Clone, Copy)]
-enum CompatibleNumericalTypes {
+pub(crate) enum CompatibleNumericalTypes {
     Dynamic {
         all_values_within_i64_range: bool,
         all_values_within_u64_range: bool,
@@ -132,7 +132,7 @@ impl Default for CompatibleNumericalTypes {
 }
 
 impl CompatibleNumericalTypes {
-    fn is_type_accepted(&self, numerical_type: NumericalType) -> bool {
+    pub fn is_type_accepted(&self, numerical_type: NumericalType) -> bool {
         match self {
             CompatibleNumericalTypes::Dynamic {
                 all_values_within_i64_range,
@@ -148,7 +148,7 @@ impl CompatibleNumericalTypes {
         }
     }
 
-    fn accept_value(&mut self, numerical_value: NumericalValue) {
+    pub fn accept_value(&mut self, numerical_value: NumericalValue) {
         match self {
             CompatibleNumericalTypes::Dynamic {
                 all_values_within_i64_range,

columnar/src/columnar/writer/mod.rs

@@ -7,8 +7,9 @@ use std::io;
 use std::net::Ipv6Addr;
 
 use column_operation::ColumnOperation;
+pub(crate) use column_writers::CompatibleNumericalTypes;
 use common::CountingWriter;
-use serializer::ColumnarSerializer;
+pub(crate) use serializer::ColumnarSerializer;
 use stacker::{Addr, ArenaHashMap, MemoryArena};
 
 use crate::column_index::SerializableColumnIndex;
@@ -395,11 +396,13 @@ impl ColumnarWriter {
                 }
             };
         }
-        serializer.finalize()?;
+        serializer.finalize(num_docs)?;
         Ok(())
     }
 }
 
+// Serialize [Dictionary, Column, dictionary num bytes U32::LE]
+// Column: [Column Index, Column Values, column index num bytes U32::LE]
 fn serialize_bytes_or_str_column(
     cardinality: Cardinality,
     num_docs: RowId,
@@ -547,7 +550,7 @@ fn send_to_serialize_column_mappable_to_u128<
 >(
     op_iterator: impl Iterator<Item = ColumnOperation<T>>,
     cardinality: Cardinality,
-    num_docs: RowId,
+    num_rows: RowId,
     value_index_builders: &mut PreallocatedIndexBuilders,
     values: &mut Vec<T>,
     mut wrt: impl io::Write,
@@ -569,31 +572,31 @@ where
         Cardinality::Optional => {
             let optional_index_builder = value_index_builders.borrow_optional_index_builder();
             consume_operation_iterator(op_iterator, optional_index_builder, values);
-            let optional_index = optional_index_builder.finish(num_docs);
-            SerializableColumnIndex::Optional(Box::new(optional_index))
+            let optional_index = optional_index_builder.finish(num_rows);
+            SerializableColumnIndex::Optional {
+                num_rows,
+                non_null_row_ids: Box::new(optional_index),
+            }
         }
         Cardinality::Multivalued => {
             let multivalued_index_builder = value_index_builders.borrow_multivalued_index_builder();
             consume_operation_iterator(op_iterator, multivalued_index_builder, values);
-            let multivalued_index = multivalued_index_builder.finish(num_docs);
+            let multivalued_index = multivalued_index_builder.finish(num_rows);
             SerializableColumnIndex::Multivalued(Box::new(multivalued_index))
         }
     };
     crate::column::serialize_column_mappable_to_u128(
         serializable_column_index,
-        || values.iter().cloned(),
+        &&values[..],
         values.len() as u32,
         &mut wrt,
     )?;
     Ok(())
 }
 
-fn sort_values_within_row_in_place(
-    multivalued_index: &impl ColumnValues<RowId>,
-    values: &mut Vec<u64>,
-) {
+fn sort_values_within_row_in_place(multivalued_index: &[RowId], values: &mut Vec<u64>) {
     let mut start_index: usize = 0;
-    for end_index in multivalued_index.iter() {
+    for end_index in multivalued_index.iter().copied() {
         let end_index = end_index as usize;
         values[start_index..end_index].sort_unstable();
         start_index = end_index;
@@ -603,7 +606,7 @@ fn sort_values_within_row_in_place(
 fn send_to_serialize_column_mappable_to_u64(
     op_iterator: impl Iterator<Item = ColumnOperation<u64>>,
     cardinality: Cardinality,
-    num_docs: RowId,
+    num_rows: RowId,
     sort_values_within_row: bool,
     value_index_builders: &mut PreallocatedIndexBuilders,
     values: &mut Vec<u64>,
@@ -625,22 +628,25 @@ where
         Cardinality::Optional => {
             let optional_index_builder = value_index_builders.borrow_optional_index_builder();
             consume_operation_iterator(op_iterator, optional_index_builder, values);
-            let optional_index = optional_index_builder.finish(num_docs);
-            SerializableColumnIndex::Optional(Box::new(optional_index))
+            let optional_index = optional_index_builder.finish(num_rows);
+            SerializableColumnIndex::Optional {
+                non_null_row_ids: Box::new(optional_index),
+                num_rows,
+            }
         }
         Cardinality::Multivalued => {
             let multivalued_index_builder = value_index_builders.borrow_multivalued_index_builder();
             consume_operation_iterator(op_iterator, multivalued_index_builder, values);
-            let multivalued_index = multivalued_index_builder.finish(num_docs);
+            let multivalued_index = multivalued_index_builder.finish(num_rows);
             if sort_values_within_row {
-                sort_values_within_row_in_place(&multivalued_index, values);
+                sort_values_within_row_in_place(multivalued_index, values);
             }
             SerializableColumnIndex::Multivalued(Box::new(multivalued_index))
         }
     };
     crate::column::serialize_column_mappable_to_u64(
         serializable_column_index,
-        &VecColumn::from(&values[..]),
+        &&values[..],
         &mut wrt,
     )?;
     Ok(())

columnar/src/columnar/writer/serializer.rs

@@ -1,11 +1,12 @@
 use std::io;
 use std::io::Write;
 
-use common::CountingWriter;
+use common::{BinarySerializable, CountingWriter};
 use sstable::value::RangeValueWriter;
 use sstable::RangeSSTable;
 
 use crate::columnar::ColumnType;
+use crate::RowId;
 
 pub struct ColumnarSerializer<W: io::Write> {
     wrt: CountingWriter<W>,
@@ -46,11 +47,12 @@ impl<W: io::Write> ColumnarSerializer<W> {
         }
     }
 
-    pub(crate) fn finalize(mut self) -> io::Result<()> {
+    pub(crate) fn finalize(mut self, num_rows: RowId) -> io::Result<()> {
         let sstable_bytes: Vec<u8> = self.sstable_range.finish()?;
         let sstable_num_bytes: u64 = sstable_bytes.len() as u64;
         self.wrt.write_all(&sstable_bytes)?;
         self.wrt.write_all(&sstable_num_bytes.to_le_bytes()[..])?;
+        num_rows.serialize(&mut self.wrt)?;
         self.wrt
             .write_all(&super::super::format_version::footer())?;
         self.wrt.flush()?;

columnar/src/columnar/writer/value_index.rs

@@ -1,5 +1,4 @@
-use crate::column_index::SerializableOptionalIndex;
-use crate::column_values::{ColumnValues, VecColumn};
+use crate::iterable::Iterable;
 use crate::RowId;
 
 /// The `IndexBuilder` interprets a sequence of
@@ -29,34 +28,15 @@ pub struct OptionalIndexBuilder {
     docs: Vec<RowId>,
 }
 
-struct SingleValueArrayIndex<'a> {
-    // RowIds with a value, in a strictly increasing order
-    row_ids: &'a [RowId],
-    num_rows: RowId,
-}
-
-impl<'a> SerializableOptionalIndex<'a> for SingleValueArrayIndex<'a> {
-    fn num_rows(&self) -> RowId {
-        self.num_rows
-    }
-
-    fn non_null_rows(&self) -> Box<dyn Iterator<Item = RowId> + 'a> {
-        Box::new(self.row_ids.iter().copied())
-    }
-}
-
 impl OptionalIndexBuilder {
-    pub fn finish<'a>(&'a mut self, num_rows: RowId) -> impl SerializableOptionalIndex + 'a {
+    pub fn finish<'a>(&'a mut self, num_rows: RowId) -> impl Iterable<RowId> + 'a {
         debug_assert!(self
             .docs
             .last()
             .copied()
             .map(|last_doc| last_doc < num_rows)
             .unwrap_or(true));
-        SingleValueArrayIndex {
-            row_ids: &self.docs[..],
-            num_rows,
-        }
+        &self.docs[..]
     }
 
     fn reset(&mut self) {
@@ -84,14 +64,10 @@ pub struct MultivaluedIndexBuilder {
 }
 
 impl MultivaluedIndexBuilder {
-    pub fn finish(&mut self, num_docs: RowId) -> impl ColumnValues<u32> + '_ {
+    pub fn finish(&mut self, num_docs: RowId) -> &[u32] {
         self.start_offsets
             .resize(num_docs as usize + 1, self.total_num_vals_seen);
-        VecColumn {
-            values: &&self.start_offsets[..],
-            min_value: 0,
-            max_value: self.start_offsets.last().copied().unwrap_or(0),
-        }
+        &self.start_offsets[..]
     }
 
     fn reset(&mut self) {
@@ -149,7 +125,7 @@ mod tests {
         assert_eq!(
             &opt_value_index_builder
                 .finish(1u32)
-                .non_null_rows()
+                .boxed_iter()
                 .collect::<Vec<u32>>(),
             &[0]
         );
@@ -159,7 +135,7 @@ mod tests {
         assert_eq!(
             &opt_value_index_builder
                 .finish(2u32)
-                .non_null_rows()
+                .boxed_iter()
                 .collect::<Vec<u32>>(),
             &[1]
         );
@@ -177,6 +153,7 @@ mod tests {
             multivalued_value_index_builder
                 .finish(4u32)
                 .iter()
+                .copied()
                 .collect::<Vec<u32>>(),
             vec![0, 0, 2, 3, 3]
         );
@@ -188,6 +165,7 @@ mod tests {
             multivalued_value_index_builder
                 .finish(4u32)
                 .iter()
+                .copied()
                 .collect::<Vec<u32>>(),
             vec![0, 0, 0, 2, 2]
         );

columnar/src/dynamic_column.rs

@@ -8,7 +8,7 @@ use common::{HasLen, OwnedBytes};
 use crate::column::{BytesColumn, Column, StrColumn};
 use crate::column_values::{monotonic_map_column, StrictlyMonotonicFn};
 use crate::columnar::ColumnType;
-use crate::{DateTime, NumericalType};
+use crate::{Cardinality, DateTime, NumericalType};
 
 #[derive(Clone)]
 pub enum DynamicColumn {
@@ -23,6 +23,18 @@ pub enum DynamicColumn {
 }
 
 impl DynamicColumn {
+    pub fn get_cardinality(&self) -> Cardinality {
+        match self {
+            DynamicColumn::Bool(c) => c.get_cardinality(),
+            DynamicColumn::I64(c) => c.get_cardinality(),
+            DynamicColumn::U64(c) => c.get_cardinality(),
+            DynamicColumn::F64(c) => c.get_cardinality(),
+            DynamicColumn::IpAddr(c) => c.get_cardinality(),
+            DynamicColumn::DateTime(c) => c.get_cardinality(),
+            DynamicColumn::Bytes(c) => c.ords().get_cardinality(),
+            DynamicColumn::Str(c) => c.ords().get_cardinality(),
+        }
+    }
     pub fn column_type(&self) -> ColumnType {
         match self {
             DynamicColumn::Bool(_) => ColumnType::Bool,
@@ -36,6 +48,14 @@ impl DynamicColumn {
         }
     }
 
+    pub fn coerce_numerical(self, target_numerical_type: NumericalType) -> Option<Self> {
+        match target_numerical_type {
+            NumericalType::I64 => self.coerce_to_i64(),
+            NumericalType::U64 => self.coerce_to_u64(),
+            NumericalType::F64 => self.coerce_to_f64(),
+        }
+    }
+
     pub fn is_numerical(&self) -> bool {
         self.column_type().numerical_type().is_some()
     }
@@ -50,7 +70,7 @@ impl DynamicColumn {
         self.column_type().numerical_type() == Some(NumericalType::U64)
     }
 
-    pub fn coerce_to_f64(self) -> Option<DynamicColumn> {
+    fn coerce_to_f64(self) -> Option<DynamicColumn> {
         match self {
             DynamicColumn::I64(column) => Some(DynamicColumn::F64(Column {
                 idx: column.idx,
@@ -64,7 +84,7 @@ impl DynamicColumn {
             _ => None,
         }
     }
-    pub fn coerce_to_i64(self) -> Option<DynamicColumn> {
+    fn coerce_to_i64(self) -> Option<DynamicColumn> {
         match self {
             DynamicColumn::U64(column) => {
                 if column.max_value() > i64::MAX as u64 {
@@ -79,7 +99,7 @@ impl DynamicColumn {
             _ => None,
         }
     }
-    pub fn coerce_to_u64(self) -> Option<DynamicColumn> {
+    fn coerce_to_u64(self) -> Option<DynamicColumn> {
         match self {
             DynamicColumn::I64(column) => {
                 if column.min_value() < 0 {

columnar/src/iterable.rs

@@ -0,0 +1,19 @@
+use std::ops::Range;
+
+pub trait Iterable<T = u64> {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = T> + '_>;
+}
+
+impl<'a, T: Copy> Iterable<T> for &'a [T] {
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = T> + '_> {
+        Box::new(self.iter().copied())
+    }
+}
+
+impl<T: Copy> Iterable<T> for Range<T>
+where Range<T>: Iterator<Item = T>
+{
+    fn boxed_iter(&self) -> Box<dyn Iterator<Item = T> + '_> {
+        Box::new(self.clone())
+    }
+}

columnar/src/lib.rs

@@ -11,10 +11,11 @@ use std::io;
 
 mod column;
 mod column_index;
-mod column_values;
+pub mod column_values;
 mod columnar;
 mod dictionary;
 mod dynamic_column;
+mod iterable;
 pub(crate) mod utils;
 mod value;
 
@@ -23,7 +24,7 @@ pub use column_index::ColumnIndex;
 pub use column_values::{ColumnValues, MonotonicallyMappableToU128, MonotonicallyMappableToU64};
 pub use columnar::{
     merge_columnar, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
-    MergeDocOrder,
+    MergeRowOrder, StackMergeOrder,
 };
 use sstable::VoidSSTable;
 pub use value::{NumericalType, NumericalValue};
@@ -66,6 +67,12 @@ pub enum Cardinality {
 }
 
 impl Cardinality {
+    pub fn is_optional(&self) -> bool {
+        matches!(self, Cardinality::Optional)
+    }
+    pub fn is_multivalue(&self) -> bool {
+        matches!(self, Cardinality::Multivalued)
+    }
     pub(crate) fn to_code(self) -> u8 {
         self as u8
     }

common/src/serialize.rs

@@ -5,12 +5,37 @@ use byteorder::{ReadBytesExt, WriteBytesExt};
 
 use crate::{Endianness, VInt};
 
+#[derive(Default)]
+struct Counter(u64);
+
+impl io::Write for Counter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0 += buf.len() as u64;
+        Ok(buf.len())
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.0 += buf.len() as u64;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 /// Trait for a simple binary serialization.
 pub trait BinarySerializable: fmt::Debug + Sized {
     /// Serialize
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()>;
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()>;
     /// Deserialize
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self>;
+
+    fn num_bytes(&self) -> u64 {
+        let mut counter = Counter::default();
+        self.serialize(&mut counter).unwrap();
+        counter.0
+    }
 }
 
 pub trait DeserializeFrom<T: BinarySerializable> {
@@ -34,7 +59,7 @@ pub trait FixedSize: BinarySerializable {
 }
 
 impl BinarySerializable for () {
-    fn serialize<W: Write>(&self, _: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, _: &mut W) -> io::Result<()> {
         Ok(())
     }
     fn deserialize<R: Read>(_: &mut R) -> io::Result<Self> {
@@ -47,7 +72,7 @@ impl FixedSize for () {
 }
 
 impl<T: BinarySerializable> BinarySerializable for Vec<T> {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         VInt(self.len() as u64).serialize(writer)?;
         for it in self {
             it.serialize(writer)?;
@@ -66,7 +91,7 @@ impl<T: BinarySerializable> BinarySerializable for Vec<T> {
 }
 
 impl<Left: BinarySerializable, Right: BinarySerializable> BinarySerializable for (Left, Right) {
-    fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, write: &mut W) -> io::Result<()> {
         self.0.serialize(write)?;
         self.1.serialize(write)
     }
@@ -81,7 +106,7 @@ impl<Left: BinarySerializable + FixedSize, Right: BinarySerializable + FixedSize
 }
 
 impl BinarySerializable for u32 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u32::<Endianness>(*self)
     }
 
@@ -95,7 +120,7 @@ impl FixedSize for u32 {
 }
 
 impl BinarySerializable for u16 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u16::<Endianness>(*self)
     }
 
@@ -109,7 +134,7 @@ impl FixedSize for u16 {
 }
 
 impl BinarySerializable for u64 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u64::<Endianness>(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -122,7 +147,7 @@ impl FixedSize for u64 {
 }
 
 impl BinarySerializable for u128 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u128::<Endianness>(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -135,7 +160,7 @@ impl FixedSize for u128 {
 }
 
 impl BinarySerializable for f32 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_f32::<Endianness>(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -148,7 +173,7 @@ impl FixedSize for f32 {
 }
 
 impl BinarySerializable for i64 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_i64::<Endianness>(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -161,7 +186,7 @@ impl FixedSize for i64 {
 }
 
 impl BinarySerializable for f64 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_f64::<Endianness>(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -174,7 +199,7 @@ impl FixedSize for f64 {
 }
 
 impl BinarySerializable for u8 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u8(*self)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<u8> {
@@ -187,7 +212,7 @@ impl FixedSize for u8 {
 }
 
 impl BinarySerializable for bool {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u8(u8::from(*self))
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<bool> {
@@ -208,7 +233,7 @@ impl FixedSize for bool {
 }
 
 impl BinarySerializable for String {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         let data: &[u8] = self.as_bytes();
         VInt(data.len() as u64).serialize(writer)?;
         writer.write_all(data)

common/src/vint.rs

@@ -44,7 +44,7 @@ pub fn deserialize_vint_u128(data: &[u8]) -> io::Result<(u128, &[u8])> {
 pub struct VIntU128(pub u128);
 
 impl BinarySerializable for VIntU128 {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         let mut buffer = vec![];
         serialize_vint_u128(self.0, &mut buffer);
         writer.write_all(&buffer)
@@ -211,7 +211,7 @@ impl VInt {
 }
 
 impl BinarySerializable for VInt {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         let mut buffer = [0u8; 10];
         let num_bytes = self.serialize_into(&mut buffer);
         writer.write_all(&buffer[0..num_bytes])

fastfield_codecs/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "fastfield_codecs"
-version = "0.3.0"
-authors = ["Pascal Seitz <pascal@quickwit.io>"]
-license = "MIT"
-edition = "2021"
-description = "Fast field codecs used by tantivy"
-documentation = "https://docs.rs/fastfield_codecs/"
-homepage = "https://github.com/quickwit-oss/tantivy"
-repository = "https://github.com/quickwit-oss/tantivy"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-common = { version = "0.5", path = "../common/", package = "tantivy-common" }
-tantivy-bitpacker = { version= "0.3", path = "../bitpacker/" }
-columnar = { version= "0.1", path="../columnar", package="tantivy-columnar" }
-prettytable-rs = {version="0.10.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"
-proptest = "1.0.0"
-rand = "0.8.3"
-
-[features]
-bin = ["prettytable-rs", "rand", "measure_time"]
-default = ["bin"]
-unstable = []
-

fastfield_codecs/README.md

@@ -1,68 +0,0 @@
-
-
-# Fast Field Codecs
-
-This crate contains various fast field codecs, used to compress/decompress fast field data in tantivy.
-
-## Contributing
-
-Contributing is pretty straightforward. Since the bitpacking is the simplest compressor, you can check it for reference.
-
-A codec needs to implement 2 traits:
-
-- A reader implementing `FastFieldCodecReader` to read the codec.
-- A serializer implementing `FastFieldCodecSerializer` for compression estimation and codec name + id.
-
-### Tests
-
-Once the traits are implemented test and benchmark integration is pretty easy (see `test_with_codec_data_sets` and `bench.rs`).
-
-Make sure to add the codec to the main.rs, which tests the compression ratio and estimation against different data sets. You can run it with:
-```
-cargo run --features bin
-```
-
-### TODO
-- Add real world data sets in comparison
-- Add codec to cover sparse data sets
-
-
-### Codec Comparison
-```
-+----------------------------------+-------------------+------------------------+
-|                                  | Compression Ratio | Compression Estimation |
-+----------------------------------+-------------------+------------------------+
-| Autoincrement                    |                   |                        |
-+----------------------------------+-------------------+------------------------+
-| LinearInterpol                   | 0.000039572664    | 0.000004396963         |
-+----------------------------------+-------------------+------------------------+
-| MultiLinearInterpol              | 0.1477348         | 0.17275847             |
-+----------------------------------+-------------------+------------------------+
-| Bitpacked                        | 0.28126493        | 0.28125                |
-+----------------------------------+-------------------+------------------------+
-| Monotonically increasing concave |                   |                        |
-+----------------------------------+-------------------+------------------------+
-| LinearInterpol                   | 0.25003937        | 0.26562938             |
-+----------------------------------+-------------------+------------------------+
-| MultiLinearInterpol              | 0.190665          | 0.1883836              |
-+----------------------------------+-------------------+------------------------+
-| Bitpacked                        | 0.31251436        | 0.3125                 |
-+----------------------------------+-------------------+------------------------+
-| Monotonically increasing convex  |                   |                        |
-+----------------------------------+-------------------+------------------------+
-| LinearInterpol                   | 0.25003937        | 0.28125438             |
-+----------------------------------+-------------------+------------------------+
-| MultiLinearInterpol              | 0.18676           | 0.2040086              |
-+----------------------------------+-------------------+------------------------+
-| Bitpacked                        | 0.31251436        | 0.3125                 |
-+----------------------------------+-------------------+------------------------+
-| Almost monotonically increasing  |                   |                        |
-+----------------------------------+-------------------+------------------------+
-| LinearInterpol                   | 0.14066513        | 0.1562544              |
-+----------------------------------+-------------------+------------------------+
-| MultiLinearInterpol              | 0.16335973        | 0.17275847             |
-+----------------------------------+-------------------+------------------------+
-| Bitpacked                        | 0.28126493        | 0.28125                |
-+----------------------------------+-------------------+------------------------+
-
-```

fastfield_codecs/benches/bench.rs

@@ -1,311 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-
-#[cfg(test)]
-mod tests {
-    use std::ops::RangeInclusive;
-    use std::sync::Arc;
-
-    use common::OwnedBytes;
-    use fastfield_codecs::*;
-    use rand::prelude::*;
-    use test::Bencher;
-
-    use super::*;
-
-    // Warning: this generates the same permutation at each call
-    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]));
-        permutation
-    }
-
-    // Warning: this generates the same permutation at each call
-    fn generate_permutation_gcd() -> Vec<u64> {
-        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 u32);
-            }
-            a
-        });
-    }
-
-    const FIFTY_PERCENT_RANGE: RangeInclusive<u64> = 1..=50;
-    const SINGLE_ITEM: u64 = 90;
-    const SINGLE_ITEM_RANGE: RangeInclusive<u64> = 90..=90;
-    const ONE_PERCENT_ITEM_RANGE: RangeInclusive<u64> = 49..=49;
-    fn get_data_50percent_item() -> Vec<u128> {
-        let mut rng = StdRng::from_seed([1u8; 32]);
-
-        let mut data = vec![];
-        for _ in 0..300_000 {
-            let val = rng.gen_range(1..=100);
-            data.push(val);
-        }
-        data.push(SINGLE_ITEM);
-
-        data.shuffle(&mut rng);
-        let data = data.iter().map(|el| *el as u128).collect::<Vec<_>>();
-        data
-    }
-    fn get_u128_column_random() -> Arc<dyn Column<u128>> {
-        let permutation = generate_random();
-        let permutation = permutation.iter().map(|el| *el as u128).collect::<Vec<_>>();
-        get_u128_column_from_data(&permutation)
-    }
-
-    fn get_u128_column_from_data(data: &[u128]) -> Arc<dyn Column<u128>> {
-        let mut out = vec![];
-        let iter_gen = || data.iter().cloned();
-        serialize_u128(iter_gen, data.len() as u32, &mut out).unwrap();
-        let out = OwnedBytes::new(out);
-        open_u128::<u128>(out).unwrap()
-    }
-
-    // U64 RANGE START
-    #[bench]
-    fn bench_intfastfield_getrange_u64_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                FIFTY_PERCENT_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_1percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                ONE_PERCENT_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                SINGLE_ITEM_RANGE,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u64_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let data = data.iter().map(|el| *el as u64).collect::<Vec<_>>();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(0..=u64::MAX, 0..data.len() as u32, &mut positions);
-            positions
-        });
-    }
-    // U64 RANGE END
-
-    // U128 RANGE START
-    #[bench]
-    fn bench_intfastfield_getrange_u128_50percent_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                *FIFTY_PERCENT_RANGE.start() as u128..=*FIFTY_PERCENT_RANGE.end() as u128,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_single_hit(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(
-                *SINGLE_ITEM_RANGE.start() as u128..=*SINGLE_ITEM_RANGE.end() as u128,
-                0..data.len() as u32,
-                &mut positions,
-            );
-            positions
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_getrange_u128_hit_all(b: &mut Bencher) {
-        let data = get_data_50percent_item();
-        let column = get_u128_column_from_data(&data);
-
-        b.iter(|| {
-            let mut positions = Vec::new();
-            column.get_docids_for_value_range(0..=u128::MAX, 0..data.len() as u32, &mut positions);
-            positions
-        });
-    }
-    // U128 RANGE END
-
-    #[bench]
-    fn bench_intfastfield_scan_all_fflookup_u128(b: &mut Bencher) {
-        let column = get_u128_column_random();
-
-        b.iter(|| {
-            let mut a = 0u128;
-            for i in 0u64..column.num_vals() as u64 {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_jumpy_stride5_u128(b: &mut Bencher) {
-        let column = get_u128_column_random();
-
-        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);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_stride7_vec(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        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) {
-        let permutation = generate_permutation();
-        let n = permutation.len();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0;
-            for i in (0..n / 7).map(|val| val * 7) {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_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 i in 0u32..n as u32 {
-                a += column.get_val(i);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_fflookup_gcd(b: &mut Bencher) {
-        let permutation = generate_permutation_gcd();
-        let n = permutation.len();
-        let column: Arc<dyn Column<u64>> = serialize_and_load(&permutation);
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0..n {
-                a += column.get_val(i as u32);
-            }
-            a
-        });
-    }
-
-    #[bench]
-    fn bench_intfastfield_scan_all_vec(b: &mut Bencher) {
-        let permutation = generate_permutation();
-        b.iter(|| {
-            let mut a = 0u64;
-            for i in 0..permutation.len() {
-                a += permutation[i as usize] as u64;
-            }
-            a
-        });
-    }
-}

fastfield_codecs/src/lib.rs

@@ -1,10 +0,0 @@
-#![warn(missing_docs)]
-#![cfg_attr(all(feature = "unstable", test), feature(test))]
-
-//! # `fastfield_codecs`
-//!
-//! - Columnar storage of data for tantivy [`Column`].
-//! - Encode data in different codecs.
-//! - Monotonically map values to u64/u128
-
-pub use columnar::ColumnValues as Column;

src/collector/filter_collector_wrapper.rs

@@ -12,8 +12,7 @@
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use columnar::{DynamicColumn, HasAssociatedColumnType};
-use fastfield_codecs::Column;
+use columnar::{ColumnValues, DynamicColumn, HasAssociatedColumnType};
 
 use crate::collector::{Collector, SegmentCollector};
 use crate::schema::Field;
@@ -152,7 +151,7 @@ where
     TPredicate: 'static,
     DynamicColumn: Into<Option<columnar::Column<TPredicateValue>>>,
 {
-    fast_field_reader: Arc<dyn Column<TPredicateValue>>,
+    fast_field_reader: Arc<dyn ColumnValues<TPredicateValue>>,
     segment_collector: TSegmentCollector,
     predicate: TPredicate,
     t_predicate_value: PhantomData<TPredicateValue>,

src/collector/histogram_collector.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
+use columnar::ColumnValues;
 use fastdivide::DividerU64;
-use fastfield_codecs::Column;
 
 use crate::collector::{Collector, SegmentCollector};
 use crate::fastfield::{FastFieldNotAvailableError, FastValue};
@@ -87,7 +87,7 @@ impl HistogramComputer {
 }
 pub struct SegmentHistogramCollector {
     histogram_computer: HistogramComputer,
-    column_u64: Arc<dyn Column<u64>>,
+    column_u64: Arc<dyn ColumnValues<u64>>,
 }
 
 impl SegmentCollector for SegmentHistogramCollector {

src/collector/tests.rs

@@ -1,12 +1,12 @@
 use std::sync::Arc;
 
-use fastfield_codecs::Column;
+use columnar::ColumnValues;
 
 use super::*;
 use crate::collector::{Count, FilterCollector, TopDocs};
 use crate::core::SegmentReader;
 use crate::query::{AllQuery, QueryParser};
-use crate::schema::{Field, Schema, FAST, TEXT};
+use crate::schema::{Schema, FAST, TEXT};
 use crate::time::format_description::well_known::Rfc3339;
 use crate::time::OffsetDateTime;
 use crate::{doc, DateTime, DocAddress, DocId, Document, Index, Score, Searcher, SegmentOrdinal};
@@ -160,7 +160,7 @@ pub struct FastFieldTestCollector {
 
 pub struct FastFieldSegmentCollector {
     vals: Vec<u64>,
-    reader: Arc<dyn Column<u64>>,
+    reader: Arc<dyn columnar::ColumnValues>,
 }
 
 impl FastFieldTestCollector {

src/collector/top_score_collector.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use fastfield_codecs::Column;
+use columnar::ColumnValues;
 
 use super::Collector;
 use crate::collector::custom_score_top_collector::CustomScoreTopCollector;
@@ -14,7 +14,6 @@ use crate::collector::{
 };
 use crate::fastfield::{FastFieldNotAvailableError, FastValue};
 use crate::query::Weight;
-use crate::schema::Field;
 use crate::{DocAddress, DocId, Score, SegmentOrdinal, SegmentReader, TantivyError};
 
 struct FastFieldConvertCollector<
@@ -133,7 +132,7 @@ impl fmt::Debug for TopDocs {
 }
 
 struct ScorerByFastFieldReader {
-    sort_column: Arc<dyn Column<u64>>,
+    sort_column: Arc<dyn ColumnValues<u64>>,
 }
 
 impl CustomSegmentScorer<u64> for ScorerByFastFieldReader {

src/directory/composite_file.rs

@@ -22,7 +22,7 @@ impl FileAddr {
 }
 
 impl BinarySerializable for FileAddr {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         self.field.serialize(writer)?;
         VInt(self.idx as u64).serialize(writer)?;
         Ok(())

src/fastfield/mod.rs

@@ -21,8 +21,8 @@
 
 use std::net::Ipv6Addr;
 
+pub use columnar::Column;
 use columnar::MonotonicallyMappableToU64;
-pub use fastfield_codecs::Column;
 
 pub use self::alive_bitset::{intersect_alive_bitsets, write_alive_bitset, AliveBitSet};
 pub use self::error::{FastFieldNotAvailableError, Result};
@@ -137,10 +137,8 @@ fn value_to_u64(value: &Value) -> crate::Result<u64> {
 #[cfg(test)]
 mod tests {
 
-    use std::collections::HashMap;
-    use std::ops::{Range, RangeInclusive};
+    use std::ops::RangeInclusive;
     use std::path::Path;
-    use std::sync::Arc;
 
     use common::{HasLen, TerminatingWrite};
     use once_cell::sync::Lazy;
@@ -191,7 +189,7 @@ mod tests {
         }
         let file = directory.open_read(path).unwrap();
 
-        assert_eq!(file.len(), 157);
+        assert_eq!(file.len(), 161);
         let fast_field_readers = FastFieldReaders::open(file).unwrap();
         let column = fast_field_readers.u64("field").unwrap();
         assert_eq!(column.get_val(0), 13u64);
@@ -238,7 +236,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 185);
+        assert_eq!(file.len(), 189);
         let fast_field_readers = FastFieldReaders::open(file).unwrap();
         let col = fast_field_readers.u64("field").unwrap();
         assert_eq!(col.get_val(0), 4u64);
@@ -268,7 +266,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 158);
+        assert_eq!(file.len(), 162);
         let fast_field_readers = FastFieldReaders::open(file).unwrap();
         let fast_field_reader = fast_field_readers.u64("field").unwrap();
         for doc in 0..10_000 {
@@ -297,7 +295,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 80166);
+        assert_eq!(file.len(), 4557);
         {
             let fast_field_readers = FastFieldReaders::open(file).unwrap();
             let col = fast_field_readers.u64("field").unwrap();
@@ -327,7 +325,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 329_usize);
+        assert_eq!(file.len(), 333_usize);
 
         {
             let fast_field_readers = FastFieldReaders::open(file).unwrap();
@@ -795,7 +793,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 171);
+        assert_eq!(file.len(), 175);
         let fast_field_readers = FastFieldReaders::open(file).unwrap();
         let bool_col = fast_field_readers.bool("field_bool").unwrap();
         assert_eq!(bool_col.get_val(0), true);
@@ -827,7 +825,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 183);
+        assert_eq!(file.len(), 187);
         let readers = FastFieldReaders::open(file).unwrap();
         let bool_col = readers.bool("field_bool").unwrap();
         for i in 0..25 {
@@ -852,7 +850,7 @@ mod tests {
             write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        assert_eq!(file.len(), 173);
+        assert_eq!(file.len(), 177);
         let fastfield_readers = FastFieldReaders::open(file).unwrap();
         let col = fastfield_readers.bool("field_bool").unwrap();
         assert_eq!(col.get_val(0), false);

src/fastfield/readers.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::io;
 use std::net::Ipv6Addr;
 use std::sync::Arc;
@@ -7,10 +6,9 @@ use columnar::{
     BytesColumn, ColumnType, ColumnValues, ColumnarReader, DynamicColumn, DynamicColumnHandle,
     HasAssociatedColumnType, StrColumn,
 };
-use fastfield_codecs::Column;
 
 use crate::directory::FileSlice;
-use crate::schema::{Field, Schema};
+use crate::schema::Schema;
 use crate::space_usage::{FieldUsage, PerFieldSpaceUsage};
 
 /// Provides access to all of the BitpackedFastFieldReader.
@@ -28,6 +26,10 @@ impl FastFieldReaders {
         Ok(FastFieldReaders { columnar })
     }
 
+    pub(crate) fn columnar(&self) -> &ColumnarReader {
+        self.columnar.as_ref()
+    }
+
     pub(crate) fn space_usage(&self, schema: &Schema) -> io::Result<PerFieldSpaceUsage> {
         let mut per_field_usages: Vec<FieldUsage> = Default::default();
         for (field, field_entry) in schema.fields() {
@@ -87,7 +89,10 @@ impl FastFieldReaders {
             .sum())
     }
 
-    pub fn typed_column_first_or_default<T>(&self, field: &str) -> crate::Result<Arc<dyn Column<T>>>
+    pub fn typed_column_first_or_default<T>(
+        &self,
+        field: &str,
+    ) -> crate::Result<Arc<dyn ColumnValues<T>>>
     where
         T: PartialOrd + Copy + HasAssociatedColumnType + Send + Sync + 'static,
         DynamicColumn: Into<Option<columnar::Column<T>>>,
@@ -119,7 +124,7 @@ impl FastFieldReaders {
     /// Returns the `ip` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.
-    pub fn ip_addr(&self, field: &str) -> crate::Result<Arc<dyn Column<Ipv6Addr>>> {
+    pub fn ip_addr(&self, field: &str) -> crate::Result<Arc<dyn ColumnValues<Ipv6Addr>>> {
         self.typed_column_first_or_default(field)
     }
 
@@ -157,21 +162,21 @@ impl FastFieldReaders {
     /// Returns the `i64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a i64 fast field, this method returns an Error.
-    pub fn i64(&self, field_name: &str) -> crate::Result<Arc<dyn Column<i64>>> {
+    pub fn i64(&self, field_name: &str) -> crate::Result<Arc<dyn ColumnValues<i64>>> {
         self.typed_column_first_or_default(field_name)
     }
 
     /// Returns the `f64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a f64 fast field, this method returns an Error.
-    pub fn f64(&self, field_name: &str) -> crate::Result<Arc<dyn Column<f64>>> {
+    pub fn f64(&self, field_name: &str) -> crate::Result<Arc<dyn ColumnValues<f64>>> {
         self.typed_column_first_or_default(field_name)
     }
 
     /// Returns the `bool` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a bool fast field, this method returns an Error.
-    pub fn bool(&self, field_name: &str) -> crate::Result<Arc<dyn Column<bool>>> {
+    pub fn bool(&self, field_name: &str) -> crate::Result<Arc<dyn ColumnValues<bool>>> {
         self.typed_column_first_or_default(field_name)
     }
 }

src/indexer/doc_id_mapping.rs

@@ -37,6 +37,11 @@ impl SegmentDocIdMapping {
     /// This flags means the segments are simply stacked in the order of their ordinal.
     /// e.g. [(0, 1), .. (n, 1), (0, 2)..., (m, 2)]
     ///
+    /// The different segment may present some deletes, in which case it is expressed by skipping a
+    /// `DocId`. [(0, 1), (0, 3)] <--- here doc_id=0 and doc_id=1 have been deleted
+    ///
+    /// Being trivial is equivalent to having the `new_doc_id_to_old_doc_addr` array sorted.
+    ///
     /// This allows for some optimization.
     pub(crate) fn is_trivial(&self) -> bool {
         self.is_trivial

src/indexer/merger.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use columnar::{ColumnValues, ColumnarReader, MergeRowOrder, StackMergeOrder};
 use itertools::Itertools;
 use measure_time::debug_time;
 
@@ -9,7 +10,7 @@ use crate::core::{Segment, SegmentReader};
 use crate::directory::WritePtr;
 use crate::docset::{DocSet, TERMINATED};
 use crate::error::DataCorruption;
-use crate::fastfield::{AliveBitSet, Column, FastFieldNotAvailableError};
+use crate::fastfield::{AliveBitSet, FastFieldNotAvailableError};
 use crate::fieldnorm::{FieldNormReader, FieldNormReaders, FieldNormsSerializer, FieldNormsWriter};
 use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
 // use crate::indexer::sorted_doc_id_multivalue_column::RemappedDocIdMultiValueColumn;
@@ -85,29 +86,6 @@ pub struct IndexMerger {
     max_doc: u32,
 }
 
-struct TermOrdinalMapping {
-    per_segment_new_term_ordinals: Vec<Vec<TermOrdinal>>,
-}
-
-impl TermOrdinalMapping {
-    fn new(max_term_ords: Vec<TermOrdinal>) -> TermOrdinalMapping {
-        TermOrdinalMapping {
-            per_segment_new_term_ordinals: max_term_ords
-                .into_iter()
-                .map(|max_term_ord| vec![TermOrdinal::default(); max_term_ord as usize])
-                .collect(),
-        }
-    }
-
-    fn register_from_to(&mut self, segment_ord: usize, from_ord: TermOrdinal, to_ord: TermOrdinal) {
-        self.per_segment_new_term_ordinals[segment_ord][from_ord as usize] = to_ord;
-    }
-
-    fn get_segment(&self, segment_ord: usize) -> &[TermOrdinal] {
-        &(self.per_segment_new_term_ordinals[segment_ord])[..]
-    }
-}
-
 struct DeltaComputer {
     buffer: Vec<u32>,
 }
@@ -244,67 +222,19 @@ impl IndexMerger {
     fn write_fast_fields(
         &self,
         fast_field_wrt: &mut WritePtr,
-        mut term_ord_mappings: HashMap<Field, TermOrdinalMapping>,
         doc_id_mapping: &SegmentDocIdMapping,
     ) -> crate::Result<()> {
-        debug_time!("wrie-fast-fields");
-        for (_field, field_entry) in self.schema.fields() {
-            if field_entry.is_fast() {
-                todo!();
-            }
+        debug_time!("write-fast-fields");
+        let columnars: Vec<&ColumnarReader> = self
+            .readers
+            .iter()
+            .map(|reader| reader.fast_fields().columnar())
+            .collect();
+        if !doc_id_mapping.is_trivial() {
+            todo!()
         }
-
-        // for (field, field_entry) in self.schema.fields() {
-        // let field_type = field_entry.field_type();
-        // match field_type {
-        // FieldType::Facet(_) | FieldType::Str(_) if field_type.is_fast() => {
-        // let term_ordinal_mapping = term_ord_mappings.remove(&field).expect(
-        // "Logic Error in Tantivy (Please report). Facet field should have required \
-        // a`term_ordinal_mapping`.",
-        // );
-        // self.write_term_id_fast_field(
-        // field,
-        // &term_ordinal_mapping,
-        // fast_field_serializer,
-        // doc_id_mapping,
-        // )?;
-        // }
-        // FieldType::U64(ref options)
-        // | FieldType::I64(ref options)
-        // | FieldType::F64(ref options)
-        // | FieldType::Bool(ref options) => {
-        // todo!()
-        // }
-        // FieldType::Date(ref options) => {
-        // if options.is_fast() {
-        // todo!();
-        // }
-        // Some(Cardinality::SingleValue) => {
-        //     self.write_single_fast_field(field, fast_field_serializer, doc_id_mapping)?;
-        // }
-        // Some(Cardinality::MultiValues) => {
-        //     self.write_multi_fast_field(field, fast_field_serializer, doc_id_mapping)?;
-        // }
-        // None => {}
-        // },
-        // FieldType::Bytes(byte_options) => {
-        // if byte_options.is_fast() {
-        // self.write_bytes_fast_field(field, fast_field_serializer, doc_id_mapping)?;
-        // }
-        // }
-        // FieldType::IpAddr(options) =>  {
-        // if options.is_fast() {
-        // todo!();
-        // }
-        // },
-        //
-        // FieldType::JsonObject(_) | FieldType::Facet(_) | FieldType::Str(_) => {
-        // We don't handle json fast field for the moment
-        // They can be implemented using what is done
-        // for facets in the future
-        // }
-        // }
-        // }
+        let merge_row_order = MergeRowOrder::Stack(StackMergeOrder::stack(&columnars[..]));
+        columnar::merge_columnar(&columnars[..], merge_row_order, fast_field_wrt)?;
         Ok(())
     }
 
@@ -334,7 +264,7 @@ impl IndexMerger {
     pub(crate) fn get_sort_field_accessor(
         reader: &SegmentReader,
         sort_by_field: &IndexSortByField,
-    ) -> crate::Result<Arc<dyn Column>> {
+    ) -> crate::Result<Arc<dyn ColumnValues>> {
         reader.schema().get_field(&sort_by_field.field)?;
         let value_accessor = reader
             .fast_fields()
@@ -348,7 +278,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, Arc<dyn ColumnValues>)>> {
         let reader_ordinal_and_field_accessors = self
             .readers
             .iter()
@@ -369,7 +299,7 @@ impl IndexMerger {
     /// doc_id.
     /// ReaderWithOrdinal will include the ordinal position of the
     /// reader in self.readers.
-    pub(crate) fn generate_doc_id_mapping(
+    pub(crate) fn generate_doc_id_mapping_with_sort_by_field(
         &self,
         sort_by_field: &IndexSortByField,
     ) -> crate::Result<SegmentDocIdMapping> {
@@ -449,7 +379,7 @@ impl IndexMerger {
         serializer: &mut InvertedIndexSerializer,
         fieldnorm_reader: Option<FieldNormReader>,
         doc_id_mapping: &SegmentDocIdMapping,
-    ) -> crate::Result<Option<TermOrdinalMapping>> {
+    ) -> crate::Result<()> {
         debug_time!("write-postings-for-field");
         let mut positions_buffer: Vec<u32> = Vec::with_capacity(1_000);
         let mut delta_computer = DeltaComputer::new();
@@ -469,14 +399,6 @@ impl IndexMerger {
             max_term_ords.push(terms.num_terms() as u64);
         }
 
-        let mut term_ord_mapping_opt = match field_type {
-            FieldType::Facet(_) => Some(TermOrdinalMapping::new(max_term_ords)),
-            FieldType::Str(options) if options.is_fast() => {
-                Some(TermOrdinalMapping::new(max_term_ords))
-            }
-            _ => None,
-        };
-
         let mut merged_terms = TermMerger::new(field_term_streams);
 
         // map from segment doc ids to the resulting merged segment doc id.
@@ -561,12 +483,6 @@ impl IndexMerger {
 
             let to_term_ord = field_serializer.new_term(term_bytes, total_doc_freq)?;
 
-            if let Some(ref mut term_ord_mapping) = term_ord_mapping_opt {
-                for (segment_ord, from_term_ord) in merged_terms.matching_segments() {
-                    term_ord_mapping.register_from_to(segment_ord, from_term_ord, to_term_ord);
-                }
-            }
-
             // We can now serialize this postings, by pushing each document to the
             // postings serializer.
             for (segment_ord, mut segment_postings) in
@@ -617,7 +533,7 @@ impl IndexMerger {
             field_serializer.close_term()?;
         }
         field_serializer.close()?;
-        Ok(term_ord_mapping_opt)
+        Ok(())
     }
 
     fn write_postings(
@@ -625,23 +541,20 @@ impl IndexMerger {
         serializer: &mut InvertedIndexSerializer,
         fieldnorm_readers: FieldNormReaders,
         doc_id_mapping: &SegmentDocIdMapping,
-    ) -> crate::Result<HashMap<Field, TermOrdinalMapping>> {
-        let mut term_ordinal_mappings = HashMap::new();
+    ) -> crate::Result<()> {
         for (field, field_entry) in self.schema.fields() {
             let fieldnorm_reader = fieldnorm_readers.get_field(field)?;
             if field_entry.is_indexed() {
-                if let Some(term_ordinal_mapping) = self.write_postings_for_field(
+                self.write_postings_for_field(
                     field,
                     field_entry.field_type(),
                     serializer,
                     fieldnorm_reader,
                     doc_id_mapping,
-                )? {
-                    term_ordinal_mappings.insert(field, term_ordinal_mapping);
-                }
+                );
             }
         }
-        Ok(term_ordinal_mappings)
+        Ok(())
     }
 
     fn write_storable_fields(
@@ -726,7 +639,7 @@ impl IndexMerger {
             if self.is_disjunct_and_sorted_on_sort_property(sort_by_field)? {
                 self.get_doc_id_from_concatenated_data()?
             } else {
-                self.generate_doc_id_mapping(sort_by_field)?
+                self.generate_doc_id_mapping_with_sort_by_field(sort_by_field)?
             }
         } else {
             self.get_doc_id_from_concatenated_data()?
@@ -740,17 +653,13 @@ impl IndexMerger {
             .segment()
             .open_read(SegmentComponent::FieldNorms)?;
         let fieldnorm_readers = FieldNormReaders::open(fieldnorm_data)?;
-        let term_ord_mappings = self.write_postings(
+        self.write_postings(
             serializer.get_postings_serializer(),
             fieldnorm_readers,
             &doc_id_mapping,
         )?;
         debug!("write-fastfields");
-        self.write_fast_fields(
-            serializer.get_fast_field_write(),
-            term_ord_mappings,
-            &doc_id_mapping,
-        )?;
+        self.write_fast_fields(serializer.get_fast_field_write(), &doc_id_mapping)?;
         debug!("write-storagefields");
         self.write_storable_fields(serializer.get_store_writer(), &doc_id_mapping)?;
         debug!("close-serializer");

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/postings/term_info.rs

@@ -39,7 +39,7 @@ impl FixedSize for TermInfo {
 }
 
 impl BinarySerializable for TermInfo {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         self.doc_freq.serialize(writer)?;
         (self.postings_range.start as u64).serialize(writer)?;
         self.posting_num_bytes().serialize(writer)?;

src/schema/document.rs

@@ -228,7 +228,7 @@ impl Document {
 }
 
 impl BinarySerializable for Document {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         let field_values = self.field_values();
         VInt(field_values.len() as u64).serialize(writer)?;
         for field_value in field_values {

src/schema/facet.rs

@@ -191,7 +191,7 @@ impl<'a, T: ?Sized + AsRef<str>> From<&'a T> for Facet {
 }
 
 impl BinarySerializable for Facet {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         <String as BinarySerializable>::serialize(&self.0, writer)
     }
 

src/schema/field.rs

@@ -23,7 +23,7 @@ impl Field {
 }
 
 impl BinarySerializable for Field {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         self.0.serialize(writer)
     }
 

src/schema/field_value.rs

@@ -36,7 +36,7 @@ impl From<FieldValue> for Value {
 }
 
 impl BinarySerializable for FieldValue {
-    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         self.field.serialize(writer)?;
         self.value.serialize(writer)
     }

src/schema/value.rs

@@ -344,7 +344,7 @@ mod binary_serialize {
     const TOK_STR_CODE: u8 = 0;
 
     impl BinarySerializable for Value {
-        fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+        fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
             match *self {
                 Value::Str(ref text) => {
                     TEXT_CODE.serialize(writer)?;

src/store/footer.rs

@@ -16,7 +16,7 @@ pub struct DocStoreFooter {
 /// - compressor id: 1 byte
 /// - reserved for future use: 15 bytes
 impl BinarySerializable for DocStoreFooter {
-    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+    fn serialize<W: io::Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
         BinarySerializable::serialize(&DOC_STORE_VERSION, writer)?;
         BinarySerializable::serialize(&self.offset, writer)?;
         BinarySerializable::serialize(&self.decompressor.get_id(), writer)?;

src/termdict/fst_termdict/term_info_store.rs

@@ -21,7 +21,7 @@ struct TermInfoBlockMeta {
 }
 
 impl BinarySerializable for TermInfoBlockMeta {
-    fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
+    fn serialize<W: Write + ?Sized>(&self, write: &mut W) -> io::Result<()> {
         self.offset.serialize(write)?;
         self.ref_term_info.serialize(write)?;
         write.write_all(&[
@@ -272,7 +272,7 @@ impl TermInfoStoreWriter {
         Ok(())
     }
 
-    pub fn serialize<W: io::Write>(&mut self, write: &mut W) -> io::Result<()> {
+    pub fn serialize<W: io::Write + ?Sized>(&mut self, write: &mut W) -> io::Result<()> {
         if !self.term_infos.is_empty() {
             self.flush_block()?;
         }

sstable/src/dictionary.rs

@@ -30,6 +30,7 @@ use crate::{BlockAddr, DeltaReader, Reader, SSTable, SSTableIndex, TermOrdinal,
 /// block boundary.
 ///
 /// (See also README.md)
+#[derive(Debug, Clone)]
 pub struct Dictionary<TSSTable: SSTable = VoidSSTable> {
     pub sstable_slice: FileSlice,
     pub sstable_index: SSTableIndex,

sstable/src/lib.rs

@@ -117,6 +117,7 @@ impl SSTable for MonotonicU64SSTable {
 /// `range_sstable[k1].end == range_sstable[k2].start`.
 ///
 /// The first range is not required to start at `0`.
+#[derive(Clone, Copy, Debug)]
 pub struct RangeSSTable;
 
 impl SSTable for RangeSSTable {

sstable/src/sstable_index.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{common_prefix_len, SSTableDataCorruption, TermOrdinal};
 
-#[derive(Default, Debug, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct SSTableIndex {
     blocks: Vec<BlockMeta>,
 }
@@ -75,7 +75,7 @@ pub struct BlockAddr {
     pub first_ordinal: u64,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct BlockMeta {
     /// Any byte string that is lexicographically greater or equal to
     /// the last key in the block,