Added solution to force the type of a column.

Cargo.toml

@@ -59,7 +59,6 @@ sstable = { version="0.1", path="./sstable", package ="tantivy-sstable", optiona
 stacker = { version="0.1", path="./stacker", package ="tantivy-stacker" }
 tantivy-query-grammar = { version= "0.19.0", path="./query-grammar" }
 tantivy-bitpacker = 		{ version= "0.3", path="./bitpacker" }
-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" }
@@ -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", "fastfield_codecs", "ownedbytes", "stacker", "sstable", "tokenizer-api"]
 
 # Following the "fail" crate best practises, we isolate
 # tests that define specific behavior in fail check points

README.md

@@ -41,7 +41,7 @@ Your mileage WILL vary depending on the nature of queries and their load.
 - SIMD integer compression when the platform/CPU includes the SSE2 instruction set
 - Single valued and multivalued u64, i64, and f64 fast fields (equivalent of doc values in Lucene)
 - `&[u8]` fast fields
-- Text, i64, u64, f64, dates, ip, bool, and hierarchical facet fields
+- Text, i64, u64, f64, dates, and hierarchical facet fields
 - Compressed document store (LZ4, Zstd, None, Brotli, Snap)
 - Range queries
 - Faceted search
@@ -80,21 +80,56 @@ There are many ways to support this project.
 # Contributing code
 
 We use the GitHub Pull Request workflow: reference a GitHub ticket and/or include a comprehensive commit message when opening a PR.
-Feel free to update CHANGELOG.md with your contribution.
 
 ## Tokenizer
 
 When implementing a tokenizer for tantivy depend on the `tantivy-tokenizer-api` crate.
 
+## Minimum supported Rust version
+
+Tantivy currently requires at least Rust 1.62 or later to compile.
+
 ## Clone and build locally
 
 Tantivy compiles on stable Rust.
 To check out and run tests, you can simply run:
 
 ```bash
-git clone https://github.com/quickwit-oss/tantivy.git
-cd tantivy
-cargo test
+    git clone https://github.com/quickwit-oss/tantivy.git
+    cd tantivy
+    cargo build
+```
+
+## Run tests
+
+Some tests will not run with just `cargo test` because of `fail-rs`.
+To run the tests exhaustively, run `./run-tests.sh`.
+
+## Debug
+
+You might find it useful to step through the programme with a debugger.
+
+### A failing test
+
+Make sure you haven't run `cargo clean` after the most recent `cargo test` or `cargo build` to guarantee that the `target/` directory exists. Use this bash script to find the name of the most recent debug build of Tantivy and run it under `rust-gdb`:
+
+```bash
+find target/debug/ -maxdepth 1 -executable -type f -name "tantivy*" -printf '%TY-%Tm-%Td %TT %p\n' | sort -r | cut -d " " -f 3 | xargs -I RECENT_DBG_TANTIVY rust-gdb RECENT_DBG_TANTIVY
+```
+
+Now that you are in `rust-gdb`, you can set breakpoints on lines and methods that match your source code and run the debug executable with flags that you normally pass to `cargo test` like this:
+
+```bash
+$gdb run --test-threads 1 --test $NAME_OF_TEST
+```
+
+### An example
+
+By default, `rustc` compiles everything in the `examples/` directory in debug mode. This makes it easy for you to make examples to reproduce bugs:
+
+```bash
+rust-gdb target/debug/examples/$EXAMPLE_NAME
+$ gdb run
 ```
 
 # Companies Using Tantivy

TODO.txt

@@ -1,18 +0,0 @@
-Make schema_builder API fluent.
-fix doc serialization and prevent compression problems
-
-u64 , etc. shoudl return Resutl<Option> now that we support optional missing a column is really not an error
-remove fastfield codecs
-ditch the first_or_default trick. if it is still useful, improve its implementation.
-rename FastFieldReaders::open to load
-
-
-remove fast field reader
-
-find a way to unify the two DateTime.
-readd type check in the filter wrapper
-
-add unit test on columnar list columns.
-
-make sure sort works
-

benches/index-bench.rs

@@ -34,7 +34,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let index = Index::create_in_ram(schema.clone());
             let index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let doc = schema.parse_document(doc_json).unwrap();
                     index_writer.add_document(doc).unwrap();
                 }
@@ -46,7 +46,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let index = Index::create_in_ram(schema.clone());
             let mut index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let doc = schema.parse_document(doc_json).unwrap();
                     index_writer.add_document(doc).unwrap();
                 }
@@ -59,7 +59,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let index = Index::create_in_ram(schema_with_store.clone());
             let index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let doc = schema.parse_document(doc_json).unwrap();
                     index_writer.add_document(doc).unwrap();
                 }
@@ -71,7 +71,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let index = Index::create_in_ram(schema_with_store.clone());
             let mut index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let doc = schema.parse_document(doc_json).unwrap();
                     index_writer.add_document(doc).unwrap();
                 }
@@ -85,7 +85,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let json_field = dynamic_schema.get_field("json").unwrap();
             let mut index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let json_val: serde_json::Map<String, serde_json::Value> =
                         serde_json::from_str(doc_json).unwrap();
                     let doc = tantivy::doc!(json_field=>json_val);
