From 962bddfbbf6ccc1d2ad7fde0f8061afdcb09aa1a Mon Sep 17 00:00:00 2001 From: Paul Masurel Date: Mon, 1 May 2017 17:54:06 +0800 Subject: [PATCH] Merge with panicks. --- src/collector/mod.rs | 2 +- src/core/segment_reader.rs | 11 ++++++++--- src/error.rs | 12 +++++++++--- src/fastfield/error.rs | 19 +++++++++++++++++++ src/fastfield/mod.rs | 2 ++ src/indexer/merger.rs | 19 ++++++++++++------- 6 files changed, 51 insertions(+), 14 deletions(-) create mode 100644 src/fastfield/error.rs diff --git a/src/collector/mod.rs b/src/collector/mod.rs index beb1e25d9..c3964c596 100644 --- a/src/collector/mod.rs +++ b/src/collector/mod.rs @@ -147,7 +147,7 @@ pub mod tests { impl Collector for FastFieldTestCollector { fn set_segment(&mut self, _: SegmentLocalId, reader: &SegmentReader) -> Result<()> { - self.ff_reader = reader.get_fast_field_reader(self.field); + self.ff_reader = Some(reader.get_fast_field_reader(self.field)?); Ok(()) } diff --git a/src/core/segment_reader.rs b/src/core/segment_reader.rs index a49d7e7fe..6d3f7b747 100644 --- a/src/core/segment_reader.rs +++ b/src/core/segment_reader.rs @@ -5,6 +5,7 @@ use core::SegmentComponent; use schema::Term; use common::HasLen; use core::SegmentMeta; +use fastfield::{self, FastFieldNotAvailableError}; use fastfield::delete::DeleteBitSet; use store::StoreReader; use schema::Document; @@ -84,13 +85,17 @@ impl SegmentReader { /// # Panics /// May panic if the index is corrupted. /// TODO return Err - pub fn get_fast_field_reader(&self, field: Field) -> Option { + pub fn get_fast_field_reader(&self, field: Field) -> fastfield::Result { let field_entry = self.schema.get_field_entry(field); if !TFastFieldReader::is_enabled(field_entry.field_type()) { - None + Err(FastFieldNotAvailableError::new(field_entry)) } else { - self.fast_fields_reader.open_reader(field) + Ok( + self.fast_fields_reader + .open_reader(field) + .expect("Fast field file corrupted.") + ) } // match field_entry.field_type() { // &FieldType::Str(_) => { diff --git a/src/error.rs b/src/error.rs index 5eaa50a9a..b897cb262 100644 --- a/src/error.rs +++ b/src/error.rs @@ -10,8 +10,7 @@ use std::sync::PoisonError; use directory::error::{OpenReadError, OpenWriteError, OpenDirectoryError}; use query; use schema; - - +use fastfield::FastFieldNotAvailableError; @@ -38,7 +37,14 @@ pub enum Error { ErrorInThread(String), /// An Error appeared related to the lack of a field. SchemaError(String), - + /// Tried to access a fastfield reader for a field not configured accordingly. + FastFieldError(FastFieldNotAvailableError) +} + +impl From for Error { + fn from(fastfield_error: FastFieldNotAvailableError) -> Error { + Error::FastFieldError(fastfield_error) + } } impl From for Error { diff --git a/src/fastfield/error.rs b/src/fastfield/error.rs new file mode 100644 index 000000000..807444a20 --- /dev/null +++ b/src/fastfield/error.rs @@ -0,0 +1,19 @@ +use std::result; +use schema::FieldEntry; + +#[derive(Debug)] +pub struct FastFieldNotAvailableError { + field_name: String, +} + +pub type Result = result::Result; + +impl FastFieldNotAvailableError { + + pub fn new(field_entry: &FieldEntry) -> FastFieldNotAvailableError { + FastFieldNotAvailableError { + field_name: field_entry.name().clone(), + } + } + +} \ No newline at end of file diff --git a/src/fastfield/mod.rs b/src/fastfield/mod.rs index 1a0c0434e..e54ea3db1 100644 --- a/src/fastfield/mod.rs +++ b/src/fastfield/mod.rs @@ -13,12 +13,14 @@ mod reader; mod writer; mod serializer; +mod error; pub mod delete; pub use self::writer::{U64FastFieldsWriter, U64FastFieldWriter}; pub use self::reader::{FastFieldsReader, U64FastFieldReader}; pub use self::reader::FastFieldReader; pub use self::serializer::FastFieldSerializer; +pub use self::error::{Result, FastFieldNotAvailableError}; #[cfg(test)] mod tests { diff --git a/src/indexer/merger.rs b/src/indexer/merger.rs index 4239adbbb..0272fc279 100644 --- a/src/indexer/merger.rs +++ b/src/indexer/merger.rs @@ -72,11 +72,15 @@ fn compute_min_max_val(u64_reader: &U64FastFieldReader, max_doc: DocId, delete_b } fn extract_fieldnorm_reader(segment_reader: &SegmentReader, field: Field) -> Option { - segment_reader.get_fieldnorms_reader(field) + // TODO + // segment_reader.get_fieldnorms_reader(field) + panic!("extract_fieldnorm_reader"); } fn extract_fast_field_reader(segment_reader: &SegmentReader, field: Field) -> Option { - segment_reader.get_fast_field_reader(field) + // segment_reader.get_fast_field_reader(field) + // TODO + panic!("extract_fast_field_reader"); } impl IndexMerger { @@ -296,6 +300,7 @@ mod tests { use query::TermQuery; use schema::{Field, FieldValue}; use core::Index; + use fastfield::U64FastFieldReader; use Searcher; use DocAddress; use collector::tests::FastFieldTestCollector; @@ -507,11 +512,11 @@ mod tests { assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")), vec!(6_000)); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")), vec!(6_000, 7_000)); - let score_field_reader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); + let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); assert_eq!(score_field_reader.min_val(), 1); assert_eq!(score_field_reader.max_val(), 3); - let score_field_reader = searcher.segment_reader(1).get_fast_field_reader(score_field).unwrap(); + let score_field_reader: U64FastFieldReader = searcher.segment_reader(1).get_fast_field_reader(score_field).unwrap(); assert_eq!(score_field_reader.min_val(), 4000); assert_eq!(score_field_reader.max_val(), 7000); } @@ -533,7 +538,7 @@ mod tests { assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), vec!()); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")), vec!(6_000)); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")), vec!(6_000, 7_000)); - let score_field_reader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); + let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); assert_eq!(score_field_reader.min_val(), 3); assert_eq!(score_field_reader.max_val(), 7000); } @@ -555,7 +560,7 @@ mod tests { assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), vec!()); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")), vec!(6_000)); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")), vec!(6_000, 7_000)); - let score_field_reader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); + let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); assert_eq!(score_field_reader.min_val(), 3); assert_eq!(score_field_reader.max_val(), 7000); } @@ -578,7 +583,7 @@ mod tests { assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), vec!()); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")), vec!(6_000)); assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")), vec!(6_000, 7_000)); - let score_field_reader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); + let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap(); assert_eq!(score_field_reader.min_val(), 6000); assert_eq!(score_field_reader.max_val(), 7000); }