add FastFieldRangeQuery, rename (#2477)

* add FastFieldRangeQuery, rename

* remove Query impl

src/query/range_query/mod.rs

@@ -2,10 +2,12 @@ use crate::schema::Type;
 
 mod fast_field_range_doc_set;
 mod range_query;
-mod range_query_u64_fastfield;
+mod range_query_fastfield;
+
+pub use common::bounds::BoundsRange;
 
 pub use self::range_query::*;
-pub use self::range_query_u64_fastfield::FastFieldRangeWeight;
+pub use self::range_query_fastfield::*;
 
 // TODO is this correct?
 pub(crate) fn is_type_valid_for_fastfield_range_query(typ: Type) -> bool {

src/query/range_query/range_query.rs

@@ -4,7 +4,7 @@ use std::ops::Bound;
 use common::bounds::{map_bound, BoundsRange};
 use common::BitSet;
 
-use super::range_query_u64_fastfield::FastFieldRangeWeight;
+use super::range_query_fastfield::FastFieldRangeWeight;
 use crate::index::SegmentReader;
 use crate::query::explanation::does_not_match;
 use crate::query::range_query::is_type_valid_for_fastfield_range_query;

src/query/range_query/range_query_fastfield.rs

@@ -12,10 +12,32 @@ use columnar::{
 use common::bounds::{BoundsRange, TransformBound};
 
 use super::fast_field_range_doc_set::RangeDocSet;
-use crate::query::{AllScorer, ConstScorer, EmptyScorer, Explanation, Query, Scorer, Weight};
+use crate::query::{
+    AllScorer, ConstScorer, EmptyScorer, EnableScoring, Explanation, Query, Scorer, Weight,
+};
 use crate::schema::{Type, ValueBytes};
 use crate::{DocId, DocSet, Score, SegmentReader, TantivyError, Term};
 
+#[derive(Clone, Debug)]
+/// `FastFieldRangeQuery` is the same as [RangeQuery] but only uses the fast field
+pub struct FastFieldRangeQuery {
+    bounds: BoundsRange<Term>,
+}
+impl FastFieldRangeQuery {
+    /// Create new `FastFieldRangeQuery`
+    pub fn new(lower_bound: Bound<Term>, upper_bound: Bound<Term>) -> FastFieldRangeQuery {
+        Self {
+            bounds: BoundsRange::new(lower_bound, upper_bound),
+        }
+    }
+}
+
+impl Query for FastFieldRangeQuery {
+    fn weight(&self, _enable_scoring: EnableScoring<'_>) -> crate::Result<Box<dyn Weight>> {
+        Ok(Box::new(FastFieldRangeWeight::new(self.bounds.clone())))
+    }
+}
+
 /// `FastFieldRangeWeight` uses the fast field to execute range queries.
 #[derive(Clone, Debug)]
 pub struct FastFieldRangeWeight {
@@ -24,20 +46,11 @@ pub struct FastFieldRangeWeight {
 
 impl FastFieldRangeWeight {
     /// Create a new FastFieldRangeWeight
-    pub(crate) fn new(bounds: BoundsRange<Term>) -> Self {
+    pub fn new(bounds: BoundsRange<Term>) -> Self {
         Self { bounds }
     }
 }
 
-impl Query for FastFieldRangeWeight {
-    fn weight(
-        &self,
-        _enable_scoring: crate::query::EnableScoring<'_>,
-    ) -> crate::Result<Box<dyn Weight>> {
-        Ok(Box::new(self.clone()))
-    }
-}
-
 impl Weight for FastFieldRangeWeight {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
         // Check if both bounds are Bound::Unbounded
@@ -49,7 +62,8 @@ impl Weight for FastFieldRangeWeight {
             .bounds
             .get_inner()
             .expect("At least one bound must be set");
-        let field_type = reader.schema().get_field_entry(term.field()).field_type();
+        let schema = reader.schema();
+        let field_type = schema.get_field_entry(term.field()).field_type();
         assert_eq!(
             term.typ(),
             field_type.value_type(),
@@ -471,7 +485,7 @@ pub mod tests {
 
     use crate::collector::{Count, TopDocs};
     use crate::fastfield::FastValue;
-    use crate::query::range_query::range_query_u64_fastfield::FastFieldRangeWeight;
+    use crate::query::range_query::range_query_fastfield::FastFieldRangeWeight;
     use crate::query::{QueryParser, RangeQuery, Weight};
     use crate::schema::{
         DateOptions, Field, NumericOptions, Schema, SchemaBuilder, FAST, INDEXED, STORED, STRING,