Added logging when token is dropped.

.travis.yml

@@ -10,7 +10,7 @@ env:
   global:
     - CRATE_NAME=tantivy
     - TRAVIS_CARGO_NIGHTLY_FEATURE=""
-    # - secure: eC8HjTi1wgRVCsMAeXEXt8Ckr0YBSGOEnQkkW4/Nde/OZ9jJjz2nmP1ELQlDE7+czHub2QvYtDMG0parcHZDx/Kus0yvyn08y3g2rhGIiE7y8OCvQm1Mybu2D/p7enm6shXquQ6Z5KRfRq+18mHy80wy9ABMA/ukEZdvnfQ76/Een8/Lb0eHaDoXDXn3PqLVtByvSfQQ7OhS60dEScu8PWZ6/l1057P5NpdWbMExBE7Ro4zYXNhkJeGZx0nP/Bd4Jjdt1XfPzMEybV6NZ5xsTILUBFTmOOt603IsqKGov089NExqxYu5bD3K+S4MzF1Nd6VhomNPJqLDCfhlymJCUj5n5Ku4yidlhQbM4Ej9nGrBalJnhcjBjPua5tmMF2WCxP9muKn/2tIOu1/+wc0vMf9Yd3wKIkf5+FtUxCgs2O+NslWvmOMAMI/yD25m7hb4t1IwE/4Bk+GVcWJRWXbo0/m6ZUHzRzdjUY2a1qvw7C9udzdhg7gcnXwsKrSWi2NjMiIVw86l+Zim0nLpKIN41sxZHLaFRG63Ki8zQ/481LGn32awJ6i3sizKS0WD+N1DfR2qYMrwYHaMN0uR0OFXYTJkFvTFttAeUY3EKmRKAuMhmO2YRdSr4/j/G5E9HMc1gSGJj6PxgpQU7EpvxRsmoVAEJr0mszmOj9icGHep/FM=
+    - secure: eC8HjTi1wgRVCsMAeXEXt8Ckr0YBSGOEnQkkW4/Nde/OZ9jJjz2nmP1ELQlDE7+czHub2QvYtDMG0parcHZDx/Kus0yvyn08y3g2rhGIiE7y8OCvQm1Mybu2D/p7enm6shXquQ6Z5KRfRq+18mHy80wy9ABMA/ukEZdvnfQ76/Een8/Lb0eHaDoXDXn3PqLVtByvSfQQ7OhS60dEScu8PWZ6/l1057P5NpdWbMExBE7Ro4zYXNhkJeGZx0nP/Bd4Jjdt1XfPzMEybV6NZ5xsTILUBFTmOOt603IsqKGov089NExqxYu5bD3K+S4MzF1Nd6VhomNPJqLDCfhlymJCUj5n5Ku4yidlhQbM4Ej9nGrBalJnhcjBjPua5tmMF2WCxP9muKn/2tIOu1/+wc0vMf9Yd3wKIkf5+FtUxCgs2O+NslWvmOMAMI/yD25m7hb4t1IwE/4Bk+GVcWJRWXbo0/m6ZUHzRzdjUY2a1qvw7C9udzdhg7gcnXwsKrSWi2NjMiIVw86l+Zim0nLpKIN41sxZHLaFRG63Ki8zQ/481LGn32awJ6i3sizKS0WD+N1DfR2qYMrwYHaMN0uR0OFXYTJkFvTFttAeUY3EKmRKAuMhmO2YRdSr4/j/G5E9HMc1gSGJj6PxgpQU7EpvxRsmoVAEJr0mszmOj9icGHep/FM=
 
 addons:
   apt:
@@ -38,12 +38,12 @@ matrix:
     # Linux
     #- env: TARGET=aarch64-unknown-linux-gnu
     #- env: TARGET=i686-unknown-linux-gnu
-    - env: TARGET=x86_64-unknown-linux-gnu CODECOV=1 UPLOAD_DOCS=1
+    - env: TARGET=x86_64-unknown-linux-gnu CODECOV=1
     # - env: TARGET=x86_64-unknown-linux-musl CODECOV=1
 
     # OSX
-    #- env: TARGET=x86_64-apple-darwin
-    #  os: osx
+    - env: TARGET=x86_64-apple-darwin
+      os: osx
 
 before_install:
   - set -e
@@ -52,7 +52,6 @@ before_install:
 install:
   - sh ci/install.sh
   - source ~/.cargo/env || true
-  - env | grep "TRAVIS"
 
 before_script:
   - export PATH=$HOME/.cargo/bin:$PATH
@@ -65,11 +64,6 @@ script:
 before_deploy:
   - sh ci/before_deploy.sh
 
-after_success:
-  # Needs GH_TOKEN env var to be set in travis settings
-  - if [[ -v GH_TOKEN ]]; then echo "GH TOKEN IS SET"; else echo "GH TOKEN NOT SET"; fi
-  - if [[ -v UPLOAD_DOCS ]]; then cargo doc; cargo doc-upload; else echo "doc upload disabled."; fi
-
 cache: cargo
 before_cache:
   # Travis can't cache files that are not readable by "others"

CHANGELOG.md

@@ -1,42 +1,13 @@
 Tantivy 0.10.0
-=====================
+====================
 
-*Tantivy 0.10.0 index format is compatible with the index format in 0.9.0.*
-
-- Added an ASCII folding filter (@drusellers)
-- Bugfix in `query.count` in presence of deletes (@pmasurel)
-- Added `.explain(...)` in `Query` and `Weight` to (@pmasurel)
-- Added an efficient way to `delete_all_documents` in `IndexWriter` (@petr-tik). 
-  All segments are simply removed.
 
 Minor
 ---------
 - Small simplification of the code. 
-Calling .freq() or .doc() when .advance() has never been called
+Calling .freq() or .doc() when .advance() has never 
 on segment postings should panic from now on.
 - Tokens exceeding `u16::max_value() - 4` chars are discarded silently instead of panicking.
-- Fast fields are now preloaded when the `SegmentReader` is created.
-- `IndexMeta` is now public.  (@hntd187)
-- `IndexWriter` `add_document`, `delete_term`. `IndexWriter` is `Sync`, making it possible to use it with a `
-Arc<RwLock<IndexWriter>>`. `add_document` and `delete_term` can 
-only require a read lock. (@pmasurel)
-- Introducing `Opstamp` as an expressive type alias for `u64`. (@petr-tik)
-- Stamper now relies on `AtomicU64` on all platforms (@petr-tik)
-
-## How to update?
-
-Your existing indexes are usable as is, but you may need some 
-trivial updates.
-
-### Fast fields
-
-Fast fields used to be accessed directly from the `SegmentReader`.
-The API changed, you are now required to acquire your fast field reader via the
-`segment_reader.fast_fields()`, and use one of the typed method: 
-- `.u64()`, `.i64()` if your field is single-valued ;
-- `.u64s()`, `.i64s()` if your field is multi-valued ;
-- `.bytes()` if your field is bytes fast field.
-
 
 
 Tantivy 0.9.0

Cargo.toml

@@ -42,7 +42,7 @@ owning_ref = "0.4"
 stable_deref_trait = "1.0.0"
 rust-stemmers = "1.1"
 downcast-rs = { version="1.0" }
-bitpacking = "0.7"
+bitpacking = "0.6"
 census = "0.2"
 fnv = "1.0.6"
 owned-read = "0.4"
@@ -54,7 +54,7 @@ murmurhash32 = "0.2"
 chrono = "0.4"
 
 [target.'cfg(windows)'.dependencies]
-winapi = "0.3"
+winapi = "0.2"
 
 [dev-dependencies]
 rand = "0.6"

README.md

