From 34d2850d284ac3677060d02913af0bc07c3a83d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renault?= Date: Sun, 6 Jan 2019 21:26:26 +0100 Subject: [PATCH 1/5] Revert "feat: Prefer using ranges and not using unreachable!" This reverts commit d899b8660382ea5a4c211761d28ea31e885a46ce. --- src/rank/mod.rs | 54 +++++++++++++++++++++++++++++-------------------- 1 file changed, 32 insertions(+), 22 deletions(-) diff --git a/src/rank/mod.rs b/src/rank/mod.rs index 91392cbee..2023cb266 100644 --- a/src/rank/mod.rs +++ b/src/rank/mod.rs @@ -3,8 +3,7 @@ mod query_builder; mod distinct_map; use std::iter::FusedIterator; -use std::slice::Iter; -use std::ops::Range; +use std::slice::Windows; use sdset::SetBuf; use group_by::GroupBy; @@ -44,19 +43,18 @@ impl Document { #[derive(Debug, Clone)] pub struct Matches { matches: SetBuf, - slices: Vec>, + slices: Vec, } impl Matches { pub fn new(matches: SetBuf) -> Matches { - let mut last_end = 0; - let mut slices = Vec::new(); + let mut last = 0; + let mut slices = vec![0]; for group in GroupBy::new(&matches, match_query_index) { - let start = last_end; - let end = last_end + group.len(); - slices.push(Range { start, end }); - last_end = end; + let index = last + group.len(); + slices.push(index); + last = index; } Matches { matches, slices } @@ -71,7 +69,7 @@ impl Matches { pub fn query_index_groups(&self) -> QueryIndexGroups { QueryIndexGroups { matches: &self.matches, - slices: self.slices.iter(), + windows: self.slices.windows(2), } } @@ -82,7 +80,7 @@ impl Matches { pub struct QueryIndexGroups<'a, 'b> { matches: &'a [Match], - slices: Iter<'b, Range>, + windows: Windows<'b, usize>, } impl<'a> Iterator for QueryIndexGroups<'a, '_> { @@ -90,14 +88,17 @@ impl<'a> Iterator for QueryIndexGroups<'a, '_> { #[inline] fn next(&mut self) -> Option { - self.slices.next().cloned().map(|range| { - unsafe { self.matches.get_unchecked(range) } + self.windows.next().map(|range| { + match *range { + [left, right] => &self.matches[left..right], + _ => unreachable!(), + } }) } #[inline] fn size_hint(&self) -> (usize, Option) { - self.slices.size_hint() + self.windows.size_hint() } #[inline] @@ -107,16 +108,22 @@ impl<'a> Iterator for QueryIndexGroups<'a, '_> { #[inline] fn nth(&mut self, n: usize) -> Option { - self.slices.nth(n).cloned().map(|range| { - unsafe { self.matches.get_unchecked(range) } + self.windows.nth(n).map(|range| { + match *range { + [left, right] => &self.matches[left..right], + _ => unreachable!(), + } }) } #[inline] fn last(self) -> Option { - let (matches, slices) = (self.matches, self.slices); - slices.last().cloned().map(|range| { - unsafe { matches.get_unchecked(range) } + let (matches, windows) = (self.matches, self.windows); + windows.last().map(|range| { + match *range { + [left, right] => &matches[left..right], + _ => unreachable!(), + } }) } } @@ -124,7 +131,7 @@ impl<'a> Iterator for QueryIndexGroups<'a, '_> { impl ExactSizeIterator for QueryIndexGroups<'_, '_> { #[inline] fn len(&self) -> usize { - self.slices.len() + self.windows.len() } } @@ -133,8 +140,11 @@ impl FusedIterator for QueryIndexGroups<'_, '_> { } impl DoubleEndedIterator for QueryIndexGroups<'_, '_> { #[inline] fn next_back(&mut self) -> Option { - self.slices.next_back().cloned().map(|range| { - unsafe { self.matches.get_unchecked(range) } + self.windows.next_back().map(|range| { + match *range { + [left, right] => &self.matches[left..right], + _ => unreachable!(), + } }) } } From 2cc5fbde1a6a3c0d6de9be670afc9636e555153a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renault?= Date: Sun, 6 Jan 2019 21:26:27 +0100 Subject: [PATCH 2/5] Revert "feat: Introduce multiple Iterator impl for Matches" This reverts commit c594597a01422087a66e78bdfddd32d5abc99ad2. --- src/rank/mod.rs | 60 +++++-------------------------------------------- 1 file changed, 6 insertions(+), 54 deletions(-) diff --git a/src/rank/mod.rs b/src/rank/mod.rs index 2023cb266..5416ca882 100644 --- a/src/rank/mod.rs +++ b/src/rank/mod.rs @@ -2,7 +2,6 @@ pub mod criterion; mod query_builder; mod distinct_map; -use std::iter::FusedIterator; use std::slice::Windows; use sdset::SetBuf; @@ -83,10 +82,9 @@ pub struct QueryIndexGroups<'a, 'b> { windows: Windows<'b, usize>, } -impl<'a> Iterator for QueryIndexGroups<'a, '_> { +impl<'a, 'b> Iterator for QueryIndexGroups<'a, 'b> { type Item = &'a [Match]; - #[inline] fn next(&mut self) -> Option { self.windows.next().map(|range| { match *range { @@ -95,56 +93,10 @@ impl<'a> Iterator for QueryIndexGroups<'a, '_> { } }) } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - self.windows.size_hint() - } - - #[inline] - fn count(self) -> usize { - self.len() - } - - #[inline] - fn nth(&mut self, n: usize) -> Option { - self.windows.nth(n).map(|range| { - match *range { - [left, right] => &self.matches[left..right], - _ => unreachable!(), - } - }) - } - - #[inline] - fn last(self) -> Option { - let (matches, windows) = (self.matches, self.windows); - windows.last().map(|range| { - match *range { - [left, right] => &matches[left..right], - _ => unreachable!(), - } - }) - } } -impl ExactSizeIterator for QueryIndexGroups<'_, '_> { - #[inline] - fn len(&self) -> usize { - self.windows.len() - } -} - -impl FusedIterator for QueryIndexGroups<'_, '_> { } - -impl DoubleEndedIterator for QueryIndexGroups<'_, '_> { - #[inline] - fn next_back(&mut self) -> Option { - self.windows.next_back().map(|range| { - match *range { - [left, right] => &self.matches[left..right], - _ => unreachable!(), - } - }) - } -} +// impl ExactSizeIterator for QueryIndexGroups<'_, '_> { +// fn len(&self) -> usize { +// self.windows.len() // FIXME (+1) ? +// } +// } From f32a59720d0527bb793956a7d52a72f98902e672 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renault?= Date: Sun, 6 Jan 2019 21:26:32 +0100 Subject: [PATCH 3/5] Revert "feat: Introducing the Matches as_matches method" This reverts commit ef7ba96d4a3f2107c386aa33860e707b812ab732. --- examples/query-database.rs | 4 ++-- src/rank/mod.rs | 4 ---- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/examples/query-database.rs b/examples/query-database.rs index 20c04aca9..e61e2d0ab 100644 --- a/examples/query-database.rs +++ b/examples/query-database.rs @@ -116,7 +116,7 @@ fn main() -> Result<(), Box> { }; print!("{}: ", name); - let areas = create_highlight_areas(&text, doc.matches.as_matches(), attr); + let areas = create_highlight_areas(&text, &doc.matches, attr); display_highlights(&text, &areas)?; println!(); } @@ -125,7 +125,7 @@ fn main() -> Result<(), Box> { } let mut matching_attributes = HashSet::new(); - for _match in doc.matches.as_matches() { + for _match in doc.matches { let attr = SchemaAttr::new(_match.attribute.attribute()); let name = schema.attribute_name(attr); matching_attributes.insert(name); diff --git a/src/rank/mod.rs b/src/rank/mod.rs index 5416ca882..ad91830bf 100644 --- a/src/rank/mod.rs +++ b/src/rank/mod.rs @@ -71,10 +71,6 @@ impl Matches { windows: self.slices.windows(2), } } - - pub fn as_matches(&self) -> &[Match] { - &self.matches - } } pub struct QueryIndexGroups<'a, 'b> { From a78b5d225fac26cf9dd1ac7c619d246f222272ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renault?= Date: Sun, 6 Jan 2019 21:26:35 +0100 Subject: [PATCH 4/5] Revert "feat: Allow Matches to be constructed" This reverts commit d21406a93908b2b3ed8cd57b2182996b43cf7806. --- src/rank/criterion/sum_of_typos.rs | 30 +++++++++++++++---- src/rank/criterion/words_proximity.rs | 9 ++---- src/rank/mod.rs | 42 ++++++++++----------------- 3 files changed, 43 insertions(+), 38 deletions(-) diff --git a/src/rank/criterion/sum_of_typos.rs b/src/rank/criterion/sum_of_typos.rs index 400650ad2..18a199113 100644 --- a/src/rank/criterion/sum_of_typos.rs +++ b/src/rank/criterion/sum_of_typos.rs @@ -66,7 +66,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(0), matches) + Document { + id: DocumentId(0), + matches: matches, + } }; let doc1 = { @@ -86,7 +89,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(1), matches) + Document { + id: DocumentId(1), + matches: matches, + } }; let lhs = sum_matches_typos(&doc0.matches); @@ -117,7 +123,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(0), matches) + Document { + id: DocumentId(0), + matches: matches, + } }; let doc1 = { @@ -130,7 +139,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(1), matches) + Document { + id: DocumentId(1), + matches: matches, + } }; let lhs = sum_matches_typos(&doc0.matches); @@ -161,7 +173,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(0), matches) + Document { + id: DocumentId(0), + matches: matches, + } }; let doc1 = { @@ -174,7 +189,10 @@ mod tests { word_area: WordArea::new_faillible(0, 6) }, ]; - Document::from_unsorted_matches(DocumentId(1), matches) + Document { + id: DocumentId(1), + matches: matches, + } }; let lhs = sum_matches_typos(&doc0.matches); diff --git a/src/rank/criterion/words_proximity.rs b/src/rank/criterion/words_proximity.rs index 7fe3102d3..41f4b49b8 100644 --- a/src/rank/criterion/words_proximity.rs +++ b/src/rank/criterion/words_proximity.rs @@ -90,8 +90,8 @@ mod tests { // soup -> of = 8 // + of -> the = 1 // + the -> day = 8 (not 1) - let matches = Matches::from_unsorted(matches.to_vec()); - assert_eq!(matches_proximity(&matches), 17); + let matches = Matches::from_unsorted_matches(matches.to_vec()); + assert_eq!(matches_proximity(matches), 17); } #[test] @@ -118,8 +118,7 @@ mod tests { // soup -> of = 1 // + of -> the = 1 // + the -> day = 1 - let matches = Matches::from_unsorted(matches.to_vec()); - assert_eq!(matches_proximity(&matches), 3); + assert_eq!(matches_proximity(matches), 3); } } @@ -153,8 +152,6 @@ mod bench { matches.push(match_); } - let matches = Matches::from_unsorted(matches.to_vec()); - bench.iter(|| { let proximity = matches_proximity(&matches); test::black_box(move || proximity) diff --git a/src/rank/mod.rs b/src/rank/mod.rs index ad91830bf..0d3f538d0 100644 --- a/src/rank/mod.rs +++ b/src/rank/mod.rs @@ -23,19 +23,28 @@ pub struct Document { } impl Document { - pub fn new(id: DocumentId, match_: Match) -> Self { + pub fn new(doc: DocumentId, match_: Match) -> Self { let matches = SetBuf::new_unchecked(vec![match_]); - Self::from_matches(id, matches) + Self::from_matches(doc, matches) } pub fn from_matches(id: DocumentId, matches: SetBuf) -> Self { - let matches = Matches::new(matches); + let mut last = 0; + let mut slices = vec![0]; + for group in GroupBy::new(&matches, match_query_index) { + let index = last + group.len(); + slices.push(index); + last = index; + } + + let matches = Matches { matches, slices }; Self { id, matches } } - pub fn from_unsorted_matches(id: DocumentId, matches: Vec) -> Self { - let matches = Matches::from_unsorted(matches); - Self { id, matches } + pub fn from_unsorted_matches(doc: DocumentId, mut matches: Vec) -> Self { + matches.sort_unstable(); + let matches = SetBuf::new_unchecked(matches); + Self::from_matches(doc, matches) } } @@ -46,25 +55,6 @@ pub struct Matches { } impl Matches { - pub fn new(matches: SetBuf) -> Matches { - let mut last = 0; - let mut slices = vec![0]; - - for group in GroupBy::new(&matches, match_query_index) { - let index = last + group.len(); - slices.push(index); - last = index; - } - - Matches { matches, slices } - } - - pub fn from_unsorted(mut matches: Vec) -> Matches { - matches.sort_unstable(); - let matches = SetBuf::new_unchecked(matches); - Matches::new(matches) - } - pub fn query_index_groups(&self) -> QueryIndexGroups { QueryIndexGroups { matches: &self.matches, @@ -85,7 +75,7 @@ impl<'a, 'b> Iterator for QueryIndexGroups<'a, 'b> { self.windows.next().map(|range| { match *range { [left, right] => &self.matches[left..right], - _ => unreachable!(), + _ => unreachable!() } }) } From f00b9788014a96c97324f3d8c9748cfd67ef2e9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Renault?= Date: Sun, 6 Jan 2019 21:27:41 +0100 Subject: [PATCH 5/5] Revert "feat: Pre-compute matches query index groups" This reverts commit 039a9a4cc7463e6c18aed3c78c622b8bbb38b51d. --- src/rank/criterion/exact.rs | 7 +- src/rank/criterion/number_of_words.rs | 8 ++- src/rank/criterion/sum_of_typos.rs | 13 ++-- src/rank/criterion/sum_of_words_attribute.rs | 8 ++- src/rank/criterion/sum_of_words_position.rs | 10 +-- src/rank/criterion/words_proximity.rs | 8 +-- src/rank/mod.rs | 69 ++------------------ src/rank/query_builder.rs | 2 +- 8 files changed, 40 insertions(+), 85 deletions(-) diff --git a/src/rank/criterion/exact.rs b/src/rank/criterion/exact.rs index 759bd951e..df670161f 100644 --- a/src/rank/criterion/exact.rs +++ b/src/rank/criterion/exact.rs @@ -2,8 +2,9 @@ use std::cmp::Ordering; use std::ops::Deref; use rocksdb::DB; +use group_by::GroupBy; -use crate::rank::{Document, Matches}; +use crate::rank::{match_query_index, Document}; use crate::rank::criterion::Criterion; use crate::database::DatabaseView; use crate::Match; @@ -14,8 +15,8 @@ fn contains_exact(matches: &&[Match]) -> bool { } #[inline] -fn number_exact_matches(matches: &Matches) -> usize { - matches.query_index_groups().filter(contains_exact).count() +fn number_exact_matches(matches: &[Match]) -> usize { + GroupBy::new(matches, match_query_index).filter(contains_exact).count() } #[derive(Debug, Clone, Copy)] diff --git a/src/rank/criterion/number_of_words.rs b/src/rank/criterion/number_of_words.rs index 23cf36a2c..855d997ba 100644 --- a/src/rank/criterion/number_of_words.rs +++ b/src/rank/criterion/number_of_words.rs @@ -2,14 +2,16 @@ use std::cmp::Ordering; use std::ops::Deref; use rocksdb::DB; +use group_by::GroupBy; -use crate::rank::{Document, Matches}; +use crate::rank::{match_query_index, Document}; use crate::rank::criterion::Criterion; use crate::database::DatabaseView; +use crate::Match; #[inline] -fn number_of_query_words(matches: &Matches) -> usize { - matches.query_index_groups().count() +fn number_of_query_words(matches: &[Match]) -> usize { + GroupBy::new(matches, match_query_index).count() } #[derive(Debug, Clone, Copy)] diff --git a/src/rank/criterion/sum_of_typos.rs b/src/rank/criterion/sum_of_typos.rs index 18a199113..085ad19cc 100644 --- a/src/rank/criterion/sum_of_typos.rs +++ b/src/rank/criterion/sum_of_typos.rs @@ -3,19 +3,22 @@ use std::ops::Deref; use rocksdb::DB; -use crate::rank::{Document, Matches}; +use group_by::GroupBy; + +use crate::rank::{match_query_index, Document}; use crate::rank::criterion::Criterion; use crate::database::DatabaseView; +use crate::Match; #[inline] -fn sum_matches_typos(matches: &Matches) -> i8 { +fn sum_matches_typos(matches: &[Match]) -> isize { let mut sum_typos = 0; let mut number_words = 0; // note that GroupBy will never return an empty group // so we can do this assumption safely - for group in matches.query_index_groups() { - sum_typos += unsafe { group.get_unchecked(0).distance } as i8; + for group in GroupBy::new(matches, match_query_index) { + sum_typos += unsafe { group.get_unchecked(0).distance } as isize; number_words += 1; } @@ -41,7 +44,7 @@ where D: Deref mod tests { use super::*; - use crate::{Match, DocumentId, Attribute, WordArea}; + use crate::{DocumentId, Attribute, WordArea}; // typing: "Geox CEO" // diff --git a/src/rank/criterion/sum_of_words_attribute.rs b/src/rank/criterion/sum_of_words_attribute.rs index aea21c35f..90ee9240e 100644 --- a/src/rank/criterion/sum_of_words_attribute.rs +++ b/src/rank/criterion/sum_of_words_attribute.rs @@ -2,16 +2,18 @@ use std::cmp::Ordering; use std::ops::Deref; use rocksdb::DB; +use group_by::GroupBy; -use crate::rank::{Document, Matches}; use crate::database::DatabaseView; +use crate::rank::{match_query_index, Document}; use crate::rank::criterion::Criterion; +use crate::Match; #[inline] -fn sum_matches_attributes(matches: &Matches) -> usize { +fn sum_matches_attributes(matches: &[Match]) -> usize { // note that GroupBy will never return an empty group // so we can do this assumption safely - matches.query_index_groups().map(|group| { + GroupBy::new(matches, match_query_index).map(|group| { unsafe { group.get_unchecked(0).attribute.attribute() as usize } }).sum() } diff --git a/src/rank/criterion/sum_of_words_position.rs b/src/rank/criterion/sum_of_words_position.rs index 0b27184ba..253f9e267 100644 --- a/src/rank/criterion/sum_of_words_position.rs +++ b/src/rank/criterion/sum_of_words_position.rs @@ -2,16 +2,18 @@ use std::cmp::Ordering; use std::ops::Deref; use rocksdb::DB; +use group_by::GroupBy; -use crate::rank::{Document, Matches}; -use crate::rank::criterion::Criterion; use crate::database::DatabaseView; +use crate::rank::{match_query_index, Document}; +use crate::rank::criterion::Criterion; +use crate::Match; #[inline] -fn sum_matches_attribute_index(matches: &Matches) -> usize { +fn sum_matches_attribute_index(matches: &[Match]) -> usize { // note that GroupBy will never return an empty group // so we can do this assumption safely - matches.query_index_groups().map(|group| { + GroupBy::new(matches, match_query_index).map(|group| { unsafe { group.get_unchecked(0).attribute.word_index() as usize } }).sum() } diff --git a/src/rank/criterion/words_proximity.rs b/src/rank/criterion/words_proximity.rs index 41f4b49b8..fc80dfaec 100644 --- a/src/rank/criterion/words_proximity.rs +++ b/src/rank/criterion/words_proximity.rs @@ -2,8 +2,9 @@ use std::cmp::{self, Ordering}; use std::ops::Deref; use rocksdb::DB; +use group_by::GroupBy; -use crate::rank::{Document, Matches}; +use crate::rank::{match_query_index, Document}; use crate::rank::criterion::Criterion; use crate::database::DatabaseView; use crate::Match; @@ -33,9 +34,9 @@ fn min_proximity(lhs: &[Match], rhs: &[Match]) -> u32 { min_prox } -fn matches_proximity(matches: &Matches) -> u32 { +fn matches_proximity(matches: &[Match]) -> u32 { let mut proximity = 0; - let mut iter = matches.query_index_groups(); + let mut iter = GroupBy::new(matches, match_query_index); // iterate over groups by windows of size 2 let mut last = iter.next(); @@ -90,7 +91,6 @@ mod tests { // soup -> of = 8 // + of -> the = 1 // + the -> day = 8 (not 1) - let matches = Matches::from_unsorted_matches(matches.to_vec()); assert_eq!(matches_proximity(matches), 17); } diff --git a/src/rank/mod.rs b/src/rank/mod.rs index 0d3f538d0..4d1b6b1ea 100644 --- a/src/rank/mod.rs +++ b/src/rank/mod.rs @@ -2,11 +2,6 @@ pub mod criterion; mod query_builder; mod distinct_map; -use std::slice::Windows; - -use sdset::SetBuf; -use group_by::GroupBy; - use crate::{Match, DocumentId}; pub use self::query_builder::{FilterFunc, QueryBuilder, DistinctQueryBuilder}; @@ -19,70 +14,20 @@ fn match_query_index(a: &Match, b: &Match) -> bool { #[derive(Debug, Clone)] pub struct Document { pub id: DocumentId, - pub matches: Matches, + pub matches: Vec, } impl Document { pub fn new(doc: DocumentId, match_: Match) -> Self { - let matches = SetBuf::new_unchecked(vec![match_]); - Self::from_matches(doc, matches) + unsafe { Self::from_sorted_matches(doc, vec![match_]) } } - pub fn from_matches(id: DocumentId, matches: SetBuf) -> Self { - let mut last = 0; - let mut slices = vec![0]; - for group in GroupBy::new(&matches, match_query_index) { - let index = last + group.len(); - slices.push(index); - last = index; - } + pub fn from_matches(doc: DocumentId, mut matches: Vec) -> Self { + matches.sort_unstable(); + unsafe { Self::from_sorted_matches(doc, matches) } + } - let matches = Matches { matches, slices }; + pub unsafe fn from_sorted_matches(id: DocumentId, matches: Vec) -> Self { Self { id, matches } } - - pub fn from_unsorted_matches(doc: DocumentId, mut matches: Vec) -> Self { - matches.sort_unstable(); - let matches = SetBuf::new_unchecked(matches); - Self::from_matches(doc, matches) - } } - -#[derive(Debug, Clone)] -pub struct Matches { - matches: SetBuf, - slices: Vec, -} - -impl Matches { - pub fn query_index_groups(&self) -> QueryIndexGroups { - QueryIndexGroups { - matches: &self.matches, - windows: self.slices.windows(2), - } - } -} - -pub struct QueryIndexGroups<'a, 'b> { - matches: &'a [Match], - windows: Windows<'b, usize>, -} - -impl<'a, 'b> Iterator for QueryIndexGroups<'a, 'b> { - type Item = &'a [Match]; - - fn next(&mut self) -> Option { - self.windows.next().map(|range| { - match *range { - [left, right] => &self.matches[left..right], - _ => unreachable!() - } - }) - } -} - -// impl ExactSizeIterator for QueryIndexGroups<'_, '_> { -// fn len(&self) -> usize { -// self.windows.len() // FIXME (+1) ? -// } -// } diff --git a/src/rank/query_builder.rs b/src/rank/query_builder.rs index eb8f21582..6b03bf4e9 100644 --- a/src/rank/query_builder.rs +++ b/src/rank/query_builder.rs @@ -119,7 +119,7 @@ where D: Deref, info!("{} documents to classify", matches.len()); - matches.into_iter().map(|(i, m)| Document::from_unsorted_matches(i, m)).collect() + matches.into_iter().map(|(i, m)| Document::from_matches(i, m)).collect() } }