Added solution to force the type of a column.

columnar/src/columnar/writer/column_writers.rs

@@ -102,18 +102,29 @@ pub(crate) struct NumericalColumnWriter {
     column_writer: ColumnWriter,
 }
 
+impl NumericalColumnWriter {
+    pub fn force_numerical_type(&mut self, numerical_type: NumericalType) {
+        assert!(self
+            .compatible_numerical_types
+            .is_type_accepted(numerical_type));
+        self.compatible_numerical_types = CompatibleNumericalTypes::StaticType(numerical_type);
+    }
+}
+
 /// State used to store what types are still acceptable
 /// after having seen a set of numerical values.
 #[derive(Clone, Copy)]
-struct CompatibleNumericalTypes {
-    all_values_within_i64_range: bool,
-    all_values_within_u64_range: bool,
-    // f64 is always acceptable.
+enum CompatibleNumericalTypes {
+    Dynamic {
+        all_values_within_i64_range: bool,
+        all_values_within_u64_range: bool,
+    },
+    StaticType(NumericalType),
 }
 
 impl Default for CompatibleNumericalTypes {
     fn default() -> CompatibleNumericalTypes {
-        CompatibleNumericalTypes {
+        CompatibleNumericalTypes::Dynamic {
             all_values_within_i64_range: true,
             all_values_within_u64_range: true,
         }
@@ -121,31 +132,54 @@ impl Default for CompatibleNumericalTypes {
 }
 
 impl CompatibleNumericalTypes {
+    fn is_type_accepted(&self, numerical_type: NumericalType) -> bool {
+        match self {
+            CompatibleNumericalTypes::Dynamic {
+                all_values_within_i64_range,
+                all_values_within_u64_range,
+            } => match numerical_type {
+                NumericalType::I64 => *all_values_within_i64_range,
+                NumericalType::U64 => *all_values_within_u64_range,
+                NumericalType::F64 => true,
+            },
+            CompatibleNumericalTypes::StaticType(static_numerical_type) => {
+                *static_numerical_type == numerical_type
+            }
+        }
+    }
+
     fn accept_value(&mut self, numerical_value: NumericalValue) {
-        match numerical_value {
-            NumericalValue::I64(val_i64) => {
-                let value_within_u64_range = val_i64 >= 0i64;
-                self.all_values_within_u64_range &= value_within_u64_range;
-            }
-            NumericalValue::U64(val_u64) => {
-                let value_within_i64_range = val_u64 < i64::MAX as u64;
-                self.all_values_within_i64_range &= value_within_i64_range;
-            }
-            NumericalValue::F64(_) => {
-                self.all_values_within_i64_range = false;
-                self.all_values_within_u64_range = false;
+        match self {
+            CompatibleNumericalTypes::Dynamic {
+                all_values_within_i64_range,
+                all_values_within_u64_range,
+            } => match numerical_value {
+                NumericalValue::I64(val_i64) => {
+                    let value_within_u64_range = val_i64 >= 0i64;
+                    *all_values_within_u64_range &= value_within_u64_range;
+                }
+                NumericalValue::U64(val_u64) => {
+                    let value_within_i64_range = val_u64 < i64::MAX as u64;
+                    *all_values_within_i64_range &= value_within_i64_range;
+                }
+                NumericalValue::F64(_) => {
+                    *all_values_within_i64_range = false;
+                    *all_values_within_u64_range = false;
+                }
+            },
+            CompatibleNumericalTypes::StaticType(typ) => {
+                assert_eq!(numerical_value.numerical_type(), *typ);
             }
         }
     }
 
     pub fn to_numerical_type(self) -> NumericalType {
-        if self.all_values_within_i64_range {
-            NumericalType::I64
-        } else if self.all_values_within_u64_range {
-            NumericalType::U64
-        } else {
-            NumericalType::F64
+        for numerical_type in [NumericalType::I64, NumericalType::U64] {
+            if self.is_type_accepted(numerical_type) {
+                return numerical_type;
+            }
         }
+        NumericalType::F64
     }
 }
 
@@ -262,4 +296,27 @@ mod tests {
         test_column_writer_coercion_aux(&[1i64.into(), 1u64.into()], NumericalType::I64);
         test_column_writer_coercion_aux(&[u64::MAX.into(), (-1i64).into()], NumericalType::F64);
     }
+
+    #[test]
+    #[should_panic]
+    fn test_compatible_numerical_types_static_incompatible_type() {
+        let mut compatible_numerical_types =
+            CompatibleNumericalTypes::StaticType(NumericalType::U64);
+        compatible_numerical_types.accept_value(NumericalValue::I64(1i64));
+    }
+
+    #[test]
+    fn test_compatible_numerical_types_static_different_type_forbidden() {
+        let mut compatible_numerical_types =
+            CompatibleNumericalTypes::StaticType(NumericalType::U64);
+        compatible_numerical_types.accept_value(NumericalValue::U64(u64::MAX));
+    }
+
+    #[test]
+    fn test_compatible_numerical_types_static() {
+        for typ in [NumericalType::I64, NumericalType::I64, NumericalType::F64] {
+            let compatible_numerical_types = CompatibleNumericalTypes::StaticType(typ);
+            assert_eq!(compatible_numerical_types.to_numerical_type(), typ);
+        }
+    }
 }

columnar/src/columnar/writer/mod.rs

@@ -68,20 +68,46 @@ impl Default for ColumnarWriter {
     }
 }
 
+#[inline]
+fn mutate_or_create_column<V, TMutator>(
+    arena_hash_map: &mut ArenaHashMap,
+    column_name: &str,
+    updater: TMutator,
+) where
+    V: Copy + 'static,
+    TMutator: FnMut(Option<V>) -> V,
+{
+    assert!(
+        !column_name.as_bytes().contains(&0u8),
+        "key may not contain the 0 byte"
+    );
+    arena_hash_map.mutate_or_create(column_name.as_bytes(), updater);
+}
+
 impl ColumnarWriter {
+    pub fn force_numerical_type(&mut self, column_name: &str, numerical_type: NumericalType) {
+        let (hash_map, _) = (&mut self.numerical_field_hash_map, &mut self.arena);
+        mutate_or_create_column(
+            hash_map,
+            column_name,
+            |column_opt: Option<NumericalColumnWriter>| {
+                let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
+                column.force_numerical_type(numerical_type);
+                column
+            },
+        );
+    }
+
     pub fn record_numerical<T: Into<NumericalValue> + Copy>(
         &mut self,
         doc: RowId,
         column_name: &str,
         numerical_value: T,
     ) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
         let (hash_map, arena) = (&mut self.numerical_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
+        mutate_or_create_column(
+            hash_map,
+            column_name,
             |column_opt: Option<NumericalColumnWriter>| {
                 let mut column: NumericalColumnWriter = column_opt.unwrap_or_default();
                 column.record_numerical_value(doc, numerical_value.into(), arena);
@@ -91,33 +117,23 @@ impl ColumnarWriter {
     }
 
     pub fn record_bool(&mut self, doc: RowId, column_name: &str, val: bool) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
         let (hash_map, arena) = (&mut self.bool_field_hash_map, &mut self.arena);
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
-            |column_opt: Option<ColumnWriter>| {
-                let mut column: ColumnWriter = column_opt.unwrap_or_default();
-                column.record(doc, val, arena);
-                column
-            },
-        );
+        mutate_or_create_column(hash_map, column_name, |column_opt: Option<ColumnWriter>| {
+            let mut column: ColumnWriter = column_opt.unwrap_or_default();
+            column.record(doc, val, arena);
+            column
+        });
     }
 
     pub fn record_str(&mut self, doc: RowId, column_name: &str, value: &str) {
-        assert!(
-            !column_name.as_bytes().contains(&0u8),
-            "key may not contain the 0 byte"
-        );
         let (hash_map, arena, dictionaries) = (
             &mut self.bytes_field_hash_map,
             &mut self.arena,
             &mut self.dictionaries,
         );
-        hash_map.mutate_or_create(
-            column_name.as_bytes(),
+        mutate_or_create_column(
+            hash_map,
+            column_name,
             |column_opt: Option<StrColumnWriter>| {
                 let mut column: StrColumnWriter = column_opt.unwrap_or_else(|| {
                     // Each column has its own dictionary

examples/custom_collector.rs

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

examples/integer_range_search.rs

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

examples/warmer.rs

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

src/aggregation/agg_req_with_accessor.rs

@@ -94,7 +94,10 @@ impl BucketAggregationWithAccessor {
             BucketAggregationType::Terms(TermsAggregation {
                 field: field_name, ..
             }) => {
-                let field = reader.schema().get_field(field_name)?;
+                let field = reader
+                    .schema()
+                    .get_field(field_name)
+                    .ok_or_else(|| TantivyError::FieldNotFound(field_name.to_string()))?;
                 inverted_index = Some(reader.inverted_index(field)?);
                 get_ff_reader_and_validate(reader, field_name, Cardinality::MultiValues)?
             }
@@ -192,7 +195,10 @@ fn get_ff_reader_and_validate(
     field_name: &str,
     cardinality: Cardinality,
 ) -> crate::Result<(FastFieldAccessor, Type)> {
-    let field = reader.schema().get_field(field_name)?;
+    let field = reader
+        .schema()
+        .get_field(field_name)
+        .ok_or_else(|| TantivyError::FieldNotFound(field_name.to_string()))?;
     let field_type = reader.schema().get_field_entry(field).field_type();
 
     if let Some((_ff_type, field_cardinality)) = type_and_cardinality(field_type) {
@@ -212,10 +218,10 @@ fn get_ff_reader_and_validate(
     let ff_fields = reader.fast_fields();
     match cardinality {
         Cardinality::SingleValue => ff_fields
-            .u64_lenient(field_name)
+            .u64_lenient(field)
             .map(|field| (FastFieldAccessor::Single(field), field_type.value_type())),
         Cardinality::MultiValues => ff_fields
-            .u64s_lenient(field_name)
+            .u64s_lenient(field)
             .map(|field| (FastFieldAccessor::Multi(field), field_type.value_type())),
     }
 }

src/aggregation/bucket/histogram/histogram.rs

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

src/aggregation/intermediate_agg_result.rs

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

src/collector/filter_collector_wrapper.rs

@@ -130,7 +130,7 @@ where
 
         let fast_field_reader = segment_reader
             .fast_fields()
-            .typed_fast_field_reader(schema.get_field_name(self.field))?;
+            .typed_fast_field_reader(self.field)?;
 
         let segment_collector = self
             .collector

src/collector/histogram_collector.rs

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

src/collector/tests.rs

@@ -155,7 +155,7 @@ impl SegmentCollector for TestSegmentCollector {
 ///
 /// This collector is mainly useful for tests.
 pub struct FastFieldTestCollector {
-    field: String,
+    field: Field,
 }
 
 pub struct FastFieldSegmentCollector {
@@ -164,7 +164,7 @@ pub struct FastFieldSegmentCollector {
 }
 
 impl FastFieldTestCollector {
-    pub fn for_field(field: String) -> FastFieldTestCollector {
+    pub fn for_field(field: Field) -> FastFieldTestCollector {
         FastFieldTestCollector { field }
     }
 }
@@ -180,7 +180,7 @@ impl Collector for FastFieldTestCollector {
     ) -> crate::Result<FastFieldSegmentCollector> {
         let reader = segment_reader
             .fast_fields()
-            .u64(&self.field)
+            .u64(self.field)
             .expect("Requested field is not a fast field.");
         Ok(FastFieldSegmentCollector {
             vals: Vec::new(),
@@ -238,9 +238,7 @@ impl Collector for BytesFastFieldTestCollector {
         _segment_local_id: u32,
         segment_reader: &SegmentReader,
     ) -> crate::Result<BytesFastFieldSegmentCollector> {
-        let reader = segment_reader
-            .fast_fields()
-            .bytes(segment_reader.schema().get_field_name(self.field))?;
+        let reader = segment_reader.fast_fields().bytes(self.field)?;
         Ok(BytesFastFieldSegmentCollector {
             vals: Vec::new(),
             reader,

src/collector/top_score_collector.rs

@@ -156,7 +156,7 @@ impl CustomScorer<u64> for ScorerByField {
         // The conversion will then happen only on the top-K docs.
         let ff_reader = segment_reader
             .fast_fields()
-            .typed_fast_field_reader(segment_reader.schema().get_field_name(self.field))?;
+            .typed_fast_field_reader(self.field)?;
         Ok(ScorerByFastFieldReader { ff_reader })
     }
 }
@@ -454,7 +454,7 @@ impl TopDocs {
     ///             // In our case, we will get a reader for the popularity
     ///             // fast field.
     ///             let popularity_reader =
-    ///                 segment_reader.fast_fields().u64("popularity").unwrap();
+    ///                 segment_reader.fast_fields().u64(popularity).unwrap();
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId, original_score: Score| {
@@ -561,9 +561,9 @@ impl TopDocs {
     ///             // Note that this is implemented by using a `(u64, u64)`
     ///             // as a score.
     ///             let popularity_reader =
-    ///                 segment_reader.fast_fields().u64("popularity").unwrap();
+    ///                 segment_reader.fast_fields().u64(popularity).unwrap();
     ///             let boosted_reader =
-    ///                 segment_reader.fast_fields().u64("boosted").unwrap();
+    ///                 segment_reader.fast_fields().u64(boosted).unwrap();
     ///
     ///             // We can now define our actual scoring function
     ///             move |doc: DocId| {

src/core/index.rs

@@ -231,7 +231,7 @@ impl IndexBuilder {
     fn validate(&self) -> crate::Result<()> {
         if let Some(schema) = self.schema.as_ref() {
             if let Some(sort_by_field) = self.index_settings.sort_by_field.as_ref() {
-                let schema_field = schema.get_field(&sort_by_field.field).map_err(|_| {
+                let schema_field = schema.get_field(&sort_by_field.field).ok_or_else(|| {
                     TantivyError::InvalidArgument(format!(
                         "Field to sort index {} not found in schema",
                         sort_by_field.field

src/core/segment_reader.rs

@@ -95,8 +95,7 @@ impl SegmentReader {
 
         match field_entry.field_type() {
             FieldType::Facet(_) => {
-                let term_ords_reader =
-                    self.fast_fields().u64s(self.schema.get_field_name(field))?;
+                let term_ords_reader = self.fast_fields().u64s(field)?;
                 let termdict = self
                     .termdict_composite
                     .open_read(field)

src/fastfield/bytes/mod.rs

@@ -25,7 +25,7 @@ mod tests {
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
         let segment_reader = searcher.segment_reader(0);
-        let bytes_reader = segment_reader.fast_fields().bytes("bytesfield").unwrap();
+        let bytes_reader = segment_reader.fast_fields().bytes(bytes_field).unwrap();
         assert_eq!(bytes_reader.get_bytes(0), &[0u8, 1, 2, 3]);
         assert!(bytes_reader.get_bytes(1).is_empty());
         assert_eq!(bytes_reader.get_bytes(2), &[255u8]);
@@ -109,7 +109,8 @@ mod tests {
         let searcher = create_index_for_test(FAST)?;
         assert_eq!(searcher.num_docs(), 1);
         let fast_fields = searcher.segment_reader(0u32).fast_fields();
-        let fast_field_reader = fast_fields.bytes("string_bytes").unwrap();
+        let field = searcher.schema().get_field("string_bytes").unwrap();
+        let fast_field_reader = fast_fields.bytes(field).unwrap();
         assert_eq!(fast_field_reader.get_bytes(0u32), b"tantivy");
         Ok(())
     }

src/fastfield/mod.rs

@@ -583,7 +583,7 @@ mod tests {
             assert_eq!(searcher.segment_readers().len(), 1);
             let segment_reader = searcher.segment_reader(0);
             let fast_fields = segment_reader.fast_fields();
-            let text_fast_field = fast_fields.u64s("text").unwrap();
+            let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
             assert_eq!(
                 get_vals_for_docs(&text_fast_field, 0..5),
@@ -622,7 +622,7 @@ mod tests {
             assert_eq!(searcher.segment_readers().len(), 2);
             let segment_reader = searcher.segment_reader(1);
             let fast_fields = segment_reader.fast_fields();
-            let text_fast_field = fast_fields.u64s("text").unwrap();
+            let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
             assert_eq!(get_vals_for_docs(&text_fast_field, 0..3), vec![0, 1, 0]);
         }
@@ -638,7 +638,7 @@ mod tests {
         let searcher = reader.searcher();
         let segment_reader = searcher.segment_reader(0);
         let fast_fields = segment_reader.fast_fields();
-        let text_fast_field = fast_fields.u64s("text").unwrap();
+        let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
         assert_eq!(
             get_vals_for_docs(&text_fast_field, 0..8),
@@ -681,7 +681,7 @@ mod tests {
             assert_eq!(searcher.segment_readers().len(), 1);
             let segment_reader = searcher.segment_reader(0);
             let fast_fields = segment_reader.fast_fields();
-            let text_fast_field = fast_fields.u64s("text").unwrap();
+            let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
             assert_eq!(get_vals_for_docs(&text_fast_field, 0..6), vec![1, 0, 0, 2]);
 
@@ -712,7 +712,7 @@ mod tests {
             assert_eq!(searcher.segment_readers().len(), 2);
             let segment_reader = searcher.segment_reader(1);
             let fast_fields = segment_reader.fast_fields();
-            let text_fast_field = fast_fields.u64s("text").unwrap();
+            let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
             assert_eq!(get_vals_for_docs(&text_fast_field, 0..2), vec![0, 1]);
         }
@@ -728,7 +728,7 @@ mod tests {
         let searcher = reader.searcher();
         let segment_reader = searcher.segment_reader(0);
         let fast_fields = segment_reader.fast_fields();
-        let text_fast_field = fast_fields.u64s("text").unwrap();
+        let text_fast_field = fast_fields.u64s(text_field).unwrap();
 
         assert_eq!(
             get_vals_for_docs(&text_fast_field, 0..9),
@@ -773,8 +773,8 @@ mod tests {
         assert_eq!(searcher.segment_readers().len(), 1);
         let segment_reader = searcher.segment_reader(0);
         let fast_fields = segment_reader.fast_fields();
-        let date_fast_field = fast_fields.date("date").unwrap();
-        let dates_fast_field = fast_fields.dates("multi_date").unwrap();
+        let date_fast_field = fast_fields.date(date_field).unwrap();
+        let dates_fast_field = fast_fields.dates(multi_date_field).unwrap();
         let mut dates = vec![];
         {
             assert_eq!(date_fast_field.get_val(0).into_timestamp_micros(), 1i64);
@@ -1014,7 +1014,7 @@ mod tests {
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         let segment = &searcher.segment_readers()[0];
-        let field = segment.fast_fields().u64("url_norm_hash").unwrap();
+        let field = segment.fast_fields().u64(num_field).unwrap();
 
         let numbers = vec![100, 200, 300];
         let test_range = |range: RangeInclusive<u64>| {
@@ -1063,7 +1063,7 @@ mod tests {
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         let segment = &searcher.segment_readers()[0];
-        let field = segment.fast_fields().u64("url_norm_hash").unwrap();
+        let field = segment.fast_fields().u64(num_field).unwrap();
 
         let numbers = vec![1000, 1001, 1003];
         let test_range = |range: RangeInclusive<u64>| {

src/fastfield/multivalued/mod.rs

@@ -52,7 +52,7 @@ mod tests {
         let searcher = index.reader()?.searcher();
         let segment_reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = segment_reader.fast_fields().u64s("multifield")?;
+        let multi_value_reader = segment_reader.fast_fields().u64s(field)?;
         {
             multi_value_reader.get_vals(2, &mut vals);
             assert_eq!(&vals, &[4u64]);
@@ -229,7 +229,7 @@ mod tests {
         let searcher = index.reader()?.searcher();
         let segment_reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = segment_reader.fast_fields().i64s("multifield").unwrap();
+        let multi_value_reader = segment_reader.fast_fields().i64s(field).unwrap();
         multi_value_reader.get_vals(2, &mut vals);
         assert_eq!(&vals, &[-4i64]);
         multi_value_reader.get_vals(0, &mut vals);
@@ -261,7 +261,7 @@ mod tests {
         let searcher = index.reader()?.searcher();
         let segment_reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = segment_reader.fast_fields().bools("multifield").unwrap();
+        let multi_value_reader = segment_reader.fast_fields().bools(bool_field).unwrap();
         multi_value_reader.get_vals(2, &mut vals);
         assert_eq!(&vals, &[false]);
         multi_value_reader.get_vals(0, &mut vals);

src/fastfield/multivalued/reader.rs

@@ -159,7 +159,7 @@ mod tests {
         let searcher = reader.searcher();
         let reader = searcher.segment_reader(0);
 
-        let date_ff_reader = reader.fast_fields().dates("multi_date_field").unwrap();
+        let date_ff_reader = reader.fast_fields().dates(date_field).unwrap();
         let mut docids = vec![];
         date_ff_reader.get_docids_for_value_range(
             DateTime::from_utc(first_time_stamp)..=DateTime::from_utc(two_secs_ahead),
@@ -173,7 +173,7 @@ mod tests {
 
         assert_eq!(
             count_multiples(RangeQuery::new_date(
-                "multi_date_field".to_string(),
+                date_field,
                 DateTime::from_utc(first_time_stamp)..DateTime::from_utc(two_secs_ahead)
             )),
             1
@@ -226,7 +226,7 @@ mod tests {
         let reader = searcher.segment_reader(0);
         assert_eq!(reader.num_docs(), 5);
 
-        let date_ff_reader = reader.fast_fields().dates("multi_date_field").unwrap();
+        let date_ff_reader = reader.fast_fields().dates(date_field).unwrap();
         let mut docids = vec![];
         date_ff_reader.get_docids_for_value_range(
             DateTime::from_utc(first_time_stamp)..=DateTime::from_utc(two_secs_ahead),
@@ -240,7 +240,7 @@ mod tests {
 
         assert_eq!(
             count_multiples(RangeQuery::new_date(
-                "multi_date_field".to_string(),
+                date_field,
                 DateTime::from_utc(first_time_stamp)..DateTime::from_utc(two_secs_ahead)
             )),
             2
@@ -324,7 +324,7 @@ mod tests {
         index_writer.commit()?;
         let searcher = index.reader()?.searcher();
         let segment_reader = searcher.segment_reader(0);
-        let field_reader = segment_reader.fast_fields().i64s("items")?;
+        let field_reader = segment_reader.fast_fields().i64s(item_field)?;
 
         assert_eq!(field_reader.min_value(), -2);
         assert_eq!(field_reader.max_value(), 6);

src/fastfield/readers.rs

@@ -114,11 +114,9 @@ impl FastFieldReaders {
 
     pub(crate) fn typed_fast_field_reader_with_idx<TFastValue: FastValue>(
         &self,
-        field_name: &str,
+        field: Field,
         index: usize,
     ) -> crate::Result<Arc<dyn Column<TFastValue>>> {
-        let field = self.schema.get_field(field_name)?;
-
         let fast_field_slice = self.fast_field_data(field, index)?;
         let bytes = fast_field_slice.read_bytes()?;
         let column = fastfield_codecs::open(bytes)?;
@@ -127,37 +125,32 @@ impl FastFieldReaders {
 
     pub(crate) fn typed_fast_field_reader<TFastValue: FastValue>(
         &self,
-        field_name: &str,
+        field: Field,
     ) -> crate::Result<Arc<dyn Column<TFastValue>>> {
-        self.typed_fast_field_reader_with_idx(field_name, 0)
+        self.typed_fast_field_reader_with_idx(field, 0)
     }
 
     pub(crate) fn typed_fast_field_multi_reader<TFastValue: FastValue>(
         &self,
-        field_name: &str,
+        field: Field,
     ) -> crate::Result<MultiValuedFastFieldReader<TFastValue>> {
-        let idx_reader = self.typed_fast_field_reader(field_name)?;
-        let vals_reader = self.typed_fast_field_reader_with_idx(field_name, 1)?;
+        let idx_reader = self.typed_fast_field_reader(field)?;
+        let vals_reader = self.typed_fast_field_reader_with_idx(field, 1)?;
         Ok(MultiValuedFastFieldReader::open(idx_reader, vals_reader))
     }
 
     /// Returns the `u64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a u64 fast field, this method returns an Error.
-    pub fn u64(&self, field_name: &str) -> crate::Result<Arc<dyn Column<u64>>> {
-        self.check_type(
-            self.schema.get_field(field_name)?,
-            FastType::U64,
-            Cardinality::SingleValue,
-        )?;
-        self.typed_fast_field_reader(field_name)
+    pub fn u64(&self, field: Field) -> crate::Result<Arc<dyn Column<u64>>> {
+        self.check_type(field, FastType::U64, Cardinality::SingleValue)?;
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns the `ip` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.
-    pub fn ip_addr(&self, field_name: &str) -> crate::Result<Arc<dyn Column<Ipv6Addr>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn ip_addr(&self, field: Field) -> crate::Result<Arc<dyn Column<Ipv6Addr>>> {
         self.check_type(field, FastType::U128, Cardinality::SingleValue)?;
         let bytes = self.fast_field_data(field, 0)?.read_bytes()?;
         Ok(open_u128::<Ipv6Addr>(bytes)?)
@@ -166,13 +159,9 @@ impl FastFieldReaders {
     /// Returns the `ip` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.
-    pub fn ip_addrs(
-        &self,
-        field_name: &str,
-    ) -> crate::Result<MultiValuedFastFieldReader<Ipv6Addr>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn ip_addrs(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<Ipv6Addr>> {
         self.check_type(field, FastType::U128, Cardinality::MultiValues)?;
-        let idx_reader: Arc<dyn Column<u64>> = self.typed_fast_field_reader(field_name)?;
+        let idx_reader: Arc<dyn Column<u64>> = self.typed_fast_field_reader(field)?;
 
         let bytes = self.fast_field_data(field, 1)?.read_bytes()?;
         let vals_reader = open_u128::<Ipv6Addr>(bytes)?;
@@ -183,8 +172,7 @@ impl FastFieldReaders {
     /// Returns the `u128` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.
-    pub(crate) fn u128(&self, field_name: &str) -> crate::Result<Arc<dyn Column<u128>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub(crate) fn u128(&self, field: Field) -> crate::Result<Arc<dyn Column<u128>>> {
         self.check_type(field, FastType::U128, Cardinality::SingleValue)?;
         let bytes = self.fast_field_data(field, 0)?.read_bytes()?;
         Ok(open_u128::<u128>(bytes)?)
@@ -193,11 +181,9 @@ impl FastFieldReaders {
     /// Returns the `u128` multi-valued fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 multi-valued fast field, this method returns an Error.
-    pub fn u128s(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<u128>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn u128s(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<u128>> {
         self.check_type(field, FastType::U128, Cardinality::MultiValues)?;
-        let idx_reader: Arc<dyn Column<u64>> =
-            self.typed_fast_field_reader(self.schema.get_field_name(field))?;
+        let idx_reader: Arc<dyn Column<u64>> = self.typed_fast_field_reader(field)?;
 
         let bytes = self.fast_field_data(field, 1)?.read_bytes()?;
         let vals_reader = open_u128::<u128>(bytes)?;
@@ -210,88 +196,80 @@ impl FastFieldReaders {
     ///
     /// If not, the fastfield reader will returns the u64-value associated with the original
     /// FastValue.
-    pub fn u64_lenient(&self, field_name: &str) -> crate::Result<Arc<dyn Column<u64>>> {
-        self.typed_fast_field_reader(field_name)
+    pub fn u64_lenient(&self, field: Field) -> crate::Result<Arc<dyn Column<u64>>> {
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns the `i64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a i64 fast field, this method returns an Error.
-    pub fn i64(&self, field_name: &str) -> crate::Result<Arc<dyn Column<i64>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn i64(&self, field: Field) -> crate::Result<Arc<dyn Column<i64>>> {
         self.check_type(field, FastType::I64, Cardinality::SingleValue)?;
-        self.typed_fast_field_reader(self.schema.get_field_name(field))
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns the `date` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a date fast field, this method returns an Error.
-    pub fn date(&self, field_name: &str) -> crate::Result<Arc<dyn Column<DateTime>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn date(&self, field: Field) -> crate::Result<Arc<dyn Column<DateTime>>> {
         self.check_type(field, FastType::Date, Cardinality::SingleValue)?;
-        self.typed_fast_field_reader(field_name)
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns the `f64` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a f64 fast field, this method returns an Error.
-    pub fn f64(&self, field_name: &str) -> crate::Result<Arc<dyn Column<f64>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn f64(&self, field: Field) -> crate::Result<Arc<dyn Column<f64>>> {
         self.check_type(field, FastType::F64, Cardinality::SingleValue)?;
-        self.typed_fast_field_reader(field_name)
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns the `bool` fast field reader reader associated with `field`.
     ///
     /// If `field` is not a bool fast field, this method returns an Error.
-    pub fn bool(&self, field_name: &str) -> crate::Result<Arc<dyn Column<bool>>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn bool(&self, field: Field) -> crate::Result<Arc<dyn Column<bool>>> {
         self.check_type(field, FastType::Bool, Cardinality::SingleValue)?;
-        self.typed_fast_field_reader(field_name)
+        self.typed_fast_field_reader(field)
     }
 
     /// Returns a `u64s` multi-valued fast field reader reader associated with `field`.
     ///
     /// If `field` is not a u64 multi-valued fast field, this method returns an Error.
-    pub fn u64s(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<u64>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn u64s(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<u64>> {
         self.check_type(field, FastType::U64, Cardinality::MultiValues)?;
-        self.typed_fast_field_multi_reader(field_name)
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns a `u64s` multi-valued fast field reader reader associated with `field`, regardless
     /// of whether the given field is effectively of type `u64` or not.
     ///
     /// If `field` is not a u64 multi-valued fast field, this method returns an Error.
-    pub fn u64s_lenient(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<u64>> {
-        self.typed_fast_field_multi_reader(field_name)
+    pub fn u64s_lenient(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<u64>> {
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns a `i64s` multi-valued fast field reader reader associated with `field`.
     ///
     /// If `field` is not a i64 multi-valued fast field, this method returns an Error.
-    pub fn i64s(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<i64>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn i64s(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<i64>> {
         self.check_type(field, FastType::I64, Cardinality::MultiValues)?;
-        self.typed_fast_field_multi_reader(self.schema.get_field_name(field))
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns a `f64s` multi-valued fast field reader reader associated with `field`.
     ///
     /// If `field` is not a f64 multi-valued fast field, this method returns an Error.
-    pub fn f64s(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<f64>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn f64s(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<f64>> {
         self.check_type(field, FastType::F64, Cardinality::MultiValues)?;
-        self.typed_fast_field_multi_reader(self.schema.get_field_name(field))
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns a `bools` multi-valued fast field reader reader associated with `field`.
     ///
     /// If `field` is not a bool multi-valued fast field, this method returns an Error.
-    pub fn bools(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<bool>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn bools(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<bool>> {
         self.check_type(field, FastType::Bool, Cardinality::MultiValues)?;
-        self.typed_fast_field_multi_reader(self.schema.get_field_name(field))
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns a `time::OffsetDateTime` multi-valued fast field reader reader associated with
@@ -299,17 +277,15 @@ impl FastFieldReaders {
     ///
     /// If `field` is not a `time::OffsetDateTime` multi-valued fast field, this method returns an
     /// Error.
-    pub fn dates(&self, field_name: &str) -> crate::Result<MultiValuedFastFieldReader<DateTime>> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn dates(&self, field: Field) -> crate::Result<MultiValuedFastFieldReader<DateTime>> {
         self.check_type(field, FastType::Date, Cardinality::MultiValues)?;
-        self.typed_fast_field_multi_reader(self.schema.get_field_name(field))
+        self.typed_fast_field_multi_reader(field)
     }
 
     /// Returns the `bytes` fast field reader associated with `field`.
     ///
     /// If `field` is not a bytes fast field, returns an Error.
-    pub fn bytes(&self, field_name: &str) -> crate::Result<BytesFastFieldReader> {
-        let field = self.schema.get_field(field_name)?;
+    pub fn bytes(&self, field: Field) -> crate::Result<BytesFastFieldReader> {
         let field_entry = self.schema.get_field_entry(field);
         if let FieldType::Bytes(bytes_option) = field_entry.field_type() {
             if !bytes_option.is_fast() {

src/indexer/doc_id_mapping.rs

@@ -99,7 +99,7 @@ pub(crate) fn expect_field_id_for_sort_field(
     schema: &Schema,
     sort_by_field: &IndexSortByField,
 ) -> crate::Result<Field> {
-    schema.get_field(&sort_by_field.field).map_err(|_| {
+    schema.get_field(&sort_by_field.field).ok_or_else(|| {
         TantivyError::InvalidArgument(format!(
             "field to sort index by not found: {:?}",
             sort_by_field.field
@@ -462,14 +462,15 @@ mod tests_indexsorting {
         assert_eq!(searcher.segment_readers().len(), 1);
         let segment_reader = searcher.segment_reader(0);
         let fast_fields = segment_reader.fast_fields();
-        index.schema().get_field("my_number").unwrap();
+        let my_number = index.schema().get_field("my_number").unwrap();
 
-        let fast_field = fast_fields.u64("my_number").unwrap();
+        let fast_field = fast_fields.u64(my_number).unwrap();
         assert_eq!(fast_field.get_val(0), 10u64);
         assert_eq!(fast_field.get_val(1), 20u64);
         assert_eq!(fast_field.get_val(2), 30u64);
 
-        let multifield = fast_fields.u64s("multi_numbers").unwrap();
+        let multi_numbers = index.schema().get_field("multi_numbers").unwrap();
+        let multifield = fast_fields.u64s(multi_numbers).unwrap();
         let mut vals = vec![];
         multifield.get_vals(0u32, &mut vals);
         assert_eq!(vals, &[] as &[u64]);

src/indexer/index_writer.rs

@@ -1465,7 +1465,7 @@ mod tests {
         let segment_reader = searcher.segment_reader(0);
         assert_eq!(segment_reader.num_docs(), 8);
         assert_eq!(segment_reader.max_doc(), 10);
-        let fast_field_reader = segment_reader.fast_fields().u64("id")?;
+        let fast_field_reader = segment_reader.fast_fields().u64(id_field)?;
         let in_order_alive_ids: Vec<u64> = segment_reader
             .doc_ids_alive()
             .map(|doc| fast_field_reader.get_val(doc))
@@ -1526,7 +1526,7 @@ mod tests {
         let segment_reader = searcher.segment_reader(0);
         assert_eq!(segment_reader.num_docs(), 8);
         assert_eq!(segment_reader.max_doc(), 10);
-        let fast_field_reader = segment_reader.fast_fields().u64("id")?;
+        let fast_field_reader = segment_reader.fast_fields().u64(id_field)?;
         let in_order_alive_ids: Vec<u64> = segment_reader
             .doc_ids_alive()
             .map(|doc| fast_field_reader.get_val(doc))
@@ -1778,7 +1778,7 @@ mod tests {
             .segment_readers()
             .iter()
             .flat_map(|segment_reader| {
-                let ff_reader = segment_reader.fast_fields().u64("id").unwrap();
+                let ff_reader = segment_reader.fast_fields().u64(id_field).unwrap();
                 segment_reader
                     .doc_ids_alive()
                     .map(move |doc| ff_reader.get_val(doc))
@@ -1789,7 +1789,7 @@ mod tests {
             .segment_readers()
             .iter()
             .flat_map(|segment_reader| {
-                let ff_reader = segment_reader.fast_fields().u64("id").unwrap();
+                let ff_reader = segment_reader.fast_fields().u64(id_field).unwrap();
                 segment_reader
                     .doc_ids_alive()
                     .map(move |doc| ff_reader.get_val(doc))
@@ -1804,7 +1804,7 @@ mod tests {
         let mut all_ips = Vec::new();
         let mut num_ips = 0;
         for segment_reader in searcher.segment_readers().iter() {
-            let ip_reader = segment_reader.fast_fields().ip_addrs("ips").unwrap();
+            let ip_reader = segment_reader.fast_fields().ip_addrs(ips_field).unwrap();
             for doc in segment_reader.doc_ids_alive() {
                 let mut vals = vec![];
                 ip_reader.get_vals(doc, &mut vals);
@@ -1851,7 +1851,7 @@ mod tests {
                 .segment_readers()
                 .iter()
                 .map(|segment_reader| {
-                    let ff_reader = segment_reader.fast_fields().ip_addrs("ips").unwrap();
+                    let ff_reader = segment_reader.fast_fields().ip_addrs(ips_field).unwrap();
                     ff_reader.get_index_reader().num_docs() as usize
                 })
                 .sum();
@@ -1863,7 +1863,7 @@ mod tests {
             .segment_readers()
             .iter()
             .flat_map(|segment_reader| {
-                let ff_reader = segment_reader.fast_fields().ip_addr("ip").unwrap();
+                let ff_reader = segment_reader.fast_fields().ip_addr(ip_field).unwrap();
                 segment_reader.doc_ids_alive().flat_map(move |doc| {
                     let val = ff_reader.get_val(doc);
                     if val == Ipv6Addr::from_u128(0) {
@@ -1902,7 +1902,7 @@ mod tests {
             .segment_readers()
             .iter()
             .flat_map(|segment_reader| {
-                let ff_reader = segment_reader.fast_fields().ip_addrs("ips").unwrap();
+                let ff_reader = segment_reader.fast_fields().ip_addrs(ips_field).unwrap();
                 segment_reader.doc_ids_alive().flat_map(move |doc| {
                     let mut vals = vec![];
                     ff_reader.get_vals(doc, &mut vals);
@@ -1914,9 +1914,9 @@ mod tests {
 
         // multivalue fast field tests
         for segment_reader in searcher.segment_readers().iter() {
-            let id_reader = segment_reader.fast_fields().u64("id").unwrap();
-            let ff_reader = segment_reader.fast_fields().u64s("multi_numbers").unwrap();
-            let bool_ff_reader = segment_reader.fast_fields().bools("multi_bools").unwrap();
+            let id_reader = segment_reader.fast_fields().u64(id_field).unwrap();
+            let ff_reader = segment_reader.fast_fields().u64s(multi_numbers).unwrap();
+            let bool_ff_reader = segment_reader.fast_fields().bools(multi_bools).unwrap();
             for doc in segment_reader.doc_ids_alive() {
                 let mut vals = vec![];
                 ff_reader.get_vals(doc, &mut vals);
@@ -2109,7 +2109,7 @@ mod tests {
         // test facets
         for segment_reader in searcher.segment_readers().iter() {
             let mut facet_reader = segment_reader.facet_reader(facet_field).unwrap();
-            let ff_reader = segment_reader.fast_fields().u64("id").unwrap();
+            let ff_reader = segment_reader.fast_fields().u64(id_field).unwrap();
             for doc_id in segment_reader.doc_ids_alive() {
                 let mut facet_ords = Vec::new();
                 facet_reader.facet_ords(doc_id, &mut facet_ords);

src/indexer/merger.rs

@@ -16,7 +16,7 @@ use crate::fastfield::{
     MultiValueIndex, MultiValuedFastFieldReader,
 };
 use crate::fieldnorm::{FieldNormReader, FieldNormReaders, FieldNormsSerializer, FieldNormsWriter};
-use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
+use crate::indexer::doc_id_mapping::{expect_field_id_for_sort_field, SegmentDocIdMapping};
 use crate::indexer::sorted_doc_id_column::RemappedDocIdColumn;
 use crate::indexer::sorted_doc_id_multivalue_column::RemappedDocIdMultiValueColumn;
 use crate::indexer::SegmentSerializer;
@@ -335,10 +335,8 @@ impl IndexMerger {
             .readers
             .iter()
             .map(|segment_reader| {
-                let ff_reader: MultiValuedFastFieldReader<u128> = segment_reader
-                    .fast_fields()
-                    .u128s(self.schema.get_field_name(field))
-                    .expect(
+                let ff_reader: MultiValuedFastFieldReader<u128> =
+                    segment_reader.fast_fields().u128s(field).expect(
                         "Failed to find index for multivalued field. This is a bug in tantivy, \
                          please report.",
                     );
@@ -403,13 +401,10 @@ impl IndexMerger {
             .readers
             .iter()
             .map(|reader| {
-                let u128_reader: Arc<dyn Column<u128>> = reader
-                    .fast_fields()
-                    .u128(self.schema.get_field_name(field))
-                    .expect(
-                        "Failed to find a reader for single fast field. This is a tantivy bug and \
-                         it should never happen.",
-                    );
+                let u128_reader: Arc<dyn Column<u128>> = reader.fast_fields().u128(field).expect(
+                    "Failed to find a reader for single fast field. This is a tantivy bug and it \
+                     should never happen.",
+                );
                 u128_reader
             })
             .collect::<Vec<_>>();
@@ -436,11 +431,7 @@ impl IndexMerger {
         fast_field_serializer: &mut CompositeFastFieldSerializer,
         doc_id_mapping: &SegmentDocIdMapping,
     ) -> crate::Result<()> {
-        let fast_field_accessor = RemappedDocIdColumn::new(
-            &self.readers,
-            doc_id_mapping,
-            self.schema.get_field_name(field),
-        );
+        let fast_field_accessor = RemappedDocIdColumn::new(&self.readers, doc_id_mapping, field);
         fast_field_serializer.create_auto_detect_u64_fast_field(field, fast_field_accessor)?;
 
         Ok(())
@@ -473,8 +464,8 @@ impl IndexMerger {
         reader: &SegmentReader,
         sort_by_field: &IndexSortByField,
     ) -> crate::Result<Arc<dyn Column>> {
-        reader.schema().get_field(&sort_by_field.field)?;
-        let value_accessor = reader.fast_fields().u64_lenient(&sort_by_field.field)?;
+        let field_id = expect_field_id_for_sort_field(reader.schema(), sort_by_field)?; // for now expect fastfield, but not strictly required
+        let value_accessor = reader.fast_fields().u64_lenient(field_id)?;
         Ok(value_accessor)
     }
     /// Collecting value_accessors into a vec to bind the lifetime.
@@ -578,7 +569,7 @@ impl IndexMerger {
             .map(|reader| {
                 let u64s_reader: MultiValuedFastFieldReader<u64> = reader
                     .fast_fields()
-                    .typed_fast_field_multi_reader::<u64>(self.schema.get_field_name(field))
+                    .typed_fast_field_multi_reader::<u64>(field)
                     .expect(
                         "Failed to find index for multivalued field. This is a bug in tantivy, \
                          please report.",
@@ -622,7 +613,7 @@ impl IndexMerger {
             .map(|reader| {
                 let ff_reader: MultiValuedFastFieldReader<u64> = reader
                     .fast_fields()
-                    .u64s(self.schema.get_field_name(field))
+                    .u64s(field)
                     .expect("Could not find multivalued u64 fast value reader.");
                 ff_reader
             })
@@ -693,11 +684,8 @@ impl IndexMerger {
 
         self.write_multi_value_fast_field_idx(field, fast_field_serializer, doc_id_mapping)?;
 
-        let fastfield_accessor = RemappedDocIdMultiValueColumn::new(
-            &self.readers,
-            doc_id_mapping,
-            self.schema.get_field_name(field),
-        );
+        let fastfield_accessor =
+            RemappedDocIdMultiValueColumn::new(&self.readers, doc_id_mapping, field);
         fast_field_serializer.create_auto_detect_u64_fast_field_with_idx_and_codecs(
             field,
             fastfield_accessor,
@@ -718,13 +706,10 @@ impl IndexMerger {
             .readers
             .iter()
             .map(|reader| {
-                let bytes_reader = reader
-                    .fast_fields()
-                    .bytes(self.schema.get_field_name(field))
-                    .expect(
-                        "Failed to find index for bytes field. This is a bug in tantivy, please \
-                         report.",
-                    );
+                let bytes_reader = reader.fast_fields().bytes(field).expect(
+                    "Failed to find index for bytes field. This is a bug in tantivy, please \
+                     report.",
+                );
                 (reader, bytes_reader)
             })
             .collect::<Vec<_>>();
@@ -1221,10 +1206,7 @@ mod tests {
             {
                 let get_fast_vals = |terms: Vec<Term>| {
                     let query = BooleanQuery::new_multiterms_query(terms);
-                    searcher.search(
-                        &query,
-                        &FastFieldTestCollector::for_field("score".to_string()),
-                    )
+                    searcher.search(&query, &FastFieldTestCollector::for_field(score_field))
                 };
                 let get_fast_vals_bytes = |terms: Vec<Term>| {
                     let query = BooleanQuery::new_multiterms_query(terms);
@@ -1262,7 +1244,7 @@ mod tests {
         let mut index_writer = index.writer_for_tests()?;
         let reader = index.reader().unwrap();
         let search_term = |searcher: &Searcher, term: Term| {
-            let collector = FastFieldTestCollector::for_field("score".to_string());
+            let collector = FastFieldTestCollector::for_field(score_field);
             let bytes_collector = BytesFastFieldTestCollector::for_field(bytes_score_field);
             let term_query = TermQuery::new(term, IndexRecordOption::Basic);
             searcher
@@ -1384,7 +1366,7 @@ mod tests {
             let score_field_reader = searcher
                 .segment_reader(0)
                 .fast_fields()
-                .u64("score")
+                .u64(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 4000);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1392,7 +1374,7 @@ mod tests {
             let score_field_reader = searcher
                 .segment_reader(1)
                 .fast_fields()
-                .u64("score")
+                .u64(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 1);
             assert_eq!(score_field_reader.max_value(), 3);
@@ -1438,7 +1420,7 @@ mod tests {
             let score_field_reader = searcher
                 .segment_reader(0)
                 .fast_fields()
-                .u64("score")
+                .u64(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 3);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1485,7 +1467,7 @@ mod tests {
             let score_field_reader = searcher
                 .segment_reader(0)
                 .fast_fields()
-                .u64("score")
+                .u64(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 3);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1532,7 +1514,7 @@ mod tests {
             let score_field_reader = searcher
                 .segment_reader(0)
                 .fast_fields()
-                .u64("score")
+                .u64(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 6000);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1854,7 +1836,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(0u32);
-            let ff_reader = segment.fast_fields().u64s("intvals").unwrap();
+            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
 
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[1, 2]);
@@ -1880,7 +1862,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(1u32);
-            let ff_reader = segment.fast_fields().u64s("intvals").unwrap();
+            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[28, 27]);
 
@@ -1890,7 +1872,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(2u32);
-            let ff_reader = segment.fast_fields().u64s("intvals").unwrap();
+            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[20]);
         }
@@ -1907,7 +1889,7 @@ mod tests {
         {
             let searcher = reader.searcher();
             let segment = searcher.segment_reader(0u32);
-            let ff_reader = segment.fast_fields().u64s("intvals").unwrap();
+            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
 
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[1, 2]);

src/indexer/merger_sorted_index_test.rs

@@ -185,7 +185,7 @@ mod tests {
         let segment_reader = searcher.segment_readers().last().unwrap();
 
         let fast_fields = segment_reader.fast_fields();
-        let fast_field = fast_fields.u64("intval").unwrap();
+        let fast_field = fast_fields.u64(int_field).unwrap();
         assert_eq!(fast_field.get_val(5), 1u64);
         assert_eq!(fast_field.get_val(4), 2u64);
         assert_eq!(fast_field.get_val(3), 3u64);
@@ -364,13 +364,15 @@ mod tests {
         .unwrap();
 
         let int_field = index.schema().get_field("intval").unwrap();
+        let multi_numbers = index.schema().get_field("multi_numbers").unwrap();
+        let bytes_field = index.schema().get_field("bytes").unwrap();
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
         assert_eq!(searcher.segment_readers().len(), 1);
         let segment_reader = searcher.segment_readers().last().unwrap();
 
         let fast_fields = segment_reader.fast_fields();
-        let fast_field = fast_fields.u64("intval").unwrap();
+        let fast_field = fast_fields.u64(int_field).unwrap();
         assert_eq!(fast_field.get_val(0), 1u64);
         assert_eq!(fast_field.get_val(1), 2u64);
         assert_eq!(fast_field.get_val(2), 3u64);
@@ -384,7 +386,7 @@ mod tests {
             vals
         };
         let fast_fields = segment_reader.fast_fields();
-        let fast_field = fast_fields.u64s("multi_numbers").unwrap();
+        let fast_field = fast_fields.u64s(multi_numbers).unwrap();
         assert_eq!(&get_vals(&fast_field, 0), &[] as &[u64]);
         assert_eq!(&get_vals(&fast_field, 1), &[2, 3]);
         assert_eq!(&get_vals(&fast_field, 2), &[3, 4]);
@@ -392,7 +394,7 @@ mod tests {
         assert_eq!(&get_vals(&fast_field, 4), &[20]);
         assert_eq!(&get_vals(&fast_field, 5), &[1001, 1002]);
 
-        let fast_field = fast_fields.bytes("bytes").unwrap();
+        let fast_field = fast_fields.bytes(bytes_field).unwrap();
         assert_eq!(fast_field.get_bytes(0), &[] as &[u8]);
         assert_eq!(fast_field.get_bytes(2), &[1, 2, 3]);
         assert_eq!(fast_field.get_bytes(5), &[5, 5]);
@@ -525,6 +527,7 @@ mod bench_sorted_index_merge {
             order: Order::Desc,
         };
         let index = create_index(Some(sort_by_field.clone()));
+        let field = index.schema().get_field("intval").unwrap();
         let segments = index.searchable_segments().unwrap();
         let merger: IndexMerger =
             IndexMerger::open(index.schema(), index.settings().clone(), &segments[..])?;
@@ -532,10 +535,8 @@ mod bench_sorted_index_merge {
         b.iter(|| {
             let sorted_doc_ids = doc_id_mapping.iter_old_doc_addrs().map(|doc_addr| {
                 let reader = &merger.readers[doc_addr.segment_ord as usize];
-                let u64_reader: Arc<dyn Column<u64>> = reader
-                    .fast_fields()
-                    .typed_fast_field_reader("intval")
-                    .expect(
+                let u64_reader: Arc<dyn Column<u64>> =
+                    reader.fast_fields().typed_fast_field_reader(field).expect(
                         "Failed to find a reader for single fast field. This is a tantivy bug and \
                          it should never happen.",
                     );

src/indexer/sorted_doc_id_column.rs

@@ -4,6 +4,7 @@ use fastfield_codecs::Column;
 use itertools::Itertools;
 
 use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
+use crate::schema::Field;
 use crate::SegmentReader;
 
 pub(crate) struct RemappedDocIdColumn<'a> {
@@ -40,7 +41,7 @@ impl<'a> RemappedDocIdColumn<'a> {
     pub(crate) fn new(
         readers: &'a [SegmentReader],
         doc_id_mapping: &'a SegmentDocIdMapping,
-        field: &str,
+        field: Field,
     ) -> Self {
         let (min_value, max_value) = readers
             .iter()

src/indexer/sorted_doc_id_multivalue_column.rs

@@ -5,6 +5,7 @@ use fastfield_codecs::Column;
 use super::flat_map_with_buffer::FlatMapWithBufferIter;
 use crate::fastfield::{MultiValueIndex, MultiValuedFastFieldReader};
 use crate::indexer::doc_id_mapping::SegmentDocIdMapping;
+use crate::schema::Field;
 use crate::{DocAddress, SegmentReader};
 
 pub(crate) struct RemappedDocIdMultiValueColumn<'a> {
@@ -19,7 +20,7 @@ impl<'a> RemappedDocIdMultiValueColumn<'a> {
     pub(crate) fn new(
         readers: &'a [SegmentReader],
         doc_id_mapping: &'a SegmentDocIdMapping,
-        field: &str,
+        field: Field,
     ) -> Self {
         // Our values are bitpacked and we need to know what should be
         // our bitwidth and our minimum value before serializing any values.

src/lib.rs

@@ -995,8 +995,8 @@ pub mod tests {
         let fast_field_unsigned = schema_builder.add_u64_field("unsigned", FAST);
         let fast_field_signed = schema_builder.add_i64_field("signed", FAST);
         let fast_field_float = schema_builder.add_f64_field("float", FAST);
-        schema_builder.add_text_field("text", TEXT);
-        schema_builder.add_u64_field("stored_int", STORED);
+        let text_field = schema_builder.add_text_field("text", TEXT);
+        let stored_int_field = schema_builder.add_u64_field("stored_int", STORED);
         let schema = schema_builder.build();
 
         let index = Index::create_in_ram(schema);
@@ -1011,37 +1011,37 @@ pub mod tests {
         let searcher = reader.searcher();
         let segment_reader: &SegmentReader = searcher.segment_reader(0);
         {
-            let fast_field_reader_res = segment_reader.fast_fields().u64("text");
+            let fast_field_reader_res = segment_reader.fast_fields().u64(text_field);
             assert!(fast_field_reader_res.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64("stored_int");
+            let fast_field_reader_opt = segment_reader.fast_fields().u64(stored_int_field);
             assert!(fast_field_reader_opt.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64("signed");
+            let fast_field_reader_opt = segment_reader.fast_fields().u64(fast_field_signed);
             assert!(fast_field_reader_opt.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64("float");
+            let fast_field_reader_opt = segment_reader.fast_fields().u64(fast_field_float);
             assert!(fast_field_reader_opt.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64("unsigned");
+            let fast_field_reader_opt = segment_reader.fast_fields().u64(fast_field_unsigned);
             assert!(fast_field_reader_opt.is_ok());
             let fast_field_reader = fast_field_reader_opt.unwrap();
             assert_eq!(fast_field_reader.get_val(0), 4u64)
         }
 
         {
-            let fast_field_reader_res = segment_reader.fast_fields().i64("signed");
+            let fast_field_reader_res = segment_reader.fast_fields().i64(fast_field_signed);
             assert!(fast_field_reader_res.is_ok());
             let fast_field_reader = fast_field_reader_res.unwrap();
             assert_eq!(fast_field_reader.get_val(0), 4i64)
         }
 
         {
-            let fast_field_reader_res = segment_reader.fast_fields().f64("float");
+            let fast_field_reader_res = segment_reader.fast_fields().f64(fast_field_float);
             assert!(fast_field_reader_res.is_ok());
             let fast_field_reader = fast_field_reader_res.unwrap();
             assert_eq!(fast_field_reader.get_val(0), 4f64)

src/query/query_parser/logical_ast.rs

@@ -10,7 +10,7 @@ pub enum LogicalLiteral {
     Term(Term),
     Phrase(Vec<(usize, Term)>, u32),
     Range {
-        field: String,
+        field: Field,
         value_type: Type,
         lower: Bound<Term>,
         upper: Bound<Term>,

src/query/query_parser/query_parser.rs

@@ -672,7 +672,7 @@ impl QueryParser {
                 let field_entry = self.schema.get_field_entry(field);
                 let value_type = field_entry.field_type().value_type();
                 let logical_ast = LogicalAst::Leaf(Box::new(LogicalLiteral::Range {
-                    field: self.schema.get_field_name(field).to_string(),
+                    field,
                     value_type,
                     lower: self.resolve_bound(field, json_path, &lower)?,
                     upper: self.resolve_bound(field, json_path, &upper)?,
@@ -964,7 +964,7 @@ mod test {
         let query = make_query_parser().parse_query("title:[A TO B]").unwrap();
         assert_eq!(
             format!("{:?}", query),
-            "RangeQuery { field: \"title\", value_type: Str, left_bound: Included([97]), \
+            "RangeQuery { field: Field(0), value_type: Str, left_bound: Included([97]), \
              right_bound: Included([98]) }"
         );
     }

src/query/range_query/range_query.rs

@@ -67,7 +67,7 @@ pub(crate) fn map_bound<TFrom, TTo, Transform: Fn(&TFrom) -> TTo>(
 ///
 /// let reader = index.reader()?;
 /// let searcher = reader.searcher();
-/// let docs_in_the_sixties = RangeQuery::new_u64("year".to_string(), 1960..1970);
+/// let docs_in_the_sixties = RangeQuery::new_u64(year_field, 1960..1970);
 /// let num_60s_books = searcher.search(&docs_in_the_sixties, &Count)?;
 /// assert_eq!(num_60s_books, 2285);
 /// Ok(())
@@ -76,7 +76,7 @@ pub(crate) fn map_bound<TFrom, TTo, Transform: Fn(&TFrom) -> TTo>(
 /// ```
 #[derive(Clone, Debug)]
 pub struct RangeQuery {
-    field: String,
+    field: Field,
     value_type: Type,
     left_bound: Bound<Vec<u8>>,
     right_bound: Bound<Vec<u8>>,
@@ -88,12 +88,15 @@ impl RangeQuery {
     /// If the value type is not correct, something may go terribly wrong when
     /// the `Weight` object is created.
     pub fn new_term_bounds(
-        field: String,
+        field: Field,
         value_type: Type,
         left_bound: &Bound<Term>,
         right_bound: &Bound<Term>,
     ) -> RangeQuery {
-        let verify_and_unwrap_term = |val: &Term| val.value_bytes().to_owned();
+        let verify_and_unwrap_term = |val: &Term| {
+            assert_eq!(field, val.field());
+            val.value_bytes().to_owned()
+        };
         RangeQuery {
             field,
             value_type,
@@ -106,7 +109,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `i64`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_i64(field: String, range: Range<i64>) -> RangeQuery {
+    pub fn new_i64(field: Field, range: Range<i64>) -> RangeQuery {
         RangeQuery::new_i64_bounds(
             field,
             Bound::Included(range.start),
@@ -122,15 +125,11 @@ impl RangeQuery {
     /// If the field is not of the type `i64`, tantivy
     /// will panic when the `Weight` object is created.
     pub fn new_i64_bounds(
-        field: String,
+        field: Field,
         left_bound: Bound<i64>,
         right_bound: Bound<i64>,
     ) -> RangeQuery {
-        let make_term_val = |val: &i64| {
-            Term::from_field_i64(Field::from_field_id(0), *val)
-                .value_bytes()
-                .to_owned()
-        };
+        let make_term_val = |val: &i64| Term::from_field_i64(field, *val).value_bytes().to_owned();
         RangeQuery {
             field,
             value_type: Type::I64,
@@ -143,7 +142,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `f64`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_f64(field: String, range: Range<f64>) -> RangeQuery {
+    pub fn new_f64(field: Field, range: Range<f64>) -> RangeQuery {
         RangeQuery::new_f64_bounds(
             field,
             Bound::Included(range.start),
@@ -159,15 +158,11 @@ impl RangeQuery {
     /// If the field is not of the type `f64`, tantivy
     /// will panic when the `Weight` object is created.
     pub fn new_f64_bounds(
-        field: String,
+        field: Field,
         left_bound: Bound<f64>,
         right_bound: Bound<f64>,
     ) -> RangeQuery {
-        let make_term_val = |val: &f64| {
-            Term::from_field_f64(Field::from_field_id(0), *val)
-                .value_bytes()
-                .to_owned()
-        };
+        let make_term_val = |val: &f64| Term::from_field_f64(field, *val).value_bytes().to_owned();
         RangeQuery {
             field,
             value_type: Type::F64,
@@ -184,15 +179,11 @@ impl RangeQuery {
     /// If the field is not of the type `u64`, tantivy
     /// will panic when the `Weight` object is created.
     pub fn new_u64_bounds(
-        field: String,
+        field: Field,
         left_bound: Bound<u64>,
         right_bound: Bound<u64>,
     ) -> RangeQuery {
-        let make_term_val = |val: &u64| {
-            Term::from_field_u64(Field::from_field_id(0), *val)
-                .value_bytes()
-                .to_owned()
-        };
+        let make_term_val = |val: &u64| Term::from_field_u64(field, *val).value_bytes().to_owned();
         RangeQuery {
             field,
             value_type: Type::U64,
@@ -205,7 +196,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `u64`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_u64(field: String, range: Range<u64>) -> RangeQuery {
+    pub fn new_u64(field: Field, range: Range<u64>) -> RangeQuery {
         RangeQuery::new_u64_bounds(
             field,
             Bound::Included(range.start),
@@ -221,15 +212,12 @@ impl RangeQuery {
     /// If the field is not of the type `date`, tantivy
     /// will panic when the `Weight` object is created.
     pub fn new_date_bounds(
-        field: String,
+        field: Field,
         left_bound: Bound<DateTime>,
         right_bound: Bound<DateTime>,
     ) -> RangeQuery {
-        let make_term_val = |val: &DateTime| {
-            Term::from_field_date(Field::from_field_id(0), *val)
-                .value_bytes()
-                .to_owned()
-        };
+        let make_term_val =
+            |val: &DateTime| Term::from_field_date(field, *val).value_bytes().to_owned();
         RangeQuery {
             field,
             value_type: Type::Date,
@@ -242,7 +230,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `date`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_date(field: String, range: Range<DateTime>) -> RangeQuery {
+    pub fn new_date(field: Field, range: Range<DateTime>) -> RangeQuery {
         RangeQuery::new_date_bounds(
             field,
             Bound::Included(range.start),
@@ -257,7 +245,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `Str`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_str_bounds(field: String, left: Bound<&str>, right: Bound<&str>) -> RangeQuery {
+    pub fn new_str_bounds(field: Field, left: Bound<&str>, right: Bound<&str>) -> RangeQuery {
         let make_term_val = |val: &&str| val.as_bytes().to_vec();
         RangeQuery {
             field,
@@ -271,7 +259,7 @@ impl RangeQuery {
     ///
     /// If the field is not of the type `Str`, tantivy
     /// will panic when the `Weight` object is created.
-    pub fn new_str(field: String, range: Range<&str>) -> RangeQuery {
+    pub fn new_str(field: Field, range: Range<&str>) -> RangeQuery {
         RangeQuery::new_str_bounds(
             field,
             Bound::Included(range.start),
@@ -280,8 +268,22 @@ impl RangeQuery {
     }
 
     /// Field to search over
-    pub fn field(&self) -> &str {
-        &self.field
+    pub fn field(&self) -> Field {
+        self.field
+    }
+
+    /// Lower bound of range
+    pub fn left_bound(&self) -> Bound<Term> {
+        map_bound(&self.left_bound, &|bytes| {
+            Term::from_field_bytes(self.field, bytes)
+        })
+    }
+
+    /// Upper bound of range
+    pub fn right_bound(&self) -> Bound<Term> {
+        map_bound(&self.right_bound, &|bytes| {
+            Term::from_field_bytes(self.field, bytes)
+        })
     }
 }
 
@@ -305,9 +307,7 @@ pub(crate) fn maps_to_u64_fastfield(typ: Type) -> bool {
 impl Query for RangeQuery {
     fn weight(&self, enable_scoring: EnableScoring<'_>) -> crate::Result<Box<dyn Weight>> {
         let schema = enable_scoring.schema();
-        let field_type = schema
-            .get_field_entry(schema.get_field(&self.field)?)
-            .field_type();
+        let field_type = schema.get_field_entry(self.field).field_type();
         let value_type = field_type.value_type();
         if value_type != self.value_type {
             let err_msg = format!(
@@ -320,7 +320,7 @@ impl Query for RangeQuery {
         if field_type.is_fast() && is_type_valid_for_fastfield_range_query(self.value_type) {
             if field_type.is_ip_addr() {
                 Ok(Box::new(IPFastFieldRangeWeight::new(
-                    self.field.to_string(),
+                    self.field,
                     &self.left_bound,
                     &self.right_bound,
                 )))
@@ -335,14 +335,14 @@ impl Query for RangeQuery {
                 let left_bound = map_bound(&self.left_bound, &parse_from_bytes);
                 let right_bound = map_bound(&self.right_bound, &parse_from_bytes);
                 Ok(Box::new(FastFieldRangeWeight::new(
-                    self.field.to_string(),
+                    self.field,
                     left_bound,
                     right_bound,
                 )))
             }
         } else {
             Ok(Box::new(RangeWeight {
-                field: self.field.to_string(),
+                field: self.field,
                 left_bound: self.left_bound.clone(),
                 right_bound: self.right_bound.clone(),
             }))
@@ -351,7 +351,7 @@ impl Query for RangeQuery {
 }
 
 pub struct RangeWeight {
-    field: String,
+    field: Field,
     left_bound: Bound<Vec<u8>>,
     right_bound: Bound<Vec<u8>>,
 }
@@ -379,7 +379,7 @@ impl Weight for RangeWeight {
         let max_doc = reader.max_doc();
         let mut doc_bitset = BitSet::with_max_value(max_doc);
 
-        let inverted_index = reader.inverted_index(reader.schema().get_field(&self.field)?)?;
+        let inverted_index = reader.inverted_index(self.field)?;
         let term_dict = inverted_index.terms();
         let mut term_range = self.term_range(term_dict)?;
         while term_range.advance() {
@@ -443,7 +443,7 @@ mod tests {
         let reader = index.reader()?;
         let searcher = reader.searcher();
 
-        let docs_in_the_sixties = RangeQuery::new_u64("year".to_string(), 1960u64..1970u64);
+        let docs_in_the_sixties = RangeQuery::new_u64(year_field, 1960u64..1970u64);
 
         // ... or `1960..=1969` if inclusive range is enabled.
         let count = searcher.search(&docs_in_the_sixties, &Count)?;
@@ -481,13 +481,10 @@ mod tests {
         let count_multiples =
             |range_query: RangeQuery| searcher.search(&range_query, &Count).unwrap();
 
-        assert_eq!(
-            count_multiples(RangeQuery::new_i64("intfield".to_string(), 10..11)),
-            9
-        );
+        assert_eq!(count_multiples(RangeQuery::new_i64(int_field, 10..11)), 9);
         assert_eq!(
             count_multiples(RangeQuery::new_i64_bounds(
-                "intfield".to_string(),
+                int_field,
                 Bound::Included(10),
                 Bound::Included(11)
             )),
@@ -495,7 +492,7 @@ mod tests {
         );
         assert_eq!(
             count_multiples(RangeQuery::new_i64_bounds(
-                "intfield".to_string(),
+                int_field,
                 Bound::Excluded(9),
                 Bound::Included(10)
             )),
@@ -503,7 +500,7 @@ mod tests {
         );
         assert_eq!(
             count_multiples(RangeQuery::new_i64_bounds(
-                "intfield".to_string(),
+                int_field,
                 Bound::Included(9),
                 Bound::Unbounded
             )),
@@ -543,12 +540,12 @@ mod tests {
             |range_query: RangeQuery| searcher.search(&range_query, &Count).unwrap();
 
         assert_eq!(
-            count_multiples(RangeQuery::new_f64("floatfield".to_string(), 10.0..11.0)),
+            count_multiples(RangeQuery::new_f64(float_field, 10.0..11.0)),
             9
         );
         assert_eq!(
             count_multiples(RangeQuery::new_f64_bounds(
-                "floatfield".to_string(),
+                float_field,
                 Bound::Included(10.0),
                 Bound::Included(11.0)
             )),
@@ -556,7 +553,7 @@ mod tests {
         );
         assert_eq!(
             count_multiples(RangeQuery::new_f64_bounds(
-                "floatfield".to_string(),
+                float_field,
                 Bound::Excluded(9.0),
                 Bound::Included(10.0)
             )),
@@ -564,7 +561,7 @@ mod tests {
         );
         assert_eq!(
             count_multiples(RangeQuery::new_f64_bounds(
-                "floatfield".to_string(),
+                float_field,
                 Bound::Included(9.0),
                 Bound::Unbounded
             )),

src/query/range_query/range_query_ip_fastfield.rs

@@ -11,18 +11,18 @@ use fastfield_codecs::MonotonicallyMappableToU128;
 use super::fast_field_range_query::{FastFieldCardinality, RangeDocSet};
 use super::range_query::map_bound;
 use crate::query::{ConstScorer, Explanation, Scorer, Weight};
-use crate::schema::Cardinality;
+use crate::schema::{Cardinality, Field};
 use crate::{DocId, DocSet, Score, SegmentReader, TantivyError};
 
 /// `IPFastFieldRangeWeight` uses the ip address fast field to execute range queries.
 pub struct IPFastFieldRangeWeight {
-    field: String,
+    field: Field,
     left_bound: Bound<Ipv6Addr>,
     right_bound: Bound<Ipv6Addr>,
 }
 
 impl IPFastFieldRangeWeight {
-    pub fn new(field: String, left_bound: &Bound<Vec<u8>>, right_bound: &Bound<Vec<u8>>) -> Self {
+    pub fn new(field: Field, left_bound: &Bound<Vec<u8>>, right_bound: &Bound<Vec<u8>>) -> Self {
         let parse_ip_from_bytes = |data: &Vec<u8>| {
             let ip_u128: u128 =
                 u128::from_be(BinarySerializable::deserialize(&mut &data[..]).unwrap());
@@ -40,13 +40,10 @@ impl IPFastFieldRangeWeight {
 
 impl Weight for IPFastFieldRangeWeight {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
-        let field_type = reader
-            .schema()
-            .get_field_entry(reader.schema().get_field(&self.field)?)
-            .field_type();
+        let field_type = reader.schema().get_field_entry(self.field).field_type();
         match field_type.fastfield_cardinality().unwrap() {
             Cardinality::SingleValue => {
-                let ip_addr_fast_field = reader.fast_fields().ip_addr(&self.field)?;
+                let ip_addr_fast_field = reader.fast_fields().ip_addr(self.field)?;
                 let value_range = bound_to_value_range(
                     &self.left_bound,
                     &self.right_bound,
@@ -60,7 +57,7 @@ impl Weight for IPFastFieldRangeWeight {
                 Ok(Box::new(ConstScorer::new(docset, boost)))
             }
             Cardinality::MultiValues => {
-                let ip_addr_fast_field = reader.fast_fields().ip_addrs(&self.field)?;
+                let ip_addr_fast_field = reader.fast_fields().ip_addrs(self.field)?;
                 let value_range = bound_to_value_range(
                     &self.left_bound,
                     &self.right_bound,

src/query/range_query/range_query_u64_fastfield.rs

@@ -9,18 +9,18 @@ use fastfield_codecs::MonotonicallyMappableToU64;
 use super::fast_field_range_query::{FastFieldCardinality, RangeDocSet};
 use super::range_query::map_bound;
 use crate::query::{ConstScorer, Explanation, Scorer, Weight};
-use crate::schema::Cardinality;
+use crate::schema::{Cardinality, Field};
 use crate::{DocId, DocSet, Score, SegmentReader, TantivyError};
 
 /// `FastFieldRangeWeight` uses the fast field to execute range queries.
 pub struct FastFieldRangeWeight {
-    field: String,
+    field: Field,
     left_bound: Bound<u64>,
     right_bound: Bound<u64>,
 }
 
 impl FastFieldRangeWeight {
-    pub fn new(field: String, left_bound: Bound<u64>, right_bound: Bound<u64>) -> Self {
+    pub fn new(field: Field, left_bound: Bound<u64>, right_bound: Bound<u64>) -> Self {
         let left_bound = map_bound(&left_bound, &|val| *val);
         let right_bound = map_bound(&right_bound, &|val| *val);
         Self {
@@ -33,13 +33,10 @@ impl FastFieldRangeWeight {
 
 impl Weight for FastFieldRangeWeight {
     fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
-        let field_type = reader
-            .schema()
-            .get_field_entry(reader.schema().get_field(&self.field)?)
-            .field_type();
+        let field_type = reader.schema().get_field_entry(self.field).field_type();
         match field_type.fastfield_cardinality().unwrap() {
             Cardinality::SingleValue => {
-                let fast_field = reader.fast_fields().u64_lenient(&self.field)?;
+                let fast_field = reader.fast_fields().u64_lenient(self.field)?;
                 let value_range = bound_to_value_range(
                     &self.left_bound,
                     &self.right_bound,
@@ -51,7 +48,7 @@ impl Weight for FastFieldRangeWeight {
                 Ok(Box::new(ConstScorer::new(docset, boost)))
             }
             Cardinality::MultiValues => {
-                let fast_field = reader.fast_fields().u64s_lenient(&self.field)?;
+                let fast_field = reader.fast_fields().u64s_lenient(self.field)?;
                 let value_range = bound_to_value_range(
                     &self.left_bound,
                     &self.right_bound,

src/schema/schema.rs

@@ -11,7 +11,6 @@ use super::ip_options::IpAddrOptions;
 use super::*;
 use crate::schema::bytes_options::BytesOptions;
 use crate::schema::field_type::ValueParsingError;
-use crate::TantivyError;
 
 /// Tantivy has a very strict schema.
 /// You need to specify in advance whether a field is indexed or not,
@@ -309,12 +308,8 @@ impl Schema {
     }
 
     /// Returns the field option associated with a given name.
-    pub fn get_field(&self, field_name: &str) -> crate::Result<Field> {
-        self.0
-            .fields_map
-            .get(field_name)
-            .cloned()
-            .ok_or_else(|| TantivyError::FieldNotFound(field_name.to_string()))
+    pub fn get_field(&self, field_name: &str) -> Option<Field> {
+        self.0.fields_map.get(field_name).cloned()
     }
 
     /// Create document from a named doc.
@@ -324,7 +319,7 @@ impl Schema {
     ) -> Result<Document, DocParsingError> {
         let mut document = Document::new();
         for (field_name, values) in named_doc.0 {
-            if let Ok(field) = self.get_field(&field_name) {
+            if let Some(field) = self.get_field(&field_name) {
                 for value in values {
                     document.add_field_value(field, value);
                 }
@@ -365,7 +360,7 @@ impl Schema {
     ) -> Result<Document, DocParsingError> {
         let mut doc = Document::default();
         for (field_name, json_value) in json_obj {
-            if let Ok(field) = self.get_field(&field_name) {
+            if let Some(field) = self.get_field(&field_name) {
                 let field_entry = self.get_field_entry(field);
                 let field_type = field_entry.field_type();
                 match json_value {