@@ -4,7 +4,6 @@
 [![Join the chat at https://gitter.im/tantivy-search/tantivy](https://badges.gitter.im/tantivy-search/tantivy.svg)](https://gitter.im/tantivy-search/tantivy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Build status](https://ci.appveyor.com/api/projects/status/r7nb13kj23u8m9pj/branch/master?svg=true)](https://ci.appveyor.com/project/fulmicoton/tantivy/branch/master)
-[![Crates.io](https://img.shields.io/crates/v/tantivy.svg)](https://crates.io/crates/tantivy)
 [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/fulmicoton)
 
 ![Tantivy](https://tantivy-search.github.io/logo/tantivy-logo.png)

examples/custom_collector.rs

@@ -18,8 +18,8 @@ use tantivy::fastfield::FastFieldReader;
 use tantivy::query::QueryParser;
 use tantivy::schema::Field;
 use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
+use tantivy::Index;
 use tantivy::SegmentReader;
-use tantivy::{Index, TantivyError};
 
 #[derive(Default)]
 struct Stats {
@@ -75,18 +75,9 @@ impl Collector for StatsCollector {
     fn for_segment(
         &self,
         _segment_local_id: u32,
-        segment_reader: &SegmentReader,
+        segment: &SegmentReader,
     ) -> tantivy::Result<StatsSegmentCollector> {
-        let fast_field_reader = segment_reader
-            .fast_fields()
-            .u64(self.field)
-            .ok_or_else(|| {
-                let field_name = segment_reader.schema().get_field_name(self.field);
-                TantivyError::SchemaError(format!(
-                    "Field {:?} is not a u64 fast field.",
-                    field_name
-                ))
-            })?;
+        let fast_field_reader = segment.fast_field_reader(self.field)?;
         Ok(StatsSegmentCollector {
             fast_field_reader,
             stats: Stats::default(),

examples/multiple_producer.rs

@@ -1,107 +0,0 @@
-// # Indexing from different threads.
-//
-// It is fairly common to have to index from different threads.
-// Tantivy forbids to create more than one `IndexWriter` at a time.
-//
-// This `IndexWriter` itself has its own multithreaded layer, so managing your own
-// indexing threads will not help. However, it can still be useful for some applications.
-//
-// For instance, if preparing documents to send to tantivy before indexing is the bottleneck of
-// your application, it is reasonable to have multiple threads.
-//
-// Another very common reason to want to index from multiple threads, is implementing a webserver
-// with CRUD capabilities. The server framework will most likely handle request from
-// different threads.
-//
-// The recommended way to address both of these use case is to wrap your `IndexWriter` into a
-// `Arc<RwLock<IndexWriter>>`.
-//
-// While this is counterintuitive, adding and deleting documents do not require mutability
-// over the `IndexWriter`, so several threads will be able to do this operation concurrently.
-//
-// The example below does not represent an actual real-life use case (who would spawn thread to
-// index a single document?), but aims at demonstrating the mechanism that makes indexing
-// from several threads possible.
-
-extern crate tempdir;
-
-// ---
-// Importing tantivy...
-#[macro_use]
-extern crate tantivy;
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
-use tantivy::schema::{Schema, STORED, TEXT};
-use tantivy::Opstamp;
-use tantivy::{Index, IndexWriter};
-
-fn main() -> tantivy::Result<()> {
-    // # Defining the schema
-    let mut schema_builder = Schema::builder();
-    let title = schema_builder.add_text_field("title", TEXT | STORED);
-    let body = schema_builder.add_text_field("body", TEXT);
-    let schema = schema_builder.build();
-
-    let index = Index::create_in_ram(schema);
-    let index_writer: Arc<RwLock<IndexWriter>> = Arc::new(RwLock::new(index.writer(50_000_000)?));
-
-    // # First indexing thread.
-    let index_writer_clone_1 = index_writer.clone();
-    thread::spawn(move || {
-        // we index 100 times the document... for the sake of the example.
-        for i in 0..100 {
-            let opstamp = {
-                // A read lock is sufficient here.
-                let index_writer_rlock = index_writer_clone_1.read().unwrap();
-                index_writer_rlock.add_document(
-                    doc!(
-                        title => "Of Mice and Men",
-                        body => "A few miles south of Soledad, the Salinas River drops in close to the hillside \
-                        bank and runs deep and green. The water is warm too, for it has slipped twinkling \
-                        over the yellow sands in the sunlight before reaching the narrow pool. On one \
-                        side of the river the golden foothill slopes curve up to the strong and rocky \
-                        Gabilan Mountains, but on the valley side the water is lined with trees—willows \
-                        fresh and green with every spring, carrying in their lower leaf junctures the \
-                        debris of the winter’s flooding; and sycamores with mottled, white, recumbent \
-                        limbs and branches that arch over the pool"
-                    ))
-            };
-            println!("add doc {} from thread 1 - opstamp {}", i, opstamp);
-            thread::sleep(Duration::from_millis(20));
-        }
-    });
-
-    // # Second indexing thread.
-    let index_writer_clone_2 = index_writer.clone();
-    // For convenience, tantivy also comes with a macro to
-    // reduce the boilerplate above.
-    thread::spawn(move || {
-        // we index 100 times the document... for the sake of the example.
-        for i in 0..100 {
-            // A read lock is sufficient here.
-            let opstamp = {
-                let index_writer_rlock = index_writer_clone_2.read().unwrap();
-                index_writer_rlock.add_document(doc!(
-                    title => "Manufacturing consent",
-                    body => "Some great book description..."
-                ))
-            };
-            println!("add doc {} from thread 2 - opstamp {}", i, opstamp);
-            thread::sleep(Duration::from_millis(10));
-        }
-    });
-
-    // # In the main thread, we commit 10 times, once every 500ms.
-    for _ in 0..10 {
-        let opstamp: Opstamp = {
-            // Committing or rollbacking on the other hand requires write lock. This will block other threads.
-            let mut index_writer_wlock = index_writer.write().unwrap();
-            index_writer_wlock.commit().unwrap()
-        };
-        println!("committed with opstamp {}", opstamp);
-        thread::sleep(Duration::from_millis(500));
-    }
-
-    Ok(())
-}

src/collector/facet_collector.rs

@@ -17,7 +17,6 @@ use Result;
 use Score;
 use SegmentLocalId;
 use SegmentReader;
-use TantivyError;
 
 struct Hit<'a> {
     count: u64,
@@ -265,10 +264,7 @@ impl Collector for FacetCollector {
         _: SegmentLocalId,
         reader: &SegmentReader,
     ) -> Result<FacetSegmentCollector> {
-        let field_name = reader.schema().get_field_name(self.field);
-        let facet_reader = reader.facet_reader(self.field).ok_or_else(|| {
-            TantivyError::SchemaError(format!("Field {:?} is not a facet field.", field_name))
-        })?;
+        let facet_reader = reader.facet_reader(self.field)?;
 
         let mut collapse_mapping = Vec::new();
         let mut counts = Vec::new();

src/collector/multi_collector.rs

@@ -2,7 +2,6 @@ use super::Collector;
 use super::SegmentCollector;
 use collector::Fruit;
 use std::marker::PhantomData;
-use std::ops::Deref;
 use DocId;
 use Result;
 use Score;
@@ -200,10 +199,7 @@ impl<'a> Collector for MultiCollector<'a> {
     }
 
     fn requires_scoring(&self) -> bool {
-        self.collector_wrappers
-            .iter()
-            .map(Deref::deref)
-            .any(Collector::requires_scoring)
+        self.collector_wrappers.iter().any(|c| c.requires_scoring())
     }
 
     fn merge_fruits(&self, segments_multifruits: Vec<MultiFruit>) -> Result<MultiFruit> {

src/collector/tests.rs

@@ -114,15 +114,11 @@ impl Collector for FastFieldTestCollector {
     fn for_segment(
         &self,
         _: SegmentLocalId,
-        segment_reader: &SegmentReader,
+        reader: &SegmentReader,
     ) -> Result<FastFieldSegmentCollector> {
-        let reader = segment_reader
-            .fast_fields()
-            .u64(self.field)
-            .expect("Requested field is not a fast field.");
         Ok(FastFieldSegmentCollector {
             vals: Vec::new(),
-            reader,
+            reader: reader.fast_field_reader(self.field)?,
         })
     }
 
@@ -174,14 +170,11 @@ impl Collector for BytesFastFieldTestCollector {
     fn for_segment(
         &self,
         _segment_local_id: u32,
-        segment_reader: &SegmentReader,
+        segment: &SegmentReader,
     ) -> Result<BytesFastFieldSegmentCollector> {
         Ok(BytesFastFieldSegmentCollector {
             vals: Vec::new(),
-            reader: segment_reader
-                .fast_fields()
-                .bytes(self.field)
-                .expect("Field is not a bytes fast field."),
+            reader: segment.bytes_fast_field_reader(self.field)?,
         })
     }
 
@@ -198,7 +191,7 @@ impl SegmentCollector for BytesFastFieldSegmentCollector {
     type Fruit = Vec<u8>;
 
     fn collect(&mut self, doc: u32, _score: f32) {
-        let data = self.reader.get_bytes(doc);
+        let data = self.reader.get_val(doc);
         self.vals.extend(data);
     }
 

src/collector/top_collector.rs

@@ -98,11 +98,11 @@ where
             .collect())
     }
 
-    pub(crate) fn for_segment<F: PartialOrd>(
+    pub(crate) fn for_segment(
         &self,
         segment_id: SegmentLocalId,
         _: &SegmentReader,
-    ) -> Result<TopSegmentCollector<F>> {
+    ) -> Result<TopSegmentCollector<T>> {
         Ok(TopSegmentCollector::new(segment_id, self.limit))
     }
 }

src/collector/top_field_collector.rs

@@ -5,12 +5,10 @@ use collector::SegmentCollector;
 use fastfield::FastFieldReader;
 use fastfield::FastValue;
 use schema::Field;
-use std::marker::PhantomData;
 use DocAddress;
 use Result;
 use SegmentLocalId;
 use SegmentReader;
-use TantivyError;
 
 /// The Top Field Collector keeps track of the K documents
 /// sorted by a fast field in the index
@@ -108,15 +106,8 @@ impl<T: FastValue + PartialOrd + Send + Sync + 'static> Collector for TopDocsByF
         reader: &SegmentReader,
     ) -> Result<TopFieldSegmentCollector<T>> {
         let collector = self.collector.for_segment(segment_local_id, reader)?;
-        let reader = reader.fast_fields().u64(self.field).ok_or_else(|| {
-            let field_name = reader.schema().get_field_name(self.field);
-            TantivyError::SchemaError(format!("Failed to find fast field reader {:?}", field_name))
-        })?;
-        Ok(TopFieldSegmentCollector {
-            collector,
-            reader,
-            _type: PhantomData,
-        })
+        let reader = reader.fast_field_reader(self.field)?;
+        Ok(TopFieldSegmentCollector { collector, reader })
     }
 
     fn requires_scoring(&self) -> bool {
@@ -131,10 +122,9 @@ impl<T: FastValue + PartialOrd + Send + Sync + 'static> Collector for TopDocsByF
     }
 }
 
-pub struct TopFieldSegmentCollector<T> {
-    collector: TopSegmentCollector<u64>,
-    reader: FastFieldReader<u64>,
-    _type: PhantomData<T>,
+pub struct TopFieldSegmentCollector<T: FastValue + PartialOrd> {
+    collector: TopSegmentCollector<T>,
+    reader: FastFieldReader<T>,
 }
 
 impl<T: FastValue + PartialOrd + Send + Sync + 'static> SegmentCollector
@@ -148,11 +138,7 @@ impl<T: FastValue + PartialOrd + Send + Sync + 'static> SegmentCollector
     }
 
     fn harvest(self) -> Vec<(T, DocAddress)> {
-        self.collector
-            .harvest()
-            .into_iter()
-            .map(|(val, doc_address)| (T::from_u64(val), doc_address))
-            .collect()
+        self.collector.harvest()
     }
 }
 
@@ -249,7 +235,7 @@ mod tests {
                 .for_segment(0, segment)
                 .map(|_| ())
                 .unwrap_err(),
-            TantivyError::SchemaError(_)
+            TantivyError::FastFieldError(_)
         );
     }
 

src/core/index.rs

@@ -340,7 +340,7 @@ impl Index {
         Ok(self
             .searchable_segment_metas()?
             .iter()
-            .map(SegmentMeta::id)
+            .map(|segment_meta| segment_meta.id())
             .collect())
     }
 }
@@ -537,35 +537,4 @@ mod tests {
         }
         assert_eq!(count, 2);
     }
-
-    #[test]
-    fn garbage_collect_works_as_intended() {
-        let directory = RAMDirectory::create();
-        let schema = throw_away_schema();
-        let field = schema.get_field("num_likes").unwrap();
-        let index = Index::create(directory.clone(), schema).unwrap();
-
-        let mut writer = index.writer_with_num_threads(8, 24_000_000).unwrap();
-        for i in 0u64..8_000u64 {
-            writer.add_document(doc!(field => i));
-        }
-        writer.commit().unwrap();
-        let mem_right_after_commit = directory.total_mem_usage();
-        thread::sleep(Duration::from_millis(1_000));
-        let reader = index
-            .reader_builder()
-            .reload_policy(ReloadPolicy::Manual)
-            .try_into()
-            .unwrap();
-
-        assert_eq!(reader.searcher().num_docs(), 8_000);
-        writer.wait_merging_threads().unwrap();
-        let mem_right_after_merge_finished = directory.total_mem_usage();
-
-        reader.reload().unwrap();
-        let searcher = reader.searcher();
-        assert_eq!(searcher.num_docs(), 8_000);
-        assert!(mem_right_after_merge_finished < mem_right_after_commit);
-    }
-
 }

src/core/index_meta.rs

@@ -2,7 +2,6 @@ use core::SegmentMeta;
 use schema::Schema;
 use serde_json;
 use std::fmt;
-use Opstamp;
 
 /// Meta information about the `Index`.
 ///
@@ -14,27 +13,14 @@ use Opstamp;
 ///
 #[derive(Clone, Serialize, Deserialize)]
 pub struct IndexMeta {
-    /// List of `SegmentMeta` informations associated to each finalized segment of the index.
     pub segments: Vec<SegmentMeta>,
-    /// Index `Schema`
     pub schema: Schema,
-    /// Opstamp associated to the last `commit` operation.
-    pub opstamp: Opstamp,
+    pub opstamp: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
-    /// Payload associated to the last commit.
-    ///
-    /// Upon commit, clients can optionally add a small `Striing` payload to their commit
-    /// to help identify this commit.
-    /// This payload is entirely unused by tantivy.
     pub payload: Option<String>,
 }
 
 impl IndexMeta {
-    /// Create an `IndexMeta` object representing a brand new `Index`
-    /// with the given index.
-    ///
-    /// This new index does not contains any segments.
-    /// Opstamp will the value `0u64`.
     pub fn with_schema(schema: Schema) -> IndexMeta {
         IndexMeta {
             segments: vec![],

src/core/searcher.rs

@@ -59,7 +59,7 @@ impl Searcher {
     ) -> Searcher {
         let store_readers = segment_readers
             .iter()
-            .map(SegmentReader::get_store_reader)
+            .map(|segment_reader| segment_reader.get_store_reader())
             .collect();
         Searcher {
             schema,
@@ -218,7 +218,7 @@ impl fmt::Debug for Searcher {
         let segment_ids = self
             .segment_readers
             .iter()
-            .map(SegmentReader::segment_id)
+            .map(|segment_reader| segment_reader.segment_id())
             .collect::<Vec<_>>();
         write!(f, "Searcher({:?})", segment_ids)
     }

src/core/segment.rs

@@ -10,7 +10,6 @@ use schema::Schema;
 use std::fmt;
 use std::path::PathBuf;
 use std::result;
-use Opstamp;
 use Result;
 
 /// A segment is a piece of the index.
@@ -51,7 +50,7 @@ impl Segment {
     }
 
     #[doc(hidden)]
-    pub fn with_delete_meta(self, num_deleted_docs: u32, opstamp: Opstamp) -> Segment {
+    pub fn with_delete_meta(self, num_deleted_docs: u32, opstamp: u64) -> Segment {
         Segment {
             index: self.index,
             meta: self.meta.with_delete_meta(num_deleted_docs, opstamp),

src/core/segment_meta.rs

@@ -5,7 +5,6 @@ use serde;
 use std::collections::HashSet;
 use std::fmt;
 use std::path::PathBuf;
-use Opstamp;
 
 lazy_static! {
     static ref INVENTORY: Inventory<InnerSegmentMeta> = { Inventory::new() };
@@ -14,7 +13,7 @@ lazy_static! {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 struct DeleteMeta {
     num_deleted_docs: u32,
-    opstamp: Opstamp,
+    opstamp: u64,
 }
 
 /// `SegmentMeta` contains simple meta information about a segment.
@@ -137,9 +136,9 @@ impl SegmentMeta {
         self.max_doc() - self.num_deleted_docs()
     }
 
-    /// Returns the `Opstamp` of the last delete operation
+    /// Returns the opstamp of the last delete operation
     /// taken in account in this segment.
-    pub fn delete_opstamp(&self) -> Option<Opstamp> {
+    pub fn delete_opstamp(&self) -> Option<u64> {
         self.tracked
             .deletes
             .as_ref()
@@ -153,7 +152,7 @@ impl SegmentMeta {
     }
 
     #[doc(hidden)]
-    pub fn with_delete_meta(self, num_deleted_docs: u32, opstamp: Opstamp) -> SegmentMeta {
+    pub fn with_delete_meta(self, num_deleted_docs: u32, opstamp: u64) -> SegmentMeta {
         let delete_meta = DeleteMeta {
             num_deleted_docs,
             opstamp,

src/core/segment_reader.rs

@@ -5,10 +5,14 @@ use core::Segment;
 use core::SegmentComponent;
 use core::SegmentId;
 use directory::ReadOnlySource;
+use error::TantivyError;
 use fastfield::DeleteBitSet;
 use fastfield::FacetReader;
-use fastfield::FastFieldReaders;
+use fastfield::FastFieldReader;
+use fastfield::{self, FastFieldNotAvailableError};
+use fastfield::{BytesFastFieldReader, FastValue, MultiValueIntFastFieldReader};
 use fieldnorm::FieldNormReader;
+use schema::Cardinality;
 use schema::Field;
 use schema::FieldType;
 use schema::Schema;
@@ -47,7 +51,7 @@ pub struct SegmentReader {
     postings_composite: CompositeFile,
     positions_composite: CompositeFile,
     positions_idx_composite: CompositeFile,
-    fast_fields_readers: Arc<FastFieldReaders>,
+    fast_fields_composite: CompositeFile,
     fieldnorms_composite: CompositeFile,
 
     store_source: ReadOnlySource,
@@ -101,21 +105,93 @@ impl SegmentReader {
     ///
     /// # Panics
     /// May panic if the index is corrupted.
-    pub fn fast_fields(&self) -> &FastFieldReaders {
-        &self.fast_fields_readers
+    pub fn fast_field_reader<Item: FastValue>(
+        &self,
+        field: Field,
+    ) -> fastfield::Result<FastFieldReader<Item>> {
+        let field_entry = self.schema.get_field_entry(field);
+        if Item::fast_field_cardinality(field_entry.field_type()) == Some(Cardinality::SingleValue)
+        {
+            self.fast_fields_composite
+                .open_read(field)
+                .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))
+                .map(FastFieldReader::open)
+        } else {
+            Err(FastFieldNotAvailableError::new(field_entry))
+        }
+    }
+
+    pub(crate) fn fast_field_reader_with_idx<Item: FastValue>(
+        &self,
+        field: Field,
+        idx: usize,
+    ) -> fastfield::Result<FastFieldReader<Item>> {
+        if let Some(ff_source) = self.fast_fields_composite.open_read_with_idx(field, idx) {
+            Ok(FastFieldReader::open(ff_source))
+        } else {
+            let field_entry = self.schema.get_field_entry(field);
+            Err(FastFieldNotAvailableError::new(field_entry))
+        }
+    }
+
+    /// Accessor to the `MultiValueIntFastFieldReader` associated to a given `Field`.
+    /// May panick if the field is not a multivalued fastfield of the type `Item`.
+    pub fn multi_fast_field_reader<Item: FastValue>(
+        &self,
+        field: Field,
+    ) -> fastfield::Result<MultiValueIntFastFieldReader<Item>> {
+        let field_entry = self.schema.get_field_entry(field);
+        if Item::fast_field_cardinality(field_entry.field_type()) == Some(Cardinality::MultiValues)
+        {
+            let idx_reader = self.fast_field_reader_with_idx(field, 0)?;
+            let vals_reader = self.fast_field_reader_with_idx(field, 1)?;
+            Ok(MultiValueIntFastFieldReader::open(idx_reader, vals_reader))
+        } else {
+            Err(FastFieldNotAvailableError::new(field_entry))
+        }
+    }
+
+    /// Accessor to the `BytesFastFieldReader` associated to a given `Field`.
+    pub fn bytes_fast_field_reader(&self, field: Field) -> fastfield::Result<BytesFastFieldReader> {
+        let field_entry = self.schema.get_field_entry(field);
+        match *field_entry.field_type() {
+            FieldType::Bytes => {}
+            _ => return Err(FastFieldNotAvailableError::new(field_entry)),
+        }
+        let idx_reader = self
+            .fast_fields_composite
+            .open_read_with_idx(field, 0)
+            .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))
+            .map(FastFieldReader::open)?;
+        let values = self
+            .fast_fields_composite
+            .open_read_with_idx(field, 1)
+            .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))?;
+        Ok(BytesFastFieldReader::open(idx_reader, values))
     }
 
     /// Accessor to the `FacetReader` associated to a given `Field`.
-    pub fn facet_reader(&self, field: Field) -> Option<FacetReader> {
+    pub fn facet_reader(&self, field: Field) -> Result<FacetReader> {
         let field_entry = self.schema.get_field_entry(field);
         if field_entry.field_type() != &FieldType::HierarchicalFacet {
-            return None;
+            return Err(TantivyError::InvalidArgument(format!(
+                "The field {:?} is not a \
+                 hierarchical facet.",
+                field_entry
+            )));
         }
-        let term_ords_reader = self.fast_fields().u64s(field)?;
-        let termdict_source = self.termdict_composite.open_read(field)?;
+        let term_ords_reader = self.multi_fast_field_reader(field)?;
+        let termdict_source = self.termdict_composite.open_read(field).ok_or_else(|| {
+            TantivyError::InvalidArgument(format!(
+                "The field \"{}\" is a hierarchical \
+                 but this segment does not seem to have the field term \
+                 dictionary.",
+                field_entry.name()
+            ))
+        })?;
         let termdict = TermDictionary::from_source(&termdict_source);
         let facet_reader = FacetReader::new(term_ords_reader, termdict);
-        Some(facet_reader)
+        Ok(facet_reader)
     }
 
     /// Accessor to the segment's `Field norms`'s reader.
@@ -171,12 +247,8 @@ impl SegmentReader {
             }
         };
 
-        let schema = segment.schema();
-
         let fast_fields_data = segment.open_read(SegmentComponent::FASTFIELDS)?;
         let fast_fields_composite = CompositeFile::open(&fast_fields_data)?;
-        let fast_field_readers =
-            Arc::new(FastFieldReaders::load_all(&schema, &fast_fields_composite)?);
 
         let fieldnorms_data = segment.open_read(SegmentComponent::FIELDNORMS)?;
         let fieldnorms_composite = CompositeFile::open(&fieldnorms_data)?;
@@ -188,13 +260,14 @@ impl SegmentReader {
             None
         };
 
+        let schema = segment.schema();
         Ok(SegmentReader {
             inv_idx_reader_cache: Arc::new(RwLock::new(HashMap::new())),
             max_doc: segment.meta().max_doc(),
             num_docs: segment.meta().num_docs(),
             termdict_composite,
             postings_composite,
-            fast_fields_readers: fast_field_readers,
+            fast_fields_composite,
             fieldnorms_composite,
             segment_id: segment.id(),
             store_source,
@@ -246,7 +319,7 @@ impl SegmentReader {
         let termdict_source = self
             .termdict_composite
             .open_read(field)
-            .expect("Failed to open field term dictionary in composite file. Is the field indexed?");
+            .expect("Failed to open field term dictionary in composite file. Is the field indexed");
 
         let positions_source = self
             .positions_composite
@@ -308,12 +381,12 @@ impl SegmentReader {
             self.postings_composite.space_usage(),
             self.positions_composite.space_usage(),
             self.positions_idx_composite.space_usage(),
-            self.fast_fields_readers.space_usage(),
+            self.fast_fields_composite.space_usage(),
             self.fieldnorms_composite.space_usage(),
             self.get_store_reader().space_usage(),
             self.delete_bitset_opt
                 .as_ref()
-                .map(DeleteBitSet::space_usage)
+                .map(|x| x.space_usage())
                 .unwrap_or(0),
         )
     }

src/directory/directory.rs

@@ -48,14 +48,14 @@ impl RetryPolicy {
 ///
 /// It is transparently associated to a lock file, that gets deleted
 /// on `Drop.` The lock is released automatically on `Drop`.
-pub struct DirectoryLock(Box<Drop + Send + Sync + 'static>);
+pub struct DirectoryLock(Box<Drop + Send + 'static>);
 
 struct DirectoryLockGuard {
     directory: Box<Directory>,
     path: PathBuf,
 }
 
-impl<T: Drop + Send + Sync + 'static> From<Box<T>> for DirectoryLock {
+impl<T: Drop + Send + 'static> From<Box<T>> for DirectoryLock {
     fn from(underlying: Box<T>) -> Self {
         DirectoryLock(underlying)
     }

src/directory/error.rs

@@ -6,7 +6,7 @@ use std::path::PathBuf;
 /// Error while trying to acquire a directory lock.
 #[derive(Debug, Fail)]
 pub enum LockError {
-    /// Failed to acquired a lock as it is already held by another
+    /// Failed to acquired a lock as it is already hold by another
     /// client.
     /// - In the context of a blocking lock, this means the lock was not released within some `timeout` period.
     /// - In the context of a non-blocking lock, this means the lock was busy at the moment of the call.

src/directory/mmap_directory.rs

@@ -320,7 +320,7 @@ impl MmapDirectory {
         #[cfg(windows)]
         {
             use std::os::windows::fs::OpenOptionsExt;
-            use winapi::um::winbase;
+            use winapi::winbase;
 
             open_opts
                 .write(true)

src/directory/ram_directory.rs

@@ -86,7 +86,7 @@ impl InnerDirectory {
         self.fs
             .get(path)
             .ok_or_else(|| OpenReadError::FileDoesNotExist(PathBuf::from(path)))
-            .map(Clone::clone)
+            .map(|el| el.clone())
     }
 
     fn delete(&mut self, path: &Path) -> result::Result<(), DeleteError> {
@@ -103,10 +103,6 @@ impl InnerDirectory {
     fn watch(&mut self, watch_handle: WatchCallback) -> WatchHandle {
         self.watch_router.subscribe(watch_handle)
     }
-
-    fn total_mem_usage(&self) -> usize {
-        self.fs.values().map(|f| f.len()).sum()
-    }
 }
 
 impl fmt::Debug for RAMDirectory {
@@ -130,12 +126,6 @@ impl RAMDirectory {
     pub fn create() -> RAMDirectory {
         Self::default()
     }
-
-    /// Returns the sum of the size of the different files
-    /// in the RAMDirectory.
-    pub fn total_mem_usage(&self) -> usize {
-        self.fs.read().unwrap().total_mem_usage()
-    }
 }
 
 impl Directory for RAMDirectory {

src/fastfield/bytes/mod.rs

@@ -23,14 +23,14 @@ mod tests {
         index_writer.add_document(doc!(field=>vec![0u8; 1000]));
         assert!(index_writer.commit().is_ok());
         let searcher = index.reader().unwrap().searcher();
-        let segment_reader = searcher.segment_reader(0);
-        let bytes_reader = segment_reader.fast_fields().bytes(field).unwrap();
+        let reader = searcher.segment_reader(0);
+        let bytes_reader = reader.bytes_fast_field_reader(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]);
-        assert_eq!(bytes_reader.get_bytes(3), &[1u8, 3, 5, 7, 9]);
+        assert_eq!(bytes_reader.get_val(0), &[0u8, 1, 2, 3]);
+        assert!(bytes_reader.get_val(1).is_empty());
+        assert_eq!(bytes_reader.get_val(2), &[255u8]);
+        assert_eq!(bytes_reader.get_val(3), &[1u8, 3, 5, 7, 9]);
         let long = vec![0u8; 1000];
-        assert_eq!(bytes_reader.get_bytes(4), long.as_slice());
+        assert_eq!(bytes_reader.get_val(4), long.as_slice());
     }
 }

src/fastfield/bytes/reader.rs

@@ -14,7 +14,6 @@ use DocId;
 ///
 /// Reading the value for a document is done by reading the start index for it,
 /// and the start index for the next document, and keeping the bytes in between.
-#[derive(Clone)]
 pub struct BytesFastFieldReader {
     idx_reader: FastFieldReader<u64>,
     values: OwningRef<ReadOnlySource, [u8]>,
@@ -29,20 +28,10 @@ impl BytesFastFieldReader {
         BytesFastFieldReader { idx_reader, values }
     }
 
-    fn range(&self, doc: DocId) -> (usize, usize) {
+    /// Returns the bytes associated to the given `doc`
+    pub fn get_val(&self, doc: DocId) -> &[u8] {
         let start = self.idx_reader.get(doc) as usize;
         let stop = self.idx_reader.get(doc + 1) as usize;
-        (start, stop)
-    }
-
-    /// Returns the bytes associated to the given `doc`
-    pub fn get_bytes(&self, doc: DocId) -> &[u8] {
-        let (start, stop) = self.range(doc);
         &self.values[start..stop]
     }
-
-    /// Returns the overall number of bytes in this bytes fast field.
-    pub fn total_num_bytes(&self) -> usize {
-        self.values.len()
-    }
 }

src/fastfield/delete.rs

@@ -53,18 +53,16 @@ impl DeleteBitSet {
         }
     }
 
-    /// Returns true iff the document is still "alive". In other words, if it has not been deleted.
-    pub fn is_alive(&self, doc: DocId) -> bool {
-        !self.is_deleted(doc)
-    }
-
-    /// Returns true iff the document has been marked as deleted.
-    #[inline(always)]
+    /// Returns whether the document has been marked as deleted.
     pub fn is_deleted(&self, doc: DocId) -> bool {
-        let byte_offset = doc / 8u32;
-        let b: u8 = (*self.data)[byte_offset as usize];
-        let shift = (doc & 7u32) as u8;
-        b & (1u8 << shift) != 0
+        if self.len == 0 {
+            false
+        } else {
+            let byte_offset = doc / 8u32;
+            let b: u8 = (*self.data)[byte_offset as usize];
+            let shift = (doc & 7u32) as u8;
+            b & (1u8 << shift) != 0
+        }
     }
 
     /// Summarize total space usage of this bitset.

src/fastfield/mod.rs

@@ -30,7 +30,6 @@ pub use self::error::{FastFieldNotAvailableError, Result};
 pub use self::facet_reader::FacetReader;
 pub use self::multivalued::{MultiValueIntFastFieldReader, MultiValueIntFastFieldWriter};
 pub use self::reader::FastFieldReader;
-pub use self::readers::FastFieldReaders;
 pub use self::serializer::FastFieldSerializer;
 pub use self::writer::{FastFieldsWriter, IntFastFieldWriter};
 use common;
@@ -44,7 +43,6 @@ mod error;
 mod facet_reader;
 mod multivalued;
 mod reader;
-mod readers;
 mod serializer;
 mod writer;
 
@@ -80,6 +78,10 @@ impl FastValue for u64 {
         *self
     }
 
+    fn as_u64(&self) -> u64 {
+        *self
+    }
+
     fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
         match *field_type {
             FieldType::U64(ref integer_options) => integer_options.get_fastfield_cardinality(),
@@ -87,10 +89,6 @@ impl FastValue for u64 {
             _ => None,
         }
     }
-
-    fn as_u64(&self) -> u64 {
-        *self
-    }
 }
 
 impl FastValue for i64 {

src/fastfield/multivalued/mod.rs

@@ -37,7 +37,9 @@ mod tests {
         let searcher = index.reader().unwrap().searcher();
         let segment_reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = segment_reader.fast_fields().u64s(field).unwrap();
+        let multi_value_reader = segment_reader
+            .multi_fast_field_reader::<u64>(field)
+            .unwrap();
         {
             multi_value_reader.get_vals(2, &mut vals);
             assert_eq!(&vals, &[4u64]);
@@ -196,9 +198,9 @@ mod tests {
         assert!(index_writer.commit().is_ok());
 
         let searcher = index.reader().unwrap().searcher();
-        let segment_reader = searcher.segment_reader(0);
+        let reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = segment_reader.fast_fields().i64s(field).unwrap();
+        let multi_value_reader = reader.multi_fast_field_reader::<i64>(field).unwrap();
         {
             multi_value_reader.get_vals(2, &mut vals);
             assert_eq!(&vals, &[-4i64]);

src/fastfield/multivalued/reader.rs

@@ -26,13 +26,6 @@ impl<Item: FastValue> MultiValueIntFastFieldReader<Item> {
         }
     }
 
-    pub(crate) fn into_u64s_reader(self) -> MultiValueIntFastFieldReader<u64> {
-        MultiValueIntFastFieldReader {
-            idx_reader: self.idx_reader,
-            vals_reader: self.vals_reader.into_u64_reader(),
-        }
-    }
-
     /// Returns `(start, stop)`, such that the values associated
     /// to the given document are `start..stop`.
     fn range(&self, doc: DocId) -> (u64, u64) {
@@ -48,24 +41,13 @@ impl<Item: FastValue> MultiValueIntFastFieldReader<Item> {
         vals.resize(len, Item::default());
         self.vals_reader.get_range_u64(start, &mut vals[..]);
     }
-
-    /// Returns the number of values associated with the document `DocId`.
-    pub fn num_vals(&self, doc: DocId) -> usize {
-        let (start, stop) = self.range(doc);
-        (stop - start) as usize
-    }
-
-    /// Returns the overall number of values in this field  .
-    pub fn total_num_vals(&self) -> u64 {
-        self.idx_reader.max_value()
-    }
 }
 
 #[cfg(test)]
 mod tests {
 
     use core::Index;
-    use schema::{Facet, Schema};
+    use schema::{Document, Facet, Schema};
 
     #[test]
     fn test_multifastfield_reader() {
@@ -76,12 +58,22 @@ mod tests {
         let mut index_writer = index
             .writer_with_num_threads(1, 30_000_000)
             .expect("Failed to create index writer.");
-        index_writer.add_document(doc!(
-            facet_field => Facet::from("/category/cat2"),
-            facet_field => Facet::from("/category/cat1"),
-        ));
-        index_writer.add_document(doc!(facet_field => Facet::from("/category/cat2")));
-        index_writer.add_document(doc!(facet_field => Facet::from("/category/cat3")));
+        {
+            let mut doc = Document::new();
+            doc.add_facet(facet_field, "/category/cat2");
+            doc.add_facet(facet_field, "/category/cat1");
+            index_writer.add_document(doc);
+        }
+        {
+            let mut doc = Document::new();
+            doc.add_facet(facet_field, "/category/cat2");
+            index_writer.add_document(doc);
+        }
+        {
+            let mut doc = Document::new();
+            doc.add_facet(facet_field, "/category/cat3");
+            index_writer.add_document(doc);
+        }
         index_writer.commit().expect("Commit failed");
         let searcher = index.reader().unwrap().searcher();
         let segment_reader = searcher.segment_reader(0);

src/fastfield/reader.rs

@@ -50,15 +50,6 @@ impl<Item: FastValue> FastFieldReader<Item> {
         }
     }
 
-    pub(crate) fn into_u64_reader(self) -> FastFieldReader<u64> {
-        FastFieldReader {
-            bit_unpacker: self.bit_unpacker,
-            min_value_u64: self.min_value_u64,
-            max_value_u64: self.max_value_u64,
-            _phantom: PhantomData,
-        }
-    }
-
     /// Return the value associated to the given document.
     ///
     /// This accessor should return as fast as possible.

src/fastfield/readers.rs

@@ -1,191 +0,0 @@
-use common::CompositeFile;
-use fastfield::BytesFastFieldReader;
-use fastfield::MultiValueIntFastFieldReader;
-use fastfield::{FastFieldNotAvailableError, FastFieldReader};
-use schema::{Cardinality, Field, FieldType, Schema};
-use space_usage::PerFieldSpaceUsage;
-use std::collections::HashMap;
-use Result;
-
-/// Provides access to all of the FastFieldReader.
-///
-/// Internally, `FastFieldReaders` have preloaded fast field readers,
-/// and just wraps several `HashMap`.
-pub struct FastFieldReaders {
-    fast_field_i64: HashMap<Field, FastFieldReader<i64>>,
-    fast_field_u64: HashMap<Field, FastFieldReader<u64>>,
-    fast_field_i64s: HashMap<Field, MultiValueIntFastFieldReader<i64>>,
-    fast_field_u64s: HashMap<Field, MultiValueIntFastFieldReader<u64>>,
-    fast_bytes: HashMap<Field, BytesFastFieldReader>,
-    fast_fields_composite: CompositeFile,
-}
-
-enum FastType {
-    I64,
-    U64,
-}
-
-fn type_and_cardinality(field_type: &FieldType) -> Option<(FastType, Cardinality)> {
-    match field_type {
-        FieldType::U64(options) => options
-            .get_fastfield_cardinality()
-            .map(|cardinality| (FastType::U64, cardinality)),
-        FieldType::I64(options) => options
-            .get_fastfield_cardinality()
-            .map(|cardinality| (FastType::I64, cardinality)),
-        FieldType::HierarchicalFacet => Some((FastType::U64, Cardinality::MultiValues)),
-        _ => None,
-    }
-}
-
-impl FastFieldReaders {
-    pub(crate) fn load_all(
-        schema: &Schema,
-        fast_fields_composite: &CompositeFile,
-    ) -> Result<FastFieldReaders> {
-        let mut fast_field_readers = FastFieldReaders {
-            fast_field_i64: Default::default(),
-            fast_field_u64: Default::default(),
-            fast_field_i64s: Default::default(),
-            fast_field_u64s: Default::default(),
-            fast_bytes: Default::default(),
-            fast_fields_composite: fast_fields_composite.clone(),
-        };
-        for (field_id, field_entry) in schema.fields().iter().enumerate() {
-            let field = Field(field_id as u32);
-            let field_type = field_entry.field_type();
-            if field_type == &FieldType::Bytes {
-                let idx_reader = fast_fields_composite
-                    .open_read_with_idx(field, 0)
-                    .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))
-                    .map(FastFieldReader::open)?;
-                let data = fast_fields_composite
-                    .open_read_with_idx(field, 1)
-                    .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))?;
-                fast_field_readers
-                    .fast_bytes
-                    .insert(field, BytesFastFieldReader::open(idx_reader, data));
-            } else if let Some((fast_type, cardinality)) = type_and_cardinality(field_type) {
-                match cardinality {
-                    Cardinality::SingleValue => {
-                        if let Some(fast_field_data) = fast_fields_composite.open_read(field) {
-                            match fast_type {
-                                FastType::U64 => {
-                                    let fast_field_reader = FastFieldReader::open(fast_field_data);
-                                    fast_field_readers
-                                        .fast_field_u64
-                                        .insert(field, fast_field_reader);
-                                }
-                                FastType::I64 => {
-                                    fast_field_readers.fast_field_i64.insert(
-                                        field,
-                                        FastFieldReader::open(fast_field_data.clone()),
-                                    );
-                                }
-                            }
-                        } else {
-                            return Err(From::from(FastFieldNotAvailableError::new(field_entry)));
-                        }
-                    }
-                    Cardinality::MultiValues => {
-                        let idx_opt = fast_fields_composite.open_read_with_idx(field, 0);
-                        let data_opt = fast_fields_composite.open_read_with_idx(field, 1);
-                        if let (Some(fast_field_idx), Some(fast_field_data)) = (idx_opt, data_opt) {
-                            let idx_reader = FastFieldReader::open(fast_field_idx);
-                            match fast_type {
-                                FastType::I64 => {
-                                    let vals_reader = FastFieldReader::open(fast_field_data);
-                                    let multivalued_int_fast_field =
-                                        MultiValueIntFastFieldReader::open(idx_reader, vals_reader);
-                                    fast_field_readers
-                                        .fast_field_i64s
-                                        .insert(field, multivalued_int_fast_field);
-                                }
-                                FastType::U64 => {
-                                    let vals_reader = FastFieldReader::open(fast_field_data);
-                                    let multivalued_int_fast_field =
-                                        MultiValueIntFastFieldReader::open(idx_reader, vals_reader);
-                                    fast_field_readers
-                                        .fast_field_u64s
-                                        .insert(field, multivalued_int_fast_field);
-                                }
-                            }
-                        } else {
-                            return Err(From::from(FastFieldNotAvailableError::new(field_entry)));
-                        }
-                    }
-                }
-            }
-        }
-        Ok(fast_field_readers)
-    }
-
-    pub(crate) fn space_usage(&self) -> PerFieldSpaceUsage {
-        self.fast_fields_composite.space_usage()
-    }
-
-    /// Returns the `u64` fast field reader reader associated to `field`.
-    ///
-    /// If `field` is not a u64 fast field, this method returns `None`.
-    pub fn u64(&self, field: Field) -> Option<FastFieldReader<u64>> {
-        self.fast_field_u64.get(&field).cloned()
-    }
-
-    /// If the field is a u64-fast field return the associated reader.
-    /// If the field is a i64-fast field, return the associated u64 reader. Values are
-    /// mapped from i64 to u64 using a (well the, it is unique) monotonic mapping.    ///
-    ///
-    /// This method is useful when merging segment reader.
-    pub(crate) fn u64_lenient(&self, field: Field) -> Option<FastFieldReader<u64>> {
-        if let Some(u64_ff_reader) = self.u64(field) {
-            return Some(u64_ff_reader);
-        }
-        if let Some(i64_ff_reader) = self.i64(field) {
-            return Some(i64_ff_reader.into_u64_reader());
-        }
-        None
-    }
-
-    /// Returns the `i64` fast field reader reader associated to `field`.
-    ///
-    /// If `field` is not a i64 fast field, this method returns `None`.
-    pub fn i64(&self, field: Field) -> Option<FastFieldReader<i64>> {
-        self.fast_field_i64.get(&field).cloned()
-    }
-
-    /// Returns a `u64s` multi-valued fast field reader reader associated to `field`.
-    ///
-    /// If `field` is not a u64 multi-valued fast field, this method returns `None`.
-    pub fn u64s(&self, field: Field) -> Option<MultiValueIntFastFieldReader<u64>> {
-        self.fast_field_u64s.get(&field).cloned()
-    }
-
-    /// If the field is a u64s-fast field return the associated reader.
-    /// If the field is a i64s-fast field, return the associated u64s reader. Values are
-    /// mapped from i64 to u64 using a (well the, it is unique) monotonic mapping.
-    ///
-    /// This method is useful when merging segment reader.
-    pub(crate) fn u64s_lenient(&self, field: Field) -> Option<MultiValueIntFastFieldReader<u64>> {
-        if let Some(u64s_ff_reader) = self.u64s(field) {
-            return Some(u64s_ff_reader);
-        }
-        if let Some(i64s_ff_reader) = self.i64s(field) {
-            return Some(i64s_ff_reader.into_u64s_reader());
-        }
-        None
-    }
-
-    /// Returns a `i64s` multi-valued fast field reader reader associated to `field`.
-    ///
-    /// If `field` is not a i64 multi-valued fast field, this method returns `None`.
-    pub fn i64s(&self, field: Field) -> Option<MultiValueIntFastFieldReader<i64>> {
-        self.fast_field_i64s.get(&field).cloned()
-    }
-
-    /// Returns the `bytes` fast field reader associated to `field`.
-    ///
-    /// If `field` is not a bytes fast field, returns `None`.
-    pub fn bytes(&self, field: Field) -> Option<BytesFastFieldReader> {
-        self.fast_bytes.get(&field).cloned()
-    }
-}

src/indexer/delete_queue.rs

@@ -2,7 +2,6 @@ use super::operation::DeleteOperation;
 use std::mem;
 use std::ops::DerefMut;
 use std::sync::{Arc, RwLock};
-use Opstamp;
 
 // The DeleteQueue is similar in conceptually to a multiple
 // consumer single producer broadcast channel.
@@ -185,7 +184,7 @@ impl DeleteCursor {
     ///   queue are consume and the next get will return None.
     /// - the next get will return the first operation with an
     /// `opstamp >= target_opstamp`.
-    pub fn skip_to(&mut self, target_opstamp: Opstamp) {
+    pub fn skip_to(&mut self, target_opstamp: u64) {
         // TODO Can be optimize as we work with block.
         while self.is_behind_opstamp(target_opstamp) {
             self.advance();
@@ -193,7 +192,7 @@ impl DeleteCursor {
     }
 
     #[cfg_attr(feature = "cargo-clippy", allow(clippy::wrong_self_convention))]
-    fn is_behind_opstamp(&mut self, target_opstamp: Opstamp) -> bool {
+    fn is_behind_opstamp(&mut self, target_opstamp: u64) -> bool {
         self.get()
             .map(|operation| operation.opstamp < target_opstamp)
             .unwrap_or(false)

src/indexer/doc_opstamp_mapping.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 use DocId;
-use Opstamp;
 
 // Doc to opstamp is used to identify which
 // document should be deleted.
@@ -24,7 +23,7 @@ pub enum DocToOpstampMapping {
 }
 
 impl From<Vec<u64>> for DocToOpstampMapping {
-    fn from(opstamps: Vec<Opstamp>) -> DocToOpstampMapping {
+    fn from(opstamps: Vec<u64>) -> DocToOpstampMapping {
         DocToOpstampMapping::WithMap(Arc::new(opstamps))
     }
 }
@@ -36,7 +35,7 @@ impl DocToOpstampMapping {
     //
     // The edge case opstamp = some doc opstamp is in practise
     // never called.
-    pub fn compute_doc_limit(&self, target_opstamp: Opstamp) -> DocId {
+    pub fn compute_doc_limit(&self, target_opstamp: u64) -> DocId {
         match *self {
             DocToOpstampMapping::WithMap(ref doc_opstamps) => {
                 match doc_opstamps.binary_search(&target_opstamp) {

src/indexer/index_writer.rs

@@ -30,7 +30,6 @@ use std::ops::Range;
 use std::sync::Arc;
 use std::thread;
 use std::thread::JoinHandle;
-use Opstamp;
 use Result;
 
 // Size of the margin for the heap. A segment is closed when the remaining memory
@@ -100,7 +99,7 @@ pub struct IndexWriter {
     delete_queue: DeleteQueue,
 
     stamper: Stamper,
-    committed_opstamp: Opstamp,
+    committed_opstamp: u64,
 }
 
 /// Open a new index writer. Attempts to acquire a lockfile.
@@ -178,7 +177,7 @@ pub fn compute_deleted_bitset(
     segment_reader: &SegmentReader,
     delete_cursor: &mut DeleteCursor,
     doc_opstamps: &DocToOpstampMapping,
-    target_opstamp: Opstamp,
+    target_opstamp: u64,
 ) -> Result<bool> {
     let mut might_have_changed = false;
 
@@ -220,7 +219,7 @@ pub fn compute_deleted_bitset(
 pub fn advance_deletes(
     mut segment: Segment,
     segment_entry: &mut SegmentEntry,
-    target_opstamp: Opstamp,
+    target_opstamp: u64,
 ) -> Result<()> {
     {
         if segment_entry.meta().delete_opstamp() == Some(target_opstamp) {
@@ -300,11 +299,11 @@ fn index_documents(
     // the worker thread.
     assert!(num_docs > 0);
 
-    let doc_opstamps: Vec<Opstamp> = segment_writer.finalize()?;
+    let doc_opstamps: Vec<u64> = segment_writer.finalize()?;
 
     let segment_meta = SegmentMeta::new(segment_id, num_docs);
 
-    let last_docstamp: Opstamp = *(doc_opstamps.last().unwrap());
+    let last_docstamp: u64 = *(doc_opstamps.last().unwrap());
 
     let delete_bitset_opt = if delete_cursor.get().is_some() {
         let doc_to_opstamps = DocToOpstampMapping::from(doc_opstamps);
@@ -332,8 +331,7 @@ fn index_documents(
 }
 
 impl IndexWriter {
-    /// If there are some merging threads, blocks until they all finish their work and
-    /// then drop the `IndexWriter`.
+    /// The index writer
     pub fn wait_merging_threads(mut self) -> Result<()> {
         // this will stop the indexing thread,
         // dropping the last reference to the segment_updater.
@@ -384,6 +382,7 @@ impl IndexWriter {
 
     /// Spawns a new worker thread for indexing.
     /// The thread consumes documents from the pipeline.
+    ///
     fn add_indexing_worker(&mut self) -> Result<()> {
         let document_receiver_clone = self.operation_receiver.clone();
         let mut segment_updater = self.segment_updater.clone();
@@ -462,52 +461,6 @@ impl IndexWriter {
         self.segment_updater.garbage_collect_files()
     }
 
-    /// Deletes all documents from the index
-    ///
-    /// Requires `commit`ing
-    /// Enables users to rebuild the index,
-    /// by clearing and resubmitting necessary documents
-    ///
-    /// ```rust
-    /// #[macro_use]
-    /// extern crate tantivy;
-    /// use tantivy::query::QueryParser;
-    /// use tantivy::collector::TopDocs;
-    /// use tantivy::schema::*;
-    /// use tantivy::Index;
-    ///
-    /// fn main() -> tantivy::Result<()> {
-    ///     let mut schema_builder = Schema::builder();
-    ///     let title = schema_builder.add_text_field("title", TEXT | STORED);
-    ///     let schema = schema_builder.build();
-    ///
-    ///     let index = Index::create_in_ram(schema.clone());
-    ///
-    ///     let mut index_writer = index.writer_with_num_threads(1, 50_000_000)?;
-    ///     index_writer.add_document(doc!(title => "The modern Promotheus"));
-    ///     index_writer.commit()?;
-    ///
-    ///     let clear_res = index_writer.delete_all_documents().unwrap();
-    ///     // have to commit, otherwise deleted terms remain available
-    ///     index_writer.commit()?;
-    ///
-    ///     let searcher = index.reader()?.searcher();
-    ///     let query_parser = QueryParser::for_index(&index, vec![title]);
-    ///     let query_promo = query_parser.parse_query("Promotheus")?;
-    ///     let top_docs_promo = searcher.search(&query_promo, &TopDocs::with_limit(1))?;
-    ///
-    ///     assert!(top_docs_promo.is_empty());
-    ///     Ok(())
-    /// }
-    /// ```
-    pub fn delete_all_documents(&mut self) -> Result<Opstamp> {
-        // Delete segments
-        self.segment_updater.remove_all_segments();
-        // Return new stamp - reverted stamp
-        self.stamper.revert(self.committed_opstamp);
-        Ok(self.committed_opstamp)
-    }
-
     /// Merges a given list of segments
     ///
     /// `segment_ids` is required to be non-empty.
@@ -535,22 +488,19 @@ impl IndexWriter {
 
     /// Rollback to the last commit
     ///
-    /// This cancels all of the updates that
-    /// happened after the last commit.
+    /// This cancels all of the update that
+    /// happened before after the last commit.
     /// After calling rollback, the index is in the same
     /// state as it was after the last commit.
     ///
     /// The opstamp at the last commit is returned.
-    pub fn rollback(&mut self) -> Result<Opstamp> {
+    pub fn rollback(&mut self) -> Result<()> {
         info!("Rolling back to opstamp {}", self.committed_opstamp);
-        self.rollback_impl()
-    }
 
-    /// Private, implementation of rollback
-    fn rollback_impl(&mut self) -> Result<Opstamp> {
         // marks the segment updater as killed. From now on, all
         // segment updates will be ignored.
         self.segment_updater.kill();
+
         let document_receiver = self.operation_receiver.clone();
 
         // take the directory lock to create a new index_writer.
@@ -579,7 +529,7 @@ impl IndexWriter {
         // was dropped with the index_writer.
         for _ in document_receiver.clone() {}
 
-        Ok(self.committed_opstamp)
+        Ok(())
     }
 
     /// Prepares a commit.
@@ -617,7 +567,7 @@ impl IndexWriter {
         info!("Preparing commit");
 
         // this will drop the current document channel
-        // and recreate a new one.
+        // and recreate a new one channels.
         self.recreate_document_channel();
 
         let former_workers_join_handle = mem::replace(&mut self.workers_join_handle, Vec::new());
@@ -651,7 +601,7 @@ impl IndexWriter {
     /// Commit returns the `opstamp` of the last document
     /// that made it in the commit.
     ///
-    pub fn commit(&mut self) -> Result<Opstamp> {
+    pub fn commit(&mut self) -> Result<u64> {
         self.prepare_commit()?.commit()
     }
 
@@ -667,7 +617,7 @@ impl IndexWriter {
     ///
     /// Like adds, the deletion itself will be visible
     /// only after calling `commit()`.
-    pub fn delete_term(&self, term: Term) -> Opstamp {
+    pub fn delete_term(&mut self, term: Term) -> u64 {
         let opstamp = self.stamper.stamp();
         let delete_operation = DeleteOperation { opstamp, term };
         self.delete_queue.push(delete_operation);
@@ -681,7 +631,7 @@ impl IndexWriter {
     ///
     /// This is also the opstamp of the commit that is currently
     /// available for searchers.
-    pub fn commit_opstamp(&self) -> Opstamp {
+    pub fn commit_opstamp(&self) -> u64 {
         self.committed_opstamp
     }
 
@@ -695,7 +645,7 @@ impl IndexWriter {
     ///
     /// Currently it represents the number of documents that
     /// have been added since the creation of the index.
-    pub fn add_document(&self, document: Document) -> Opstamp {
+    pub fn add_document(&mut self, document: Document) -> u64 {
         let opstamp = self.stamper.stamp();
         let add_operation = AddOperation { opstamp, document };
         let send_result = self.operation_sender.send(vec![add_operation]);
@@ -712,7 +662,7 @@ impl IndexWriter {
     /// The total number of stamps generated by this method is `count + 1`;
     /// each operation gets a stamp from the `stamps` iterator and `last_opstamp`
     /// is for the batch itself.
-    fn get_batch_opstamps(&self, count: Opstamp) -> (Opstamp, Range<Opstamp>) {
+    fn get_batch_opstamps(&mut self, count: u64) -> (u64, Range<u64>) {
         let Range { start, end } = self.stamper.stamps(count + 1u64);
         let last_opstamp = end - 1;
         let stamps = Range {
@@ -738,7 +688,7 @@ impl IndexWriter {
     /// Like adds and deletes (see `IndexWriter.add_document` and
     /// `IndexWriter.delete_term`), the changes made by calling `run` will be
     /// visible to readers only after calling `commit()`.
-    pub fn run(&self, user_operations: Vec<UserOperation>) -> Opstamp {
+    pub fn run(&mut self, user_operations: Vec<UserOperation>) -> u64 {
         let count = user_operations.len() as u64;
         if count == 0 {
             return self.stamper.stamp();
@@ -789,7 +739,7 @@ mod tests {
         let mut schema_builder = schema::Schema::builder();
         let text_field = schema_builder.add_text_field("text", schema::TEXT);
         let index = Index::create_in_ram(schema_builder.build());
-        let index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
+        let mut index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
         let operations = vec![
             UserOperation::Add(doc!(text_field=>"a")),
             UserOperation::Add(doc!(text_field=>"b")),
@@ -851,7 +801,7 @@ mod tests {
     fn test_empty_operations_group() {
         let schema_builder = schema::Schema::builder();
         let index = Index::create_in_ram(schema_builder.build());
-        let index_writer = index.writer(3_000_000).unwrap();
+        let mut index_writer = index.writer(3_000_000).unwrap();
         let operations1 = vec![];
         let batch_opstamp1 = index_writer.run(operations1);
         assert_eq!(batch_opstamp1, 0u64);
@@ -1098,145 +1048,4 @@ mod tests {
         assert_eq!(num_docs_containing("b"), 0);
         fail::cfg("RAMDirectory::atomic_write", "off").unwrap();
     }
-
-    #[test]
-    fn test_add_then_delete_all_documents() {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        let reader = index
-            .reader_builder()
-            .reload_policy(ReloadPolicy::Manual)
-            .try_into()
-            .unwrap();
-        let num_docs_containing = |s: &str| {
-            reader.reload().unwrap();
-            let searcher = reader.searcher();
-            let term = Term::from_field_text(text_field, s);
-            searcher.doc_freq(&term)
-        };
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-
-        let add_tstamp = index_writer.add_document(doc!(text_field => "a"));
-        let commit_tstamp = index_writer.commit().unwrap();
-        assert!(commit_tstamp > add_tstamp);
-        index_writer.delete_all_documents().unwrap();
-        index_writer.commit().unwrap();
-
-        // Search for documents with the same term that we added
-        assert_eq!(num_docs_containing("a"), 0);
-    }
-
-    #[test]
-    fn test_delete_all_documents_rollback_correct_stamp() {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-
-        let add_tstamp = index_writer.add_document(doc!(text_field => "a"));
-
-        // commit documents - they are now available
-        let first_commit = index_writer.commit();
-        assert!(first_commit.is_ok());
-        let first_commit_tstamp = first_commit.unwrap();
-        assert!(first_commit_tstamp > add_tstamp);
-
-        // delete_all_documents the index
-        let clear_tstamp = index_writer.delete_all_documents().unwrap();
-        assert_eq!(clear_tstamp, add_tstamp);
-
-        // commit the clear command - now documents aren't available
-        let second_commit = index_writer.commit();
-        assert!(second_commit.is_ok());
-        let second_commit_tstamp = second_commit.unwrap();
-
-        // add new documents again
-        for _ in 0..100 {
-            index_writer.add_document(doc!(text_field => "b"));
-        }
-
-        // rollback to last commit, when index was empty
-        let rollback = index_writer.rollback();
-        assert!(rollback.is_ok());
-        let rollback_tstamp = rollback.unwrap();
-        assert_eq!(rollback_tstamp, second_commit_tstamp);
-
-        // working with an empty index == no documents
-        let term_b = Term::from_field_text(text_field, "b");
-        assert_eq!(index.reader().unwrap().searcher().doc_freq(&term_b), 0);
-    }
-
-    #[test]
-    fn test_delete_all_documents_then_add() {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        // writing the segment
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-        let res = index_writer.delete_all_documents();
-        assert!(res.is_ok());
-
-        assert!(index_writer.commit().is_ok());
-        // add one simple doc
-        index_writer.add_document(doc!(text_field => "a"));
-        assert!(index_writer.commit().is_ok());
-
-        let term_a = Term::from_field_text(text_field, "a");
-        // expect the document with that term to be in the index
-        assert_eq!(index.reader().unwrap().searcher().doc_freq(&term_a), 1);
-    }
-
-    #[test]
-    fn test_delete_all_documents_and_rollback() {
-        let mut schema_builder = schema::Schema::builder();
-        let text_field = schema_builder.add_text_field("text", schema::TEXT);
-        let index = Index::create_in_ram(schema_builder.build());
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-
-        // add one simple doc
-        index_writer.add_document(doc!(text_field => "a"));
-        let comm = index_writer.commit();
-        assert!(comm.is_ok());
-        let commit_tstamp = comm.unwrap();
-
-        // clear but don't commit!
-        let clear_tstamp = index_writer.delete_all_documents().unwrap();
-        // clear_tstamp should reset to before the last commit
-        assert!(clear_tstamp < commit_tstamp);
-
-        // rollback
-        let _rollback_tstamp = index_writer.rollback().unwrap();
-        // Find original docs in the index
-        let term_a = Term::from_field_text(text_field, "a");
-        // expect the document with that term to be in the index
-        assert_eq!(index.reader().unwrap().searcher().doc_freq(&term_a), 1);
-    }
-
-    #[test]
-    fn test_delete_all_documents_empty_index() {
-        let schema_builder = schema::Schema::builder();
-        let index = Index::create_in_ram(schema_builder.build());
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-        let clear = index_writer.delete_all_documents();
-        let commit = index_writer.commit();
-        assert!(clear.is_ok());
-        assert!(commit.is_ok());
-    }
-
-    #[test]
-    fn test_delete_all_documents_index_twice() {
-        let schema_builder = schema::Schema::builder();
-        let index = Index::create_in_ram(schema_builder.build());
-        let mut index_writer = index.writer_with_num_threads(4, 12_000_000).unwrap();
-        let clear = index_writer.delete_all_documents();
-        let commit = index_writer.commit();
-        assert!(clear.is_ok());
-        assert!(commit.is_ok());
-        let clear_again = index_writer.delete_all_documents();
-        let commit_again = index_writer.commit();
-        assert!(clear_again.is_ok());
-        assert!(commit_again.is_ok());
-    }
-
 }

src/indexer/log_merge_policy.rs

@@ -52,7 +52,7 @@ impl MergePolicy for LogMergePolicy {
 
         let mut size_sorted_tuples = segments
             .iter()
-            .map(SegmentMeta::num_docs)
+            .map(|x| x.num_docs())
             .enumerate()
             .collect::<Vec<(usize, u32)>>();
 

src/indexer/merge_operation.rs

@@ -1,6 +1,5 @@
 use census::{Inventory, TrackedObject};
 use std::collections::HashSet;
-use Opstamp;
 use SegmentId;
 
 #[derive(Default)]
@@ -18,8 +17,8 @@ impl MergeOperationInventory {
     }
 }
 
-/// A `MergeOperation` has two roles.
-/// It carries all of the information required to describe a merge:
+/// A `MergeOperation` has two role.
+/// It carries all of the information required to describe a merge :
 /// - `target_opstamp` is the opstamp up to which we want to consume the
 /// delete queue and reflect their deletes.
 /// - `segment_ids` is the list of segment to be merged.
@@ -36,14 +35,14 @@ pub struct MergeOperation {
 }
 
 struct InnerMergeOperation {
-    target_opstamp: Opstamp,
+    target_opstamp: u64,
     segment_ids: Vec<SegmentId>,
 }
 
 impl MergeOperation {
     pub fn new(
         inventory: &MergeOperationInventory,
-        target_opstamp: Opstamp,
+        target_opstamp: u64,
         segment_ids: Vec<SegmentId>,
     ) -> MergeOperation {
         let inner_merge_operation = InnerMergeOperation {
@@ -55,7 +54,7 @@ impl MergeOperation {
         }
     }
 
-    pub fn target_opstamp(&self) -> Opstamp {
+    pub fn target_opstamp(&self) -> u64 {
         self.inner.target_opstamp
     }
 

src/indexer/merger.rs

@@ -3,7 +3,6 @@ use core::Segment;
 use core::SegmentReader;
 use core::SerializableSegment;
 use docset::DocSet;
-use fastfield::BytesFastFieldReader;
 use fastfield::DeleteBitSet;
 use fastfield::FastFieldReader;
 use fastfield::FastFieldSerializer;
@@ -73,7 +72,7 @@ fn compute_min_max_val(
                 // some deleted documents,
                 // we need to recompute the max / min
                 (0..max_doc)
-                    .filter(|doc_id| delete_bitset.is_alive(*doc_id))
+                    .filter(|doc_id| !delete_bitset.is_deleted(*doc_id))
                     .map(|doc_id| u64_reader.get(doc_id))
                     .minmax()
                     .into_option()
@@ -240,10 +239,7 @@ impl IndexMerger {
         let mut max_value = u64::min_value();
 
         for reader in &self.readers {
-            let u64_reader: FastFieldReader<u64> = reader
-                .fast_fields()
-                .u64_lenient(field)
-                .expect("Failed to find a reader for single fast field. This is a tantivy bug and it should never happen.");
+            let u64_reader: FastFieldReader<u64> = reader.fast_field_reader(field)?;
             if let Some((seg_min_val, seg_max_val)) =
                 compute_min_max_val(&u64_reader, reader.max_doc(), reader.delete_bitset())
             {
@@ -286,28 +282,24 @@ impl IndexMerger {
         fast_field_serializer: &mut FastFieldSerializer,
     ) -> Result<()> {
         let mut total_num_vals = 0u64;
-        let mut u64s_readers: Vec<MultiValueIntFastFieldReader<u64>> = Vec::new();
 
         // In the first pass, we compute the total number of vals.
         //
         // This is required by the bitpacker, as it needs to know
         // what should be the bit length use for bitpacking.
         for reader in &self.readers {
-            let u64s_reader = reader.fast_fields()
-                .u64s_lenient(field)
-                .expect("Failed to find index for multivalued field. This is a bug in tantivy, please report.");
-
+            let idx_reader = reader.fast_field_reader_with_idx::<u64>(field, 0)?;
             if let Some(delete_bitset) = reader.delete_bitset() {
                 for doc in 0u32..reader.max_doc() {
-                    if delete_bitset.is_alive(doc) {
-                        let num_vals = u64s_reader.num_vals(doc) as u64;
-                        total_num_vals += num_vals;
+                    if !delete_bitset.is_deleted(doc) {
+                        let start = idx_reader.get(doc);
+                        let end = idx_reader.get(doc + 1);
+                        total_num_vals += end - start;
                     }
                 }
             } else {
-                total_num_vals += u64s_reader.total_num_vals();
+                total_num_vals += idx_reader.max_value();
             }
-            u64s_readers.push(u64s_reader);
         }
 
         // We can now create our `idx` serializer, and in a second pass,
@@ -315,10 +307,13 @@ impl IndexMerger {
         let mut serialize_idx =
             fast_field_serializer.new_u64_fast_field_with_idx(field, 0, total_num_vals, 0)?;
         let mut idx = 0;
-        for (segment_reader, u64s_reader) in self.readers.iter().zip(&u64s_readers) {
-            for doc in segment_reader.doc_ids_alive() {
+        for reader in &self.readers {
+            let idx_reader = reader.fast_field_reader_with_idx::<u64>(field, 0)?;
+            for doc in reader.doc_ids_alive() {
                 serialize_idx.add_val(idx)?;
-                idx += u64s_reader.num_vals(doc) as u64;
+                let start = idx_reader.get(doc);
+                let end = idx_reader.get(doc + 1);
+                idx += end - start;
             }
         }
         serialize_idx.add_val(idx)?;
@@ -349,10 +344,8 @@ impl IndexMerger {
             for (segment_ord, segment_reader) in self.readers.iter().enumerate() {
                 let term_ordinal_mapping: &[TermOrdinal] =
                     term_ordinal_mappings.get_segment(segment_ord);
-                let ff_reader: MultiValueIntFastFieldReader<u64> = segment_reader
-                    .fast_fields()
-                    .u64s(field)
-                    .expect("Could not find multivalued u64 fast value reader.");
+                let ff_reader: MultiValueIntFastFieldReader<u64> =
+                    segment_reader.multi_fast_field_reader(field)?;
                 // TODO optimize if no deletes
                 for doc in segment_reader.doc_ids_alive() {
                     ff_reader.get_vals(doc, &mut vals);
@@ -384,8 +377,6 @@ impl IndexMerger {
 
         let mut vals = Vec::with_capacity(100);
 
-        let mut ff_readers = Vec::new();
-
         // Our values are bitpacked and we need to know what should be
         // our bitwidth and our minimum value before serializing any values.
         //
@@ -394,10 +385,7 @@ impl IndexMerger {
         // maximum value and initialize our Serializer.
         for reader in &self.readers {
             let ff_reader: MultiValueIntFastFieldReader<u64> =
-                reader.fast_fields().u64s_lenient(field).expect(
-                    "Failed to find multivalued fast field reader. This is a bug in \
-                     tantivy. Please report.",
-                );
+                reader.multi_fast_field_reader(field)?;
             for doc in reader.doc_ids_alive() {
                 ff_reader.get_vals(doc, &mut vals);
                 for &val in &vals {
@@ -405,7 +393,6 @@ impl IndexMerger {
                     max_value = cmp::max(val, max_value);
                 }
             }
-            ff_readers.push(ff_reader);
             // TODO optimize when no deletes
         }
 
@@ -418,7 +405,9 @@ impl IndexMerger {
         {
             let mut serialize_vals = fast_field_serializer
                 .new_u64_fast_field_with_idx(field, min_value, max_value, 1)?;
-            for (reader, ff_reader) in self.readers.iter().zip(ff_readers) {
+            for reader in &self.readers {
+                let ff_reader: MultiValueIntFastFieldReader<u64> =
+                    reader.multi_fast_field_reader(field)?;
                 // TODO optimize if no deletes
                 for doc in reader.doc_ids_alive() {
                     ff_reader.get_vals(doc, &mut vals);
@@ -437,53 +426,19 @@ impl IndexMerger {
         field: Field,
         fast_field_serializer: &mut FastFieldSerializer,
     ) -> Result<()> {
-        let mut total_num_vals = 0u64;
-        let mut bytes_readers: Vec<BytesFastFieldReader> = Vec::new();
-
-        for reader in &self.readers {
-            let bytes_reader = reader.fast_fields().bytes(field).expect(
-                "Failed to find bytes fast field reader. This is a bug in tantivy, please report.",
-            );
-            if let Some(delete_bitset) = reader.delete_bitset() {
-                for doc in 0u32..reader.max_doc() {
-                    if delete_bitset.is_alive(doc) {
-                        let num_vals = bytes_reader.get_bytes(doc).len() as u64;
-                        total_num_vals += num_vals;
-                    }
-                }
-            } else {
-                total_num_vals += bytes_reader.total_num_bytes() as u64;
-            }
-            bytes_readers.push(bytes_reader);
-        }
-
-        {
-            // We can now create our `idx` serializer, and in a second pass,
-            // can effectively push the different indexes.
-            let mut serialize_idx =
-                fast_field_serializer.new_u64_fast_field_with_idx(field, 0, total_num_vals, 0)?;
-            let mut idx = 0;
-            for (segment_reader, bytes_reader) in self.readers.iter().zip(&bytes_readers) {
-                for doc in segment_reader.doc_ids_alive() {
-                    serialize_idx.add_val(idx)?;
-                    idx += bytes_reader.get_bytes(doc).len() as u64;
-                }
-            }
-            serialize_idx.add_val(idx)?;
-            serialize_idx.close_field()?;
-        }
+        self.write_fast_field_idx(field, fast_field_serializer)?;
 
         let mut serialize_vals = fast_field_serializer.new_bytes_fast_field_with_idx(field, 1)?;
-        for segment_reader in &self.readers {
-            let bytes_reader = segment_reader.fast_fields().bytes(field)
-                .expect("Failed to find bytes field in fast field reader. This is a bug in tantivy. Please report.");
+        for reader in &self.readers {
+            let bytes_reader = reader.bytes_fast_field_reader(field)?;
             // TODO: optimize if no deletes
-            for doc in segment_reader.doc_ids_alive() {
-                let val = bytes_reader.get_bytes(doc);
+            for doc in reader.doc_ids_alive() {
+                let val = bytes_reader.get_val(doc);
                 serialize_vals.write_all(val)?;
             }
         }
         serialize_vals.flush()?;
+
         Ok(())
     }
 
@@ -1024,16 +979,14 @@ mod tests {
 
             let score_field_reader = searcher
                 .segment_reader(0)
-                .fast_fields()
-                .u64(score_field)
+                .fast_field_reader::<u64>(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 4000);
             assert_eq!(score_field_reader.max_value(), 7000);
 
             let score_field_reader = searcher
                 .segment_reader(1)
-                .fast_fields()
-                .u64(score_field)
+                .fast_field_reader::<u64>(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 1);
             assert_eq!(score_field_reader.max_value(), 3);
@@ -1084,8 +1037,7 @@ mod tests {
             );
             let score_field_reader = searcher
                 .segment_reader(0)
-                .fast_fields()
-                .u64(score_field)
+                .fast_field_reader::<u64>(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 3);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1131,8 +1083,7 @@ mod tests {
             );
             let score_field_reader = searcher
                 .segment_reader(0)
-                .fast_fields()
-                .u64(score_field)
+                .fast_field_reader::<u64>(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 3);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1184,8 +1135,7 @@ mod tests {
             );
             let score_field_reader = searcher
                 .segment_reader(0)
-                .fast_fields()
-                .u64(score_field)
+                .fast_field_reader::<u64>(score_field)
                 .unwrap();
             assert_eq!(score_field_reader.min_value(), 6000);
             assert_eq!(score_field_reader.max_value(), 7000);
@@ -1431,7 +1381,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(0u32);
-            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
+            let ff_reader = segment.multi_fast_field_reader(int_field).unwrap();
 
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[1, 2]);
@@ -1466,7 +1416,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(1u32);
-            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
+            let ff_reader = segment.multi_fast_field_reader(int_field).unwrap();
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[28, 27]);
 
@@ -1476,7 +1426,7 @@ mod tests {
 
         {
             let segment = searcher.segment_reader(2u32);
-            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
+            let ff_reader = segment.multi_fast_field_reader(int_field).unwrap();
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[20]);
         }
@@ -1509,7 +1459,7 @@ mod tests {
                     .collect::<Vec<_>>()
             );
             let segment = searcher.segment_reader(0u32);
-            let ff_reader = segment.fast_fields().u64s(int_field).unwrap();
+            let ff_reader = segment.multi_fast_field_reader(int_field).unwrap();
 
             ff_reader.get_vals(0, &mut vals);
             assert_eq!(&vals, &[1, 2]);

src/indexer/operation.rs

@@ -1,18 +1,17 @@
 use schema::Document;
 use schema::Term;
-use Opstamp;
 
 /// Timestamped Delete operation.
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct DeleteOperation {
-    pub opstamp: Opstamp,
+    pub opstamp: u64,
     pub term: Term,
 }
 
 /// Timestamped Add operation.
 #[derive(Eq, PartialEq, Debug)]
 pub struct AddOperation {
-    pub opstamp: Opstamp,
+    pub opstamp: u64,
     pub document: Document,
 }
 

src/indexer/prepared_commit.rs

@@ -1,16 +1,15 @@
 use super::IndexWriter;
-use Opstamp;
 use Result;
 
 /// A prepared commit
 pub struct PreparedCommit<'a> {
     index_writer: &'a mut IndexWriter,
     payload: Option<String>,
-    opstamp: Opstamp,
+    opstamp: u64,
 }
 
 impl<'a> PreparedCommit<'a> {
-    pub(crate) fn new(index_writer: &'a mut IndexWriter, opstamp: Opstamp) -> PreparedCommit {
+    pub(crate) fn new(index_writer: &'a mut IndexWriter, opstamp: u64) -> PreparedCommit {
         PreparedCommit {
             index_writer,
             payload: None,
@@ -18,7 +17,7 @@ impl<'a> PreparedCommit<'a> {
         }
     }
 
-    pub fn opstamp(&self) -> Opstamp {
+    pub fn opstamp(&self) -> u64 {
         self.opstamp
     }
 
@@ -26,11 +25,11 @@ impl<'a> PreparedCommit<'a> {
         self.payload = Some(payload.to_string())
     }
 
-    pub fn abort(self) -> Result<Opstamp> {
+    pub fn abort(self) -> Result<()> {
         self.index_writer.rollback()
     }
 
-    pub fn commit(self) -> Result<Opstamp> {
+    pub fn commit(self) -> Result<u64> {
         info!("committing {}", self.opstamp);
         self.index_writer
             .segment_updater()

src/indexer/segment_manager.rs

@@ -118,12 +118,6 @@ impl SegmentManager {
             });
     }
 
-    pub(crate) fn remove_all_segments(&self) {
-        let mut registers_lock = self.write();
-        registers_lock.committed.clear();
-        registers_lock.uncommitted.clear();
-    }
-
     pub fn commit(&self, segment_entries: Vec<SegmentEntry>) {
         let mut registers_lock = self.write();
         registers_lock.committed.clear();

src/indexer/segment_register.rs

@@ -56,7 +56,7 @@ impl SegmentRegister {
             .values()
             .map(|segment_entry| segment_entry.meta().clone())
             .collect();
-        segment_ids.sort_by_key(SegmentMeta::id);
+        segment_ids.sort_by_key(|meta| meta.id());
         segment_ids
     }
 

src/indexer/segment_updater.rs

@@ -36,15 +36,14 @@ use std::sync::Arc;
 use std::sync::RwLock;
 use std::thread;
 use std::thread::JoinHandle;
-use Opstamp;
 use Result;
 
 /// Save the index meta file.
 /// This operation is atomic :
 /// Either
-///  - it fails, in which case an error is returned,
+//  - it fails, in which case an error is returned,
 /// and the `meta.json` remains untouched,
-/// - it succeeds, and `meta.json` is written
+/// - it success, and `meta.json` is written
 /// and flushed.
 ///
 /// This method is not part of tantivy's public API
@@ -70,7 +69,6 @@ pub fn save_new_metas(schema: Schema, directory: &mut Directory) -> Result<()> {
 ///
 /// This method is not part of tantivy's public API
 fn save_metas(metas: &IndexMeta, directory: &mut Directory) -> Result<()> {
-    info!("save metas");
     let mut buffer = serde_json::to_vec_pretty(metas)?;
     // Just adding a new line at the end of the buffer.
     writeln!(&mut buffer)?;
@@ -214,11 +212,6 @@ impl SegmentUpdater {
         }
     }
 
-    /// Orders `SegmentManager` to remove all segments
-    pub(crate) fn remove_all_segments(&self) {
-        self.0.segment_manager.remove_all_segments();
-    }
-
     pub fn kill(&mut self) {
         self.0.killed.store(true, Ordering::Release);
     }
@@ -229,9 +222,9 @@ impl SegmentUpdater {
 
     /// Apply deletes up to the target opstamp to all segments.
     ///
-    /// The method returns copies of the segment entries,
+    /// Tne method returns copies of the segment entries,
     /// updated with the delete information.
-    fn purge_deletes(&self, target_opstamp: Opstamp) -> Result<Vec<SegmentEntry>> {
+    fn purge_deletes(&self, target_opstamp: u64) -> Result<Vec<SegmentEntry>> {
         let mut segment_entries = self.0.segment_manager.segment_entries();
         for segment_entry in &mut segment_entries {
             let segment = self.0.index.segment(segment_entry.meta().clone());
@@ -240,7 +233,7 @@ impl SegmentUpdater {
         Ok(segment_entries)
     }
 
-    pub fn save_metas(&self, opstamp: Opstamp, commit_message: Option<String>) {
+    pub fn save_metas(&self, opstamp: u64, commit_message: Option<String>) {
         if self.is_alive() {
             let index = &self.0.index;
             let directory = index.directory();
@@ -287,7 +280,7 @@ impl SegmentUpdater {
             .garbage_collect(|| self.0.segment_manager.list_files());
     }
 
-    pub fn commit(&self, opstamp: Opstamp, payload: Option<String>) -> Result<()> {
+    pub fn commit(&self, opstamp: u64, payload: Option<String>) -> Result<()> {
         self.run_async(move |segment_updater| {
             if segment_updater.is_alive() {
                 let segment_entries = segment_updater
@@ -452,41 +445,38 @@ impl SegmentUpdater {
     ) -> Result<()> {
         self.run_async(move |segment_updater| {
             info!("End merge {:?}", after_merge_segment_entry.meta());
-            {
-                let mut delete_cursor = after_merge_segment_entry.delete_cursor().clone();
-                if let Some(delete_operation) = delete_cursor.get() {
-                    let committed_opstamp = segment_updater.load_metas().opstamp;
-                    if delete_operation.opstamp < committed_opstamp {
-                        let index = &segment_updater.0.index;
-                        let segment = index.segment(after_merge_segment_entry.meta().clone());
-                        if let Err(e) = advance_deletes(
-                            segment,
-                            &mut after_merge_segment_entry,
-                            committed_opstamp,
-                        ) {
-                            error!(
-                                "Merge of {:?} was cancelled (advancing deletes failed): {:?}",
-                                merge_operation.segment_ids(),
-                                e
-                            );
-                            if cfg!(test) {
-                                panic!("Merge failed.");
-                            }
-                            // ... cancel merge
-                            // `merge_operations` are tracked. As it is dropped, the
-                            // the segment_ids will be available again for merge.
-                            return;
+            let mut delete_cursor = after_merge_segment_entry.delete_cursor().clone();
+            if let Some(delete_operation) = delete_cursor.get() {
+                let committed_opstamp = segment_updater.load_metas().opstamp;
+                if delete_operation.opstamp < committed_opstamp {
+                    let index = &segment_updater.0.index;
+                    let segment = index.segment(after_merge_segment_entry.meta().clone());
+                    if let Err(e) =
+                        advance_deletes(segment, &mut after_merge_segment_entry, committed_opstamp)
+                    {
+                        error!(
+                            "Merge of {:?} was cancelled (advancing deletes failed): {:?}",
+                            merge_operation.segment_ids(),
+                            e
+                        );
+                        if cfg!(test) {
+                            panic!("Merge failed.");
                         }
+                        // ... cancel merge
+                        // `merge_operations` are tracked. As it is dropped, the
+                        // the segment_ids will be available again for merge.
+                        return;
                     }
                 }
-                let previous_metas = segment_updater.load_metas();
-                segment_updater
-                    .0
-                    .segment_manager
-                    .end_merge(merge_operation.segment_ids(), after_merge_segment_entry);
-                segment_updater.consider_merge_options();
-                segment_updater.save_metas(previous_metas.opstamp, previous_metas.payload.clone());
-            } // we drop all possible handle to a now useless `SegmentMeta`.
+            }
+            segment_updater
+                .0
+                .segment_manager
+                .end_merge(merge_operation.segment_ids(), after_merge_segment_entry);
+            segment_updater.consider_merge_options();
+            info!("save metas");
+            let previous_metas = segment_updater.load_metas();
+            segment_updater.save_metas(previous_metas.opstamp, previous_metas.payload.clone());
             segment_updater.garbage_collect_files_exec();
         })
         .wait()
@@ -660,31 +650,4 @@ mod tests {
         assert!(index.searchable_segment_metas().unwrap().is_empty());
         assert!(reader.searcher().segment_readers().is_empty());
     }
-
-    #[test]
-    fn test_remove_all_segments() {
-        let mut schema_builder = Schema::builder();
-        let text_field = schema_builder.add_text_field("text", TEXT);
-        let schema = schema_builder.build();
-
-        let index = Index::create_in_ram(schema);
-
-        // writing the segment
-        let mut index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
-
-        {
-            for _ in 0..100 {
-                index_writer.add_document(doc!(text_field=>"a"));
-                index_writer.add_document(doc!(text_field=>"b"));
-            }
-            assert!(index_writer.commit().is_ok());
-        }
-        index_writer.segment_updater().remove_all_segments();
-        let seg_vec = index_writer
-            .segment_updater()
-            .0
-            .segment_manager
-            .segment_entries();
-        assert!(seg_vec.is_empty());
-    }
 }

src/indexer/segment_writer.rs

@@ -5,7 +5,6 @@ use fastfield::FastFieldsWriter;
 use fieldnorm::FieldNormsWriter;
 use indexer::segment_serializer::SegmentSerializer;
 use postings::MultiFieldPostingsWriter;
-use schema::FieldEntry;
 use schema::FieldType;
 use schema::Schema;
 use schema::Term;
@@ -16,11 +15,10 @@ use tokenizer::BoxedTokenizer;
 use tokenizer::FacetTokenizer;
 use tokenizer::{TokenStream, Tokenizer};
 use DocId;
-use Opstamp;
 use Result;
 
 /// A `SegmentWriter` is in charge of creating segment index from a
-/// set of documents.
+/// documents.
 ///
 /// They creates the postings list in anonymous memory.
 /// The segment is layed on disk when the segment gets `finalized`.
@@ -30,7 +28,7 @@ pub struct SegmentWriter {
     segment_serializer: SegmentSerializer,
     fast_field_writers: FastFieldsWriter,
     fieldnorms_writer: FieldNormsWriter,
-    doc_opstamps: Vec<Opstamp>,
+    doc_opstamps: Vec<u64>,
     tokenizers: Vec<Option<Box<BoxedTokenizer>>>,
 }
 
@@ -55,7 +53,7 @@ impl SegmentWriter {
             schema
                 .fields()
                 .iter()
-                .map(FieldEntry::field_type)
+                .map(|field_entry| field_entry.field_type())
                 .map(|field_type| match *field_type {
                     FieldType::Str(ref text_options) => text_options
                         .get_indexing_options()

src/indexer/stamper.rs

@@ -1,39 +1,76 @@
 use std::ops::Range;
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use Opstamp;
 
-/// Stamper provides Opstamps, which is just an auto-increment id to label
-/// an operation.
-///
-/// Cloning does not "fork" the stamp generation. The stamper actually wraps an `Arc`.
+// AtomicU64 have not landed in stable.
+// For the moment let's just use AtomicUsize on
+// x86/64 bit platform, and a mutex on other platform.
+#[cfg(target_arch = "x86_64")]
+mod archicture_impl {
+
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[derive(Default)]
+    pub struct AtomicU64Ersatz(AtomicUsize);
+
+    impl AtomicU64Ersatz {
+        pub fn new(first_opstamp: u64) -> AtomicU64Ersatz {
+            AtomicU64Ersatz(AtomicUsize::new(first_opstamp as usize))
+        }
+
+        pub fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
+            self.0.fetch_add(val as usize, order) as u64
+        }
+    }
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+mod archicture_impl {
+
+    use std::sync::atomic::Ordering;
+    /// Under other architecture, we rely on a mutex.
+    use std::sync::RwLock;
+
+    #[derive(Default)]
+    pub struct AtomicU64Ersatz(RwLock<u64>);
+
+    impl AtomicU64Ersatz {
+        pub fn new(first_opstamp: u64) -> AtomicU64Ersatz {
+            AtomicU64Ersatz(RwLock::new(first_opstamp))
+        }
+
+        pub fn fetch_add(&self, incr: u64, _order: Ordering) -> u64 {
+            let mut lock = self.0.write().unwrap();
+            let previous_val = *lock;
+            *lock = previous_val + incr;
+            previous_val
+        }
+    }
+}
+
+use self::archicture_impl::AtomicU64Ersatz;
+
 #[derive(Clone, Default)]
-pub struct Stamper(Arc<AtomicU64>);
+pub struct Stamper(Arc<AtomicU64Ersatz>);
 
 impl Stamper {
-    pub fn new(first_opstamp: Opstamp) -> Stamper {
-        Stamper(Arc::new(AtomicU64::new(first_opstamp)))
+    pub fn new(first_opstamp: u64) -> Stamper {
+        Stamper(Arc::new(AtomicU64Ersatz::new(first_opstamp)))
     }
 
-    pub fn stamp(&self) -> Opstamp {
+    pub fn stamp(&self) -> u64 {
         self.0.fetch_add(1u64, Ordering::SeqCst) as u64
     }
 
     /// Given a desired count `n`, `stamps` returns an iterator that
     /// will supply `n` number of u64 stamps.
-    pub fn stamps(&self, n: u64) -> Range<Opstamp> {
+    pub fn stamps(&self, n: u64) -> Range<u64> {
         let start = self.0.fetch_add(n, Ordering::SeqCst);
         Range {
             start,
             end: start + n,
         }
     }
-
-    /// Reverts the stamper to a given `Opstamp` value and returns it
-    pub fn revert(&self, to_opstamp: Opstamp) -> Opstamp {
-        self.0.store(to_opstamp, Ordering::SeqCst);
-        to_opstamp
-    }
 }
 
 #[cfg(test)]
@@ -55,18 +92,4 @@ mod test {
         assert_eq!(stamper.stamps(3u64), (12..15));
         assert_eq!(stamper.stamp(), 15u64);
     }
-
-    #[test]
-    fn test_stamper_revert() {
-        let stamper = Stamper::new(7u64);
-        assert_eq!(stamper.stamp(), 7u64);
-        assert_eq!(stamper.stamp(), 8u64);
-
-        let stamper_clone = stamper.clone();
-        assert_eq!(stamper_clone.stamp(), 9u64);
-
-        stamper.revert(6);
-        assert_eq!(stamper.stamp(), 6);
-        assert_eq!(stamper_clone.stamp(), 7);
-    }
 }

src/lib.rs

@@ -226,7 +226,7 @@ mod docset;
 pub use self::docset::{DocSet, SkipResult};
 
 pub use core::SegmentComponent;
-pub use core::{Index, IndexMeta, Searcher, Segment, SegmentId, SegmentMeta};
+pub use core::{Index, Searcher, Segment, SegmentId, SegmentMeta};
 pub use core::{InvertedIndexReader, SegmentReader};
 pub use directory::Directory;
 pub use indexer::IndexWriter;
@@ -254,16 +254,6 @@ pub mod merge_policy {
 /// as they are added in the segment.
 pub type DocId = u32;
 
-/// A u64 assigned to every operation incrementally
-///
-/// All operations modifying the index receives an monotonic Opstamp.
-/// The resulting state of the index is consistent with the opstamp ordering.
-///
-/// For instance, a commit with opstamp `32_423` will reflect all Add and Delete operations
-/// with an opstamp `<= 32_423`. A delete operation with opstamp n will no affect a document added
-/// with opstamp `n+1`.
-pub type Opstamp = u64;
-
 /// A f32 that represents the relevance of the document to the query
 ///
 /// This is modelled internally as a `f32`. The
@@ -886,28 +876,28 @@ mod tests {
         let searcher = reader.searcher();
         let segment_reader: &SegmentReader = searcher.segment_reader(0);
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64(text_field);
-            assert!(fast_field_reader_opt.is_none());
+            let fast_field_reader_res = segment_reader.fast_field_reader::<u64>(text_field);
+            assert!(fast_field_reader_res.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64(stored_int_field);
-            assert!(fast_field_reader_opt.is_none());
+            let fast_field_reader_res = segment_reader.fast_field_reader::<u64>(stored_int_field);
+            assert!(fast_field_reader_res.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().u64(fast_field_signed);
-            assert!(fast_field_reader_opt.is_none());
+            let fast_field_reader_res = segment_reader.fast_field_reader::<u64>(fast_field_signed);
+            assert!(fast_field_reader_res.is_err());
         }
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().i64(fast_field_signed);
-            assert!(fast_field_reader_opt.is_some());
-            let fast_field_reader = fast_field_reader_opt.unwrap();
+            let fast_field_reader_res = segment_reader.fast_field_reader::<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(0), 4i64)
         }
 
         {
-            let fast_field_reader_opt = segment_reader.fast_fields().i64(fast_field_signed);
-            assert!(fast_field_reader_opt.is_some());
-            let fast_field_reader = fast_field_reader_opt.unwrap();
+            let fast_field_reader_res = segment_reader.fast_field_reader::<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(0), 4i64)
         }
     }

src/postings/serializer.rs

@@ -175,7 +175,7 @@ impl<'a> FieldSerializer<'a> {
         let positions_idx = self
             .positions_serializer_opt
             .as_ref()
-            .map(PositionSerializer::positions_idx)
+            .map(|positions_serializer| positions_serializer.positions_idx())
             .unwrap_or(0u64);
         TermInfo {
             doc_freq: 0,

src/query/all_query.rs

@@ -1,8 +1,7 @@
 use core::Searcher;
 use core::SegmentReader;
 use docset::DocSet;
-use query::explanation::does_not_match;
-use query::{Explanation, Query, Scorer, Weight};
+use query::{Query, Scorer, Weight};
 use DocId;
 use Result;
 use Score;
@@ -30,13 +29,6 @@ impl Weight for AllWeight {
             max_doc: reader.max_doc(),
         }))
     }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        if doc >= reader.max_doc() {
-            return Err(does_not_match(doc));
-        }
-        Ok(Explanation::new("AllQuery", 1f32))
-    }
 }
 
 enum State {

src/query/automaton_weight.rs

@@ -1,14 +1,12 @@
 use common::BitSet;
 use core::SegmentReader;
+use query::BitSetDocSet;
 use query::ConstScorer;
-use query::{BitSetDocSet, Explanation};
 use query::{Scorer, Weight};
 use schema::{Field, IndexRecordOption};
 use tantivy_fst::Automaton;
 use termdict::{TermDictionary, TermStreamer};
-use DocId;
-use TantivyError;
-use {Result, SkipResult};
+use Result;
 
 /// A weight struct for Fuzzy Term and Regex Queries
 pub struct AutomatonWeight<A>
@@ -58,15 +56,4 @@ where
         let doc_bitset = BitSetDocSet::from(doc_bitset);
         Ok(Box::new(ConstScorer::new(doc_bitset)))
     }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        let mut scorer = self.scorer(reader)?;
-        if scorer.skip_next(doc) == SkipResult::Reached {
-            Ok(Explanation::new("AutomatonScorer", 1.0f32))
-        } else {
-            Err(TantivyError::InvalidArgument(
-                "Document does not exist".to_string(),
-            ))
-        }
-    }
 }

src/query/bm25.rs

@@ -1,5 +1,4 @@
 use fieldnorm::FieldNormReader;
-use query::Explanation;
 use Score;
 use Searcher;
 use Term;
@@ -27,13 +26,18 @@ fn compute_tf_cache(average_fieldnorm: f32) -> [f32; 256] {
 
 #[derive(Clone)]
 pub struct BM25Weight {
-    idf_explain: Explanation,
     weight: f32,
     cache: [f32; 256],
-    average_fieldnorm: f32,
 }
 
 impl BM25Weight {
+    pub fn null() -> BM25Weight {
+        BM25Weight {
+            weight: 0f32,
+            cache: [1f32; 256],
+        }
+    }
+
     pub fn for_terms(searcher: &Searcher, terms: &[Term]) -> BM25Weight {
         assert!(!terms.is_empty(), "BM25 requires at least one term");
         let field = terms[0].field();
@@ -54,37 +58,20 @@ impl BM25Weight {
         }
         let average_fieldnorm = total_num_tokens as f32 / total_num_docs as f32;
 
-        let mut idf_explain: Explanation;
-        if terms.len() == 1 {
-            let term_doc_freq = searcher.doc_freq(&terms[0]);
-            let idf = idf(term_doc_freq, total_num_docs);
-            idf_explain =
-                Explanation::new("idf, computed as log(1 + (N - n + 0.5) / (n + 0.5))", idf);
-            idf_explain.add_const(
-                "n, number of docs containing this term",
-                term_doc_freq as f32,
-            );
-            idf_explain.add_const("N, total number of docs", total_num_docs as f32);
-        } else {
-            let idf = terms
-                .iter()
-                .map(|term| {
-                    let term_doc_freq = searcher.doc_freq(term);
-                    idf(term_doc_freq, total_num_docs)
-                })
-                .sum::<f32>();
-            idf_explain = Explanation::new("idf", idf);
-        }
-        BM25Weight::new(idf_explain, average_fieldnorm)
+        let idf = terms
+            .iter()
+            .map(|term| {
+                let term_doc_freq = searcher.doc_freq(term);
+                idf(term_doc_freq, total_num_docs)
+            })
+            .sum::<f32>();
+        BM25Weight::new(idf, average_fieldnorm)
     }
 
-    fn new(idf_explain: Explanation, average_fieldnorm: f32) -> BM25Weight {
-        let weight = idf_explain.value() * (1f32 + K1);
+    fn new(idf: f32, average_fieldnorm: f32) -> BM25Weight {
         BM25Weight {
-            idf_explain,
-            weight,
+            weight: idf * (1f32 + K1),
             cache: compute_tf_cache(average_fieldnorm),
-            average_fieldnorm,
         }
     }
 
@@ -94,37 +81,6 @@ impl BM25Weight {
         let term_freq = term_freq as f32;
         self.weight * term_freq / (term_freq + norm)
     }
-
-    pub fn explain(&self, fieldnorm_id: u8, term_freq: u32) -> Explanation {
-        // The explain format is directly copied from Lucene's.
-        // (So, Kudos to Lucene)
-
-        let score = self.score(fieldnorm_id, term_freq);
-
-        let norm = self.cache[fieldnorm_id as usize];
-        let term_freq = term_freq as f32;
-        let right_factor = term_freq / (term_freq + norm);
-
-        let mut tf_explanation = Explanation::new(
-            "freq / (freq + k1 * (1 - b + b * dl / avgdl))",
-            right_factor,
-        );
-
-        tf_explanation.add_const("freq, occurrences of term within document", term_freq);
-        tf_explanation.add_const("k1, term saturation parameter", K1);
-        tf_explanation.add_const("b, length normalization parameter", B);
-        tf_explanation.add_const(
-            "dl, length of field",
-            FieldNormReader::id_to_fieldnorm(fieldnorm_id) as f32,
-        );
-        tf_explanation.add_const("avgdl, average length of field", self.average_fieldnorm);
-
-        let mut explanation = Explanation::new("TermQuery, product of...", score);
-        explanation.add_detail(Explanation::new("(K1+1)", K1 + 1f32));
-        explanation.add_detail(self.idf_explain.clone());
-        explanation.add_detail(tf_explanation);
-        explanation
-    }
 }
 
 #[cfg(test)]

src/query/boolean_query/boolean_weight.rs

@@ -1,5 +1,5 @@
 use core::SegmentReader;
-use query::explanation::does_not_match;
+use query::intersect_scorers;
 use query::score_combiner::{DoNothingCombiner, ScoreCombiner, SumWithCoordsCombiner};
 use query::term_query::TermScorer;
 use query::EmptyScorer;
@@ -9,10 +9,8 @@ use query::RequiredOptionalScorer;
 use query::Scorer;
 use query::Union;
 use query::Weight;
-use query::{intersect_scorers, Explanation};
 use std::collections::HashMap;
 use Result;
-use {DocId, SkipResult};
 
 fn scorer_union<TScoreCombiner>(scorers: Vec<Box<Scorer>>) -> Box<Scorer>
 where
@@ -52,10 +50,10 @@ impl BooleanWeight {
         }
     }
 
-    fn per_occur_scorers(
+    fn complex_scorer<TScoreCombiner: ScoreCombiner>(
         &self,
         reader: &SegmentReader,
-    ) -> Result<HashMap<Occur, Vec<Box<Scorer>>>> {
+    ) -> Result<Box<Scorer>> {
         let mut per_occur_scorers: HashMap<Occur, Vec<Box<Scorer>>> = HashMap::new();
         for &(ref occur, ref subweight) in &self.weights {
             let sub_scorer: Box<Scorer> = subweight.scorer(reader)?;
@@ -64,14 +62,6 @@ impl BooleanWeight {
                 .or_insert_with(Vec::new)
                 .push(sub_scorer);
         }
-        Ok(per_occur_scorers)
-    }
-
-    fn complex_scorer<TScoreCombiner: ScoreCombiner>(
-        &self,
-        reader: &SegmentReader,
-    ) -> Result<Box<Scorer>> {
-        let mut per_occur_scorers = self.per_occur_scorers(reader)?;
 
         let should_scorer_opt: Option<Box<Scorer>> = per_occur_scorers
             .remove(&Occur::Should)
@@ -128,31 +118,4 @@ impl Weight for BooleanWeight {
             self.complex_scorer::<DoNothingCombiner>(reader)
         }
     }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        let mut scorer = self.scorer(reader)?;
-        if scorer.skip_next(doc) != SkipResult::Reached {
-            return Err(does_not_match(doc));
-        }
-        if !self.scoring_enabled {
-            return Ok(Explanation::new("BooleanQuery with no scoring", 1f32));
-        }
-
-        let mut explanation = Explanation::new("BooleanClause. Sum of ...", scorer.score());
-        for &(ref occur, ref subweight) in &self.weights {
-            if is_positive_occur(*occur) {
-                if let Ok(child_explanation) = subweight.explain(reader, doc) {
-                    explanation.add_detail(child_explanation);
-                }
-            }
-        }
-        Ok(explanation)
-    }
-}
-
-fn is_positive_occur(occur: Occur) -> bool {
-    match occur {
-        Occur::Must | Occur::Should => true,
-        Occur::MustNot => false,
-    }
 }

src/query/boolean_query/mod.rs

@@ -18,8 +18,8 @@ mod tests {
     use query::Scorer;
     use query::TermQuery;
     use schema::*;
+    use DocId;
     use Index;
-    use {DocAddress, DocId};
 
     fn aux_test_helper() -> (Index, Field) {
         let mut schema_builder = Schema::builder();
@@ -205,167 +205,4 @@ mod tests {
             assert_eq!(score_docs(&boolean_query), vec![0.977973, 0.84699446]);
         }
     }
-
-    // motivated by #554
-    #[test]
-    fn test_bm25_several_fields() {
-        let mut schema_builder = Schema::builder();
-        let title = schema_builder.add_text_field("title", TEXT);
-        let text = schema_builder.add_text_field("text", TEXT);
-        let schema = schema_builder.build();
-        let index = Index::create_in_ram(schema);
-
-        let mut index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
-        index_writer.add_document(doc!(
-            // tf = 1 0
-            title =>  "Законы притяжения   Оксана Кулакова",
-            // tf = 1 0
-            text => "Законы притяжения Оксана Кулакова]  \n\nТема: Сексуальное искусство, Женственность\nТип товара: Запись вебинара (аудио)\nПродолжительность: 1,5 часа\n\nСсылка на вебинар:\n  ",
-        ));
-        index_writer.add_document(doc!(
-            // tf = 1 0
-            title => "Любимые русские пироги (Оксана Путан)",
-            // tf = 2 0
-            text => "http://i95.fastpic.ru/big/2017/0628/9a/615b9c8504d94a3893d7f496ac53539a.jpg \n\nОт издателя\nОксана Путан   профессиональный повар, автор кулинарных книг и известный кулинарный блогер. Ее рецепты отличаются практичностью, доступностью и пользуются огромной популярностью в русскоязычном интернете. Это третья книга автора о самом вкусном и ароматном   настоящих русских пирогах и выпечке!\nДаже новички на кухне легко готовят по ее рецептам. Оксана описывает процесс приготовления настолько подробно и понятно, что вам остается только наслаждаться готовкой и не тратить время на лишние усилия. Готовьте легко и просто!\n\nhttps://www.ozon.ru/context/detail/id/139872462/"
-        ));
-        index_writer.add_document(doc!(
-            // tf = 1 1
-            title =>  "PDF Мастер Класс \"Морячок\" (Оксана Лифенко)",
-            // tf = 0 0 
-            text => "https://i.ibb.co/pzvHrDN/I3d U T6 Gg TM.jpg\nhttps://i.ibb.co/NFrb6v6/N0ls Z9nwjb U.jpg\nВ описание входит штаны, кофта, берет, матросский воротник. Описание продается в формате PDF, состоит из 12 страниц формата А4 и может быть напечатано на любом принтере.\nОписание предназначено для кукол BJD RealPuki от FairyLand, но может подойти и другим подобным куклам. Также вы можете вязать этот наряд из обычной пряжи, и он подойдет для куколок побольше.\nhttps://vk.com/market 95724412?w=product 95724412_2212"
-        ));
-        for _ in 0..1_000 {
-            index_writer.add_document(doc!(
-                title =>  "a b d e f g",
-                text => "maitre corbeau sur un arbre perche tenait dans son bec un fromage Maitre rnard par lodeur alleche lui tint a peu pres ce langage."
-            ));
-        }
-        index_writer.commit().unwrap();
-        let reader = index.reader().unwrap();
-        let searcher = reader.searcher();
-        let query_parser = QueryParser::for_index(&index, vec![title, text]);
-        let query = query_parser
-            .parse_query("Оксана Лифенко")
-            .unwrap();
-        let weight = query.weight(&searcher, true).unwrap();
-        let mut scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
-        scorer.advance();
-
-        let explanation = query.explain(&searcher, DocAddress(0u32, 0u32)).unwrap();
-        assert_eq!(
-            explanation.to_pretty_json(),
-            r#"{
-  "value": 12.997711,
-  "description": "BooleanClause. Sum of ...",
-  "details": [
-    {
-      "value": 12.997711,
-      "description": "BooleanClause. Sum of ...",
-      "details": [
-        {
-          "value": 6.551476,
-          "description": "TermQuery, product of...",
-          "details": [
-            {
-              "value": 2.2,
-              "description": "(K1+1)"
-            },
-            {
-              "value": 5.658984,
-              "description": "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5))",
-              "details": [
-                {
-                  "value": 3.0,
-                  "description": "n, number of docs containing this term"
-                },
-                {
-                  "value": 1003.0,
-                  "description": "N, total number of docs"
-                }
-              ]
-            },
-            {
-              "value": 0.5262329,
-              "description": "freq / (freq + k1 * (1 - b + b * dl / avgdl))",
-              "details": [
-                {
-                  "value": 1.0,
-                  "description": "freq, occurrences of term within document"
-                },
-                {
-                  "value": 1.2,
-                  "description": "k1, term saturation parameter"
-                },
-                {
-                  "value": 0.75,
-                  "description": "b, length normalization parameter"
-                },
-                {
-                  "value": 4.0,
-                  "description": "dl, length of field"
-                },
-                {
-                  "value": 5.997009,
-                  "description": "avgdl, average length of field"
-                }
-              ]
-            }
-          ]
-        },
-        {
-          "value": 6.446235,
-          "description": "TermQuery, product of...",
-          "details": [
-            {
-              "value": 2.2,
-              "description": "(K1+1)"
-            },
-            {
-              "value": 5.9954567,
-              "description": "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5))",
-              "details": [
-                {
-                  "value": 2.0,
-                  "description": "n, number of docs containing this term"
-                },
-                {
-                  "value": 1003.0,
-                  "description": "N, total number of docs"
-                }
-              ]
-            },
-            {
-              "value": 0.4887212,
-              "description": "freq / (freq + k1 * (1 - b + b * dl / avgdl))",
-              "details": [
-                {
-                  "value": 1.0,
-                  "description": "freq, occurrences of term within document"
-                },
-                {
-                  "value": 1.2,
-                  "description": "k1, term saturation parameter"
-                },
-                {
-                  "value": 0.75,
-                  "description": "b, length normalization parameter"
-                },
-                {
-                  "value": 20.0,
-                  "description": "dl, length of field"
-                },
-                {
-                  "value": 24.123629,
-                  "description": "avgdl, average length of field"
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}"#
-        );
-    }
 }

src/query/empty_query.rs

@@ -1,7 +1,6 @@
 use super::Scorer;
-use query::explanation::does_not_match;
+use query::Query;
 use query::Weight;
-use query::{Explanation, Query};
 use DocId;
 use DocSet;
 use Result;
@@ -33,10 +32,6 @@ impl Weight for EmptyWeight {
     fn scorer(&self, _reader: &SegmentReader) -> Result<Box<Scorer>> {
         Ok(Box::new(EmptyScorer))
     }
-
-    fn explain(&self, _reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        Err(does_not_match(doc))
-    }
 }
 
 /// `EmptyScorer` is a dummy `Scorer` in which no document matches.

src/query/explanation.rs

@@ -1,51 +0,0 @@
-use {DocId, TantivyError};
-
-pub(crate) fn does_not_match(doc: DocId) -> TantivyError {
-    TantivyError::InvalidArgument(format!("Document #({}) does not match", doc))
-}
-
-/// Object describing the score of a given document.
-/// It is organized in trees.
-///
-/// `.to_pretty_json()` can be useful to print out a human readable
-/// representation of this tree when debugging a given score.
-#[derive(Clone, Serialize)]
-pub struct Explanation {
-    value: f32,
-    description: String,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    details: Vec<Explanation>,
-}
-
-impl Explanation {
-    /// Creates a new explanation object.
-    pub fn new<T: ToString>(description: T, value: f32) -> Explanation {
-        Explanation {
-            value,
-            description: description.to_string(),
-            details: vec![],
-        }
-    }
-
-    /// Returns the value associated to the current node.
-    pub fn value(&self) -> f32 {
-        self.value
-    }
-
-    /// Add some detail, explaining some part of the current node formula.
-    ///
-    /// Details are treated as child of the current node.
-    pub fn add_detail(&mut self, child_explanation: Explanation) {
-        self.details.push(child_explanation);
-    }
-
-    /// Shortcut for `self.details.push(Explanation::new(name, value));`
-    pub fn add_const<T: ToString>(&mut self, name: T, value: f32) {
-        self.details.push(Explanation::new(name, value));
-    }
-
-    /// Returns an indented json representation of the explanation tree for debug usage.
-    pub fn to_pretty_json(&self) -> String {
-        serde_json::to_string_pretty(self).unwrap()
-    }
-}

src/query/mod.rs

@@ -9,7 +9,6 @@ mod bm25;
 mod boolean_query;
 mod empty_query;
 mod exclude;
-mod explanation;
 mod fuzzy_query;
 mod intersection;
 mod occur;
@@ -40,7 +39,6 @@ pub use self::bitset::BitSetDocSet;
 pub use self::boolean_query::BooleanQuery;
 pub use self::empty_query::{EmptyQuery, EmptyScorer, EmptyWeight};
 pub use self::exclude::Exclude;
-pub use self::explanation::Explanation;
 pub use self::fuzzy_query::FuzzyTermQuery;
 pub use self::intersection::intersect_scorers;
 pub use self::occur::Occur;

src/query/phrase_query/phrase_query.rs

@@ -4,7 +4,6 @@ use error::TantivyError;
 use query::bm25::BM25Weight;
 use query::Query;
 use query::Weight;
-use schema::IndexRecordOption;
 use schema::{Field, Term};
 use std::collections::BTreeSet;
 use Result;
@@ -84,7 +83,7 @@ impl Query for PhraseQuery {
         let has_positions = field_entry
             .field_type()
             .get_index_record_option()
-            .map(IndexRecordOption::has_positions)
+            .map(|index_record_option| index_record_option.has_positions())
             .unwrap_or(false);
         if !has_positions {
             let field_name = field_entry.name();
@@ -93,12 +92,21 @@ impl Query for PhraseQuery {
                 field_name
             )));
         }
-        let terms = self.phrase_terms();
-        let bm25_weight = BM25Weight::for_terms(searcher, &terms);
-
-        let phrase_weight: PhraseWeight =
-            PhraseWeight::new(self.phrase_terms.clone(), bm25_weight, scoring_enabled);
-        Ok(Box::new(phrase_weight))
+        if scoring_enabled {
+            let terms = self.phrase_terms();
+            let bm25_weight = BM25Weight::for_terms(searcher, &terms);
+            Ok(Box::new(PhraseWeight::new(
+                self.phrase_terms.clone(),
+                bm25_weight,
+                true,
+            )))
+        } else {
+            Ok(Box::new(PhraseWeight::new(
+                self.phrase_terms.clone(),
+                BM25Weight::null(),
+                false,
+            )))
+        }
     }
 
     fn query_terms(&self, term_set: &mut BTreeSet<Term>) {

src/query/phrase_query/phrase_scorer.rs

@@ -148,13 +148,9 @@ impl<TPostings: Postings> PhraseScorer<TPostings> {
         }
     }
 
-    pub fn phrase_count(&self) -> u32 {
-        self.phrase_count
-    }
-
     fn phrase_match(&mut self) -> bool {
         if self.score_needed {
-            let count = self.compute_phrase_count();
+            let count = self.phrase_count();
             self.phrase_count = count;
             count > 0u32
         } else {
@@ -187,7 +183,7 @@ impl<TPostings: Postings> PhraseScorer<TPostings> {
         intersection_exists(&self.left[..intersection_len], &self.right[..])
     }
 
-    fn compute_phrase_count(&mut self) -> u32 {
+    fn phrase_count(&mut self) -> u32 {
         {
             self.intersection_docset
                 .docset_mut_specialized(0)

src/query/phrase_query/phrase_weight.rs

@@ -1,16 +1,12 @@
 use super::PhraseScorer;
 use core::SegmentReader;
-use fieldnorm::FieldNormReader;
-use postings::SegmentPostings;
 use query::bm25::BM25Weight;
-use query::explanation::does_not_match;
+use query::EmptyScorer;
 use query::Scorer;
 use query::Weight;
-use query::{EmptyScorer, Explanation};
 use schema::IndexRecordOption;
 use schema::Term;
-use {DocId, DocSet};
-use {Result, SkipResult};
+use Result;
 
 pub struct PhraseWeight {
     phrase_terms: Vec<(usize, Term)>,
@@ -31,18 +27,13 @@ impl PhraseWeight {
             score_needed,
         }
     }
+}
 
-    fn fieldnorm_reader(&self, reader: &SegmentReader) -> FieldNormReader {
-        let field = self.phrase_terms[0].1.field();
-        reader.get_fieldnorms_reader(field)
-    }
-
-    fn phrase_scorer(
-        &self,
-        reader: &SegmentReader,
-    ) -> Result<Option<PhraseScorer<SegmentPostings>>> {
+impl Weight for PhraseWeight {
+    fn scorer(&self, reader: &SegmentReader) -> Result<Box<Scorer>> {
         let similarity_weight = self.similarity_weight.clone();
-        let fieldnorm_reader = self.fieldnorm_reader(reader);
+        let field = self.phrase_terms[0].1.field();
+        let fieldnorm_reader = reader.get_fieldnorms_reader(field);
         if reader.has_deletes() {
             let mut term_postings_list = Vec::new();
             for &(offset, ref term) in &self.phrase_terms {
@@ -52,10 +43,10 @@ impl PhraseWeight {
                 {
                     term_postings_list.push((offset, postings));
                 } else {
-                    return Ok(None);
+                    return Ok(Box::new(EmptyScorer));
                 }
             }
-            Ok(Some(PhraseScorer::new(
+            Ok(Box::new(PhraseScorer::new(
                 term_postings_list,
                 similarity_weight,
                 fieldnorm_reader,
@@ -70,10 +61,10 @@ impl PhraseWeight {
                 {
                     term_postings_list.push((offset, postings));
                 } else {
-                    return Ok(None);
+                    return Ok(Box::new(EmptyScorer));
                 }
             }
-            Ok(Some(PhraseScorer::new(
+            Ok(Box::new(PhraseScorer::new(
                 term_postings_list,
                 similarity_weight,
                 fieldnorm_reader,
@@ -82,30 +73,3 @@ impl PhraseWeight {
         }
     }
 }
-
-impl Weight for PhraseWeight {
-    fn scorer(&self, reader: &SegmentReader) -> Result<Box<Scorer>> {
-        if let Some(scorer) = self.phrase_scorer(reader)? {
-            Ok(Box::new(scorer))
-        } else {
-            Ok(Box::new(EmptyScorer))
-        }
-    }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        let scorer_opt = self.phrase_scorer(reader)?;
-        if scorer_opt.is_none() {
-            return Err(does_not_match(doc));
-        }
-        let mut scorer = scorer_opt.unwrap();
-        if scorer.skip_next(doc) != SkipResult::Reached {
-            return Err(does_not_match(doc));
-        }
-        let fieldnorm_reader = self.fieldnorm_reader(reader);
-        let fieldnorm_id = fieldnorm_reader.fieldnorm_id(doc);
-        let phrase_count = scorer.phrase_count();
-        let mut explanation = Explanation::new("Phrase Scorer", scorer.score());
-        explanation.add_detail(self.similarity_weight.explain(fieldnorm_id, phrase_count));
-        Ok(explanation)
-    }
-}

src/query/query.rs

@@ -1,11 +1,10 @@
 use super::Weight;
 use core::searcher::Searcher;
-use query::Explanation;
+use downcast_rs;
 use std::collections::BTreeSet;
 use std::fmt;
 use Result;
 use Term;
-use {downcast_rs, DocAddress};
 
 /// The `Query` trait defines a set of documents and a scoring method
 /// for those documents.
@@ -49,13 +48,6 @@ pub trait Query: QueryClone + downcast_rs::Downcast + fmt::Debug {
     /// See [`Weight`](./trait.Weight.html).
     fn weight(&self, searcher: &Searcher, scoring_enabled: bool) -> Result<Box<Weight>>;
 
-    /// Returns an `Explanation` for the score of the document.
-    fn explain(&self, searcher: &Searcher, doc_address: DocAddress) -> Result<Explanation> {
-        let reader = searcher.segment_reader(doc_address.segment_ord());
-        let weight = self.weight(searcher, true)?;
-        weight.explain(reader, doc_address.doc())
-    }
-
     /// Returns the number of documents matching the query.
     fn count(&self, searcher: &Searcher) -> Result<usize> {
         let weight = self.weight(searcher, false)?;

src/query/query_parser/query_grammar.rs

@@ -1,7 +1,6 @@
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::unneeded_field_pattern))]
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::toplevel_ref_arg))]
 
-use super::query_grammar;
 use super::user_input_ast::*;
 use combine::char::*;
 use combine::error::StreamError;
@@ -23,7 +22,7 @@ parser! {
 parser! {
     fn word[I]()(I) -> String
     where [I: Stream<Item = char>] {
-        many1(satisfy(char::is_alphanumeric))
+        many1(satisfy(|c: char| c.is_alphanumeric()))
                .and_then(|s: String| {
                    match s.as_str() {
                      "OR" => Err(StreamErrorFor::<I>::unexpected_static_message("OR")),
@@ -63,7 +62,7 @@ parser! {
     fn negative_number[I]()(I) -> String
     where [I: Stream<Item = char>]
     {
-            (char('-'), many1(satisfy(char::is_numeric)))
+            (char('-'), many1(satisfy(|c: char| c.is_numeric())))
                 .map(|(s1, s2): (char, String)| format!("{}{}", s1, s2))
     }
 }
@@ -185,7 +184,7 @@ parser! {
                         }
                     )
                 )
-                .map(query_grammar::Element::into_dnf)
+                .map(|el| el.into_dnf())
                 .map(|fnd| {
                     if fnd.len() == 1 {
                         UserInputAST::and(fnd.into_iter().next().unwrap()) //< safe

src/query/range_query.rs

@@ -2,17 +2,15 @@ use common::BitSet;
 use core::Searcher;
 use core::SegmentReader;
 use error::TantivyError;
-use query::explanation::does_not_match;
+use query::BitSetDocSet;
 use query::ConstScorer;
-use query::{BitSetDocSet, Explanation};
 use query::{Query, Scorer, Weight};
 use schema::Type;
 use schema::{Field, IndexRecordOption, Term};
 use std::collections::Bound;
 use std::ops::Range;
 use termdict::{TermDictionary, TermStreamer};
-use DocId;
-use {Result, SkipResult};
+use Result;
 
 fn map_bound<TFrom, TTo, Transform: Fn(&TFrom) -> TTo>(
     bound: &Bound<TFrom>,
@@ -288,14 +286,6 @@ impl Weight for RangeWeight {
         let doc_bitset = BitSetDocSet::from(doc_bitset);
         Ok(Box::new(ConstScorer::new(doc_bitset)))
     }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        let mut scorer = self.scorer(reader)?;
-        if scorer.skip_next(doc) != SkipResult::Reached {
-            return Err(does_not_match(doc));
-        }
-        Ok(Explanation::new("RangeQuery", 1.0f32))
-    }
 }
 
 #[cfg(test)]

src/query/term_query/term_scorer.rs

@@ -1,5 +1,5 @@
 use docset::{DocSet, SkipResult};
-use query::{Explanation, Scorer};
+use query::Scorer;
 use DocId;
 use Score;
 
@@ -28,31 +28,11 @@ impl TermScorer {
     }
 }
 
-impl TermScorer {
-    pub fn term_freq(&self) -> u32 {
-        self.postings.term_freq()
-    }
-
-    pub fn fieldnorm_id(&self) -> u8 {
-        self.fieldnorm_reader.fieldnorm_id(self.doc())
-    }
-
-    pub fn explain(&self) -> Explanation {
-        let fieldnorm_id = self.fieldnorm_id();
-        let term_freq = self.term_freq();
-        self.similarity_weight.explain(fieldnorm_id, term_freq)
-    }
-}
-
 impl DocSet for TermScorer {
     fn advance(&mut self) -> bool {
         self.postings.advance()
     }
 
-    fn skip_next(&mut self, target: DocId) -> SkipResult {
-        self.postings.skip_next(target)
-    }
-
     fn doc(&self) -> DocId {
         self.postings.doc()
     }
@@ -60,12 +40,17 @@ impl DocSet for TermScorer {
     fn size_hint(&self) -> u32 {
         self.postings.size_hint()
     }
+
+    fn skip_next(&mut self, target: DocId) -> SkipResult {
+        self.postings.skip_next(target)
+    }
 }
 
 impl Scorer for TermScorer {
     fn score(&mut self) -> Score {
-        let fieldnorm_id = self.fieldnorm_id();
-        let term_freq = self.term_freq();
-        self.similarity_weight.score(fieldnorm_id, term_freq)
+        let doc = self.doc();
+        let fieldnorm_id = self.fieldnorm_reader.fieldnorm_id(doc);
+        self.similarity_weight
+            .score(fieldnorm_id, self.postings.term_freq())
     }
 }

src/query/term_query/term_weight.rs

@@ -3,13 +3,11 @@ use core::SegmentReader;
 use docset::DocSet;
 use postings::SegmentPostings;
 use query::bm25::BM25Weight;
-use query::explanation::does_not_match;
+use query::Scorer;
 use query::Weight;
-use query::{Explanation, Scorer};
 use schema::IndexRecordOption;
-use DocId;
+use Result;
 use Term;
-use {Result, SkipResult};
 
 pub struct TermWeight {
     term: Term,
@@ -19,16 +17,25 @@ pub struct TermWeight {
 
 impl Weight for TermWeight {
     fn scorer(&self, reader: &SegmentReader) -> Result<Box<Scorer>> {
-        let term_scorer = self.scorer_specialized(reader)?;
-        Ok(Box::new(term_scorer))
-    }
-
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation> {
-        let mut scorer = self.scorer_specialized(reader)?;
-        if scorer.skip_next(doc) != SkipResult::Reached {
-            return Err(does_not_match(doc));
+        let field = self.term.field();
+        let inverted_index = reader.inverted_index(field);
+        let fieldnorm_reader = reader.get_fieldnorms_reader(field);
+        let similarity_weight = self.similarity_weight.clone();
+        let postings_opt: Option<SegmentPostings> =
+            inverted_index.read_postings(&self.term, self.index_record_option);
+        if let Some(segment_postings) = postings_opt {
+            Ok(Box::new(TermScorer::new(
+                segment_postings,
+                fieldnorm_reader,
+                similarity_weight,
+            )))
+        } else {
+            Ok(Box::new(TermScorer::new(
+                SegmentPostings::empty(),
+                fieldnorm_reader,
+                similarity_weight,
+            )))
         }
-        Ok(scorer.explain())
     }
 
     fn count(&self, reader: &SegmentReader) -> Result<u32> {
@@ -57,26 +64,4 @@ impl TermWeight {
             similarity_weight,
         }
     }
-
-    fn scorer_specialized(&self, reader: &SegmentReader) -> Result<TermScorer> {
-        let field = self.term.field();
-        let inverted_index = reader.inverted_index(field);
-        let fieldnorm_reader = reader.get_fieldnorms_reader(field);
-        let similarity_weight = self.similarity_weight.clone();
-        let postings_opt: Option<SegmentPostings> =
-            inverted_index.read_postings(&self.term, self.index_record_option);
-        if let Some(segment_postings) = postings_opt {
-            Ok(TermScorer::new(
-                segment_postings,
-                fieldnorm_reader,
-                similarity_weight,
-            ))
-        } else {
-            Ok(TermScorer::new(
-                SegmentPostings::empty(),
-                fieldnorm_reader,
-                similarity_weight,
-            ))
-        }
-    }
 }

src/query/union.rs

@@ -96,7 +96,7 @@ fn refill<TScorer: Scorer, TScoreCombiner: ScoreCombiner>(
 
 impl<TScorer: Scorer, TScoreCombiner: ScoreCombiner> Union<TScorer, TScoreCombiner> {
     fn refill(&mut self) -> bool {
-        if let Some(min_doc) = self.docsets.iter().map(DocSet::doc).min() {
+        if let Some(min_doc) = self.docsets.iter_mut().map(|docset| docset.doc()).min() {
             self.offset = min_doc;
             self.cursor = 0;
             refill(

src/query/weight.rs

@@ -1,7 +1,6 @@
 use super::Scorer;
 use core::SegmentReader;
-use query::Explanation;
-use {DocId, Result};
+use Result;
 
 /// A Weight is the specialization of a Query
 /// for a given set of segments.
@@ -12,9 +11,6 @@ pub trait Weight: Send + Sync + 'static {
     /// See [`Query`](./trait.Query.html).
     fn scorer(&self, reader: &SegmentReader) -> Result<Box<Scorer>>;
 
-    /// Returns an `Explanation` for the given document.
-    fn explain(&self, reader: &SegmentReader, doc: DocId) -> Result<Explanation>;
-
     /// Returns the number documents within the given `SegmentReader`.
     fn count(&self, reader: &SegmentReader) -> Result<u32> {
         let mut scorer = self.scorer(reader)?;

src/schema/document.rs

@@ -128,7 +128,7 @@ impl Document {
         self.field_values
             .iter()
             .filter(|field_value| field_value.field() == field)
-            .map(FieldValue::value)
+            .map(|field_value| field_value.value())
             .collect()
     }
 
@@ -137,7 +137,7 @@ impl Document {
         self.field_values
             .iter()
             .find(|field_value| field_value.field() == field)
-            .map(FieldValue::value)
+            .map(|field_value| field_value.value())
     }
 }
 

src/schema/field_type.rs

@@ -4,7 +4,6 @@ use schema::{IntOptions, TextOptions};
 
 use schema::Facet;
 use schema::IndexRecordOption;
-use schema::TextFieldIndexing;
 use schema::Value;
 use serde_json::Value as JsonValue;
 
@@ -95,7 +94,7 @@ impl FieldType {
         match *self {
             FieldType::Str(ref text_options) => text_options
                 .get_indexing_options()
-                .map(TextFieldIndexing::index_option),
+                .map(|indexing_options| indexing_options.index_option()),
             FieldType::U64(ref int_options)
             | FieldType::I64(ref int_options)
             | FieldType::Date(ref int_options) => {

src/schema/schema.rs

@@ -130,16 +130,7 @@ impl SchemaBuilder {
         self.add_field(field_entry)
     }
 
-    /// Adds a fast bytes field to the schema.
-    ///
-    /// Bytes field are not searchable and are only used
-    /// as fast field, to associate any kind of payload
-    /// to a document.
-    ///
-    /// For instance, learning-to-rank often requires to access
-    /// some document features at scoring time.
-    /// These can be serializing and stored as a bytes field to
-    /// get access rapidly when scoring each document.
+    /// Adds a fast bytes field to the schema
     pub fn add_bytes_field(&mut self, field_name: &str) -> Field {
         let field_entry = FieldEntry::new_bytes(field_name.to_string());
         self.add_field(field_entry)
@@ -233,7 +224,7 @@ impl Schema {
             let field_name = self.get_field_name(field);
             let values: Vec<Value> = field_values
                 .into_iter()
-                .map(FieldValue::value)
+                .map(|field_val| field_val.value())
                 .cloned()
                 .collect();
             field_map.insert(field_name.to_string(), values);

src/snippet/mod.rs

@@ -1,7 +1,6 @@
 use htmlescape::encode_minimal;
 use query::Query;
 use schema::Field;
-use schema::Value;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
@@ -304,7 +303,7 @@ impl SnippetGenerator {
         let text: String = doc
             .get_all(self.field)
             .into_iter()
-            .flat_map(Value::text)
+            .flat_map(|val| val.text())
             .collect::<Vec<&str>>()
             .join(" ");
         self.snippet(&text)

src/space_usage/mod.rs

@@ -227,7 +227,7 @@ pub struct PerFieldSpaceUsage {
 
 impl PerFieldSpaceUsage {
     pub(crate) fn new(fields: HashMap<Field, FieldUsage>) -> PerFieldSpaceUsage {
-        let total = fields.values().map(FieldUsage::total).sum();
+        let total = fields.values().map(|x| x.total()).sum();
         PerFieldSpaceUsage { fields, total }
     }
 

src/store/writer.rs

@@ -16,7 +16,7 @@ const BLOCK_SIZE: usize = 16_384;
 /// the store is written to disc as document as being added,
 /// as opposed to when the segment is getting finalized.
 ///
-/// The skip list index on the other hand, is built in memory.
+/// The skip list index on the other hand, is build in memory.
 ///
 pub struct StoreWriter {
     doc: DocId,

src/tokenizer/lower_caser.rs

@@ -44,17 +44,18 @@ where
     }
 
     fn advance(&mut self) -> bool {
-        if !self.tail.advance() {
-            return false;
-        }
-        if self.token_mut().text.is_ascii() {
-            // fast track for ascii.
-            self.token_mut().text.make_ascii_lowercase();
+        if self.tail.advance() {
+            if self.token_mut().text.is_ascii() {
+                // fast track for ascii.
+                self.token_mut().text.make_ascii_lowercase();
+            } else {
+                to_lowercase_unicode(&mut self.tail.token_mut().text, &mut self.buffer);
+                mem::swap(&mut self.tail.token_mut().text, &mut self.buffer);
+            }
+            true
         } else {
-            to_lowercase_unicode(&mut self.tail.token_mut().text, &mut self.buffer);
-            mem::swap(&mut self.tail.token_mut().text, &mut self.buffer);
+            false
         }
-        true
     }
 }
 

src/tokenizer/mod.rs

@@ -131,7 +131,6 @@
 //! ```
 //!
 mod alphanum_only;
-mod ascii_folding_filter;
 mod facet_tokenizer;
 mod lower_caser;
 mod ngram_tokenizer;
@@ -145,7 +144,6 @@ mod tokenizer;
 mod tokenizer_manager;
 
 pub use self::alphanum_only::AlphaNumOnlyFilter;
-pub use self::ascii_folding_filter::AsciiFoldingFilter;
 pub use self::facet_tokenizer::FacetTokenizer;
 pub use self::lower_caser::LowerCaser;
 pub use self::ngram_tokenizer::NgramTokenizer;

src/tokenizer/raw_tokenizer.rs

@@ -29,9 +29,12 @@ impl<'a> Tokenizer<'a> for RawTokenizer {
 
 impl TokenStream for RawTokenStream {
     fn advance(&mut self) -> bool {
-        let result = self.has_token;
-        self.has_token = false;
-        result
+        if self.has_token {
+            self.has_token = false;
+            true
+        } else {
+            false
+        }
     }
 
     fn token(&self) -> &Token {

src/tokenizer/remove_long.rs

@@ -91,6 +91,7 @@ where
                 return true;
             }
         }
+
         false
     }
 }

src/tokenizer/simple_tokenizer.rs

@@ -38,16 +38,23 @@ impl<'a> TokenStream for SimpleTokenStream<'a> {
     fn advance(&mut self) -> bool {
         self.token.text.clear();
         self.token.position = self.token.position.wrapping_add(1);
-        while let Some((offset_from, c)) = self.chars.next() {
-            if c.is_alphanumeric() {
-                let offset_to = self.search_token_end();
-                self.token.offset_from = offset_from;
-                self.token.offset_to = offset_to;
-                self.token.text.push_str(&self.text[offset_from..offset_to]);
-                return true;
+
+        loop {
+            match self.chars.next() {
+                Some((offset_from, c)) => {
+                    if c.is_alphanumeric() {
+                        let offset_to = self.search_token_end();
+                        self.token.offset_from = offset_from;
+                        self.token.offset_to = offset_to;
+                        self.token.text.push_str(&self.text[offset_from..offset_to]);
+                        return true;
+                    }
+                }
+                None => {
+                    return false;
+                }
             }
         }
-        false
     }
 
     fn token(&self) -> &Token {

src/tokenizer/stemmer.rs

@@ -108,14 +108,15 @@ where
     }
 
     fn advance(&mut self) -> bool {
-        if !self.tail.advance() {
-            return false;
+        if self.tail.advance() {
+            // TODO remove allocation
+            let stemmed_str: String = self.stemmer.stem(&self.token().text).into_owned();
+            self.token_mut().text.clear();
+            self.token_mut().text.push_str(&stemmed_str);
+            true
+        } else {
+            false
         }
-        // TODO remove allocation
-        let stemmed_str: String = self.stemmer.stem(&self.token().text).into_owned();
-        self.token_mut().text.clear();
-        self.token_mut().text.push_str(&stemmed_str);
-        true
     }
 }
 

src/tokenizer/stop_word_filter.rs

@@ -104,6 +104,7 @@ where
                 return true;
             }
         }
+
         false
     }
 }

src/tokenizer/tokenizer_manager.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::ops::Deref;
 use std::sync::{Arc, RwLock};
 use tokenizer::box_tokenizer;
 use tokenizer::stemmer::Language;
@@ -47,8 +46,7 @@ impl TokenizerManager {
             .read()
             .expect("Acquiring the lock should never fail")
             .get(tokenizer_name)
-            .map(Deref::deref)
-            .map(BoxedTokenizer::boxed_clone)
+            .map(|boxed_tokenizer| boxed_tokenizer.boxed_clone())
     }
 }