@@ -101,7 +101,7 @@ pub fn hdfs_index_benchmark(c: &mut Criterion) {
             let json_field = dynamic_schema.get_field("json").unwrap();
             let mut index_writer = index.writer_with_num_threads(1, 100_000_000).unwrap();
             for _ in 0..NUM_REPEATS {
-                for doc_json in HDFS_LOGS.trim().split('\n') {
+                for doc_json in HDFS_LOGS.trim().split("\n") {
                     let json_val: serde_json::Map<String, serde_json::Value> =
                         serde_json::from_str(doc_json).unwrap();
                     let doc = tantivy::doc!(json_field=>json_val);

bitpacker/Cargo.toml

@@ -15,7 +15,3 @@ homepage = "https://github.com/quickwit-oss/tantivy"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-
-[dev-dependencies]
-rand = "0.8"
-proptest = "1"

bitpacker/benches/bench.rs

@@ -4,39 +4,9 @@ extern crate test;
 
 #[cfg(test)]
 mod tests {
-    use rand::seq::IteratorRandom;
-    use rand::thread_rng;
-    use tantivy_bitpacker::{BitPacker, BitUnpacker, BlockedBitpacker};
+    use tantivy_bitpacker::BlockedBitpacker;
     use test::Bencher;
 
-    #[inline(never)]
-    fn create_bitpacked_data(bit_width: u8, num_els: u32) -> Vec<u8> {
-        let mut bitpacker = BitPacker::new();
-        let mut buffer = Vec::new();
-        for _ in 0..num_els {
-            // the values do not matter.
-            bitpacker.write(0u64, bit_width, &mut buffer).unwrap();
-            bitpacker.flush(&mut buffer).unwrap();
-        }
-        buffer
-    }
-
-    #[bench]
-    fn bench_bitpacking_read(b: &mut Bencher) {
-        let bit_width = 3;
-        let num_els = 1_000_000u32;
-        let bit_unpacker = BitUnpacker::new(bit_width);
-        let data = create_bitpacked_data(bit_width, num_els);
-        let idxs: Vec<u32> = (0..num_els).choose_multiple(&mut thread_rng(), 100_000);
-        b.iter(|| {
-            let mut out = 0u64;
-            for &idx in &idxs {
-                out = out.wrapping_add(bit_unpacker.get(idx, &data[..]));
-            }
-            out
-        });
-    }
-
     #[bench]
     fn bench_blockedbitp_read(b: &mut Bencher) {
         let mut blocked_bitpacker = BlockedBitpacker::new();
@@ -44,9 +14,9 @@ mod tests {
             blocked_bitpacker.add(val * val);
         }
         b.iter(|| {
-            let mut out = 0u64;
+            let mut out = 0;
             for val in 0..=21500 {
-                out = out.wrapping_add(blocked_bitpacker.get(val));
+                out = blocked_bitpacker.get(val);
             }
             out
         });

bitpacker/src/bitpacker.rs

@@ -56,31 +56,27 @@ impl BitPacker {
 
     pub fn close<TWrite: io::Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
         self.flush(output)?;
+        // Padding the write file to simplify reads.
+        output.write_all(&[0u8; 7])?;
         Ok(())
     }
 }
 
-#[derive(Clone, Debug, Default, Copy)]
+#[derive(Clone, Debug, Default)]
 pub struct BitUnpacker {
-    num_bits: u32,
+    num_bits: u64,
     mask: u64,
 }
 
 impl BitUnpacker {
-    /// Creates a bit unpacker, that assumes the same bitwidth for all values.
-    ///
-    /// The bitunpacker works by doing an unaligned read of 8 bytes.
-    /// For this reason, values of `num_bits` between
-    /// [57..63] are forbidden.
     pub fn new(num_bits: u8) -> BitUnpacker {
-        assert!(num_bits <= 7 * 8 || num_bits == 64);
         let mask: u64 = if num_bits == 64 {
             !0u64
         } else {
             (1u64 << num_bits) - 1u64
         };
         BitUnpacker {
-            num_bits: u32::from(num_bits),
+            num_bits: u64::from(num_bits),
             mask,
         }
     }
@@ -91,40 +87,28 @@ impl BitUnpacker {
 
     #[inline]
     pub fn get(&self, idx: u32, data: &[u8]) -> u64 {
-        let addr_in_bits = idx * self.num_bits;
-        let addr = (addr_in_bits >> 3) as usize;
-        if addr + 8 > data.len() {
-            if self.num_bits == 0 {
-                return 0;
-            }
-            let bit_shift = addr_in_bits & 7;
-            return self.get_slow_path(addr, bit_shift, data);
+        if self.num_bits == 0 {
+            return 0u64;
         }
+        let addr_in_bits = idx * self.num_bits as u32;
+        let addr = (addr_in_bits >> 3) as usize;
         let bit_shift = addr_in_bits & 7;
+        debug_assert!(
+            addr + 8 <= data.len(),
+            "The fast field field should have been padded with 7 bytes."
+        );
         let bytes: [u8; 8] = (&data[addr..addr + 8]).try_into().unwrap();
         let val_unshifted_unmasked: u64 = u64::from_le_bytes(bytes);
         let val_shifted = val_unshifted_unmasked >> bit_shift;
         val_shifted & self.mask
     }
-
-    #[inline(never)]
-    fn get_slow_path(&self, addr: usize, bit_shift: u32, data: &[u8]) -> u64 {
-        let mut bytes: [u8; 8] = [0u8; 8];
-        let available_bytes = data.len() - addr;
-        // This function is meant to only be called if we did not have 8 bytes to load.
-        debug_assert!(available_bytes < 8);
-        bytes[..available_bytes].copy_from_slice(&data[addr..]);
-        let val_unshifted_unmasked: u64 = u64::from_le_bytes(bytes);
-        let val_shifted = val_unshifted_unmasked >> bit_shift;
-        val_shifted & self.mask
-    }
 }
 
 #[cfg(test)]
 mod test {
     use super::{BitPacker, BitUnpacker};
 
-    fn create_bitpacker(len: usize, num_bits: u8) -> (BitUnpacker, Vec<u64>, Vec<u8>) {
+    fn create_fastfield_bitpacker(len: usize, num_bits: u8) -> (BitUnpacker, Vec<u64>, Vec<u8>) {
         let mut data = Vec::new();
         let mut bitpacker = BitPacker::new();
         let max_val: u64 = (1u64 << num_bits as u64) - 1u64;
@@ -135,13 +119,13 @@ mod test {
             bitpacker.write(val, num_bits, &mut data).unwrap();
         }
         bitpacker.close(&mut data).unwrap();
-        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8);
+        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8 + 7);
         let bitunpacker = BitUnpacker::new(num_bits);
         (bitunpacker, vals, data)
     }
 
     fn test_bitpacker_util(len: usize, num_bits: u8) {
-        let (bitunpacker, vals, data) = create_bitpacker(len, num_bits);
+        let (bitunpacker, vals, data) = create_fastfield_bitpacker(len, num_bits);
         for (i, val) in vals.iter().enumerate() {
             assert_eq!(bitunpacker.get(i as u32, &data), *val);
         }
@@ -155,49 +139,4 @@ mod test {
         test_bitpacker_util(6, 14);
         test_bitpacker_util(1000, 14);
     }
-
-    use proptest::prelude::*;
-
-    fn num_bits_strategy() -> impl Strategy<Value = u8> {
-        prop_oneof!(Just(0), Just(1), 2u8..56u8, Just(56), Just(64),)
-    }
-
-    fn vals_strategy() -> impl Strategy<Value = (u8, Vec<u64>)> {
-        (num_bits_strategy(), 0usize..100usize).prop_flat_map(|(num_bits, len)| {
-            let max_val = if num_bits == 64 {
-                u64::MAX
-            } else {
-                (1u64 << num_bits as u32) - 1
-            };
-            let vals = proptest::collection::vec(0..=max_val, len);
-            vals.prop_map(move |vals| (num_bits, vals))
-        })
-    }
-
-    fn test_bitpacker_aux(num_bits: u8, vals: &[u64]) {
-        let mut buffer: Vec<u8> = Vec::new();
-        let mut bitpacker = BitPacker::new();
-        for &val in vals {
-            bitpacker.write(val, num_bits, &mut buffer).unwrap();
-        }
-        bitpacker.flush(&mut buffer).unwrap();
-        assert_eq!(buffer.len(), (vals.len() * num_bits as usize + 7) / 8);
-        let bitunpacker = BitUnpacker::new(num_bits);
-        let max_val = if num_bits == 64 {
-            u64::MAX
-        } else {
-            (1u64 << num_bits) - 1
-        };
-        for (i, val) in vals.iter().copied().enumerate() {
-            assert!(val <= max_val);
-            assert_eq!(bitunpacker.get(i as u32, &buffer), val);
-        }
-    }
-
-    proptest::proptest! {
-        #[test]
-        fn test_bitpacker_proptest((num_bits, vals) in vals_strategy()) {
-            test_bitpacker_aux(num_bits, &vals);
-        }
-    }
 }

columnar/Cargo.toml

@@ -24,5 +24,9 @@ proptest = "1"
 more-asserts = "0.3.0"
 rand = "0.8.3"
 
+# temporary
+[workspace]
+members = []
+
 [features]
 unstable = []

columnar/Makefile

@@ -1,6 +0,0 @@
-test:
-	echo "Run test only... No examples."
-	cargo test --tests --lib
-
-fmt:
-	cargo +nightly fmt --all

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/src/TODO.md

@@ -9,9 +9,6 @@
     - indexing
     - aggregations
     - merge
-* replug facets
-* replug range queries
-+ mutlivaued range queries restrat frm the beginning all of the time.
 
 # Perf and Size
 * re-add ZSTD compression for dictionaries
@@ -29,7 +26,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
@@ -39,13 +35,6 @@ remove all  doc_id occurences -> row_id
 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
-
 
 # Other
 fix enhance column-cli
@@ -53,3 +42,4 @@ fix enhance column-cli
 # Santa claus
 
 autodetect datetime ipaddr, plug customizable tokenizer.
+

columnar/src/column/dictionary_encoded.rs

@@ -5,16 +5,9 @@ use std::sync::Arc;
 use sstable::{Dictionary, VoidSSTable};
 
 use crate::column::Column;
-use crate::RowId;
+use crate::column_index::ColumnIndex;
 
 /// Dictionary encoded column.
-///
-/// The column simply gives access to a regular u64-column that, in
-/// which the values are term-ordinals.
-///
-/// These ordinals are ids uniquely identify the bytes that are stored in
-/// the column. These ordinals are small, and sorted in the same order
-/// as the term_ord_column.
 #[derive(Clone)]
 pub struct BytesColumn {
     pub(crate) dictionary: Arc<Dictionary<VoidSSTable>>,
@@ -22,69 +15,26 @@ pub struct BytesColumn {
 }
 
 impl BytesColumn {
-    /// Fills the given `output` buffer with the term associated to the ordinal `ord`.
-    ///
     /// Returns `false` if the term does not exist (e.g. `term_ord` is greater or equal to the
     /// overll number of terms).
-    pub fn ord_to_bytes(&self, ord: u64, output: &mut Vec<u8>) -> io::Result<bool> {
-        self.dictionary.ord_to_term(ord, output)
+    pub fn term_ord_to_str(&self, term_ord: u64, output: &mut Vec<u8>) -> io::Result<bool> {
+        self.dictionary.ord_to_term(term_ord, output)
     }
 
-    /// Returns the number of rows in the column.
-    pub fn num_rows(&self) -> RowId {
-        self.term_ord_column.num_rows()
-    }
-
-    pub fn term_ords(&self, row_id: RowId) -> impl Iterator<Item = u64> + '_ {
-        self.term_ord_column.values(row_id)
-    }
-
-    /// Returns the column of ordinals
-    pub fn ords(&self) -> &Column<u64> {
+    pub fn term_ords(&self) -> &Column<u64> {
         &self.term_ord_column
     }
-
-    pub fn num_terms(&self) -> usize {
-        self.dictionary.num_terms()
-    }
-
-    pub fn dictionary(&self) -> &Dictionary<VoidSSTable> {
-        self.dictionary.as_ref()
-    }
 }
 
-#[derive(Clone)]
-pub struct StrColumn(BytesColumn);
-
-impl From<BytesColumn> for StrColumn {
-    fn from(bytes_col: BytesColumn) -> Self {
-        StrColumn(bytes_col)
-    }
-}
-
-impl StrColumn {
-    /// 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)?;
-            // TODO consider remove checks if it hurts performance.
-            if std::str::from_utf8(buf.as_slice()).is_err() {
-                buf.clear();
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidData,
-                    "Not valid utf-8",
-                ));
-            }
-        }
-        Ok(true)
-    }
-}
-
-impl Deref for StrColumn {
-    type Target = BytesColumn;
+impl Deref for BytesColumn {
+    type Target = ColumnIndex<'static>;
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        &**self.term_ords()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{ColumnarReader, ColumnarWriter};
+}

columnar/src/column/mod.rs

@@ -1,16 +1,12 @@
 mod dictionary_encoded;
 mod serialize;
 
-use std::fmt::Debug;
 use std::ops::Deref;
 use std::sync::Arc;
 
 use common::BinarySerializable;
-pub use dictionary_encoded::{BytesColumn, StrColumn};
-pub use serialize::{
-    open_column_bytes, open_column_u128, open_column_u64, serialize_column_mappable_to_u128,
-    serialize_column_mappable_to_u64,
-};
+pub use dictionary_encoded::BytesColumn;
+pub use serialize::{open_column_bytes, open_column_u64, serialize_column_u64};
 
 use crate::column_index::ColumnIndex;
 use crate::column_values::ColumnValues;
@@ -18,50 +14,29 @@ use crate::{Cardinality, RowId};
 
 #[derive(Clone)]
 pub struct Column<T> {
-    pub idx: ColumnIndex,
+    pub idx: ColumnIndex<'static>,
     pub values: Arc<dyn ColumnValues<T>>,
 }
 
-impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
-    pub fn num_rows(&self) -> RowId {
+use crate::column_index::Set;
+
+impl<T: PartialOrd> Column<T> {
+    pub fn first(&self, row_id: RowId) -> Option<T> {
         match &self.idx {
-            ColumnIndex::Full => self.values.num_vals() as u32,
-            ColumnIndex::Optional(optional_index) => optional_index.num_rows(),
-            ColumnIndex::Multivalued(col_index) => {
-                // The multivalued index contains all value start row_id,
-                // and one extra value at the end with the overall number of rows.
-                col_index.num_rows()
+            ColumnIndex::Full => Some(self.values.get_val(row_id)),
+            ColumnIndex::Optional(opt_idx) => {
+                let value_row_idx = opt_idx.rank_if_exists(row_id)?;
+                Some(self.values.get_val(value_row_idx))
+            }
+            ColumnIndex::Multivalued(_multivalued_index) => {
+                todo!();
             }
         }
     }
-
-    pub fn min_value(&self) -> T {
-        self.values.min_value()
-    }
-
-    pub fn max_value(&self) -> T {
-        self.values.max_value()
-    }
-
-    pub fn first(&self, row_id: RowId) -> Option<T> {
-        self.values(row_id).next()
-    }
-
-    pub fn values(&self, row_id: RowId) -> impl Iterator<Item = T> + '_ {
-        self.value_row_ids(row_id)
-            .map(|value_row_id: RowId| self.values.get_val(value_row_id))
-    }
-
-    pub fn first_or_default_col(self, default_value: T) -> Arc<dyn ColumnValues<T>> {
-        Arc::new(FirstValueWithDefault {
-            column: self,
-            default_value,
-        })
-    }
 }
 
 impl<T> Deref for Column<T> {
-    type Target = ColumnIndex;
+    type Target = ColumnIndex<'static>;
 
     fn deref(&self) -> &Self::Target {
         &self.idx
@@ -79,33 +54,3 @@ impl BinarySerializable for Cardinality {
         Ok(cardinality)
     }
 }
-
-// TODO simplify or optimize
-struct FirstValueWithDefault<T: Copy> {
-    column: Column<T>,
-    default_value: T,
-}
-
-impl<T: PartialOrd + Debug + Send + Sync + Copy + 'static> ColumnValues<T>
-    for FirstValueWithDefault<T>
-{
-    fn get_val(&self, idx: u32) -> T {
-        self.column.first(idx).unwrap_or(self.default_value)
-    }
-
-    fn min_value(&self) -> T {
-        self.column.values.min_value()
-    }
-
-    fn max_value(&self) -> T {
-        self.column.values.max_value()
-    }
-
-    fn num_vals(&self) -> u32 {
-        match &self.column.idx {
-            ColumnIndex::Full => self.column.values.num_vals(),
-            ColumnIndex::Optional(optional_idx) => optional_idx.num_rows(),
-            ColumnIndex::Multivalued(_) => todo!(),
-        }
-    }
-}

columnar/src/column/serialize.rs

@@ -1,53 +1,25 @@
-use std::fmt::Debug;
 use std::io;
 use std::io::Write;
 use std::sync::Arc;
 
-use common::OwnedBytes;
+use common::{CountingWriter, OwnedBytes};
 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,
+    serialize_column_values, ColumnValues, MonotonicallyMappableToU64, ALL_CODEC_TYPES,
 };
-
-pub fn serialize_column_mappable_to_u128<
-    F: Fn() -> I,
-    I: Iterator<Item = T>,
-    T: MonotonicallyMappableToU128,
->(
-    column_index: SerializableColumnIndex<'_>,
-    column_values: F,
-    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,
-    )?;
-    output.write_all(&column_index_num_bytes.to_le_bytes())?;
-    Ok(())
-}
-
-pub fn serialize_column_mappable_to_u64<T: MonotonicallyMappableToU64 + Debug>(
+pub fn serialize_column_u64<T: MonotonicallyMappableToU64>(
     column_index: SerializableColumnIndex<'_>,
     column_values: &impl ColumnValues<T>,
     output: &mut impl Write,
 ) -> io::Result<()> {
-    let column_index_num_bytes = serialize_column_index(column_index, output)?;
-    serialize_column_values(
-        column_values,
-        &[
-            FastFieldCodecType::Bitpacked,
-            FastFieldCodecType::BlockwiseLinear,
-        ],
-        output,
-    )?;
+    let mut counting_writer = CountingWriter::wrap(output);
+    serialize_column_index(column_index, &mut counting_writer)?;
+    let column_index_num_bytes = counting_writer.written_bytes() as u32;
+    let output = counting_writer.finish();
+    serialize_column_values(column_values, &ALL_CODEC_TYPES[..], output)?;
     output.write_all(&column_index_num_bytes.to_le_bytes())?;
     Ok(())
 }
@@ -69,34 +41,14 @@ pub fn open_column_u64<T: MonotonicallyMappableToU64>(bytes: OwnedBytes) -> io::
     })
 }
 
-pub fn open_column_u128<T: MonotonicallyMappableToU128>(
-    bytes: OwnedBytes,
-) -> io::Result<Column<T>> {
-    let (body, column_index_num_bytes_payload) = bytes.rsplit(4);
-    let column_index_num_bytes = u32::from_le_bytes(
-        column_index_num_bytes_payload
-            .as_slice()
-            .try_into()
-            .unwrap(),
-    );
-    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_u128_mapped(column_values_data)?;
-    Ok(Column {
-        idx: column_index,
-        values: column_values,
-    })
-}
-
-pub fn open_column_bytes<T: From<BytesColumn>>(data: OwnedBytes) -> io::Result<T> {
+pub fn open_column_bytes(data: OwnedBytes) -> io::Result<BytesColumn> {
     let (body, dictionary_len_bytes) = data.rsplit(4);
     let dictionary_len = u32::from_le_bytes(dictionary_len_bytes.as_slice().try_into().unwrap());
     let (dictionary_bytes, column_bytes) = body.split(dictionary_len as usize);
     let dictionary = Arc::new(Dictionary::from_bytes(dictionary_bytes)?);
     let term_ord_column = crate::column::open_column_u64::<u64>(column_bytes)?;
-    let bytes_column = BytesColumn {
+    Ok(BytesColumn {
         dictionary,
         term_ord_column,
-    };
-    Ok(bytes_column.into())
+    })
 }

columnar/src/column_index/mod.rs

@@ -2,24 +2,24 @@ mod multivalued_index;
 mod optional_index;
 mod serialize;
 
-use std::ops::Range;
+use std::sync::Arc;
 
 pub use optional_index::{OptionalIndex, SerializableOptionalIndex, Set};
 pub use serialize::{open_column_index, serialize_column_index, SerializableColumnIndex};
 
-use crate::column_index::multivalued_index::MultiValueIndex;
+use crate::column_values::ColumnValues;
 use crate::{Cardinality, RowId};
 
 #[derive(Clone)]
-pub enum ColumnIndex {
+pub enum ColumnIndex<'a> {
     Full,
     Optional(OptionalIndex),
-    /// In addition, at index num_rows, an extra value is added
-    /// containing the overal number of values.
-    Multivalued(MultiValueIndex),
+    // TODO remove the Arc<dyn> apart from serialization this is not
+    // dynamic at all.
+    Multivalued(Arc<dyn ColumnValues<RowId> + 'a>),
 }
 
-impl ColumnIndex {
+impl<'a> ColumnIndex<'a> {
     pub fn get_cardinality(&self) -> Cardinality {
         match self {
             ColumnIndex::Full => Cardinality::Full,
@@ -28,33 +28,13 @@ impl ColumnIndex {
         }
     }
 
-    pub fn value_row_ids(&self, row_id: RowId) -> Range<RowId> {
-        match self {
-            ColumnIndex::Full => row_id..row_id + 1,
-            ColumnIndex::Optional(optional_index) => {
-                if let Some(val) = optional_index.rank_if_exists(row_id) {
-                    val..val + 1
-                } else {
-                    0..0
-                }
-            }
-            ColumnIndex::Multivalued(multivalued_index) => multivalued_index.range(row_id),
-        }
-    }
-
-    pub fn select_batch_in_place(&self, rank_ids: &mut Vec<RowId>) {
+    pub fn num_rows(&self) -> RowId {
         match self {
             ColumnIndex::Full => {
-                // No need to do anything:
-                // value_idx and row_idx are the same.
-            }
-            ColumnIndex::Optional(optional_index) => {
-                optional_index.select_batch(&mut rank_ids[..]);
-            }
-            ColumnIndex::Multivalued(multivalued_index) => {
-                // TODO important: avoid using 0u32, and restart from the beginning all of the time.
-                multivalued_index.select_batch_in_place(0u32, rank_ids)
+                todo!()
             }
+            ColumnIndex::Optional(optional_index) => optional_index.num_rows(),
+            ColumnIndex::Multivalued(multivalued_index) => multivalued_index.num_vals() - 1,
         }
     }
 }

columnar/src/column_index/multivalued_index.rs

@@ -1,6 +1,5 @@
 use std::io;
 use std::io::Write;
-use std::ops::Range;
 use std::sync::Arc;
 
 use common::OwnedBytes;
@@ -8,125 +7,21 @@ use common::OwnedBytes;
 use crate::column_values::{ColumnValues, FastFieldCodecType};
 use crate::RowId;
 
+#[derive(Clone)]
+pub struct MultivaluedIndex(Arc<dyn ColumnValues<RowId>>);
+
 pub fn serialize_multivalued_index(
-    multivalued_index: &dyn ColumnValues<RowId>,
+    multivalued_index: MultivaluedIndex,
     output: &mut impl Write,
 ) -> io::Result<()> {
     crate::column_values::serialize_column_values(
-        &*multivalued_index,
+        &*multivalued_index.0,
         &[FastFieldCodecType::Bitpacked, FastFieldCodecType::Linear],
         output,
     )?;
     Ok(())
 }
 
-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)?;
-    Ok(MultiValueIndex { start_index_column })
-}
-
-#[derive(Clone)]
-/// Index to resolve value range for given doc_id.
-/// Starts at 0.
-pub struct MultiValueIndex {
-    start_index_column: Arc<dyn crate::ColumnValues<RowId>>,
-}
-
-impl From<Arc<dyn ColumnValues<RowId>>> for MultiValueIndex {
-    fn from(start_index_column: Arc<dyn ColumnValues<RowId>>) -> Self {
-        MultiValueIndex { start_index_column }
-    }
-}
-
-impl MultiValueIndex {
-    /// Returns `[start, end)`, such that the values associated with
-    /// the given document are `start..end`.
-    #[inline]
-    pub(crate) fn range(&self, row_id: RowId) -> Range<RowId> {
-        let start = self.start_index_column.get_val(row_id);
-        let end = self.start_index_column.get_val(row_id + 1);
-        start..end
-    }
-
-    /// Returns the number of documents in the index.
-    #[inline]
-    pub fn num_rows(&self) -> u32 {
-        self.start_index_column.num_vals() - 1
-    }
-
-    /// Converts a list of ranks (row ids of values) in a 1:n index to the corresponding list of
-    /// row_ids. Positions are converted inplace to docids.
-    ///
-    /// Since there is no index for value pos -> docid, but docid -> value pos range, we scan the
-    /// index.
-    ///
-    /// Correctness: positions needs to be sorted. idx_reader needs to contain monotonically
-    /// increasing positions.
-    ///
-    /// TODO: Instead of a linear scan we can employ a exponential search into binary search to
-    /// match a docid to its value position.
-    #[allow(clippy::bool_to_int_with_if)]
-    pub(crate) fn select_batch_in_place(&self, row_start: RowId, ranks: &mut Vec<u32>) {
-        if ranks.is_empty() {
-            return;
-        }
-        let mut cur_doc = row_start;
-        let mut last_doc = None;
-
-        assert!(self.start_index_column.get_val(row_start) as u32 <= ranks[0]);
-
-        let mut write_doc_pos = 0;
-        for i in 0..ranks.len() {
-            let pos = ranks[i];
-            loop {
-                let end = self.start_index_column.get_val(cur_doc + 1) as u32;
-                if end > pos {
-                    ranks[write_doc_pos] = cur_doc;
-                    write_doc_pos += if last_doc == Some(cur_doc) { 0 } else { 1 };
-                    last_doc = Some(cur_doc);
-                    break;
-                }
-                cur_doc += 1;
-            }
-        }
-        ranks.truncate(write_doc_pos);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::ops::Range;
-    use std::sync::Arc;
-
-    use super::MultiValueIndex;
-    use crate::column_values::IterColumn;
-    use crate::{ColumnValues, RowId};
-
-    fn index_to_pos_helper(
-        index: &MultiValueIndex,
-        doc_id_range: Range<u32>,
-        positions: &[u32],
-    ) -> Vec<u32> {
-        let mut positions = positions.to_vec();
-        index.select_batch_in_place(doc_id_range.start, &mut positions);
-        positions
-    }
-
-    #[test]
-    fn test_positions_to_docid() {
-        let offsets: Vec<RowId> = vec![0, 10, 12, 15, 22, 23]; // docid values are [0..10, 10..12, 12..15, etc.]
-        let column: Arc<dyn ColumnValues<RowId>> = Arc::new(IterColumn::from(offsets.into_iter()));
-        let index = MultiValueIndex::from(column);
-        assert_eq!(index.num_rows(), 5);
-        let positions = &[10u32, 11, 15, 20, 21, 22];
-        assert_eq!(index_to_pos_helper(&index, 0..5, positions), vec![1, 3, 4]);
-        assert_eq!(index_to_pos_helper(&index, 1..5, positions), vec![1, 3, 4]);
-        assert_eq!(index_to_pos_helper(&index, 0..5, &[9]), vec![0]);
-        assert_eq!(index_to_pos_helper(&index, 1..5, &[10]), vec![1]);
-        assert_eq!(index_to_pos_helper(&index, 1..5, &[11]), vec![1]);
-        assert_eq!(index_to_pos_helper(&index, 2..5, &[12]), vec![2]);
-        assert_eq!(index_to_pos_helper(&index, 2..5, &[12, 14]), vec![2]);
-        assert_eq!(index_to_pos_helper(&index, 2..5, &[12, 14, 15]), vec![2, 3]);
-    }
+pub fn open_multivalued_index(bytes: OwnedBytes) -> io::Result<Arc<dyn ColumnValues<RowId>>> {
+    todo!();
 }

columnar/src/column_index/optional_index/mod.rs

@@ -5,8 +5,8 @@ use std::sync::Arc;
 mod set;
 mod set_block;
 
-use common::{BinarySerializable, OwnedBytes, VInt};
-pub use set::{SelectCursor, Set, SetCodec};
+use common::{BinarySerializable, GroupByIteratorExtended, OwnedBytes, VInt};
+pub use set::{Set, SetCodec};
 use set_block::{
     DenseBlock, DenseBlockCodec, SparseBlock, SparseBlockCodec, DENSE_BLOCK_NUM_BYTES,
 };
@@ -115,63 +115,7 @@ fn row_addr_from_row_id(row_id: RowId) -> RowAddr {
     }
 }
 
-enum BlockSelectCursor<'a> {
-    Dense(<DenseBlock<'a> as Set<u16>>::SelectCursor<'a>),
-    Sparse(<SparseBlock<'a> as Set<u16>>::SelectCursor<'a>),
-}
-
-impl<'a> BlockSelectCursor<'a> {
-    fn select(&mut self, rank: u16) -> u16 {
-        match self {
-            BlockSelectCursor::Dense(dense_select_cursor) => dense_select_cursor.select(rank),
-            BlockSelectCursor::Sparse(sparse_select_cursor) => sparse_select_cursor.select(rank),
-        }
-    }
-}
-pub struct OptionalIndexSelectCursor<'a> {
-    current_block_cursor: BlockSelectCursor<'a>,
-    current_block_id: u16,
-    // The current block is guaranteed to contain ranks < end_rank.
-    current_block_end_rank: RowId,
-    optional_index: &'a OptionalIndex,
-    block_doc_idx_start: RowId,
-    num_null_rows_before_block: RowId,
-}
-
-impl<'a> OptionalIndexSelectCursor<'a> {
-    fn search_and_load_block(&mut self, rank: RowId) {
-        if rank < self.current_block_end_rank {
-            // we are already in the right block
-            return;
-        }
-        self.current_block_id = self.optional_index.find_block(rank, self.current_block_id);
-        self.current_block_end_rank = self
-            .optional_index
-            .block_metas
-            .get(self.current_block_id as usize + 1)
-            .map(|block_meta| block_meta.non_null_rows_before_block)
-            .unwrap_or(u32::MAX);
-        self.block_doc_idx_start = (self.current_block_id as u32) * ELEMENTS_PER_BLOCK;
-        let block_meta = self.optional_index.block_metas[self.current_block_id as usize];
-        self.num_null_rows_before_block = block_meta.non_null_rows_before_block;
-        let block: Block<'_> = self.optional_index.block(block_meta);
-        self.current_block_cursor = match block {
-            Block::Dense(dense_block) => BlockSelectCursor::Dense(dense_block.select_cursor()),
-            Block::Sparse(sparse_block) => BlockSelectCursor::Sparse(sparse_block.select_cursor()),
-        };
-    }
-}
-
-impl<'a> SelectCursor<RowId> for OptionalIndexSelectCursor<'a> {
-    fn select(&mut self, rank: RowId) -> RowId {
-        self.search_and_load_block(rank);
-        let index_in_block = (rank - self.num_null_rows_before_block) as u16;
-        self.current_block_cursor.select(index_in_block) as RowId + self.block_doc_idx_start
-    }
-}
-
 impl Set<RowId> for OptionalIndex {
-    type SelectCursor<'b> = OptionalIndexSelectCursor<'b> where Self: 'b;
     // Check if value at position is not null.
     #[inline]
     fn contains(&self, row_id: RowId) -> bool {
@@ -204,7 +148,7 @@ impl Set<RowId> for OptionalIndex {
     #[inline]
     fn select(&self, rank: RowId) -> RowId {
         let block_pos = self.find_block(rank, 0);
-        let block_doc_idx_start = (block_pos as u32) * ELEMENTS_PER_BLOCK;
+        let block_doc_idx_start = block_pos * ELEMENTS_PER_BLOCK;
         let block_meta = self.block_metas[block_pos as usize];
         let block: Block<'_> = self.block(block_meta);
         let index_in_block = (rank - block_meta.non_null_rows_before_block) as u16;
@@ -215,28 +159,39 @@ impl Set<RowId> for OptionalIndex {
         block_doc_idx_start + in_block_rank as u32
     }
 
-    fn select_cursor<'b>(&'b self) -> OptionalIndexSelectCursor<'b> {
-        OptionalIndexSelectCursor {
-            current_block_cursor: BlockSelectCursor::Sparse(
-                SparseBlockCodec::open(b"").select_cursor(),
-            ),
-            current_block_id: 0u16,
-            current_block_end_rank: 0u32, //< this is sufficient to force the first load
-            optional_index: self,
-            block_doc_idx_start: 0u32,
-            num_null_rows_before_block: 0u32,
+    fn select_batch(&self, ranks: &[u32], output_idxs: &mut [u32]) {
+        let mut block_pos = 0u32;
+        let mut start = 0;
+        let group_by_it = ranks.iter().copied().group_by(move |codec_idx| {
+            block_pos = self.find_block(*codec_idx, block_pos);
+            block_pos
+        });
+        for (block_pos, block_iter) in group_by_it {
+            let block_doc_idx_start = block_pos * ELEMENTS_PER_BLOCK;
+            let block_meta = self.block_metas[block_pos as usize];
+            let block: Block<'_> = self.block(block_meta);
+            let offset = block_meta.non_null_rows_before_block;
+            let indexes_in_block_iter =
+                block_iter.map(move |codec_idx| (codec_idx - offset) as u16);
+            match block {
+                Block::Dense(dense_block) => {
+                    for in_offset in dense_block.select_iter(indexes_in_block_iter) {
+                        output_idxs[start] = in_offset as u32 + block_doc_idx_start;
+                        start += 1;
+                    }
+                }
+                Block::Sparse(sparse_block) => {
+                    for in_offset in sparse_block.select_iter(indexes_in_block_iter) {
+                        output_idxs[start] = in_offset as u32 + block_doc_idx_start;
+                        start += 1;
+                    }
+                }
+            };
         }
     }
 }
 
 impl OptionalIndex {
-    pub fn select_batch(&self, ranks: &mut [RowId]) {
-        let mut select_cursor = self.select_cursor();
-        for rank in ranks.iter_mut() {
-            *rank = select_cursor.select(*rank);
-        }
-    }
-
     #[inline]
     fn block<'a>(&'a self, block_meta: BlockMeta) -> Block<'a> {
         let BlockMeta {
@@ -259,14 +214,14 @@ impl OptionalIndex {
     }
 
     #[inline]
-    fn find_block(&self, dense_idx: u32, start_block_pos: u16) -> u16 {
-        for block_pos in start_block_pos..self.block_metas.len() as u16 {
+    fn find_block(&self, dense_idx: u32, start_block_pos: u32) -> u32 {
+        for block_pos in start_block_pos..self.block_metas.len() as u32 {
             let offset = self.block_metas[block_pos as usize].non_null_rows_before_block;
             if offset > dense_idx {
-                return block_pos - 1u16;
+                return block_pos - 1;
             }
         }
-        self.block_metas.len() as u16 - 1u16
+        self.block_metas.len() as u32 - 1u32
     }
 
     // TODO Add a good API for the codec_idx to original_idx translation.

columnar/src/column_index/optional_index/set.rs

@@ -13,18 +13,7 @@ pub trait SetCodec {
     fn open<'a>(data: &'a [u8]) -> Self::Reader<'a>;
 }
 
-/// Stateful object that makes it possible to compute several select in a row,
-/// provided the rank passed as argument are increasing.
-pub trait SelectCursor<T> {
-    // May panic if rank is greater than the number of elements in the Set,
-    // or if rank is < than value provided in the previous call.
-    fn select(&mut self, rank: T) -> T;
-}
-
 pub trait Set<T> {
-    type SelectCursor<'b>: SelectCursor<T>
-    where Self: 'b;
-
     /// Returns true if the elements is contained in the Set
     fn contains(&self, el: T) -> bool;
 
@@ -39,6 +28,11 @@ pub trait Set<T> {
     /// May panic if rank is greater than the number of elements in the Set.
     fn select(&self, rank: T) -> T;
 
-    /// Creates a brand new select cursor.
-    fn select_cursor<'b>(&'b self) -> Self::SelectCursor<'b>;
+    /// Batch version of select.
+    /// `ranks` is assumed to be sorted.
+    ///
+    /// # Panics
+    ///
+    /// May panic if rank is greater than the number of elements in the Set.
+    fn select_batch(&self, ranks: &[T], outputs: &mut [T]);
 }

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

@@ -1,7 +1,7 @@
-mod dense;
+mod set_block;
 mod sparse;
 
-pub use dense::{DenseBlock, DenseBlockCodec, DENSE_BLOCK_NUM_BYTES};
+pub use set_block::{DenseBlock, DenseBlockCodec, DENSE_BLOCK_NUM_BYTES};
 pub use sparse::{SparseBlock, SparseBlockCodec};
 
 #[cfg(test)]

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

@@ -3,7 +3,7 @@ use std::io::{self, Write};
 
 use common::BinarySerializable;
 
-use crate::column_index::optional_index::{SelectCursor, Set, SetCodec, ELEMENTS_PER_BLOCK};
+use crate::column_index::optional_index::{Set, SetCodec, ELEMENTS_PER_BLOCK};
 
 #[inline(always)]
 fn get_bit_at(input: u64, n: u16) -> bool {
@@ -105,27 +105,7 @@ impl DenseMiniBlock {
 #[derive(Copy, Clone)]
 pub struct DenseBlock<'a>(&'a [u8]);
 
-pub struct DenseBlockSelectCursor<'a> {
-    block_id: u16,
-    dense_block: DenseBlock<'a>,
-}
-
-impl<'a> SelectCursor<u16> for DenseBlockSelectCursor<'a> {
-    #[inline]
-    fn select(&mut self, rank: u16) -> u16 {
-        self.block_id = self
-            .dense_block
-            .find_miniblock_containing_rank(rank, self.block_id)
-            .unwrap();
-        let index_block = self.dense_block.mini_block(self.block_id);
-        let in_block_rank = rank - index_block.rank;
-        self.block_id * ELEMENTS_PER_MINI_BLOCK + select_u64(index_block.bitvec, in_block_rank)
-    }
-}
-
 impl<'a> Set<u16> for DenseBlock<'a> {
-    type SelectCursor<'b> = DenseBlockSelectCursor<'a> where Self: 'b;
-
     #[inline(always)]
     fn contains(&self, el: u16) -> bool {
         let mini_block_id = el / ELEMENTS_PER_MINI_BLOCK;
@@ -156,15 +136,37 @@ impl<'a> Set<u16> for DenseBlock<'a> {
         block_id * ELEMENTS_PER_MINI_BLOCK + select_u64(index_block.bitvec, in_block_rank)
     }
 
-    #[inline(always)]
-    fn select_cursor<'b>(&'b self) -> Self::SelectCursor<'b> {
-        DenseBlockSelectCursor {
-            block_id: 0,
-            dense_block: *self,
+    fn select_batch(&self, ranks: &[u16], outputs: &mut [u16]) {
+        let orig_ids = self.select_iter(ranks.iter().copied());
+        for (output, original_id) in outputs.iter_mut().zip(orig_ids) {
+            *output = original_id;
         }
     }
 }
 
+impl<'a> DenseBlock<'a> {
+    /// Iterator verison of select.
+    ///
+    /// # Panics
+    /// Panics if one of the rank is higher than the number of elements in the set.
+    pub fn select_iter<'b>(
+        &self,
+        rank_it: impl Iterator<Item = u16> + 'b,
+    ) -> impl Iterator<Item = u16> + 'b
+    where
+        Self: 'b,
+    {
+        let mut block_id = 0u16;
+        let me = *self;
+        rank_it.map(move |rank| {
+            block_id = me.find_miniblock_containing_rank(rank, block_id).unwrap();
+            let index_block = me.mini_block(block_id);
+            let in_block_rank = rank - index_block.rank;
+            block_id * ELEMENTS_PER_MINI_BLOCK + select_u64(index_block.bitvec, in_block_rank)
+        })
+    }
+}
+
 impl<'a> DenseBlock<'a> {
     #[inline]
     fn mini_block(&self, mini_block_id: u16) -> DenseMiniBlock {

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

@@ -1,4 +1,4 @@
-use crate::column_index::optional_index::{SelectCursor, Set, SetCodec};
+use crate::column_index::optional_index::{Set, SetCodec};
 
 pub struct SparseBlockCodec;
 
@@ -24,16 +24,7 @@ impl SetCodec for SparseBlockCodec {
 #[derive(Copy, Clone)]
 pub struct SparseBlock<'a>(&'a [u8]);
 
-impl<'a> SelectCursor<u16> for SparseBlock<'a> {
-    #[inline]
-    fn select(&mut self, rank: u16) -> u16 {
-        <SparseBlock<'a> as Set<u16>>::select(self, rank)
-    }
-}
-
 impl<'a> Set<u16> for SparseBlock<'a> {
-    type SelectCursor<'b> = Self where Self: 'b;
-
     #[inline(always)]
     fn contains(&self, el: u16) -> bool {
         self.binary_search(el).is_ok()
@@ -50,9 +41,11 @@ impl<'a> Set<u16> for SparseBlock<'a> {
         u16::from_le_bytes(self.0[offset..offset + 2].try_into().unwrap())
     }
 
-    #[inline(always)]
-    fn select_cursor<'b>(&'b self) -> Self::SelectCursor<'b> {
-        *self
+    fn select_batch(&self, ranks: &[u16], outputs: &mut [u16]) {
+        let orig_ids = self.select_iter(ranks.iter().copied());
+        for (output, original_id) in outputs.iter_mut().zip(orig_ids) {
+            *output = original_id;
+        }
     }
 }
 
@@ -103,4 +96,17 @@ impl<'a> SparseBlock<'a> {
         }
         Err(left)
     }
+
+    pub fn select_iter<'b>(
+        &self,
+        iter: impl Iterator<Item = u16> + 'b,
+    ) -> impl Iterator<Item = u16> + 'b
+    where
+        Self: 'b,
+    {
+        iter.map(|codec_id| {
+            let offset = codec_id as usize * 2;
+            u16::from_le_bytes(self.0[offset..offset + 2].try_into().unwrap())
+        })
+    }
 }

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

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
-use crate::column_index::optional_index::set_block::dense::DENSE_BLOCK_NUM_BYTES;
+use crate::column_index::optional_index::set_block::set_block::DENSE_BLOCK_NUM_BYTES;
 use crate::column_index::optional_index::set_block::{DenseBlockCodec, SparseBlockCodec};
-use crate::column_index::optional_index::{SelectCursor, Set, SetCodec};
+use crate::column_index::optional_index::{Set, SetCodec};
 
 fn test_set_helper<C: SetCodec<Item = u16>>(vals: &[u16]) -> usize {
     let mut buffer = Vec::new();
@@ -51,7 +51,6 @@ fn test_sparse_block_set_u16_max() {
 use proptest::prelude::*;
 
 proptest! {
-    #![proptest_config(ProptestConfig::with_cases(1))]
     #[test]
     fn test_prop_test_dense(els in proptest::collection::btree_set(0..=u16::MAX, 0..=u16::MAX as usize)) {
         let vals: Vec<u16> = els.into_iter().collect();
@@ -74,10 +73,12 @@ fn test_simple_translate_codec_codec_idx_to_original_idx_dense() {
         .unwrap();
     let tested_set = DenseBlockCodec::open(buffer.as_slice());
     assert!(tested_set.contains(1));
-    let mut select_cursor = tested_set.select_cursor();
-    assert_eq!(select_cursor.select(0), 1);
-    assert_eq!(select_cursor.select(1), 3);
-    assert_eq!(select_cursor.select(2), 17);
+    assert_eq!(
+        &tested_set
+            .select_iter([0, 1, 2, 5].iter().copied())
+            .collect::<Vec<u16>>(),
+        &[1, 3, 17, 30_001]
+    );
 }
 
 #[test]
@@ -86,10 +87,12 @@ fn test_simple_translate_codec_idx_to_original_idx_sparse() {
     SparseBlockCodec::serialize([1, 3, 17].iter().copied(), &mut buffer).unwrap();
     let tested_set = SparseBlockCodec::open(buffer.as_slice());
     assert!(tested_set.contains(1));
-    let mut select_cursor = tested_set.select_cursor();
-    assert_eq!(SelectCursor::select(&mut select_cursor, 0), 1);
-    assert_eq!(SelectCursor::select(&mut select_cursor, 1), 3);
-    assert_eq!(SelectCursor::select(&mut select_cursor, 2), 17);
+    assert_eq!(
+        &tested_set
+            .select_iter([0, 1, 2].iter().copied())
+            .collect::<Vec<u16>>(),
+        &[1, 3, 17]
+    );
 }
 
 #[test]
@@ -98,8 +101,10 @@ fn test_simple_translate_codec_idx_to_original_idx_dense() {
     DenseBlockCodec::serialize(0u16..150u16, &mut buffer).unwrap();
     let tested_set = DenseBlockCodec::open(buffer.as_slice());
     assert!(tested_set.contains(1));
-    let mut select_cursor = tested_set.select_cursor();
-    for i in 0..150 {
-        assert_eq!(i, select_cursor.select(i));
-    }
+    let rg = 0u16..150u16;
+    let els: Vec<u16> = rg.clone().collect();
+    assert_eq!(
+        &tested_set.select_iter(rg.clone()).collect::<Vec<u16>>(),
+        &els
+    );
 }

columnar/src/column_index/optional_index/tests.rs

@@ -41,10 +41,9 @@ fn test_with_random_sets_simple() {
     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();
-    let mut select_cursor = null_index.select_cursor();
-    for (rank, el) in ranks.iter().copied().zip(els.iter().copied()) {
-        assert_eq!(select_cursor.select(rank), el);
-    }
+    let mut output = vec![0u32; ranks.len()];
+    null_index.select_batch(&ranks[..], &mut output[..]);
+    assert_eq!(&output, &els);
 }
 
 #[test]
@@ -92,10 +91,11 @@ fn test_null_index(data: &[bool]) {
         .filter(|(_pos, val)| **val)
         .map(|(pos, _val)| pos as u32)
         .collect();
-    let mut select_iter = null_index.select_cursor();
-    for i in 0..orig_idx_with_value.len() {
-        assert_eq!(select_iter.select(i as u32), orig_idx_with_value[i]);
-    }
+    let ids: Vec<u32> = (0..orig_idx_with_value.len() as u32).collect();
+    let mut output = vec![0u32; ids.len()];
+    null_index.select_batch(&ids[..], &mut output);
+    // assert_eq!(&output[0..100], &orig_idx_with_value[0..100]);
+    assert_eq!(output, orig_idx_with_value);
 
     let step_size = (orig_idx_with_value.len() / 100).max(1);
     for (dense_idx, orig_idx) in orig_idx_with_value.iter().enumerate().step_by(step_size) {
@@ -115,9 +115,9 @@ fn test_optional_index_test_translation() {
     let iter = &[true, false, true, false];
     serialize_optional_index(&&iter[..], &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);
-    assert_eq!(select_cursor.select(1), 2);
+    let mut output = vec![0u32; 2];
+    null_index.select_batch(&[0, 1], &mut output);
+    assert_eq!(output, &[0, 2]);
 }
 
 #[test]
@@ -175,6 +175,7 @@ mod bench {
             .map(|_| rng.gen_bool(fill_ratio))
             .collect();
         serialize_optional_index(&&vals[..], &mut out).unwrap();
+
         let codec = open_optional_index(OwnedBytes::new(out)).unwrap();
         codec
     }
@@ -310,8 +311,7 @@ mod bench {
         };
         let mut output = vec![0u32; idxs.len()];
         bench.iter(|| {
-            output.copy_from_slice(&idxs[..]);
-            codec.select_batch(&mut output);
+            codec.select_batch(&idxs[..], &mut output);
         });
     }
 

columnar/src/column_index/serialize.rs

@@ -1,20 +1,19 @@
 use std::io;
 use std::io::Write;
 
-use common::{CountingWriter, OwnedBytes};
+use common::OwnedBytes;
 
-use crate::column_index::multivalued_index::serialize_multivalued_index;
+use crate::column_index::multivalued_index::{serialize_multivalued_index, MultivaluedIndex};
 use crate::column_index::optional_index::serialize_optional_index;
 use crate::column_index::{ColumnIndex, SerializableOptionalIndex};
-use crate::column_values::ColumnValues;
-use crate::{Cardinality, RowId};
+use crate::Cardinality;
 
 pub enum SerializableColumnIndex<'a> {
     Full,
     Optional(Box<dyn SerializableOptionalIndex<'a> + 'a>),
     // TODO remove the Arc<dyn> apart from serialization this is not
     // dynamic at all.
-    Multivalued(Box<dyn ColumnValues<RowId> + 'a>),
+    Multivalued(MultivaluedIndex),
 }
 
 impl<'a> SerializableColumnIndex<'a> {
@@ -30,24 +29,22 @@ impl<'a> SerializableColumnIndex<'a> {
 pub fn serialize_column_index(
     column_index: SerializableColumnIndex,
     output: &mut impl Write,
-) -> io::Result<u32> {
-    let mut output = CountingWriter::wrap(output);
+) -> io::Result<()> {
     let cardinality = column_index.get_cardinality().to_code();
     output.write_all(&[cardinality])?;
     match column_index {
         SerializableColumnIndex::Full => {}
         SerializableColumnIndex::Optional(optional_index) => {
-            serialize_optional_index(&*optional_index, &mut output)?
+            serialize_optional_index(&*optional_index, output)?
         }
         SerializableColumnIndex::Multivalued(multivalued_index) => {
-            serialize_multivalued_index(&*multivalued_index, &mut output)?
+            serialize_multivalued_index(multivalued_index, output)?
         }
     }
-    let column_index_num_bytes = output.written_bytes() as u32;
-    Ok(column_index_num_bytes)
+    Ok(())
 }
 
-pub fn open_column_index(mut bytes: OwnedBytes) -> io::Result<ColumnIndex> {
+pub fn open_column_index(mut bytes: OwnedBytes) -> io::Result<ColumnIndex<'static>> {
     if bytes.is_empty() {
         return Err(io::Error::new(
             io::ErrorKind::UnexpectedEof,
@@ -64,8 +61,8 @@ pub fn open_column_index(mut bytes: OwnedBytes) -> io::Result<ColumnIndex> {
             Ok(ColumnIndex::Optional(optional_index))
         }
         Cardinality::Multivalued => {
-            let multivalue_index = super::multivalued_index::open_multivalued_index(bytes)?;
-            Ok(ColumnIndex::Multivalued(multivalue_index))
+            let multivalued_index = super::multivalued_index::open_multivalued_index(bytes)?;
+            Ok(ColumnIndex::Multivalued(multivalued_index))
         }
     }
 }

columnar/src/column_values/column.rs

@@ -1,4 +1,3 @@
-use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Range, RangeInclusive};
 
@@ -9,7 +8,7 @@ use crate::column_values::monotonic_mapping::StrictlyMonotonicFn;
 /// `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.
@@ -45,6 +44,7 @@ pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
         positions: &mut Vec<u32>,
     ) {
         let doc_id_range = doc_id_range.start..doc_id_range.end.min(self.num_vals());
+
         for idx in doc_id_range.start..doc_id_range.end {
             let val = self.get_val(idx);
             if value_range.contains(&val) {
@@ -78,33 +78,7 @@ pub trait ColumnValues<T: PartialOrd + Debug = u64>: Send + Sync {
     }
 }
 
-impl<T: Copy + PartialOrd + Debug> ColumnValues<T> for std::sync::Arc<dyn ColumnValues<T>> {
-    fn get_val(&self, idx: u32) -> T {
-        self.as_ref().get_val(idx)
-    }
-
-    fn min_value(&self) -> T {
-        self.as_ref().min_value()
-    }
-
-    fn max_value(&self) -> T {
-        self.as_ref().max_value()
-    }
-
-    fn num_vals(&self) -> u32 {
-        self.as_ref().num_vals()
-    }
-
-    fn iter<'b>(&'b self) -> Box<dyn Iterator<Item = T> + 'b> {
-        self.as_ref().iter()
-    }
-
-    fn get_range(&self, start: u64, output: &mut [T]) {
-        self.as_ref().get_range(start, output)
-    }
-}
-
-impl<'a, C: ColumnValues<T> + ?Sized, T: Copy + PartialOrd + Debug> ColumnValues<T> for &'a C {
+impl<'a, C: ColumnValues<T> + ?Sized, T: Copy + PartialOrd> ColumnValues<T> for &'a C {
     fn get_val(&self, idx: u32) -> T {
         (*self).get_val(idx)
     }
@@ -137,7 +111,7 @@ pub struct VecColumn<'a, T = u64> {
     pub(crate) max_value: T,
 }
 
-impl<'a, T: Copy + PartialOrd + Send + Sync + Debug> ColumnValues<T> for VecColumn<'a, T> {
+impl<'a, T: Copy + PartialOrd + Send + Sync> ColumnValues<T> for VecColumn<'a, T> {
     fn get_val(&self, position: u32) -> T {
         self.values[position as usize]
     }
@@ -205,8 +179,8 @@ pub fn monotonic_map_column<C, T, Input, Output>(
 where
     C: ColumnValues<Input>,
     T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
-    Input: PartialOrd + Debug + Send + Sync + Clone,
-    Output: PartialOrd + Debug + Send + Sync + Clone,
+    Input: PartialOrd + Send + Sync + Clone,
+    Output: PartialOrd + Send + Sync + Clone,
 {
     MonotonicMappingColumn {
         from_column,
@@ -219,8 +193,8 @@ impl<C, T, Input, Output> ColumnValues<Output> for MonotonicMappingColumn<C, T,
 where
     C: ColumnValues<Input>,
     T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
-    Input: PartialOrd + Send + Debug + Sync + Clone,
-    Output: PartialOrd + Send + Debug + Sync + Clone,
+    Input: PartialOrd + Send + Sync + Clone,
+    Output: PartialOrd + Send + Sync + Clone,
 {
     #[inline]
     fn get_val(&self, idx: u32) -> Output {
@@ -282,7 +256,7 @@ where T: Iterator + Clone + ExactSizeIterator
 impl<T> ColumnValues<T::Item> for IterColumn<T>
 where
     T: Iterator + Clone + ExactSizeIterator + Send + Sync,
-    T::Item: PartialOrd + Debug,
+    T::Item: PartialOrd,
 {
     fn get_val(&self, idx: u32) -> T::Item {
         self.0.clone().nth(idx as usize).unwrap()

columnar/src/column_values/column_with_cardinality.rs

@@ -0,0 +1,19 @@
+// Copyright (C) 2022 Quickwit, Inc.
+//
+// Quickwit is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at hello@quickwit.io.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//

columnar/src/column_values/mod.rs

@@ -10,19 +10,16 @@
 #[cfg(test)]
 mod tests;
 
-use std::fmt::Debug;
 use std::io;
 use std::io::Write;
 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,
 };
-pub use monotonic_mapping_u128::MonotonicallyMappableToU128;
 use serialize::{Header, U128Header};
 
 mod bitpacked;
@@ -31,16 +28,17 @@ mod compact_space;
 mod line;
 mod linear;
 pub(crate) mod monotonic_mapping;
-pub(crate) mod monotonic_mapping_u128;
+// mod monotonic_mapping_u128;
 
 mod column;
+mod column_with_cardinality;
 mod gcd;
 pub mod serialize;
 
 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};
+pub use self::monotonic_mapping::{MonotonicallyMappableToU64, StrictlyMonotonicFn};
+// pub use self::monotonic_mapping_u128::MonotonicallyMappableToU128;
+pub use self::serialize::{serialize_and_load, serialize_column_values, NormalizedHeader};
 use crate::column_values::bitpacked::BitpackedCodec;
 use crate::column_values::blockwise_linear::BlockwiseLinearCodec;
 use crate::column_values::linear::LinearCodec;
@@ -124,20 +122,22 @@ impl U128FastFieldCodecType {
 }
 
 /// Returns the correct codec reader wrapped in the `Arc` for the data.
-pub fn open_u128_mapped<T: MonotonicallyMappableToU128 + Debug>(
-    mut bytes: OwnedBytes,
-) -> io::Result<Arc<dyn ColumnValues<T>>> {
-    let header = U128Header::deserialize(&mut bytes)?;
-    assert_eq!(header.codec_type, U128FastFieldCodecType::CompactSpace);
-    let reader = CompactSpaceDecompressor::open(bytes)?;
-
-    let inverted: StrictlyMonotonicMappingInverter<StrictlyMonotonicMappingToInternal<T>> =
-        StrictlyMonotonicMappingToInternal::<T>::new().into();
-    Ok(Arc::new(monotonic_map_column(reader, inverted)))
-}
+// pub fn open_u128<Item: MonotonicallyMappableToU128>(
+//     bytes: OwnedBytes,
+// ) -> io::Result<Arc<dyn Column<Item>>> {
+//     todo!();
+//     // let (bytes, _format_version) = read_format_version(bytes)?;
+//     // let (mut bytes, _null_index_footer) = read_null_index_footer(bytes)?;
+//     // let header = U128Header::deserialize(&mut bytes)?;
+//     // assert_eq!(header.codec_type, U128FastFieldCodecType::CompactSpace);
+//     // let reader = CompactSpaceDecompressor::open(bytes)?;
+//     // let inverted: StrictlyMonotonicMappingInverter<StrictlyMonotonicMappingToInternal<Item>> =
+//     //     StrictlyMonotonicMappingToInternal::<Item>::new().into();
+//     // 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>(
+pub fn open_u64_mapped<T: MonotonicallyMappableToU64>(
     mut bytes: OwnedBytes,
 ) -> io::Result<Arc<dyn ColumnValues<T>>> {
     let header = Header::deserialize(&mut bytes)?;
@@ -150,7 +150,7 @@ pub fn open_u64_mapped<T: MonotonicallyMappableToU64 + Debug>(
     }
 }
 
-fn open_specific_codec<C: FastFieldCodec, Item: MonotonicallyMappableToU64 + Debug>(
+fn open_specific_codec<C: FastFieldCodec, Item: MonotonicallyMappableToU64>(
     bytes: OwnedBytes,
     header: &Header,
 ) -> io::Result<Arc<dyn ColumnValues<Item>>> {
@@ -198,6 +198,13 @@ pub(crate) trait FastFieldCodec: 'static {
     fn estimate(column: &dyn ColumnValues) -> Option<f32>;
 }
 
+/// The list of all available codecs for u64 convertible data.
+pub const ALL_CODEC_TYPES: [FastFieldCodecType; 3] = [
+    FastFieldCodecType::Bitpacked,
+    FastFieldCodecType::BlockwiseLinear,
+    FastFieldCodecType::Linear,
+];
+
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
     use std::sync::Arc;

columnar/src/column_values/monotonic_mapping.rs

@@ -1,14 +1,12 @@
-use std::fmt::Debug;
 use std::marker::PhantomData;
 
 use fastdivide::DividerU64;
 
-use super::MonotonicallyMappableToU128;
 use crate::RowId;
 
 /// Monotonic maps a value to u64 value space.
 /// Monotonic mapping enables `PartialOrd` on u64 space without conversion to original space.
-pub trait MonotonicallyMappableToU64: 'static + PartialOrd + Debug + Copy + Send + Sync {
+pub trait MonotonicallyMappableToU64: 'static + PartialOrd + Copy + Send + Sync {
     /// Converts a value to u64.
     ///
     /// Internally all fast field values are encoded as u64.
@@ -82,20 +80,21 @@ impl<T> StrictlyMonotonicMappingToInternal<T> {
     }
 }
 
-impl<External: MonotonicallyMappableToU128, T: MonotonicallyMappableToU128>
-    StrictlyMonotonicFn<External, u128> for StrictlyMonotonicMappingToInternal<T>
-where T: MonotonicallyMappableToU128
-{
-    #[inline(always)]
-    fn mapping(&self, inp: External) -> u128 {
-        External::to_u128(inp)
-    }
+// TODO
+// impl<External: MonotonicallyMappableToU128, T: MonotonicallyMappableToU128>
+//     StrictlyMonotonicFn<External, u128> for StrictlyMonotonicMappingToInternal<T>
+// where T: MonotonicallyMappableToU128
+// {
+//     #[inline(always)]
+//     fn mapping(&self, inp: External) -> u128 {
+//         External::to_u128(inp)
+//     }
 
-    #[inline(always)]
-    fn inverse(&self, out: u128) -> External {
-        External::from_u128(out)
-    }
-}
+//     #[inline(always)]
+//     fn inverse(&self, out: u128) -> External {
+//         External::from_u128(out)
+//     }
+// }
 
 impl<External: MonotonicallyMappableToU64, T: MonotonicallyMappableToU64>
     StrictlyMonotonicFn<External, u64> for StrictlyMonotonicMappingToInternal<T>
@@ -195,20 +194,6 @@ impl MonotonicallyMappableToU64 for i64 {
     }
 }
 
-impl MonotonicallyMappableToU64 for crate::DateTime {
-    #[inline(always)]
-    fn to_u64(self) -> u64 {
-        common::i64_to_u64(self.timestamp_micros)
-    }
-
-    #[inline(always)]
-    fn from_u64(val: u64) -> Self {
-        crate::DateTime {
-            timestamp_micros: common::u64_to_i64(val),
-        }
-    }
-}
-
 impl MonotonicallyMappableToU64 for bool {
     #[inline(always)]
     fn to_u64(self) -> u64 {

columnar/src/column_values/monotonic_mapping_u128.rs

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

columnar/src/column_values/serialize.rs

@@ -1,8 +1,27 @@
-use std::fmt::Debug;
+// Copyright (C) 2022 Quickwit, Inc.
+//
+// Quickwit is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at hello@quickwit.io.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
 use std::io;
 use std::num::NonZeroU64;
+use std::sync::Arc;
 
-use common::{BinarySerializable, VInt};
+use common::{BinarySerializable, OwnedBytes, VInt};
 use log::warn;
 
 use super::bitpacked::BitpackedCodec;
@@ -14,9 +33,8 @@ use super::monotonic_mapping::{
 };
 use super::{
     monotonic_map_column, ColumnValues, FastFieldCodec, FastFieldCodecType,
-    MonotonicallyMappableToU64, U128FastFieldCodecType,
+    MonotonicallyMappableToU64, U128FastFieldCodecType, VecColumn, ALL_CODEC_TYPES,
 };
-use crate::column_values::compact_space::CompactSpaceCompressor;
 
 /// The normalized header gives some parameters after applying the following
 /// normalization of the vector:
@@ -142,25 +160,57 @@ impl BinarySerializable for Header {
     }
 }
 
-/// Serializes u128 values with the compact space codec.
-pub fn serialize_column_values_u128<F: Fn() -> I, I: Iterator<Item = u128>>(
-    iter_gen: F,
-    num_vals: u32,
-    output: &mut impl io::Write,
-) -> io::Result<()> {
-    let header = U128Header {
-        num_vals,
-        codec_type: U128FastFieldCodecType::CompactSpace,
-    };
-    header.serialize(output)?;
-    let compressor = CompactSpaceCompressor::train_from(iter_gen(), num_vals);
-    compressor.compress_into(iter_gen(), output)?;
-
-    Ok(())
+/// Return estimated compression for given codec in the value range [0.0..1.0], where 1.0 means no
+/// compression.
+pub(crate) fn estimate<T: MonotonicallyMappableToU64>(
+    typed_column: impl ColumnValues<T>,
+    codec_type: FastFieldCodecType,
+) -> Option<f32> {
+    let column = monotonic_map_column(typed_column, StrictlyMonotonicMappingToInternal::<T>::new());
+    let min_value = column.min_value();
+    let gcd = super::gcd::find_gcd(column.iter().map(|val| val - min_value))
+        .filter(|gcd| gcd.get() > 1u64);
+    let mapping = StrictlyMonotonicMappingToInternalGCDBaseval::new(
+        gcd.map(|gcd| gcd.get()).unwrap_or(1u64),
+        min_value,
+    );
+    let normalized_column = monotonic_map_column(&column, mapping);
+    match codec_type {
+        FastFieldCodecType::Bitpacked => BitpackedCodec::estimate(&normalized_column),
+        FastFieldCodecType::Linear => LinearCodec::estimate(&normalized_column),
+        FastFieldCodecType::BlockwiseLinear => BlockwiseLinearCodec::estimate(&normalized_column),
+    }
 }
 
+// TODO
+/// Serializes u128 values with the compact space codec.
+// pub fn serialize_u128_new<F: Fn() -> I, I: Iterator<Item = u128>>(
+//     value_index: ColumnIndex,
+//     iter_gen: F,
+//     num_vals: u32,
+//     output: &mut impl io::Write,
+// ) -> io::Result<()> {
+//     let header = U128Header {
+//         num_vals,
+//         codec_type: U128FastFieldCodecType::CompactSpace,
+//     };
+//     header.serialize(output)?;
+//     let compressor = CompactSpaceCompressor::train_from(iter_gen(), num_vals);
+//     compressor.compress_into(iter_gen(), output).unwrap();
+
+//     let null_index_footer = ColumnFooter {
+//         cardinality: value_index.get_cardinality(),
+//         null_index_codec: NullIndexCodec::Full,
+//         null_index_byte_range: 0..0,
+//     };
+//     append_null_index_footer(output, null_index_footer)?;
+//     append_format_version(output)?;
+
+//     Ok(())
+// }
+
 /// Serializes the column with the codec with the best estimate on the data.
-pub fn serialize_column_values<T: MonotonicallyMappableToU64 + Debug>(
+pub fn serialize_column_values<T: MonotonicallyMappableToU64>(
     typed_column: impl ColumnValues<T>,
     codecs: &[FastFieldCodecType],
     output: &mut impl io::Write,
@@ -229,29 +279,20 @@ pub(crate) fn serialize_given_codec(
     Ok(())
 }
 
+/// 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();
+    super::serialize_column_values(&VecColumn::from(&column), &ALL_CODEC_TYPES, &mut buffer)
+        .unwrap();
+    super::open_u64_mapped(OwnedBytes::new(buffer)).unwrap()
+}
+
 #[cfg(test)]
-pub mod tests {
-    use std::sync::Arc;
-
-    use common::OwnedBytes;
-
+mod tests {
     use super::*;
-    use crate::column_values::{open_u64_mapped, VecColumn};
 
-    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 {
@@ -278,7 +319,7 @@ pub mod tests {
         serialize_column_values(&col, &ALL_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);
+        assert_eq!(buffer.len(), 5 + 1 + 7);
     }
 
     #[test]
@@ -287,7 +328,7 @@ pub mod tests {
         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);
+        assert_eq!(buffer.len(), 5 + 7);
     }
 
     #[test]
@@ -297,6 +338,6 @@ pub mod tests {
         let col = VecColumn::from(&vals[..]);
         serialize_column_values(&col, &[FastFieldCodecType::Bitpacked], &mut buffer).unwrap();
         // Values are stored over 3 bits.
-        assert_eq!(buffer.len(), 7 + (3 * 80 / 8));
+        assert_eq!(buffer.len(), 7 + (3 * 80 / 8) + 7);
     }
 }

columnar/src/columnar/column_type.rs

@@ -1,6 +1,4 @@
-use std::fmt::Debug;
-use std::net::Ipv6Addr;
-
+use crate::utils::{place_bits, select_bits};
 use crate::value::NumericalType;
 use crate::InvalidData;
 
@@ -9,152 +7,62 @@ use crate::InvalidData;
 /// - bits[0..3]: Column category type.
 /// - bits[3..6]: Numerical type if necessary.
 #[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
-#[repr(u8)]
 pub enum ColumnType {
-    I64 = 0u8,
-    U64 = 1u8,
-    F64 = 2u8,
-    Bytes = 10u8,
-    Str = 14u8,
-    Bool = 18u8,
-    IpAddr = 22u8,
-    DateTime = 26u8,
+    Bytes,
+    Numerical(NumericalType),
+    Bool,
 }
 
-#[cfg(test)]
-const COLUMN_TYPES: [ColumnType; 8] = [
-    ColumnType::I64,
-    ColumnType::U64,
-    ColumnType::F64,
-    ColumnType::Bytes,
-    ColumnType::Str,
-    ColumnType::Bool,
-    ColumnType::IpAddr,
-    ColumnType::DateTime,
-];
-
 impl ColumnType {
-    pub fn to_code(self) -> u8 {
-        self as u8
+    /// Encoded over 6 bits.
+    pub(crate) fn to_code(self) -> u8 {
+        let column_type_category;
+        let numerical_type_code: u8;
+        match self {
+            ColumnType::Bytes => {
+                column_type_category = ColumnTypeCategory::Str;
+                numerical_type_code = 0u8;
+            }
+            ColumnType::Numerical(numerical_type) => {
+                column_type_category = ColumnTypeCategory::Numerical;
+                numerical_type_code = numerical_type.to_code();
+            }
+            ColumnType::Bool => {
+                column_type_category = ColumnTypeCategory::Bool;
+                numerical_type_code = 0u8;
+            }
+        }
+        place_bits::<0, 3>(column_type_category.to_code()) | place_bits::<3, 6>(numerical_type_code)
     }
 
     pub(crate) fn try_from_code(code: u8) -> Result<ColumnType, InvalidData> {
-        use ColumnType::*;
-        match code {
-            0u8 => Ok(I64),
-            1u8 => Ok(U64),
-            2u8 => Ok(F64),
-            10u8 => Ok(Bytes),
-            14u8 => Ok(Str),
-            18u8 => Ok(Bool),
-            22u8 => Ok(IpAddr),
-            26u8 => Ok(Self::DateTime),
-            _ => Err(InvalidData),
+        if select_bits::<6, 8>(code) != 0u8 {
+            return Err(InvalidData);
         }
-    }
-}
-
-impl From<NumericalType> for ColumnType {
-    fn from(numerical_type: NumericalType) -> Self {
-        match numerical_type {
-            NumericalType::I64 => ColumnType::I64,
-            NumericalType::U64 => ColumnType::U64,
-            NumericalType::F64 => ColumnType::F64,
+        let column_type_category_code = select_bits::<0, 3>(code);
+        let numerical_type_code = select_bits::<3, 6>(code);
+        let column_type_category = ColumnTypeCategory::try_from_code(column_type_category_code)?;
+        match column_type_category {
+            ColumnTypeCategory::Bool => {
+                if numerical_type_code != 0u8 {
+                    return Err(InvalidData);
+                }
+                Ok(ColumnType::Bool)
+            }
+            ColumnTypeCategory::Str => {
+                if numerical_type_code != 0u8 {
+                    return Err(InvalidData);
+                }
+                Ok(ColumnType::Bytes)
+            }
+            ColumnTypeCategory::Numerical => {
+                let numerical_type = NumericalType::try_from_code(numerical_type_code)?;
+                Ok(ColumnType::Numerical(numerical_type))
+            }
         }
     }
 }
 
-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),
-            ColumnType::U64 => Some(NumericalType::U64),
-            ColumnType::F64 => Some(NumericalType::F64),
-            ColumnType::Bytes
-            | ColumnType::Str
-            | ColumnType::Bool
-            | ColumnType::IpAddr
-            | ColumnType::DateTime => None,
-        }
-    }
-}
-
-// TODO remove if possible
-pub trait HasAssociatedColumnType: 'static + Debug + Send + Sync + Copy + PartialOrd {
-    fn column_type() -> ColumnType;
-    fn default_value() -> Self;
-}
-
-impl HasAssociatedColumnType for u64 {
-    fn column_type() -> ColumnType {
-        ColumnType::U64
-    }
-
-    fn default_value() -> Self {
-        0u64
-    }
-}
-
-impl HasAssociatedColumnType for i64 {
-    fn column_type() -> ColumnType {
-        ColumnType::I64
-    }
-
-    fn default_value() -> Self {
-        0i64
-    }
-}
-
-impl HasAssociatedColumnType for f64 {
-    fn column_type() -> ColumnType {
-        ColumnType::F64
-    }
-
-    fn default_value() -> Self {
-        Default::default()
-    }
-}
-
-impl HasAssociatedColumnType for bool {
-    fn column_type() -> ColumnType {
-        ColumnType::Bool
-    }
-    fn default_value() -> Self {
-        Default::default()
-    }
-}
-
-impl HasAssociatedColumnType for crate::DateTime {
-    fn column_type() -> ColumnType {
-        ColumnType::DateTime
-    }
-    fn default_value() -> Self {
-        Default::default()
-    }
-}
-
-impl HasAssociatedColumnType for Ipv6Addr {
-    fn column_type() -> ColumnType {
-        ColumnType::IpAddr
-    }
-
-    fn default_value() -> Self {
-        Ipv6Addr::from([0u8; 16])
-    }
-}
-
 /// Column types are grouped into different categories that
 /// corresponds to the different types of `JsonValue` types.
 ///
@@ -162,28 +70,25 @@ impl HasAssociatedColumnType for Ipv6Addr {
 /// at most one column exist per `ColumnTypeCategory`.
 ///
 /// See also [README.md].
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
 #[repr(u8)]
-pub enum ColumnTypeCategory {
-    Bool,
-    Str,
-    Numerical,
-    DateTime,
-    Bytes,
-    IpAddr,
+pub(crate) enum ColumnTypeCategory {
+    Bool = 0u8,
+    Str = 1u8,
+    Numerical = 2u8,
 }
 
-impl From<ColumnType> for ColumnTypeCategory {
-    fn from(column_type: ColumnType) -> Self {
-        match column_type {
-            ColumnType::I64 => ColumnTypeCategory::Numerical,
-            ColumnType::U64 => ColumnTypeCategory::Numerical,
-            ColumnType::F64 => ColumnTypeCategory::Numerical,
-            ColumnType::Bytes => ColumnTypeCategory::Bytes,
-            ColumnType::Str => ColumnTypeCategory::Str,
-            ColumnType::Bool => ColumnTypeCategory::Bool,
-            ColumnType::IpAddr => ColumnTypeCategory::IpAddr,
-            ColumnType::DateTime => ColumnTypeCategory::DateTime,
+impl ColumnTypeCategory {
+    pub fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub fn try_from_code(code: u8) -> Result<Self, InvalidData> {
+        match code {
+            0u8 => Ok(Self::Bool),
+            1u8 => Ok(Self::Str),
+            2u8 => Ok(Self::Numerical),
+            _ => Err(InvalidData),
         }
     }
 }
@@ -204,22 +109,7 @@ mod tests {
                 assert!(column_type_set.insert(column_type));
             }
         }
-        assert_eq!(column_type_set.len(), super::COLUMN_TYPES.len());
-    }
-
-    #[test]
-    fn test_column_category_sort_consistent_with_column_type_sort() {
-        // This is a very important property because we
-        // we need to serialize colunmn in the right order.
-        let mut column_types: Vec<ColumnType> = super::COLUMN_TYPES.iter().copied().collect();
-        column_types.sort_by_key(|col| col.to_code());
-        let column_categories: Vec<ColumnTypeCategory> = column_types
-            .into_iter()
-            .map(ColumnTypeCategory::from)
-            .collect();
-        for (prev, next) in column_categories.iter().zip(column_categories.iter()) {
-            assert!(prev <= next);
-        }
+        assert_eq!(column_type_set.len(), 2 + 3);
     }
 
     #[test]

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/mod.rs

@@ -1,10 +1,28 @@
+// Copyright (C) 2022 Quickwit, Inc.
+//
+// Quickwit is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at hello@quickwit.io.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
 mod column_type;
 mod format_version;
-mod merge;
 mod reader;
 mod writer;
 
-pub use column_type::{ColumnType, HasAssociatedColumnType};
-pub use merge::{merge_columnar, MergeDocOrder};
+pub use column_type::ColumnType;
 pub use reader::ColumnarReader;
 pub use writer::ColumnarWriter;

columnar/src/columnar/reader/mod.rs

@@ -44,7 +44,7 @@ impl ColumnarReader {
         })
     }
 
-    // TODO Add unit tests
+    // TODO fix ugly API
     pub fn list_columns(&self) -> io::Result<Vec<(String, DynamicColumnHandle)>> {
         let mut stream = self.column_dictionary.stream()?;
         let mut results = Vec::new();
@@ -55,8 +55,7 @@ impl ColumnarReader {
                 .map_err(|_| io_invalid_data(format!("Unknown column code `{column_code}`")))?;
             let range = stream.value().clone();
             let column_name =
-                // The last two bytes are respectively the 0u8 separator and the column_type.
-                String::from_utf8_lossy(&key_bytes[..key_bytes.len() - 2]).to_string();
+                String::from_utf8_lossy(&key_bytes[..key_bytes.len() - 1]).to_string();
             let file_slice = self
                 .column_data
                 .slice(range.start as usize..range.end as usize);
@@ -73,6 +72,7 @@ impl ColumnarReader {
     ///
     /// There can be more than one column associated to a given column name, provided they have
     /// different types.
+    // TODO fix ugly API
     pub fn read_columns(&self, column_name: &str) -> io::Result<Vec<DynamicColumnHandle>> {
         // Each column is a associated to a given `column_key`,
         // that starts by `column_name\0column_header`.
@@ -119,46 +119,3 @@ impl ColumnarReader {
         self.column_dictionary.num_terms()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{ColumnType, ColumnarReader, ColumnarWriter};
-
-    #[test]
-    fn test_list_columns() {
-        let mut columnar_writer = ColumnarWriter::default();
-        columnar_writer.record_column_type("col1", ColumnType::Str, false);
-        columnar_writer.record_column_type("col2", ColumnType::U64, false);
-        let mut buffer = Vec::new();
-        columnar_writer.serialize(1, &mut buffer).unwrap();
-        let columnar = ColumnarReader::open(buffer).unwrap();
-        let columns = columnar.list_columns().unwrap();
-        assert_eq!(columns.len(), 2);
-        assert_eq!(&columns[0].0, "col1");
-        assert_eq!(columns[0].1.column_type(), ColumnType::Str);
-        assert_eq!(&columns[1].0, "col2");
-        assert_eq!(columns[1].1.column_type(), ColumnType::U64);
-    }
-
-    #[test]
-    fn test_list_columns_strict_typing_prevents_coercion() {
-        let mut columnar_writer = ColumnarWriter::default();
-        columnar_writer.record_column_type("count", ColumnType::U64, false);
-        columnar_writer.record_numerical(1, "count", 1u64);
-        let mut buffer = Vec::new();
-        columnar_writer.serialize(2, &mut buffer).unwrap();
-        let columnar = ColumnarReader::open(buffer).unwrap();
-        let columns = columnar.list_columns().unwrap();
-        assert_eq!(columns.len(), 1);
-        assert_eq!(&columns[0].0, "count");
-        assert_eq!(columns[0].1.column_type(), ColumnType::U64);
-    }
-
-    #[test]
-    #[should_panic(expect = "Input type forbidden")]
-    fn test_list_columns_strict_typing_panics_on_wrong_types() {
-        let mut columnar_writer = ColumnarWriter::default();
-        columnar_writer.record_column_type("count", ColumnType::U64, false);
-        columnar_writer.record_numerical(1, "count", 1i64);
-    }
-}

columnar/src/columnar/writer/column_operation.rs

@@ -1,5 +1,3 @@
-use std::net::Ipv6Addr;
-
 use crate::dictionary::UnorderedId;
 use crate::utils::{place_bits, pop_first_byte, select_bits};
 use crate::value::NumericalValue;
@@ -27,12 +25,12 @@ struct ColumnOperationMetadata {
 
 impl ColumnOperationMetadata {
     fn to_code(self) -> u8 {
-        place_bits::<0, 6>(self.len) | place_bits::<6, 8>(self.op_type.to_code())
+        place_bits::<0, 4>(self.len) | place_bits::<4, 8>(self.op_type.to_code())
     }
 
     fn try_from_code(code: u8) -> Result<Self, InvalidData> {
-        let len = select_bits::<0, 6>(code);
-        let typ_code = select_bits::<6, 8>(code);
+        let len = select_bits::<0, 4>(code);
+        let typ_code = select_bits::<4, 8>(code);
         let column_type = ColumnOperationType::try_from_code(typ_code)?;
         Ok(ColumnOperationMetadata {
             op_type: column_type,
@@ -144,21 +142,9 @@ impl SymbolValue for bool {
     }
 }
 
-impl SymbolValue for Ipv6Addr {
-    fn serialize(self, buffer: &mut [u8]) -> u8 {
-        buffer[0..16].copy_from_slice(&self.octets());
-        16
-    }
-
-    fn deserialize(bytes: &[u8]) -> Self {
-        let octets: [u8; 16] = bytes[0..16].try_into().unwrap();
-        Ipv6Addr::from(octets)
-    }
-}
-
 #[derive(Default)]
 struct MiniBuffer {
-    pub bytes: [u8; 17],
+    pub bytes: [u8; 10],
     pub len: u8,
 }
 

columnar/src/columnar/writer/column_writers.rs

@@ -168,12 +168,7 @@ impl CompatibleNumericalTypes {
                 }
             },
             CompatibleNumericalTypes::StaticType(typ) => {
-                assert_eq!(
-                    numerical_value.numerical_type(),
-                    *typ,
-                    "Input type forbidden. This column has been forced to type {typ:?}, received \
-                     {numerical_value:?}"
-                );
+                assert_eq!(numerical_value.numerical_type(), *typ);
             }
         }
     }
@@ -214,26 +209,17 @@ impl NumericalColumnWriter {
     }
 }
 
-#[derive(Copy, Clone)]
-pub(crate) struct StrOrBytesColumnWriter {
+#[derive(Copy, Clone, Default)]
+pub(crate) struct StrColumnWriter {
     pub(crate) dictionary_id: u32,
     pub(crate) column_writer: ColumnWriter,
-    // If true, when facing a multivalued cardinality,
-    // values associated to a given document will be sorted.
-    //
-    // This is useful for facets.
-    //
-    // If false, the order of appearance in the document will be
-    // observed.
-    pub(crate) sort_values_within_row: bool,
 }
 
-impl StrOrBytesColumnWriter {
-    pub(crate) fn with_dictionary_id(dictionary_id: u32) -> StrOrBytesColumnWriter {
-        StrOrBytesColumnWriter {
+impl StrColumnWriter {
+    pub(crate) fn with_dictionary_id(dictionary_id: u32) -> StrColumnWriter {
+        StrColumnWriter {
             dictionary_id,
             column_writer: Default::default(),
-            sort_values_within_row: false,
         }
     }
 

columnar/src/columnar/writer/mod.rs

@@ -4,7 +4,6 @@ mod serializer;
 mod value_index;
 
 use std::io;
-use std::net::Ipv6Addr;
 
 use column_operation::ColumnOperation;
 use common::CountingWriter;
@@ -12,12 +11,10 @@ use serializer::ColumnarSerializer;
 use stacker::{Addr, ArenaHashMap, MemoryArena};
 
 use crate::column_index::SerializableColumnIndex;
-use crate::column_values::{
-    ColumnValues, MonotonicallyMappableToU128, MonotonicallyMappableToU64, VecColumn,
-};
+use crate::column_values::{ColumnValues, MonotonicallyMappableToU64, VecColumn};
 use crate::columnar::column_type::{ColumnType, ColumnTypeCategory};
 use crate::columnar::writer::column_writers::{
-    ColumnWriter, NumericalColumnWriter, StrOrBytesColumnWriter,
+    ColumnWriter, NumericalColumnWriter, StrColumnWriter,
 };
 use crate::columnar::writer::value_index::{IndexBuilder, PreallocatedIndexBuilders};
 use crate::dictionary::{DictionaryBuilder, TermIdMapping, UnorderedId};
@@ -29,8 +26,10 @@ use crate::{Cardinality, RowId};
 #[derive(Default)]
 struct SpareBuffers {
     value_index_builders: PreallocatedIndexBuilders,
+    i64_values: Vec<i64>,
     u64_values: Vec<u64>,
-    ip_addr_values: Vec<Ipv6Addr>,
+    f64_values: Vec<f64>,
+    bool_values: Vec<bool>,
 }
 
 /// Makes it possible to create a new columnar.
@@ -48,11 +47,8 @@ struct SpareBuffers {
 /// ```
 pub struct ColumnarWriter {
     numerical_field_hash_map: ArenaHashMap,
-    datetime_field_hash_map: ArenaHashMap,
     bool_field_hash_map: ArenaHashMap,
-    ip_addr_field_hash_map: ArenaHashMap,
     bytes_field_hash_map: ArenaHashMap,
-    str_field_hash_map: ArenaHashMap,
     arena: MemoryArena,
     // Dictionaries used to store dictionary-encoded values.
     dictionaries: Vec<DictionaryBuilder>,
@@ -64,10 +60,7 @@ impl Default for ColumnarWriter {
         ColumnarWriter {
             numerical_field_hash_map: ArenaHashMap::new(10_000),
             bool_field_hash_map: ArenaHashMap::new(10_000),
-            ip_addr_field_hash_map: ArenaHashMap::new(10_000),
             bytes_field_hash_map: ArenaHashMap::new(10_000),
-            str_field_hash_map: ArenaHashMap::new(10_000),
-            datetime_field_hash_map: ArenaHashMap::new(10_000),
             dictionaries: Vec::new(),
             arena: MemoryArena::default(),
             buffers: SpareBuffers::default(),
@@ -92,92 +85,17 @@ fn mutate_or_create_column<V, TMutator>(
 }
 
 impl ColumnarWriter {
-    pub fn mem_usage(&self) -> usize {
-        // TODO add dictionary builders.
-        self.arena.mem_usage()
-            + self.numerical_field_hash_map.mem_usage()
-            + self.bool_field_hash_map.mem_usage()
-            + self.bytes_field_hash_map.mem_usage()
-            + self.str_field_hash_map.mem_usage()
-            + self.ip_addr_field_hash_map.mem_usage()
-            + self.datetime_field_hash_map.mem_usage()
-    }
-
-    /// Records a column type. This is useful to bypass the coercion process,
-    /// makes sure the empty is present in the resulting columnar, or set
-    /// the `sort_values_within_row`.
-    ///
-    /// `sort_values_within_row` is only allowed for `Bytes` or `Str` columns.
-    pub fn record_column_type(
-        &mut self,
-        column_name: &str,
-        column_type: ColumnType,
-        sort_values_within_row: bool,
-    ) {
-        if sort_values_within_row {
-            assert!(
-                column_type == ColumnType::Bytes || column_type == ColumnType::Str,
-                "sort_values_within_row is only allowed for Bytes and Str columns",
-            );
-        }
-        match column_type {
-            ColumnType::Str | ColumnType::Bytes => {
-                let (hash_map, dictionaries) = (
-                    if column_type == ColumnType::Str {
-                        &mut self.str_field_hash_map
-                    } else {
-                        &mut self.bytes_field_hash_map
-                    },
-                    &mut self.dictionaries,
-                );
-                mutate_or_create_column(
-                    hash_map,
-                    column_name,
-                    |column_opt: Option<StrOrBytesColumnWriter>| {
-                        let mut column_writer = if let Some(column_writer) = column_opt {
-                            column_writer
-                        } else {
-                            let dictionary_id = dictionaries.len() as u32;
-                            dictionaries.push(DictionaryBuilder::default());
-                            StrOrBytesColumnWriter::with_dictionary_id(dictionary_id)
-                        };
-                        column_writer.sort_values_within_row = sort_values_within_row;
-                        column_writer
-                    },
-                );
-            }
-            ColumnType::Bool => {
-                mutate_or_create_column(
-                    &mut self.bool_field_hash_map,
-                    column_name,
-                    |column_opt: Option<ColumnWriter>| column_opt.unwrap_or_default(),
-                );
-            }
-            ColumnType::DateTime => {
-                mutate_or_create_column(
-                    &mut self.datetime_field_hash_map,
-                    column_name,
-                    |column_opt: Option<ColumnWriter>| column_opt.unwrap_or_default(),
-                );
-            }
-            ColumnType::I64 | ColumnType::F64 | ColumnType::U64 => {
-                let numerical_type = column_type.numerical_type().unwrap();
-                mutate_or_create_column(
-                    &mut self.numerical_field_hash_map,
-                    column_name,
-                    |column_opt: Option<NumericalColumnWriter>| {
-                        let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
-                        column.force_numerical_type(numerical_type);
-                        column
-                    },
-                );
-            }
-            ColumnType::IpAddr => mutate_or_create_column(
-                &mut self.ip_addr_field_hash_map,
-                column_name,
-                |column_opt: Option<ColumnWriter>| column_opt.unwrap_or_default(),
-            ),
-        }
+    pub fn force_numerical_type(&mut self, column_name: &str, numerical_type: NumericalType) {
+        let (hash_map, _) = (&mut self.numerical_field_hash_map, &mut self.arena);
+        mutate_or_create_column(
+            hash_map,
+            column_name,
+            |column_opt: Option<NumericalColumnWriter>| {
+                let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
+                column.force_numerical_type(numerical_type);
+                column
+            },
+        );
     }
 
     pub fn record_numerical<T: Into<NumericalValue> + Copy>(
@@ -198,22 +116,6 @@ impl ColumnarWriter {
         );
     }
 
-    pub fn record_ip_addr(&mut self, doc: RowId, column_name: &str, ip_addr: Ipv6Addr) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
-        let (hash_map, arena) = (&mut self.ip_addr_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<ColumnWriter>| {
-                let mut column: ColumnWriter = column_opt.unwrap_or_default();
-                column.record(doc, ip_addr, arena);
-                column
-            },
-        );
-    }
-
     pub fn record_bool(&mut self, doc: RowId, column_name: &str, val: bool) {
         let (hash_map, arena) = (&mut self.bool_field_hash_map, &mut self.arena);
         mutate_or_create_column(hash_map, column_name, |column_opt: Option<ColumnWriter>| {
@@ -223,29 +125,21 @@ impl ColumnarWriter {
         });
     }
 
-    pub fn record_datetime(&mut self, doc: RowId, column_name: &str, datetime: crate::DateTime) {
-        let (hash_map, arena) = (&mut self.datetime_field_hash_map, &mut self.arena);
-        mutate_or_create_column(hash_map, column_name, |column_opt: Option<ColumnWriter>| {
-            let mut column: ColumnWriter = column_opt.unwrap_or_default();
-            column.record(doc, NumericalValue::I64(datetime.timestamp_micros), arena);
-            column
-        });
-    }
-
     pub fn record_str(&mut self, doc: RowId, column_name: &str, value: &str) {
         let (hash_map, arena, dictionaries) = (
-            &mut self.str_field_hash_map,
+            &mut self.bytes_field_hash_map,
             &mut self.arena,
             &mut self.dictionaries,
         );
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<StrOrBytesColumnWriter>| {
-                let mut column: StrOrBytesColumnWriter = column_opt.unwrap_or_else(|| {
+        mutate_or_create_column(
+            hash_map,
+            column_name,
+            |column_opt: Option<StrColumnWriter>| {
+                let mut column: StrColumnWriter = column_opt.unwrap_or_else(|| {
                     // Each column has its own dictionary
                     let dictionary_id = dictionaries.len() as u32;
                     dictionaries.push(DictionaryBuilder::default());
-                    StrOrBytesColumnWriter::with_dictionary_id(dictionary_id)
+                    StrColumnWriter::with_dictionary_id(dictionary_id)
                 });
                 column.record_bytes(doc, value.as_bytes(), dictionaries, arena);
                 column
@@ -253,68 +147,28 @@ impl ColumnarWriter {
         );
     }
 
-    pub fn record_bytes(&mut self, doc: RowId, column_name: &str, value: &[u8]) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
-        let (hash_map, arena, dictionaries) = (
-            &mut self.bytes_field_hash_map,
-            &mut self.arena,
-            &mut self.dictionaries,
-        );
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<StrOrBytesColumnWriter>| {
-                let mut column: StrOrBytesColumnWriter = column_opt.unwrap_or_else(|| {
-                    // Each column has its own dictionary
-                    let dictionary_id = dictionaries.len() as u32;
-                    dictionaries.push(DictionaryBuilder::default());
-                    StrOrBytesColumnWriter::with_dictionary_id(dictionary_id)
-                });
-                column.record_bytes(doc, value, dictionaries, arena);
-                column
-            },
-        );
-    }
     pub fn serialize(&mut self, num_docs: RowId, wrt: &mut dyn io::Write) -> io::Result<()> {
         let mut serializer = ColumnarSerializer::new(wrt);
-        let mut columns: Vec<(&[u8], ColumnTypeCategory, Addr)> = self
+        let mut field_columns: Vec<(&[u8], ColumnTypeCategory, Addr)> = self
             .numerical_field_hash_map
             .iter()
-            .map(|(column_name, addr, _)| (column_name, ColumnTypeCategory::Numerical, addr))
+            .map(|(term, addr, _)| (term, ColumnTypeCategory::Numerical, addr))
             .collect();
-        columns.extend(
+        field_columns.extend(
             self.bytes_field_hash_map
                 .iter()
-                .map(|(term, addr, _)| (term, ColumnTypeCategory::Bytes, addr)),
+                .map(|(term, addr, _)| (term, ColumnTypeCategory::Str, addr)),
         );
-        columns.extend(
-            self.str_field_hash_map
-                .iter()
-                .map(|(column_name, addr, _)| (column_name, ColumnTypeCategory::Str, addr)),
-        );
-        columns.extend(
+        field_columns.extend(
             self.bool_field_hash_map
                 .iter()
-                .map(|(column_name, addr, _)| (column_name, ColumnTypeCategory::Bool, addr)),
+                .map(|(term, addr, _)| (term, ColumnTypeCategory::Bool, addr)),
         );
-        columns.extend(
-            self.ip_addr_field_hash_map
-                .iter()
-                .map(|(column_name, addr, _)| (column_name, ColumnTypeCategory::IpAddr, addr)),
-        );
-        columns.extend(
-            self.datetime_field_hash_map
-                .iter()
-                .map(|(column_name, addr, _)| (column_name, ColumnTypeCategory::DateTime, addr)),
-        );
-        columns.sort_unstable_by_key(|(column_name, col_type, _)| (*column_name, *col_type));
-
+        field_columns.sort_unstable_by_key(|(column_name, col_type, _)| (*column_name, *col_type));
         let (arena, buffers, dictionaries) = (&self.arena, &mut self.buffers, &self.dictionaries);
         let mut symbol_byte_buffer: Vec<u8> = Vec::new();
-        for (column_name, column_type, addr) in columns {
-            match column_type {
+        for (column_name, bytes_or_numerical, addr) in field_columns {
+            match bytes_or_numerical {
                 ColumnTypeCategory::Bool => {
                     let column_writer: ColumnWriter = self.bool_field_hash_map.read(addr);
                     let cardinality = column_writer.get_cardinality(num_docs);
@@ -328,35 +182,16 @@ impl ColumnarWriter {
                         &mut column_serializer,
                     )?;
                 }
-                ColumnTypeCategory::IpAddr => {
-                    let column_writer: ColumnWriter = self.ip_addr_field_hash_map.read(addr);
-                    let cardinality = column_writer.get_cardinality(num_docs);
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, ColumnType::IpAddr);
-                    serialize_ip_addr_column(
-                        cardinality,
-                        num_docs,
-                        column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
-                        buffers,
-                        &mut column_serializer,
-                    )?;
-                }
-                ColumnTypeCategory::Bytes | ColumnTypeCategory::Str => {
-                    let (column_type, str_column_writer): (ColumnType, StrOrBytesColumnWriter) =
-                        if column_type == ColumnTypeCategory::Bytes {
-                            (ColumnType::Bytes, self.bytes_field_hash_map.read(addr))
-                        } else {
-                            (ColumnType::Str, self.str_field_hash_map.read(addr))
-                        };
+                ColumnTypeCategory::Str => {
+                    let str_column_writer: StrColumnWriter = self.bytes_field_hash_map.read(addr);
                     let dictionary_builder =
                         &dictionaries[str_column_writer.dictionary_id as usize];
                     let cardinality = str_column_writer.column_writer.get_cardinality(num_docs);
                     let mut column_serializer =
-                        serializer.serialize_column(column_name, column_type);
-                    serialize_bytes_or_str_column(
+                        serializer.serialize_column(column_name, ColumnType::Bytes);
+                    serialize_bytes_column(
                         cardinality,
                         num_docs,
-                        str_column_writer.sort_values_within_row,
                         dictionary_builder,
                         str_column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
                         buffers,
@@ -368,8 +203,8 @@ impl ColumnarWriter {
                         self.numerical_field_hash_map.read(addr);
                     let (numerical_type, cardinality) =
                         numerical_column_writer.column_type_and_cardinality(num_docs);
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, ColumnType::from(numerical_type));
+                    let mut column_serializer = serializer
+                        .serialize_column(column_name, ColumnType::Numerical(numerical_type));
                     serialize_numerical_column(
                         cardinality,
                         num_docs,
@@ -379,20 +214,6 @@ impl ColumnarWriter {
                         &mut column_serializer,
                     )?;
                 }
-                ColumnTypeCategory::DateTime => {
-                    let column_writer: ColumnWriter = self.datetime_field_hash_map.read(addr);
-                    let cardinality = column_writer.get_cardinality(num_docs);
-                    let mut column_serializer =
-                        serializer.serialize_column(column_name, ColumnType::DateTime);
-                    serialize_numerical_column(
-                        cardinality,
-                        num_docs,
-                        NumericalType::I64,
-                        column_writer.operation_iterator(arena, &mut symbol_byte_buffer),
-                        buffers,
-                        &mut column_serializer,
-                    )?;
-                }
             };
         }
         serializer.finalize()?;
@@ -400,10 +221,9 @@ impl ColumnarWriter {
     }
 }
 
-fn serialize_bytes_or_str_column(
+fn serialize_bytes_column(
     cardinality: Cardinality,
     num_docs: RowId,
-    sort_values_within_row: bool,
     dictionary_builder: &DictionaryBuilder,
     operation_it: impl Iterator<Item = ColumnOperation<UnorderedId>>,
     buffers: &mut SpareBuffers,
@@ -428,11 +248,10 @@ fn serialize_bytes_or_str_column(
             ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
         }
     });
-    send_to_serialize_column_mappable_to_u64(
+    serialize_column(
         operation_iterator,
         cardinality,
         num_docs,
-        sort_values_within_row,
         value_index_builders,
         u64_values,
         &mut wrt,
@@ -452,39 +271,38 @@ fn serialize_numerical_column(
     let SpareBuffers {
         value_index_builders,
         u64_values,
+        i64_values,
+        f64_values,
         ..
     } = buffers;
     match numerical_type {
         NumericalType::I64 => {
-            send_to_serialize_column_mappable_to_u64(
+            serialize_column(
                 coerce_numerical_symbol::<i64>(op_iterator),
                 cardinality,
                 num_docs,
-                false,
                 value_index_builders,
-                u64_values,
+                i64_values,
                 wrt,
             )?;
         }
         NumericalType::U64 => {
-            send_to_serialize_column_mappable_to_u64(
+            serialize_column(
                 coerce_numerical_symbol::<u64>(op_iterator),
                 cardinality,
                 num_docs,
-                false,
                 value_index_builders,
                 u64_values,
                 wrt,
             )?;
         }
         NumericalType::F64 => {
-            send_to_serialize_column_mappable_to_u64(
+            serialize_column(
                 coerce_numerical_symbol::<f64>(op_iterator),
                 cardinality,
                 num_docs,
-                false,
                 value_index_builders,
-                u64_values,
+                f64_values,
                 wrt,
             )?;
         }
@@ -501,49 +319,22 @@ fn serialize_bool_column(
 ) -> io::Result<()> {
     let SpareBuffers {
         value_index_builders,
-        u64_values,
+        bool_values,
         ..
     } = buffers;
-    send_to_serialize_column_mappable_to_u64(
-        column_operations_it.map(|bool_column_operation| match bool_column_operation {
-            ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
-            ColumnOperation::Value(bool_val) => ColumnOperation::Value(bool_val.to_u64()),
-        }),
-        cardinality,
-        num_docs,
-        false,
-        value_index_builders,
-        u64_values,
-        wrt,
-    )?;
-    Ok(())
-}
-
-fn serialize_ip_addr_column(
-    cardinality: Cardinality,
-    num_docs: RowId,
-    column_operations_it: impl Iterator<Item = ColumnOperation<Ipv6Addr>>,
-    buffers: &mut SpareBuffers,
-    wrt: &mut impl io::Write,
-) -> io::Result<()> {
-    let SpareBuffers {
-        value_index_builders,
-        ip_addr_values,
-        ..
-    } = buffers;
-    send_to_serialize_column_mappable_to_u128(
+    serialize_column(
         column_operations_it,
         cardinality,
         num_docs,
         value_index_builders,
-        ip_addr_values,
+        bool_values,
         wrt,
     )?;
     Ok(())
 }
 
-fn send_to_serialize_column_mappable_to_u128<
-    T: Copy + Ord + std::fmt::Debug + Send + Sync + MonotonicallyMappableToU128 + PartialOrd,
+fn serialize_column<
+    T: Copy + Default + std::fmt::Debug + Send + Sync + MonotonicallyMappableToU64 + PartialOrd,
 >(
     op_iterator: impl Iterator<Item = ColumnOperation<T>>,
     cardinality: Cardinality,
@@ -556,7 +347,6 @@ where
     for<'a> VecColumn<'a, T>: ColumnValues<T>,
 {
     values.clear();
-    // TODO: split index and values
     let serializable_column_index = match cardinality {
         Cardinality::Full => {
             consume_operation_iterator(
@@ -576,69 +366,11 @@ where
             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);
-            SerializableColumnIndex::Multivalued(Box::new(multivalued_index))
+            todo!();
+            // SerializableColumnIndex::Multivalued(Box::new(multivalued_index))
         }
     };
-    crate::column::serialize_column_mappable_to_u128(
-        serializable_column_index,
-        || values.iter().cloned(),
-        values.len() as u32,
-        &mut wrt,
-    )?;
-    Ok(())
-}
-
-fn sort_values_within_row_in_place(
-    multivalued_index: &impl ColumnValues<RowId>,
-    values: &mut Vec<u64>,
-) {
-    let mut start_index: usize = 0;
-    for end_index in multivalued_index.iter() {
-        let end_index = end_index as usize;
-        values[start_index..end_index].sort_unstable();
-        start_index = end_index;
-    }
-}
-
-fn send_to_serialize_column_mappable_to_u64(
-    op_iterator: impl Iterator<Item = ColumnOperation<u64>>,
-    cardinality: Cardinality,
-    num_docs: RowId,
-    sort_values_within_row: bool,
-    value_index_builders: &mut PreallocatedIndexBuilders,
-    values: &mut Vec<u64>,
-    mut wrt: impl io::Write,
-) -> io::Result<()>
-where
-    for<'a> VecColumn<'a, u64>: ColumnValues<u64>,
-{
-    values.clear();
-    let serializable_column_index = match cardinality {
-        Cardinality::Full => {
-            consume_operation_iterator(
-                op_iterator,
-                value_index_builders.borrow_required_index_builder(),
-                values,
-            );
-            SerializableColumnIndex::Full
-        }
-        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))
-        }
-        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);
-            if sort_values_within_row {
-                sort_values_within_row_in_place(&multivalued_index, values);
-            }
-            SerializableColumnIndex::Multivalued(Box::new(multivalued_index))
-        }
-    };
-    crate::column::serialize_column_mappable_to_u64(
+    crate::column::serialize_column_u64(
         serializable_column_index,
         &VecColumn::from(&values[..]),
         &mut wrt,
@@ -648,17 +380,17 @@ where
 
 fn coerce_numerical_symbol<T>(
     operation_iterator: impl Iterator<Item = ColumnOperation<NumericalValue>>,
-) -> impl Iterator<Item = ColumnOperation<u64>>
-where T: Coerce + MonotonicallyMappableToU64 {
+) -> impl Iterator<Item = ColumnOperation<T>>
+where T: Coerce {
     operation_iterator.map(|symbol| match symbol {
         ColumnOperation::NewDoc(doc) => ColumnOperation::NewDoc(doc),
         ColumnOperation::Value(numerical_value) => {
-            ColumnOperation::Value(T::coerce(numerical_value).to_u64())
+            ColumnOperation::Value(Coerce::coerce(numerical_value))
         }
     })
 }
 
-fn consume_operation_iterator<T: Ord, TIndexBuilder: IndexBuilder>(
+fn consume_operation_iterator<T: std::fmt::Debug, TIndexBuilder: IndexBuilder>(
     operation_iterator: impl Iterator<Item = ColumnOperation<T>>,
     index_builder: &mut TIndexBuilder,
     values: &mut Vec<T>,
@@ -676,12 +408,59 @@ fn consume_operation_iterator<T: Ord, TIndexBuilder: IndexBuilder>(
     }
 }
 
+// /// Serializes the column with the codec with the best estimate on the data.
+// fn serialize_numerical<T: MonotonicallyMappableToU64>(
+//     value_index: ValueIndexInfo,
+//     typed_column: impl Column<T>,
+//     output: &mut impl io::Write,
+//     codecs: &[FastFieldCodecType],
+// ) -> io::Result<()> {
+
+//     let counting_writer = CountingWriter::wrap(output);
+//     serialize_value_index(value_index, output)?;
+//     let value_index_len = counting_writer.written_bytes();
+//     let output = counting_writer.finish();
+
+//     serialize_column(value_index, output)?;
+//     let column = monotonic_map_column(
+//         typed_column,
+//         crate::column::monotonic_mapping::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)?;
+
+//     let column_header = ColumnFooter {
+//         value_index_len: todo!(),
+//         cardinality: todo!(),
+//     };
+
+//     let null_index_footer = NullIndexFooter {
+//         cardinality: value_index.get_cardinality(),
+//         null_index_codec: NullIndexCodec::Full,
+//         null_index_byte_range: 0..0,
+//     };
+//     append_null_index_footer(output, null_index_footer)?;
+//     Ok(())
+// }
+
 #[cfg(test)]
 mod tests {
+    use column_operation::ColumnOperation;
     use stacker::MemoryArena;
 
-    use crate::columnar::writer::column_operation::ColumnOperation;
-    use crate::{Cardinality, NumericalValue};
+    use super::*;
+    use crate::value::NumericalValue;
 
     #[test]
     fn test_column_writer_required_simple() {

columnar/src/columnar/writer/serializer.rs

@@ -97,10 +97,10 @@ mod tests {
     #[test]
     fn test_prepare_key_bytes() {
         let mut buffer: Vec<u8> = b"somegarbage".to_vec();
-        prepare_key(b"root\0child", ColumnType::Str, &mut buffer);
+        prepare_key(b"root\0child", ColumnType::Bytes, &mut buffer);
         assert_eq!(buffer.len(), 12);
         assert_eq!(&buffer[..10], b"root\0child");
         assert_eq!(buffer[10], 0u8);
-        assert_eq!(buffer[11], ColumnType::Str.to_code());
+        assert_eq!(buffer[11], ColumnType::Bytes.to_code());
     }
 }

columnar/src/columnar/writer/value_index.rs

@@ -45,6 +45,16 @@ impl<'a> SerializableOptionalIndex<'a> for SingleValueArrayIndex<'a> {
     }
 }
 
+impl OptionalIndexBuilder {
+    fn num_non_nulls(&self) -> u32 {
+        self.docs.len() as u32
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_> {
+        Box::new(self.docs.iter().copied())
+    }
+}
+
 impl OptionalIndexBuilder {
     pub fn finish<'a>(&'a mut self, num_rows: RowId) -> impl SerializableOptionalIndex + 'a {
         debug_assert!(self
@@ -86,7 +96,7 @@ pub struct MultivaluedIndexBuilder {
 impl MultivaluedIndexBuilder {
     pub fn finish(&mut self, num_docs: RowId) -> impl ColumnValues<u32> + '_ {
         self.start_offsets
-            .resize(num_docs as usize + 1, self.total_num_vals_seen);
+            .resize(num_docs as usize, self.total_num_vals_seen);
         VecColumn {
             values: &&self.start_offsets[..],
             min_value: 0,
@@ -178,7 +188,7 @@ mod tests {
                 .finish(4u32)
                 .iter()
                 .collect::<Vec<u32>>(),
-            vec![0, 0, 2, 3, 3]
+            vec![0, 0, 2, 3]
         );
         multivalued_value_index_builder.reset();
         multivalued_value_index_builder.record_row(2u32);
@@ -189,7 +199,7 @@ mod tests {
                 .finish(4u32)
                 .iter()
                 .collect::<Vec<u32>>(),
-            vec![0, 0, 0, 2, 2]
+            vec![0, 0, 0, 2]
         );
     }
 }

columnar/src/dynamic_column.rs

@@ -1,14 +1,12 @@
 use std::io;
-use std::net::Ipv6Addr;
-use std::sync::Arc;
+use std::net::IpAddr;
 
 use common::file_slice::FileSlice;
 use common::{HasLen, OwnedBytes};
 
-use crate::column::{BytesColumn, Column, StrColumn};
-use crate::column_values::{monotonic_map_column, StrictlyMonotonicFn};
+use crate::column::{BytesColumn, Column};
 use crate::columnar::ColumnType;
-use crate::{DateTime, NumericalType};
+use crate::DateTime;
 
 #[derive(Clone)]
 pub enum DynamicColumn {
@@ -16,163 +14,41 @@ pub enum DynamicColumn {
     I64(Column<i64>),
     U64(Column<u64>),
     F64(Column<f64>),
-    IpAddr(Column<Ipv6Addr>),
+    IpAddr(Column<IpAddr>),
     DateTime(Column<DateTime>),
-    Bytes(BytesColumn),
-    Str(StrColumn),
+    Str(BytesColumn),
 }
 
-impl DynamicColumn {
-    pub fn column_type(&self) -> ColumnType {
-        match self {
-            DynamicColumn::Bool(_) => ColumnType::Bool,
-            DynamicColumn::I64(_) => ColumnType::I64,
-            DynamicColumn::U64(_) => ColumnType::U64,
-            DynamicColumn::F64(_) => ColumnType::F64,
-            DynamicColumn::IpAddr(_) => ColumnType::IpAddr,
-            DynamicColumn::DateTime(_) => ColumnType::DateTime,
-            DynamicColumn::Bytes(_) => ColumnType::Bytes,
-            DynamicColumn::Str(_) => ColumnType::Str,
-        }
-    }
-
-    pub fn is_numerical(&self) -> bool {
-        self.column_type().numerical_type().is_some()
-    }
-
-    pub fn is_f64(&self) -> bool {
-        self.column_type().numerical_type() == Some(NumericalType::F64)
-    }
-    pub fn is_i64(&self) -> bool {
-        self.column_type().numerical_type() == Some(NumericalType::I64)
-    }
-    pub fn is_u64(&self) -> bool {
-        self.column_type().numerical_type() == Some(NumericalType::U64)
-    }
-
-    pub fn coerce_to_f64(self) -> Option<DynamicColumn> {
-        match self {
-            DynamicColumn::I64(column) => Some(DynamicColumn::F64(Column {
-                idx: column.idx,
-                values: Arc::new(monotonic_map_column(column.values, MapI64ToF64)),
-            })),
-            DynamicColumn::U64(column) => Some(DynamicColumn::F64(Column {
-                idx: column.idx,
-                values: Arc::new(monotonic_map_column(column.values, MapU64ToF64)),
-            })),
-            DynamicColumn::F64(_) => Some(self),
-            _ => None,
-        }
-    }
-    pub fn coerce_to_i64(self) -> Option<DynamicColumn> {
-        match self {
-            DynamicColumn::U64(column) => {
-                if column.max_value() > i64::MAX as u64 {
-                    return None;
-                }
-                Some(DynamicColumn::I64(Column {
-                    idx: column.idx,
-                    values: Arc::new(monotonic_map_column(column.values, MapU64ToI64)),
-                }))
-            }
-            DynamicColumn::I64(_) => Some(self),
-            _ => None,
-        }
-    }
-    pub fn coerce_to_u64(self) -> Option<DynamicColumn> {
-        match self {
-            DynamicColumn::I64(column) => {
-                if column.min_value() < 0 {
-                    return None;
-                }
-                Some(DynamicColumn::U64(Column {
-                    idx: column.idx,
-                    values: Arc::new(monotonic_map_column(column.values, MapI64ToU64)),
-                }))
-            }
-            DynamicColumn::U64(_) => Some(self),
-            _ => None,
-        }
+impl From<Column<i64>> for DynamicColumn {
+    fn from(column_i64: Column<i64>) -> Self {
+        DynamicColumn::I64(column_i64)
     }
 }
 
-struct MapI64ToF64;
-impl StrictlyMonotonicFn<i64, f64> for MapI64ToF64 {
-    #[inline(always)]
-    fn mapping(&self, inp: i64) -> f64 {
-        inp as f64
-    }
-    #[inline(always)]
-    fn inverse(&self, out: f64) -> i64 {
-        out as i64
+impl From<Column<u64>> for DynamicColumn {
+    fn from(column_u64: Column<u64>) -> Self {
+        DynamicColumn::U64(column_u64)
     }
 }
 
-struct MapU64ToF64;
-impl StrictlyMonotonicFn<u64, f64> for MapU64ToF64 {
-    #[inline(always)]
-    fn mapping(&self, inp: u64) -> f64 {
-        inp as f64
-    }
-    #[inline(always)]
-    fn inverse(&self, out: f64) -> u64 {
-        out as u64
+impl From<Column<f64>> for DynamicColumn {
+    fn from(column_f64: Column<f64>) -> Self {
+        DynamicColumn::F64(column_f64)
     }
 }
 
-struct MapU64ToI64;
-impl StrictlyMonotonicFn<u64, i64> for MapU64ToI64 {
-    #[inline(always)]
-    fn mapping(&self, inp: u64) -> i64 {
-        inp as i64
-    }
-    #[inline(always)]
-    fn inverse(&self, out: i64) -> u64 {
-        out as u64
+impl From<Column<bool>> for DynamicColumn {
+    fn from(bool_column: Column<bool>) -> Self {
+        DynamicColumn::Bool(bool_column)
     }
 }
 
-struct MapI64ToU64;
-impl StrictlyMonotonicFn<i64, u64> for MapI64ToU64 {
-    #[inline(always)]
-    fn mapping(&self, inp: i64) -> u64 {
-        inp as u64
-    }
-    #[inline(always)]
-    fn inverse(&self, out: u64) -> i64 {
-        out as i64
+impl From<BytesColumn> for DynamicColumn {
+    fn from(dictionary_encoded_col: BytesColumn) -> Self {
+        DynamicColumn::Str(dictionary_encoded_col)
     }
 }
 
-macro_rules! static_dynamic_conversions {
-    ($typ:ty, $enum_name:ident) => {
-        impl Into<Option<$typ>> for DynamicColumn {
-            fn into(self) -> Option<$typ> {
-                if let DynamicColumn::$enum_name(col) = self {
-                    Some(col)
-                } else {
-                    None
-                }
-            }
-        }
-
-        impl From<$typ> for DynamicColumn {
-            fn from(typed_column: $typ) -> Self {
-                DynamicColumn::$enum_name(typed_column)
-            }
-        }
-    };
-}
-
-static_dynamic_conversions!(Column<bool>, Bool);
-static_dynamic_conversions!(Column<u64>, U64);
-static_dynamic_conversions!(Column<i64>, I64);
-static_dynamic_conversions!(Column<f64>, F64);
-static_dynamic_conversions!(Column<crate::DateTime>, DateTime);
-static_dynamic_conversions!(StrColumn, Str);
-static_dynamic_conversions!(BytesColumn, Bytes);
-static_dynamic_conversions!(Column<Ipv6Addr>, IpAddr);
-
 #[derive(Clone)]
 pub struct DynamicColumnHandle {
     pub(crate) file_slice: FileSlice,
@@ -180,53 +56,31 @@ pub struct DynamicColumnHandle {
 }
 
 impl DynamicColumnHandle {
-    // TODO rename load
     pub fn open(&self) -> io::Result<DynamicColumn> {
         let column_bytes: OwnedBytes = self.file_slice.read_bytes()?;
         self.open_internal(column_bytes)
     }
 
-    // TODO rename load_async
     pub async fn open_async(&self) -> io::Result<DynamicColumn> {
         let column_bytes: OwnedBytes = self.file_slice.read_bytes_async().await?;
         self.open_internal(column_bytes)
     }
 
-    /// Returns the `u64` fast field reader reader associated with `fields` of types
-    /// Str, u64, i64, f64, or datetime.
-    ///
-    /// If not, the fastfield reader will returns the u64-value associated with the original
-    /// FastValue.
-    pub fn open_u64_lenient(&self) -> io::Result<Option<Column<u64>>> {
-        let column_bytes = self.file_slice.read_bytes()?;
-        match self.column_type {
-            ColumnType::Str | ColumnType::Bytes => {
-                let column: BytesColumn = crate::column::open_column_bytes(column_bytes)?;
-                Ok(Some(column.term_ord_column))
-            }
-            ColumnType::Bool => Ok(None),
-            ColumnType::IpAddr => Ok(None),
-            ColumnType::I64 | ColumnType::U64 | ColumnType::F64 | ColumnType::DateTime => {
-                let column = crate::column::open_column_u64::<u64>(column_bytes)?;
-                Ok(Some(column))
-            }
-        }
-    }
-
     fn open_internal(&self, column_bytes: OwnedBytes) -> io::Result<DynamicColumn> {
         let dynamic_column: DynamicColumn = match self.column_type {
-            ColumnType::Bytes => {
-                crate::column::open_column_bytes::<BytesColumn>(column_bytes)?.into()
-            }
-            ColumnType::Str => crate::column::open_column_bytes::<StrColumn>(column_bytes)?.into(),
-            ColumnType::I64 => crate::column::open_column_u64::<i64>(column_bytes)?.into(),
-            ColumnType::U64 => crate::column::open_column_u64::<u64>(column_bytes)?.into(),
-            ColumnType::F64 => crate::column::open_column_u64::<f64>(column_bytes)?.into(),
+            ColumnType::Bytes => crate::column::open_column_bytes(column_bytes)?.into(),
+            ColumnType::Numerical(numerical_type) => match numerical_type {
+                crate::NumericalType::I64 => {
+                    crate::column::open_column_u64::<i64>(column_bytes)?.into()
+                }
+                crate::NumericalType::U64 => {
+                    crate::column::open_column_u64::<u64>(column_bytes)?.into()
+                }
+                crate::NumericalType::F64 => {
+                    crate::column::open_column_u64::<f64>(column_bytes)?.into()
+                }
+            },
             ColumnType::Bool => crate::column::open_column_u64::<bool>(column_bytes)?.into(),
-            ColumnType::IpAddr => crate::column::open_column_u128::<Ipv6Addr>(column_bytes)?.into(),
-            ColumnType::DateTime => {
-                crate::column::open_column_u64::<crate::DateTime>(column_bytes)?.into()
-            }
         };
         Ok(dynamic_column)
     }

columnar/src/lib.rs

@@ -18,25 +18,16 @@ mod dynamic_column;
 pub(crate) mod utils;
 mod value;
 
-pub use column::{BytesColumn, Column, StrColumn};
-pub use column_index::ColumnIndex;
-pub use column_values::{ColumnValues, MonotonicallyMappableToU128, MonotonicallyMappableToU64};
-pub use columnar::{
-    merge_columnar, ColumnType, ColumnarReader, ColumnarWriter, HasAssociatedColumnType,
-    MergeDocOrder,
-};
-use sstable::VoidSSTable;
+pub use columnar::{ColumnarReader, ColumnarWriter};
 pub use value::{NumericalType, NumericalValue};
 
-pub use self::dynamic_column::{DynamicColumn, DynamicColumnHandle};
+// pub use self::dynamic_column::DynamicColumnHandle;
 
 pub type RowId = u32;
-pub use sstable::Dictionary;
-pub type Streamer<'a> = sstable::Streamer<'a, VoidSSTable>;
 
-#[derive(Clone, Copy, PartialOrd, PartialEq, Default, Debug)]
+#[derive(Clone, Copy)]
 pub struct DateTime {
-    pub timestamp_micros: i64,
+    timestamp_micros: i64,
 }
 
 #[derive(Copy, Clone, Debug)]

columnar/src/tests.rs

@@ -1,13 +1,10 @@
-use std::net::Ipv6Addr;
-
-use crate::column_values::MonotonicallyMappableToU128;
 use crate::columnar::ColumnType;
 use crate::dynamic_column::{DynamicColumn, DynamicColumnHandle};
 use crate::value::NumericalValue;
 use crate::{Cardinality, ColumnarReader, ColumnarWriter};
 
 #[test]
-fn test_dataframe_writer_str() {
+fn test_dataframe_writer_bytes() {
     let mut dataframe_writer = ColumnarWriter::default();
     dataframe_writer.record_str(1u32, "my_string", "hello");
     dataframe_writer.record_str(3u32, "my_string", "helloeee");
@@ -17,21 +14,7 @@ fn test_dataframe_writer_str() {
     assert_eq!(columnar.num_columns(), 1);
     let cols: Vec<DynamicColumnHandle> = columnar.read_columns("my_string").unwrap();
     assert_eq!(cols.len(), 1);
-    assert_eq!(cols[0].num_bytes(), 158);
-}
-
-#[test]
-fn test_dataframe_writer_bytes() {
-    let mut dataframe_writer = ColumnarWriter::default();
-    dataframe_writer.record_bytes(1u32, "my_string", b"hello");
-    dataframe_writer.record_bytes(3u32, "my_string", b"helloeee");
-    let mut buffer: Vec<u8> = Vec::new();
-    dataframe_writer.serialize(5, &mut buffer).unwrap();
-    let columnar = ColumnarReader::open(buffer).unwrap();
-    assert_eq!(columnar.num_columns(), 1);
-    let cols: Vec<DynamicColumnHandle> = columnar.read_columns("my_string").unwrap();
-    assert_eq!(cols.len(), 1);
-    assert_eq!(cols[0].num_bytes(), 158);
+    assert_eq!(cols[0].num_bytes(), 165);
 }
 
 #[test]
@@ -45,7 +28,7 @@ fn test_dataframe_writer_bool() {
     assert_eq!(columnar.num_columns(), 1);
     let cols: Vec<DynamicColumnHandle> = columnar.read_columns("bool.value").unwrap();
     assert_eq!(cols.len(), 1);
-    assert_eq!(cols[0].num_bytes(), 22);
+    assert_eq!(cols[0].num_bytes(), 29);
     assert_eq!(cols[0].column_type(), ColumnType::Bool);
     let dyn_bool_col = cols[0].open().unwrap();
     let DynamicColumn::Bool(bool_col) = dyn_bool_col else { panic!(); };
@@ -53,59 +36,6 @@ fn test_dataframe_writer_bool() {
     assert_eq!(&vals, &[None, Some(false), None, Some(true), None,]);
 }
 
-#[test]
-fn test_dataframe_writer_u64_multivalued() {
-    let mut dataframe_writer = ColumnarWriter::default();
-    dataframe_writer.record_numerical(2u32, "divisor", 2u64);
-    dataframe_writer.record_numerical(3u32, "divisor", 3u64);
-    dataframe_writer.record_numerical(4u32, "divisor", 2u64);
-    dataframe_writer.record_numerical(5u32, "divisor", 5u64);
-    dataframe_writer.record_numerical(6u32, "divisor", 2u64);
-    dataframe_writer.record_numerical(6u32, "divisor", 3u64);
-    let mut buffer: Vec<u8> = Vec::new();
-    dataframe_writer.serialize(7, &mut buffer).unwrap();
-    let columnar = ColumnarReader::open(buffer).unwrap();
-    assert_eq!(columnar.num_columns(), 1);
-    let cols: Vec<DynamicColumnHandle> = columnar.read_columns("divisor").unwrap();
-    assert_eq!(cols.len(), 1);
-    assert_eq!(cols[0].num_bytes(), 29);
-    let dyn_i64_col = cols[0].open().unwrap();
-    let DynamicColumn::I64(divisor_col) = dyn_i64_col else { panic!(); };
-    assert_eq!(
-        divisor_col.get_cardinality(),
-        crate::Cardinality::Multivalued
-    );
-    assert_eq!(divisor_col.num_rows(), 7);
-}
-
-#[test]
-fn test_dataframe_writer_ip_addr() {
-    let mut dataframe_writer = ColumnarWriter::default();
-    dataframe_writer.record_ip_addr(1, "ip_addr", Ipv6Addr::from_u128(1001));
-    dataframe_writer.record_ip_addr(3, "ip_addr", Ipv6Addr::from_u128(1050));
-    let mut buffer: Vec<u8> = Vec::new();
-    dataframe_writer.serialize(5, &mut buffer).unwrap();
-    let columnar = ColumnarReader::open(buffer).unwrap();
-    assert_eq!(columnar.num_columns(), 1);
-    let cols: Vec<DynamicColumnHandle> = columnar.read_columns("ip_addr").unwrap();
-    assert_eq!(cols.len(), 1);
-    assert_eq!(cols[0].num_bytes(), 42);
-    assert_eq!(cols[0].column_type(), ColumnType::IpAddr);
-    let dyn_bool_col = cols[0].open().unwrap();
-    let DynamicColumn::IpAddr(ip_col) = dyn_bool_col else { panic!(); };
-    let vals: Vec<Option<Ipv6Addr>> = (0..5).map(|row_id| ip_col.first(row_id)).collect();
-    assert_eq!(
-        &vals,
-        &[
-            None,
-            Some(Ipv6Addr::from_u128(1001)),
-            None,
-            Some(Ipv6Addr::from_u128(1050)),
-            None,
-        ]
-    );
-}
-
 #[test]
 fn test_dataframe_writer_numerical() {
     let mut dataframe_writer = ColumnarWriter::default();
@@ -123,7 +53,7 @@ fn test_dataframe_writer_numerical() {
     // - header 14 bytes
     // - vals  8 //< due to padding? could have been 1byte?.
     // - null footer 6 bytes
-    assert_eq!(cols[0].num_bytes(), 33);
+    assert_eq!(cols[0].num_bytes(), 40);
     let column = cols[0].open().unwrap();
     let DynamicColumn::I64(column_i64) = column else { panic!(); };
     assert_eq!(column_i64.idx.get_cardinality(), Cardinality::Optional);
@@ -137,76 +67,18 @@ fn test_dataframe_writer_numerical() {
 }
 
 #[test]
-fn test_dictionary_encoded_str() {
+fn test_dictionary_encoded() {
     let mut buffer = Vec::new();
     let mut columnar_writer = ColumnarWriter::default();
-    columnar_writer.record_str(1, "my.column", "a");
-    columnar_writer.record_str(3, "my.column", "c");
+    columnar_writer.record_str(1, "my.column", "my.key");
+    columnar_writer.record_str(3, "my.column", "my.key2");
     columnar_writer.record_str(3, "my.column2", "different_column!");
-    columnar_writer.record_str(4, "my.column", "b");
     columnar_writer.serialize(5, &mut buffer).unwrap();
     let columnar_reader = ColumnarReader::open(buffer).unwrap();
     assert_eq!(columnar_reader.num_columns(), 2);
     let col_handles = columnar_reader.read_columns("my.column").unwrap();
     assert_eq!(col_handles.len(), 1);
     let DynamicColumn::Str(str_col) = col_handles[0].open().unwrap() else  { panic!(); };
-    let index: Vec<Option<u64>> = (0..5).map(|row_id| str_col.ords().first(row_id)).collect();
-    assert_eq!(index, &[None, Some(0), None, Some(2), Some(1)]);
     assert_eq!(str_col.num_rows(), 5);
-    let mut term_buffer = String::new();
-    let term_ords = str_col.ords();
-    assert_eq!(term_ords.first(0), None);
-    assert_eq!(term_ords.first(1), Some(0));
-    str_col.ord_to_str(0u64, &mut term_buffer).unwrap();
-    assert_eq!(term_buffer, "a");
-    assert_eq!(term_ords.first(2), None);
-    assert_eq!(term_ords.first(3), Some(2));
-    str_col.ord_to_str(2u64, &mut term_buffer).unwrap();
-    assert_eq!(term_buffer, "c");
-    assert_eq!(term_ords.first(4), Some(1));
-    str_col.ord_to_str(1u64, &mut term_buffer).unwrap();
-    assert_eq!(term_buffer, "b");
-}
-
-#[test]
-fn test_dictionary_encoded_bytes() {
-    let mut buffer = Vec::new();
-    let mut columnar_writer = ColumnarWriter::default();
-    columnar_writer.record_bytes(1, "my.column", b"a");
-    columnar_writer.record_bytes(3, "my.column", b"c");
-    columnar_writer.record_bytes(3, "my.column2", b"different_column!");
-    columnar_writer.record_bytes(4, "my.column", b"b");
-    columnar_writer.serialize(5, &mut buffer).unwrap();
-    let columnar_reader = ColumnarReader::open(buffer).unwrap();
-    assert_eq!(columnar_reader.num_columns(), 2);
-    let col_handles = columnar_reader.read_columns("my.column").unwrap();
-    assert_eq!(col_handles.len(), 1);
-    let DynamicColumn::Bytes(bytes_col) = col_handles[0].open().unwrap() else  { panic!(); };
-    let index: Vec<Option<u64>> = (0..5)
-        .map(|row_id| bytes_col.ords().first(row_id))
-        .collect();
-    assert_eq!(index, &[None, Some(0), None, Some(2), Some(1)]);
-    assert_eq!(bytes_col.num_rows(), 5);
-    let mut term_buffer = Vec::new();
-    let term_ords = bytes_col.ords();
-    assert_eq!(term_ords.first(0), None);
-    assert_eq!(term_ords.first(1), Some(0));
-    bytes_col
-        .dictionary
-        .ord_to_term(0u64, &mut term_buffer)
-        .unwrap();
-    assert_eq!(term_buffer, b"a");
-    assert_eq!(term_ords.first(2), None);
-    assert_eq!(term_ords.first(3), Some(2));
-    bytes_col
-        .dictionary
-        .ord_to_term(2u64, &mut term_buffer)
-        .unwrap();
-    assert_eq!(term_buffer, b"c");
-    assert_eq!(term_ords.first(4), Some(1));
-    bytes_col
-        .dictionary
-        .ord_to_term(1u64, &mut term_buffer)
-        .unwrap();
-    assert_eq!(term_buffer, b"b");
+    // let term_ords = (0..)
 }

columnar/src/value.rs

@@ -1,22 +1,12 @@
 use crate::InvalidData;
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum NumericalValue {
     I64(i64),
     U64(u64),
     F64(f64),
 }
 
-impl NumericalValue {
-    pub fn numerical_type(&self) -> NumericalType {
-        match self {
-            NumericalValue::I64(_) => NumericalType::I64,
-            NumericalValue::U64(_) => NumericalType::U64,
-            NumericalValue::F64(_) => NumericalType::F64,
-        }
-    }
-}
-
 impl From<u64> for NumericalValue {
     fn from(val: u64) -> NumericalValue {
         NumericalValue::U64(val)
@@ -35,6 +25,18 @@ impl From<f64> for NumericalValue {
     }
 }
 
+impl NumericalValue {
+    pub fn numerical_type(&self) -> NumericalType {
+        match self {
+            NumericalValue::F64(_) => NumericalType::F64,
+            NumericalValue::I64(_) => NumericalType::I64,
+            NumericalValue::U64(_) => NumericalType::U64,
+        }
+    }
+}
+
+impl Eq for NumericalValue {}
+
 #[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq)]
 #[repr(u8)]
 pub enum NumericalType {
@@ -104,13 +106,6 @@ impl Coerce for f64 {
     }
 }
 
-impl Coerce for crate::DateTime {
-    fn coerce(value: NumericalValue) -> Self {
-        let timestamp_micros = i64::coerce(value);
-        crate::DateTime { timestamp_micros }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::NumericalType;

examples/aggregation.rs

@@ -13,7 +13,7 @@ use tantivy::aggregation::agg_result::AggregationResults;
 use tantivy::aggregation::metric::AverageAggregation;
 use tantivy::aggregation::AggregationCollector;
 use tantivy::query::TermQuery;
-use tantivy::schema::{self, IndexRecordOption, Schema, TextFieldIndexing};
+use tantivy::schema::{self, Cardinality, IndexRecordOption, Schema, TextFieldIndexing};
 use tantivy::{doc, Index, Term};
 
 fn main() -> tantivy::Result<()> {
@@ -25,9 +25,9 @@ fn main() -> tantivy::Result<()> {
         .set_stored();
     let text_field = schema_builder.add_text_field("text", text_fieldtype);
     let score_fieldtype =
-        crate::schema::NumericOptions::default().set_fast();
+        crate::schema::NumericOptions::default().set_fast(Cardinality::SingleValue);
     let highscore_field = schema_builder.add_f64_field("highscore", score_fieldtype.clone());
-    let price_field = schema_builder.add_f64_field("price", score_fieldtype);
+    let price_field = schema_builder.add_f64_field("price", score_fieldtype.clone());
 
     let schema = schema_builder.build();
 
@@ -112,7 +112,7 @@ fn main() -> tantivy::Result<()> {
                 ],
                 ..Default::default()
             }),
-            sub_aggregation: sub_agg_req_1,
+            sub_aggregation: sub_agg_req_1.clone(),
         }),
     )]
     .into_iter()
@@ -123,7 +123,7 @@ fn main() -> tantivy::Result<()> {
     let searcher = reader.searcher();
     let agg_res: AggregationResults = searcher.search(&term_query, &collector).unwrap();
 
-    let res: Value = serde_json::to_value(agg_res)?;
+    let res: Value = serde_json::to_value(&agg_res)?;
     println!("{}", serde_json::to_string_pretty(&res)?);
 
     Ok(())

examples/custom_collector.rs

@@ -14,7 +14,7 @@ use fastfield_codecs::Column;
 // Importing tantivy...
 use tantivy::collector::{Collector, SegmentCollector};
 use tantivy::query::QueryParser;
-use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
+use tantivy::schema::{Field, Schema, FAST, INDEXED, TEXT};
 use tantivy::{doc, Index, Score, SegmentReader};
 
 #[derive(Default)]
@@ -52,11 +52,11 @@ impl Stats {
 }
 
 struct StatsCollector {
-    field: String,
+    field: Field,
 }
 
 impl StatsCollector {
-    fn with_field(field: String) -> StatsCollector {
+    fn with_field(field: Field) -> StatsCollector {
         StatsCollector { field }
     }
 }
@@ -73,7 +73,7 @@ impl Collector for StatsCollector {
         _segment_local_id: u32,
         segment_reader: &SegmentReader,
     ) -> tantivy::Result<StatsSegmentCollector> {
-        let fast_field_reader = segment_reader.fast_fields().u64(&self.field)?;
+        let fast_field_reader = segment_reader.fast_fields().u64(self.field)?;
         Ok(StatsSegmentCollector {
             fast_field_reader,
             stats: Stats::default(),
@@ -171,9 +171,7 @@ fn main() -> tantivy::Result<()> {
 
     // here we want to get a hit on the 'ken' in Frankenstein
     let query = query_parser.parse_query("broom")?;
-    if let Some(stats) =
-        searcher.search(&query, &StatsCollector::with_field("price".to_string()))?
-    {
+    if let Some(stats) = searcher.search(&query, &StatsCollector::with_field(price))? {
         println!("count: {}", stats.count());
         println!("mean: {}", stats.mean());
         println!("standard deviation: {}", stats.standard_deviation());

examples/date_time_field.rs

@@ -4,7 +4,7 @@
 
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
-use tantivy::schema::{DateOptions, Schema, Value, INDEXED, STORED, STRING};
+use tantivy::schema::{Cardinality, DateOptions, Schema, Value, INDEXED, STORED, STRING};
 use tantivy::Index;
 
 fn main() -> tantivy::Result<()> {
@@ -12,7 +12,7 @@ fn main() -> tantivy::Result<()> {
     let mut schema_builder = Schema::builder();
     let opts = DateOptions::from(INDEXED)
         .set_stored()
-        .set_fast()
+        .set_fast(Cardinality::SingleValue)
         .set_precision(tantivy::DatePrecision::Seconds);
     let occurred_at = schema_builder.add_date_field("occurred_at", opts);
     let event_type = schema_builder.add_text_field("event", STRING | STORED);

examples/integer_range_search.rs

@@ -27,7 +27,7 @@ fn main() -> Result<()> {
     reader.reload()?;
     let searcher = reader.searcher();
     // The end is excluded i.e. here we are searching up to 1969
-    let docs_in_the_sixties = RangeQuery::new_u64("year".to_string(), 1960..1970);
+    let docs_in_the_sixties = RangeQuery::new_u64(year_field, 1960..1970);
     // Uses a Count collector to sum the total number of docs in the range
     let num_60s_books = searcher.search(&docs_in_the_sixties, &Count)?;
     assert_eq!(num_60s_books, 10);

examples/warmer.rs

@@ -4,7 +4,7 @@ use std::sync::{Arc, RwLock, Weak};
 
 use tantivy::collector::TopDocs;
 use tantivy::query::QueryParser;
-use tantivy::schema::{Schema, FAST, TEXT};
+use tantivy::schema::{Field, Schema, FAST, TEXT};
 use tantivy::{
     doc, DocAddress, DocId, Index, IndexReader, Opstamp, Searcher, SearcherGeneration, SegmentId,
     SegmentReader, Warmer,
@@ -25,13 +25,13 @@ pub trait PriceFetcher: Send + Sync + 'static {
 }
 
 struct DynamicPriceColumn {
-    field: String,
+    field: Field,
     price_cache: RwLock<HashMap<(SegmentId, Option<Opstamp>), Arc<Vec<Price>>>>,
     price_fetcher: Box<dyn PriceFetcher>,
 }
 
 impl DynamicPriceColumn {
-    pub fn with_product_id_field<T: PriceFetcher>(field: String, price_fetcher: T) -> Self {
+    pub fn with_product_id_field<T: PriceFetcher>(field: Field, price_fetcher: T) -> Self {
         DynamicPriceColumn {
             field,
             price_cache: Default::default(),
@@ -48,7 +48,7 @@ impl Warmer for DynamicPriceColumn {
     fn warm(&self, searcher: &Searcher) -> tantivy::Result<()> {
         for segment in searcher.segment_readers() {
             let key = (segment.segment_id(), segment.delete_opstamp());
-            let product_id_reader = segment.fast_fields().u64(&self.field)?;
+            let product_id_reader = segment.fast_fields().u64(self.field)?;
             let product_ids: Vec<ProductId> = segment
                 .doc_ids_alive()
                 .map(|doc| product_id_reader.get_val(doc))
@@ -123,7 +123,7 @@ fn main() -> tantivy::Result<()> {
 
     let price_table = ExternalPriceTable::default();
     let price_dynamic_column = Arc::new(DynamicPriceColumn::with_product_id_field(
-        "product_id".to_string(),
+        product_id,
         price_table.clone(),
     ));
     price_table.update_price(OLIVE_OIL, 12);

fastfield_codecs/Cargo.toml

@@ -14,7 +14,6 @@ repository = "https://github.com/quickwit-oss/tantivy"
 [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"

fastfield_codecs/src/bitpacked.rs

@@ -0,0 +1,116 @@
+use std::io::{self, Write};
+
+use common::OwnedBytes;
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use crate::serialize::NormalizedHeader;
+use crate::{Column, 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 Column 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 Column, 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 Column) -> 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::tests::get_codec_test_datasets;
+
+    fn create_and_validate(data: &[u64], name: &str) {
+        crate::tests::create_and_validate::<BitpackedCodec>(data, name);
+    }
+
+    #[test]
+    fn test_with_codec_data_sets() {
+        let data_sets = 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 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(&data, "rand");
+
+            data.reverse();
+            create_and_validate(&data, "rand");
+        }
+    }
+}

fastfield_codecs/src/blockwise_linear.rs

@@ -0,0 +1,188 @@
+use std::sync::Arc;
+use std::{io, iter};
+
+use common::{BinarySerializable, CountingWriter, DeserializeFrom, OwnedBytes};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use crate::line::Line;
+use crate::serialize::NormalizedHeader;
+use crate::{Column, 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: crate::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 crate::Column) -> 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 Column, 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 Column 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
+    }
+}

fastfield_codecs/src/column.rs

@@ -0,0 +1,352 @@
+use std::fmt::{self, Debug};
+use std::marker::PhantomData;
+use std::ops::{Range, RangeInclusive};
+
+use tantivy_bitpacker::minmax;
+
+use crate::monotonic_mapping::StrictlyMonotonicFn;
+
+/// `Column` provides columnar access on a field.
+pub trait Column<T: PartialOrd + Debug = u64>: Send + Sync {
+    /// Return the value associated with the given idx.
+    ///
+    /// This accessor should return as fast as possible.
+    ///
+    /// # Panics
+    ///
+    /// May panic if `idx` is greater than the column length.
+    fn get_val(&self, idx: u32) -> T;
+
+    /// Fills an output buffer with the fast field values
+    /// associated with the `DocId` going from
+    /// `start` to `start + output.len()`.
+    ///
+    /// # Panics
+    ///
+    /// Must panic if `start + output.len()` is greater than
+    /// the segment's `maxdoc`.
+    #[inline]
+    fn get_range(&self, start: u64, output: &mut [T]) {
+        for (out, idx) in output.iter_mut().zip(start..) {
+            *out = self.get_val(idx as u32);
+        }
+    }
+
+    /// Get the positions of values which are in the provided value range.
+    ///
+    /// Note that position == docid for single value fast fields
+    #[inline]
+    fn get_docids_for_value_range(
+        &self,
+        value_range: RangeInclusive<T>,
+        doc_id_range: Range<u32>,
+        positions: &mut Vec<u32>,
+    ) {
+        let doc_id_range = doc_id_range.start..doc_id_range.end.min(self.num_vals());
+
+        for idx in doc_id_range.start..doc_id_range.end {
+            let val = self.get_val(idx);
+            if value_range.contains(&val) {
+                positions.push(idx);
+            }
+        }
+    }
+
+    /// Returns the minimum value for this fast field.
+    ///
+    /// This min_value may not be exact.
+    /// For instance, the min value does not take in account of possible
+    /// deleted document. All values are however guaranteed to be higher than
+    /// `.min_value()`.
+    fn min_value(&self) -> T;
+
+    /// Returns the maximum value for this fast field.
+    ///
+    /// This max_value may not be exact.
+    /// For instance, the max value does not take in account of possible
+    /// deleted document. All values are however guaranteed to be higher than
+    /// `.max_value()`.
+    fn max_value(&self) -> T;
+
+    /// The number of values in the column.
+    fn num_vals(&self) -> u32;
+
+    /// Returns a iterator over the data
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = T> + 'a> {
+        Box::new((0..self.num_vals()).map(|idx| self.get_val(idx)))
+    }
+}
+
+/// VecColumn provides `Column` over a slice.
+pub struct VecColumn<'a, T = u64> {
+    values: &'a [T],
+    min_value: T,
+    max_value: T,
+}
+
+impl<'a, C: Column<T>, T: Copy + PartialOrd + fmt::Debug> Column<T> for &'a C {
+    fn get_val(&self, idx: u32) -> T {
+        (*self).get_val(idx)
+    }
+
+    fn min_value(&self) -> T {
+        (*self).min_value()
+    }
+
+    fn max_value(&self) -> T {
+        (*self).max_value()
+    }
+
+    fn num_vals(&self) -> u32 {
+        (*self).num_vals()
+    }
+
+    fn iter<'b>(&'b self) -> Box<dyn Iterator<Item = T> + 'b> {
+        (*self).iter()
+    }
+
+    fn get_range(&self, start: u64, output: &mut [T]) {
+        (*self).get_range(start, output)
+    }
+}
+
+impl<'a, T: Copy + PartialOrd + Send + Sync + Debug> Column<T> for VecColumn<'a, T> {
+    fn get_val(&self, position: u32) -> T {
+        self.values[position as usize]
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = T> + '_> {
+        Box::new(self.values.iter().copied())
+    }
+
+    fn min_value(&self) -> T {
+        self.min_value
+    }
+
+    fn max_value(&self) -> T {
+        self.max_value
+    }
+
+    fn num_vals(&self) -> u32 {
+        self.values.len() as u32
+    }
+
+    fn get_range(&self, start: u64, output: &mut [T]) {
+        output.copy_from_slice(&self.values[start as usize..][..output.len()])
+    }
+}
+
+impl<'a, T: Copy + PartialOrd + Default, V> From<&'a V> for VecColumn<'a, T>
+where V: AsRef<[T]> + ?Sized
+{
+    fn from(values: &'a V) -> Self {
+        let values = values.as_ref();
+        let (min_value, max_value) = minmax(values.iter().copied()).unwrap_or_default();
+        Self {
+            values,
+            min_value,
+            max_value,
+        }
+    }
+}
+
+struct MonotonicMappingColumn<C, T, Input> {
+    from_column: C,
+    monotonic_mapping: T,
+    _phantom: PhantomData<Input>,
+}
+
+/// Creates a view of a column transformed by a strictly monotonic mapping. See
+/// [`StrictlyMonotonicFn`].
+///
+/// E.g. apply a gcd monotonic_mapping([100, 200, 300]) == [1, 2, 3]
+/// monotonic_mapping.mapping() is expected to be injective, and we should always have
+/// monotonic_mapping.inverse(monotonic_mapping.mapping(el)) == el
+///
+/// The inverse of the mapping is required for:
+/// `fn get_positions_for_value_range(&self, range: RangeInclusive<T>) -> Vec<u64> `
+/// The user provides the original value range and we need to monotonic map them in the same way the
+/// serialization does before calling the underlying column.
+///
+/// Note that when opening a codec, the monotonic_mapping should be the inverse of the mapping
+/// during serialization. And therefore the monotonic_mapping_inv when opening is the same as
+/// monotonic_mapping during serialization.
+pub fn monotonic_map_column<C, T, Input, Output>(
+    from_column: C,
+    monotonic_mapping: T,
+) -> impl Column<Output>
+where
+    C: Column<Input>,
+    T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
+    Input: PartialOrd + Send + Sync + Copy + Debug,
+    Output: PartialOrd + Send + Sync + Copy + Debug,
+{
+    MonotonicMappingColumn {
+        from_column,
+        monotonic_mapping,
+        _phantom: PhantomData,
+    }
+}
+
+impl<C, T, Input, Output> Column<Output> for MonotonicMappingColumn<C, T, Input>
+where
+    C: Column<Input>,
+    T: StrictlyMonotonicFn<Input, Output> + Send + Sync,
+    Input: PartialOrd + Send + Sync + Copy + Debug,
+    Output: PartialOrd + Send + Sync + Copy + Debug,
+{
+    #[inline]
+    fn get_val(&self, idx: u32) -> Output {
+        let from_val = self.from_column.get_val(idx);
+        self.monotonic_mapping.mapping(from_val)
+    }
+
+    fn min_value(&self) -> Output {
+        let from_min_value = self.from_column.min_value();
+        self.monotonic_mapping.mapping(from_min_value)
+    }
+
+    fn max_value(&self) -> Output {
+        let from_max_value = self.from_column.max_value();
+        self.monotonic_mapping.mapping(from_max_value)
+    }
+
+    fn num_vals(&self) -> u32 {
+        self.from_column.num_vals()
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = Output> + '_> {
+        Box::new(
+            self.from_column
+                .iter()
+                .map(|el| self.monotonic_mapping.mapping(el)),
+        )
+    }
+
+    fn get_docids_for_value_range(
+        &self,
+        range: RangeInclusive<Output>,
+        doc_id_range: Range<u32>,
+        positions: &mut Vec<u32>,
+    ) {
+        if range.start() > &self.max_value() || range.end() < &self.min_value() {
+            return;
+        }
+        let range = self.monotonic_mapping.inverse_coerce(range);
+        if range.start() > range.end() {
+            return;
+        }
+        self.from_column
+            .get_docids_for_value_range(range, doc_id_range, positions)
+    }
+
+    // We voluntarily do not implement get_range as it yields a regression,
+    // and we do not have any specialized implementation anyway.
+}
+
+/// Wraps an iterator into a `Column`.
+pub struct IterColumn<T>(T);
+
+impl<T> From<T> for IterColumn<T>
+where T: Iterator + Clone + ExactSizeIterator
+{
+    fn from(iter: T) -> Self {
+        IterColumn(iter)
+    }
+}
+
+impl<T> Column<T::Item> for IterColumn<T>
+where
+    T: Iterator + Clone + ExactSizeIterator + Send + Sync,
+    T::Item: PartialOrd + fmt::Debug,
+{
+    fn get_val(&self, idx: u32) -> T::Item {
+        self.0.clone().nth(idx as usize).unwrap()
+    }
+
+    fn min_value(&self) -> T::Item {
+        self.0.clone().next().unwrap()
+    }
+
+    fn max_value(&self) -> T::Item {
+        self.0.clone().last().unwrap()
+    }
+
+    fn num_vals(&self) -> u32 {
+        self.0.len() as u32
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item = T::Item> + '_> {
+        Box::new(self.0.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::monotonic_mapping::{
+        StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternalBaseval,
+        StrictlyMonotonicMappingToInternalGCDBaseval,
+    };
+
+    #[test]
+    fn test_monotonic_mapping() {
+        let vals = &[3u64, 5u64][..];
+        let col = VecColumn::from(vals);
+        let mapped = monotonic_map_column(col, StrictlyMonotonicMappingToInternalBaseval::new(2));
+        assert_eq!(mapped.min_value(), 1u64);
+        assert_eq!(mapped.max_value(), 3u64);
+        assert_eq!(mapped.num_vals(), 2);
+        assert_eq!(mapped.num_vals(), 2);
+        assert_eq!(mapped.get_val(0), 1);
+        assert_eq!(mapped.get_val(1), 3);
+    }
+
+    #[test]
+    fn test_range_as_col() {
+        let col = IterColumn::from(10..100);
+        assert_eq!(col.num_vals(), 90);
+        assert_eq!(col.max_value(), 99);
+    }
+
+    #[test]
+    fn test_monotonic_mapping_iter() {
+        let vals: Vec<u64> = (10..110u64).map(|el| el * 10).collect();
+        let col = VecColumn::from(&vals);
+        let mapped = monotonic_map_column(
+            col,
+            StrictlyMonotonicMappingInverter::from(
+                StrictlyMonotonicMappingToInternalGCDBaseval::new(10, 100),
+            ),
+        );
+        let val_i64s: Vec<u64> = mapped.iter().collect();
+        for i in 0..100 {
+            assert_eq!(val_i64s[i as usize], mapped.get_val(i));
+        }
+    }
+
+    #[test]
+    fn test_monotonic_mapping_get_range() {
+        let vals: Vec<u64> = (0..100u64).map(|el| el * 10).collect();
+        let col = VecColumn::from(&vals);
+        let mapped = monotonic_map_column(
+            col,
+            StrictlyMonotonicMappingInverter::from(
+                StrictlyMonotonicMappingToInternalGCDBaseval::new(10, 0),
+            ),
+        );
+
+        assert_eq!(mapped.min_value(), 0u64);
+        assert_eq!(mapped.max_value(), 9900u64);
+        assert_eq!(mapped.num_vals(), 100);
+        let val_u64s: Vec<u64> = mapped.iter().collect();
+        assert_eq!(val_u64s.len(), 100);
+        for i in 0..100 {
+            assert_eq!(val_u64s[i as usize], mapped.get_val(i));
+            assert_eq!(val_u64s[i as usize], vals[i as usize] * 10);
+        }
+        let mut buf = [0u64; 20];
+        mapped.get_range(7, &mut buf[..]);
+        assert_eq!(&val_u64s[7..][..20], &buf);
+    }
+}

fastfield_codecs/src/compact_space/blank_range.rs

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

fastfield_codecs/src/compact_space/build_compact_space.rs

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

fastfield_codecs/src/compact_space/mod.rs

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

fastfield_codecs/src/format_version.rs

@@ -0,0 +1,38 @@
+use std::io;
+
+use common::{BinarySerializable, OwnedBytes};
+
+const MAGIC_NUMBER: u16 = 4335u16;
+const FASTFIELD_FORMAT_VERSION: u8 = 1;
+
+pub(crate) fn append_format_version(output: &mut impl io::Write) -> io::Result<()> {
+    FASTFIELD_FORMAT_VERSION.serialize(output)?;
+    MAGIC_NUMBER.serialize(output)?;
+
+    Ok(())
+}
+
+pub(crate) fn read_format_version(data: OwnedBytes) -> io::Result<(OwnedBytes, u8)> {
+    let (data, magic_number_bytes) = data.rsplit(2);
+
+    let magic_number = u16::deserialize(&mut magic_number_bytes.as_slice())?;
+    if magic_number != MAGIC_NUMBER {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("magic number mismatch {} != {}", magic_number, MAGIC_NUMBER),
+        ));
+    }
+    let (data, format_version_bytes) = data.rsplit(1);
+    let format_version = u8::deserialize(&mut format_version_bytes.as_slice())?;
+    if format_version > FASTFIELD_FORMAT_VERSION {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!(
+                "Unsupported fastfield format version: {}. Max supported version: {}",
+                format_version, FASTFIELD_FORMAT_VERSION
+            ),
+        ));
+    }
+
+    Ok((data, format_version))
+}

fastfield_codecs/src/gcd.rs

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

fastfield_codecs/src/lib.rs

@@ -7,4 +7,562 @@
 //! - Encode data in different codecs.
 //! - Monotonically map values to u64/u128
 
-pub use columnar::ColumnValues as Column;
+#[cfg(test)]
+#[macro_use]
+extern crate more_asserts;
+
+#[cfg(all(test, feature = "unstable"))]
+extern crate test;
+
+use std::io::Write;
+use std::sync::Arc;
+use std::{fmt, io};
+
+use common::{BinarySerializable, OwnedBytes};
+use compact_space::CompactSpaceDecompressor;
+use format_version::read_format_version;
+use monotonic_mapping::{
+    StrictlyMonotonicMappingInverter, StrictlyMonotonicMappingToInternal,
+    StrictlyMonotonicMappingToInternalBaseval, StrictlyMonotonicMappingToInternalGCDBaseval,
+};
+use null_index_footer::read_null_index_footer;
+use serialize::{Header, U128Header};
+
+mod bitpacked;
+mod blockwise_linear;
+mod compact_space;
+mod format_version;
+mod line;
+mod linear;
+mod monotonic_mapping;
+mod monotonic_mapping_u128;
+#[allow(dead_code)]
+mod null_index;
+mod null_index_footer;
+
+mod column;
+mod gcd;
+pub mod serialize;
+
+use self::bitpacked::BitpackedCodec;
+use self::blockwise_linear::BlockwiseLinearCodec;
+pub use self::column::{monotonic_map_column, Column, IterColumn, VecColumn};
+use self::linear::LinearCodec;
+pub use self::monotonic_mapping::{MonotonicallyMappableToU64, StrictlyMonotonicFn};
+pub use self::monotonic_mapping_u128::MonotonicallyMappableToU128;
+pub use self::serialize::{
+    estimate, serialize, serialize_and_load, serialize_u128, NormalizedHeader,
+};
+
+#[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)]
+/// Available codecs to use to encode the u128 (via [`MonotonicallyMappableToU128`]) converted data.
+pub enum U128FastFieldCodecType {
+    /// This codec takes a large number space (u128) and reduces it to a compact number space, by
+    /// removing the holes.
+    CompactSpace = 1,
+}
+
+impl BinarySerializable for U128FastFieldCodecType {
+    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 U128FastFieldCodecType {
+    pub(crate) fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub(crate) fn from_code(code: u8) -> Option<Self> {
+        match code {
+            1 => Some(Self::CompactSpace),
+            _ => None,
+        }
+    }
+}
+
+/// Returns the correct codec reader wrapped in the `Arc` for the data.
+pub fn open_u128<Item: MonotonicallyMappableToU128 + fmt::Debug>(
+    bytes: OwnedBytes,
+) -> io::Result<Arc<dyn Column<Item>>> {
+    let (bytes, _format_version) = read_format_version(bytes)?;
+    let (mut bytes, _null_index_footer) = read_null_index_footer(bytes)?;
+    let header = U128Header::deserialize(&mut bytes)?;
+    assert_eq!(header.codec_type, U128FastFieldCodecType::CompactSpace);
+    let reader = CompactSpaceDecompressor::open(bytes)?;
+    let inverted: StrictlyMonotonicMappingInverter<StrictlyMonotonicMappingToInternal<Item>> =
+        StrictlyMonotonicMappingToInternal::<Item>::new().into();
+    Ok(Arc::new(monotonic_map_column(reader, inverted)))
+}
+
+/// Returns the correct codec reader wrapped in the `Arc` for the data.
+pub fn open<T: MonotonicallyMappableToU64 + fmt::Debug>(
+    bytes: OwnedBytes,
+) -> io::Result<Arc<dyn Column<T>>> {
+    let (bytes, _format_version) = read_format_version(bytes)?;
+    let (mut bytes, _null_index_footer) = read_null_index_footer(bytes)?;
+    let header = Header::deserialize(&mut bytes)?;
+    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 + fmt::Debug>(
+    bytes: OwnedBytes,
+    header: &Header,
+) -> io::Result<Arc<dyn Column<Item>>> {
+    let normalized_header = header.normalized();
+    let reader = C::open_from_bytes(bytes, normalized_header)?;
+    let min_value = header.min_value;
+    if let Some(gcd) = header.gcd {
+        let 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.
+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: Column<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 Column, 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 Column) -> Option<f32>;
+}
+
+/// The list of all available codecs for u64 convertible data.
+pub const ALL_CODEC_TYPES: [FastFieldCodecType; 3] = [
+    FastFieldCodecType::Bitpacked,
+    FastFieldCodecType::BlockwiseLinear,
+    FastFieldCodecType::Linear,
+];
+
+#[cfg(test)]
+mod tests {
+
+    use proptest::prelude::*;
+    use proptest::strategy::Strategy;
+    use proptest::{prop_oneof, proptest};
+
+    use crate::bitpacked::BitpackedCodec;
+    use crate::blockwise_linear::BlockwiseLinearCodec;
+    use crate::linear::LinearCodec;
+    use crate::serialize::Header;
+
+    pub(crate) fn create_and_validate<Codec: FastFieldCodec>(
+        data: &[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 out = Vec::new();
+        let col = VecColumn::from(data);
+        serialize(col, &mut out, &[Codec::CODEC_TYPE]).unwrap();
+
+        let actual_compression = out.len() as f32 / (data.len() as f32 * 8.0);
+
+        let reader = crate::open::<u64>(OwnedBytes::new(out)).unwrap();
+        assert_eq!(reader.num_vals(), data.len() as u32);
+        for (doc, orig_val) in data.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:?}`",
+            );
+        }
+
+        if !data.is_empty() {
+            let test_rand_idx = rand::thread_rng().gen_range(0..=data.len() - 1);
+            let expected_positions: Vec<u32> = data
+                .iter()
+                .enumerate()
+                .filter(|(_, el)| **el == data[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,
+                &mut positions,
+            );
+            assert_eq!(expected_positions, positions);
+        }
+        Some((estimation, actual_compression))
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(100))]
+
+        #[test]
+        fn test_proptest_small_bitpacked(data in proptest::collection::vec(num_strategy(), 1..10)) {
+            create_and_validate::<BitpackedCodec>(&data, "proptest bitpacked");
+        }
+
+        #[test]
+        fn test_proptest_small_linear(data in proptest::collection::vec(num_strategy(), 1..10)) {
+            create_and_validate::<LinearCodec>(&data, "proptest linearinterpol");
+        }
+
+        #[test]
+        fn test_proptest_small_blockwise_linear(data in proptest::collection::vec(num_strategy(), 1..10)) {
+            create_and_validate::<BlockwiseLinearCodec>(&data, "proptest multilinearinterpol");
+        }
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(10))]
+
+        #[test]
+        fn test_proptest_large_bitpacked(data in proptest::collection::vec(num_strategy(), 1..6000)) {
+            create_and_validate::<BitpackedCodec>(&data, "proptest bitpacked");
+        }
+
+        #[test]
+        fn test_proptest_large_linear(data in proptest::collection::vec(num_strategy(), 1..6000)) {
+            create_and_validate::<LinearCodec>(&data, "proptest linearinterpol");
+        }
+
+        #[test]
+        fn test_proptest_large_blockwise_linear(data in proptest::collection::vec(num_strategy(), 1..6000)) {
+            create_and_validate::<BlockwiseLinearCodec>(&data, "proptest multilinearinterpol");
+        }
+    }
+
+    fn num_strategy() -> impl Strategy<Value = u64> {
+        prop_oneof![
+            1 => prop::num::u64::ANY.prop_map(|num| u64::MAX - (num % 10) ),
+            1 => prop::num::u64::ANY.prop_map(|num| num % 10 ),
+            20 => prop::num::u64::ANY,
+        ]
+    }
+
+    pub fn get_codec_test_datasets() -> Vec<(Vec<u64>, &'static str)> {
+        let mut data_and_names = vec![];
+
+        let data = vec![10];
+        data_and_names.push((data, "minimal test"));
+
+        let data = (10..=10_000_u64).collect::<Vec<_>>();
+        data_and_names.push((data, "simple monotonically increasing"));
+
+        data_and_names.push((
+            vec![5, 6, 7, 8, 9, 10, 99, 100],
+            "offset in linear interpol",
+        ));
+
+        data_and_names.push((vec![3, 18446744073709551613, 5], "docid range regression"));
+
+        data_and_names.push((vec![5, 50, 3, 13, 1, 1000, 35], "rand small"));
+        data_and_names.push((vec![10], "single value"));
+
+        data_and_names.push((
+            vec![1572656989877777, 1170935903116329, 720575940379279, 0],
+            "overflow error",
+        ));
+
+        data_and_names
+    }
+
+    fn test_codec<C: FastFieldCodec>() {
+        let codec_name = format!("{:?}", C::CODEC_TYPE);
+        for (data, dataset_name) in get_codec_test_datasets() {
+            let estimate_actual_opt: Option<(f32, f32)> =
+                crate::tests::create_and_validate::<C>(&data, dataset_name);
+            let result = if let Some((estimate, actual)) = estimate_actual_opt {
+                format!("Estimate `{estimate}` Actual `{actual}`")
+            } else {
+                "Disabled".to_string()
+            };
+            println!("Codec {codec_name}, DataSet {dataset_name}, {result}");
+        }
+    }
+    #[test]
+    fn test_codec_bitpacking() {
+        test_codec::<BitpackedCodec>();
+    }
+    #[test]
+    fn test_codec_interpolation() {
+        test_codec::<LinearCodec>();
+    }
+    #[test]
+    fn test_codec_multi_interpolation() {
+        test_codec::<BlockwiseLinearCodec>();
+    }
+
+    use super::*;
+
+    #[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();
+        assert_le!(linear_interpol_estimation, 0.01);
+
+        let multi_linear_interpol_estimation = BlockwiseLinearCodec::estimate(&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();
+        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();
+        assert_le!(linear_interpol_estimation, 0.35);
+
+        let bitpacked_estimation = BitpackedCodec::estimate(&data).unwrap();
+        assert_le!(bitpacked_estimation, 0.32);
+        assert_le!(bitpacked_estimation, linear_interpol_estimation);
+    }
+
+    #[test]
+    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) {
+                assert_eq!(codec_type.to_code(), code);
+                count_codec += 1;
+            }
+        }
+        assert_eq!(count_codec, 3);
+    }
+}
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+    use std::sync::Arc;
+
+    use common::OwnedBytes;
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+    use test::{self, Bencher};
+
+    use super::*;
+    use crate::Column;
+
+    fn get_data() -> Vec<u64> {
+        let mut rng = StdRng::seed_from_u64(2u64);
+        let mut data: Vec<_> = (100..55000_u64)
+            .map(|num| num + rng.gen::<u8>() as u64)
+            .collect();
+        data.push(99_000);
+        data.insert(1000, 2000);
+        data.insert(2000, 100);
+        data.insert(3000, 4100);
+        data.insert(4000, 100);
+        data.insert(5000, 800);
+        data
+    }
+
+    #[inline(never)]
+    fn value_iter() -> impl Iterator<Item = u64> {
+        0..20_000
+    }
+    fn get_reader_for_bench<Codec: FastFieldCodec>(data: &[u64]) -> Codec::Reader {
+        let mut bytes = Vec::new();
+        let min_value = *data.iter().min().unwrap();
+        let data = data.iter().map(|el| *el - min_value).collect::<Vec<_>>();
+        let col = VecColumn::from(&data);
+        let normalized_header = crate::NormalizedHeader {
+            num_vals: col.num_vals(),
+            max_value: col.max_value(),
+        };
+        Codec::serialize(&VecColumn::from(&data), &mut bytes).unwrap();
+        Codec::open_from_bytes(OwnedBytes::new(bytes), normalized_header).unwrap()
+    }
+    fn bench_get<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
+        let col = get_reader_for_bench::<Codec>(data);
+        b.iter(|| {
+            let mut sum = 0u64;
+            for pos in value_iter() {
+                let val = col.get_val(pos as u32);
+                sum = sum.wrapping_add(val);
+            }
+            sum
+        });
+    }
+
+    #[inline(never)]
+    fn bench_get_dynamic_helper(b: &mut Bencher, col: Arc<dyn Column>) {
+        b.iter(|| {
+            let mut sum = 0u64;
+            for pos in value_iter() {
+                let val = col.get_val(pos as u32);
+                sum = sum.wrapping_add(val);
+            }
+            sum
+        });
+    }
+
+    fn bench_get_dynamic<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
+        let col = Arc::new(get_reader_for_bench::<Codec>(data));
+        bench_get_dynamic_helper(b, col);
+    }
+    fn bench_create<Codec: FastFieldCodec>(b: &mut Bencher, data: &[u64]) {
+        let min_value = *data.iter().min().unwrap();
+        let data = data.iter().map(|el| *el - min_value).collect::<Vec<_>>();
+
+        let mut bytes = Vec::new();
+        b.iter(|| {
+            bytes.clear();
+            Codec::serialize(&VecColumn::from(&data), &mut bytes).unwrap();
+        });
+    }
+
+    #[bench]
+    fn bench_fastfield_bitpack_create(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_create::<BitpackedCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_linearinterpol_create(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_create::<LinearCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_multilinearinterpol_create(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_create::<BlockwiseLinearCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_bitpack_get(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get::<BitpackedCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_bitpack_get_dynamic(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get_dynamic::<BitpackedCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_linearinterpol_get(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get::<LinearCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_linearinterpol_get_dynamic(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get_dynamic::<LinearCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_multilinearinterpol_get(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get::<BlockwiseLinearCodec>(b, &data);
+    }
+    #[bench]
+    fn bench_fastfield_multilinearinterpol_get_dynamic(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        bench_get_dynamic::<BlockwiseLinearCodec>(b, &data);
+    }
+}

fastfield_codecs/src/line.rs

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

fastfield_codecs/src/linear.rs

@@ -0,0 +1,230 @@
+use std::io::{self, Write};
+
+use common::{BinarySerializable, OwnedBytes};
+use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
+
+use crate::line::Line;
+use crate::serialize::NormalizedHeader;
+use crate::{Column, FastFieldCodec, FastFieldCodecType};
+
+/// Depending on the field type, a different
+/// fast field is required.
+#[derive(Clone)]
+pub struct LinearReader {
+    data: OwnedBytes,
+    linear_params: LinearParams,
+    header: NormalizedHeader,
+}
+
+impl Column 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 Column, 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 Column) -> 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::tests::get_codec_test_datasets;
+
+    fn create_and_validate(data: &[u64], name: &str) -> Option<(f32, f32)> {
+        crate::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 = 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");
+        }
+    }
+}

fastfield_codecs/src/main.rs

@@ -0,0 +1,222 @@
+#[macro_use]
+extern crate prettytable;
+use std::collections::HashSet;
+use std::env;
+use std::io::BufRead;
+use std::net::{IpAddr, Ipv6Addr};
+use std::str::FromStr;
+
+use common::OwnedBytes;
+use fastfield_codecs::{open_u128, serialize_u128, Column, FastFieldCodecType, VecColumn};
+use itertools::Itertools;
+use measure_time::print_time;
+use prettytable::{Cell, Row, Table};
+
+fn print_set_stats(ip_addrs: &[u128]) {
+    println!("NumIps\t{}", ip_addrs.len());
+    let ip_addr_set: HashSet<u128> = ip_addrs.iter().cloned().collect();
+    println!("NumUniqueIps\t{}", ip_addr_set.len());
+    let ratio_unique = ip_addr_set.len() as f64 / ip_addrs.len() as f64;
+    println!("RatioUniqueOverTotal\t{ratio_unique:.4}");
+
+    // histogram
+    let mut ip_addrs = ip_addrs.to_vec();
+    ip_addrs.sort();
+    let mut cnts: Vec<usize> = ip_addrs
+        .into_iter()
+        .dedup_with_count()
+        .map(|(cnt, _)| cnt)
+        .collect();
+    cnts.sort();
+
+    let top_256_cnt: usize = cnts.iter().rev().take(256).sum();
+    let top_128_cnt: usize = cnts.iter().rev().take(128).sum();
+    let top_64_cnt: usize = cnts.iter().rev().take(64).sum();
+    let top_8_cnt: usize = cnts.iter().rev().take(8).sum();
+    let total: usize = cnts.iter().sum();
+
+    println!("{}", total);
+    println!("{}", top_256_cnt);
+    println!("{}", top_128_cnt);
+    println!("Percentage Top8 {:02}", top_8_cnt as f32 / total as f32);
+    println!("Percentage Top64 {:02}", top_64_cnt as f32 / total as f32);
+    println!("Percentage Top128 {:02}", top_128_cnt as f32 / total as f32);
+    println!("Percentage Top256 {:02}", top_256_cnt as f32 / total as f32);
+
+    let mut cnts: Vec<(usize, usize)> = cnts.into_iter().dedup_with_count().collect();
+    cnts.sort_by(|a, b| {
+        if a.1 == b.1 {
+            a.0.cmp(&b.0)
+        } else {
+            b.1.cmp(&a.1)
+        }
+    });
+}
+
+fn ip_dataset() -> Vec<u128> {
+    let mut ip_addr_v4 = 0;
+
+    let stdin = std::io::stdin();
+    let ip_addrs: Vec<u128> = stdin
+        .lock()
+        .lines()
+        .flat_map(|line| {
+            let line = line.unwrap();
+            let line = line.trim();
+            let ip_addr = IpAddr::from_str(line.trim()).ok()?;
+            if ip_addr.is_ipv4() {
+                ip_addr_v4 += 1;
+            }
+            let ip_addr_v6: Ipv6Addr = match ip_addr {
+                IpAddr::V4(v4) => v4.to_ipv6_mapped(),
+                IpAddr::V6(v6) => v6,
+            };
+            Some(ip_addr_v6)
+        })
+        .map(|ip_v6| u128::from_be_bytes(ip_v6.octets()))
+        .collect();
+
+    println!("IpAddrsAny\t{}", ip_addrs.len());
+    println!("IpAddrsV4\t{}", ip_addr_v4);
+
+    ip_addrs
+}
+
+fn bench_ip() {
+    let dataset = ip_dataset();
+    print_set_stats(&dataset);
+
+    // Chunks
+    {
+        let mut data = vec![];
+        for dataset in dataset.chunks(500_000) {
+            serialize_u128(|| dataset.iter().cloned(), dataset.len() as u32, &mut data).unwrap();
+        }
+        let compression = data.len() as f64 / (dataset.len() * 16) as f64;
+        println!("Compression 50_000 chunks {:.4}", compression);
+        println!(
+            "Num Bits per elem {:.2}",
+            (data.len() * 8) as f32 / dataset.len() as f32
+        );
+    }
+
+    let mut data = vec![];
+    {
+        print_time!("creation");
+        serialize_u128(|| dataset.iter().cloned(), dataset.len() as u32, &mut data).unwrap();
+    }
+
+    let compression = data.len() as f64 / (dataset.len() * 16) as f64;
+    println!("Compression {:.2}", compression);
+    println!(
+        "Num Bits per elem {:.2}",
+        (data.len() * 8) as f32 / dataset.len() as f32
+    );
+
+    let decompressor = open_u128::<u128>(OwnedBytes::new(data)).unwrap();
+    // Sample some ranges
+    let mut doc_values = Vec::new();
+    for value in dataset.iter().take(1110).skip(1100).cloned() {
+        doc_values.clear();
+        print_time!("get range");
+        decompressor.get_docids_for_value_range(
+            value..=value,
+            0..decompressor.num_vals(),
+            &mut doc_values,
+        );
+        println!("{:?}", doc_values.len());
+    }
+}
+
+fn main() {
+    if env::args().nth(1).unwrap() == "bench_ip" {
+        bench_ip();
+        return;
+    }
+
+    let mut table = Table::new();
+
+    // Add a row per time
+    table.add_row(row!["", "Compression Ratio", "Compression Estimation"]);
+
+    for (data, data_set_name) in get_codec_test_data_sets() {
+        let results: Vec<(f32, f32, FastFieldCodecType)> = [
+            serialize_with_codec(&data, FastFieldCodecType::Bitpacked),
+            serialize_with_codec(&data, FastFieldCodecType::Linear),
+            serialize_with_codec(&data, FastFieldCodecType::BlockwiseLinear),
+        ]
+        .into_iter()
+        .flatten()
+        .collect();
+        let best_compression_ratio_codec = results
+            .iter()
+            .min_by(|&res1, &res2| res1.partial_cmp(res2).unwrap())
+            .cloned()
+            .unwrap();
+
+        table.add_row(Row::new(vec![Cell::new(data_set_name).style_spec("Bbb")]));
+        for (est, comp, codec_type) in results {
+            let est_cell = est.to_string();
+            let ratio_cell = comp.to_string();
+            let style = if comp == best_compression_ratio_codec.1 {
+                "Fb"
+            } else {
+                ""
+            };
+            table.add_row(Row::new(vec![
+                Cell::new(&format!("{codec_type:?}")).style_spec("bFg"),
+                Cell::new(&ratio_cell).style_spec(style),
+                Cell::new(&est_cell).style_spec(""),
+            ]));
+        }
+    }
+
+    table.printstd();
+}
+
+pub fn get_codec_test_data_sets() -> Vec<(Vec<u64>, &'static str)> {
+    let mut data_and_names = vec![];
+
+    let data = (1000..=200_000_u64).collect::<Vec<_>>();
+    data_and_names.push((data, "Autoincrement"));
+
+    let mut current_cumulative = 0;
+    let data = (1..=200_000_u64)
+        .map(|num| {
+            let num = (num as f32 + num as f32).log10() as u64;
+            current_cumulative += num;
+            current_cumulative
+        })
+        .collect::<Vec<_>>();
+    // let data = (1..=200000_u64).map(|num| num + num).collect::<Vec<_>>();
+    data_and_names.push((data, "Monotonically increasing concave"));
+
+    let mut current_cumulative = 0;
+    let data = (1..=200_000_u64)
+        .map(|num| {
+            let num = (200_000.0 - num as f32).log10() as u64;
+            current_cumulative += num;
+            current_cumulative
+        })
+        .collect::<Vec<_>>();
+    data_and_names.push((data, "Monotonically increasing convex"));
+
+    let data = (1000..=200_000_u64)
+        .map(|num| num + rand::random::<u8>() as u64)
+        .collect::<Vec<_>>();
+    data_and_names.push((data, "Almost monotonically increasing"));
+
+    data_and_names
+}
+
+pub fn serialize_with_codec(
+    data: &[u64],
+    codec_type: FastFieldCodecType,
+) -> Option<(f32, f32, FastFieldCodecType)> {
+    let col = VecColumn::from(data);
+    let estimation = fastfield_codecs::estimate(&col, codec_type)?;
+    let mut out = Vec::new();
+    fastfield_codecs::serialize(&col, &mut out, &[codec_type]).ok()?;
+    let actual_compression = out.len() as f32 / (col.num_vals() * 8) as f32;
+    Some((estimation, actual_compression, codec_type))
+}

fastfield_codecs/src/monotonic_mapping.rs

@@ -0,0 +1,320 @@
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::RangeInclusive;
+
+use fastdivide::DividerU64;
+
+use crate::MonotonicallyMappableToU128;
+
+/// Monotonic maps a value to u64 value space.
+/// Monotonic mapping enables `PartialOrd` on u64 space without conversion to original space.
+pub trait MonotonicallyMappableToU64:
+    'static + PartialOrd + Copy + Send + Sync + fmt::Debug
+{
+    /// Converts a value to u64.
+    ///
+    /// Internally all fast field values are encoded as u64.
+    fn to_u64(self) -> u64;
+
+    /// Converts a value from u64
+    ///
+    /// Internally all fast field values are encoded as u64.
+    /// **Note: To be used for converting encoded Term, Posting values.**
+    fn from_u64(val: u64) -> Self;
+}
+
+/// Values need to be strictly monotonic mapped to a `Internal` value (u64 or u128) that can be
+/// used in fast field codecs.
+///
+/// The monotonic mapping is required so that `PartialOrd` can be used on `Internal` without
+/// converting to `External`.
+///
+/// All strictly monotonic functions are invertible because they are guaranteed to have a one-to-one
+/// mapping from their range to their domain. The `inverse` method is required when opening a codec,
+/// so a value can be converted back to its original domain (e.g. ip address or f64) from its
+/// internal representation.
+pub trait StrictlyMonotonicFn<External: Copy, Internal: Copy> {
+    /// Strictly monotonically maps the value from External to Internal.
+    fn mapping(&self, inp: External) -> Internal;
+    /// Inverse of `mapping`. Maps the value from Internal to External.
+    fn inverse(&self, out: Internal) -> External;
+
+    /// Maps a user provded value from External to Internal.
+    /// It may be necessary to coerce the value if it is outside the value space.
+    /// In that case it tries to find the next greater value in the value space.
+    ///
+    /// Returns a bool to mark if a value was outside the value space and had to be coerced _up_.
+    /// With that information we can detect if two values in a range both map outside the same value
+    /// space.
+    ///
+    /// coerce_up means the next valid upper value in the value space will be chosen if the value
+    /// has to be coerced.
+    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<Internal> {
+        self.mapping(*inp.start())..=self.mapping(*inp.end())
+    }
+    /// Inverse of `mapping_coerce`.
+    fn inverse_coerce(&self, out: RangeInclusive<Internal>) -> RangeInclusive<External> {
+        self.inverse(*out.start())..=self.inverse(*out.end())
+    }
+}
+
+/// Inverts a strictly monotonic mapping from `StrictlyMonotonicFn<A, B>` to
+/// `StrictlyMonotonicFn<B, A>`.
+///
+/// # Warning
+///
+/// This type comes with a footgun. A type being strictly monotonic does not impose that the inverse
+/// mapping is strictly monotonic over the entire space External. e.g. a -> a * 2. Use at your own
+/// risks.
+pub(crate) struct StrictlyMonotonicMappingInverter<T> {
+    orig_mapping: T,
+}
+impl<T> From<T> for StrictlyMonotonicMappingInverter<T> {
+    fn from(orig_mapping: T) -> Self {
+        Self { orig_mapping }
+    }
+}
+
+impl<From, To, T> StrictlyMonotonicFn<To, From> for StrictlyMonotonicMappingInverter<T>
+where
+    T: StrictlyMonotonicFn<From, To>,
+    From: Copy,
+    To: Copy,
+{
+    #[inline(always)]
+    fn mapping(&self, val: To) -> From {
+        self.orig_mapping.inverse(val)
+    }
+
+    #[inline(always)]
+    fn inverse(&self, val: From) -> To {
+        self.orig_mapping.mapping(val)
+    }
+
+    #[inline]
+    fn mapping_coerce(&self, inp: RangeInclusive<To>) -> RangeInclusive<From> {
+        self.orig_mapping.inverse_coerce(inp)
+    }
+    #[inline]
+    fn inverse_coerce(&self, out: RangeInclusive<From>) -> RangeInclusive<To> {
+        self.orig_mapping.mapping_coerce(out)
+    }
+}
+
+/// Applies the strictly monotonic mapping from `T` without any additional changes.
+pub(crate) struct StrictlyMonotonicMappingToInternal<T> {
+    _phantom: PhantomData<T>,
+}
+
+impl<T> StrictlyMonotonicMappingToInternal<T> {
+    pub(crate) fn new() -> StrictlyMonotonicMappingToInternal<T> {
+        Self {
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<External: MonotonicallyMappableToU128, T: MonotonicallyMappableToU128>
+    StrictlyMonotonicFn<External, u128> for StrictlyMonotonicMappingToInternal<T>
+where T: MonotonicallyMappableToU128
+{
+    #[inline(always)]
+    fn mapping(&self, inp: External) -> u128 {
+        External::to_u128(inp)
+    }
+
+    #[inline(always)]
+    fn inverse(&self, out: u128) -> External {
+        External::from_u128(out)
+    }
+}
+
+impl<External: MonotonicallyMappableToU64, T: MonotonicallyMappableToU64>
+    StrictlyMonotonicFn<External, u64> for StrictlyMonotonicMappingToInternal<T>
+where T: MonotonicallyMappableToU64
+{
+    #[inline(always)]
+    fn mapping(&self, inp: External) -> u64 {
+        External::to_u64(inp)
+    }
+
+    #[inline(always)]
+    fn inverse(&self, out: u64) -> External {
+        External::from_u64(out)
+    }
+}
+
+/// Mapping dividing by  gcd and a base value.
+///
+/// The function is assumed to be only called on values divided by passed
+/// gcd value. (It is necessary for the function to be monotonic.)
+pub(crate) struct StrictlyMonotonicMappingToInternalGCDBaseval {
+    gcd_divider: DividerU64,
+    gcd: u64,
+    min_value: u64,
+}
+impl StrictlyMonotonicMappingToInternalGCDBaseval {
+    pub(crate) fn new(gcd: u64, min_value: u64) -> Self {
+        let gcd_divider = DividerU64::divide_by(gcd);
+        Self {
+            gcd_divider,
+            gcd,
+            min_value,
+        }
+    }
+}
+impl<External: MonotonicallyMappableToU64> StrictlyMonotonicFn<External, u64>
+    for StrictlyMonotonicMappingToInternalGCDBaseval
+{
+    #[inline(always)]
+    fn mapping(&self, inp: External) -> u64 {
+        self.gcd_divider
+            .divide(External::to_u64(inp) - self.min_value)
+    }
+
+    #[inline(always)]
+    fn inverse(&self, out: u64) -> External {
+        External::from_u64(self.min_value + out * self.gcd)
+    }
+
+    #[inline]
+    #[allow(clippy::reversed_empty_ranges)]
+    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<u64> {
+        let end = External::to_u64(*inp.end());
+        if end < self.min_value || inp.end() < inp.start() {
+            return 1..=0;
+        }
+        let map_coerce = |mut inp, coerce_up| {
+            let inp_lower_bound = self.inverse(0);
+            if inp < inp_lower_bound {
+                inp = inp_lower_bound;
+            }
+            let val = External::to_u64(inp);
+            let need_coercion = coerce_up && (val - self.min_value) % self.gcd != 0;
+            let mut mapped_val = self.mapping(inp);
+            if need_coercion {
+                mapped_val += 1;
+            }
+            mapped_val
+        };
+        let start = map_coerce(*inp.start(), true);
+        let end = map_coerce(*inp.end(), false);
+        start..=end
+    }
+}
+
+/// Strictly monotonic mapping with a base value.
+pub(crate) struct StrictlyMonotonicMappingToInternalBaseval {
+    min_value: u64,
+}
+impl StrictlyMonotonicMappingToInternalBaseval {
+    #[inline(always)]
+    pub(crate) fn new(min_value: u64) -> Self {
+        Self { min_value }
+    }
+}
+
+impl<External: MonotonicallyMappableToU64> StrictlyMonotonicFn<External, u64>
+    for StrictlyMonotonicMappingToInternalBaseval
+{
+    #[inline]
+    #[allow(clippy::reversed_empty_ranges)]
+    fn mapping_coerce(&self, inp: RangeInclusive<External>) -> RangeInclusive<u64> {
+        if External::to_u64(*inp.end()) < self.min_value {
+            return 1..=0;
+        }
+        let start = self.mapping(External::to_u64(*inp.start()).max(self.min_value));
+        let end = self.mapping(External::to_u64(*inp.end()));
+        start..=end
+    }
+
+    #[inline(always)]
+    fn mapping(&self, val: External) -> u64 {
+        External::to_u64(val) - self.min_value
+    }
+
+    #[inline(always)]
+    fn inverse(&self, val: u64) -> External {
+        External::from_u64(self.min_value + val)
+    }
+}
+
+impl MonotonicallyMappableToU64 for u64 {
+    #[inline(always)]
+    fn to_u64(self) -> u64 {
+        self
+    }
+
+    #[inline(always)]
+    fn from_u64(val: u64) -> Self {
+        val
+    }
+}
+
+impl MonotonicallyMappableToU64 for i64 {
+    #[inline(always)]
+    fn to_u64(self) -> u64 {
+        common::i64_to_u64(self)
+    }
+
+    #[inline(always)]
+    fn from_u64(val: u64) -> Self {
+        common::u64_to_i64(val)
+    }
+}
+
+impl MonotonicallyMappableToU64 for bool {
+    #[inline(always)]
+    fn to_u64(self) -> u64 {
+        u64::from(self)
+    }
+
+    #[inline(always)]
+    fn from_u64(val: u64) -> Self {
+        val > 0
+    }
+}
+
+// TODO remove me.
+// Tantivy should refuse NaN values and work with NotNaN internally.
+impl MonotonicallyMappableToU64 for f64 {
+    #[inline(always)]
+    fn to_u64(self) -> u64 {
+        common::f64_to_u64(self)
+    }
+
+    #[inline(always)]
+    fn from_u64(val: u64) -> Self {
+        common::u64_to_f64(val)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn strictly_monotonic_test() {
+        // identity mapping
+        test_round_trip(&StrictlyMonotonicMappingToInternal::<u64>::new(), 100u64);
+        // round trip to i64
+        test_round_trip(&StrictlyMonotonicMappingToInternal::<i64>::new(), 100u64);
+        // identity mapping
+        test_round_trip(&StrictlyMonotonicMappingToInternal::<u128>::new(), 100u128);
+
+        // base value to i64 round trip
+        let mapping = StrictlyMonotonicMappingToInternalBaseval::new(100);
+        test_round_trip::<_, _, u64>(&mapping, 100i64);
+        // base value and gcd to u64 round trip
+        let mapping = StrictlyMonotonicMappingToInternalGCDBaseval::new(10, 100);
+        test_round_trip::<_, _, u64>(&mapping, 100u64);
+    }
+
+    fn test_round_trip<T: StrictlyMonotonicFn<K, L>, K: std::fmt::Debug + Eq + Copy, L: Copy>(
+        mapping: &T,
+        test_val: K,
+    ) {
+        assert_eq!(mapping.inverse(mapping.mapping(test_val)), test_val);
+    }
+}

fastfield_codecs/src/monotonic_mapping_u128.rs

@@ -0,0 +1,43 @@
+use std::fmt;
+use std::net::Ipv6Addr;
+
+/// Montonic maps a value to u128 value space
+/// Monotonic mapping enables `PartialOrd` on u128 space without conversion to original space.
+pub trait MonotonicallyMappableToU128:
+    'static + PartialOrd + Copy + Send + Sync + fmt::Debug
+{
+    /// Converts a value to u128.
+    ///
+    /// Internally all fast field values are encoded as u64.
+    fn to_u128(self) -> u128;
+
+    /// Converts a value from u128
+    ///
+    /// Internally all fast field values are encoded as u64.
+    /// **Note: To be used for converting encoded Term, Posting values.**
+    fn from_u128(val: u128) -> Self;
+}
+
+impl MonotonicallyMappableToU128 for u128 {
+    fn to_u128(self) -> u128 {
+        self
+    }
+
+    fn from_u128(val: u128) -> Self {
+        val
+    }
+}
+
+impl MonotonicallyMappableToU128 for Ipv6Addr {
+    fn to_u128(self) -> u128 {
+        ip_to_u128(self)
+    }
+
+    fn from_u128(val: u128) -> Self {
+        Ipv6Addr::from(val.to_be_bytes())
+    }
+}
+
+fn ip_to_u128(ip_addr: Ipv6Addr) -> u128 {
+    u128::from_be_bytes(ip_addr.octets())
+}

fastfield_codecs/src/null_index/dense.rs

@@ -0,0 +1,500 @@
+use std::convert::TryInto;
+use std::io::{self, Write};
+
+use common::{BinarySerializable, OwnedBytes};
+use itertools::Itertools;
+
+use super::{get_bit_at, set_bit_at};
+
+/// For the `DenseCodec`, `data` which contains the encoded blocks.
+/// Each block consists of [u8; 12]. The first 8 bytes is a bitvec for 64 elements.
+/// The last 4 bytes are the offset, the number of set bits so far.
+///
+/// When translating the original index to a dense index, the correct block can be computed
+/// directly `orig_idx/64`. Inside the block the position is `orig_idx%64`.
+///
+/// When translating a dense index to the original index, we can use the offset to find the correct
+/// block. Direct computation is not possible, but we can employ a linear or binary search.
+#[derive(Clone)]
+pub struct DenseCodec {
+    // data consists of blocks of 64 bits.
+    //
+    // The format is &[(u64, u32)]
+    // u64 is the bitvec
+    // u32 is the offset of the block, the number of set bits so far.
+    //
+    // At the end one block is appended, to store the number of values in the index in offset.
+    data: OwnedBytes,
+}
+const ELEMENTS_PER_BLOCK: u32 = 64;
+const BLOCK_BITVEC_SIZE: usize = 8;
+const BLOCK_OFFSET_SIZE: usize = 4;
+const SERIALIZED_BLOCK_SIZE: usize = BLOCK_BITVEC_SIZE + BLOCK_OFFSET_SIZE;
+
+/// Interpreting the bitvec as a list of 64 bits from the low weight to the
+/// high weight.
+///
+/// This function returns the number of bits set to 1 within
+/// `[0..pos_in_vec)`.
+#[inline]
+fn count_ones(bitvec: u64, pos_in_bitvec: u32) -> u32 {
+    let mask = (1u64 << pos_in_bitvec) - 1;
+    let masked_bitvec = bitvec & mask;
+    masked_bitvec.count_ones()
+}
+
+#[derive(Clone, Copy)]
+struct DenseIndexBlock {
+    bitvec: u64,
+    offset: u32,
+}
+
+impl From<[u8; SERIALIZED_BLOCK_SIZE]> for DenseIndexBlock {
+    fn from(data: [u8; SERIALIZED_BLOCK_SIZE]) -> Self {
+        let bitvec = u64::from_le_bytes(data[..BLOCK_BITVEC_SIZE].try_into().unwrap());
+        let offset = u32::from_le_bytes(data[BLOCK_BITVEC_SIZE..].try_into().unwrap());
+        Self { bitvec, offset }
+    }
+}
+
+impl DenseCodec {
+    /// Open the DenseCodec from OwnedBytes
+    pub fn open(data: OwnedBytes) -> Self {
+        Self { data }
+    }
+    #[inline]
+    /// Check if value at position is not null.
+    pub fn exists(&self, idx: u32) -> bool {
+        let block_pos = idx / ELEMENTS_PER_BLOCK;
+        let bitvec = self.dense_index_block(block_pos).bitvec;
+        let pos_in_bitvec = idx % ELEMENTS_PER_BLOCK;
+        get_bit_at(bitvec, pos_in_bitvec)
+    }
+    #[inline]
+    fn dense_index_block(&self, block_pos: u32) -> DenseIndexBlock {
+        dense_index_block(&self.data, block_pos)
+    }
+
+    /// Return the number of non-null values in an index
+    pub fn num_non_nulls(&self) -> u32 {
+        let last_block = (self.data.len() / SERIALIZED_BLOCK_SIZE) - 1;
+        self.dense_index_block(last_block as u32).offset
+    }
+
+    #[inline]
+    /// Translate from the original index to the codec index.
+    pub fn translate_to_codec_idx(&self, idx: u32) -> Option<u32> {
+        let block_pos = idx / ELEMENTS_PER_BLOCK;
+        let index_block = self.dense_index_block(block_pos);
+        let pos_in_block_bit_vec = idx % ELEMENTS_PER_BLOCK;
+        let ones_in_block = count_ones(index_block.bitvec, pos_in_block_bit_vec);
+        if get_bit_at(index_block.bitvec, pos_in_block_bit_vec) {
+            Some(index_block.offset + ones_in_block)
+        } else {
+            None
+        }
+    }
+
+    /// Translate positions from the codec index to the original index.
+    ///
+    /// # Panics
+    ///
+    /// May panic if any `idx` is greater than the max codec index.
+    pub fn translate_codec_idx_to_original_idx<'a>(
+        &'a self,
+        iter: impl Iterator<Item = u32> + 'a,
+    ) -> impl Iterator<Item = u32> + 'a {
+        let mut block_pos = 0u32;
+        iter.map(move |dense_idx| {
+            // update block_pos to limit search scope
+            block_pos = find_block(dense_idx, block_pos, &self.data);
+            let index_block = self.dense_index_block(block_pos);
+
+            // The next offset is higher than dense_idx and therefore:
+            // dense_idx <= offset + num_set_bits in block
+            let mut num_set_bits = 0;
+            for idx_in_bitvec in 0..ELEMENTS_PER_BLOCK {
+                if get_bit_at(index_block.bitvec, idx_in_bitvec) {
+                    num_set_bits += 1;
+                }
+                if num_set_bits == (dense_idx - index_block.offset + 1) {
+                    let orig_idx = block_pos * ELEMENTS_PER_BLOCK + idx_in_bitvec;
+                    return orig_idx;
+                }
+            }
+            panic!("Internal Error: Offset calculation in dense idx seems to be wrong.");
+        })
+    }
+}
+
+#[inline]
+fn dense_index_block(data: &[u8], block_pos: u32) -> DenseIndexBlock {
+    let data_start_pos = block_pos as usize * SERIALIZED_BLOCK_SIZE;
+    let block_data: [u8; SERIALIZED_BLOCK_SIZE] = data[data_start_pos..][..SERIALIZED_BLOCK_SIZE]
+        .try_into()
+        .unwrap();
+    block_data.into()
+}
+
+#[inline]
+/// Finds the block position containing the dense_idx.
+///
+/// # Correctness
+/// dense_idx needs to be smaller than the number of values in the index
+///
+/// The last offset number is equal to the number of values in the index.
+fn find_block(dense_idx: u32, mut block_pos: u32, data: &[u8]) -> u32 {
+    loop {
+        let offset = dense_index_block(data, block_pos).offset;
+        if offset > dense_idx {
+            return block_pos - 1;
+        }
+        block_pos += 1;
+    }
+}
+
+/// Iterator over all values, true if set, otherwise false
+pub fn serialize_dense_codec(
+    iter: impl Iterator<Item = bool>,
+    mut out: impl Write,
+) -> io::Result<()> {
+    let mut offset: u32 = 0;
+
+    for chunk in &iter.chunks(ELEMENTS_PER_BLOCK as usize) {
+        let mut block: u64 = 0;
+        for (pos, is_bit_set) in chunk.enumerate() {
+            if is_bit_set {
+                set_bit_at(&mut block, pos as u64);
+            }
+        }
+
+        block.serialize(&mut out)?;
+        offset.serialize(&mut out)?;
+
+        offset += block.count_ones();
+    }
+    // Add sentinal block for the offset
+    let block: u64 = 0;
+    block.serialize(&mut out)?;
+    offset.serialize(&mut out)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use proptest::prelude::{any, prop, *};
+    use proptest::strategy::Strategy;
+    use proptest::{prop_oneof, proptest};
+
+    use super::*;
+
+    fn random_bitvec() -> BoxedStrategy<Vec<bool>> {
+        prop_oneof![
+            1 => prop::collection::vec(proptest::bool::weighted(1.0), 0..100),
+            1 => prop::collection::vec(proptest::bool::weighted(1.0), 0..64),
+            1 => prop::collection::vec(proptest::bool::weighted(0.0), 0..100),
+            1 => prop::collection::vec(proptest::bool::weighted(0.0), 0..64),
+            8 => vec![any::<bool>()],
+            2 => prop::collection::vec(any::<bool>(), 0..50),
+        ]
+        .boxed()
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(500))]
+        #[test]
+        fn test_with_random_bitvecs(bitvec1 in random_bitvec(), bitvec2 in random_bitvec(), bitvec3 in random_bitvec()) {
+            let mut bitvec = Vec::new();
+            bitvec.extend_from_slice(&bitvec1);
+            bitvec.extend_from_slice(&bitvec2);
+            bitvec.extend_from_slice(&bitvec3);
+            test_null_index(bitvec);
+        }
+    }
+
+    #[test]
+    fn dense_codec_test_one_block_false() {
+        let mut iter = vec![false; 64];
+        iter.push(true);
+        test_null_index(iter);
+    }
+
+    fn test_null_index(data: Vec<bool>) {
+        let mut out = vec![];
+
+        serialize_dense_codec(data.iter().cloned(), &mut out).unwrap();
+        let null_index = DenseCodec::open(OwnedBytes::new(out));
+
+        let orig_idx_with_value: Vec<u32> = data
+            .iter()
+            .enumerate()
+            .filter(|(_pos, val)| **val)
+            .map(|(pos, _val)| pos as u32)
+            .collect();
+
+        assert_eq!(
+            null_index
+                .translate_codec_idx_to_original_idx(0..orig_idx_with_value.len() as u32)
+                .collect_vec(),
+            orig_idx_with_value
+        );
+
+        for (dense_idx, orig_idx) in orig_idx_with_value.iter().enumerate() {
+            assert_eq!(
+                null_index.translate_to_codec_idx(*orig_idx),
+                Some(dense_idx as u32)
+            );
+        }
+
+        for (pos, value) in data.iter().enumerate() {
+            assert_eq!(null_index.exists(pos as u32), *value);
+        }
+    }
+
+    #[test]
+    fn dense_codec_test_translation() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_dense_codec(iter, &mut out).unwrap();
+        let null_index = DenseCodec::open(OwnedBytes::new(out));
+
+        assert_eq!(
+            null_index
+                .translate_codec_idx_to_original_idx(0..2)
+                .collect_vec(),
+            vec![0, 2]
+        );
+    }
+
+    #[test]
+    fn dense_codec_translate() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_dense_codec(iter, &mut out).unwrap();
+        let null_index = DenseCodec::open(OwnedBytes::new(out));
+        assert_eq!(null_index.translate_to_codec_idx(0), Some(0));
+        assert_eq!(null_index.translate_to_codec_idx(2), Some(1));
+    }
+
+    #[test]
+    fn dense_codec_test_small() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_dense_codec(iter, &mut out).unwrap();
+        let null_index = DenseCodec::open(OwnedBytes::new(out));
+        assert!(null_index.exists(0));
+        assert!(!null_index.exists(1));
+        assert!(null_index.exists(2));
+        assert!(!null_index.exists(3));
+    }
+
+    #[test]
+    fn dense_codec_test_large() {
+        let mut docs = vec![];
+        docs.extend((0..1000).map(|_idx| false));
+        docs.extend((0..=1000).map(|_idx| true));
+
+        let iter = docs.iter().cloned();
+        let mut out = vec![];
+        serialize_dense_codec(iter, &mut out).unwrap();
+        let null_index = DenseCodec::open(OwnedBytes::new(out));
+        assert!(!null_index.exists(0));
+        assert!(!null_index.exists(100));
+        assert!(!null_index.exists(999));
+        assert!(null_index.exists(1000));
+        assert!(null_index.exists(1999));
+        assert!(null_index.exists(2000));
+        assert!(!null_index.exists(2001));
+    }
+
+    #[test]
+    fn test_count_ones() {
+        let mut block = 0;
+        set_bit_at(&mut block, 0);
+        set_bit_at(&mut block, 2);
+
+        assert_eq!(count_ones(block, 0), 0);
+        assert_eq!(count_ones(block, 1), 1);
+        assert_eq!(count_ones(block, 2), 1);
+        assert_eq!(count_ones(block, 3), 2);
+    }
+}
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+    use test::Bencher;
+
+    use super::*;
+
+    const TOTAL_NUM_VALUES: u32 = 1_000_000;
+    fn gen_bools(fill_ratio: f64) -> DenseCodec {
+        let mut out = Vec::new();
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        let bools: Vec<_> = (0..TOTAL_NUM_VALUES)
+            .map(|_| rng.gen_bool(fill_ratio))
+            .collect();
+        serialize_dense_codec(bools.into_iter(), &mut out).unwrap();
+
+        let codec = DenseCodec::open(OwnedBytes::new(out));
+        codec
+    }
+
+    fn random_range_iterator(
+        start: u32,
+        end: u32,
+        avg_step_size: u32,
+        avg_deviation: u32,
+    ) -> impl Iterator<Item = u32> {
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        let mut current = start;
+        std::iter::from_fn(move || {
+            current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+            if current >= end {
+                None
+            } else {
+                Some(current)
+            }
+        })
+    }
+
+    fn n_percent_step_iterator(percent: f32, num_values: u32) -> impl Iterator<Item = u32> {
+        let ratio = percent as f32 / 100.0;
+        let step_size = (1f32 / ratio) as u32;
+        let deviation = step_size - 1;
+        random_range_iterator(0, num_values, step_size, deviation)
+    }
+
+    fn walk_over_data(codec: &DenseCodec, avg_step_size: u32) -> Option<u32> {
+        walk_over_data_from_positions(
+            codec,
+            random_range_iterator(0, TOTAL_NUM_VALUES, avg_step_size, 0),
+        )
+    }
+
+    fn walk_over_data_from_positions(
+        codec: &DenseCodec,
+        positions: impl Iterator<Item = u32>,
+    ) -> Option<u32> {
+        let mut dense_idx: Option<u32> = None;
+        for idx in positions {
+            dense_idx = dense_idx.or(codec.translate_to_codec_idx(idx));
+        }
+        dense_idx
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 1000));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_1percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_10percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_90percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_10percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_50percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.5f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_90percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(10.0, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_vals = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(0..num_vals)
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.90f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        let num_vals = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(0..num_vals)
+                .last()
+        });
+    }
+}

fastfield_codecs/src/null_index/mod.rs

@@ -0,0 +1,14 @@
+pub use dense::{serialize_dense_codec, DenseCodec};
+
+mod dense;
+mod sparse;
+
+#[inline]
+fn get_bit_at(input: u64, n: u32) -> bool {
+    input & (1 << n) != 0
+}
+
+#[inline]
+fn set_bit_at(input: &mut u64, n: u64) {
+    *input |= 1 << n;
+}

fastfield_codecs/src/null_index/sparse.rs

@@ -0,0 +1,768 @@
+use std::io::{self, Write};
+
+use common::{BitSet, GroupByIteratorExtended, OwnedBytes};
+
+use super::{serialize_dense_codec, DenseCodec};
+
+/// `SparseCodec` is the codec for data, when only few documents have values.
+/// In contrast to `DenseCodec` opening a `SparseCodec` causes runtime data to be produced, for
+/// faster access.
+///
+/// The lower 16 bits of doc ids are stored as u16 while the upper 16 bits are given by the block
+/// id. Each block contains 1<<16 docids.
+///
+/// # Serialized Data Layout
+/// The data starts with the block data. Each block is either dense or sparse encoded, depending on
+/// the number of values in the block. A block is sparse when it contains less than
+/// DENSE_BLOCK_THRESHOLD (6144) values.
+/// [Sparse data block | dense data block, .. #repeat*; Desc: Either a sparse or dense encoded
+/// block]
+/// ### Sparse block data
+/// [u16 LE, .. #repeat*; Desc: Positions with values in a block]
+/// ### Dense block data
+/// [Dense codec for the whole block; Desc: Similar to a bitvec(0..ELEMENTS_PER_BLOCK) + Metadata
+/// for faster lookups. See dense.rs]
+///
+/// The data is followed by block metadata, to know which area of the raw block data belongs to
+/// which block. Only metadata for blocks with elements is recorded to
+/// keep the overhead low for scenarios with many very sparse columns. The block metadata consists
+/// of the block index and the number of values in the block. Since we don't store empty blocks
+/// num_vals is incremented by 1, e.g. 0 means 1 value.
+///
+/// The last u16 is storing the number of metadata blocks.
+/// [u16 LE, .. #repeat*; Desc: Positions with values in a block][(u16 LE, u16 LE), .. #repeat*;
+/// Desc: (Block Id u16, Num Elements u16)][u16 LE; Desc: num blocks with values u16]
+///
+/// # Opening
+/// When opening the data layout, the data is expanded to `Vec<SparseCodecBlockVariant>`, where the
+/// index is the block index. For each block `byte_start` and `offset` is computed.
+pub struct SparseCodec {
+    data: OwnedBytes,
+    blocks: Vec<SparseCodecBlockVariant>,
+}
+
+/// The threshold for for number of elements after which we switch to dense block encoding
+const DENSE_BLOCK_THRESHOLD: u32 = 6144;
+
+const ELEMENTS_PER_BLOCK: u32 = u16::MAX as u32 + 1;
+
+/// 1.5 bit per Element + 12 bytes for the sentinal block
+const NUM_BYTES_DENSE_BLOCK: u32 = (ELEMENTS_PER_BLOCK + ELEMENTS_PER_BLOCK / 2 + 64 + 32) / 8;
+
+#[derive(Clone)]
+enum SparseCodecBlockVariant {
+    Empty { offset: u32 },
+    Dense(DenseBlock),
+    Sparse(SparseBlock),
+}
+
+impl SparseCodecBlockVariant {
+    /// The number of non-null values that preceeded that block.
+    #[inline]
+    fn offset(&self) -> u32 {
+        match self {
+            SparseCodecBlockVariant::Empty { offset } => *offset,
+            SparseCodecBlockVariant::Dense(dense) => dense.offset,
+            SparseCodecBlockVariant::Sparse(sparse) => sparse.offset,
+        }
+    }
+}
+
+/// A block consists of max u16 values
+#[derive(Clone)]
+struct DenseBlock {
+    /// The number of values set before the block
+    offset: u32,
+    /// The data for the dense encoding
+    codec: DenseCodec,
+}
+
+impl DenseBlock {
+    #[inline]
+    pub fn exists(&self, idx: u32) -> bool {
+        self.codec.exists(idx)
+    }
+    #[inline]
+    pub fn translate_to_codec_idx(&self, idx: u32) -> Option<u32> {
+        self.codec.translate_to_codec_idx(idx)
+    }
+    #[inline]
+    pub fn translate_codec_idx_to_original_idx_iter<'a>(
+        &'a self,
+        iter: impl Iterator<Item = u32> + 'a,
+    ) -> impl Iterator<Item = u32> + 'a {
+        self.codec.translate_codec_idx_to_original_idx(iter)
+    }
+    #[inline]
+    pub fn translate_codec_idx_to_original_idx(&self, idx: u32) -> u32 {
+        self.codec
+            .translate_codec_idx_to_original_idx(idx..=idx)
+            .next()
+            .unwrap()
+    }
+}
+
+/// A block consists of max u16 values
+#[derive(Debug, Copy, Clone)]
+struct SparseBlock {
+    /// The number of values in the block
+    num_vals: u32,
+    /// The number of values set before the block
+    offset: u32,
+    /// The start position of the data for the block
+    byte_start: u32,
+}
+
+impl SparseBlock {
+    fn empty_block(offset: u32) -> Self {
+        Self {
+            num_vals: 0,
+            byte_start: 0,
+            offset,
+        }
+    }
+
+    #[inline]
+    fn value_at_idx(&self, data: &[u8], idx: u16) -> u16 {
+        let start_offset: usize = self.byte_start as usize + (idx as u32 as usize * 2);
+        get_u16(data, start_offset)
+    }
+
+    #[inline]
+    #[allow(clippy::comparison_chain)]
+    // Looks for the element in the block. Returns the positions if found.
+    fn binary_search(&self, data: &[u8], target: u16) -> Option<u16> {
+        let mut size = self.num_vals as u16;
+        let mut left = 0;
+        let mut right = size;
+        // TODO try different implem.
+        //  e.g. exponential search into binary search
+        while left < right {
+            let mid = left + size / 2;
+
+            // TODO do boundary check only once, and then use an
+            // unsafe `value_at_idx`
+            let mid_val = self.value_at_idx(data, mid);
+
+            if target > mid_val {
+                left = mid + 1;
+            } else if target < mid_val {
+                right = mid;
+            } else {
+                return Some(mid);
+            }
+
+            size = right - left;
+        }
+        None
+    }
+}
+
+#[inline]
+fn get_u16(data: &[u8], byte_position: usize) -> u16 {
+    let bytes: [u8; 2] = data[byte_position..byte_position + 2].try_into().unwrap();
+    u16::from_le_bytes(bytes)
+}
+
+const SERIALIZED_BLOCK_METADATA_SIZE: usize = 4;
+
+fn deserialize_sparse_codec_block(data: &OwnedBytes) -> Vec<SparseCodecBlockVariant> {
+    // The number of vals so far
+    let mut offset = 0;
+    let mut sparse_codec_blocks = Vec::new();
+    let num_blocks = get_u16(data, data.len() - 2);
+    let block_data_index_start =
+        data.len() - 2 - num_blocks as usize * SERIALIZED_BLOCK_METADATA_SIZE;
+    let mut byte_start = 0;
+    for block_num in 0..num_blocks as usize {
+        let block_data_index = block_data_index_start + SERIALIZED_BLOCK_METADATA_SIZE * block_num;
+        let block_idx = get_u16(data, block_data_index);
+        let num_vals = get_u16(data, block_data_index + 2) as u32 + 1;
+        sparse_codec_blocks.resize(
+            block_idx as usize,
+            SparseCodecBlockVariant::Empty { offset },
+        );
+
+        if is_sparse(num_vals) {
+            let block = SparseBlock {
+                num_vals,
+                offset,
+                byte_start,
+            };
+            sparse_codec_blocks.push(SparseCodecBlockVariant::Sparse(block));
+            byte_start += 2 * num_vals;
+        } else {
+            let block = DenseBlock {
+                offset,
+                codec: DenseCodec::open(data.slice(byte_start as usize..data.len()).clone()),
+            };
+            sparse_codec_blocks.push(SparseCodecBlockVariant::Dense(block));
+            // Dense blocks have a fixed size spanning ELEMENTS_PER_BLOCK.
+            byte_start += NUM_BYTES_DENSE_BLOCK;
+        }
+
+        offset += num_vals;
+    }
+    sparse_codec_blocks.push(SparseCodecBlockVariant::Empty { offset });
+    sparse_codec_blocks
+}
+
+/// Splits a value address into lower and upper 16bits.
+/// The lower 16 bits are the value in the block
+/// The upper 16 bits are the block index
+#[derive(Debug, Clone, Copy)]
+struct ValueAddr {
+    block_idx: u16,
+    value_in_block: u16,
+}
+
+/// Splits a idx into block index and value in the block
+#[inline]
+fn value_addr(idx: u32) -> ValueAddr {
+    /// Static assert number elements per block this method expects
+    #[allow(clippy::assertions_on_constants)]
+    const _: () = assert!(ELEMENTS_PER_BLOCK == (1 << 16));
+
+    let value_in_block = idx as u16;
+    let block_idx = (idx >> 16) as u16;
+    ValueAddr {
+        block_idx,
+        value_in_block,
+    }
+}
+
+impl SparseCodec {
+    /// Open the SparseCodec from OwnedBytes
+    pub fn open(data: OwnedBytes) -> Self {
+        let blocks = deserialize_sparse_codec_block(&data);
+        Self { data, blocks }
+    }
+
+    #[inline]
+    /// Check if value at position is not null.
+    pub fn exists(&self, idx: u32) -> bool {
+        let value_addr = value_addr(idx);
+        // There may be trailing nulls without data, those are not stored as blocks. It would be
+        // possible to create empty blocks, but for that we would need to serialize the number of
+        // values or pass them when opening
+
+        if let Some(block) = self.blocks.get(value_addr.block_idx as usize) {
+            match block {
+                SparseCodecBlockVariant::Empty { offset: _ } => false,
+                SparseCodecBlockVariant::Dense(block) => {
+                    block.exists(value_addr.value_in_block as u32)
+                }
+                SparseCodecBlockVariant::Sparse(block) => block
+                    .binary_search(&self.data, value_addr.value_in_block)
+                    .is_some(),
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Return the number of non-null values in an index
+    pub fn num_non_nulls(&self) -> u32 {
+        self.blocks.last().map(|block| block.offset()).unwrap_or(0)
+    }
+
+    #[inline]
+    /// Translate from the original index to the codec index.
+    pub fn translate_to_codec_idx(&self, idx: u32) -> Option<u32> {
+        let value_addr = value_addr(idx);
+        let block = self.blocks.get(value_addr.block_idx as usize)?;
+
+        match block {
+            SparseCodecBlockVariant::Empty { offset: _ } => None,
+            SparseCodecBlockVariant::Dense(block) => block
+                .translate_to_codec_idx(value_addr.value_in_block as u32)
+                .map(|pos_in_block| pos_in_block + block.offset),
+            SparseCodecBlockVariant::Sparse(block) => {
+                let pos_in_block = block.binary_search(&self.data, value_addr.value_in_block);
+                pos_in_block.map(|pos_in_block: u16| block.offset + pos_in_block as u32)
+            }
+        }
+    }
+
+    #[inline]
+    fn find_block(&self, dense_idx: u32, mut block_pos: u32) -> u32 {
+        loop {
+            let offset = self.blocks[block_pos as usize].offset();
+            if offset > dense_idx {
+                return block_pos - 1;
+            }
+            block_pos += 1;
+        }
+    }
+
+    /// Translate positions from the codec index to the original index.
+    /// Correctness: Provided values must be in increasing values
+    ///
+    /// # Panics
+    ///
+    /// May panic if any `idx` is greater than the max codec index.
+    pub fn translate_codec_idx_to_original_idx<'a>(
+        &'a self,
+        iter: impl Iterator<Item = u32> + 'a,
+    ) -> impl Iterator<Item = u32> + 'a {
+        let mut block_pos = 0u32;
+        iter.group_by(move |codec_idx| {
+            block_pos = self.find_block(*codec_idx, block_pos);
+            block_pos
+        })
+        .flat_map(move |(block_pos, block_iter)| {
+            let block_doc_idx_start = block_pos * ELEMENTS_PER_BLOCK;
+            let block = &self.blocks[block_pos as usize];
+            let offset = block.offset();
+            let indexes_in_block_iter = block_iter.map(move |codec_idx| codec_idx - offset);
+            match block {
+                SparseCodecBlockVariant::Empty { offset: _ } => {
+                    panic!(
+                        "invalid input, cannot translate to original index. associated empty \
+                         block with dense idx. block_pos {}, idx_in_block {:?}",
+                        block_pos,
+                        indexes_in_block_iter.collect::<Vec<_>>()
+                    )
+                }
+                SparseCodecBlockVariant::Dense(dense) => {
+                    Box::new(dense.translate_codec_idx_to_original_idx_iter(indexes_in_block_iter))
+                        as Box<dyn Iterator<Item = u32>>
+                }
+                SparseCodecBlockVariant::Sparse(block) => {
+                    Box::new(indexes_in_block_iter.map(move |idx_in_block| {
+                        block.value_at_idx(&self.data, idx_in_block as u16) as u32
+                    }))
+                }
+            }
+            .map(move |idx| idx + block_doc_idx_start)
+        })
+    }
+}
+
+#[inline]
+fn is_sparse(num_elem_in_block: u32) -> bool {
+    num_elem_in_block < DENSE_BLOCK_THRESHOLD
+}
+
+#[derive(Default)]
+struct BlockDataSerialized {
+    block_idx: u16,
+    num_vals: u32,
+}
+
+/// Iterator over positions of set values.
+pub fn serialize_sparse_codec<W: Write>(
+    mut iter: impl Iterator<Item = u32>,
+    mut out: W,
+) -> io::Result<()> {
+    let mut block_metadata: Vec<BlockDataSerialized> = Vec::new();
+    let mut current_block = Vec::new();
+    // This if-statement for the first element ensures that
+    // `block_metadata` is not empty in the loop below.
+    if let Some(idx) = iter.next() {
+        let value_addr = value_addr(idx);
+        block_metadata.push(BlockDataSerialized {
+            block_idx: value_addr.block_idx,
+            num_vals: 1,
+        });
+        current_block.push(value_addr.value_in_block);
+    }
+    let flush_block = |current_block: &mut Vec<u16>, out: &mut W| -> io::Result<()> {
+        let is_sparse = is_sparse(current_block.len() as u32);
+        if is_sparse {
+            for val_in_block in current_block.iter() {
+                out.write_all(val_in_block.to_le_bytes().as_ref())?;
+            }
+        } else {
+            let mut bitset = BitSet::with_max_value(ELEMENTS_PER_BLOCK + 1);
+            for val_in_block in current_block.iter() {
+                bitset.insert(*val_in_block as u32);
+            }
+
+            let iter = (0..ELEMENTS_PER_BLOCK).map(|idx| bitset.contains(idx));
+            serialize_dense_codec(iter, out)?;
+        }
+        current_block.clear();
+        Ok(())
+    };
+    for idx in iter {
+        let value_addr = value_addr(idx);
+        if block_metadata[block_metadata.len() - 1].block_idx == value_addr.block_idx {
+            let last_idx_metadata = block_metadata.len() - 1;
+            block_metadata[last_idx_metadata].num_vals += 1;
+        } else {
+            // flush prev block
+            flush_block(&mut current_block, &mut out)?;
+
+            block_metadata.push(BlockDataSerialized {
+                block_idx: value_addr.block_idx,
+                num_vals: 1,
+            });
+        }
+        current_block.push(value_addr.value_in_block);
+    }
+    // handle last block
+    flush_block(&mut current_block, &mut out)?;
+
+    for block in &block_metadata {
+        out.write_all(block.block_idx.to_le_bytes().as_ref())?;
+        // We don't store empty blocks, therefore we can subtract 1.
+        // This way we will be able to use u16 when the number of elements is 1 << 16 or u16::MAX+1
+        out.write_all(((block.num_vals - 1) as u16).to_le_bytes().as_ref())?;
+    }
+    out.write_all((block_metadata.len() as u16).to_le_bytes().as_ref())?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use itertools::Itertools;
+    use proptest::prelude::{any, prop, *};
+    use proptest::strategy::Strategy;
+    use proptest::{prop_oneof, proptest};
+
+    use super::*;
+
+    fn random_bitvec() -> BoxedStrategy<Vec<bool>> {
+        prop_oneof![
+            1 => prop::collection::vec(proptest::bool::weighted(1.0), 0..100),
+            1 => prop::collection::vec(proptest::bool::weighted(0.00), 0..(ELEMENTS_PER_BLOCK as usize * 3)), // empty blocks
+            1 => prop::collection::vec(proptest::bool::weighted(1.00), 0..(ELEMENTS_PER_BLOCK as usize + 10)), // full block
+            1 => prop::collection::vec(proptest::bool::weighted(0.01), 0..100),
+            1 => prop::collection::vec(proptest::bool::weighted(0.01), 0..u16::MAX as usize),
+            8 => vec![any::<bool>()],
+        ]
+        .boxed()
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(50))]
+        #[test]
+        fn test_with_random_bitvecs(bitvec1 in random_bitvec(), bitvec2 in random_bitvec(), bitvec3 in random_bitvec()) {
+            let mut bitvec = Vec::new();
+            bitvec.extend_from_slice(&bitvec1);
+            bitvec.extend_from_slice(&bitvec2);
+            bitvec.extend_from_slice(&bitvec3);
+            test_null_index(bitvec);
+        }
+    }
+
+    #[test]
+    fn sparse_codec_test_one_block_false() {
+        let mut iter = vec![false; ELEMENTS_PER_BLOCK as usize];
+        iter.push(true);
+        test_null_index(iter);
+    }
+
+    #[test]
+    fn sparse_codec_test_one_block_true() {
+        let mut iter = vec![true; ELEMENTS_PER_BLOCK as usize];
+        iter.push(true);
+        test_null_index(iter);
+    }
+
+    fn test_null_index(data: Vec<bool>) {
+        let mut out = vec![];
+
+        serialize_sparse_codec(
+            data.iter()
+                .cloned()
+                .enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+        let null_index = SparseCodec::open(OwnedBytes::new(out));
+
+        let orig_idx_with_value: Vec<u32> = data
+            .iter()
+            .enumerate()
+            .filter(|(_pos, val)| **val)
+            .map(|(pos, _val)| pos as u32)
+            .collect();
+
+        assert_eq!(
+            null_index
+                .translate_codec_idx_to_original_idx(0..orig_idx_with_value.len() as u32)
+                .collect_vec(),
+            orig_idx_with_value
+        );
+
+        let step_size = (orig_idx_with_value.len() / 100).max(1);
+        for (dense_idx, orig_idx) in orig_idx_with_value.iter().enumerate().step_by(step_size) {
+            assert_eq!(
+                null_index.translate_to_codec_idx(*orig_idx),
+                Some(dense_idx as u32)
+            );
+        }
+
+        // 100 samples
+        let step_size = (data.len() / 100).max(1);
+        for (pos, value) in data.iter().enumerate().step_by(step_size) {
+            assert_eq!(null_index.exists(pos as u32), *value);
+        }
+    }
+
+    #[test]
+    fn sparse_codec_test_translation() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_sparse_codec(
+            iter.enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+        let null_index = SparseCodec::open(OwnedBytes::new(out));
+
+        assert_eq!(
+            null_index
+                .translate_codec_idx_to_original_idx(0..2)
+                .collect_vec(),
+            vec![0, 2]
+        );
+    }
+
+    #[test]
+    fn sparse_codec_translate() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_sparse_codec(
+            iter.enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+        let null_index = SparseCodec::open(OwnedBytes::new(out));
+        assert_eq!(null_index.translate_to_codec_idx(0), Some(0));
+        assert_eq!(null_index.translate_to_codec_idx(2), Some(1));
+    }
+
+    #[test]
+    fn sparse_codec_test_small() {
+        let mut out = vec![];
+
+        let iter = ([true, false, true, false]).iter().cloned();
+        serialize_sparse_codec(
+            iter.enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+        let null_index = SparseCodec::open(OwnedBytes::new(out));
+        assert!(null_index.exists(0));
+        assert!(!null_index.exists(1));
+        assert!(null_index.exists(2));
+        assert!(!null_index.exists(3));
+    }
+
+    #[test]
+    fn sparse_codec_test_large() {
+        let mut docs = vec![];
+        docs.extend((0..ELEMENTS_PER_BLOCK).map(|_idx| false));
+        docs.extend((0..=1).map(|_idx| true));
+
+        let iter = docs.iter().cloned();
+        let mut out = vec![];
+        serialize_sparse_codec(
+            iter.enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+        let null_index = SparseCodec::open(OwnedBytes::new(out));
+        assert!(!null_index.exists(0));
+        assert!(!null_index.exists(100));
+        assert!(!null_index.exists(ELEMENTS_PER_BLOCK - 1));
+        assert!(null_index.exists(ELEMENTS_PER_BLOCK));
+        assert!(null_index.exists(ELEMENTS_PER_BLOCK + 1));
+    }
+}
+
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+    use test::Bencher;
+
+    use super::*;
+
+    const TOTAL_NUM_VALUES: u32 = 1_000_000;
+    fn gen_bools(fill_ratio: f64) -> SparseCodec {
+        let mut out = Vec::new();
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        serialize_sparse_codec(
+            (0..TOTAL_NUM_VALUES)
+                .map(|_| rng.gen_bool(fill_ratio))
+                .enumerate()
+                .filter(|(_pos, val)| *val)
+                .map(|(pos, _val)| pos as u32),
+            &mut out,
+        )
+        .unwrap();
+
+        let codec = SparseCodec::open(OwnedBytes::new(out));
+        codec
+    }
+
+    fn random_range_iterator(
+        start: u32,
+        end: u32,
+        avg_step_size: u32,
+        avg_deviation: u32,
+    ) -> impl Iterator<Item = u32> {
+        let mut rng: StdRng = StdRng::from_seed([1u8; 32]);
+        let mut current = start;
+        std::iter::from_fn(move || {
+            current += rng.gen_range(avg_step_size - avg_deviation..=avg_step_size + avg_deviation);
+            if current >= end {
+                None
+            } else {
+                Some(current)
+            }
+        })
+    }
+
+    fn n_percent_step_iterator(percent: f32, num_values: u32) -> impl Iterator<Item = u32> {
+        let ratio = percent as f32 / 100.0;
+        let step_size = (1f32 / ratio) as u32;
+        let deviation = step_size - 1;
+        random_range_iterator(0, num_values, step_size, deviation)
+    }
+
+    fn walk_over_data(codec: &SparseCodec, avg_step_size: u32) -> Option<u32> {
+        walk_over_data_from_positions(
+            codec,
+            random_range_iterator(0, TOTAL_NUM_VALUES, avg_step_size, 0),
+        )
+    }
+
+    fn walk_over_data_from_positions(
+        codec: &SparseCodec,
+        positions: impl Iterator<Item = u32>,
+    ) -> Option<u32> {
+        let mut dense_idx: Option<u32> = None;
+        for idx in positions {
+            dense_idx = dense_idx.or(codec.translate_to_codec_idx(idx));
+        }
+        dense_idx
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_5percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.05f64);
+        bench.iter(|| walk_over_data(&codec, 1000));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_1percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_10percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_full_scan_90percent_filled(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data_from_positions(&codec, 0..TOTAL_NUM_VALUES));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_10percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.1f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_50percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.5f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_orig_to_codec_90percent_filled_1percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        bench.iter(|| walk_over_data(&codec, 100));
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_10percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(10.0, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_1percent_filled_full_scan(bench: &mut Bencher) {
+        let codec = gen_bools(0.01f64);
+        let num_vals = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(0..num_vals)
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_0comma005percent_hit(bench: &mut Bencher) {
+        let codec = gen_bools(0.90f64);
+        let num_non_nulls = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(n_percent_step_iterator(0.005, num_non_nulls))
+                .last()
+        });
+    }
+
+    #[bench]
+    fn bench_translate_codec_to_orig_90percent_filled_full_scan(bench: &mut Bencher) {
+        let codec = gen_bools(0.9f64);
+        let num_vals = codec.num_non_nulls();
+        bench.iter(|| {
+            codec
+                .translate_codec_idx_to_original_idx(0..num_vals)
+                .last()
+        });
+    }
+}

fastfield_codecs/src/null_index_footer.rs

@@ -0,0 +1,145 @@
+use std::io::{self, Write};
+use std::ops::Range;
+
+use common::{BinarySerializable, CountingWriter, OwnedBytes, VInt};
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub(crate) enum FastFieldCardinality {
+    Single = 1,
+    Multi = 2,
+}
+
+impl BinarySerializable for FastFieldCardinality {
+    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 FastFieldCardinality {
+    pub(crate) fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub(crate) fn from_code(code: u8) -> Option<Self> {
+        match code {
+            1 => Some(Self::Single),
+            2 => Some(Self::Multi),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum NullIndexCodec {
+    Full = 1,
+}
+
+impl BinarySerializable for NullIndexCodec {
+    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 NullIndexCodec {
+    pub(crate) fn to_code(self) -> u8 {
+        self as u8
+    }
+
+    pub(crate) fn from_code(code: u8) -> Option<Self> {
+        match code {
+            1 => Some(Self::Full),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub(crate) struct NullIndexFooter {
+    pub(crate) cardinality: FastFieldCardinality,
+    pub(crate) null_index_codec: NullIndexCodec,
+    // Unused for NullIndexCodec::Full
+    pub(crate) null_index_byte_range: Range<u64>,
+}
+
+impl BinarySerializable for NullIndexFooter {
+    fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+        self.cardinality.serialize(writer)?;
+        self.null_index_codec.serialize(writer)?;
+        VInt(self.null_index_byte_range.start).serialize(writer)?;
+        VInt(self.null_index_byte_range.end - self.null_index_byte_range.start)
+            .serialize(writer)?;
+        Ok(())
+    }
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let cardinality = FastFieldCardinality::deserialize(reader)?;
+        let null_index_codec = NullIndexCodec::deserialize(reader)?;
+        let null_index_byte_range_start = VInt::deserialize(reader)?.0;
+        let null_index_byte_range_end = VInt::deserialize(reader)?.0 + null_index_byte_range_start;
+        Ok(Self {
+            cardinality,
+            null_index_codec,
+            null_index_byte_range: null_index_byte_range_start..null_index_byte_range_end,
+        })
+    }
+}
+
+pub(crate) fn append_null_index_footer(
+    output: &mut impl io::Write,
+    null_index_footer: NullIndexFooter,
+) -> io::Result<()> {
+    let mut counting_write = CountingWriter::wrap(output);
+    null_index_footer.serialize(&mut counting_write)?;
+    let footer_payload_len = counting_write.written_bytes();
+    BinarySerializable::serialize(&(footer_payload_len as u16), &mut counting_write)?;
+
+    Ok(())
+}
+
+pub(crate) fn read_null_index_footer(
+    data: OwnedBytes,
+) -> io::Result<(OwnedBytes, NullIndexFooter)> {
+    let (data, null_footer_length_bytes) = data.rsplit(2);
+
+    let footer_length = u16::deserialize(&mut null_footer_length_bytes.as_slice())?;
+    let (data, null_index_footer_bytes) = data.rsplit(footer_length as usize);
+    let null_index_footer = NullIndexFooter::deserialize(&mut null_index_footer_bytes.as_ref())?;
+
+    Ok((data, null_index_footer))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn null_index_footer_deser_test() {
+        let null_index_footer = NullIndexFooter {
+            cardinality: FastFieldCardinality::Single,
+            null_index_codec: NullIndexCodec::Full,
+            null_index_byte_range: 100..120,
+        };
+
+        let mut out = vec![];
+        null_index_footer.serialize(&mut out).unwrap();
+
+        assert_eq!(
+            null_index_footer,
+            NullIndexFooter::deserialize(&mut &out[..]).unwrap()
+        );
+    }
+}

fastfield_codecs/src/serialize.rs

@@ -0,0 +1,427 @@
+// Copyright (C) 2022 Quickwit, Inc.
+//
+// Quickwit is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at hello@quickwit.io.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+use std::num::NonZeroU64;
+use std::sync::Arc;
+use std::{fmt, io};
+
+use common::{BinarySerializable, OwnedBytes, VInt};
+use log::warn;
+
+use crate::bitpacked::BitpackedCodec;
+use crate::blockwise_linear::BlockwiseLinearCodec;
+use crate::compact_space::CompactSpaceCompressor;
+use crate::format_version::append_format_version;
+use crate::linear::LinearCodec;
+use crate::monotonic_mapping::{
+    StrictlyMonotonicFn, StrictlyMonotonicMappingToInternal,
+    StrictlyMonotonicMappingToInternalGCDBaseval,
+};
+use crate::null_index_footer::{
+    append_null_index_footer, FastFieldCardinality, NullIndexCodec, NullIndexFooter,
+};
+use crate::{
+    monotonic_map_column, Column, FastFieldCodec, FastFieldCodecType, MonotonicallyMappableToU64,
+    U128FastFieldCodecType, VecColumn, ALL_CODEC_TYPES,
+};
+
+/// The normalized header gives some parameters after applying the following
+/// normalization of the vector:
+/// `val -> (val - min_value) / gcd`
+///
+/// By design, after normalization, `min_value = 0` and `gcd = 1`.
+#[derive(Debug, Copy, Clone)]
+pub struct NormalizedHeader {
+    /// The number of values in the underlying column.
+    pub num_vals: u32,
+    /// The max value of the underlying column.
+    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 fn normalize_column<C: Column>(&self, from_column: C) -> impl Column {
+        normalize_column(from_column, self.min_value, self.gcd)
+    }
+
+    pub fn compute_header(
+        column: impl Column<u64>,
+        codecs: &[FastFieldCodecType],
+    ) -> Option<Header> {
+        let num_vals = column.num_vals();
+        let min_value = column.min_value();
+        let max_value = column.max_value();
+        let gcd = crate::gcd::find_gcd(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,
+    pub codec_type: U128FastFieldCodecType,
+}
+
+impl BinarySerializable for U128Header {
+    fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+        VInt(self.num_vals as u64).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 codec_type = U128FastFieldCodecType::deserialize(reader)?;
+        Ok(U128Header {
+            num_vals,
+            codec_type,
+        })
+    }
+}
+
+pub fn normalize_column<C: Column>(
+    from_column: C,
+    min_value: u64,
+    gcd: Option<NonZeroU64>,
+) -> impl Column {
+    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,
+        })
+    }
+}
+
+/// Return estimated compression for given codec in the value range [0.0..1.0], where 1.0 means no
+/// compression.
+pub fn estimate<T: MonotonicallyMappableToU64 + fmt::Debug>(
+    typed_column: impl Column<T>,
+    codec_type: FastFieldCodecType,
+) -> Option<f32> {
+    let column = monotonic_map_column(typed_column, StrictlyMonotonicMappingToInternal::<T>::new());
+    let min_value = column.min_value();
+    let gcd = crate::gcd::find_gcd(column.iter().map(|val| val - min_value))
+        .filter(|gcd| gcd.get() > 1u64);
+    let mapping = StrictlyMonotonicMappingToInternalGCDBaseval::new(
+        gcd.map(|gcd| gcd.get()).unwrap_or(1u64),
+        min_value,
+    );
+    let normalized_column = monotonic_map_column(&column, mapping);
+    match codec_type {
+        FastFieldCodecType::Bitpacked => BitpackedCodec::estimate(&normalized_column),
+        FastFieldCodecType::Linear => LinearCodec::estimate(&normalized_column),
+        FastFieldCodecType::BlockwiseLinear => BlockwiseLinearCodec::estimate(&normalized_column),
+    }
+}
+
+/// Serializes u128 values with the compact space codec.
+pub fn serialize_u128<F: Fn() -> I, I: Iterator<Item = u128>>(
+    iter_gen: F,
+    num_vals: u32,
+    output: &mut impl io::Write,
+) -> io::Result<()> {
+    serialize_u128_new(ValueIndexInfo::default(), iter_gen, num_vals, output)
+}
+
+#[allow(dead_code)]
+pub enum ValueIndexInfo<'a> {
+    MultiValue(Box<dyn MultiValueIndexInfo + 'a>),
+    SingleValue(Box<dyn SingleValueIndexInfo + 'a>),
+}
+
+// TODO Remove me
+impl Default for ValueIndexInfo<'static> {
+    fn default() -> Self {
+        struct Dummy {}
+        impl SingleValueIndexInfo for Dummy {
+            fn num_vals(&self) -> u32 {
+                todo!()
+            }
+            fn num_non_nulls(&self) -> u32 {
+                todo!()
+            }
+            fn iter(&self) -> Box<dyn Iterator<Item = u32>> {
+                todo!()
+            }
+        }
+
+        Self::SingleValue(Box::new(Dummy {}))
+    }
+}
+
+impl<'a> ValueIndexInfo<'a> {
+    fn get_cardinality(&self) -> FastFieldCardinality {
+        match self {
+            ValueIndexInfo::MultiValue(_) => FastFieldCardinality::Multi,
+            ValueIndexInfo::SingleValue(_) => FastFieldCardinality::Single,
+        }
+    }
+}
+
+pub trait MultiValueIndexInfo {
+    /// The number of docs in the column.
+    fn num_docs(&self) -> u32;
+    /// The number of values in the column.
+    fn num_vals(&self) -> u32;
+    /// Return the start index of the values for each doc
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_>;
+}
+
+pub trait SingleValueIndexInfo {
+    /// The number of values including nulls in the column.
+    fn num_vals(&self) -> u32;
+    /// The number of non-null values in the column.
+    fn num_non_nulls(&self) -> u32;
+    /// Return a iterator of the positions of docs with a value
+    fn iter(&self) -> Box<dyn Iterator<Item = u32> + '_>;
+}
+
+/// Serializes u128 values with the compact space codec.
+pub fn serialize_u128_new<F: Fn() -> I, I: Iterator<Item = u128>>(
+    value_index: ValueIndexInfo,
+    iter_gen: F,
+    num_vals: u32,
+    output: &mut impl io::Write,
+) -> io::Result<()> {
+    let header = U128Header {
+        num_vals,
+        codec_type: U128FastFieldCodecType::CompactSpace,
+    };
+    header.serialize(output)?;
+    let compressor = CompactSpaceCompressor::train_from(iter_gen(), num_vals);
+    compressor.compress_into(iter_gen(), output).unwrap();
+
+    let null_index_footer = NullIndexFooter {
+        cardinality: value_index.get_cardinality(),
+        null_index_codec: NullIndexCodec::Full,
+        null_index_byte_range: 0..0,
+    };
+    append_null_index_footer(output, null_index_footer)?;
+    append_format_version(output)?;
+
+    Ok(())
+}
+
+/// Serializes the column with the codec with the best estimate on the data.
+pub fn serialize<T: MonotonicallyMappableToU64 + fmt::Debug>(
+    typed_column: impl Column<T>,
+    output: &mut impl io::Write,
+    codecs: &[FastFieldCodecType],
+) -> io::Result<()> {
+    serialize_new(ValueIndexInfo::default(), typed_column, output, codecs)
+}
+
+/// Serializes the column with the codec with the best estimate on the data.
+pub fn serialize_new<T: MonotonicallyMappableToU64 + fmt::Debug>(
+    value_index: ValueIndexInfo,
+    typed_column: impl Column<T>,
+    output: &mut impl io::Write,
+    codecs: &[FastFieldCodecType],
+) -> 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)?;
+
+    let null_index_footer = NullIndexFooter {
+        cardinality: value_index.get_cardinality(),
+        null_index_codec: NullIndexCodec::Full,
+        null_index_byte_range: 0..0,
+    };
+    append_null_index_footer(output, null_index_footer)?;
+    append_format_version(output)?;
+
+    Ok(())
+}
+
+fn detect_codec(
+    column: impl Column<u64>,
+    codecs: &[FastFieldCodecType],
+) -> Option<FastFieldCodecType> {
+    let mut estimations = Vec::new();
+    for &codec in codecs {
+        let estimation_opt = match codec {
+            FastFieldCodecType::Bitpacked => BitpackedCodec::estimate(&column),
+            FastFieldCodecType::Linear => LinearCodec::estimate(&column),
+            FastFieldCodecType::BlockwiseLinear => BlockwiseLinearCodec::estimate(&column),
+        };
+        if let Some(estimation) = estimation_opt {
+            estimations.push((estimation, codec));
+        }
+    }
+    if let Some(broken_estimation) = estimations.iter().find(|estimation| estimation.0.is_nan()) {
+        warn!(
+            "broken estimation for fast field codec {:?}",
+            broken_estimation.1
+        );
+    }
+    // removing nan values for codecs with broken calculations, and max values which disables
+    // codecs
+    estimations.retain(|estimation| !estimation.0.is_nan() && estimation.0 != f32::MAX);
+    estimations.sort_by(|(score_left, _), (score_right, _)| score_left.total_cmp(score_right));
+    Some(estimations.first()?.1)
+}
+
+fn serialize_given_codec(
+    column: impl Column<u64>,
+    codec_type: FastFieldCodecType,
+    output: &mut impl io::Write,
+) -> io::Result<()> {
+    match codec_type {
+        FastFieldCodecType::Bitpacked => {
+            BitpackedCodec::serialize(&column, output)?;
+        }
+        FastFieldCodecType::Linear => {
+            LinearCodec::serialize(&column, output)?;
+        }
+        FastFieldCodecType::BlockwiseLinear => {
+            BlockwiseLinearCodec::serialize(&column, output)?;
+        }
+    }
+    output.flush()?;
+    Ok(())
+}
+
+/// Helper function to serialize a column (autodetect from all codecs) and then open it
+pub fn serialize_and_load<T: MonotonicallyMappableToU64 + Ord + Default + fmt::Debug>(
+    column: &[T],
+) -> Arc<dyn Column<T>> {
+    let mut buffer = Vec::new();
+    super::serialize(VecColumn::from(&column), &mut buffer, &ALL_CODEC_TYPES).unwrap();
+    super::open(OwnedBytes::new(buffer)).unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_serialize_deserialize_u128_header() {
+        let original = U128Header {
+            num_vals: 11,
+            codec_type: U128FastFieldCodecType::CompactSpace,
+        };
+        let mut out = Vec::new();
+        original.serialize(&mut out).unwrap();
+        let restored = U128Header::deserialize(&mut &out[..]).unwrap();
+        assert_eq!(restored, original);
+    }
+
+    #[test]
+    fn test_serialize_deserialize() {
+        let original = [1u64, 5u64, 10u64];
+        let restored: Vec<u64> = serialize_and_load(&original[..]).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(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
+        // 5 bytes of header, 1 byte of value, 7 bytes of padding.
+        assert_eq!(buffer.len(), 3 + 5 + 8 + 4 + 2);
+    }
+
+    #[test]
+    fn test_fastfield_bool_bit_size_bitwidth_0() {
+        let mut buffer = Vec::new();
+        let col = VecColumn::from(&[true][..]);
+        serialize(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
+        // 5 bytes of header, 0 bytes of value, 7 bytes of padding.
+        assert_eq!(buffer.len(), 3 + 5 + 7 + 4 + 2);
+    }
+
+    #[test]
+    fn test_fastfield_gcd() {
+        let mut buffer = Vec::new();
+        let vals: Vec<u64> = (0..80).map(|val| (val % 7) * 1_000u64).collect();
+        let col = VecColumn::from(&vals[..]);
+        serialize(col, &mut buffer, &[FastFieldCodecType::Bitpacked]).unwrap();
+        // Values are stored over 3 bits.
+        assert_eq!(buffer.len(), 3 + 7 + (3 * 80 / 8) + 7 + 4 + 2);
+    }
+}

run-tests.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+cargo test

src/aggregation/agg_req_with_accessor.rs

@@ -15,7 +15,7 @@ use super::metric::{
 use super::segment_agg_result::BucketCount;
 use super::VecWithNames;
 use crate::fastfield::{type_and_cardinality, MultiValuedFastFieldReader};
-use crate::schema::Type;
+use crate::schema::{Cardinality, Type};
 use crate::{InvertedIndexReader, SegmentReader, TantivyError};
 
 #[derive(Clone, Default)]
@@ -94,7 +94,10 @@ impl BucketAggregationWithAccessor {
             BucketAggregationType::Terms(TermsAggregation {
                 field: field_name, ..
             }) => {
-                let field = reader.schema().get_field(field_name)?;
+                let field = reader
+                    .schema()
+                    .get_field(field_name)
+                    .ok_or_else(|| TantivyError::FieldNotFound(field_name.to_string()))?;
                 inverted_index = Some(reader.inverted_index(field)?);
                 get_ff_reader_and_validate(reader, field_name, Cardinality::MultiValues)?
             }
@@ -192,7 +195,10 @@ fn get_ff_reader_and_validate(
     field_name: &str,
     cardinality: Cardinality,
 ) -> crate::Result<(FastFieldAccessor, Type)> {
-    let field = reader.schema().get_field(field_name)?;
+    let field = reader
+        .schema()
+        .get_field(field_name)
+        .ok_or_else(|| TantivyError::FieldNotFound(field_name.to_string()))?;
     let field_type = reader.schema().get_field_entry(field).field_type();
 
     if let Some((_ff_type, field_cardinality)) = type_and_cardinality(field_type) {
@@ -212,10 +218,10 @@ fn get_ff_reader_and_validate(
     let ff_fields = reader.fast_fields();
     match cardinality {
         Cardinality::SingleValue => ff_fields
-            .u64_lenient(field_name)
+            .u64_lenient(field)
             .map(|field| (FastFieldAccessor::Single(field), field_type.value_type())),
         Cardinality::MultiValues => ff_fields
-            .u64s_lenient(field_name)
+            .u64s_lenient(field)
             .map(|field| (FastFieldAccessor::Multi(field), field_type.value_type())),
     }
 }

src/aggregation/bucket/histogram/histogram.rs

@@ -548,7 +548,9 @@ pub(crate) fn intermediate_histogram_buckets_to_final_buckets(
     };
 
     // If we have a date type on the histogram buckets, we add the `key_as_string` field as rfc339
-    let field = schema.get_field(&histogram_req.field)?;
+    let field = schema
+        .get_field(&histogram_req.field)
+        .ok_or_else(|| TantivyError::FieldNotFound(histogram_req.field.to_string()))?;
     if schema.get_field_entry(field).field_type().is_date() {
         for bucket in buckets.iter_mut() {
             if let crate::aggregation::Key::F64(val) = bucket.key {

src/aggregation/intermediate_agg_result.rs

@@ -26,6 +26,7 @@ use super::{format_date, Key, SerializedKey, VecWithNames};
 use crate::aggregation::agg_result::{AggregationResults, BucketEntries, BucketEntry};
 use crate::aggregation::bucket::TermsAggregationInternal;
 use crate::schema::Schema;
+use crate::TantivyError;
 
 /// Contains the intermediate aggregation result, which is optimized to be merged with other
 /// intermediate results.
@@ -657,7 +658,9 @@ impl IntermediateRangeBucketEntry {
 
         // If we have a date type on the histogram buckets, we add the `key_as_string` field as
         // rfc339
-        let field = schema.get_field(&range_req.field)?;
+        let field = schema
+            .get_field(&range_req.field)
+            .ok_or_else(|| TantivyError::FieldNotFound(range_req.field.to_string()))?;
         if schema.get_field_entry(field).field_type().is_date() {
             if let Some(val) = range_bucket_entry.to {
                 let key_as_string = format_date(val as i64)?;

src/aggregation/metric/average.rs

@@ -6,13 +6,14 @@ use super::{IntermediateStats, SegmentStatsCollector};
 
 /// A single-value metric aggregation that computes the average of numeric values that are
 /// extracted from the aggregated documents.
+/// Supported field types are u64, i64, and f64.
 /// See [super::SingleMetricResult] for return value.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "avg": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 /// }
 /// ```

src/aggregation/metric/count.rs

@@ -6,13 +6,14 @@ use super::{IntermediateStats, SegmentStatsCollector};
 
 /// A single-value metric aggregation that counts the number of values that are
 /// extracted from the aggregated documents.
+/// Supported field types are u64, i64, and f64.
 /// See [super::SingleMetricResult] for return value.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "value_count": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 /// }
 /// ```

src/aggregation/metric/max.rs

@@ -6,13 +6,14 @@ use super::{IntermediateStats, SegmentStatsCollector};
 
 /// A single-value metric aggregation that computes the maximum of numeric values that are
 /// extracted from the aggregated documents.
+/// Supported field types are u64, i64, and f64.
 /// See [super::SingleMetricResult] for return value.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "max": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 /// }
 /// ```

src/aggregation/metric/min.rs

@@ -6,13 +6,14 @@ use super::{IntermediateStats, SegmentStatsCollector};
 
 /// A single-value metric aggregation that computes the minimum of numeric values that are
 /// extracted from the aggregated documents.
+/// Supported field types are u64, i64, and f64.
 /// See [super::SingleMetricResult] for return value.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "min": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 /// }
 /// ```

src/aggregation/metric/mod.rs

@@ -43,13 +43,13 @@ mod tests {
     use crate::aggregation::agg_result::AggregationResults;
     use crate::aggregation::AggregationCollector;
     use crate::query::AllQuery;
-    use crate::schema::{NumericOptions, Schema};
+    use crate::schema::{Cardinality, NumericOptions, Schema};
     use crate::Index;
 
     #[test]
     fn test_metric_aggregations() {
         let mut schema_builder = Schema::builder();
-        let field_options = NumericOptions::default().set_fast();
+        let field_options = NumericOptions::default().set_fast(Cardinality::SingleValue);
         let field = schema_builder.add_f64_field("price", field_options);
         let index = Index::create_in_ram(schema_builder.build());
         let mut index_writer = index.writer_for_tests().unwrap();
@@ -80,12 +80,12 @@ mod tests {
             "price_stats": { "stats": { "field": "price" } },
             "price_sum": { "sum": { "field": "price" } }
         }"#;
-        let aggregations: Aggregations = serde_json::from_str(aggregations_json).unwrap();
+        let aggregations: Aggregations = serde_json::from_str(&aggregations_json).unwrap();
         let collector = AggregationCollector::from_aggs(aggregations, None, index.schema());
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         let aggregations_res: AggregationResults = searcher.search(&AllQuery, &collector).unwrap();
-        let aggregations_res_json = serde_json::to_value(aggregations_res).unwrap();
+        let aggregations_res_json = serde_json::to_value(&aggregations_res).unwrap();
 
         assert_eq!(aggregations_res_json["price_avg"]["value"], 2.5);
         assert_eq!(aggregations_res_json["price_count"]["value"], 6.0);

src/aggregation/metric/stats.rs

@@ -7,13 +7,14 @@ use crate::{DocId, TantivyError};
 
 /// A multi-value metric aggregation that computes a collection of statistics on numeric values that
 /// are extracted from the aggregated documents.
+/// Supported field types are `u64`, `i64`, and `f64`.
 /// See [`Stats`] for returned statistics.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "stats": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 ///  }
 /// ```

src/aggregation/metric/sum.rs

@@ -6,13 +6,14 @@ use super::{IntermediateStats, SegmentStatsCollector};
 
 /// A single-value metric aggregation that sums up numeric values that are
 /// extracted from the aggregated documents.
+/// Supported field types are u64, i64, and f64.
 /// See [super::SingleMetricResult] for return value.
 ///
 /// # JSON Format
 /// ```json
 /// {
 ///     "sum": {
-///         "field": "score"
+///         "field": "score",
 ///     }
 /// }
 /// ```

src/aggregation/mod.rs

@@ -1,5 +1,6 @@
 //! # Aggregations
 //!
+//!
 //! An aggregation summarizes your data as statistics on buckets or metrics.
 //!
 //! Aggregations can provide answer to questions like:
@@ -40,10 +41,6 @@
 //! - [Metric](metric)
 //!     - [Average](metric::AverageAggregation)
 //!     - [Stats](metric::StatsAggregation)
-//!     - [Min](metric::MinAggregation)
-//!     - [Max](metric::MaxAggregation)
-//!     - [Sum](metric::SumAggregation)
-//!     - [Count](metric::CountAggregation)
 //!
 //! # Example
 //! Compute the average metric, by building [`agg_req::Aggregations`], which is built from an
@@ -78,7 +75,7 @@
 //! }
 //! ```
 //! # Example JSON
-//! Requests are compatible with the elasticsearch JSON request format.
+//! Requests are compatible with the elasticsearch json request format.
 //!
 //! ```
 //! use tantivy::aggregation::agg_req::Aggregations;
@@ -433,13 +430,13 @@ mod tests {
         let text_field_id = schema_builder.add_text_field("text_id", text_fieldtype);
         let string_field_id = schema_builder.add_text_field("string_id", STRING | FAST);
         let score_fieldtype =
-            crate::schema::NumericOptions::default().set_fast();
+            crate::schema::NumericOptions::default().set_fast(Cardinality::SingleValue);
         let score_field = schema_builder.add_u64_field("score", score_fieldtype.clone());
         let score_field_f64 = schema_builder.add_f64_field("score_f64", score_fieldtype.clone());
         let score_field_i64 = schema_builder.add_i64_field("score_i64", score_fieldtype);
         let fraction_field = schema_builder.add_f64_field(
             "fraction_f64",
-            crate::schema::NumericOptions::default().set_fast(),
+            crate::schema::NumericOptions::default().set_fast(Cardinality::SingleValue),
         );
         let index = Index::create_in_ram(schema_builder.build());
         {
@@ -657,12 +654,12 @@ mod tests {
         let date_field = schema_builder.add_date_field("date", FAST);
         schema_builder.add_text_field("dummy_text", STRING);
         let score_fieldtype =
-            crate::schema::NumericOptions::default().set_fast();
+            crate::schema::NumericOptions::default().set_fast(Cardinality::SingleValue);
         let score_field = schema_builder.add_u64_field("score", score_fieldtype.clone());
         let score_field_f64 = schema_builder.add_f64_field("score_f64", score_fieldtype.clone());
 
         let multivalue =
-            crate::schema::NumericOptions::default().set_fast();
+            crate::schema::NumericOptions::default().set_fast(Cardinality::MultiValues);
         let scores_field_i64 = schema_builder.add_i64_field("scores_i64", multivalue);
 
         let score_field_i64 = schema_builder.add_i64_field("score_i64", score_fieldtype);
@@ -1190,7 +1187,7 @@ mod tests {
             let text_field_few_terms =
                 schema_builder.add_text_field("text_few_terms", STRING | FAST);
             let score_fieldtype =
-                crate::schema::NumericOptions::default().set_fast();
+                crate::schema::NumericOptions::default().set_fast(Cardinality::SingleValue);
             let score_field = schema_builder.add_u64_field("score", score_fieldtype.clone());
             let score_field_f64 =
                 schema_builder.add_f64_field("score_f64", score_fieldtype.clone());

src/collector/facet_collector.rs

@@ -1,11 +1,12 @@
 use std::cmp::Ordering;
 use std::collections::{btree_map, BTreeMap, BTreeSet, BinaryHeap};
+use std::iter::Peekable;
 use std::ops::Bound;
-use std::{io, u64, usize};
+use std::{u64, usize};
 
 use crate::collector::{Collector, SegmentCollector};
 use crate::fastfield::FacetReader;
-use crate::schema::Facet;
+use crate::schema::{Facet, Field};
 use crate::{DocId, Score, SegmentOrdinal, SegmentReader};
 
 struct Hit<'a> {
@@ -118,7 +119,7 @@ fn facet_depth(facet_bytes: &[u8]) -> usize {
 ///     let searcher = reader.searcher();
 ///
 ///     {
-///         let mut facet_collector = FacetCollector::for_field("facet");
+///         let mut facet_collector = FacetCollector::for_field(facet);
 ///         facet_collector.add_facet("/lang");
 ///         facet_collector.add_facet("/category");
 ///         let facet_counts = searcher.search(&AllQuery, &facet_collector)?;
@@ -134,7 +135,7 @@ fn facet_depth(facet_bytes: &[u8]) -> usize {
 ///     }
 ///
 ///     {
-///         let mut facet_collector = FacetCollector::for_field("facet");
+///         let mut facet_collector = FacetCollector::for_field(facet);
 ///         facet_collector.add_facet("/category/fiction");
 ///         let facet_counts = searcher.search(&AllQuery, &facet_collector)?;
 ///
@@ -166,18 +167,47 @@ fn facet_depth(facet_bytes: &[u8]) -> usize {
 /// # assert!(example().is_ok());
 /// ```
 pub struct FacetCollector {
-    field_name: String,
+    field: Field,
     facets: BTreeSet<Facet>,
 }
 
 pub struct FacetSegmentCollector {
     reader: FacetReader,
+    facet_ords_buf: Vec<u64>,
+    // facet_ord -> collapse facet_id
+    collapse_mapping: Vec<usize>,
     // collapse facet_id -> count
     counts: Vec<u64>,
-    // facet_ord -> compressed collapse facet_id
-    compressed_collapse_mapping: Vec<usize>,
-    // compressed collapse facet_id -> facet_ord
-    unique_facet_ords: Vec<(u64, usize)>,
+    // collapse facet_id -> facet_ord
+    collapse_facet_ords: Vec<u64>,
+}
+
+enum SkipResult {
+    Found,
+    NotFound,
+}
+
+fn skip<'a, I: Iterator<Item = &'a Facet>>(
+    target: &[u8],
+    collapse_it: &mut Peekable<I>,
+) -> SkipResult {
+    loop {
+        match collapse_it.peek() {
+            Some(facet_bytes) => match facet_bytes.encoded_str().as_bytes().cmp(target) {
+                Ordering::Less => {}
+                Ordering::Greater => {
+                    return SkipResult::NotFound;
+                }
+                Ordering::Equal => {
+                    return SkipResult::Found;
+                }
+            },
+            None => {
+                return SkipResult::NotFound;
+            }
+        }
+        collapse_it.next();
+    }
 }
 
 impl FacetCollector {
@@ -186,9 +216,9 @@ impl FacetCollector {
     ///
     /// This function does not check whether the field
     /// is of the proper type.
-    pub fn for_field(field_name: impl ToString) -> FacetCollector {
+    pub fn for_field(field: Field) -> FacetCollector {
         FacetCollector {
-            field_name: field_name.to_string(),
+            field,
             facets: BTreeSet::default(),
         }
     }
@@ -219,29 +249,6 @@ impl FacetCollector {
     }
 }
 
-fn compress_mapping(mapping: &[(u64, usize)]) -> (Vec<usize>, Vec<(u64, usize)>) {
-    // facet_ord -> collapse facet_id
-    let mut compressed_collapse_mapping: Vec<usize> = Vec::with_capacity(mapping.len());
-    // collapse facet_id -> facet_ord
-    let mut unique_facet_ords: Vec<(u64, usize)> = Vec::new();
-    if mapping.is_empty() {
-        return (Vec::new(), Vec::new());
-    }
-    compressed_collapse_mapping.push(0);
-    unique_facet_ords.push(mapping[0]);
-    let mut last_facet_ord = mapping[0];
-    let mut last_facet_id = 0;
-    for &facet_ord in &mapping[1..] {
-        if facet_ord != last_facet_ord {
-            last_facet_id += 1;
-            last_facet_ord = facet_ord;
-            unique_facet_ords.push(facet_ord);
-        }
-        compressed_collapse_mapping.push(last_facet_id);
-    }
-    (compressed_collapse_mapping, unique_facet_ords)
-}
-
 impl Collector for FacetCollector {
     type Fruit = FacetCounts;
 
@@ -252,17 +259,59 @@ impl Collector for FacetCollector {
         _: SegmentOrdinal,
         reader: &SegmentReader,
     ) -> crate::Result<FacetSegmentCollector> {
-        let facet_reader = reader.facet_reader(&self.field_name)?;
-        let facet_dict = facet_reader.facet_dict();
-        let collapse_mapping: Vec<(u64, usize)> =
-            compute_collapse_mapping(facet_dict, &self.facets)?;
-        let (compressed_collapse_mapping, unique_facet_ords) = compress_mapping(&collapse_mapping);
-        let counts = vec![0u64; unique_facet_ords.len()];
+        let facet_reader = reader.facet_reader(self.field)?;
+
+        let mut collapse_mapping = Vec::new();
+        let mut counts = Vec::new();
+        let mut collapse_facet_ords = Vec::new();
+
+        let mut collapse_facet_it = self.facets.iter().peekable();
+        collapse_facet_ords.push(0);
+        {
+            let mut facet_streamer = facet_reader.facet_dict().range().into_stream()?;
+            if facet_streamer.advance() {
+                'outer: loop {
+                    // at the beginning of this loop, facet_streamer
+                    // is positioned on a term that has not been processed yet.
+                    let skip_result = skip(facet_streamer.key(), &mut collapse_facet_it);
+                    match skip_result {
+                        SkipResult::Found => {
+                            // we reach a facet we decided to collapse.
+                            let collapse_depth = facet_depth(facet_streamer.key());
+                            let mut collapsed_id = 0;
+                            collapse_mapping.push(0);
+                            while facet_streamer.advance() {
+                                let depth = facet_depth(facet_streamer.key());
+                                if depth <= collapse_depth {
+                                    continue 'outer;
+                                }
+                                if depth == collapse_depth + 1 {
+                                    collapsed_id = collapse_facet_ords.len();
+                                    collapse_facet_ords.push(facet_streamer.term_ord());
+                                }
+                                collapse_mapping.push(collapsed_id);
+                            }
+                            break;
+                        }
+                        SkipResult::NotFound => {
+                            collapse_mapping.push(0);
+                            if !facet_streamer.advance() {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        counts.resize(collapse_facet_ords.len(), 0);
+
         Ok(FacetSegmentCollector {
             reader: facet_reader,
-            compressed_collapse_mapping,
+            facet_ords_buf: Vec::with_capacity(255),
+            collapse_mapping,
             counts,
-            unique_facet_ords,
+            collapse_facet_ords,
         })
     }
 
@@ -281,78 +330,14 @@ impl Collector for FacetCollector {
     }
 }
 
-fn is_child_facet(parent_facet: &[u8], possible_child_facet: &[u8]) -> bool {
-    if !possible_child_facet.starts_with(parent_facet) {
-        return false;
-    }
-    possible_child_facet.get(parent_facet.len()).copied() == Some(0u8)
-}
-
-fn compute_collapse_mapping_one(
-    facet_terms: &mut columnar::Streamer,
-    facet_bytes: &[u8],
-    collapsed: &mut [(u64, usize)],
-) -> io::Result<bool> {
-    let mut facet_child: Vec<u8> = Vec::new();
-    let mut term_ord = 0;
-    let offset = facet_bytes.len() + 1;
-    let depth = facet_depth(facet_bytes);
-    loop {
-        match facet_terms.key().cmp(facet_bytes) {
-            Ordering::Less | Ordering::Equal => {}
-            Ordering::Greater => {
-                if !is_child_facet(facet_bytes, facet_terms.key()) {
-                    return Ok(true);
-                }
-                let suffix = &facet_terms.key()[offset..];
-                if facet_child.is_empty() || !is_child_facet(&facet_child, suffix) {
-                    facet_child.clear();
-                    term_ord = facet_terms.term_ord();
-                    let end = suffix
-                        .iter()
-                        .position(|b| *b == 0u8)
-                        .unwrap_or(suffix.len());
-                    facet_child.extend(&suffix[..end]);
-                }
-                collapsed[facet_terms.term_ord() as usize] = (term_ord, depth);
-            }
-        }
-        if !facet_terms.advance() {
-            return Ok(false);
-        }
-    }
-}
-
-fn compute_collapse_mapping(
-    facet_dict: &columnar::Dictionary,
-    facets: &BTreeSet<Facet>,
-) -> io::Result<Vec<(u64, usize)>> {
-    let mut collapsed = vec![(u64::MAX, 0); facet_dict.num_terms()];
-    if facets.is_empty() {
-        return Ok(collapsed);
-    }
-    let mut facet_terms: columnar::Streamer = facet_dict.range().into_stream()?;
-    if !facet_terms.advance() {
-        return Ok(collapsed);
-    }
-    let mut facet_bytes = Vec::new();
-    for facet in facets {
-        facet_bytes.clear();
-        facet_bytes.extend(facet.encoded_str().as_bytes());
-        if !compute_collapse_mapping_one(&mut facet_terms, &facet_bytes, &mut collapsed[..])? {
-            break;
-        }
-    }
-    Ok(collapsed)
-}
-
 impl SegmentCollector for FacetSegmentCollector {
     type Fruit = FacetCounts;
 
     fn collect(&mut self, doc: DocId, _: Score) {
+        self.reader.facet_ords(doc, &mut self.facet_ords_buf);
         let mut previous_collapsed_ord: usize = usize::MAX;
-        for facet_ord in self.reader.facet_ords(doc) {
-            let collapsed_ord = self.compressed_collapse_mapping[facet_ord as usize];
+        for &facet_ord in &self.facet_ords_buf {
+            let collapsed_ord = self.collapse_mapping[facet_ord as usize];
             self.counts[collapsed_ord] += u64::from(collapsed_ord != previous_collapsed_ord);
             previous_collapsed_ord = collapsed_ord;
         }
@@ -370,17 +355,9 @@ impl SegmentCollector for FacetSegmentCollector {
                 continue;
             }
             let mut facet = vec![];
-            let (facet_ord, facet_depth) = self.unique_facet_ords[collapsed_facet_ord];
+            let facet_ord = self.collapse_facet_ords[collapsed_facet_ord];
             // TODO handle errors.
             if facet_dict.ord_to_term(facet_ord, &mut facet).is_ok() {
-                if let Some((end_collapsed_facet, _)) = facet
-                    .iter()
-                    .enumerate()
-                    .filter(|(_pos, &b)| b == 0u8)
-                    .nth(facet_depth)
-                {
-                    facet.truncate(end_collapsed_facet);
-                }
                 if let Ok(facet) = Facet::from_encoded(facet) {
                     facet_counts.insert(facet, count);
                 }
@@ -464,114 +441,27 @@ impl FacetCounts {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeSet;
     use std::iter;
 
-    use columnar::Dictionary;
     use rand::distributions::Uniform;
     use rand::prelude::SliceRandom;
     use rand::{thread_rng, Rng};
 
     use super::{FacetCollector, FacetCounts};
-    use crate::collector::facet_collector::compress_mapping;
     use crate::collector::Count;
     use crate::core::Index;
     use crate::query::{AllQuery, QueryParser, TermQuery};
-    use crate::schema::{Document, Facet, FacetOptions, IndexRecordOption, Schema};
+    use crate::schema::{Document, Facet, FacetOptions, Field, IndexRecordOption, Schema};
     use crate::Term;
 
-    fn test_collapse_mapping_aux(
-        facet_terms: &[&str],
-        facet_params: &[&str],
-        expected_collapsed_mapping: &[(u64, usize)],
-    ) {
-        let mut facets: Vec<Facet> = facet_terms.iter().map(Facet::from).collect();
-        facets.sort();
-        let facet_terms: Vec<&str> = facets.iter().map(|facet| facet.encoded_str()).collect();
-        let dictionary = Dictionary::build_for_tests(&facet_terms);
-        let facet_params: BTreeSet<Facet> = facet_params.iter().map(Facet::from).collect();
-        let collapse_mapping = super::compute_collapse_mapping(&dictionary, &facet_params).unwrap();
-        assert_eq!(&collapse_mapping[..], expected_collapsed_mapping);
-    }
-
     #[test]
-    fn test_collapse_simple() {
-        test_collapse_mapping_aux(&["/facet/a", "/facet/b"], &["/facet"], &[(0, 1), (1, 1)]);
-        test_collapse_mapping_aux(
-            &["/facet/a", "/facet/a2", "/facet/b"],
-            &["/facet"],
-            &[(0, 1), (1, 1), (2, 1)],
-        );
-        test_collapse_mapping_aux(&["/facet/a", "/facet/a/2"], &["/facet"], &[(0, 1), (0, 1)]);
-        test_collapse_mapping_aux(
-            &["/facet/a", "/facet/a/2", "/facet/b"],
-            &["/facet"],
-            &[(0, 1), (0, 1), (2, 1)],
-        );
-    }
-
-    fn test_compress_mapping_aux(
-        collapsed_mapping: &[(u64, usize)],
-        expected_compressed_collapsed_mapping: &[usize],
-        expected_unique_facet_ords: &[(u64, usize)],
-    ) {
-        let (compressed_collapsed_mapping, unique_facet_ords) =
-            compress_mapping(&collapsed_mapping);
-        assert_eq!(
-            compressed_collapsed_mapping,
-            expected_compressed_collapsed_mapping
-        );
-        assert_eq!(unique_facet_ords, expected_unique_facet_ords);
-    }
-
-    #[test]
-    fn test_compress_mapping() {
-        test_compress_mapping_aux(&[], &[], &[]);
-        test_compress_mapping_aux(&[(1, 2)], &[0], &[(1, 2)]);
-        test_compress_mapping_aux(&[(1, 2), (1, 2)], &[0, 0], &[(1, 2)]);
-        test_compress_mapping_aux(
-            &[(1, 2), (5, 2), (5, 2), (6, 3), (8, 3)],
-            &[0, 1, 1, 2, 3],
-            &[(1, 2), (5, 2), (6, 3), (8, 3)],
-        );
-    }
-
-    #[test]
-    fn test_facet_collector_simple() {
-        let mut schema_builder = Schema::builder();
-        let facet_field = schema_builder.add_facet_field("facet", FacetOptions::default());
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-        let mut index_writer = index.writer_for_tests().unwrap();
-        index_writer
-            .add_document(doc!(facet_field=>Facet::from("/facet/a")))
-            .unwrap();
-        index_writer
-            .add_document(doc!(facet_field=>Facet::from("/facet/b")))
-            .unwrap();
-        index_writer
-            .add_document(doc!(facet_field=>Facet::from("/facet/b")))
-            .unwrap();
-        index_writer
-            .add_document(doc!(facet_field=>Facet::from("/facet/c")))
-            .unwrap();
-        index_writer.commit().unwrap();
-        let searcher = index.reader().unwrap().searcher();
-        let mut facet_collector = FacetCollector::for_field("facet");
-        facet_collector.add_facet("/facet");
-        let counts: FacetCounts = searcher.search(&AllQuery, &facet_collector).unwrap();
-        let facets: Vec<(&Facet, u64)> = counts.top_k("/facet", 1);
-        assert_eq!(facets, vec![(&Facet::from("/facet/b"), 2)]);
-    }
-
-    #[test]
-    fn test_facet_collector_drilldown() {
+    fn test_facet_collector_drilldown() -> crate::Result<()> {
         let mut schema_builder = Schema::builder();
         let facet_field = schema_builder.add_facet_field("facet", FacetOptions::default());
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
 
-        let mut index_writer = index.writer_for_tests().unwrap();
+        let mut index_writer = index.writer_for_tests()?;
         let num_facets: usize = 3 * 4 * 5;
         let facets: Vec<Facet> = (0..num_facets)
             .map(|mut n| {
@@ -586,14 +476,14 @@ mod tests {
         for i in 0..num_facets * 10 {
             let mut doc = Document::new();
             doc.add_facet(facet_field, facets[i % num_facets].clone());
-            index_writer.add_document(doc).unwrap();
+            index_writer.add_document(doc)?;
         }
-        index_writer.commit().unwrap();
-        let reader = index.reader().unwrap();
+        index_writer.commit()?;
+        let reader = index.reader()?;
         let searcher = reader.searcher();
-        let mut facet_collector = FacetCollector::for_field("facet");
+        let mut facet_collector = FacetCollector::for_field(facet_field);
         facet_collector.add_facet(Facet::from("/top1"));
-        let counts = searcher.search(&AllQuery, &facet_collector).unwrap();
+        let counts = searcher.search(&AllQuery, &facet_collector)?;
 
         {
             let facets: Vec<(String, u64)> = counts
@@ -613,6 +503,7 @@ mod tests {
                 .collect::<Vec<_>>()
             );
         }
+        Ok(())
     }
 
     #[test]
@@ -620,7 +511,7 @@ mod tests {
         expected = "Tried to add a facet which is a descendant of an already added facet."
     )]
     fn test_misused_facet_collector() {
-        let mut facet_collector = FacetCollector::for_field("facet");
+        let mut facet_collector = FacetCollector::for_field(Field::from_field_id(0));
         facet_collector.add_facet(Facet::from("/country"));
         facet_collector.add_facet(Facet::from("/country/europe"));
     }
@@ -642,7 +533,7 @@ mod tests {
         let reader = index.reader()?;
         let searcher = reader.searcher();
         assert_eq!(searcher.num_docs(), 1);
-        let mut facet_collector = FacetCollector::for_field("facets");
+        let mut facet_collector = FacetCollector::for_field(facet_field);
         facet_collector.add_facet("/subjects");
         let counts = searcher.search(&AllQuery, &facet_collector)?;
         let facets: Vec<(&Facet, u64)> = counts.get("/subjects").collect();
@@ -702,7 +593,7 @@ mod tests {
 
     #[test]
     fn test_non_used_facet_collector() {
-        let mut facet_collector = FacetCollector::for_field("facet");
+        let mut facet_collector = FacetCollector::for_field(Field::from_field_id(0));
         facet_collector.add_facet(Facet::from("/country"));
         facet_collector.add_facet(Facet::from("/countryeurope"));
     }
@@ -739,7 +630,7 @@ mod tests {
         index_writer.commit().unwrap();
         let searcher = index.reader().unwrap().searcher();
 
-        let mut facet_collector = FacetCollector::for_field("facet");
+        let mut facet_collector = FacetCollector::for_field(facet_field);
         facet_collector.add_facet("/facet");
         let counts: FacetCounts = searcher.search(&AllQuery, &facet_collector).unwrap();
 
@@ -779,7 +670,7 @@ mod tests {
         index_writer.commit()?;
 
         let searcher = index.reader()?.searcher();
-        let mut facet_collector = FacetCollector::for_field("facet");
+        let mut facet_collector = FacetCollector::for_field(facet_field);
         facet_collector.add_facet("/facet");
         let counts: FacetCounts = searcher.search(&AllQuery, &facet_collector)?;
 

src/collector/filter_collector_wrapper.rs

@@ -12,10 +12,10 @@
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-use columnar::{DynamicColumn, HasAssociatedColumnType};
 use fastfield_codecs::Column;
 
 use crate::collector::{Collector, SegmentCollector};
+use crate::fastfield::FastValue;
 use crate::schema::Field;
 use crate::{Score, SegmentReader, TantivyError};
 
@@ -61,7 +61,7 @@ use crate::{Score, SegmentReader, TantivyError};
 /// # Ok(())
 /// # }
 /// ```
-pub struct FilterCollector<TCollector, TPredicate, TPredicateValue: Default>
+pub struct FilterCollector<TCollector, TPredicate, TPredicateValue: FastValue>
 where TPredicate: 'static + Clone
 {
     field: Field,
@@ -70,7 +70,7 @@ where TPredicate: 'static + Clone
     t_predicate_value: PhantomData<TPredicateValue>,
 }
 
-impl<TCollector, TPredicate, TPredicateValue: Default>
+impl<TCollector, TPredicate, TPredicateValue: FastValue>
     FilterCollector<TCollector, TPredicate, TPredicateValue>
 where
     TCollector: Collector + Send + Sync,
@@ -91,13 +91,12 @@ where
     }
 }
 
-impl<TCollector, TPredicate, TPredicateValue: Default> Collector
+impl<TCollector, TPredicate, TPredicateValue: FastValue> Collector
     for FilterCollector<TCollector, TPredicate, TPredicateValue>
 where
     TCollector: Collector + Send + Sync,
     TPredicate: 'static + Fn(TPredicateValue) -> bool + Send + Sync + Clone,
-    TPredicateValue: HasAssociatedColumnType,
-    DynamicColumn: Into<Option<columnar::Column<TPredicateValue>>>,
+    TPredicateValue: FastValue,
 {
     // That's the type of our result.
     // Our standard deviation will be a float.
@@ -118,10 +117,20 @@ where
                 field_entry.name()
             )));
         }
+        let requested_type = TPredicateValue::to_type();
+        let field_schema_type = field_entry.field_type().value_type();
+        if requested_type != field_schema_type {
+            return Err(TantivyError::SchemaError(format!(
+                "Field {:?} is of type {:?}!={:?}",
+                field_entry.name(),
+                requested_type,
+                field_schema_type
+            )));
+        }
 
         let fast_field_reader = segment_reader
             .fast_fields()
-            .typed_column_first_or_default(schema.get_field_name(self.field))?;
+            .typed_fast_field_reader(self.field)?;
 
         let segment_collector = self
             .collector
@@ -150,7 +159,7 @@ where
 pub struct FilterSegmentCollector<TSegmentCollector, TPredicate, TPredicateValue>
 where
     TPredicate: 'static,
-    DynamicColumn: Into<Option<columnar::Column<TPredicateValue>>>,
+    TPredicateValue: FastValue,
 {
     fast_field_reader: Arc<dyn Column<TPredicateValue>>,
     segment_collector: TSegmentCollector,
@@ -162,9 +171,8 @@ impl<TSegmentCollector, TPredicate, TPredicateValue> SegmentCollector
     for FilterSegmentCollector<TSegmentCollector, TPredicate, TPredicateValue>
 where
     TSegmentCollector: SegmentCollector,
-    TPredicateValue: HasAssociatedColumnType,
     TPredicate: 'static + Fn(TPredicateValue) -> bool + Send + Sync,
-    DynamicColumn: Into<Option<columnar::Column<TPredicateValue>>>,
+    TPredicateValue: FastValue,
 {
     type Fruit = TSegmentCollector::Fruit;
 

src/collector/histogram_collector.rs

@@ -4,8 +4,8 @@ use fastdivide::DividerU64;
 use fastfield_codecs::Column;
 
 use crate::collector::{Collector, SegmentCollector};
-use crate::fastfield::{FastFieldNotAvailableError, FastValue};
-use crate::schema::Type;
+use crate::fastfield::FastValue;
+use crate::schema::{Field, Type};
 use crate::{DocId, Score};
 
 /// Histogram builds an histogram of the values of a fastfield for the
@@ -28,7 +28,7 @@ pub struct HistogramCollector {
     min_value: u64,
     num_buckets: usize,
     divider: DividerU64,
-    field: String,
+    field: Field,
 }
 
 impl HistogramCollector {
@@ -46,7 +46,7 @@ impl HistogramCollector {
     /// # Disclaimer
     /// This function panics if the field given is of type f64.
     pub fn new<TFastValue: FastValue>(
-        field: String,
+        field: Field,
         min_value: TFastValue,
         bucket_width: u64,
         num_buckets: usize,
@@ -87,14 +87,14 @@ impl HistogramComputer {
 }
 pub struct SegmentHistogramCollector {
     histogram_computer: HistogramComputer,
-    column_u64: Arc<dyn Column<u64>>,
+    ff_reader: Arc<dyn Column<u64>>,
 }
 
 impl SegmentCollector for SegmentHistogramCollector {
     type Fruit = Vec<u64>;
 
     fn collect(&mut self, doc: DocId, _score: Score) {
-        let value = self.column_u64.get_val(doc);
+        let value = self.ff_reader.get_val(doc);
         self.histogram_computer.add_value(value);
     }
 
@@ -112,18 +112,14 @@ impl Collector for HistogramCollector {
         _segment_local_id: crate::SegmentOrdinal,
         segment: &crate::SegmentReader,
     ) -> crate::Result<Self::Child> {
-        let column_opt = segment.fast_fields().u64_lenient(&self.field)?;
-        let column = column_opt.ok_or_else(|| FastFieldNotAvailableError {
-            field_name: self.field.clone(),
-        })?;
-        let column_u64 = column.first_or_default_col(0u64);
+        let ff_reader = segment.fast_fields().u64_lenient(self.field)?;
         Ok(SegmentHistogramCollector {
             histogram_computer: HistogramComputer {
                 counts: vec![0; self.num_buckets],
                 min_value: self.min_value,
                 divider: self.divider,
             },
-            column_u64,
+            ff_reader,
         })
     }
 
@@ -215,13 +211,13 @@ mod tests {
     #[test]
     fn test_no_segments() -> crate::Result<()> {
         let mut schema_builder = Schema::builder();
-        schema_builder.add_u64_field("val_field", FAST);
+        let val_field = schema_builder.add_u64_field("val_field", FAST);
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
         let reader = index.reader()?;
         let searcher = reader.searcher();
         let all_query = AllQuery;
-        let histogram_collector = HistogramCollector::new("val_field".to_string(), 0u64, 2, 5);
+        let histogram_collector = HistogramCollector::new(val_field, 0u64, 2, 5);
         let histogram = searcher.search(&all_query, &histogram_collector)?;
         assert_eq!(histogram, vec![0; 5]);
         Ok(())
@@ -242,8 +238,7 @@ mod tests {
         let reader = index.reader()?;
         let searcher = reader.searcher();
         let all_query = AllQuery;
-        let histogram_collector =
-            HistogramCollector::new("val_field".to_string(), -20i64, 10u64, 4);
+        let histogram_collector = HistogramCollector::new(val_field, -20i64, 10u64, 4);
         let histogram = searcher.search(&all_query, &histogram_collector)?;
         assert_eq!(histogram, vec![1, 1, 0, 1]);
         Ok(())
@@ -267,8 +262,7 @@ mod tests {
         let reader = index.reader()?;
         let searcher = reader.searcher();
         let all_query = AllQuery;
-        let histogram_collector =
-            HistogramCollector::new("val_field".to_string(), -20i64, 10u64, 4);
+        let histogram_collector = HistogramCollector::new(val_field, -20i64, 10u64, 4);
         let histogram = searcher.search(&all_query, &histogram_collector)?;
         assert_eq!(histogram, vec![1, 1, 0, 1]);
         Ok(())
@@ -291,7 +285,7 @@ mod tests {
         let searcher = reader.searcher();
         let all_query = AllQuery;
         let week_histogram_collector = HistogramCollector::new(
-            "date_field".to_string(),
+            date_field,
             DateTime::from_primitive(
                 Date::from_calendar_date(1980, Month::January, 1)?.with_hms(0, 0, 0)?,
             ),

src/collector/mod.rs

@@ -104,6 +104,7 @@ pub use self::custom_score_top_collector::{CustomScorer, CustomSegmentScorer};
 
 mod tweak_score_top_collector;
 pub use self::tweak_score_top_collector::{ScoreSegmentTweaker, ScoreTweaker};
+
 mod facet_collector;
 pub use self::facet_collector::{FacetCollector, FacetCounts};
 use crate::query::Weight;

src/collector/tests.rs

@@ -5,6 +5,7 @@ use fastfield_codecs::Column;
 use super::*;
 use crate::collector::{Count, FilterCollector, TopDocs};
 use crate::core::SegmentReader;
+use crate::fastfield::BytesFastFieldReader;
 use crate::query::{AllQuery, QueryParser};
 use crate::schema::{Field, Schema, FAST, TEXT};
 use crate::time::format_description::well_known::Rfc3339;
@@ -57,10 +58,9 @@ pub fn test_filter_collector() -> crate::Result<()> {
 
     assert_eq!(filtered_top_docs.len(), 0);
 
-    fn date_filter(value: columnar::DateTime) -> bool {
-        (crate::DateTime::from(value).into_utc()
-            - OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())
-        .whole_weeks()
+    fn date_filter(value: DateTime) -> bool {
+        (value.into_utc() - OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())
+            .whole_weeks()
             > 0
     }
 
@@ -155,7 +155,7 @@ impl SegmentCollector for TestSegmentCollector {
 ///
 /// This collector is mainly useful for tests.
 pub struct FastFieldTestCollector {
-    field: String,
+    field: Field,
 }
 
 pub struct FastFieldSegmentCollector {
@@ -164,10 +164,8 @@ pub struct FastFieldSegmentCollector {
 }
 
 impl FastFieldTestCollector {
-    pub fn for_field(field: impl ToString) -> FastFieldTestCollector {
-        FastFieldTestCollector {
-            field: field.to_string(),
-        }
+    pub fn for_field(field: Field) -> FastFieldTestCollector {
+        FastFieldTestCollector { field }
     }
 }
 
@@ -182,7 +180,7 @@ impl Collector for FastFieldTestCollector {
     ) -> crate::Result<FastFieldSegmentCollector> {
         let reader = segment_reader
             .fast_fields()
-            .u64(&self.field)
+            .u64(self.field)
             .expect("Requested field is not a fast field.");
         Ok(FastFieldSegmentCollector {
             vals: Vec::new(),
@@ -212,62 +210,62 @@ impl SegmentCollector for FastFieldSegmentCollector {
     }
 }
 
-// /// Collects in order all of the fast field bytes for all of the
-// /// docs in the `DocSet`
-// ///
-// /// This collector is mainly useful for tests.
-// pub struct BytesFastFieldTestCollector {
-//     field: Field,
-// }
+/// Collects in order all of the fast field bytes for all of the
+/// docs in the `DocSet`
+///
+/// This collector is mainly useful for tests.
+pub struct BytesFastFieldTestCollector {
+    field: Field,
+}
 
-// pub struct BytesFastFieldSegmentCollector {
-//     vals: Vec<u8>,
-//     reader: BytesFastFieldReader,
-// }
+pub struct BytesFastFieldSegmentCollector {
+    vals: Vec<u8>,
+    reader: BytesFastFieldReader,
+}
 
-// impl BytesFastFieldTestCollector {
-//     pub fn for_field(field: Field) -> BytesFastFieldTestCollector {
-//         BytesFastFieldTestCollector { field }
-//     }
-// }
+impl BytesFastFieldTestCollector {
+    pub fn for_field(field: Field) -> BytesFastFieldTestCollector {
+        BytesFastFieldTestCollector { field }
+    }
+}
 
-// impl Collector for BytesFastFieldTestCollector {
-//     type Fruit = Vec<u8>;
-//     type Child = BytesFastFieldSegmentCollector;
+impl Collector for BytesFastFieldTestCollector {
+    type Fruit = Vec<u8>;
+    type Child = BytesFastFieldSegmentCollector;
 
-//     fn for_segment(
-//         &self,
-//         _segment_local_id: u32,
-//         segment_reader: &SegmentReader,
-//     ) -> crate::Result<BytesFastFieldSegmentCollector> {
-//         let reader = segment_reader.fast_fields().bytes(self.field)?;
-//         Ok(BytesFastFieldSegmentCollector {
-//             vals: Vec::new(),
-//             reader,
-//         })
-//     }
+    fn for_segment(
+        &self,
+        _segment_local_id: u32,
+        segment_reader: &SegmentReader,
+    ) -> crate::Result<BytesFastFieldSegmentCollector> {
+        let reader = segment_reader.fast_fields().bytes(self.field)?;
+        Ok(BytesFastFieldSegmentCollector {
+            vals: Vec::new(),
+            reader,
+        })
+    }
 
-//     fn requires_scoring(&self) -> bool {
-//         false
-//     }
+    fn requires_scoring(&self) -> bool {
+        false
+    }
 
-//     fn merge_fruits(&self, children: Vec<Vec<u8>>) -> crate::Result<Vec<u8>> {
-//         Ok(children.into_iter().flat_map(|c| c.into_iter()).collect())
-//     }
-// }
+    fn merge_fruits(&self, children: Vec<Vec<u8>>) -> crate::Result<Vec<u8>> {
+        Ok(children.into_iter().flat_map(|c| c.into_iter()).collect())
+    }
+}
 
-// impl SegmentCollector for BytesFastFieldSegmentCollector {
-//     type Fruit = Vec<u8>;
+impl SegmentCollector for BytesFastFieldSegmentCollector {
+    type Fruit = Vec<u8>;
 
-//     fn collect(&mut self, doc: u32, _score: Score) {
-//         let data = self.reader.get_bytes(doc);
-//         self.vals.extend(data);
-//     }
+    fn collect(&mut self, doc: u32, _score: Score) {
+        let data = self.reader.get_bytes(doc);
+        self.vals.extend(data);
+    }
 
-//     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
-//         self.vals
-//     }
-// }
+    fn harvest(self) -> <Self as SegmentCollector>::Fruit {
+        self.vals
+    }
+}
 
 fn make_test_searcher() -> crate::Result<Searcher> {
     let schema = Schema::builder().build();

src/collector/top_score_collector.rs

@@ -12,7 +12,7 @@ use crate::collector::tweak_score_top_collector::TweakedScoreTopCollector;
 use crate::collector::{
     CustomScorer, CustomSegmentScorer, ScoreSegmentTweaker, ScoreTweaker, SegmentCollector,
 };
-use crate::fastfield::{FastFieldNotAvailableError, FastValue};
+use crate::fastfield::FastValue;
 use crate::query::Weight;
 use crate::schema::Field;
 use crate::{DocAddress, DocId, Score, SegmentOrdinal, SegmentReader, TantivyError};
@@ -22,7 +22,7 @@ struct FastFieldConvertCollector<
     TFastValue: FastValue,
 > {
     pub collector: TCollector,
-    pub field: String,
+    pub field: Field,
     pub fast_value: std::marker::PhantomData<TFastValue>,
 }
 
@@ -41,8 +41,7 @@ where
         segment: &SegmentReader,
     ) -> crate::Result<Self::Child> {
         let schema = segment.schema();
-        let field = schema.get_field(&self.field)?;
-        let field_entry = schema.get_field_entry(field);
+        let field_entry = schema.get_field_entry(self.field);
         if !field_entry.is_fast() {
             return Err(TantivyError::SchemaError(format!(
                 "Field {:?} is not a fast field.",
@@ -133,17 +132,17 @@ impl fmt::Debug for TopDocs {
 }
 
 struct ScorerByFastFieldReader {
-    sort_column: Arc<dyn Column<u64>>,
+    ff_reader: Arc<dyn Column<u64>>,
 }
 
 impl CustomSegmentScorer<u64> for ScorerByFastFieldReader {
     fn score(&mut self, doc: DocId) -> u64 {
-        self.sort_column.get_val(doc)
+        self.ff_reader.get_val(doc)
     }
 }
 
 struct ScorerByField {
-    field: String,
+    field: Field,
 }
 
 impl CustomScorer<u64> for ScorerByField {
@@ -155,13 +154,10 @@ impl CustomScorer<u64> for ScorerByField {
         // mapping is monotonic, so it is sufficient to compute our top-K docs.
         //
         // The conversion will then happen only on the top-K docs.
-        let sort_column_opt = segment_reader.fast_fields().u64_lenient(&self.field)?;
-        let sort_column = sort_column_opt
-            .ok_or_else(|| FastFieldNotAvailableError {
-                field_name: self.field.clone(),
-            })?
-            .first_or_default_col(0u64);
-        Ok(ScorerByFastFieldReader { sort_column })
+        let ff_reader = segment_reader
+            .fast_fields()
+            .typed_fast_field_reader(self.field)?;
+        Ok(ScorerByFastFieldReader { ff_reader })
     }
 }
 
@@ -294,14 +290,9 @@ impl TopDocs {
     /// the [.order_by_fast_field(...)](TopDocs::order_by_fast_field) method.
     pub fn order_by_u64_field(
         self,
-        field: impl ToString,
+        field: Field,
     ) -> impl Collector<Fruit = Vec<(u64, DocAddress)>> {
-        CustomScoreTopCollector::new(
-            ScorerByField {
-                field: field.to_string(),
-            },
-            self.0.into_tscore(),
-        )
+        CustomScoreTopCollector::new(ScorerByField { field }, self.0.into_tscore())
     }
 
     /// Set top-K to rank documents by a given fast field.
@@ -376,15 +367,15 @@ impl TopDocs {
     /// ```
     pub fn order_by_fast_field<TFastValue>(
         self,
-        fast_field: impl ToString,
+        fast_field: Field,
     ) -> impl Collector<Fruit = Vec<(TFastValue, DocAddress)>>
     where
         TFastValue: FastValue,
     {
-        let u64_collector = self.order_by_u64_field(fast_field.to_string());
+        let u64_collector = self.order_by_u64_field(fast_field);
         FastFieldConvertCollector {
             collector: u64_collector,
-            field: fast_field.to_string(),
+            field: fast_field,
             fast_value: PhantomData,
         }
     }
@@ -463,7 +454,7 @@ impl TopDocs {
     ///             // In our case, we will get a reader for the popularity
     ///             // fast field.
     ///             let popularity_reader =
-    ///                 segment_reader.fast_fields().u64("popularity").unwrap();
+    ///                 segment_reader.fast_fields().u64(popularity).unwrap();
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId, original_score: Score| {
@@ -570,9 +561,9 @@ impl TopDocs {
     ///             // Note that this is implemented by using a `(u64, u64)`
     ///             // as a score.
     ///             let popularity_reader =
-    ///                 segment_reader.fast_fields().u64("popularity").unwrap();
+    ///                 segment_reader.fast_fields().u64(popularity).unwrap();
     ///             let boosted_reader =
-    ///                 segment_reader.fast_fields().u64("boosted").unwrap();
+    ///                 segment_reader.fast_fields().u64(boosted).unwrap();
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId| {
@@ -886,7 +877,7 @@ mod tests {
         });
         let searcher = index.reader()?.searcher();
 
-        let top_collector = TopDocs::with_limit(4).order_by_u64_field(SIZE);
+        let top_collector = TopDocs::with_limit(4).order_by_u64_field(size);
         let top_docs: Vec<(u64, DocAddress)> = searcher.search(&query, &top_collector)?;
         assert_eq!(
             &top_docs[..],
@@ -925,7 +916,7 @@ mod tests {
         ))?;
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
-        let top_collector = TopDocs::with_limit(3).order_by_fast_field("birthday");
+        let top_collector = TopDocs::with_limit(3).order_by_fast_field(birthday);
         let top_docs: Vec<(DateTime, DocAddress)> = searcher.search(&AllQuery, &top_collector)?;
         assert_eq!(
             &top_docs[..],
@@ -955,7 +946,7 @@ mod tests {
         ))?;
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
-        let top_collector = TopDocs::with_limit(3).order_by_fast_field("altitude");
+        let top_collector = TopDocs::with_limit(3).order_by_fast_field(altitude);
         let top_docs: Vec<(i64, DocAddress)> = searcher.search(&AllQuery, &top_collector)?;
         assert_eq!(
             &top_docs[..],
@@ -985,7 +976,7 @@ mod tests {
         ))?;
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
-        let top_collector = TopDocs::with_limit(3).order_by_fast_field("altitude");
+        let top_collector = TopDocs::with_limit(3).order_by_fast_field(altitude);
         let top_docs: Vec<(f64, DocAddress)> = searcher.search(&AllQuery, &top_collector)?;
         assert_eq!(
             &top_docs[..],
@@ -1013,7 +1004,7 @@ mod tests {
                 .unwrap();
         });
         let searcher = index.reader().unwrap().searcher();
-        let top_collector = TopDocs::with_limit(4).order_by_u64_field("missing_field");
+        let top_collector = TopDocs::with_limit(4).order_by_u64_field(Field::from_field_id(2));
         let segment_reader = searcher.segment_reader(0u32);
         top_collector
             .for_segment(0, segment_reader)
@@ -1031,7 +1022,7 @@ mod tests {
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
         let segment = searcher.segment_reader(0);
-        let top_collector = TopDocs::with_limit(4).order_by_u64_field(SIZE);
+        let top_collector = TopDocs::with_limit(4).order_by_u64_field(size);
         let err = top_collector.for_segment(0, segment).err().unwrap();
         assert!(matches!(err, crate::TantivyError::SchemaError(_)));
         Ok(())
@@ -1048,7 +1039,7 @@ mod tests {
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
         let segment = searcher.segment_reader(0);
-        let top_collector = TopDocs::with_limit(4).order_by_fast_field::<i64>(SIZE);
+        let top_collector = TopDocs::with_limit(4).order_by_fast_field::<i64>(size);
         let err = top_collector.for_segment(0, segment).err().unwrap();
         assert!(
             matches!(err, crate::TantivyError::SchemaError(msg) if msg == "Field \"size\" is not a fast field.")

src/core/index.rs

@@ -19,7 +19,7 @@ use crate::error::{DataCorruption, TantivyError};
 use crate::indexer::index_writer::{MAX_NUM_THREAD, MEMORY_ARENA_NUM_BYTES_MIN};
 use crate::indexer::segment_updater::save_metas;
 use crate::reader::{IndexReader, IndexReaderBuilder};
-use crate::schema::{Field, FieldType, Schema};
+use crate::schema::{Cardinality, Field, FieldType, Schema};
 use crate::tokenizer::{TextAnalyzer, TokenizerManager};
 use crate::IndexWriter;
 
@@ -93,7 +93,7 @@ fn save_new_metas(
 /// let body_field = schema_builder.add_text_field("body", TEXT);
 /// let number_field = schema_builder.add_u64_field(
 ///     "number",
-///     NumericOptions::default().set_fast(),
+///     NumericOptions::default().set_fast(Cardinality::SingleValue),
 /// );
 ///
 /// let schema = schema_builder.build();
@@ -231,7 +231,7 @@ impl IndexBuilder {
     fn validate(&self) -> crate::Result<()> {
         if let Some(schema) = self.schema.as_ref() {
             if let Some(sort_by_field) = self.index_settings.sort_by_field.as_ref() {
-                let schema_field = schema.get_field(&sort_by_field.field).map_err(|_| {
+                let schema_field = schema.get_field(&sort_by_field.field).ok_or_else(|| {
                     TantivyError::InvalidArgument(format!(
                         "Field to sort index {} not found in schema",
                         sort_by_field.field
@@ -245,6 +245,12 @@ impl IndexBuilder {
                         sort_by_field.field
                     )));
                 }
+                if entry.field_type().fastfield_cardinality() != Some(Cardinality::SingleValue) {
+                    return Err(TantivyError::InvalidArgument(format!(
+                        "Only single value fast field Cardinality supported for sorting index {}",
+                        sort_by_field.field
+                    )));
+                }
             }
             Ok(())
         } else {