clarify tokenizer docs

* tokenizer option on text fastfield

allow to set tokenizer option on text fastfield (fixes #1901)
handle PreTokenized strings in fast field

* change visibility

* remove custom de/serialization

bitpacker/Cargo.toml

@@ -15,6 +15,7 @@ homepage = "https://github.com/quickwit-oss/tantivy"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+bitpacking = {version="0.8", default-features=false, features = ["bitpacker1x"]}
 
 [dev-dependencies]
 rand = "0.8"

bitpacker/src/bitpacker.rs

@@ -1,10 +1,14 @@
 use std::convert::TryInto;
 use std::io;
+use std::ops::{Range, RangeInclusive};
+
+use bitpacking::{BitPacker as ExternalBitPackerTrait, BitPacker1x};
 
 pub struct BitPacker {
     mini_buffer: u64,
     mini_buffer_written: usize,
 }
+
 impl Default for BitPacker {
     fn default() -> Self {
         BitPacker::new()
@@ -118,6 +122,125 @@ impl BitUnpacker {
         let val_shifted = val_unshifted_unmasked >> bit_shift;
         val_shifted & self.mask
     }
+
+    // Decodes the range of bitpacked `u32` values with idx
+    // in [start_idx, start_idx + output.len()).
+    //
+    // #Panics
+    //
+    // This methods panics if `num_bits` is > 32.
+    fn get_batch_u32s(&self, start_idx: u32, data: &[u8], output: &mut [u32]) {
+        assert!(
+            self.bit_width() <= 32,
+            "Bitwidth must be <= 32 to use this method."
+        );
+
+        let end_idx = start_idx + output.len() as u32;
+
+        let end_bit_read = end_idx * self.num_bits;
+        let end_byte_read = (end_bit_read + 7) / 8;
+        assert!(
+            end_byte_read as usize <= data.len(),
+            "Requested index is out of bounds."
+        );
+
+        // Simple slow implementation of get_batch_u32s, to deal with our ramps.
+        let get_batch_ramp = |start_idx: u32, output: &mut [u32]| {
+            for (out, idx) in output.iter_mut().zip(start_idx..) {
+                *out = self.get(idx, data) as u32;
+            }
+        };
+
+        // We use an unrolled routine to decode 32 values at once.
+        // We therefore decompose our range of values to decode into three ranges:
+        // - Entrance ramp: [start_idx, fast_track_start) (up to 31 values)
+        // - Highway: [fast_track_start, fast_track_end) (a length multiple of 32s)
+        // - Exit ramp: [fast_track_end, start_idx + output.len()) (up to 31 values)
+
+        // We want the start of the fast track to start align with bytes.
+        // A sufficient condition is to start with an idx that is a multiple of 8,
+        // so highway start is the closest multiple of 8 that is >= start_idx.
+        let entrance_ramp_len = 8 - (start_idx % 8) % 8;
+
+        let highway_start: u32 = start_idx + entrance_ramp_len;
+
+        if highway_start + BitPacker1x::BLOCK_LEN as u32 > end_idx {
+            // We don't have enough values to have even a single block of highway.
+            // Let's just supply the values the simple way.
+            get_batch_ramp(start_idx, output);
+            return;
+        }
+
+        let num_blocks: u32 = (end_idx - highway_start) / BitPacker1x::BLOCK_LEN as u32;
+
+        // Entrance ramp
+        get_batch_ramp(start_idx, &mut output[..entrance_ramp_len as usize]);
+
+        // Highway
+        let mut offset = (highway_start * self.num_bits) as usize / 8;
+        let mut output_cursor = (highway_start - start_idx) as usize;
+        for _ in 0..num_blocks {
+            offset += BitPacker1x.decompress(
+                &data[offset..],
+                &mut output[output_cursor..],
+                self.num_bits as u8,
+            );
+            output_cursor += 32;
+        }
+
+        // Exit ramp
+        let highway_end = highway_start + num_blocks * BitPacker1x::BLOCK_LEN as u32;
+        get_batch_ramp(highway_end, &mut output[output_cursor..]);
+    }
+
+    pub fn get_ids_for_value_range(
+        &self,
+        range: RangeInclusive<u64>,
+        id_range: Range<u32>,
+        data: &[u8],
+        positions: &mut Vec<u32>,
+    ) {
+        if self.bit_width() > 32 {
+            self.get_ids_for_value_range_slow(range, id_range, data, positions)
+        } else {
+            if *range.start() > u32::MAX as u64 {
+                positions.clear();
+                return;
+            }
+            let range_u32 = (*range.start() as u32)..=(*range.end()).min(u32::MAX as u64) as u32;
+            self.get_ids_for_value_range_fast(range_u32, id_range, data, positions)
+        }
+    }
+
+    fn get_ids_for_value_range_slow(
+        &self,
+        range: RangeInclusive<u64>,
+        id_range: Range<u32>,
+        data: &[u8],
+        positions: &mut Vec<u32>,
+    ) {
+        positions.clear();
+        for i in id_range {
+            // If we cared we could make this branchless, but the slow implementation should rarely
+            // kick in.
+            let val = self.get(i, data);
+            if range.contains(&val) {
+                positions.push(i);
+            }
+        }
+    }
+
+    fn get_ids_for_value_range_fast(
+        &self,
+        value_range: RangeInclusive<u32>,
+        id_range: Range<u32>,
+        data: &[u8],
+        positions: &mut Vec<u32>,
+    ) {
+        positions.resize(id_range.len(), 0u32);
+        self.get_batch_u32s(id_range.start, data, positions);
+        crate::filter_vec::filter_vec_in_place(value_range, id_range.start, positions)
+    }
 }
 
 #[cfg(test)]
@@ -200,4 +323,58 @@ mod test {
             test_bitpacker_aux(num_bits, &vals);
         }
     }
+
+    #[test]
+    #[should_panic]
+    fn test_get_batch_panics_over_32_bits() {
+        let bitunpacker = BitUnpacker::new(33);
+        let mut output: [u32; 1] = [0u32];
+        bitunpacker.get_batch_u32s(0, &[0, 0, 0, 0, 0, 0, 0, 0], &mut output[..]);
+    }
+
+    #[test]
+    fn test_get_batch_limit() {
+        let bitunpacker = BitUnpacker::new(1);
+        let mut output: [u32; 3] = [0u32, 0u32, 0u32];
+        bitunpacker.get_batch_u32s(8 * 4 - 3, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_get_batch_panics_when_off_scope() {
+        let bitunpacker = BitUnpacker::new(1);
+        let mut output: [u32; 3] = [0u32, 0u32, 0u32];
+        // We are missing exactly one bit.
+        bitunpacker.get_batch_u32s(8 * 4 - 2, &[0u8, 0u8, 0u8, 0u8], &mut output[..]);
+    }
+
+    proptest::proptest! {
+        #[test]
+        fn test_get_batch_u32s_proptest(num_bits in 0u8..=32u8) {
+            let mask =
+                if num_bits == 32u8 {
+                    u32::MAX
+                } else {
+                    (1u32 << num_bits) - 1
+                };
+            let mut buffer: Vec<u8> = Vec::new();
+            let mut bitpacker = BitPacker::new();
+            for val in 0..100 {
+                bitpacker.write(val & mask as u64, num_bits, &mut buffer).unwrap();
+            }
+            bitpacker.flush(&mut buffer).unwrap();
+            let bitunpacker = BitUnpacker::new(num_bits);
+            let mut output: Vec<u32> = Vec::new();
+            for len in [0, 1, 2, 32, 33, 34, 64] {
+                for start_idx in 0u32..32u32 {
+                    output.resize(len as usize, 0);
+                    bitunpacker.get_batch_u32s(start_idx, &buffer, &mut output);
+                    for i in 0..len {
+                        let expected = (start_idx + i as u32) & mask;
+                        assert_eq!(output[i], expected);
+                    }
+                }
+            }
+        }
+    }
 }

bitpacker/src/filter_vec/avx2.rs

@@ -0,0 +1,365 @@
+//! SIMD filtering of a vector as described in the following blog post.
+//! https://quickwit.io/blog/filtering%20a%20vector%20with%20simd%20instructions%20avx-2%20and%20avx-512
+use std::arch::x86_64::{
+    __m256i as DataType, _mm256_add_epi32 as op_add, _mm256_cmpgt_epi32 as op_greater,
+    _mm256_lddqu_si256 as load_unaligned, _mm256_or_si256 as op_or, _mm256_set1_epi32 as set1,
+    _mm256_storeu_si256 as store_unaligned, _mm256_xor_si256 as op_xor, *,
+};
+use std::ops::RangeInclusive;
+
+const NUM_LANES: usize = 8;
+
+const HIGHEST_BIT: u32 = 1 << 31;
+
+#[inline]
+fn u32_to_i32(val: u32) -> i32 {
+    (val ^ HIGHEST_BIT) as i32
+}
+
+#[inline]
+unsafe fn u32_to_i32_avx2(vals_u32x8s: DataType) -> DataType {
+    const HIGHEST_BIT_MASK: DataType = from_u32x8([HIGHEST_BIT; NUM_LANES]);
+    op_xor(vals_u32x8s, HIGHEST_BIT_MASK)
+}
+
+pub fn filter_vec_in_place(range: RangeInclusive<u32>, offset: u32, output: &mut Vec<u32>) {
+    // We use a monotonic mapping from u32 to i32 to make the comparison possible in AVX2.
+    let range_i32: RangeInclusive<i32> = u32_to_i32(*range.start())..=u32_to_i32(*range.end());
+    let num_words = output.len() / NUM_LANES;
+    let mut output_len = unsafe {
+        filter_vec_avx2_aux(
+            output.as_ptr() as *const __m256i,
+            range_i32,
+            output.as_mut_ptr(),
+            offset,
+            num_words,
+        )
+    };
+    let reminder_start = num_words * NUM_LANES;
+    for i in reminder_start..output.len() {
+        let val = output[i];
+        output[output_len] = offset + i as u32;
+        output_len += if range.contains(&val) { 1 } else { 0 };
+    }
+    output.truncate(output_len);
+}
+
+#[target_feature(enable = "avx2")]
+unsafe fn filter_vec_avx2_aux(
+    mut input: *const __m256i,
+    range: RangeInclusive<i32>,
+    output: *mut u32,
+    offset: u32,
+    num_words: usize,
+) -> usize {
+    let mut output_tail = output;
+    let range_simd = set1(*range.start())..=set1(*range.end());
+    let mut ids = from_u32x8([
+        offset,
+        offset + 1,
+        offset + 2,
+        offset + 3,
+        offset + 4,
+        offset + 5,
+        offset + 6,
+        offset + 7,
+    ]);
+    const SHIFT: __m256i = from_u32x8([NUM_LANES as u32; NUM_LANES]);
+    for _ in 0..num_words {
+        let word = load_unaligned(input);
+        let word = u32_to_i32_avx2(word);
+        let keeper_bitset = compute_filter_bitset(word, range_simd.clone());
+        let added_len = keeper_bitset.count_ones();
+        let filtered_doc_ids = compact(ids, keeper_bitset);
+        store_unaligned(output_tail as *mut __m256i, filtered_doc_ids);
+        output_tail = output_tail.offset(added_len as isize);
+        ids = op_add(ids, SHIFT);
+        input = input.offset(1);
+    }
+    output_tail.offset_from(output) as usize
+}
+
+#[inline]
+#[target_feature(enable = "avx2")]
+unsafe fn compact(data: DataType, mask: u8) -> DataType {
+    let vperm_mask = MASK_TO_PERMUTATION[mask as usize];
+    _mm256_permutevar8x32_epi32(data, vperm_mask)
+}
+
+#[inline]
+#[target_feature(enable = "avx2")]
+unsafe fn compute_filter_bitset(val: __m256i, range: std::ops::RangeInclusive<__m256i>) -> u8 {
+    let too_low = op_greater(*range.start(), val);
+    let too_high = op_greater(val, *range.end());
+    let inside = op_or(too_low, too_high);
+    255 - std::arch::x86_64::_mm256_movemask_ps(std::mem::transmute::<DataType, __m256>(inside))
+        as u8
+}
+
+union U8x32 {
+    vector: DataType,
+    vals: [u32; NUM_LANES],
+}
+
+const fn from_u32x8(vals: [u32; NUM_LANES]) -> DataType {
+    unsafe { U8x32 { vals }.vector }
+}
+
+const MASK_TO_PERMUTATION: [DataType; 256] = [
+    from_u32x8([0, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 0, 0, 0, 0, 0]),
+    from_u32x8([3, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 3, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 0, 0, 0, 0]),
+    from_u32x8([4, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 4, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 0, 0, 0, 0]),
+    from_u32x8([3, 4, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 0, 0, 0, 0]),
+    from_u32x8([2, 3, 4, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 0, 0, 0]),
+    from_u32x8([5, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 5, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 5, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 5, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 5, 0, 0, 0, 0]),
+    from_u32x8([3, 5, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 5, 0, 0, 0, 0]),
+    from_u32x8([2, 3, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 5, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 5, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 5, 0, 0, 0]),
+    from_u32x8([4, 5, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([2, 4, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 5, 0, 0, 0]),
+    from_u32x8([3, 4, 5, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 5, 0, 0, 0]),
+    from_u32x8([2, 3, 4, 5, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 5, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 5, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 5, 0, 0]),
+    from_u32x8([6, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 6, 0, 0, 0, 0]),
+    from_u32x8([3, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 6, 0, 0, 0, 0]),
+    from_u32x8([2, 3, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 6, 0, 0, 0]),
+    from_u32x8([4, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([2, 4, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 6, 0, 0, 0]),
+    from_u32x8([3, 4, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 6, 0, 0, 0]),
+    from_u32x8([2, 3, 4, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 6, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 6, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 6, 0, 0]),
+    from_u32x8([5, 6, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 5, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 5, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([2, 5, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 5, 6, 0, 0, 0]),
+    from_u32x8([3, 5, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 5, 6, 0, 0, 0]),
+    from_u32x8([2, 3, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 5, 6, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 5, 6, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 5, 6, 0, 0]),
+    from_u32x8([4, 5, 6, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([2, 4, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 5, 6, 0, 0]),
+    from_u32x8([3, 4, 5, 6, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 5, 6, 0, 0]),
+    from_u32x8([2, 3, 4, 5, 6, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 5, 6, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 5, 6, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 5, 6, 0]),
+    from_u32x8([7, 0, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([2, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 7, 0, 0, 0, 0]),
+    from_u32x8([3, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 7, 0, 0, 0, 0]),
+    from_u32x8([2, 3, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 7, 0, 0, 0]),
+    from_u32x8([4, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([2, 4, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 7, 0, 0, 0]),
+    from_u32x8([3, 4, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 7, 0, 0, 0]),
+    from_u32x8([2, 3, 4, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 7, 0, 0]),
+    from_u32x8([5, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 5, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 5, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([2, 5, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 5, 7, 0, 0, 0]),
+    from_u32x8([3, 5, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 5, 7, 0, 0, 0]),
+    from_u32x8([2, 3, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 5, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 5, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 5, 7, 0, 0]),
+    from_u32x8([4, 5, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([2, 4, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 5, 7, 0, 0]),
+    from_u32x8([3, 4, 5, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 5, 7, 0, 0]),
+    from_u32x8([2, 3, 4, 5, 7, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 5, 7, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 5, 7, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 5, 7, 0]),
+    from_u32x8([6, 7, 0, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([1, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([2, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 2, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 6, 7, 0, 0, 0]),
+    from_u32x8([3, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 3, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 6, 7, 0, 0, 0]),
+    from_u32x8([2, 3, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 3, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 6, 7, 0, 0]),
+    from_u32x8([4, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 4, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([2, 4, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 6, 7, 0, 0]),
+    from_u32x8([3, 4, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 3, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 6, 7, 0, 0]),
+    from_u32x8([2, 3, 4, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 6, 7, 0, 0]),
+    from_u32x8([1, 2, 3, 4, 6, 7, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 6, 7, 0]),
+    from_u32x8([5, 6, 7, 0, 0, 0, 0, 0]),
+    from_u32x8([0, 5, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([1, 5, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 1, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([2, 5, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 2, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 2, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 2, 5, 6, 7, 0, 0]),
+    from_u32x8([3, 5, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 3, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 3, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 3, 5, 6, 7, 0, 0]),
+    from_u32x8([2, 3, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 2, 3, 5, 6, 7, 0, 0]),
+    from_u32x8([1, 2, 3, 5, 6, 7, 0, 0]),
+    from_u32x8([0, 1, 2, 3, 5, 6, 7, 0]),
+    from_u32x8([4, 5, 6, 7, 0, 0, 0, 0]),
+    from_u32x8([0, 4, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([1, 4, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 1, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([2, 4, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 2, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([1, 2, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([0, 1, 2, 4, 5, 6, 7, 0]),
+    from_u32x8([3, 4, 5, 6, 7, 0, 0, 0]),
+    from_u32x8([0, 3, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([1, 3, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([0, 1, 3, 4, 5, 6, 7, 0]),
+    from_u32x8([2, 3, 4, 5, 6, 7, 0, 0]),
+    from_u32x8([0, 2, 3, 4, 5, 6, 7, 0]),
+    from_u32x8([1, 2, 3, 4, 5, 6, 7, 0]),
+    from_u32x8([0, 1, 2, 3, 4, 5, 6, 7]),
+];

bitpacker/src/filter_vec/mod.rs

@@ -0,0 +1,165 @@
+use std::ops::RangeInclusive;
+
+#[cfg(any(target_arch = "x86_64"))]
+mod avx2;
+
+mod scalar;
+
+#[derive(Clone, Copy, Eq, PartialEq, Debug)]
+#[repr(u8)]
+enum FilterImplPerInstructionSet {
+    #[cfg(target_arch = "x86_64")]
+    AVX2 = 0u8,
+    Scalar = 1u8,
+}
+
+impl FilterImplPerInstructionSet {
+    #[inline]
+    pub fn is_available(&self) -> bool {
+        match *self {
+            #[cfg(target_arch = "x86_64")]
+            FilterImplPerInstructionSet::AVX2 => is_x86_feature_detected!("avx2"),
+            FilterImplPerInstructionSet::Scalar => true,
+        }
+    }
+}
+
+// List of available implementation in preferred order.
+#[cfg(target_arch = "x86_64")]
+const IMPLS: [FilterImplPerInstructionSet; 2] = [
+    FilterImplPerInstructionSet::AVX2,
+    FilterImplPerInstructionSet::Scalar,
+];
+
+#[cfg(not(target_arch = "x86_64"))]
+const IMPLS: [FilterImplPerInstructionSet; 1] = [FilterImplPerInstructionSet::Scalar];
+
+impl FilterImplPerInstructionSet {
+    #[allow(unused_variables)]
+    #[inline]
+    fn from(code: u8) -> FilterImplPerInstructionSet {
+        #[cfg(target_arch = "x86_64")]
+        if code == FilterImplPerInstructionSet::AVX2 as u8 {
+            return FilterImplPerInstructionSet::AVX2;
+        }
+        FilterImplPerInstructionSet::Scalar
+    }
+
+    #[inline]
+    fn filter_vec_in_place(self, range: RangeInclusive<u32>, offset: u32, output: &mut Vec<u32>) {
+        match self {
+            #[cfg(target_arch = "x86_64")]
+            FilterImplPerInstructionSet::AVX2 => avx2::filter_vec_in_place(range, offset, output),
+            FilterImplPerInstructionSet::Scalar => {
+                scalar::filter_vec_in_place(range, offset, output)
+            }
+        }
+    }
+}
+
+#[inline]
+fn get_best_available_instruction_set() -> FilterImplPerInstructionSet {
+    use std::sync::atomic::{AtomicU8, Ordering};
+    static INSTRUCTION_SET_BYTE: AtomicU8 = AtomicU8::new(u8::MAX);
+    let instruction_set_byte: u8 = INSTRUCTION_SET_BYTE.load(Ordering::Relaxed);
+    if instruction_set_byte == u8::MAX {
+        // Let's initialize the instruction set and cache it.
+        let instruction_set = IMPLS
+            .into_iter()
+            .find(FilterImplPerInstructionSet::is_available)
+            .unwrap();
+        INSTRUCTION_SET_BYTE.store(instruction_set as u8, Ordering::Relaxed);
+        return instruction_set;
+    }
+    FilterImplPerInstructionSet::from(instruction_set_byte)
+}
+
+pub fn filter_vec_in_place(range: RangeInclusive<u32>, offset: u32, output: &mut Vec<u32>) {
+    get_best_available_instruction_set().filter_vec_in_place(range, offset, output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_best_available_instruction_set() {
+        // This does not test much unfortunately.
+        // We just make sure the function returns without crashing and returns the same result.
+        let instruction_set = get_best_available_instruction_set();
+        assert_eq!(get_best_available_instruction_set(), instruction_set);
+    }
+
+    #[cfg(target_arch = "x86_64")]
+    #[test]
+    fn test_instruction_set_to_code_from_code() {
+        for instruction_set in [
+            FilterImplPerInstructionSet::AVX2,
+            FilterImplPerInstructionSet::Scalar,
+        ] {
+            let code = instruction_set as u8;
+            assert_eq!(instruction_set, FilterImplPerInstructionSet::from(code));
+        }
+    }
+
+    fn test_filter_impl_empty_aux(filter_impl: FilterImplPerInstructionSet) {
+        let mut output = vec![];
+        filter_impl.filter_vec_in_place(0..=u32::MAX, 0, &mut output);
+        assert_eq!(&output, &[]);
+    }
+
+    fn test_filter_impl_simple_aux(filter_impl: FilterImplPerInstructionSet) {
+        let mut output = vec![3, 2, 1, 5, 11, 2, 5, 10, 2];
+        filter_impl.filter_vec_in_place(3..=10, 0, &mut output);
+        assert_eq!(&output, &[0, 3, 6, 7]);
+    }
+
+    fn test_filter_impl_simple_aux_shifted(filter_impl: FilterImplPerInstructionSet) {
+        let mut output = vec![3, 2, 1, 5, 11, 2, 5, 10, 2];
+        filter_impl.filter_vec_in_place(3..=10, 10, &mut output);
+        assert_eq!(&output, &[10, 13, 16, 17]);
+    }
+
+    fn test_filter_impl_simple_outside_i32_range(filter_impl: FilterImplPerInstructionSet) {
+        let mut output = vec![u32::MAX, i32::MAX as u32 + 1, 0, 1, 3, 1, 1, 1, 1];
+        filter_impl.filter_vec_in_place(1..=i32::MAX as u32 + 1u32, 0, &mut output);
+        assert_eq!(&output, &[1, 3, 4, 5, 6, 7, 8]);
+    }
+
+    fn test_filter_impl_test_suite(filter_impl: FilterImplPerInstructionSet) {
+        test_filter_impl_empty_aux(filter_impl);
+        test_filter_impl_simple_aux(filter_impl);
+        test_filter_impl_simple_aux_shifted(filter_impl);
+        test_filter_impl_simple_outside_i32_range(filter_impl);
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn test_filter_implementation_avx2() {
+        if FilterImplPerInstructionSet::AVX2.is_available() {
+            test_filter_impl_test_suite(FilterImplPerInstructionSet::AVX2);
+        }
+    }
+
+    #[test]
+    fn test_filter_implementation_scalar() {
+        test_filter_impl_test_suite(FilterImplPerInstructionSet::Scalar);
+    }
+
+    #[cfg(target_arch = "x86_64")]
+    proptest::proptest! {
+        #[test]
+        fn test_filter_compare_scalar_and_avx2_impl_proptest(
+            start in proptest::prelude::any::<u32>(),
+            end in proptest::prelude::any::<u32>(),
+            offset in 0u32..2u32,
+            mut vals in proptest::collection::vec(0..u32::MAX, 0..30)) {
+            if FilterImplPerInstructionSet::AVX2.is_available() {
+                let mut vals_clone = vals.clone();
+                FilterImplPerInstructionSet::AVX2.filter_vec_in_place(start..=end, offset, &mut vals);
+                FilterImplPerInstructionSet::Scalar.filter_vec_in_place(start..=end, offset, &mut vals_clone);
+                assert_eq!(&vals, &vals_clone);
+            }
+       }
+    }
+}

bitpacker/src/filter_vec/scalar.rs

@@ -0,0 +1,13 @@
+use std::ops::RangeInclusive;
+
+pub fn filter_vec_in_place(range: RangeInclusive<u32>, offset: u32, output: &mut Vec<u32>) {
+    // We restrict the accepted boundary, because unsigned integers & SIMD don't
+    // play well.
+    let mut output_cursor = 0;
+    for i in 0..output.len() {
+        let val = output[i];
+        output[output_cursor] = offset + i as u32;
+        output_cursor += if range.contains(&val) { 1 } else { 0 };
+    }
+    output.truncate(output_cursor);
+}

bitpacker/src/lib.rs

@@ -1,5 +1,6 @@
 mod bitpacker;
 mod blocked_bitpacker;
+mod filter_vec;
 
 use std::cmp::Ordering;
 

columnar/src/column/dictionary_encoded.rs

@@ -1,6 +1,6 @@
-use std::io;
 use std::ops::Deref;
 use std::sync::Arc;
+use std::{fmt, io};
 
 use sstable::{Dictionary, VoidSSTable};
 
@@ -21,6 +21,14 @@ pub struct BytesColumn {
     pub(crate) term_ord_column: Column<u64>,
 }
 
+impl fmt::Debug for BytesColumn {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BytesColumn")
+            .field("term_ord_column", &self.term_ord_column)
+            .finish()
+    }
+}
+
 impl BytesColumn {
     /// Fills the given `output` buffer with the term associated to the ordinal `ord`.
     ///
@@ -56,6 +64,12 @@ impl BytesColumn {
 #[derive(Clone)]
 pub struct StrColumn(BytesColumn);
 
+impl fmt::Debug for StrColumn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.term_ord_column)
+    }
+}
+
 impl From<StrColumn> for BytesColumn {
     fn from(str_column: StrColumn) -> BytesColumn {
         str_column.0

columnar/src/column/mod.rs

@@ -1,7 +1,7 @@
 mod dictionary_encoded;
 mod serialize;
 
-use std::fmt::Debug;
+use std::fmt::{self, Debug};
 use std::io::Write;
 use std::ops::{Deref, Range, RangeInclusive};
 use std::sync::Arc;
@@ -24,6 +24,16 @@ pub struct Column<T = u64> {
     pub values: Arc<dyn ColumnValues<T>>,
 }
 
+impl<T: Debug + PartialOrd + Send + Sync + Copy + 'static> Debug for Column<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let num_docs = self.num_docs();
+        let entries = (0..num_docs)
+            .map(|i| (i, self.values_for_doc(i).collect::<Vec<_>>()))
+            .filter(|(_, vals)| !vals.is_empty());
+        f.debug_map().entries(entries).finish()
+    }
+}
+
 impl<T: PartialOrd + Default> Column<T> {
     pub fn build_empty_column(num_docs: u32) -> Column<T> {
         Column {

columnar/src/column_index/mod.rs

@@ -12,7 +12,7 @@ pub use serialize::{open_column_index, serialize_column_index, SerializableColum
 use crate::column_index::multivalued_index::MultiValueIndex;
 use crate::{Cardinality, DocId, RowId};
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum ColumnIndex {
     Empty {
         num_docs: u32,
@@ -37,11 +37,15 @@ impl From<MultiValueIndex> for ColumnIndex {
 }
 
 impl ColumnIndex {
+    // Returns the cardinality of the column index.
+    //
+    // By convention, if the column contains no docs, we consider that it is
+    // full.
     #[inline]
     pub fn get_cardinality(&self) -> Cardinality {
         match self {
+            ColumnIndex::Empty { num_docs: 0 } | ColumnIndex::Full => Cardinality::Full,
             ColumnIndex::Empty { .. } => Cardinality::Optional,
-            ColumnIndex::Full => Cardinality::Full,
             ColumnIndex::Optional(_) => Cardinality::Optional,
             ColumnIndex::Multivalued(_) => Cardinality::Multivalued,
         }
@@ -152,3 +156,21 @@ impl ColumnIndex {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{Cardinality, ColumnIndex};
+
+    #[test]
+    fn test_column_index_get_cardinality() {
+        assert_eq!(
+            ColumnIndex::Empty { num_docs: 0 }.get_cardinality(),
+            Cardinality::Full
+        );
+        assert_eq!(ColumnIndex::Full.get_cardinality(), Cardinality::Full);
+        assert_eq!(
+            ColumnIndex::Empty { num_docs: 1 }.get_cardinality(),
+            Cardinality::Optional
+        );
+    }
+}

columnar/src/column_index/multivalued_index.rs

@@ -35,6 +35,14 @@ pub struct MultiValueIndex {
     pub start_index_column: Arc<dyn crate::ColumnValues<RowId>>,
 }
 
+impl std::fmt::Debug for MultiValueIndex {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("MultiValuedIndex")
+            .field("num_rows", &self.start_index_column.num_vals())
+            .finish_non_exhaustive()
+    }
+}
+
 impl From<Arc<dyn ColumnValues<RowId>>> for MultiValueIndex {
     fn from(start_index_column: Arc<dyn ColumnValues<RowId>>) -> Self {
         MultiValueIndex { start_index_column }

columnar/src/column_index/optional_index/mod.rs

@@ -88,6 +88,15 @@ pub struct OptionalIndex {
     block_metas: Arc<[BlockMeta]>,
 }
 
+impl std::fmt::Debug for OptionalIndex {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OptionalIndex")
+            .field("num_rows", &self.num_rows)
+            .field("num_non_null_rows", &self.num_non_null_rows)
+            .finish_non_exhaustive()
+    }
+}
+
 /// 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

columnar/src/column_values/mod.rs

@@ -94,7 +94,6 @@ pub trait ColumnValues<T: PartialOrd = u64>: Send + Sync {
     /// Get the row ids of values which are in the provided value range.
     ///
     /// Note that position == docid for single value fast fields
-    #[inline(always)]
     fn get_row_ids_for_value_range(
         &self,
         value_range: RangeInclusive<T>,

columnar/src/column_values/u128_based/compact_space/build_compact_space.rs

@@ -10,7 +10,7 @@ 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() {
+    for (first, second) in values_sorted.iter().copied().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;
@@ -65,12 +65,12 @@ pub fn get_compact_space(
         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);
+    // Replace after stabilization of https://github.com/rust-lang/rust/issues/62924
+    let min_value = values_deduped_sorted.iter().next().copied().unwrap_or(0);
+    let max_value = values_deduped_sorted.iter().last().copied().unwrap_or(0);
+
+    let mut blanks: BinaryHeap<BlankRange> = get_blanks(values_deduped_sorted);
 
     // +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);
@@ -84,6 +84,7 @@ pub fn get_compact_space(
     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
@@ -93,6 +94,7 @@ pub fn get_compact_space(
         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;
         }
@@ -100,7 +102,16 @@ pub fn get_compact_space(
         // 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 {
+
+        // We want to end up with a compact space that fits into 32 bits.
+        // In order to deal with pathological cases, we force the algorithm to keep
+        // refining the compact space the amplitude bits is lower than 32.
+        //
+        // The worst case scenario happens for a large number of u128s regularly
+        // spread over the full u128 space.
+        //
+        // This change will force the algorithm to degenerate into dictionary encoding.
+        if amplitude_bits <= 32 && 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
             //
@@ -115,6 +126,8 @@ pub fn get_compact_space(
         compact_space_builder.add_blanks(blank_collector.drain().map(|blank| blank.blank_range()));
     }
 
+    assert!(amplitude_bits <= 32);
+
     // 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
@@ -199,7 +212,7 @@ impl CompactSpaceBuilder {
             covered_space.push(0..=0); // empty data case
         };
 
-        let mut compact_start: u64 = 1; // 0 is reserved for `null`
+        let mut compact_start: u32 = 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 {
@@ -218,6 +231,7 @@ impl CompactSpaceBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::column_values::u128_based::compact_space::COST_PER_BLANK_IN_BITS;
 
     #[test]
     fn test_binary_heap_pop_order() {
@@ -228,4 +242,11 @@ mod tests {
         assert_eq!(blanks.pop().unwrap().blank_size(), 101);
         assert_eq!(blanks.pop().unwrap().blank_size(), 11);
     }
+
+    #[test]
+    fn test_worst_case_scenario() {
+        let vals: BTreeSet<u128> = (0..8).map(|i| i * ((1u128 << 34) / 8)).collect();
+        let compact_space = get_compact_space(&vals, vals.len() as u32, COST_PER_BLANK_IN_BITS);
+        assert!(compact_space.amplitude_compact_space() < u32::MAX as u128);
+    }
 }

columnar/src/column_values/u128_based/compact_space/mod.rs

@@ -42,15 +42,15 @@ pub struct CompactSpace {
 #[derive(Debug, Clone, Eq, PartialEq)]
 struct RangeMapping {
     value_range: RangeInclusive<u128>,
-    compact_start: u64,
+    compact_start: u32,
 }
 impl RangeMapping {
-    fn range_length(&self) -> u64 {
-        (self.value_range.end() - self.value_range.start()) as u64 + 1
+    fn range_length(&self) -> u32 {
+        (self.value_range.end() - self.value_range.start()) as u32 + 1
     }
 
     // The last value of the compact space in this range
-    fn compact_end(&self) -> u64 {
+    fn compact_end(&self) -> u32 {
         self.compact_start + self.range_length() - 1
     }
 }
@@ -81,7 +81,7 @@ impl BinarySerializable for CompactSpace {
         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`
+        let mut compact_start = 1u32; // 0 is reserved for `null`
         for _ in 0..num_ranges {
             let blank_delta_start = VIntU128::deserialize(reader)?.0;
             value += blank_delta_start;
@@ -122,10 +122,10 @@ impl CompactSpace {
 
     /// 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> {
+    fn u128_to_compact(&self, value: u128) -> Result<u32, usize> {
         self.ranges_mapping
             .binary_search_by(|probe| {
-                let value_range = &probe.value_range;
+                let value_range: &RangeInclusive<u128> = &probe.value_range;
                 if value < *value_range.start() {
                     Ordering::Greater
                 } else if value > *value_range.end() {
@@ -136,13 +136,13 @@ impl CompactSpace {
             })
             .map(|pos| {
                 let range_mapping = &self.ranges_mapping[pos];
-                let pos_in_range = (value - range_mapping.value_range.start()) as u64;
+                let pos_in_range: u32 = (value - range_mapping.value_range.start()) as u32;
                 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 {
+    /// Unpacks a value from compact space u32 to u128 space
+    fn compact_to_u128(&self, compact: u32) -> u128 {
         let pos = self
             .ranges_mapping
             .binary_search_by_key(&compact, |range_mapping| range_mapping.compact_start)
@@ -178,11 +178,15 @@ 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>) -> Self {
         let mut values_sorted = BTreeSet::new();
+        // Total number of values, with their redundancy.
         let mut total_num_values = 0u32;
         for val in iter {
             total_num_values += 1u32;
             values_sorted.insert(val);
         }
+        let min_value = *values_sorted.iter().next().unwrap_or(&0);
+        let max_value = *values_sorted.iter().last().unwrap_or(&0);
+
         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();
@@ -193,13 +197,12 @@ impl CompactSpaceCompressor {
         );
 
         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
+            amplitude_compact_space as u32
         );
         CompactSpaceCompressor {
             params: IPCodecParams {
@@ -240,7 +243,7 @@ impl CompactSpaceCompressor {
                         "Could not convert value to compact_space. This is a bug.",
                     )
                 })?;
-            bitpacker.write(compact, self.params.num_bits, write)?;
+            bitpacker.write(compact as u64, self.params.num_bits, write)?;
         }
         bitpacker.close(write)?;
         self.write_footer(write)?;
@@ -314,48 +317,6 @@ impl ColumnValues<u128> for CompactSpaceDecompressor {
 
     #[inline]
     fn get_row_ids_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>,
@@ -395,44 +356,42 @@ impl CompactSpaceDecompressor {
             range_mapping.compact_end()
         });
 
-        let range = compact_from..=compact_to;
+        let value_range = compact_from..=compact_to;
+        self.get_positions_for_compact_value_range(value_range, position_range, positions);
+    }
+}
 
-        let scan_num_docs = position_range.end - position_range.start;
+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 step_size = 4;
-        let cutoff = position_range.start + scan_num_docs - scan_num_docs % step_size;
+        let data_footer = &data_slice[data_slice.len() - footer_len as usize..];
+        let params = IPCodecParams::deserialize(&mut &data_footer[..])?;
+        let decompressor = CompactSpaceDecompressor { data, params };
 
-        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);
-        }
+        Ok(decompressor)
+    }
 
-        // handle rest
-        for idx in cutoff..position_range.end {
-            push_if_in_range(idx, get_val(idx));
-        }
+    /// 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<u32, usize> {
+        self.params.compact_space.u128_to_compact(value)
+    }
+
+    fn compact_to_u128(&self, compact: u32) -> u128 {
+        self.params.compact_space.compact_to_u128(compact)
     }
 
     #[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))
+    fn iter_compact(&self) -> impl Iterator<Item = u32> + '_ {
+        (0..self.params.num_vals)
+            .map(move |idx| self.params.bit_unpacker.get(idx, &self.data) as u32)
     }
 
     #[inline]
@@ -445,7 +404,7 @@ impl CompactSpaceDecompressor {
 
     #[inline]
     pub fn get(&self, idx: u32) -> u128 {
-        let compact = self.params.bit_unpacker.get(idx, &self.data);
+        let compact = self.params.bit_unpacker.get(idx, &self.data) as u32;
         self.compact_to_u128(compact)
     }
 
@@ -456,6 +415,20 @@ impl CompactSpaceDecompressor {
     pub fn max_value(&self) -> u128 {
         self.params.max_value
     }
+
+    fn get_positions_for_compact_value_range(
+        &self,
+        value_range: RangeInclusive<u32>,
+        position_range: Range<u32>,
+        positions: &mut Vec<u32>,
+    ) {
+        self.params.bit_unpacker.get_ids_for_value_range(
+            *value_range.start() as u64..=*value_range.end() as u64,
+            position_range,
+            &self.data,
+            positions,
+        );
+    }
 }
 
 #[cfg(test)]
@@ -469,12 +442,12 @@ mod tests {
 
     #[test]
     fn compact_space_test() {
-        let ips = &[
+        let ips: BTreeSet<u128> = [
             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 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());
@@ -497,8 +470,8 @@ mod tests {
         );
 
         for ip in ips {
-            let compact = compact_space.u128_to_compact(*ip).unwrap();
-            assert_eq!(compact_space.compact_to_u128(compact), *ip);
+            let compact = compact_space.u128_to_compact(ip).unwrap();
+            assert_eq!(compact_space.compact_to_u128(compact), ip);
         }
     }
 
@@ -524,7 +497,7 @@ mod tests {
                     .map(|pos| pos as u32)
                     .collect::<Vec<_>>();
                 let mut positions = Vec::new();
-                decompressor.get_positions_for_value_range(
+                decompressor.get_row_ids_for_value_range(
                     range,
                     0..decompressor.num_vals(),
                     &mut positions,
@@ -569,7 +542,7 @@ mod tests {
             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);
+            decomp.get_row_ids_for_value_range(val..=val, pos..pos + 1, &mut positions);
             assert_eq!(positions, vec![pos]);
         }
 

columnar/src/column_values/u64_based/bitpacked.rs

@@ -1,4 +1,6 @@
 use std::io::{self, Write};
+use std::num::NonZeroU64;
+use std::ops::{Range, RangeInclusive};
 
 use common::{BinarySerializable, OwnedBytes};
 use fastdivide::DividerU64;
@@ -16,6 +18,46 @@ pub struct BitpackedReader {
     stats: ColumnStats,
 }
 
+#[inline(always)]
+const fn div_ceil(n: u64, q: NonZeroU64) -> u64 {
+    // copied from unstable rust standard library.
+    let d = n / q.get();
+    let r = n % q.get();
+    if r > 0 {
+        d + 1
+    } else {
+        d
+    }
+}
+
+// The bitpacked codec applies a linear transformation `f` over data that are bitpacked.
+// f is defined by:
+// f: bitpacked -> stats.min_value + stats.gcd * bitpacked
+//
+// In order to run range queries, we invert the transformation.
+// `transform_range_before_linear_transformation` returns the range of values
+// [min_bipacked_value..max_bitpacked_value] such that
+// f(bitpacked) ∈ [min_value, max_value] <=> bitpacked ∈ [min_bitpacked_value, max_bitpacked_value]
+fn transform_range_before_linear_transformation(
+    stats: &ColumnStats,
+    range: RangeInclusive<u64>,
+) -> Option<RangeInclusive<u64>> {
+    if range.is_empty() {
+        return None;
+    }
+    if stats.min_value > *range.end() {
+        return None;
+    }
+    if stats.max_value < *range.start() {
+        return None;
+    }
+    let shifted_range =
+        range.start().saturating_sub(stats.min_value)..=range.end().saturating_sub(stats.min_value);
+    let start_before_gcd_multiplication: u64 = div_ceil(*shifted_range.start(), stats.gcd);
+    let end_before_gcd_multiplication: u64 = *shifted_range.end() / stats.gcd;
+    Some(start_before_gcd_multiplication..=end_before_gcd_multiplication)
+}
+
 impl ColumnValues for BitpackedReader {
     #[inline(always)]
     fn get_val(&self, doc: u32) -> u64 {
@@ -34,6 +76,25 @@ impl ColumnValues for BitpackedReader {
     fn num_vals(&self) -> RowId {
         self.stats.num_rows
     }
+
+    fn get_row_ids_for_value_range(
+        &self,
+        range: RangeInclusive<u64>,
+        doc_id_range: Range<u32>,
+        positions: &mut Vec<u32>,
+    ) {
+        let Some(transformed_range) = transform_range_before_linear_transformation(&self.stats, range)
+        else {
+            positions.clear();
+            return;
+        };
+        self.bit_unpacker.get_ids_for_value_range(
+            transformed_range,
+            doc_id_range,
+            &self.data,
+            positions,
+        );
+    }
 }
 
 fn num_bits(stats: &ColumnStats) -> u8 {

columnar/src/columnar/column_type.rs

@@ -1,3 +1,4 @@
+use std::fmt;
 use std::fmt::Debug;
 use std::net::Ipv6Addr;
 
@@ -21,6 +22,22 @@ pub enum ColumnType {
     DateTime = 7u8,
 }
 
+impl fmt::Display for ColumnType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let short_str = match self {
+            ColumnType::I64 => "i64",
+            ColumnType::U64 => "u64",
+            ColumnType::F64 => "f64",
+            ColumnType::Bytes => "bytes",
+            ColumnType::Str => "str",
+            ColumnType::Bool => "bool",
+            ColumnType::IpAddr => "ip",
+            ColumnType::DateTime => "datetime",
+        };
+        write!(f, "{}", short_str)
+    }
+}
+
 // The order needs to match _exactly_ the order in the enum
 const COLUMN_TYPES: [ColumnType; 8] = [
     ColumnType::I64,

columnar/src/columnar/merge/mod.rs

@@ -28,7 +28,7 @@ use crate::{
 ///
 /// See also [README.md].
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-enum ColumnTypeCategory {
+pub(crate) enum ColumnTypeCategory {
     Bool,
     Str,
     Numerical,
@@ -78,25 +78,23 @@ pub fn merge_columnar(
     output: &mut impl io::Write,
 ) -> io::Result<()> {
     let mut serializer = ColumnarSerializer::new(output);
-    let num_rows_per_column = columnar_readers
+    let num_rows_per_columnar = columnar_readers
         .iter()
         .map(|reader| reader.num_rows())
         .collect::<Vec<u32>>();
-
     let columns_to_merge = group_columns_for_merge(columnar_readers, required_columns)?;
     for ((column_name, column_type), columns) in columns_to_merge {
         let mut column_serializer =
             serializer.serialize_column(column_name.as_bytes(), column_type);
         merge_column(
             column_type,
-            &num_rows_per_column,
+            &num_rows_per_columnar,
             columns,
             &merge_row_order,
             &mut column_serializer,
         )?;
     }
     serializer.finalize(merge_row_order.num_rows())?;
-
     Ok(())
 }
 
@@ -375,8 +373,8 @@ fn coerce_column(column_type: ColumnType, column: DynamicColumn) -> io::Result<D
 fn min_max_if_numerical(column: &DynamicColumn) -> Option<(NumericalValue, NumericalValue)> {
     match column {
         DynamicColumn::I64(column) => Some((column.min_value().into(), column.max_value().into())),
-        DynamicColumn::U64(column) => Some((column.min_value().into(), column.min_value().into())),
-        DynamicColumn::F64(column) => Some((column.min_value().into(), column.min_value().into())),
+        DynamicColumn::U64(column) => Some((column.min_value().into(), column.max_value().into())),
+        DynamicColumn::F64(column) => Some((column.min_value().into(), column.max_value().into())),
         DynamicColumn::Bool(_)
         | DynamicColumn::IpAddr(_)
         | DynamicColumn::DateTime(_)

columnar/src/columnar/mod.rs

@@ -5,6 +5,8 @@ mod reader;
 mod writer;
 
 pub use column_type::{ColumnType, HasAssociatedColumnType};
+#[cfg(test)]
+pub(crate) use merge::ColumnTypeCategory;
 pub use merge::{merge_columnar, MergeRowOrder, ShuffleMergeOrder, StackMergeOrder};
 pub use reader::ColumnarReader;
 pub use writer::ColumnarWriter;

columnar/src/columnar/reader/mod.rs

@@ -1,4 +1,4 @@
-use std::{io, mem};
+use std::{fmt, io, mem};
 
 use common::file_slice::FileSlice;
 use common::BinarySerializable;
@@ -21,6 +21,32 @@ pub struct ColumnarReader {
     num_rows: RowId,
 }
 
+impl fmt::Debug for ColumnarReader {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let num_rows = self.num_rows();
+        let columns = self.list_columns().unwrap();
+        let num_cols = columns.len();
+        let mut debug_struct = f.debug_struct("Columnar");
+        debug_struct
+            .field("num_rows", &num_rows)
+            .field("num_cols", &num_cols);
+        for (col_name, dynamic_column_handle) in columns.into_iter().take(5) {
+            let col = dynamic_column_handle.open().unwrap();
+            if col.num_values() > 10 {
+                debug_struct.field(&col_name, &"..");
+            } else {
+                debug_struct.field(&col_name, &col);
+            }
+        }
+        if num_cols > 5 {
+            debug_struct.finish_non_exhaustive()?;
+        } else {
+            debug_struct.finish()?;
+        }
+        Ok(())
+    }
+}
+
 /// Functions by both the async/sync code listing columns.
 /// It takes a stream from the column sstable and return the list of
 /// `DynamicColumn` available in it.

columnar/src/columnar/writer/mod.rs

@@ -104,16 +104,25 @@ impl ColumnarWriter {
         };
         let mut symbols_buffer = Vec::new();
         let mut values = Vec::new();
-        let mut last_doc_opt: Option<RowId> = None;
+        let mut start_doc_check_fill = 0;
+        let mut current_doc_opt: Option<RowId> = None;
+        // Assumption: NewDoc will never call the same doc twice and is strictly increasing between
+        // calls
         for op in numerical_col_writer.operation_iterator(&self.arena, None, &mut symbols_buffer) {
             match op {
                 ColumnOperation::NewDoc(doc) => {
-                    last_doc_opt = Some(doc);
+                    current_doc_opt = Some(doc);
                 }
                 ColumnOperation::Value(numerical_value) => {
-                    if let Some(last_doc) = last_doc_opt {
+                    if let Some(current_doc) = current_doc_opt {
+                        // Fill up with 0.0 since last doc
+                        values.extend((start_doc_check_fill..current_doc).map(|doc| (0.0, doc)));
+                        start_doc_check_fill = current_doc + 1;
+                        // handle multi values
+                        current_doc_opt = None;
+
                         let score: f32 = f64::coerce(numerical_value) as f32;
-                        values.push((score, last_doc));
+                        values.push((score, current_doc));
                     }
                 }
             }
@@ -123,9 +132,9 @@ impl ColumnarWriter {
         }
         values.sort_by(|(left_score, _), (right_score, _)| {
             if reversed {
-                right_score.partial_cmp(left_score).unwrap()
+                right_score.total_cmp(left_score)
             } else {
-                left_score.partial_cmp(right_score).unwrap()
+                left_score.total_cmp(right_score)
             }
         });
         values.into_iter().map(|(_score, doc)| doc).collect()

columnar/src/dynamic_column.rs

@@ -1,6 +1,6 @@
-use std::io;
 use std::net::Ipv6Addr;
 use std::sync::Arc;
+use std::{fmt, io};
 
 use common::file_slice::FileSlice;
 use common::{ByteCount, DateTime, HasLen, OwnedBytes};
@@ -8,7 +8,7 @@ use common::{ByteCount, DateTime, HasLen, OwnedBytes};
 use crate::column::{BytesColumn, Column, StrColumn};
 use crate::column_values::{monotonic_map_column, StrictlyMonotonicFn};
 use crate::columnar::ColumnType;
-use crate::{Cardinality, NumericalType};
+use crate::{Cardinality, ColumnIndex, NumericalType};
 
 #[derive(Clone)]
 pub enum DynamicColumn {
@@ -22,19 +22,54 @@ pub enum DynamicColumn {
     Str(StrColumn),
 }
 
-impl DynamicColumn {
-    pub fn get_cardinality(&self) -> Cardinality {
+impl fmt::Debug for DynamicColumn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "[{} {} |", self.get_cardinality(), self.column_type())?;
         match self {
-            DynamicColumn::Bool(c) => c.get_cardinality(),
-            DynamicColumn::I64(c) => c.get_cardinality(),
-            DynamicColumn::U64(c) => c.get_cardinality(),
-            DynamicColumn::F64(c) => c.get_cardinality(),
-            DynamicColumn::IpAddr(c) => c.get_cardinality(),
-            DynamicColumn::DateTime(c) => c.get_cardinality(),
-            DynamicColumn::Bytes(c) => c.ords().get_cardinality(),
-            DynamicColumn::Str(c) => c.ords().get_cardinality(),
+            DynamicColumn::Bool(col) => write!(f, " {:?}", col)?,
+            DynamicColumn::I64(col) => write!(f, " {:?}", col)?,
+            DynamicColumn::U64(col) => write!(f, " {:?}", col)?,
+            DynamicColumn::F64(col) => write!(f, "{:?}", col)?,
+            DynamicColumn::IpAddr(col) => write!(f, "{:?}", col)?,
+            DynamicColumn::DateTime(col) => write!(f, "{:?}", col)?,
+            DynamicColumn::Bytes(col) => write!(f, "{:?}", col)?,
+            DynamicColumn::Str(col) => write!(f, "{:?}", col)?,
+        }
+        write!(f, "]")
+    }
+}
+
+impl DynamicColumn {
+    pub fn column_index(&self) -> &ColumnIndex {
+        match self {
+            DynamicColumn::Bool(c) => &c.index,
+            DynamicColumn::I64(c) => &c.index,
+            DynamicColumn::U64(c) => &c.index,
+            DynamicColumn::F64(c) => &c.index,
+            DynamicColumn::IpAddr(c) => &c.index,
+            DynamicColumn::DateTime(c) => &c.index,
+            DynamicColumn::Bytes(c) => &c.ords().index,
+            DynamicColumn::Str(c) => &c.ords().index,
         }
     }
+
+    pub fn get_cardinality(&self) -> Cardinality {
+        self.column_index().get_cardinality()
+    }
+
+    pub fn num_values(&self) -> u32 {
+        match self {
+            DynamicColumn::Bool(c) => c.values.num_vals(),
+            DynamicColumn::I64(c) => c.values.num_vals(),
+            DynamicColumn::U64(c) => c.values.num_vals(),
+            DynamicColumn::F64(c) => c.values.num_vals(),
+            DynamicColumn::IpAddr(c) => c.values.num_vals(),
+            DynamicColumn::DateTime(c) => c.values.num_vals(),
+            DynamicColumn::Bytes(c) => c.ords().values.num_vals(),
+            DynamicColumn::Str(c) => c.ords().values.num_vals(),
+        }
+    }
+
     pub fn column_type(&self) -> ColumnType {
         match self {
             DynamicColumn::Bool(_) => ColumnType::Bool,

columnar/src/lib.rs

@@ -7,6 +7,7 @@ extern crate more_asserts;
 #[cfg(all(test, feature = "unstable"))]
 extern crate test;
 
+use std::fmt::Display;
 use std::io;
 
 mod block_accessor;
@@ -75,6 +76,17 @@ pub enum Cardinality {
     Multivalued = 2,
 }
 
+impl Display for Cardinality {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let short_str = match self {
+            Cardinality::Full => "full",
+            Cardinality::Optional => "opt",
+            Cardinality::Multivalued => "mult",
+        };
+        write!(f, "{short_str}")
+    }
+}
+
 impl Cardinality {
     pub fn is_optional(&self) -> bool {
         matches!(self, Cardinality::Optional)
@@ -85,7 +97,6 @@ impl Cardinality {
     pub(crate) fn to_code(self) -> u8 {
         self as u8
     }
-
     pub(crate) fn try_from_code(code: u8) -> Result<Cardinality, InvalidData> {
         match code {
             0 => Ok(Cardinality::Full),

columnar/src/tests.rs

@@ -1,10 +1,17 @@
+use std::collections::HashMap;
+use std::fmt::Debug;
 use std::net::Ipv6Addr;
 
+use common::DateTime;
+use proptest::prelude::*;
+
 use crate::column_values::MonotonicallyMappableToU128;
-use crate::columnar::ColumnType;
+use crate::columnar::{ColumnType, ColumnTypeCategory};
 use crate::dynamic_column::{DynamicColumn, DynamicColumnHandle};
-use crate::value::NumericalValue;
-use crate::{Cardinality, ColumnarReader, ColumnarWriter};
+use crate::value::{Coerce, NumericalValue};
+use crate::{
+    BytesColumn, Cardinality, Column, ColumnarReader, ColumnarWriter, RowId, StackMergeOrder,
+};
 
 #[test]
 fn test_dataframe_writer_str() {
@@ -136,6 +143,46 @@ fn test_dataframe_writer_numerical() {
     assert_eq!(column_i64.first(6), None); //< we can change the spec for that one.
 }
 
+#[test]
+fn test_dataframe_sort_by_full() {
+    let mut dataframe_writer = ColumnarWriter::default();
+    dataframe_writer.record_numerical(0u32, "value", NumericalValue::U64(1));
+    dataframe_writer.record_numerical(1u32, "value", NumericalValue::U64(2));
+    let data = dataframe_writer.sort_order("value", 2, false);
+    assert_eq!(data, vec![0, 1]);
+}
+
+#[test]
+fn test_dataframe_sort_by_opt() {
+    let mut dataframe_writer = ColumnarWriter::default();
+    dataframe_writer.record_numerical(1u32, "value", NumericalValue::U64(3));
+    dataframe_writer.record_numerical(3u32, "value", NumericalValue::U64(2));
+    let data = dataframe_writer.sort_order("value", 5, false);
+    // 0, 2, 4 is 0.0
+    assert_eq!(data, vec![0, 2, 4, 3, 1]);
+    let data = dataframe_writer.sort_order("value", 5, true);
+    assert_eq!(
+        data,
+        vec![4, 2, 0, 3, 1].into_iter().rev().collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn test_dataframe_sort_by_multi() {
+    let mut dataframe_writer = ColumnarWriter::default();
+    // valid for sort
+    dataframe_writer.record_numerical(1u32, "value", NumericalValue::U64(2));
+    // those are ignored for sort
+    dataframe_writer.record_numerical(1u32, "value", NumericalValue::U64(4));
+    dataframe_writer.record_numerical(1u32, "value", NumericalValue::U64(4));
+    // valid for sort
+    dataframe_writer.record_numerical(3u32, "value", NumericalValue::U64(3));
+    // ignored, would change sort order
+    dataframe_writer.record_numerical(3u32, "value", NumericalValue::U64(1));
+    let data = dataframe_writer.sort_order("value", 4, false);
+    assert_eq!(data, vec![0, 2, 1, 3]);
+}
+
 #[test]
 fn test_dictionary_encoded_str() {
     let mut buffer = Vec::new();
@@ -210,3 +257,497 @@ fn test_dictionary_encoded_bytes() {
         .unwrap();
     assert_eq!(term_buffer, b"b");
 }
+
+fn num_strategy() -> impl Strategy<Value = NumericalValue> {
+    prop_oneof![
+        Just(NumericalValue::U64(0u64)),
+        Just(NumericalValue::U64(u64::MAX)),
+        Just(NumericalValue::I64(0i64)),
+        Just(NumericalValue::I64(i64::MIN)),
+        Just(NumericalValue::I64(i64::MAX)),
+        Just(NumericalValue::F64(1.2f64)),
+    ]
+}
+
+#[derive(Debug, Clone, Copy)]
+enum ColumnValue {
+    Str(&'static str),
+    Bytes(&'static [u8]),
+    Numerical(NumericalValue),
+    IpAddr(Ipv6Addr),
+    Bool(bool),
+    DateTime(DateTime),
+}
+
+impl ColumnValue {
+    pub(crate) fn column_type_category(&self) -> ColumnTypeCategory {
+        match self {
+            ColumnValue::Str(_) => ColumnTypeCategory::Str,
+            ColumnValue::Bytes(_) => ColumnTypeCategory::Bytes,
+            ColumnValue::Numerical(_) => ColumnTypeCategory::Numerical,
+            ColumnValue::IpAddr(_) => ColumnTypeCategory::IpAddr,
+            ColumnValue::Bool(_) => ColumnTypeCategory::Bool,
+            ColumnValue::DateTime(_) => ColumnTypeCategory::DateTime,
+        }
+    }
+}
+
+fn column_name_strategy() -> impl Strategy<Value = &'static str> {
+    prop_oneof![Just("c1"), Just("c2")]
+}
+
+fn string_strategy() -> impl Strategy<Value = &'static str> {
+    prop_oneof![Just("a"), Just("b")]
+}
+
+fn bytes_strategy() -> impl Strategy<Value = &'static [u8]> {
+    prop_oneof![Just(&[0u8][..]), Just(&[1u8][..])]
+}
+
+// A random column value
+fn column_value_strategy() -> impl Strategy<Value = ColumnValue> {
+    prop_oneof![
+        10 => string_strategy().prop_map(|s| ColumnValue::Str(s)),
+        1 => bytes_strategy().prop_map(|b| ColumnValue::Bytes(b)),
+        40 => num_strategy().prop_map(|n| ColumnValue::Numerical(n)),
+        1 => (1u16..3u16).prop_map(|ip_addr_byte| ColumnValue::IpAddr(Ipv6Addr::new(
+            127,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            ip_addr_byte
+        ))),
+        1 => any::<bool>().prop_map(|b| ColumnValue::Bool(b)),
+        1 => (0_679_723_993i64..1_679_723_995i64)
+            .prop_map(|val| { ColumnValue::DateTime(DateTime::from_timestamp_secs(val)) })
+    ]
+}
+
+// A document contains up to 4 values.
+fn doc_strategy() -> impl Strategy<Value = Vec<(&'static str, ColumnValue)>> {
+    proptest::collection::vec((column_name_strategy(), column_value_strategy()), 0..4)
+}
+
+// A columnar contains up to 2 docs.
+fn columnar_docs_strategy() -> impl Strategy<Value = Vec<Vec<(&'static str, ColumnValue)>>> {
+    proptest::collection::vec(doc_strategy(), 0..=2)
+}
+
+fn columnar_docs_and_mapping_strategy(
+) -> impl Strategy<Value = (Vec<Vec<(&'static str, ColumnValue)>>, Vec<RowId>)> {
+    columnar_docs_strategy().prop_flat_map(|docs| {
+        permutation_strategy(docs.len()).prop_map(move |permutation| (docs.clone(), permutation))
+    })
+}
+
+fn permutation_strategy(n: usize) -> impl Strategy<Value = Vec<RowId>> {
+    Just((0u32..n as RowId).collect()).prop_shuffle()
+}
+
+fn build_columnar_with_mapping(
+    docs: &[Vec<(&'static str, ColumnValue)>],
+    old_to_new_row_ids_opt: Option<&[RowId]>,
+) -> ColumnarReader {
+    let num_docs = docs.len() as u32;
+    let mut buffer = Vec::new();
+    let mut columnar_writer = ColumnarWriter::default();
+    for (doc_id, vals) in docs.iter().enumerate() {
+        for (column_name, col_val) in vals {
+            match *col_val {
+                ColumnValue::Str(str_val) => {
+                    columnar_writer.record_str(doc_id as u32, column_name, str_val);
+                }
+                ColumnValue::Bytes(bytes) => {
+                    columnar_writer.record_bytes(doc_id as u32, column_name, bytes)
+                }
+                ColumnValue::Numerical(num) => {
+                    columnar_writer.record_numerical(doc_id as u32, column_name, num);
+                }
+                ColumnValue::IpAddr(ip_addr) => {
+                    columnar_writer.record_ip_addr(doc_id as u32, column_name, ip_addr);
+                }
+                ColumnValue::Bool(bool_val) => {
+                    columnar_writer.record_bool(doc_id as u32, column_name, bool_val);
+                }
+                ColumnValue::DateTime(date_time) => {
+                    columnar_writer.record_datetime(doc_id as u32, column_name, date_time);
+                }
+            }
+        }
+    }
+    columnar_writer
+        .serialize(num_docs, old_to_new_row_ids_opt, &mut buffer)
+        .unwrap();
+    let columnar_reader = ColumnarReader::open(buffer).unwrap();
+    columnar_reader
+}
+
+fn build_columnar(docs: &[Vec<(&'static str, ColumnValue)>]) -> ColumnarReader {
+    build_columnar_with_mapping(docs, None)
+}
+
+fn assert_columnar_eq(left: &ColumnarReader, right: &ColumnarReader) {
+    assert_eq!(left.num_rows(), right.num_rows());
+    let left_columns = left.list_columns().unwrap();
+    let right_columns = right.list_columns().unwrap();
+    assert_eq!(left_columns.len(), right_columns.len());
+    for i in 0..left_columns.len() {
+        assert_eq!(left_columns[i].0, right_columns[i].0);
+        let left_column = left_columns[i].1.open().unwrap();
+        let right_column = right_columns[i].1.open().unwrap();
+        assert_dyn_column_eq(&left_column, &right_column);
+    }
+}
+
+fn assert_column_eq<T: Copy + PartialOrd + Debug + Send + Sync + 'static>(
+    left: &Column<T>,
+    right: &Column<T>,
+) {
+    assert_eq!(left.get_cardinality(), right.get_cardinality());
+    assert_eq!(left.num_docs(), right.num_docs());
+    let num_docs = left.num_docs();
+    for doc in 0..num_docs {
+        assert_eq!(
+            left.index.value_row_ids(doc),
+            right.index.value_row_ids(doc)
+        );
+    }
+    assert_eq!(left.values.num_vals(), right.values.num_vals());
+    let num_vals = left.values.num_vals();
+    for i in 0..num_vals {
+        assert_eq!(left.values.get_val(i), right.values.get_val(i));
+    }
+}
+
+fn assert_bytes_column_eq(left: &BytesColumn, right: &BytesColumn) {
+    assert_eq!(
+        left.term_ord_column.get_cardinality(),
+        right.term_ord_column.get_cardinality()
+    );
+    assert_eq!(left.num_rows(), right.num_rows());
+    assert_column_eq(&left.term_ord_column, &right.term_ord_column);
+    assert_eq!(left.dictionary.num_terms(), right.dictionary.num_terms());
+    let num_terms = left.dictionary.num_terms();
+    let mut left_terms = left.dictionary.stream().unwrap();
+    let mut right_terms = right.dictionary.stream().unwrap();
+    for _ in 0..num_terms {
+        assert!(left_terms.advance());
+        assert!(right_terms.advance());
+        assert_eq!(left_terms.key(), right_terms.key());
+    }
+    assert!(!left_terms.advance());
+    assert!(!right_terms.advance());
+}
+
+fn assert_dyn_column_eq(left_dyn_column: &DynamicColumn, right_dyn_column: &DynamicColumn) {
+    assert_eq!(
+        &left_dyn_column.column_type(),
+        &right_dyn_column.column_type()
+    );
+    assert_eq!(
+        &left_dyn_column.get_cardinality(),
+        &right_dyn_column.get_cardinality()
+    );
+    match &(left_dyn_column, right_dyn_column) {
+        (DynamicColumn::Bool(left_col), DynamicColumn::Bool(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::I64(left_col), DynamicColumn::I64(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::U64(left_col), DynamicColumn::U64(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::F64(left_col), DynamicColumn::F64(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::DateTime(left_col), DynamicColumn::DateTime(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::IpAddr(left_col), DynamicColumn::IpAddr(right_col)) => {
+            assert_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::Bytes(left_col), DynamicColumn::Bytes(right_col)) => {
+            assert_bytes_column_eq(left_col, right_col);
+        }
+        (DynamicColumn::Str(left_col), DynamicColumn::Str(right_col)) => {
+            assert_bytes_column_eq(left_col, right_col);
+        }
+        _ => {
+            unreachable!()
+        }
+    }
+}
+
+trait AssertEqualToColumnValue {
+    fn assert_equal_to_column_value(&self, column_value: &ColumnValue);
+}
+
+impl AssertEqualToColumnValue for bool {
+    fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
+        let ColumnValue::Bool(val) = column_value else { panic!() };
+        assert_eq!(self, val);
+    }
+}
+
+impl AssertEqualToColumnValue for Ipv6Addr {
+    fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
+        let ColumnValue::IpAddr(val) = column_value else { panic!() };
+        assert_eq!(self, val);
+    }
+}
+
+impl<T: Coerce + PartialEq + Debug + Into<NumericalValue>> AssertEqualToColumnValue for T {
+    fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
+        let ColumnValue::Numerical(num) = column_value else { panic!() };
+        assert_eq!(self, &T::coerce(*num));
+    }
+}
+
+impl AssertEqualToColumnValue for DateTime {
+    fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
+        let ColumnValue::DateTime(dt) = column_value else { panic!() };
+        assert_eq!(self, dt);
+    }
+}
+
+fn assert_column_values<
+    T: AssertEqualToColumnValue + PartialEq + Copy + PartialOrd + Debug + Send + Sync + 'static,
+>(
+    col: &Column<T>,
+    expected: &HashMap<u32, Vec<&ColumnValue>>,
+) {
+    let mut num_non_empty_rows = 0;
+    for doc in 0..col.num_docs() {
+        let doc_vals: Vec<T> = col.values_for_doc(doc).collect();
+        if doc_vals.is_empty() {
+            continue;
+        }
+        num_non_empty_rows += 1;
+        let expected_vals = expected.get(&doc).unwrap();
+        assert_eq!(doc_vals.len(), expected_vals.len());
+        for (val, &expected) in doc_vals.iter().zip(expected_vals.iter()) {
+            val.assert_equal_to_column_value(expected)
+        }
+    }
+    assert_eq!(num_non_empty_rows, expected.len());
+}
+
+fn assert_bytes_column_values(
+    col: &BytesColumn,
+    expected: &HashMap<u32, Vec<&ColumnValue>>,
+    is_str: bool,
+) {
+    let mut num_non_empty_rows = 0;
+    let mut buffer = Vec::new();
+    for doc in 0..col.term_ord_column.num_docs() {
+        let doc_vals: Vec<u64> = col.term_ords(doc).collect();
+        if doc_vals.is_empty() {
+            continue;
+        }
+        let expected_vals = expected.get(&doc).unwrap();
+        assert_eq!(doc_vals.len(), expected_vals.len());
+        for (&expected_col_val, &ord) in expected_vals.iter().zip(&doc_vals) {
+            col.ord_to_bytes(ord, &mut buffer).unwrap();
+            match expected_col_val {
+                ColumnValue::Str(str_val) => {
+                    assert!(is_str);
+                    assert_eq!(str_val.as_bytes(), &buffer);
+                }
+                ColumnValue::Bytes(bytes_val) => {
+                    assert!(!is_str);
+                    assert_eq!(bytes_val, &buffer);
+                }
+                _ => {
+                    panic!();
+                }
+            }
+        }
+        num_non_empty_rows += 1;
+    }
+    assert_eq!(num_non_empty_rows, expected.len());
+}
+
+// This proptest attempts to create a tiny columnar based of up to 3 rows, and checks that the
+// resulting columnar matches the row data.
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(500))]
+    #[test]
+    fn test_single_columnar_builder_proptest(docs in columnar_docs_strategy()) {
+        let columnar = build_columnar(&docs[..]);
+        assert_eq!(columnar.num_rows() as usize, docs.len());
+        let mut expected_columns: HashMap<(&str, ColumnTypeCategory), HashMap<u32, Vec<&ColumnValue>> > = Default::default();
+        for (doc_id, doc_vals) in docs.iter().enumerate() {
+            for (col_name, col_val) in doc_vals {
+                expected_columns
+                    .entry((col_name, col_val.column_type_category()))
+                    .or_default()
+                    .entry(doc_id as u32)
+                    .or_default()
+                    .push(col_val);
+            }
+        }
+        let column_list = columnar.list_columns().unwrap();
+        assert_eq!(expected_columns.len(), column_list.len());
+        for (column_name, column) in column_list {
+            let dynamic_column = column.open().unwrap();
+            let col_category: ColumnTypeCategory = dynamic_column.column_type().into();
+            let expected_col_values: &HashMap<u32, Vec<&ColumnValue>> = expected_columns.get(&(column_name.as_str(), col_category)).unwrap();
+            match &dynamic_column {
+                DynamicColumn::Bool(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::I64(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::U64(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::F64(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::IpAddr(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::DateTime(col) =>
+                    assert_column_values(col, expected_col_values),
+                DynamicColumn::Bytes(col) =>
+                    assert_bytes_column_values(col, expected_col_values, false),
+                DynamicColumn::Str(col) =>
+                    assert_bytes_column_values(col, expected_col_values, true),
+            }
+        }
+    }
+}
+
+// Same as `test_single_columnar_builder_proptest` but with a shuffling mapping.
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(500))]
+    #[test]
+    fn test_single_columnar_builder_with_shuffle_proptest((docs, mapping) in columnar_docs_and_mapping_strategy()) {
+        let columnar = build_columnar_with_mapping(&docs[..], Some(&mapping));
+        assert_eq!(columnar.num_rows() as usize, docs.len());
+        let mut expected_columns: HashMap<(&str, ColumnTypeCategory), HashMap<u32, Vec<&ColumnValue>> > = Default::default();
+        for (doc_id, doc_vals) in docs.iter().enumerate() {
+            for (col_name, col_val) in doc_vals {
+                expected_columns
+                    .entry((col_name, col_val.column_type_category()))
+                    .or_default()
+                    .entry(mapping[doc_id])
+                    .or_default()
+                    .push(col_val);
+            }
+        }
+        let column_list = columnar.list_columns().unwrap();
+        assert_eq!(expected_columns.len(), column_list.len());
+        for (column_name, column) in column_list {
+            let dynamic_column = column.open().unwrap();
+            let col_category: ColumnTypeCategory = dynamic_column.column_type().into();
+            let expected_col_values: &HashMap<u32, Vec<&ColumnValue>> = expected_columns.get(&(column_name.as_str(), col_category)).unwrap();
+            for _doc_id in 0..columnar.num_rows() {
+                match &dynamic_column {
+                    DynamicColumn::Bool(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::I64(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::U64(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::F64(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::IpAddr(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::DateTime(col) =>
+                        assert_column_values(col, expected_col_values),
+                    DynamicColumn::Bytes(col) =>
+                        assert_bytes_column_values(col, expected_col_values, false),
+                    DynamicColumn::Str(col) =>
+                        assert_bytes_column_values(col, expected_col_values, true),
+                }
+            }
+        }
+    }
+}
+
+// This tests create 2 or 3 random small columnar and attempts to merge them.
+// It compares the resulting merged dataframe with what would have been obtained by building the
+// dataframe from the concatenated rows to begin with.
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(1000))]
+    #[test]
+    fn test_columnar_merge_proptest(columnar_docs in proptest::collection::vec(columnar_docs_strategy(), 2..=3)) {
+        let columnar_readers: Vec<ColumnarReader> = columnar_docs.iter()
+            .map(|docs| build_columnar(&docs[..]))
+            .collect::<Vec<_>>();
+        let columnar_readers_arr: Vec<&ColumnarReader> = columnar_readers.iter().collect();
+        let mut output: Vec<u8> = Vec::new();
+        let stack_merge_order = StackMergeOrder::stack(&columnar_readers_arr[..]).into();
+        crate::merge_columnar(&columnar_readers_arr[..], &[], stack_merge_order, &mut output).unwrap();
+        let merged_columnar = ColumnarReader::open(output).unwrap();
+        let concat_rows: Vec<Vec<(&'static str, ColumnValue)>> = columnar_docs.iter().cloned().flatten().collect();
+        let expected_merged_columnar = build_columnar(&concat_rows[..]);
+        assert_columnar_eq(&merged_columnar, &expected_merged_columnar);
+    }
+}
+
+#[test]
+fn test_columnar_merging_empty_columnar() {
+    let columnar_docs: Vec<Vec<Vec<(&str, ColumnValue)>>> =
+        vec![vec![], vec![vec![("c1", ColumnValue::Str("a"))]]];
+    let columnar_readers: Vec<ColumnarReader> = columnar_docs
+        .iter()
+        .map(|docs| build_columnar(&docs[..]))
+        .collect::<Vec<_>>();
+    let columnar_readers_arr: Vec<&ColumnarReader> = columnar_readers.iter().collect();
+    let mut output: Vec<u8> = Vec::new();
+    let stack_merge_order = StackMergeOrder::stack(&columnar_readers_arr[..]);
+    crate::merge_columnar(
+        &columnar_readers_arr[..],
+        &[],
+        crate::MergeRowOrder::Stack(stack_merge_order),
+        &mut output,
+    )
+    .unwrap();
+    let merged_columnar = ColumnarReader::open(output).unwrap();
+    let concat_rows: Vec<Vec<(&'static str, ColumnValue)>> =
+        columnar_docs.iter().cloned().flatten().collect();
+    let expected_merged_columnar = build_columnar(&concat_rows[..]);
+    assert_columnar_eq(&merged_columnar, &expected_merged_columnar);
+}
+
+#[test]
+fn test_columnar_merging_number_columns() {
+    let columnar_docs: Vec<Vec<Vec<(&str, ColumnValue)>>> = vec![
+        // columnar 1
+        vec![
+            // doc 1.1
+            vec![("c2", ColumnValue::Numerical(0i64.into()))],
+        ],
+        // columnar2
+        vec![
+            // doc 2.1
+            vec![("c2", ColumnValue::Numerical(0u64.into()))],
+            // doc 2.2
+            vec![("c2", ColumnValue::Numerical(u64::MAX.into()))],
+        ],
+    ];
+    let columnar_readers: Vec<ColumnarReader> = columnar_docs
+        .iter()
+        .map(|docs| build_columnar(&docs[..]))
+        .collect::<Vec<_>>();
+    let columnar_readers_arr: Vec<&ColumnarReader> = columnar_readers.iter().collect();
+    let mut output: Vec<u8> = Vec::new();
+    let stack_merge_order = StackMergeOrder::stack(&columnar_readers_arr[..]);
+    crate::merge_columnar(
+        &columnar_readers_arr[..],
+        &[],
+        crate::MergeRowOrder::Stack(stack_merge_order),
+        &mut output,
+    )
+    .unwrap();
+    let merged_columnar = ColumnarReader::open(output).unwrap();
+    let concat_rows: Vec<Vec<(&'static str, ColumnValue)>> =
+        columnar_docs.iter().cloned().flatten().collect();
+    let expected_merged_columnar = build_columnar(&concat_rows[..]);
+    assert_columnar_eq(&merged_columnar, &expected_merged_columnar);
+}
+// TODO add non trivial remap and merge
+// TODO test required_columns
+// TODO document edge case: required_columns incompatible with values.

common/src/datetime.rs

@@ -36,6 +36,16 @@ pub struct DateTime {
 }
 
 impl DateTime {
+    /// Minimum possible `DateTime` value.
+    pub const MIN: DateTime = DateTime {
+        timestamp_micros: i64::MIN,
+    };
+
+    /// Maximum possible `DateTime` value.
+    pub const MAX: DateTime = DateTime {
+        timestamp_micros: i64::MAX,
+    };
+
     /// Create new from UNIX timestamp in seconds
     pub const fn from_timestamp_secs(seconds: i64) -> Self {
         Self {

examples/aggregation.rs

@@ -42,7 +42,7 @@ fn main() -> tantivy::Result<()> {
                 .set_index_option(IndexRecordOption::WithFreqs)
                 .set_tokenizer("raw"),
         )
-        .set_fast()
+        .set_fast(None)
         .set_stored();
     schema_builder.add_text_field("category", text_fieldtype);
     schema_builder.add_f64_field("stock", FAST);

src/aggregation/agg_bench.rs

@@ -0,0 +1,611 @@
+#[cfg(all(test, feature = "unstable"))]
+mod bench {
+
+    use columnar::Cardinality;
+    use rand::prelude::SliceRandom;
+    use rand::{thread_rng, Rng};
+    use test::{self, Bencher};
+
+    use super::*;
+    use crate::aggregation::bucket::{
+        CustomOrder, HistogramAggregation, HistogramBounds, Order, OrderTarget, TermsAggregation,
+    };
+    use crate::aggregation::metric::StatsAggregation;
+    use crate::query::AllQuery;
+    use crate::schema::{Schema, TextFieldIndexing, FAST, STRING};
+    use crate::Index;
+
+    fn get_test_index_bench(cardinality: Cardinality) -> crate::Result<Index> {
+        let mut schema_builder = Schema::builder();
+        let text_fieldtype = crate::schema::TextOptions::default()
+            .set_indexing_options(
+                TextFieldIndexing::default().set_index_option(IndexRecordOption::WithFreqs),
+            )
+            .set_stored();
+        let text_field = schema_builder.add_text_field("text", text_fieldtype);
+        let text_field_many_terms = schema_builder.add_text_field("text_many_terms", STRING | FAST);
+        let text_field_few_terms = schema_builder.add_text_field("text_few_terms", STRING | FAST);
+        let score_fieldtype = crate::schema::NumericOptions::default().set_fast();
+        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 index = Index::create_from_tempdir(schema_builder.build())?;
+        let few_terms_data = vec!["INFO", "ERROR", "WARN", "DEBUG"];
+        let many_terms_data = (0..150_000)
+            .map(|num| format!("author{}", num))
+            .collect::<Vec<_>>();
+        {
+            let mut rng = thread_rng();
+            let mut index_writer = index.writer_with_num_threads(1, 100_000_000)?;
+            // To make the different test cases comparable we just change one doc to force the
+            // cardinality
+            if cardinality == Cardinality::Optional {
+                index_writer.add_document(doc!())?;
+            }
+            if cardinality == Cardinality::Multivalued {
+                index_writer.add_document(doc!(
+                    text_field => "cool",
+                    text_field => "cool",
+                    text_field_many_terms => "cool",
+                    text_field_many_terms => "cool",
+                    text_field_few_terms => "cool",
+                    text_field_few_terms => "cool",
+                    score_field => 1u64,
+                    score_field => 1u64,
+                    score_field_f64 => 1.0,
+                    score_field_f64 => 1.0,
+                    score_field_i64 => 1i64,
+                    score_field_i64 => 1i64,
+                ))?;
+            }
+            for _ in 0..1_000_000 {
+                let val: f64 = rng.gen_range(0.0..1_000_000.0);
+                index_writer.add_document(doc!(
+                    text_field => "cool",
+                    text_field_many_terms => many_terms_data.choose(&mut rng).unwrap().to_string(),
+                    text_field_few_terms => few_terms_data.choose(&mut rng).unwrap().to_string(),
+                    score_field => val as u64,
+                    score_field_f64 => val,
+                    score_field_i64 => val as i64,
+                ))?;
+            }
+            // writing the segment
+            index_writer.commit()?;
+        }
+
+        Ok(index)
+    }
+
+    use paste::paste;
+    #[macro_export]
+    macro_rules! bench_all_cardinalities {
+        (  $x:ident ) => {
+            paste! {
+                #[bench]
+                fn $x(b: &mut Bencher) {
+                    [<$x _card>](b, Cardinality::Full)
+                }
+
+                #[bench]
+                fn [<$x _opt>](b: &mut Bencher) {
+                    [<$x _card>](b, Cardinality::Optional)
+                }
+
+                #[bench]
+                fn [<$x _multi>](b: &mut Bencher) {
+                    [<$x _card>](b, Cardinality::Multivalued)
+                }
+            }
+        };
+    }
+
+    bench_all_cardinalities!(bench_aggregation_average_u64);
+
+    fn bench_aggregation_average_u64_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+        let text_field = reader.searcher().schema().get_field("text").unwrap();
+
+        b.iter(|| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, "cool"),
+                IndexRecordOption::Basic,
+            );
+
+            let agg_req_1: Aggregations = vec![(
+                "average".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&term_query, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_stats_f64);
+
+    fn bench_aggregation_stats_f64_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+        let text_field = reader.searcher().schema().get_field("text").unwrap();
+
+        b.iter(|| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, "cool"),
+                IndexRecordOption::Basic,
+            );
+
+            let agg_req_1: Aggregations = vec![(
+                "average_f64".to_string(),
+                Aggregation::Metric(MetricAggregation::Stats(StatsAggregation::from_field_name(
+                    "score_f64".to_string(),
+                ))),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&term_query, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_average_f64);
+
+    fn bench_aggregation_average_f64_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+        let text_field = reader.searcher().schema().get_field("text").unwrap();
+
+        b.iter(|| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, "cool"),
+                IndexRecordOption::Basic,
+            );
+
+            let agg_req_1: Aggregations = vec![(
+                "average_f64".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score_f64".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&term_query, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_average_u64_and_f64);
+
+    fn bench_aggregation_average_u64_and_f64_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+        let text_field = reader.searcher().schema().get_field("text").unwrap();
+
+        b.iter(|| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, "cool"),
+                IndexRecordOption::Basic,
+            );
+
+            let agg_req_1: Aggregations = vec![
+                (
+                    "average_f64".to_string(),
+                    Aggregation::Metric(MetricAggregation::Average(
+                        AverageAggregation::from_field_name("score_f64".to_string()),
+                    )),
+                ),
+                (
+                    "average".to_string(),
+                    Aggregation::Metric(MetricAggregation::Average(
+                        AverageAggregation::from_field_name("score".to_string()),
+                    )),
+                ),
+            ]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&term_query, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_terms_few);
+
+    fn bench_aggregation_terms_few_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req: Aggregations = vec![(
+                "my_texts".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
+                            field: "text_few_terms".to_string(),
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_terms_many_with_sub_agg);
+
+    fn bench_aggregation_terms_many_with_sub_agg_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let sub_agg_req: Aggregations = vec![(
+                "average_f64".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score_f64".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let agg_req: Aggregations = vec![(
+                "my_texts".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
+                            field: "text_many_terms".to_string(),
+                            ..Default::default()
+                        }),
+                        sub_aggregation: sub_agg_req,
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_terms_many2);
+
+    fn bench_aggregation_terms_many2_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req: Aggregations = vec![(
+                "my_texts".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
+                            field: "text_many_terms".to_string(),
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_terms_many_order_by_term);
+
+    fn bench_aggregation_terms_many_order_by_term_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req: Aggregations = vec![(
+                "my_texts".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
+                            field: "text_many_terms".to_string(),
+                            order: Some(CustomOrder {
+                                order: Order::Desc,
+                                target: OrderTarget::Key,
+                            }),
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_range_only);
+
+    fn bench_aggregation_range_only_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req_1: Aggregations = vec![(
+                "rangef64".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Range(RangeAggregation {
+                            field: "score_f64".to_string(),
+                            ranges: vec![
+                                (3f64..7000f64).into(),
+                                (7000f64..20000f64).into(),
+                                (20000f64..30000f64).into(),
+                                (30000f64..40000f64).into(),
+                                (40000f64..50000f64).into(),
+                                (50000f64..60000f64).into(),
+                            ],
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_range_with_avg);
+
+    fn bench_aggregation_range_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let sub_agg_req: Aggregations = vec![(
+                "average_f64".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score_f64".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let agg_req_1: Aggregations = vec![(
+                "rangef64".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Range(RangeAggregation {
+                            field: "score_f64".to_string(),
+                            ranges: vec![
+                                (3f64..7000f64).into(),
+                                (7000f64..20000f64).into(),
+                                (20000f64..30000f64).into(),
+                                (30000f64..40000f64).into(),
+                                (40000f64..50000f64).into(),
+                                (50000f64..60000f64).into(),
+                            ],
+                            ..Default::default()
+                        }),
+                        sub_aggregation: sub_agg_req,
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    // hard bounds has a different algorithm, because it actually limits collection range
+    //
+    bench_all_cardinalities!(bench_aggregation_histogram_only_hard_bounds);
+
+    fn bench_aggregation_histogram_only_hard_bounds_card(
+        b: &mut Bencher,
+        cardinality: Cardinality,
+    ) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req_1: Aggregations = vec![(
+                "rangef64".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
+                            field: "score_f64".to_string(),
+                            interval: 100f64,
+                            hard_bounds: Some(HistogramBounds {
+                                min: 1000.0,
+                                max: 300_000.0,
+                            }),
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_histogram_with_avg);
+
+    fn bench_aggregation_histogram_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let sub_agg_req: Aggregations = vec![(
+                "average_f64".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score_f64".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let agg_req_1: Aggregations = vec![(
+                "rangef64".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
+                            field: "score_f64".to_string(),
+                            interval: 100f64, // 1000 buckets
+                            ..Default::default()
+                        }),
+                        sub_aggregation: sub_agg_req,
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_histogram_only);
+
+    fn bench_aggregation_histogram_only_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+
+        b.iter(|| {
+            let agg_req_1: Aggregations = vec![(
+                "rangef64".to_string(),
+                Aggregation::Bucket(
+                    BucketAggregation {
+                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
+                            field: "score_f64".to_string(),
+                            interval: 100f64, // 1000 buckets
+                            ..Default::default()
+                        }),
+                        sub_aggregation: Default::default(),
+                    }
+                    .into(),
+                ),
+            )]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&AllQuery, &collector).unwrap()
+        });
+    }
+
+    bench_all_cardinalities!(bench_aggregation_avg_and_range_with_avg);
+
+    fn bench_aggregation_avg_and_range_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
+        let index = get_test_index_bench(cardinality).unwrap();
+        let reader = index.reader().unwrap();
+        let text_field = reader.searcher().schema().get_field("text").unwrap();
+
+        b.iter(|| {
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, "cool"),
+                IndexRecordOption::Basic,
+            );
+
+            let sub_agg_req_1: Aggregations = vec![(
+                "average_in_range".to_string(),
+                Aggregation::Metric(MetricAggregation::Average(
+                    AverageAggregation::from_field_name("score".to_string()),
+                )),
+            )]
+            .into_iter()
+            .collect();
+
+            let agg_req_1: Aggregations = vec![
+                (
+                    "average".to_string(),
+                    Aggregation::Metric(MetricAggregation::Average(
+                        AverageAggregation::from_field_name("score".to_string()),
+                    )),
+                ),
+                (
+                    "rangef64".to_string(),
+                    Aggregation::Bucket(
+                        BucketAggregation {
+                            bucket_agg: BucketAggregationType::Range(RangeAggregation {
+                                field: "score_f64".to_string(),
+                                ranges: vec![
+                                    (3f64..7000f64).into(),
+                                    (7000f64..20000f64).into(),
+                                    (20000f64..60000f64).into(),
+                                ],
+                                ..Default::default()
+                            }),
+                            sub_aggregation: sub_agg_req_1,
+                        }
+                        .into(),
+                    ),
+                ),
+            ]
+            .into_iter()
+            .collect();
+
+            let collector = get_collector(agg_req_1);
+
+            let searcher = reader.searcher();
+            searcher.search(&term_query, &collector).unwrap()
+        });
+    }
+}

src/aggregation/agg_req_with_accessor.rs

@@ -46,6 +46,15 @@ pub struct BucketAggregationWithAccessor {
     pub(crate) column_block_accessor: ColumnBlockAccessor<u64>,
 }
 
+fn get_numeric_or_date_column_types() -> &'static [ColumnType] {
+    &[
+        ColumnType::F64,
+        ColumnType::U64,
+        ColumnType::I64,
+        ColumnType::DateTime,
+    ]
+}
+
 impl BucketAggregationWithAccessor {
     fn try_from_bucket(
         bucket: &BucketAggregationType,
@@ -57,19 +66,31 @@ impl BucketAggregationWithAccessor {
         let (accessor, field_type) = match &bucket {
             BucketAggregationType::Range(RangeAggregation {
                 field: field_name, ..
-            }) => get_ff_reader_and_validate(reader, field_name)?,
+            }) => get_ff_reader_and_validate(
+                reader,
+                field_name,
+                Some(get_numeric_or_date_column_types()),
+            )?,
             BucketAggregationType::Histogram(HistogramAggregation {
                 field: field_name, ..
-            }) => get_ff_reader_and_validate(reader, field_name)?,
+            }) => get_ff_reader_and_validate(
+                reader,
+                field_name,
+                Some(get_numeric_or_date_column_types()),
+            )?,
             BucketAggregationType::DateHistogram(DateHistogramAggregationReq {
                 field: field_name,
                 ..
-            }) => get_ff_reader_and_validate(reader, field_name)?,
+            }) => get_ff_reader_and_validate(
+                reader,
+                field_name,
+                Some(get_numeric_or_date_column_types()),
+            )?,
             BucketAggregationType::Terms(TermsAggregation {
                 field: field_name, ..
             }) => {
                 str_dict_column = reader.fast_fields().str(field_name)?;
-                get_ff_reader_and_validate(reader, field_name)?
+                get_ff_reader_and_validate(reader, field_name, None)?
             }
         };
         let sub_aggregation = sub_aggregation.clone();
@@ -110,7 +131,11 @@ impl MetricAggregationWithAccessor {
             | MetricAggregation::Min(MinAggregation { field: field_name })
             | MetricAggregation::Stats(StatsAggregation { field: field_name })
             | MetricAggregation::Sum(SumAggregation { field: field_name }) => {
-                let (accessor, field_type) = get_ff_reader_and_validate(reader, field_name)?;
+                let (accessor, field_type) = get_ff_reader_and_validate(
+                    reader,
+                    field_name,
+                    Some(get_numeric_or_date_column_types()),
+                )?;
 
                 Ok(MetricAggregationWithAccessor {
                     accessor,
@@ -157,10 +182,11 @@ pub(crate) fn get_aggs_with_accessor_and_validate(
 fn get_ff_reader_and_validate(
     reader: &SegmentReader,
     field_name: &str,
+    allowed_column_types: Option<&[ColumnType]>,
 ) -> crate::Result<(columnar::Column<u64>, ColumnType)> {
     let ff_fields = reader.fast_fields();
     let ff_field_with_type = ff_fields
-        .u64_lenient_with_type(field_name)?
+        .u64_lenient_for_type(allowed_column_types, field_name)?
         .unwrap_or_else(|| {
             (
                 Column::build_empty_column(reader.num_docs()),

src/aggregation/agg_tests.rs

@@ -769,614 +769,98 @@ fn test_aggregation_on_json_object_empty_columns() {
     );
 }
 
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
+#[test]
+fn test_aggregation_on_json_object_mixed_types() {
+    let mut schema_builder = Schema::builder();
+    let json = schema_builder.add_json_field("json", FAST);
+    let schema = schema_builder.build();
+    let index = Index::create_in_ram(schema);
+    let mut index_writer = index.writer_for_tests().unwrap();
+    // => Segment with all values numeric
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": 10.0})))
+        .unwrap();
+    index_writer.commit().unwrap();
+    // => Segment with all values text
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": "blue"})))
+        .unwrap();
+    index_writer.commit().unwrap();
+    // => Segment with all boolen
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": true})))
+        .unwrap();
+    index_writer.commit().unwrap();
 
-    use columnar::Cardinality;
-    use rand::prelude::SliceRandom;
-    use rand::{thread_rng, Rng};
-    use test::{self, Bencher};
+    // => Segment with mixed values
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": "red"})))
+        .unwrap();
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": -20.5})))
+        .unwrap();
+    index_writer
+        .add_document(doc!(json => json!({"mixed_type": true})))
+        .unwrap();
 
-    use super::*;
-    use crate::aggregation::bucket::{
-        CustomOrder, HistogramAggregation, HistogramBounds, Order, OrderTarget, TermsAggregation,
-    };
-    use crate::aggregation::metric::StatsAggregation;
-    use crate::query::AllQuery;
-    use crate::schema::{Schema, TextFieldIndexing, FAST, STRING};
-    use crate::Index;
+    index_writer.commit().unwrap();
 
-    fn get_test_index_bench(cardinality: Cardinality) -> crate::Result<Index> {
-        let mut schema_builder = Schema::builder();
-        let text_fieldtype = crate::schema::TextOptions::default()
-            .set_indexing_options(
-                TextFieldIndexing::default().set_index_option(IndexRecordOption::WithFreqs),
-            )
-            .set_stored();
-        let text_field = schema_builder.add_text_field("text", text_fieldtype);
-        let text_field_many_terms = schema_builder.add_text_field("text_many_terms", STRING | FAST);
-        let text_field_few_terms = schema_builder.add_text_field("text_few_terms", STRING | FAST);
-        let score_fieldtype = crate::schema::NumericOptions::default().set_fast();
-        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 index = Index::create_from_tempdir(schema_builder.build())?;
-        let few_terms_data = vec!["INFO", "ERROR", "WARN", "DEBUG"];
-        let many_terms_data = (0..150_000)
-            .map(|num| format!("author{}", num))
-            .collect::<Vec<_>>();
-        {
-            let mut rng = thread_rng();
-            let mut index_writer = index.writer_with_num_threads(1, 100_000_000)?;
-            // To make the different test cases comparable we just change one doc to force the
-            // cardinality
-            if cardinality == Cardinality::Optional {
-                index_writer.add_document(doc!())?;
+    // All bucket types
+    let agg_req_str = r#"
+    {
+        "termagg": {
+            "terms": {
+                "field": "json.mixed_type",
+                "order": { "min_price": "desc" }
+            },
+            "aggs": {
+                "min_price": { "min": { "field": "json.mixed_type" } }
             }
-            if cardinality == Cardinality::Multivalued {
-                index_writer.add_document(doc!(
-                    text_field => "cool",
-                    text_field => "cool",
-                    text_field_many_terms => "cool",
-                    text_field_many_terms => "cool",
-                    text_field_few_terms => "cool",
-                    text_field_few_terms => "cool",
-                    score_field => 1u64,
-                    score_field => 1u64,
-                    score_field_f64 => 1.0,
-                    score_field_f64 => 1.0,
-                    score_field_i64 => 1i64,
-                    score_field_i64 => 1i64,
-                ))?;
+        },
+        "rangeagg": {
+            "range": {
+                "field": "json.mixed_type",
+                "ranges": [
+                    { "to": 3.0 },
+                    { "from": 19.0, "to": 20.0 },
+                    { "from": 20.0 }
+                ]
+            },
+            "aggs": {
+                "average_in_range": { "avg": { "field": "json.mixed_type" } }
             }
-            for _ in 0..1_000_000 {
-                let val: f64 = rng.gen_range(0.0..1_000_000.0);
-                index_writer.add_document(doc!(
-                    text_field => "cool",
-                    text_field_many_terms => many_terms_data.choose(&mut rng).unwrap().to_string(),
-                    text_field_few_terms => few_terms_data.choose(&mut rng).unwrap().to_string(),
-                    score_field => val as u64,
-                    score_field_f64 => val,
-                    score_field_i64 => val as i64,
-                ))?;
-            }
-            // writing the segment
-            index_writer.commit()?;
         }
+    } "#;
+    let agg: Aggregations = serde_json::from_str(agg_req_str).unwrap();
+    let aggregation_collector = get_collector(agg);
+    let reader = index.reader().unwrap();
+    let searcher = reader.searcher();
 
-        Ok(index)
-    }
-
-    use paste::paste;
-    #[macro_export]
-    macro_rules! bench_all_cardinalities {
-        (  $x:ident ) => {
-            paste! {
-                #[bench]
-                fn $x(b: &mut Bencher) {
-                    [<$x _card>](b, Cardinality::Full)
-                }
-
-                #[bench]
-                fn [<$x _opt>](b: &mut Bencher) {
-                    [<$x _card>](b, Cardinality::Optional)
-                }
-
-                #[bench]
-                fn [<$x _multi>](b: &mut Bencher) {
-                    [<$x _card>](b, Cardinality::Multivalued)
-                }
-            }
-        };
-    }
-
-    bench_all_cardinalities!(bench_aggregation_average_u64);
-
-    fn bench_aggregation_average_u64_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-        let text_field = reader.searcher().schema().get_field("text").unwrap();
-
-        b.iter(|| {
-            let term_query = TermQuery::new(
-                Term::from_field_text(text_field, "cool"),
-                IndexRecordOption::Basic,
-            );
-
-            let agg_req_1: Aggregations = vec![(
-                "average".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&term_query, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_stats_f64);
-
-    fn bench_aggregation_stats_f64_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-        let text_field = reader.searcher().schema().get_field("text").unwrap();
-
-        b.iter(|| {
-            let term_query = TermQuery::new(
-                Term::from_field_text(text_field, "cool"),
-                IndexRecordOption::Basic,
-            );
-
-            let agg_req_1: Aggregations = vec![(
-                "average_f64".to_string(),
-                Aggregation::Metric(MetricAggregation::Stats(StatsAggregation::from_field_name(
-                    "score_f64".to_string(),
-                ))),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&term_query, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_average_f64);
-
-    fn bench_aggregation_average_f64_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-        let text_field = reader.searcher().schema().get_field("text").unwrap();
-
-        b.iter(|| {
-            let term_query = TermQuery::new(
-                Term::from_field_text(text_field, "cool"),
-                IndexRecordOption::Basic,
-            );
-
-            let agg_req_1: Aggregations = vec![(
-                "average_f64".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score_f64".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&term_query, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_average_u64_and_f64);
-
-    fn bench_aggregation_average_u64_and_f64_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-        let text_field = reader.searcher().schema().get_field("text").unwrap();
-
-        b.iter(|| {
-            let term_query = TermQuery::new(
-                Term::from_field_text(text_field, "cool"),
-                IndexRecordOption::Basic,
-            );
-
-            let agg_req_1: Aggregations = vec![
-                (
-                    "average_f64".to_string(),
-                    Aggregation::Metric(MetricAggregation::Average(
-                        AverageAggregation::from_field_name("score_f64".to_string()),
-                    )),
-                ),
-                (
-                    "average".to_string(),
-                    Aggregation::Metric(MetricAggregation::Average(
-                        AverageAggregation::from_field_name("score".to_string()),
-                    )),
-                ),
+    let aggregation_results = searcher.search(&AllQuery, &aggregation_collector).unwrap();
+    let aggregation_res_json = serde_json::to_value(aggregation_results).unwrap();
+    assert_eq!(
+        &aggregation_res_json,
+        &serde_json::json!({
+          "rangeagg": {
+            "buckets": [
+              { "average_in_range": { "value": -20.5 }, "doc_count": 1, "key": "*-3", "to": 3.0 },
+              { "average_in_range": { "value": 10.0 }, "doc_count": 1, "from": 3.0, "key": "3-19", "to": 19.0 },
+              { "average_in_range": { "value": null }, "doc_count": 0, "from": 19.0, "key": "19-20", "to": 20.0 },
+              { "average_in_range": { "value": null }, "doc_count": 0, "from": 20.0, "key": "20-*" }
             ]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&term_query, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_terms_few);
-
-    fn bench_aggregation_terms_few_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req: Aggregations = vec![(
-                "my_texts".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
-                            field: "text_few_terms".to_string(),
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_terms_many_with_sub_agg);
-
-    fn bench_aggregation_terms_many_with_sub_agg_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let sub_agg_req: Aggregations = vec![(
-                "average_f64".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score_f64".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let agg_req: Aggregations = vec![(
-                "my_texts".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
-                            field: "text_many_terms".to_string(),
-                            ..Default::default()
-                        }),
-                        sub_aggregation: sub_agg_req,
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_terms_many2);
-
-    fn bench_aggregation_terms_many2_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req: Aggregations = vec![(
-                "my_texts".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
-                            field: "text_many_terms".to_string(),
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_terms_many_order_by_term);
-
-    fn bench_aggregation_terms_many_order_by_term_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req: Aggregations = vec![(
-                "my_texts".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Terms(TermsAggregation {
-                            field: "text_many_terms".to_string(),
-                            order: Some(CustomOrder {
-                                order: Order::Desc,
-                                target: OrderTarget::Key,
-                            }),
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_range_only);
-
-    fn bench_aggregation_range_only_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req_1: Aggregations = vec![(
-                "rangef64".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Range(RangeAggregation {
-                            field: "score_f64".to_string(),
-                            ranges: vec![
-                                (3f64..7000f64).into(),
-                                (7000f64..20000f64).into(),
-                                (20000f64..30000f64).into(),
-                                (30000f64..40000f64).into(),
-                                (40000f64..50000f64).into(),
-                                (50000f64..60000f64).into(),
-                            ],
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_range_with_avg);
-
-    fn bench_aggregation_range_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let sub_agg_req: Aggregations = vec![(
-                "average_f64".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score_f64".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let agg_req_1: Aggregations = vec![(
-                "rangef64".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Range(RangeAggregation {
-                            field: "score_f64".to_string(),
-                            ranges: vec![
-                                (3f64..7000f64).into(),
-                                (7000f64..20000f64).into(),
-                                (20000f64..30000f64).into(),
-                                (30000f64..40000f64).into(),
-                                (40000f64..50000f64).into(),
-                                (50000f64..60000f64).into(),
-                            ],
-                            ..Default::default()
-                        }),
-                        sub_aggregation: sub_agg_req,
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    // hard bounds has a different algorithm, because it actually limits collection range
-    //
-    bench_all_cardinalities!(bench_aggregation_histogram_only_hard_bounds);
-
-    fn bench_aggregation_histogram_only_hard_bounds_card(
-        b: &mut Bencher,
-        cardinality: Cardinality,
-    ) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req_1: Aggregations = vec![(
-                "rangef64".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
-                            field: "score_f64".to_string(),
-                            interval: 100f64,
-                            hard_bounds: Some(HistogramBounds {
-                                min: 1000.0,
-                                max: 300_000.0,
-                            }),
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_histogram_with_avg);
-
-    fn bench_aggregation_histogram_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let sub_agg_req: Aggregations = vec![(
-                "average_f64".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score_f64".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let agg_req_1: Aggregations = vec![(
-                "rangef64".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
-                            field: "score_f64".to_string(),
-                            interval: 100f64, // 1000 buckets
-                            ..Default::default()
-                        }),
-                        sub_aggregation: sub_agg_req,
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_histogram_only);
-
-    fn bench_aggregation_histogram_only_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-
-        b.iter(|| {
-            let agg_req_1: Aggregations = vec![(
-                "rangef64".to_string(),
-                Aggregation::Bucket(
-                    BucketAggregation {
-                        bucket_agg: BucketAggregationType::Histogram(HistogramAggregation {
-                            field: "score_f64".to_string(),
-                            interval: 100f64, // 1000 buckets
-                            ..Default::default()
-                        }),
-                        sub_aggregation: Default::default(),
-                    }
-                    .into(),
-                ),
-            )]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&AllQuery, &collector).unwrap()
-        });
-    }
-
-    bench_all_cardinalities!(bench_aggregation_avg_and_range_with_avg);
-
-    fn bench_aggregation_avg_and_range_with_avg_card(b: &mut Bencher, cardinality: Cardinality) {
-        let index = get_test_index_bench(cardinality).unwrap();
-        let reader = index.reader().unwrap();
-        let text_field = reader.searcher().schema().get_field("text").unwrap();
-
-        b.iter(|| {
-            let term_query = TermQuery::new(
-                Term::from_field_text(text_field, "cool"),
-                IndexRecordOption::Basic,
-            );
-
-            let sub_agg_req_1: Aggregations = vec![(
-                "average_in_range".to_string(),
-                Aggregation::Metric(MetricAggregation::Average(
-                    AverageAggregation::from_field_name("score".to_string()),
-                )),
-            )]
-            .into_iter()
-            .collect();
-
-            let agg_req_1: Aggregations = vec![
-                (
-                    "average".to_string(),
-                    Aggregation::Metric(MetricAggregation::Average(
-                        AverageAggregation::from_field_name("score".to_string()),
-                    )),
-                ),
-                (
-                    "rangef64".to_string(),
-                    Aggregation::Bucket(
-                        BucketAggregation {
-                            bucket_agg: BucketAggregationType::Range(RangeAggregation {
-                                field: "score_f64".to_string(),
-                                ranges: vec![
-                                    (3f64..7000f64).into(),
-                                    (7000f64..20000f64).into(),
-                                    (20000f64..60000f64).into(),
-                                ],
-                                ..Default::default()
-                            }),
-                            sub_aggregation: sub_agg_req_1,
-                        }
-                        .into(),
-                    ),
-                ),
-            ]
-            .into_iter()
-            .collect();
-
-            let collector = get_collector(agg_req_1);
-
-            let searcher = reader.searcher();
-            searcher.search(&term_query, &collector).unwrap()
-        });
-    }
+          },
+          "termagg": {
+            "buckets": [
+              { "doc_count": 1, "key": 10.0, "min_price": { "value": 10.0 } },
+              { "doc_count": 1, "key": -20.5, "min_price": { "value": -20.5 } },
+              // TODO red is missing since there is no multi aggregation within one
+              // segment for multiple types
+              // TODO bool is also not yet handled in aggregation
+              { "doc_count": 1, "key": "blue", "min_price": { "value": null } }
+            ],
+            "sum_other_doc_count": 0
+          }
+        }
+        )
+    );
 }

src/aggregation/intermediate_agg_result.rs

@@ -7,7 +7,8 @@ use std::cmp::Ordering;
 use columnar::ColumnType;
 use itertools::Itertools;
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
+use serde::ser::SerializeSeq;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use super::agg_req::{
     Aggregations, AggregationsInternal, BucketAggregationInternal, BucketAggregationType,
@@ -463,11 +464,39 @@ pub struct IntermediateRangeBucketResult {
 #[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
 /// Term aggregation including error counts
 pub struct IntermediateTermBucketResult {
+    #[serde(
+        serialize_with = "serialize_entries",
+        deserialize_with = "deserialize_entries"
+    )]
     pub(crate) entries: FxHashMap<Key, IntermediateTermBucketEntry>,
     pub(crate) sum_other_doc_count: u64,
     pub(crate) doc_count_error_upper_bound: u64,
 }
 
+// Serialize into a Vec to circument the JSON limitation, where keys can't be numbers
+fn serialize_entries<S>(
+    entries: &FxHashMap<Key, IntermediateTermBucketEntry>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut seq = serializer.serialize_seq(Some(entries.len()))?;
+    for (k, v) in entries {
+        seq.serialize_element(&(k, v))?;
+    }
+    seq.end()
+}
+
+fn deserialize_entries<'de, D>(
+    deserializer: D,
+) -> Result<FxHashMap<Key, IntermediateTermBucketEntry>, D::Error>
+where D: Deserializer<'de> {
+    let vec_entries: Vec<(Key, IntermediateTermBucketEntry)> =
+        Deserialize::deserialize(deserializer)?;
+    Ok(vec_entries.into_iter().collect())
+}
+
 impl IntermediateTermBucketResult {
     pub(crate) fn into_final_result(
         self,
@@ -841,4 +870,26 @@ mod tests {
 
         assert_eq!(tree_left, orig);
     }
+
+    #[test]
+    fn test_term_bucket_json_roundtrip() {
+        let term_buckets = IntermediateTermBucketResult {
+            entries: vec![(
+                Key::F64(5.0),
+                IntermediateTermBucketEntry {
+                    doc_count: 10,
+                    sub_aggregation: Default::default(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            sum_other_doc_count: 0,
+            doc_count_error_upper_bound: 0,
+        };
+
+        let term_buckets_round: IntermediateTermBucketResult =
+            serde_json::from_str(&serde_json::to_string(&term_buckets).unwrap()).unwrap();
+
+        assert_eq!(term_buckets, term_buckets_round);
+    }
 }

src/aggregation/mod.rs

@@ -445,7 +445,7 @@ mod tests {
                     .set_index_option(IndexRecordOption::Basic)
                     .set_fieldnorms(false),
             )
-            .set_fast()
+            .set_fast(None)
             .set_stored();
         let text_field = schema_builder.add_text_field("text", text_fieldtype.clone());
         let text_field_id = schema_builder.add_text_field("text_id", text_fieldtype);
@@ -500,7 +500,7 @@ mod tests {
             .set_indexing_options(
                 TextFieldIndexing::default().set_index_option(IndexRecordOption::WithFreqs),
             )
-            .set_fast()
+            .set_fast(None)
             .set_stored();
         let text_field = schema_builder.add_text_field("text", text_fieldtype);
         let date_field = schema_builder.add_date_field("date", FAST);

src/collector/histogram_collector.rs

@@ -113,7 +113,7 @@ impl Collector for HistogramCollector {
         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 {
+        let (column, _column_type) = column_opt.ok_or_else(|| FastFieldNotAvailableError {
             field_name: self.field.clone(),
         })?;
         let column_u64 = column.first_or_default_col(0u64);

src/collector/top_score_collector.rs

@@ -155,12 +155,13 @@ impl CustomScorer<u64> for ScorerByField {
         //
         // 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 {
+        let (sort_column, _sort_column_type) =
+            sort_column_opt.ok_or_else(|| FastFieldNotAvailableError {
                 field_name: self.field.clone(),
-            })?
-            .first_or_default_col(0u64);
-        Ok(ScorerByFastFieldReader { sort_column })
+            })?;
+        Ok(ScorerByFastFieldReader {
+            sort_column: sort_column.first_or_default_col(0u64),
+        })
     }
 }
 

src/fastfield/mod.rs

@@ -14,8 +14,8 @@
 //! Fields have to be declared as `FAST` in the schema.
 //! Currently supported fields are: u64, i64, f64, bytes, ip and text.
 //!
-//! Fast fields are stored in with [different codecs](fastfield_codecs). The best codec is detected
-//! automatically, when serializing.
+//! Fast fields are stored in with [different codecs](columnar::column_values). The best codec is
+//! detected automatically, when serializing.
 //!
 //! Read access performance is comparable to that of an array lookup.
 
@@ -115,7 +115,7 @@ mod tests {
         let directory: RamDirectory = RamDirectory::create();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA).unwrap();
             fast_field_writers
                 .add_document(&doc!(*FIELD=>13u64))
                 .unwrap();
@@ -148,7 +148,7 @@ mod tests {
         let directory: RamDirectory = RamDirectory::create();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA).unwrap();
             fast_field_writers
                 .add_document(&doc!(*FIELD=>4u64))
                 .unwrap();
@@ -203,7 +203,7 @@ mod tests {
         let directory: RamDirectory = RamDirectory::create();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA).unwrap();
             for _ in 0..10_000 {
                 fast_field_writers
                     .add_document(&doc!(*FIELD=>100_000u64))
@@ -231,7 +231,7 @@ mod tests {
 
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA).unwrap();
             // forcing the amplitude to be high
             fast_field_writers
                 .add_document(&doc!(*FIELD=>0u64))
@@ -268,7 +268,7 @@ mod tests {
         let schema = schema_builder.build();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             for i in -100i64..10_000i64 {
                 let mut doc = Document::default();
                 doc.add_i64(i64_field, i);
@@ -310,7 +310,7 @@ mod tests {
 
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             let doc = Document::default();
             fast_field_writers.add_document(&doc).unwrap();
             fast_field_writers.serialize(&mut write, None).unwrap();
@@ -343,7 +343,7 @@ mod tests {
         let schema = schema_builder.build();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             let doc = Document::default();
             fast_field_writers.add_document(&doc).unwrap();
             fast_field_writers.serialize(&mut write, None).unwrap();
@@ -379,7 +379,7 @@ mod tests {
         let directory = RamDirectory::create();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA).unwrap();
             for &x in &permutation {
                 fast_field_writers.add_document(&doc!(*FIELD=>x)).unwrap();
             }
@@ -759,7 +759,7 @@ mod tests {
 
         {
             let mut write: WritePtr = directory.open_write(path).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             fast_field_writers.add_document(&doc!(field=>true)).unwrap();
             fast_field_writers
                 .add_document(&doc!(field=>false))
@@ -793,7 +793,7 @@ mod tests {
 
         {
             let mut write: WritePtr = directory.open_write(path).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             for _ in 0..50 {
                 fast_field_writers.add_document(&doc!(field=>true)).unwrap();
                 fast_field_writers
@@ -822,7 +822,7 @@ mod tests {
         let schema = schema_builder.build();
         {
             let mut write: WritePtr = directory.open_write(path).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(&schema).unwrap();
             let doc = Document::default();
             fast_field_writers.add_document(&doc).unwrap();
             fast_field_writers.serialize(&mut write, None).unwrap();
@@ -849,7 +849,7 @@ mod tests {
         let directory: RamDirectory = RamDirectory::create();
         {
             let mut write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut fast_field_writers = FastFieldsWriter::from_schema(schema);
+            let mut fast_field_writers = FastFieldsWriter::from_schema(schema).unwrap();
             for doc in docs {
                 fast_field_writers.add_document(doc).unwrap();
             }
@@ -1173,6 +1173,45 @@ mod tests {
         assert_eq!(&vals, &[33]);
     }
 
+    #[test]
+    fn test_text_fast_field_tokenizer() {
+        let mut schema_builder = Schema::builder();
+
+        let text_fieldtype = crate::schema::TextOptions::default()
+            .set_indexing_options(
+                crate::schema::TextFieldIndexing::default()
+                    .set_index_option(crate::schema::IndexRecordOption::WithFreqs)
+                    .set_tokenizer("raw"),
+            )
+            .set_fast(Some("default"))
+            .set_stored();
+
+        let log_field = schema_builder.add_text_field("log_level", text_fieldtype);
+        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!(log_field => "info"))
+            .unwrap();
+        index_writer
+            .add_document(doc!(log_field => "INFO"))
+            .unwrap();
+        index_writer.commit().unwrap();
+        let searcher = index.reader().unwrap().searcher();
+        let fast_field_reader = searcher.segment_reader(0u32).fast_fields();
+
+        let text_fast_field = fast_field_reader.str("log_level").unwrap().unwrap();
+        let mut buffer = String::new();
+        assert!(text_fast_field.ord_to_str(0, &mut buffer).unwrap());
+        assert_eq!(buffer, "info");
+        assert!(!text_fast_field.ord_to_str(1, &mut buffer).unwrap());
+
+        assert!(text_fast_field.term_ords(0).eq([0].into_iter()));
+        assert!(text_fast_field.term_ords(1).eq([0].into_iter()));
+        assert!(text_fast_field.ords().values_for_doc(0u32).eq([0]));
+        assert!(text_fast_field.ords().values_for_doc(1u32).eq([0]));
+    }
+
     #[test]
     fn test_shadowing_fast_field_with_expand_dots() {
         let mut schema_builder = Schema::builder();

src/fastfield/readers.rs

@@ -252,26 +252,25 @@ impl FastFieldReaders {
         Ok(columns)
     }
 
-    /// Returns the `u64` column used to represent any `u64`-mapped typed (i64, u64, f64, DateTime).
-    #[doc(hidden)]
-    pub fn u64_lenient(&self, field_name: &str) -> crate::Result<Option<Column<u64>>> {
-        Ok(self
-            .u64_lenient_with_type(field_name)?
-            .map(|(u64_column, _)| u64_column))
-    }
-
-    /// Returns the `u64` column used to represent any `u64`-mapped typed (i64, u64, f64, DateTime).
+    /// Returns the `u64` column used to represent any `u64`-mapped typed (String/Bytes term ids,
+    /// i64, u64, f64, DateTime).
     ///
     /// Returns Ok(None) for empty columns
     #[doc(hidden)]
-    pub fn u64_lenient_with_type(
+    pub fn u64_lenient_for_type(
         &self,
+        type_white_list_opt: Option<&[ColumnType]>,
         field_name: &str,
     ) -> crate::Result<Option<(Column<u64>, ColumnType)>> {
         let Some(resolved_field_name) = self.resolve_field(field_name)? else {
             return Ok(None);
         };
         for col in self.columnar.read_columns(&resolved_field_name)? {
+            if let Some(type_white_list) = type_white_list_opt {
+                if !type_white_list.contains(&col.column_type()) {
+                    continue;
+                }
+            }
             if let Some(col_u64) = col.open_u64_lenient()? {
                 return Ok(Some((col_u64, col.column_type())));
             }
@@ -279,6 +278,17 @@ impl FastFieldReaders {
         Ok(None)
     }
 
+    /// Returns the `u64` column used to represent any `u64`-mapped typed (i64, u64, f64, DateTime).
+    ///
+    /// Returns Ok(None) for empty columns
+    #[doc(hidden)]
+    pub fn u64_lenient(
+        &self,
+        field_name: &str,
+    ) -> crate::Result<Option<(Column<u64>, ColumnType)>> {
+        self.u64_lenient_for_type(None, field_name)
+    }
+
     /// Returns the `i64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a i64 fast field, this method returns an Error.

src/fastfield/writer.rs

@@ -2,11 +2,13 @@ use std::io;
 
 use columnar::{ColumnarWriter, NumericalValue};
 use common::replace_in_place;
+use tokenizer_api::Token;
 
 use crate::indexer::doc_id_mapping::DocIdMapping;
 use crate::schema::term::{JSON_PATH_SEGMENT_SEP, JSON_PATH_SEGMENT_SEP_STR};
 use crate::schema::{value_type_to_column_type, Document, FieldType, Schema, Type, Value};
-use crate::{DatePrecision, DocId};
+use crate::tokenizer::{TextAnalyzer, TokenizerManager};
+use crate::{DatePrecision, DocId, TantivyError};
 
 /// Only index JSON down to a depth of 20.
 /// This is mostly to guard us from a stack overflow triggered by malicious input.
@@ -15,7 +17,8 @@ const JSON_DEPTH_LIMIT: usize = 20;
 /// The `FastFieldsWriter` groups all of the fast field writers.
 pub struct FastFieldsWriter {
     columnar_writer: ColumnarWriter,
-    fast_field_names: Vec<Option<String>>, //< TODO see if we can cash the field name hash too.
+    fast_field_names: Vec<Option<String>>, //< TODO see if we can hash the field name hash too.
+    per_field_tokenizer: Vec<Option<TextAnalyzer>>,
     date_precisions: Vec<DatePrecision>,
     expand_dots: Vec<bool>,
     num_docs: DocId,
@@ -25,14 +28,25 @@ pub struct FastFieldsWriter {
 
 impl FastFieldsWriter {
     /// Create all `FastFieldWriter` required by the schema.
-    pub fn from_schema(schema: &Schema) -> FastFieldsWriter {
+    #[cfg(test)]
+    pub fn from_schema(schema: &Schema) -> crate::Result<FastFieldsWriter> {
+        FastFieldsWriter::from_schema_and_tokenizer_manager(&schema, TokenizerManager::new())
+    }
+
+    /// Create all `FastFieldWriter` required by the schema.
+    pub fn from_schema_and_tokenizer_manager(
+        schema: &Schema,
+        tokenizer_manager: TokenizerManager,
+    ) -> crate::Result<FastFieldsWriter> {
         let mut columnar_writer = ColumnarWriter::default();
+
         let mut fast_field_names: Vec<Option<String>> = vec![None; schema.num_fields()];
         let mut date_precisions: Vec<DatePrecision> =
             std::iter::repeat_with(DatePrecision::default)
                 .take(schema.num_fields())
                 .collect();
         let mut expand_dots = vec![false; schema.num_fields()];
+        let mut per_field_tokenizer = vec![None; schema.num_fields()];
         // TODO see other types
         for (field_id, field_entry) in schema.fields() {
             if !field_entry.field_type().is_fast() {
@@ -47,6 +61,18 @@ impl FastFieldsWriter {
                 expand_dots[field_id.field_id() as usize] =
                     json_object_options.is_expand_dots_enabled();
             }
+            if let FieldType::Str(text_options) = field_entry.field_type() {
+                if let Some(tokenizer_name) = text_options.get_fast_field_tokenizer_name() {
+                    let text_analyzer = tokenizer_manager.get(tokenizer_name).ok_or_else(|| {
+                        TantivyError::InvalidArgument(format!(
+                            "Tokenizer {:?} not found",
+                            tokenizer_name
+                        ))
+                    })?;
+                    per_field_tokenizer[field_id.field_id() as usize] = Some(text_analyzer);
+                }
+            }
+
             let sort_values_within_row = value_type == Type::Facet;
             if let Some(column_type) = value_type_to_column_type(value_type) {
                 columnar_writer.record_column_type(
@@ -56,14 +82,15 @@ impl FastFieldsWriter {
                 );
             }
         }
-        FastFieldsWriter {
+        Ok(FastFieldsWriter {
             columnar_writer,
             fast_field_names,
+            per_field_tokenizer,
             num_docs: 0u32,
             date_precisions,
             expand_dots,
             json_path_buffer: String::new(),
-        }
+        })
     }
 
     /// The memory used (inclusive childs)
@@ -111,14 +138,35 @@ impl FastFieldsWriter {
                         );
                     }
                     Value::Str(text_val) => {
-                        self.columnar_writer
-                            .record_str(doc_id, field_name.as_str(), text_val);
+                        if let Some(text_analyzer) =
+                            &self.per_field_tokenizer[field_value.field().field_id() as usize]
+                        {
+                            let mut token_stream = text_analyzer.token_stream(text_val);
+                            token_stream.process(&mut |token: &Token| {
+                                self.columnar_writer.record_str(
+                                    doc_id,
+                                    field_name.as_str(),
+                                    &token.text,
+                                );
+                            })
+                        } else {
+                            self.columnar_writer
+                                .record_str(doc_id, field_name.as_str(), text_val);
+                        }
                     }
                     Value::Bytes(bytes_val) => {
                         self.columnar_writer
                             .record_bytes(doc_id, field_name.as_str(), bytes_val);
                     }
-                    Value::PreTokStr(_) => todo!(),
+                    Value::PreTokStr(pre_tok) => {
+                        for token in &pre_tok.tokens {
+                            self.columnar_writer.record_str(
+                                doc_id,
+                                field_name.as_str(),
+                                &token.text,
+                            );
+                        }
+                    }
                     Value::Bool(bool_val) => {
                         self.columnar_writer
                             .record_bool(doc_id, field_name.as_str(), *bool_val);

src/indexer/index_writer.rs

@@ -1640,6 +1640,7 @@ mod tests {
             .add_ip_addr_field("ips", IpAddrOptions::default().set_fast().set_indexed());
         let i64_field = schema_builder.add_i64_field("i64", INDEXED);
         let id_field = schema_builder.add_u64_field("id", FAST | INDEXED | STORED);
+        let id_opt_field = schema_builder.add_u64_field("id_opt", FAST | INDEXED | STORED);
         let f64_field = schema_builder.add_f64_field("f64", INDEXED);
         let date_field = schema_builder.add_date_field("date", INDEXED);
         let bytes_field = schema_builder.add_bytes_field("bytes", FAST | INDEXED | STORED);
@@ -1670,7 +1671,7 @@ mod tests {
         let settings = if sort_index {
             IndexSettings {
                 sort_by_field: Some(IndexSortByField {
-                    field: "id".to_string(),
+                    field: "id_opt".to_string(),
                     order: Order::Asc,
                 }),
                 ..Default::default()
@@ -1689,7 +1690,7 @@ mod tests {
 
         let old_reader = index.reader()?;
 
-        let ip_exists = |id| id % 3 != 0; // 0 does not exist
+        let id_exists = |id| id % 3 != 0; // 0 does not exist
 
         let multi_text_field_text1 = "test1 test2 test3 test1 test2 test3";
         // rotate left
@@ -1705,28 +1706,15 @@ mod tests {
                     let facet = Facet::from(&("/cola/".to_string() + &id.to_string()));
                     let ip = ip_from_id(id);
 
-                    if !ip_exists(id) {
+                    if !id_exists(id) {
                         // every 3rd doc has no ip field
-                        index_writer.add_document(doc!(id_field=>id,
-                                bytes_field => id.to_le_bytes().as_slice(),
-                                multi_numbers=> id,
-                                multi_numbers => id,
-                                bool_field => (id % 2u64) != 0,
-                                i64_field => id as i64,
-                                f64_field => id as f64,
-                                date_field => DateTime::from_timestamp_secs(id as i64),
-                                multi_bools => (id % 2u64) != 0,
-                                multi_bools => (id % 2u64) == 0,
-                                text_field => id.to_string(),
-                                facet_field => facet,
-                                large_text_field => LOREM,
-                                multi_text_fields => multi_text_field_text1,
-                                multi_text_fields => multi_text_field_text2,
-                                multi_text_fields => multi_text_field_text3,
+                        index_writer.add_document(doc!(
+                            id_field=>id,
                         ))?;
                     } else {
                         index_writer.add_document(doc!(id_field=>id,
                                 bytes_field => id.to_le_bytes().as_slice(),
+                                id_opt_field => id,
                                 ip_field => ip,
                                 ips_field => ip,
                                 ips_field => ip,
@@ -1835,6 +1823,13 @@ mod tests {
             .values()
             .map(|id_occurrences| *id_occurrences as usize)
             .sum::<usize>();
+
+        let num_docs_with_values = expected_ids_and_num_occurrences
+            .iter()
+            .filter(|(id, _id_occurrences)| id_exists(**id))
+            .map(|(_, id_occurrences)| *id_occurrences as usize)
+            .sum::<usize>();
+
         assert_eq!(searcher.num_docs() as usize, num_docs_expected);
         assert_eq!(old_searcher.num_docs() as usize, num_docs_expected);
         assert_eq!(
@@ -1855,7 +1850,7 @@ mod tests {
         if force_end_merge && num_segments_before_merge > 1 && num_segments_after_merge == 1 {
             let mut expected_multi_ips: Vec<_> = id_list
                 .iter()
-                .filter(|id| ip_exists(**id))
+                .filter(|id| id_exists(**id))
                 .flat_map(|id| vec![ip_from_id(*id), ip_from_id(*id)])
                 .collect();
             assert_eq!(num_ips, expected_multi_ips.len() as u32);
@@ -1893,7 +1888,7 @@ mod tests {
         let expected_ips = expected_ids_and_num_occurrences
             .keys()
             .flat_map(|id| {
-                if !ip_exists(*id) {
+                if !id_exists(*id) {
                     None
                 } else {
                     Some(Ipv6Addr::from_u128(*id as u128))
@@ -1905,7 +1900,7 @@ mod tests {
         let expected_ips = expected_ids_and_num_occurrences
             .keys()
             .filter_map(|id| {
-                if !ip_exists(*id) {
+                if !id_exists(*id) {
                     None
                 } else {
                     Some(Ipv6Addr::from_u128(*id as u128))
@@ -1937,16 +1932,25 @@ mod tests {
                 .unwrap()
                 .unwrap();
             for doc in segment_reader.doc_ids_alive() {
+                let id = id_reader.first(doc).unwrap();
+
                 let vals: Vec<u64> = ff_reader.values_for_doc(doc).collect();
-                assert_eq!(vals.len(), 2);
-                assert_eq!(vals[0], vals[1]);
-                assert_eq!(id_reader.first(doc), Some(vals[0]));
+                if id_exists(id) {
+                    assert_eq!(vals.len(), 2);
+                    assert_eq!(vals[0], vals[1]);
+                    assert!(expected_ids_and_num_occurrences.contains_key(&vals[0]));
+                    assert_eq!(id_reader.first(doc), Some(vals[0]));
+                } else {
+                    assert_eq!(vals.len(), 0);
+                }
 
                 let bool_vals: Vec<bool> = bool_ff_reader.values_for_doc(doc).collect();
-                assert_eq!(bool_vals.len(), 2);
-                assert_ne!(bool_vals[0], bool_vals[1]);
-
-                assert!(expected_ids_and_num_occurrences.contains_key(&vals[0]));
+                if id_exists(id) {
+                    assert_eq!(bool_vals.len(), 2);
+                    assert_ne!(bool_vals[0], bool_vals[1]);
+                } else {
+                    assert_eq!(bool_vals.len(), 0);
+                }
             }
         }
 
@@ -1970,26 +1974,28 @@ mod tests {
                     .as_u64()
                     .unwrap();
                 assert!(expected_ids_and_num_occurrences.contains_key(&id));
-                let id2 = store_reader
-                    .get(doc_id)
-                    .unwrap()
-                    .get_first(multi_numbers)
-                    .unwrap()
-                    .as_u64()
-                    .unwrap();
-                assert_eq!(id, id2);
-                let bool = store_reader
-                    .get(doc_id)
-                    .unwrap()
-                    .get_first(bool_field)
-                    .unwrap()
-                    .as_bool()
-                    .unwrap();
-                let doc = store_reader.get(doc_id).unwrap();
-                let mut bool2 = doc.get_all(multi_bools);
-                assert_eq!(bool, bool2.next().unwrap().as_bool().unwrap());
-                assert_ne!(bool, bool2.next().unwrap().as_bool().unwrap());
-                assert_eq!(None, bool2.next())
+                if id_exists(id) {
+                    let id2 = store_reader
+                        .get(doc_id)
+                        .unwrap()
+                        .get_first(multi_numbers)
+                        .unwrap()
+                        .as_u64()
+                        .unwrap();
+                    assert_eq!(id, id2);
+                    let bool = store_reader
+                        .get(doc_id)
+                        .unwrap()
+                        .get_first(bool_field)
+                        .unwrap()
+                        .as_bool()
+                        .unwrap();
+                    let doc = store_reader.get(doc_id).unwrap();
+                    let mut bool2 = doc.get_all(multi_bools);
+                    assert_eq!(bool, bool2.next().unwrap().as_bool().unwrap());
+                    assert_ne!(bool, bool2.next().unwrap().as_bool().unwrap());
+                    assert_eq!(None, bool2.next())
+                }
             }
         }
         // test search
@@ -2011,22 +2017,25 @@ mod tests {
             top_docs.iter().map(|el| el.1).collect::<Vec<_>>()
         };
 
-        for (existing_id, count) in &expected_ids_and_num_occurrences {
-            let (existing_id, count) = (*existing_id, *count);
+        for (id, count) in &expected_ids_and_num_occurrences {
+            let (existing_id, count) = (*id, *count);
             let get_num_hits = |field| do_search(&existing_id.to_string(), field).len() as u64;
+            assert_eq!(get_num_hits(id_field), count);
+            if !id_exists(existing_id) {
+                continue;
+            }
             assert_eq!(get_num_hits(text_field), count);
             assert_eq!(get_num_hits(i64_field), count);
             assert_eq!(get_num_hits(f64_field), count);
-            assert_eq!(get_num_hits(id_field), count);
 
             // Test multi text
             assert_eq!(
                 do_search("\"test1 test2\"", multi_text_fields).len(),
-                num_docs_expected
+                num_docs_with_values
             );
             assert_eq!(
                 do_search("\"test2 test3\"", multi_text_fields).len(),
-                num_docs_expected
+                num_docs_with_values
             );
 
             // Test bytes
@@ -2062,7 +2071,7 @@ mod tests {
         //
         for (existing_id, count) in &expected_ids_and_num_occurrences {
             let (existing_id, count) = (*existing_id, *count);
-            if !ip_exists(existing_id) {
+            if !id_exists(existing_id) {
                 continue;
             }
             let do_search_ip_field = |term: &str| do_search(term, ip_field).len() as u64;
@@ -2083,7 +2092,7 @@ mod tests {
         //
         for (existing_id, count) in expected_ids_and_num_occurrences.iter().take(10) {
             let (existing_id, count) = (*existing_id, *count);
-            if !ip_exists(existing_id) {
+            if !id_exists(existing_id) {
                 continue;
             }
             let gen_query_inclusive = |field: &str, from: Ipv6Addr, to: Ipv6Addr| {
@@ -2106,7 +2115,7 @@ mod tests {
         //
         for (existing_id, count) in expected_ids_and_num_occurrences.iter().take(10) {
             let (existing_id, count) = (*existing_id, *count);
-            if !ip_exists(existing_id) {
+            if !id_exists(existing_id) {
                 continue;
             }
             let gen_query_inclusive = |field: &str, from: Ipv6Addr, to: Ipv6Addr| {
@@ -2131,23 +2140,61 @@ mod tests {
                 .fast_fields()
                 .u64("id")
                 .unwrap()
-                .first_or_default_col(0);
+                .first_or_default_col(9999);
             for doc_id in segment_reader.doc_ids_alive() {
+                let id = ff_reader.get_val(doc_id);
+                if !id_exists(id) {
+                    continue;
+                }
                 let facet_ords: Vec<u64> = facet_reader.facet_ords(doc_id).collect();
                 assert_eq!(facet_ords.len(), 1);
                 let mut facet = Facet::default();
                 facet_reader
                     .facet_from_ord(facet_ords[0], &mut facet)
                     .unwrap();
-                let id = ff_reader.get_val(doc_id);
                 let facet_expected = Facet::from(&("/cola/".to_string() + &id.to_string()));
 
                 assert_eq!(facet, facet_expected);
             }
         }
+
+        // Test if index property is in sort order
+        if sort_index {
+            // load all id_opt in each segment and check they are in order
+
+            for reader in searcher.segment_readers() {
+                let (ff_reader, _) = reader.fast_fields().u64_lenient("id_opt").unwrap().unwrap();
+                let mut ids_in_segment: Vec<u64> = Vec::new();
+
+                for doc in 0..reader.num_docs() {
+                    ids_in_segment.extend(ff_reader.values_for_doc(doc));
+                }
+
+                assert!(is_sorted(&ids_in_segment));
+
+                fn is_sorted<T>(data: &[T]) -> bool
+                where T: Ord {
+                    data.windows(2).all(|w| w[0] <= w[1])
+                }
+            }
+        }
         Ok(index)
     }
 
+    #[test]
+    fn test_sort_index_on_opt_field_regression() {
+        assert!(test_operation_strategy(
+            &[
+                IndexingOp::AddDoc { id: 81 },
+                IndexingOp::AddDoc { id: 70 },
+                IndexingOp::DeleteDoc { id: 70 }
+            ],
+            true,
+            false
+        )
+        .is_ok());
+    }
+
     #[test]
     fn test_ip_range_query_multivalue_bug() {
         assert!(test_operation_strategy(

src/indexer/log_merge_policy.rs

@@ -171,7 +171,7 @@ mod tests {
             index_writer.set_merge_policy(Box::new(log_merge_policy));
 
             // after every commit the merge checker is started, it will merge only segments with 1
-            // element in it because of the max_merge_size.
+            // element in it because of the max_docs_before_merge.
             index_writer.add_document(doc!(int_field=>1_u64))?;
             index_writer.commit()?;
 

src/indexer/merger.rs

@@ -306,7 +306,7 @@ impl IndexMerger {
         sort_by_field: &IndexSortByField,
     ) -> crate::Result<Arc<dyn ColumnValues>> {
         reader.schema().get_field(&sort_by_field.field)?;
-        let value_accessor = reader
+        let (value_accessor, _column_type) = reader
             .fast_fields()
             .u64_lenient(&sort_by_field.field)?
             .ok_or_else(|| FastFieldNotAvailableError {

src/indexer/segment_writer.rs

@@ -111,7 +111,10 @@ impl SegmentWriter {
             per_field_postings_writers,
             fieldnorms_writer: FieldNormsWriter::for_schema(&schema),
             segment_serializer,
-            fast_field_writers: FastFieldsWriter::from_schema(&schema),
+            fast_field_writers: FastFieldsWriter::from_schema_and_tokenizer_manager(
+                &schema,
+                tokenizer_manager,
+            )?,
             doc_opstamps: Vec::with_capacity(1_000),
             per_field_text_analyzers,
             term_buffer: Term::with_capacity(16),

src/query/range_query/range_query_u64_fastfield.rs

@@ -33,7 +33,7 @@ impl FastFieldRangeWeight {
 impl Weight for FastFieldRangeWeight {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         let fast_field_reader = reader.fast_fields();
-        let Some(column) = fast_field_reader.u64_lenient(&self.field)? else {
+        let Some((column, _)) = fast_field_reader.u64_lenient(&self.field)? else {
             return Ok(Box::new(EmptyScorer));
         };
         let value_range = bound_to_value_range(

src/schema/text_options.rs

@@ -16,13 +16,53 @@ pub struct TextOptions {
     #[serde(default)]
     stored: bool,
     #[serde(default)]
-    fast: bool,
+    fast: FastFieldOptions,
     #[serde(default)]
     #[serde(skip_serializing_if = "is_false")]
-    /// coerce values if they are not of type string
+    /// coerce values into string if they are not of type string
     coerce: bool,
 }
 
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+enum FastFieldOptions {
+    IsEnabled(bool),
+    EnabledWithTokenizer { with_tokenizer: TokenizerName },
+}
+
+impl Default for FastFieldOptions {
+    fn default() -> Self {
+        FastFieldOptions::IsEnabled(false)
+    }
+}
+
+impl BitOr<FastFieldOptions> for FastFieldOptions {
+    type Output = FastFieldOptions;
+
+    fn bitor(self, other: FastFieldOptions) -> FastFieldOptions {
+        match (self, other) {
+            (
+                FastFieldOptions::EnabledWithTokenizer {
+                    with_tokenizer: tokenizer,
+                },
+                _,
+            )
+            | (
+                _,
+                FastFieldOptions::EnabledWithTokenizer {
+                    with_tokenizer: tokenizer,
+                },
+            ) => FastFieldOptions::EnabledWithTokenizer {
+                with_tokenizer: tokenizer,
+            },
+            (FastFieldOptions::IsEnabled(true), _) | (_, FastFieldOptions::IsEnabled(true)) => {
+                FastFieldOptions::IsEnabled(true)
+            }
+            (_, FastFieldOptions::IsEnabled(false)) => FastFieldOptions::IsEnabled(false),
+        }
+    }
+}
+
 fn is_false(val: &bool) -> bool {
     !val
 }
@@ -40,7 +80,21 @@ impl TextOptions {
 
     /// Returns true if and only if the value is a fast field.
     pub fn is_fast(&self) -> bool {
-        self.fast
+        matches!(self.fast, FastFieldOptions::IsEnabled(true))
+            || matches!(
+                &self.fast,
+                FastFieldOptions::EnabledWithTokenizer { with_tokenizer: _ }
+            )
+    }
+
+    /// Returns true if and only if the value is a fast field.
+    pub fn get_fast_field_tokenizer_name(&self) -> Option<&str> {
+        match &self.fast {
+            FastFieldOptions::IsEnabled(true) | FastFieldOptions::IsEnabled(false) => None,
+            FastFieldOptions::EnabledWithTokenizer {
+                with_tokenizer: tokenizer,
+            } => Some(tokenizer.name()),
+        }
     }
 
     /// Returns true if values should be coerced to strings (numbers, null).
@@ -53,19 +107,24 @@ impl TextOptions {
     /// Fast fields are designed for random access.
     /// Access time are similar to a random lookup in an array.
     /// Text fast fields will have the term ids stored in the fast field.
-    /// The fast field will be a multivalued fast field.
     ///
-    /// The effective cardinality depends on the tokenizer. When creating fast fields on text
-    /// fields it is recommended to use the "raw" tokenizer, since it will store the original text
-    /// unchanged. The "default" tokenizer will store the terms as lower case and this will be
-    /// reflected in the dictionary.
+    /// The effective cardinality depends on the tokenizer. Without a tokenizer, the text will be
+    /// stored as is, which equals to the "raw" tokenizer. The tokenizer can be used to apply
+    /// normalization like lower case.
     ///
     /// The original text can be retrieved via
     /// [`TermDictionary::ord_to_term()`](crate::termdict::TermDictionary::ord_to_term)
     /// from the dictionary.
     #[must_use]
-    pub fn set_fast(mut self) -> TextOptions {
-        self.fast = true;
+    pub fn set_fast(mut self, tokenizer_name: Option<&str>) -> TextOptions {
+        if let Some(tokenizer) = tokenizer_name {
+            let tokenizer = TokenizerName::from_name(tokenizer);
+            self.fast = FastFieldOptions::EnabledWithTokenizer {
+                with_tokenizer: tokenizer,
+            }
+        } else {
+            self.fast = FastFieldOptions::IsEnabled(true);
+        }
         self
     }
 
@@ -92,7 +151,7 @@ impl TextOptions {
 }
 
 #[derive(Clone, PartialEq, Debug, Eq, Serialize, Deserialize)]
-struct TokenizerName(Cow<'static, str>);
+pub(crate) struct TokenizerName(Cow<'static, str>);
 
 const DEFAULT_TOKENIZER_NAME: &str = "default";
 
@@ -105,7 +164,7 @@ impl Default for TokenizerName {
 }
 
 impl TokenizerName {
-    const fn from_static(name: &'static str) -> Self {
+    pub const fn from_static(name: &'static str) -> Self {
         TokenizerName(Cow::Borrowed(name))
     }
     fn from_name(name: &str) -> Self {
@@ -199,7 +258,7 @@ pub const STRING: TextOptions = TextOptions {
         record: IndexRecordOption::Basic,
     }),
     stored: false,
-    fast: false,
+    fast: FastFieldOptions::IsEnabled(false),
     coerce: false,
 };
 
@@ -212,7 +271,7 @@ pub const TEXT: TextOptions = TextOptions {
     }),
     stored: false,
     coerce: false,
-    fast: false,
+    fast: FastFieldOptions::IsEnabled(false),
 };
 
 impl<T: Into<TextOptions>> BitOr<T> for TextOptions {
@@ -240,7 +299,7 @@ impl From<StoredFlag> for TextOptions {
         TextOptions {
             indexing: None,
             stored: true,
-            fast: false,
+            fast: FastFieldOptions::IsEnabled(false),
             coerce: false,
         }
     }
@@ -251,7 +310,7 @@ impl From<CoerceFlag> for TextOptions {
         TextOptions {
             indexing: None,
             stored: false,
-            fast: false,
+            fast: FastFieldOptions::IsEnabled(false),
             coerce: true,
         }
     }
@@ -262,7 +321,7 @@ impl From<FastFlag> for TextOptions {
         TextOptions {
             indexing: None,
             stored: false,
-            fast: true,
+            fast: FastFieldOptions::IsEnabled(true),
             coerce: false,
         }
     }
@@ -281,6 +340,7 @@ where
 
 #[cfg(test)]
 mod tests {
+    use crate::schema::text_options::{FastFieldOptions, TokenizerName};
     use crate::schema::*;
 
     #[test]
@@ -323,4 +383,44 @@ mod tests {
         let options3: TextOptions = serde_json::from_str("{}").unwrap();
         assert_eq!(options3.indexing, None);
     }
+
+    #[test]
+    fn serde_fast_field_tokenizer() {
+        let json = r#" {
+            "fast": { "with_tokenizer": "default" }
+        } "#;
+        let options: TextOptions = serde_json::from_str(json).unwrap();
+        assert_eq!(
+            options.fast,
+            FastFieldOptions::EnabledWithTokenizer {
+                with_tokenizer: TokenizerName::from_static("default")
+            }
+        );
+        let options: TextOptions =
+            serde_json::from_str(&serde_json::to_string(&options).unwrap()).unwrap();
+        assert_eq!(
+            options.fast,
+            FastFieldOptions::EnabledWithTokenizer {
+                with_tokenizer: TokenizerName::from_static("default")
+            }
+        );
+
+        let json = r#" {
+            "fast": true
+        } "#;
+        let options: TextOptions = serde_json::from_str(json).unwrap();
+        assert_eq!(options.fast, FastFieldOptions::IsEnabled(true));
+        let options: TextOptions =
+            serde_json::from_str(&serde_json::to_string(&options).unwrap()).unwrap();
+        assert_eq!(options.fast, FastFieldOptions::IsEnabled(true));
+
+        let json = r#" {
+            "fast": false
+        } "#;
+        let options: TextOptions = serde_json::from_str(json).unwrap();
+        assert_eq!(options.fast, FastFieldOptions::IsEnabled(false));
+        let options: TextOptions =
+            serde_json::from_str(&serde_json::to_string(&options).unwrap()).unwrap();
+        assert_eq!(options.fast, FastFieldOptions::IsEnabled(false));
+    }
 }

src/tokenizer/simple_tokenizer.rs

@@ -2,7 +2,8 @@ use std::str::CharIndices;
 
 use super::{Token, TokenStream, Tokenizer};
 
-/// Tokenize the text by splitting on whitespaces and punctuation.
+/// Tokenize the text by returning only tokens of consecutive
+/// [`alphanumeric`](char::is_alphanumeric).
 #[derive(Clone)]
 pub struct SimpleTokenizer;
 

src/tokenizer/tokenizer_manager.rs

@@ -13,9 +13,8 @@ use crate::tokenizer::{
 /// By default, it is populated with the following managers.
 ///
 ///  * `raw` : does not process nor tokenize the text.
-///  * `default` : Chops the text on according to whitespace and
-///  punctuation, removes tokens that are too long, and lowercases
-///  tokens
+///  * `default` : Chops the text according to [`SimpleTokenizer`],
+///  removes tokens that are longer than 40, and lowercases tokens
 ///  * `en_stem` : Like `default`, but also applies stemming on the
 ///  resulting tokens. Stemming can improve the recall of your
 ///  search engine.
@@ -35,7 +34,9 @@ impl TokenizerManager {
 
     /// Registers a new tokenizer associated with a given name.
     pub fn register<T>(&self, tokenizer_name: &str, tokenizer: T)
-    where TextAnalyzer: From<T> {
+    where
+        TextAnalyzer: From<T>,
+    {
         let boxed_tokenizer: TextAnalyzer = TextAnalyzer::from(tokenizer);
         self.tokenizers
             .write()