handle exlusive out of bounds ranges on fastfield range queries

closes quickwit-oss/quickwit#3790

Author: PSeitz

src/query/range_query/range_query_u64_fastfield.rs

@@ -76,12 +76,14 @@ impl Weight for FastFieldRangeWeight {
         else {
             return Ok(Box::new(EmptyScorer));
         };
+        #[allow(clippy::reversed_empty_ranges)]
         let value_range = bound_to_value_range(
             &self.lower_bound,
             &self.upper_bound,
             column.min_value(),
             column.max_value(),
-        );
+        )
+        .unwrap_or(1..=0); // empty range
         if value_range.is_empty() {
             return Ok(Box::new(EmptyScorer));
         }
@@ -102,26 +104,28 @@ impl Weight for FastFieldRangeWeight {
     }
 }
 
+// Returns None, if the range cannot be converted to a inclusive range (which equals to a empty
+// range).
 fn bound_to_value_range<T: MonotonicallyMappableToU64>(
     lower_bound: &Bound<T>,
     upper_bound: &Bound<T>,
     min_value: T,
     max_value: T,
-) -> RangeInclusive<T> {
+) -> Option<RangeInclusive<T>> {
     let mut start_value = match lower_bound {
         Bound::Included(val) => *val,
-        Bound::Excluded(val) => T::from_u64(val.to_u64() + 1),
+        Bound::Excluded(val) => T::from_u64(val.to_u64().checked_add(1)?),
         Bound::Unbounded => min_value,
     };
     if start_value.partial_cmp(&min_value) == Some(std::cmp::Ordering::Less) {
         start_value = min_value;
     }
     let end_value = match upper_bound {
         Bound::Included(val) => *val,
-        Bound::Excluded(val) => T::from_u64(val.to_u64() - 1),
+        Bound::Excluded(val) => T::from_u64(val.to_u64().checked_sub(1)?),
         Bound::Unbounded => max_value,
     };
-    start_value..=end_value
+    Some(start_value..=end_value)
 }
 
 #[cfg(test)]
@@ -295,6 +299,9 @@ pub mod tests {
         let gen_query_inclusive = |field: &str, range: RangeInclusive<u64>| {
             format!("{}:[{} TO {}]", field, range.start(), range.end())
         };
+        let gen_query_exclusive = |field: &str, range: RangeInclusive<u64>| {
+            format!("{}:{{{} TO {}}}", field, range.start(), range.end())
+        };
 
         let test_sample = |sample_docs: Vec<Doc>| {
             let mut ids: Vec<u64> = sample_docs.iter().map(|doc| doc.id).collect();
@@ -310,6 +317,20 @@ pub mod tests {
             let query = gen_query_inclusive("ids", ids[0]..=ids[1]);
             assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
 
+            // Exclusive range
+            let expected_num_hits = docs
+                .iter()
+                .filter(|doc| {
+                    (ids[0].saturating_add(1)..=ids[1].saturating_sub(1)).contains(&doc.id)
+                })
+                .count();
+
+            let query = gen_query_exclusive("id", ids[0]..=ids[1]);
+            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
+
+            let query = gen_query_exclusive("ids", ids[0]..=ids[1]);
+            assert_eq!(get_num_hits(query_from_text(&query)), expected_num_hits);
+
             // Intersection search
             let id_filter = sample_docs[0].id_name.to_string();
             let expected_num_hits = docs

src/schema/term.rs

@@ -419,7 +419,7 @@ where B: AsRef<[u8]>
         let pos = bytes.iter().cloned().position(|b| b == JSON_END_OF_PATH)?;
         // split at pos + 1, so that json_path_bytes includes the JSON_END_OF_PATH byte.
         let (json_path_bytes, term) = bytes.split_at(pos + 1);
-        Some((json_path_bytes, ValueBytes::wrap(&term)))
+        Some((json_path_bytes, ValueBytes::wrap(term)))
     }
 
     /// Returns the encoded ValueBytes after the json path.