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] 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() } }