From d7a6a409a108a3c539ea074f1edc3e2c335a8687 Mon Sep 17 00:00:00 2001 From: Pascal Seitz Date: Thu, 23 Sep 2021 20:33:11 +0800 Subject: [PATCH] renames --- src/collector/mod.rs | 4 +- src/collector/top_score_collector.rs | 4 +- src/core/segment_reader.rs | 26 ++++---- src/docset.rs | 12 ++-- src/fastfield/alive_bitset.rs | 84 ++++++++++++------------- src/fastfield/mod.rs | 2 +- src/indexer/index_writer.rs | 30 ++++----- src/indexer/merger.rs | 16 ++--- src/indexer/merger_sorted_index_test.rs | 6 +- src/indexer/segment_entry.rs | 16 ++--- src/postings/segment_postings.rs | 8 +-- src/query/boost_query.rs | 4 +- src/query/term_query/term_weight.rs | 4 +- src/query/weight.rs | 4 +- src/store/mod.rs | 10 +-- src/store/reader.rs | 12 ++-- 16 files changed, 121 insertions(+), 121 deletions(-) diff --git a/src/collector/mod.rs b/src/collector/mod.rs index c7e64f004..bb409fb79 100644 --- a/src/collector/mod.rs +++ b/src/collector/mod.rs @@ -178,9 +178,9 @@ pub trait Collector: Sync + Send { ) -> crate::Result<::Fruit> { let mut segment_collector = self.for_segment(segment_ord as u32, reader)?; - if let Some(delete_bitset) = reader.delete_bitset() { + if let Some(alive_bitset) = reader.alive_bitset() { weight.for_each(reader, &mut |doc, score| { - if delete_bitset.is_alive(doc) { + if alive_bitset.is_alive(doc) { segment_collector.collect(doc, score); } })?; diff --git a/src/collector/top_score_collector.rs b/src/collector/top_score_collector.rs index b1786b77c..51d0a5801 100644 --- a/src/collector/top_score_collector.rs +++ b/src/collector/top_score_collector.rs @@ -629,10 +629,10 @@ impl Collector for TopDocs { let heap_len = self.0.limit + self.0.offset; let mut heap: BinaryHeap> = BinaryHeap::with_capacity(heap_len); - if let Some(delete_bitset) = reader.delete_bitset() { + if let Some(alive_bitset) = reader.alive_bitset() { let mut threshold = Score::MIN; weight.for_each_pruning(threshold, reader, &mut |doc, score| { - if delete_bitset.is_deleted(doc) { + if alive_bitset.is_deleted(doc) { return threshold; } let heap_item = ComparableDoc { diff --git a/src/core/segment_reader.rs b/src/core/segment_reader.rs index 10b224e33..8ec303b6e 100644 --- a/src/core/segment_reader.rs +++ b/src/core/segment_reader.rs @@ -47,7 +47,7 @@ pub struct SegmentReader { fieldnorm_readers: FieldNormReaders, store_file: FileSlice, - delete_bitset_opt: Option, + alive_bitset_opt: Option, schema: Schema, } @@ -72,14 +72,14 @@ impl SegmentReader { /// Return the number of documents that have been /// deleted in the segment. pub fn num_deleted_docs(&self) -> DocId { - self.delete_bitset() + self.alive_bitset() .map(|delete_set| delete_set.num_deleted() as DocId) .unwrap_or(0u32) } /// Returns true iff some of the documents of the segment have been deleted. pub fn has_deletes(&self) -> bool { - self.delete_bitset().is_some() + self.alive_bitset().is_some() } /// Accessor to a segment's fast field reader given a field. @@ -170,10 +170,10 @@ impl SegmentReader { let fieldnorm_data = segment.open_read(SegmentComponent::FieldNorms)?; let fieldnorm_readers = FieldNormReaders::open(fieldnorm_data)?; - let delete_bitset_opt = if segment.meta().has_deletes() { + let alive_bitset_opt = if segment.meta().has_deletes() { let delete_data = segment.open_read(SegmentComponent::Delete)?; - let delete_bitset = AliveBitSet::open(delete_data)?; - Some(delete_bitset) + let alive_bitset = AliveBitSet::open(delete_data)?; + Some(alive_bitset) } else { None }; @@ -188,7 +188,7 @@ impl SegmentReader { fieldnorm_readers, segment_id: segment.id(), store_file, - delete_bitset_opt, + alive_bitset_opt, positions_composite, schema, }) @@ -274,22 +274,22 @@ impl SegmentReader { /// Returns the bitset representing /// the documents that have been deleted. - pub fn delete_bitset(&self) -> Option<&AliveBitSet> { - self.delete_bitset_opt.as_ref() + pub fn alive_bitset(&self) -> Option<&AliveBitSet> { + self.alive_bitset_opt.as_ref() } /// Returns true iff the `doc` is marked /// as deleted. pub fn is_deleted(&self, doc: DocId) -> bool { - self.delete_bitset() + self.alive_bitset() .map(|delete_set| delete_set.is_deleted(doc)) .unwrap_or(false) } /// Returns an iterator that will iterate over the alive document ids pub fn doc_ids_alive(&self) -> Box + '_> { - if let Some(delete_bitset) = &self.delete_bitset_opt { - Box::new(delete_bitset.iter_unset()) + if let Some(alive_bitset) = &self.alive_bitset_opt { + Box::new(alive_bitset.iter_unset()) } else { Box::new(0u32..self.max_doc) } @@ -305,7 +305,7 @@ impl SegmentReader { self.fast_fields_readers.space_usage(), self.fieldnorm_readers.space_usage(), self.get_store_reader()?.space_usage(), - self.delete_bitset_opt + self.alive_bitset_opt .as_ref() .map(AliveBitSet::space_usage) .unwrap_or(0), diff --git a/src/docset.rs b/src/docset.rs index 72352e689..0df231e23 100644 --- a/src/docset.rs +++ b/src/docset.rs @@ -85,11 +85,11 @@ pub trait DocSet: Send { /// Returns the number documents matching. /// Calling this method consumes the `DocSet`. - fn count(&mut self, delete_bitset: &AliveBitSet) -> u32 { + fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 { let mut count = 0u32; let mut doc = self.doc(); while doc != TERMINATED { - if !delete_bitset.is_deleted(doc) { + if !alive_bitset.is_deleted(doc) { count += 1u32; } doc = self.advance(); @@ -130,8 +130,8 @@ impl<'a> DocSet for &'a mut dyn DocSet { (**self).size_hint() } - fn count(&mut self, delete_bitset: &AliveBitSet) -> u32 { - (**self).count(delete_bitset) + fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 { + (**self).count(alive_bitset) } fn count_including_deleted(&mut self) -> u32 { @@ -160,9 +160,9 @@ impl DocSet for Box { unboxed.size_hint() } - fn count(&mut self, delete_bitset: &AliveBitSet) -> u32 { + fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 { let unboxed: &mut TDocSet = self.borrow_mut(); - unboxed.count(delete_bitset) + unboxed.count(alive_bitset) } fn count_including_deleted(&mut self) -> u32 { diff --git a/src/fastfield/alive_bitset.rs b/src/fastfield/alive_bitset.rs index 7cc098004..3f8136c23 100644 --- a/src/fastfield/alive_bitset.rs +++ b/src/fastfield/alive_bitset.rs @@ -6,17 +6,17 @@ use common::BitSet; use std::io; use std::io::Write; -/// Write a delete `BitSet` +/// Write a alive `BitSet` /// -/// where `delete_bitset` is the set of deleted `DocId`. +/// where `alive_bitset` is the set of alive `DocId`. /// Warning: this function does not call terminate. The caller is in charge of /// closing the writer properly. -pub fn write_delete_bitset(delete_bitset: &BitSet, writer: &mut T) -> io::Result<()> { - delete_bitset.serialize(writer)?; +pub fn write_alive_bitset(alive_bitset: &BitSet, writer: &mut T) -> io::Result<()> { + alive_bitset.serialize(writer)?; Ok(()) } -/// Set of deleted `DocId`s. +/// Set of alive `DocId`s. #[derive(Clone)] pub struct AliveBitSet { data: OwnedBytes, @@ -36,7 +36,7 @@ impl AliveBitSet { let directory = RamDirectory::create(); let path = Path::new("dummydeletebitset"); let mut wrt = directory.open_write(path).unwrap(); - write_delete_bitset(&bitset, &mut wrt).unwrap(); + write_alive_bitset(&bitset, &mut wrt).unwrap(); wrt.terminate().unwrap(); let file = directory.open_read(path).unwrap(); Self::open(file).unwrap() @@ -89,54 +89,54 @@ mod tests { use super::AliveBitSet; #[test] - fn test_delete_bitset_empty() { - let delete_bitset = AliveBitSet::for_test(&[], 10); + fn test_alive_bitset_empty() { + let alive_bitset = AliveBitSet::for_test(&[], 10); for doc in 0..10 { - assert_eq!(delete_bitset.is_deleted(doc), !delete_bitset.is_alive(doc)); + assert_eq!(alive_bitset.is_deleted(doc), !alive_bitset.is_alive(doc)); } - assert_eq!(delete_bitset.num_deleted(), 0); + assert_eq!(alive_bitset.num_deleted(), 0); } #[test] - fn test_delete_bitset() { - let delete_bitset = AliveBitSet::for_test(&[1, 9], 10); - assert!(delete_bitset.is_alive(0)); - assert!(delete_bitset.is_deleted(1)); - assert!(delete_bitset.is_alive(2)); - assert!(delete_bitset.is_alive(3)); - assert!(delete_bitset.is_alive(4)); - assert!(delete_bitset.is_alive(5)); - assert!(delete_bitset.is_alive(6)); - assert!(delete_bitset.is_alive(6)); - assert!(delete_bitset.is_alive(7)); - assert!(delete_bitset.is_alive(8)); - assert!(delete_bitset.is_deleted(9)); + fn test_alive_bitset() { + let alive_bitset = AliveBitSet::for_test(&[1, 9], 10); + assert!(alive_bitset.is_alive(0)); + assert!(alive_bitset.is_deleted(1)); + assert!(alive_bitset.is_alive(2)); + assert!(alive_bitset.is_alive(3)); + assert!(alive_bitset.is_alive(4)); + assert!(alive_bitset.is_alive(5)); + assert!(alive_bitset.is_alive(6)); + assert!(alive_bitset.is_alive(6)); + assert!(alive_bitset.is_alive(7)); + assert!(alive_bitset.is_alive(8)); + assert!(alive_bitset.is_deleted(9)); for doc in 0..10 { - assert_eq!(delete_bitset.is_deleted(doc), !delete_bitset.is_alive(doc)); + assert_eq!(alive_bitset.is_deleted(doc), !alive_bitset.is_alive(doc)); } - assert_eq!(delete_bitset.num_deleted(), 2); + assert_eq!(alive_bitset.num_deleted(), 2); } #[test] - fn test_delete_bitset_iter_minimal() { - let delete_bitset = AliveBitSet::for_test(&[7], 8); + fn test_alive_bitset_iter_minimal() { + let alive_bitset = AliveBitSet::for_test(&[7], 8); - let data: Vec<_> = delete_bitset.iter_unset().collect(); + let data: Vec<_> = alive_bitset.iter_unset().collect(); assert_eq!(data, vec![0, 1, 2, 3, 4, 5, 6]); } #[test] - fn test_delete_bitset_iter_small() { - let delete_bitset = AliveBitSet::for_test(&[0, 2, 3, 6], 7); + fn test_alive_bitset_iter_small() { + let alive_bitset = AliveBitSet::for_test(&[0, 2, 3, 6], 7); - let data: Vec<_> = delete_bitset.iter_unset().collect(); + let data: Vec<_> = alive_bitset.iter_unset().collect(); assert_eq!(data, vec![1, 4, 5]); } #[test] - fn test_delete_bitset_iter() { - let delete_bitset = AliveBitSet::for_test(&[0, 1, 1000], 1001); + fn test_alive_bitset_iter() { + let alive_bitset = AliveBitSet::for_test(&[0, 1, 1000], 1001); - let data: Vec<_> = delete_bitset.iter_unset().collect(); + let data: Vec<_> = alive_bitset.iter_unset().collect(); assert_eq!(data, (2..=999).collect::>()); } } @@ -164,36 +164,36 @@ mod bench { #[bench] fn bench_deletebitset_iter_deser_on_fly(bench: &mut Bencher) { - let delete_bitset = AliveBitSet::for_test(&[0, 1, 1000, 10000], 1_000_000); + let alive_bitset = AliveBitSet::for_test(&[0, 1, 1000, 10000], 1_000_000); - bench.iter(|| delete_bitset.iter_unset().collect::>()); + bench.iter(|| alive_bitset.iter_unset().collect::>()); } #[bench] fn bench_deletebitset_access(bench: &mut Bencher) { - let delete_bitset = AliveBitSet::for_test(&[0, 1, 1000, 10000], 1_000_000); + let alive_bitset = AliveBitSet::for_test(&[0, 1, 1000, 10000], 1_000_000); bench.iter(|| { (0..1_000_000_u32) - .filter(|doc| delete_bitset.is_alive(*doc)) + .filter(|doc| alive_bitset.is_alive(*doc)) .collect::>() }); } #[bench] fn bench_deletebitset_iter_deser_on_fly_1_8_alive(bench: &mut Bencher) { - let delete_bitset = AliveBitSet::for_test(&get_alive(), 1_000_000); + let alive_bitset = AliveBitSet::for_test(&get_alive(), 1_000_000); - bench.iter(|| delete_bitset.iter_unset().collect::>()); + bench.iter(|| alive_bitset.iter_unset().collect::>()); } #[bench] fn bench_deletebitset_access_1_8_alive(bench: &mut Bencher) { - let delete_bitset = AliveBitSet::for_test(&get_alive(), 1_000_000); + let alive_bitset = AliveBitSet::for_test(&get_alive(), 1_000_000); bench.iter(|| { (0..1_000_000_u32) - .filter(|doc| delete_bitset.is_alive(*doc)) + .filter(|doc| alive_bitset.is_alive(*doc)) .collect::>() }); } diff --git a/src/fastfield/mod.rs b/src/fastfield/mod.rs index 73a3a475c..dd100074c 100644 --- a/src/fastfield/mod.rs +++ b/src/fastfield/mod.rs @@ -23,7 +23,7 @@ values stored. Read access performance is comparable to that of an array lookup. */ -pub use self::alive_bitset::write_delete_bitset; +pub use self::alive_bitset::write_alive_bitset; pub use self::alive_bitset::AliveBitSet; pub use self::bytes::{BytesFastFieldReader, BytesFastFieldWriter}; pub use self::error::{FastFieldNotAvailableError, Result}; diff --git a/src/indexer/index_writer.rs b/src/indexer/index_writer.rs index e4623e548..ff45df9d3 100644 --- a/src/indexer/index_writer.rs +++ b/src/indexer/index_writer.rs @@ -11,7 +11,7 @@ use crate::directory::TerminatingWrite; use crate::directory::{DirectoryLock, GarbageCollectionResult}; use crate::docset::{DocSet, TERMINATED}; use crate::error::TantivyError; -use crate::fastfield::write_delete_bitset; +use crate::fastfield::write_alive_bitset; use crate::indexer::delete_queue::{DeleteCursor, DeleteQueue}; use crate::indexer::doc_opstamp_mapping::DocToOpstampMapping; use crate::indexer::operation::DeleteOperation; @@ -93,7 +93,7 @@ pub struct IndexWriter { } fn compute_deleted_bitset( - delete_bitset: &mut BitSet, + alive_bitset: &mut BitSet, segment_reader: &SegmentReader, delete_cursor: &mut DeleteCursor, doc_opstamps: &DocToOpstampMapping, @@ -114,7 +114,7 @@ fn compute_deleted_bitset( let mut doc_matching_deleted_term = docset.doc(); while doc_matching_deleted_term != TERMINATED { if doc_opstamps.is_deleted(doc_matching_deleted_term, delete_op.opstamp) { - delete_bitset.remove(doc_matching_deleted_term); + alive_bitset.remove(doc_matching_deleted_term); might_have_changed = true; } doc_matching_deleted_term = docset.advance(); @@ -141,7 +141,7 @@ pub(crate) fn advance_deletes( return Ok(()); } - if segment_entry.delete_bitset().is_none() && segment_entry.delete_cursor().get().is_none() { + if segment_entry.alive_bitset().is_none() && segment_entry.delete_cursor().get().is_none() { // There has been no `DeleteOperation` between the segment status and `target_opstamp`. return Ok(()); } @@ -149,15 +149,15 @@ pub(crate) fn advance_deletes( let segment_reader = SegmentReader::open(&segment)?; let max_doc = segment_reader.max_doc(); - let mut delete_bitset: BitSet = match segment_entry.delete_bitset() { - Some(previous_delete_bitset) => (*previous_delete_bitset).clone(), + let mut alive_bitset: BitSet = match segment_entry.alive_bitset() { + Some(previous_alive_bitset) => (*previous_alive_bitset).clone(), None => BitSet::with_max_value_and_filled(max_doc), }; let num_deleted_docs_before = segment.meta().num_deleted_docs(); compute_deleted_bitset( - &mut delete_bitset, + &mut alive_bitset, &segment_reader, segment_entry.delete_cursor(), &DocToOpstampMapping::None, @@ -167,21 +167,21 @@ pub(crate) fn advance_deletes( // TODO optimize // It should be possible to do something smarter by manipulation bitsets directly // to compute this union. - if let Some(seg_delete_bitset) = segment_reader.delete_bitset() { + if let Some(seg_alive_bitset) = segment_reader.alive_bitset() { for doc in 0u32..max_doc { - if seg_delete_bitset.is_deleted(doc) { - delete_bitset.remove(doc); + if seg_alive_bitset.is_deleted(doc) { + alive_bitset.remove(doc); } } } - let num_alive_docs: u32 = delete_bitset.num_set_bits() as u32; + let num_alive_docs: u32 = alive_bitset.num_set_bits() as u32; let num_deleted_docs = max_doc - num_alive_docs; if num_deleted_docs > num_deleted_docs_before { // There are new deletes. We need to write a new delete file. segment = segment.with_delete_meta(num_deleted_docs as u32, target_opstamp); let mut delete_file = segment.open_write(SegmentComponent::Delete)?; - write_delete_bitset(&delete_bitset, &mut delete_file)?; + write_alive_bitset(&alive_bitset, &mut delete_file)?; delete_file.terminate()?; } @@ -227,13 +227,13 @@ fn index_documents( let segment_with_max_doc = segment.with_max_doc(max_doc); - let delete_bitset_opt = + let alive_bitset_opt = apply_deletes(&segment_with_max_doc, &mut delete_cursor, &doc_opstamps)?; let meta = segment_with_max_doc.meta().clone(); meta.untrack_temp_docstore(); // update segment_updater inventory to remove tempstore - let segment_entry = SegmentEntry::new(meta, delete_cursor, delete_bitset_opt); + let segment_entry = SegmentEntry::new(meta, delete_cursor, alive_bitset_opt); block_on(segment_updater.schedule_add_segment(segment_entry))?; Ok(true) } @@ -1514,7 +1514,7 @@ mod tests { for segment_reader in searcher.segment_readers().iter() { let store_reader = segment_reader.get_store_reader().unwrap(); // test store iterator - for doc in store_reader.iter(segment_reader.delete_bitset()) { + for doc in store_reader.iter(segment_reader.alive_bitset()) { let id = doc .unwrap() .get_first(id_field) diff --git a/src/indexer/merger.rs b/src/indexer/merger.rs index a34fd541c..84151c8b1 100644 --- a/src/indexer/merger.rs +++ b/src/indexer/merger.rs @@ -101,7 +101,7 @@ fn compute_min_max_val( if segment_reader.max_doc() == 0 { None } else { - if segment_reader.delete_bitset().is_some() { + if segment_reader.alive_bitset().is_some() { // some deleted documents, // we need to recompute the max / min minmax( @@ -497,8 +497,8 @@ impl IndexMerger { // what should be the bit length use for bitpacking. let mut num_docs = 0; for (reader, u64s_reader) in reader_and_field_accessors.iter() { - if let Some(delete_bitset) = reader.delete_bitset() { - num_docs += reader.max_doc() as u64 - delete_bitset.num_deleted() as u64; + if let Some(alive_bitset) = reader.alive_bitset() { + num_docs += reader.max_doc() as u64 - alive_bitset.num_deleted() as u64; for doc in reader.doc_ids_alive() { let num_vals = u64s_reader.get_len(doc) as u64; total_num_vals += num_vals; @@ -888,9 +888,9 @@ impl IndexMerger { let inverted_index: &InvertedIndexReader = &*field_readers[segment_ord]; let segment_postings = inverted_index .read_postings_from_terminfo(&term_info, segment_postings_option)?; - let delete_bitset_opt = segment_reader.delete_bitset(); - let doc_freq = if let Some(delete_bitset) = delete_bitset_opt { - segment_postings.doc_freq_given_deletes(delete_bitset) + let alive_bitset_opt = segment_reader.alive_bitset(); + let doc_freq = if let Some(alive_bitset) = alive_bitset_opt { + segment_postings.doc_freq_given_deletes(alive_bitset) } else { segment_postings.doc_freq() }; @@ -1010,7 +1010,7 @@ impl IndexMerger { let mut document_iterators: Vec<_> = store_readers .iter() .enumerate() - .map(|(i, store)| store.iter_raw(self.readers[i].delete_bitset())) + .map(|(i, store)| store.iter_raw(self.readers[i].alive_bitset())) .collect(); if !doc_id_mapping.is_trivial() { for (old_doc_id, reader_with_ordinal) in doc_id_mapping.iter() { @@ -1046,7 +1046,7 @@ impl IndexMerger { || store_reader.block_checkpoints().take(7).count() < 6 || store_reader.compressor() != store_writer.compressor() { - for doc_bytes_res in store_reader.iter_raw(reader.delete_bitset()) { + for doc_bytes_res in store_reader.iter_raw(reader.alive_bitset()) { let doc_bytes = doc_bytes_res?; store_writer.store_bytes(&doc_bytes)?; } diff --git a/src/indexer/merger_sorted_index_test.rs b/src/indexer/merger_sorted_index_test.rs index a9950affa..fd9b4883b 100644 --- a/src/indexer/merger_sorted_index_test.rs +++ b/src/indexer/merger_sorted_index_test.rs @@ -260,7 +260,7 @@ mod tests { let fallback_bitset = AliveBitSet::for_test(&[0], 100); assert_eq!( postings.doc_freq_given_deletes( - segment_reader.delete_bitset().unwrap_or(&fallback_bitset) + segment_reader.alive_bitset().unwrap_or(&fallback_bitset) ), 2 ); @@ -339,7 +339,7 @@ mod tests { let fallback_bitset = AliveBitSet::for_test(&[0], 100); assert_eq!( postings.doc_freq_given_deletes( - segment_reader.delete_bitset().unwrap_or(&fallback_bitset) + segment_reader.alive_bitset().unwrap_or(&fallback_bitset) ), 2 ); @@ -449,7 +449,7 @@ mod tests { let fallback_bitset = AliveBitSet::for_test(&[0], 100); assert_eq!( postings.doc_freq_given_deletes( - segment_reader.delete_bitset().unwrap_or(&fallback_bitset) + segment_reader.alive_bitset().unwrap_or(&fallback_bitset) ), 2 ); diff --git a/src/indexer/segment_entry.rs b/src/indexer/segment_entry.rs index e0beb2179..b7cae25c1 100644 --- a/src/indexer/segment_entry.rs +++ b/src/indexer/segment_entry.rs @@ -9,16 +9,16 @@ use std::fmt; /// /// In addition to segment `meta`, /// it contains a few transient states -/// - `delete_bitset` is a bitset describing -/// documents that were deleted during the commit +/// - `alive_bitset` is a bitset describing +/// documents that were alive during the commit /// itself. /// - `delete_cursor` is the position in the delete queue. /// Deletes happening before the cursor are reflected either -/// in the .del file or in the `delete_bitset`. +/// in the .del file or in the `alive_bitset`. #[derive(Clone)] pub struct SegmentEntry { meta: SegmentMeta, - delete_bitset: Option, + alive_bitset: Option, delete_cursor: DeleteCursor, } @@ -27,11 +27,11 @@ impl SegmentEntry { pub fn new( segment_meta: SegmentMeta, delete_cursor: DeleteCursor, - delete_bitset: Option, + alive_bitset: Option, ) -> SegmentEntry { SegmentEntry { meta: segment_meta, - delete_bitset, + alive_bitset, delete_cursor, } } @@ -39,8 +39,8 @@ impl SegmentEntry { /// Return a reference to the segment entry deleted bitset. /// /// `DocId` in this bitset are flagged as deleted. - pub fn delete_bitset(&self) -> Option<&BitSet> { - self.delete_bitset.as_ref() + pub fn alive_bitset(&self) -> Option<&BitSet> { + self.alive_bitset.as_ref() } /// Set the `SegmentMeta` for this segment. diff --git a/src/postings/segment_postings.rs b/src/postings/segment_postings.rs index 753737d51..f5e383c37 100644 --- a/src/postings/segment_postings.rs +++ b/src/postings/segment_postings.rs @@ -34,7 +34,7 @@ impl SegmentPostings { /// /// This method will clone and scan through the posting lists. /// (this is a rather expensive operation). - pub fn doc_freq_given_deletes(&self, delete_bitset: &AliveBitSet) -> u32 { + pub fn doc_freq_given_deletes(&self, alive_bitset: &AliveBitSet) -> u32 { let mut docset = self.clone(); let mut doc_freq = 0; loop { @@ -42,7 +42,7 @@ impl SegmentPostings { if doc == TERMINATED { return doc_freq; } - if delete_bitset.is_alive(doc) { + if alive_bitset.is_alive(doc) { doc_freq += 1u32; } docset.advance(); @@ -296,8 +296,8 @@ mod tests { fn test_doc_freq() { let docs = SegmentPostings::create_from_docs(&[0, 2, 10]); assert_eq!(docs.doc_freq(), 3); - let delete_bitset = AliveBitSet::for_test(&[2], 12); - assert_eq!(docs.doc_freq_given_deletes(&delete_bitset), 2); + let alive_bitset = AliveBitSet::for_test(&[2], 12); + assert_eq!(docs.doc_freq_given_deletes(&alive_bitset), 2); let all_deleted = AliveBitSet::for_test(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 12); assert_eq!(docs.doc_freq_given_deletes(&all_deleted), 0); } diff --git a/src/query/boost_query.rs b/src/query/boost_query.rs index 72bd3ebba..d7eee9efe 100644 --- a/src/query/boost_query.rs +++ b/src/query/boost_query.rs @@ -118,8 +118,8 @@ impl DocSet for BoostScorer { self.underlying.size_hint() } - fn count(&mut self, delete_bitset: &AliveBitSet) -> u32 { - self.underlying.count(delete_bitset) + fn count(&mut self, alive_bitset: &AliveBitSet) -> u32 { + self.underlying.count(alive_bitset) } fn count_including_deleted(&mut self) -> u32 { diff --git a/src/query/term_query/term_weight.rs b/src/query/term_query/term_weight.rs index 877243f8a..51779124b 100644 --- a/src/query/term_query/term_weight.rs +++ b/src/query/term_query/term_weight.rs @@ -40,8 +40,8 @@ impl Weight for TermWeight { } fn count(&self, reader: &SegmentReader) -> crate::Result { - if let Some(delete_bitset) = reader.delete_bitset() { - Ok(self.scorer(reader, 1.0)?.count(delete_bitset)) + if let Some(alive_bitset) = reader.alive_bitset() { + Ok(self.scorer(reader, 1.0)?.count(alive_bitset)) } else { let field = self.term.field(); let inv_index = reader.inverted_index(field)?; diff --git a/src/query/weight.rs b/src/query/weight.rs index 772846e3e..3a2ff3d33 100644 --- a/src/query/weight.rs +++ b/src/query/weight.rs @@ -59,8 +59,8 @@ pub trait Weight: Send + Sync + 'static { /// Returns the number documents within the given `SegmentReader`. fn count(&self, reader: &SegmentReader) -> crate::Result { let mut scorer = self.scorer(reader, 1.0)?; - if let Some(delete_bitset) = reader.delete_bitset() { - Ok(scorer.count(delete_bitset)) + if let Some(alive_bitset) = reader.alive_bitset() { + Ok(scorer.count(alive_bitset)) } else { Ok(scorer.count_including_deleted()) } diff --git a/src/store/mod.rs b/src/store/mod.rs index 0ad341473..364ed5a92 100644 --- a/src/store/mod.rs +++ b/src/store/mod.rs @@ -113,7 +113,7 @@ pub mod tests { fn test_doc_store_iter_with_delete_bug_1077() -> crate::Result<()> { // this will cover deletion of the first element in a checkpoint let deleted_docids = (200..300).collect::>(); - let delete_bitset = AliveBitSet::for_test(&deleted_docids, NUM_DOCS as u32); + let alive_bitset = AliveBitSet::for_test(&deleted_docids, NUM_DOCS as u32); let path = Path::new("store"); let directory = RamDirectory::create(); @@ -134,7 +134,7 @@ pub mod tests { ); } - for (_, doc) in store.iter(Some(&delete_bitset)).enumerate() { + for (_, doc) in store.iter(Some(&alive_bitset)).enumerate() { let doc = doc?; let title_content = doc.get_first(field_title).unwrap().text().unwrap(); if !title_content.starts_with("Doc ") { @@ -146,7 +146,7 @@ pub mod tests { .unwrap() .parse::() .unwrap(); - if delete_bitset.is_deleted(id) { + if alive_bitset.is_deleted(id) { panic!("unexpected deleted document {}", id); } } @@ -230,7 +230,7 @@ pub mod tests { let searcher = index.reader().unwrap().searcher(); let reader = searcher.segment_reader(0); let store = reader.get_store_reader().unwrap(); - for doc in store.iter(reader.delete_bitset()) { + for doc in store.iter(reader.alive_bitset()) { assert_eq!( *doc?.get_first(text_field).unwrap().text().unwrap(), "deletemenot".to_string() @@ -288,7 +288,7 @@ pub mod tests { let reader = searcher.segment_readers().iter().last().unwrap(); let store = reader.get_store_reader().unwrap(); - for doc in store.iter(reader.delete_bitset()).take(50) { + for doc in store.iter(reader.alive_bitset()).take(50) { assert_eq!( *doc?.get_first(text_field).unwrap().text().unwrap(), LOREM.to_string() diff --git a/src/store/reader.rs b/src/store/reader.rs index 75012718d..98c127d97 100644 --- a/src/store/reader.rs +++ b/src/store/reader.rs @@ -133,12 +133,12 @@ impl StoreReader { /// Iterator over all Documents in their order as they are stored in the doc store. /// Use this, if you want to extract all Documents from the doc store. - /// The delete_bitset has to be forwarded from the `SegmentReader` or the results maybe wrong. + /// The alive_bitset has to be forwarded from the `SegmentReader` or the results maybe wrong. pub fn iter<'a: 'b, 'b>( &'b self, - delete_bitset: Option<&'a AliveBitSet>, + alive_bitset: Option<&'a AliveBitSet>, ) -> impl Iterator> + 'b { - self.iter_raw(delete_bitset).map(|doc_bytes_res| { + self.iter_raw(alive_bitset).map(|doc_bytes_res| { let mut doc_bytes = doc_bytes_res?; Ok(Document::deserialize(&mut doc_bytes)?) }) @@ -146,10 +146,10 @@ impl StoreReader { /// Iterator over all RawDocuments in their order as they are stored in the doc store. /// Use this, if you want to extract all Documents from the doc store. - /// The delete_bitset has to be forwarded from the `SegmentReader` or the results maybe wrong. + /// The alive_bitset has to be forwarded from the `SegmentReader` or the results maybe wrong. pub(crate) fn iter_raw<'a: 'b, 'b>( &'b self, - delete_bitset: Option<&'a AliveBitSet>, + alive_bitset: Option<&'a AliveBitSet>, ) -> impl Iterator> + 'b { let last_docid = self .block_checkpoints() @@ -179,7 +179,7 @@ impl StoreReader { num_skipped = 0; } - let alive = delete_bitset.map_or(true, |bitset| bitset.is_alive(doc_id)); + let alive = alive_bitset.map_or(true, |bitset| bitset.is_alive(doc_id)); if alive { let ret = Some((curr_block.clone(), num_skipped, reset_block_pos)); // the map block will move over the num_skipped, so we reset to 0