snowykami/meilisearch
1
0
Fork 0
mirror of https://github.com/meilisearch/meilisearch.git synced 2024-11-30 00:55:00 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Rename Criterion/Criteria into RankingRules

Browse Source
This commit is contained in:
Kerollmops 2023-11-08 10:45:06 +01:00
parent 48865470d7
commit 67dc0268c5
No known key found for this signature in database
GPG Key ID: F250A4C4E3AE5F5F
30 changed files with 220 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
benchmarks/benches/utils.rs
View File

@ -12,7 +12,7 @@ use milli::heed::EnvOpenOptions;
use milli::update::{ use milli::update::{
IndexDocuments, IndexDocumentsConfig, IndexDocumentsMethod, IndexerConfig, Settings, IndexDocuments, IndexDocumentsConfig, IndexDocumentsMethod, IndexerConfig, Settings,
}; };
use milli::{Criterion, Filter, Index, Object, TermsMatchingStrategy}; use milli::{Filter, Index, Object, RankingRule, TermsMatchingStrategy};
use serde_json::Value; use serde_json::Value;
pub struct Conf<'a> { pub struct Conf<'a> {
@ -78,11 +78,11 @@ pub fn base_setup(conf: &Conf) -> Index {
if let Some(criterion) = conf.criterion { if let Some(criterion) = conf.criterion {
builder.reset_filterable_fields(); builder.reset_filterable_fields();
builder.reset_criteria(); builder.reset_ranking_rules();
builder.reset_stop_words(); builder.reset_stop_words();
let criterion = criterion.iter().map(|s| Criterion::from_str(s).unwrap()).collect(); let criterion = criterion.iter().map(|s| RankingRule::from_str(s).unwrap()).collect();
builder.set_criteria(criterion); builder.set_ranking_rules(criterion);
} }
(conf.configure)(&mut builder); (conf.configure)(&mut builder);

60
meilisearch-types/src/settings.rs
View File

@ -9,7 +9,7 @@ use std::str::FromStr;
use deserr::{DeserializeError, Deserr, ErrorKind, MergeWithError, ValuePointerRef}; use deserr::{DeserializeError, Deserr, ErrorKind, MergeWithError, ValuePointerRef};
use fst::IntoStreamer; use fst::IntoStreamer;
use milli::update::Setting; use milli::update::Setting;
use milli::{Criterion, CriterionError, Index, DEFAULT_VALUES_PER_FACET}; use milli::{Index, RankingRule, RankingRuleError, DEFAULT_VALUES_PER_FACET};
use serde::{Deserialize, Serialize, Serializer}; use serde::{Deserialize, Serialize, Serializer};
use crate::deserr::DeserrJsonError; use crate::deserr::DeserrJsonError;
@ -117,10 +117,10 @@ pub struct PaginationSettings {
pub max_total_hits: Setting<usize>, pub max_total_hits: Setting<usize>,
} }
impl MergeWithError<milli::CriterionError> for DeserrJsonError<InvalidSettingsRankingRules> { impl MergeWithError<milli::RankingRuleError> for DeserrJsonError<InvalidSettingsRankingRules> {
fn merge( fn merge(
_self_: Option<Self>, _self_: Option<Self>,
other: milli::CriterionError, other: milli::RankingRuleError,
merge_location: ValuePointerRef, merge_location: ValuePointerRef,
) -> ControlFlow<Self, Self> { ) -> ControlFlow<Self, Self> {
Self::error::<Infallible>( Self::error::<Infallible>(
@ -344,9 +344,9 @@ pub fn apply_settings_to_builder(
match settings.ranking_rules { match settings.ranking_rules {
Setting::Set(ref criteria) => { Setting::Set(ref criteria) => {
builder.set_criteria(criteria.iter().map(|c| c.clone().into()).collect()) builder.set_ranking_rules(criteria.iter().map(|c| c.clone().into()).collect())
} }
Setting::Reset => builder.reset_criteria(), Setting::Reset => builder.reset_ranking_rules(),
Setting::NotSet => (), Setting::NotSet => (),
} }
@ -578,7 +578,7 @@ pub fn settings(
} }
#[derive(Debug, Clone, PartialEq, Eq, Deserr)] #[derive(Debug, Clone, PartialEq, Eq, Deserr)]
#[deserr(try_from(&String) = FromStr::from_str -> CriterionError)] #[deserr(try_from(&String) = FromStr::from_str -> RankingRuleError)]
pub enum RankingRuleView { pub enum RankingRuleView {
/// Sorted by decreasing number of matched query terms. /// Sorted by decreasing number of matched query terms.
/// Query words at the front of an attribute is considered better than if it was at the back. /// Query words at the front of an attribute is considered better than if it was at the back.
@ -605,7 +605,7 @@ impl Serialize for RankingRuleView {
where where
S: Serializer, S: Serializer,
{ {
serializer.serialize_str(&format!("{}", Criterion::from(self.clone()))) serializer.serialize_str(&format!("{}", RankingRule::from(self.clone())))
} }
} }
impl<'de> Deserialize<'de> for RankingRuleView { impl<'de> Deserialize<'de> for RankingRuleView {
@ -623,7 +623,7 @@ impl<'de> Deserialize<'de> for RankingRuleView {
where where
E: serde::de::Error, E: serde::de::Error,
{ {
let criterion = Criterion::from_str(v).map_err(|_| { let criterion = RankingRule::from_str(v).map_err(|_| {
E::invalid_value(serde::de::Unexpected::Str(v), &"a valid ranking rule") E::invalid_value(serde::de::Unexpected::Str(v), &"a valid ranking rule")
})?; })?;
Ok(RankingRuleView::from(criterion)) Ok(RankingRuleView::from(criterion))
@ -633,42 +633,42 @@ impl<'de> Deserialize<'de> for RankingRuleView {
} }
} }
impl FromStr for RankingRuleView { impl FromStr for RankingRuleView {
type Err = <Criterion as FromStr>::Err; type Err = <RankingRule as FromStr>::Err;
fn from_str(s: &str) -> Result<Self, Self::Err> { fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(RankingRuleView::from(Criterion::from_str(s)?)) Ok(RankingRuleView::from(RankingRule::from_str(s)?))
} }
} }
impl fmt::Display for RankingRuleView { impl fmt::Display for RankingRuleView {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
fmt::Display::fmt(&Criterion::from(self.clone()), f) fmt::Display::fmt(&RankingRule::from(self.clone()), f)
} }
} }
impl From<Criterion> for RankingRuleView { impl From<RankingRule> for RankingRuleView {
fn from(value: Criterion) -> Self { fn from(value: RankingRule) -> Self {
match value { match value {
Criterion::Words => RankingRuleView::Words, RankingRule::Words => RankingRuleView::Words,
Criterion::Typo => RankingRuleView::Typo, RankingRule::Typo => RankingRuleView::Typo,
Criterion::Proximity => RankingRuleView::Proximity, RankingRule::Proximity => RankingRuleView::Proximity,
Criterion::Attribute => RankingRuleView::Attribute, RankingRule::Attribute => RankingRuleView::Attribute,
Criterion::Sort => RankingRuleView::Sort, RankingRule::Sort => RankingRuleView::Sort,
Criterion::Exactness => RankingRuleView::Exactness, RankingRule::Exactness => RankingRuleView::Exactness,
Criterion::Asc(x) => RankingRuleView::Asc(x), RankingRule::Asc(x) => RankingRuleView::Asc(x),
Criterion::Desc(x) => RankingRuleView::Desc(x), RankingRule::Desc(x) => RankingRuleView::Desc(x),
} }
} }
} }
impl From<RankingRuleView> for Criterion { impl From<RankingRuleView> for RankingRule {
fn from(value: RankingRuleView) -> Self { fn from(value: RankingRuleView) -> Self {
match value { match value {
RankingRuleView::Words => Criterion::Words, RankingRuleView::Words => RankingRule::Words,
RankingRuleView::Typo => Criterion::Typo, RankingRuleView::Typo => RankingRule::Typo,
RankingRuleView::Proximity => Criterion::Proximity, RankingRuleView::Proximity => RankingRule::Proximity,
RankingRuleView::Attribute => Criterion::Attribute, RankingRuleView::Attribute => RankingRule::Attribute,
RankingRuleView::Sort => Criterion::Sort, RankingRuleView::Sort => RankingRule::Sort,
RankingRuleView::Exactness => Criterion::Exactness, RankingRuleView::Exactness => RankingRule::Exactness,
RankingRuleView::Asc(x) => Criterion::Asc(x), RankingRuleView::Asc(x) => RankingRule::Asc(x),
RankingRuleView::Desc(x) => Criterion::Desc(x), RankingRuleView::Desc(x) => RankingRule::Desc(x),
} }
} }
} }

16
milli/examples/settings.rs
View File

@ -3,7 +3,7 @@ use heed::EnvOpenOptions;
// use maplit::hashset; // use maplit::hashset;
use milli::{ use milli::{
update::{IndexerConfig, Settings}, update::{IndexerConfig, Settings},
Criterion, Index, Index, RankingRule,
}; };
fn main() { fn main() {
@ -19,13 +19,13 @@ fn main() {
// builder.set_min_word_len_one_typo(5); // builder.set_min_word_len_one_typo(5);
// builder.set_min_word_len_two_typos(7); // builder.set_min_word_len_two_typos(7);
// builder.set_sortable_fields(hashset! { S("release_date") }); // builder.set_sortable_fields(hashset! { S("release_date") });
builder.set_criteria(vec![ builder.set_ranking_rules(vec![
Criterion::Words, RankingRule::Words,
Criterion::Typo, RankingRule::Typo,
Criterion::Proximity, RankingRule::Proximity,
Criterion::Attribute, RankingRule::Attribute,
Criterion::Sort, RankingRule::Sort,
Criterion::Exactness, RankingRule::Exactness,
]); ]);
builder.execute(|_| (), || false).unwrap(); builder.execute(|_| (), || false).unwrap();

16
milli/src/asc_desc.rs
View File

@ -8,7 +8,7 @@ use thiserror::Error;
use crate::error::is_reserved_keyword; use crate::error::is_reserved_keyword;
use crate::search::facet::BadGeoError; use crate::search::facet::BadGeoError;
use crate::{CriterionError, Error, UserError}; use crate::{Error, RankingRuleError, UserError};
/// This error type is never supposed to be shown to the end user. /// This error type is never supposed to be shown to the end user.
/// You must always cast it to a sort error or a criterion error. /// You must always cast it to a sort error or a criterion error.
@ -28,23 +28,23 @@ impl From<BadGeoError> for AscDescError {
} }
} }
impl From<AscDescError> for CriterionError { impl From<AscDescError> for RankingRuleError {
fn from(error: AscDescError) -> Self { fn from(error: AscDescError) -> Self {
match error { match error {
AscDescError::GeoError(_) => { AscDescError::GeoError(_) => {
CriterionError::ReservedNameForSort { name: "_geoPoint".to_string() } RankingRuleError::ReservedNameForSort { name: "_geoPoint".to_string() }
} }
AscDescError::InvalidSyntax { name } => CriterionError::InvalidName { name }, AscDescError::InvalidSyntax { name } => RankingRuleError::InvalidName { name },
AscDescError::ReservedKeyword { name } if name.starts_with("_geoPoint") => { AscDescError::ReservedKeyword { name } if name.starts_with("_geoPoint") => {
CriterionError::ReservedNameForSort { name: "_geoPoint".to_string() } RankingRuleError::ReservedNameForSort { name: "_geoPoint".to_string() }
} }
AscDescError::ReservedKeyword { name } if name.starts_with("_geoRadius") => { AscDescError::ReservedKeyword { name } if name.starts_with("_geoRadius") => {
CriterionError::ReservedNameForFilter { name: "_geoRadius".to_string() } RankingRuleError::ReservedNameForFilter { name: "_geoRadius".to_string() }
} }
AscDescError::ReservedKeyword { name } if name.starts_with("_geoBoundingBox") => { AscDescError::ReservedKeyword { name } if name.starts_with("_geoBoundingBox") => {
CriterionError::ReservedNameForFilter { name: "_geoBoundingBox".to_string() } RankingRuleError::ReservedNameForFilter { name: "_geoBoundingBox".to_string() }
} }
AscDescError::ReservedKeyword { name } => CriterionError::ReservedName { name }, AscDescError::ReservedKeyword { name } => RankingRuleError::ReservedName { name },
} }
} }
} }

6
milli/src/error.rs
View File

@ -9,7 +9,7 @@ use serde_json::Value;
use thiserror::Error; use thiserror::Error;
use crate::documents::{self, DocumentsBatchCursorError}; use crate::documents::{self, DocumentsBatchCursorError};
use crate::{CriterionError, DocumentId, FieldId, Object, SortError}; use crate::{DocumentId, FieldId, Object, RankingRuleError, SortError};
pub fn is_reserved_keyword(keyword: &str) -> bool { pub fn is_reserved_keyword(keyword: &str) -> bool {
["_geo", "_geoDistance", "_geoPoint", "_geoRadius", "_geoBoundingBox"].contains(&keyword) ["_geo", "_geoDistance", "_geoPoint", "_geoRadius", "_geoBoundingBox"].contains(&keyword)
@ -94,7 +94,7 @@ pub enum UserError {
#[error("A document cannot contain more than 65,535 fields.")] #[error("A document cannot contain more than 65,535 fields.")]
AttributeLimitReached, AttributeLimitReached,
#[error(transparent)] #[error(transparent)]
CriterionError(#[from] CriterionError), CriterionError(#[from] RankingRuleError),
#[error("Maximum number of documents reached.")] #[error("Maximum number of documents reached.")]
DocumentLimitReached, DocumentLimitReached,
#[error( #[error(
@ -280,7 +280,7 @@ error_from_sub_error! {
ThreadPoolBuildError => InternalError, ThreadPoolBuildError => InternalError,
SerializationError => InternalError, SerializationError => InternalError,
GeoError => UserError, GeoError => UserError,
CriterionError => UserError, RankingRuleError => UserError,
} }
impl<E> From<grenad::Error<E>> for Error impl<E> From<grenad::Error<E>> for Error

17
milli/src/index.rs
View File

@ -25,10 +25,9 @@ use crate::heed_codec::{
}; };
use crate::readable_slices::ReadableSlices; use crate::readable_slices::ReadableSlices;
use crate::{ use crate::{
default_criteria, CboRoaringBitmapCodec, Criterion, DocumentId, ExternalDocumentsIds, default_criteria, CboRoaringBitmapCodec, DocumentId, ExternalDocumentsIds, FacetDistribution,
FacetDistribution, FieldDistribution, FieldId, FieldIdWordCountCodec, GeoPoint, ObkvCodec, FieldDistribution, FieldId, FieldIdWordCountCodec, GeoPoint, ObkvCodec, OrderBy, RankingRule,
OrderBy, Result, RoaringBitmapCodec, RoaringBitmapLenCodec, Search, U8StrStrCodec, BEU16, Result, RoaringBitmapCodec, RoaringBitmapLenCodec, Search, U8StrStrCodec, BEU16, BEU32,
BEU32,
}; };
/// The HNSW data-structure that we serialize, fill and search in. /// The HNSW data-structure that we serialize, fill and search in.
@ -895,7 +894,7 @@ impl Index {
let distinct_field = self.distinct_field(rtxn)?; let distinct_field = self.distinct_field(rtxn)?;
let asc_desc_fields = let asc_desc_fields =
self.criteria(rtxn)?.into_iter().filter_map(|criterion| match criterion { self.criteria(rtxn)?.into_iter().filter_map(|criterion| match criterion {
Criterion::Asc(field) | Criterion::Desc(field) => Some(field), RankingRule::Asc(field) | RankingRule::Desc(field) => Some(field),
_otherwise => None, _otherwise => None,
}); });
@ -1023,17 +1022,17 @@ impl Index {
pub(crate) fn put_criteria( pub(crate) fn put_criteria(
&self, &self,
wtxn: &mut RwTxn, wtxn: &mut RwTxn,
criteria: &[Criterion], criteria: &[RankingRule],
) -> heed::Result<()> { ) -> heed::Result<()> {
self.main.put::<_, Str, SerdeJson<&[Criterion]>>(wtxn, main_key::CRITERIA_KEY, &criteria) self.main.put::<_, Str, SerdeJson<&[RankingRule]>>(wtxn, main_key::CRITERIA_KEY, &criteria)
} }
pub(crate) fn delete_criteria(&self, wtxn: &mut RwTxn) -> heed::Result<bool> { pub(crate) fn delete_criteria(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
self.main.delete::<_, Str>(wtxn, main_key::CRITERIA_KEY) self.main.delete::<_, Str>(wtxn, main_key::CRITERIA_KEY)
} }
pub fn criteria(&self, rtxn: &RoTxn) -> heed::Result<Vec<Criterion>> { pub fn criteria(&self, rtxn: &RoTxn) -> heed::Result<Vec<RankingRule>> {
match self.main.get::<_, Str, SerdeJson<Vec<Criterion>>>(rtxn, main_key::CRITERIA_KEY)? { match self.main.get::<_, Str, SerdeJson<Vec<RankingRule>>>(rtxn, main_key::CRITERIA_KEY)? {
Some(criteria) => Ok(criteria), Some(criteria) => Ok(criteria),
None => Ok(default_criteria()), None => Ok(default_criteria()),
} }

4
milli/src/lib.rs
View File

@ -9,7 +9,6 @@ pub static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
pub mod documents; pub mod documents;
mod asc_desc; mod asc_desc;
mod criterion;
pub mod distance; pub mod distance;
mod error; mod error;
mod external_documents_ids; mod external_documents_ids;
@ -18,6 +17,7 @@ mod fields_ids_map;
pub mod heed_codec; pub mod heed_codec;
pub mod index; pub mod index;
pub mod proximity; pub mod proximity;
mod ranking_rule;
mod readable_slices; mod readable_slices;
pub mod score_details; pub mod score_details;
mod search; mod search;
@ -44,7 +44,6 @@ use serde_json::Value;
pub use {charabia as tokenizer, heed}; pub use {charabia as tokenizer, heed};
pub use self::asc_desc::{AscDesc, AscDescError, Member, SortError}; pub use self::asc_desc::{AscDesc, AscDescError, Member, SortError};
pub use self::criterion::{default_criteria, Criterion, CriterionError};
pub use self::error::{ pub use self::error::{
Error, FieldIdMapMissingEntry, InternalError, SerializationError, UserError, Error, FieldIdMapMissingEntry, InternalError, SerializationError, UserError,
}; };
@ -57,6 +56,7 @@ pub use self::heed_codec::{
UncheckedU8StrStrCodec, UncheckedU8StrStrCodec,
}; };
pub use self::index::Index; pub use self::index::Index;
pub use self::ranking_rule::{default_criteria, RankingRule, RankingRuleError};
pub use self::search::{ pub use self::search::{
FacetDistribution, FacetValueHit, Filter, FormatOptions, MatchBounds, MatcherBuilder, FacetDistribution, FacetValueHit, Filter, FormatOptions, MatchBounds, MatcherBuilder,
MatchingWords, OrderBy, Search, SearchForFacetValues, SearchResult, TermsMatchingStrategy, MatchingWords, OrderBy, Search, SearchForFacetValues, SearchResult, TermsMatchingStrategy,

0
milli/src/criterion.rs → milli/src/ranking_rule.rs
View File

43
milli/src/search/new/mod.rs
View File

@ -203,12 +203,12 @@ fn get_ranking_rules_for_placeholder_search<'ctx>(
for rr in settings_ranking_rules { for rr in settings_ranking_rules {
match rr { match rr {
// These rules need a query to have an effect; ignore them in placeholder search // These rules need a query to have an effect; ignore them in placeholder search
crate::Criterion::Words crate::RankingRule::Words
| crate::Criterion::Typo | crate::RankingRule::Typo
| crate::Criterion::Attribute | crate::RankingRule::Attribute
| crate::Criterion::Proximity | crate::RankingRule::Proximity
| crate::Criterion::Exactness => continue, | crate::RankingRule::Exactness => continue,
crate::Criterion::Sort => { crate::RankingRule::Sort => {
if sort { if sort {
continue; continue;
} }
@ -222,14 +222,14 @@ fn get_ranking_rules_for_placeholder_search<'ctx>(
)?; )?;
sort = true; sort = true;
} }
crate::Criterion::Asc(field_name) => { crate::RankingRule::Asc(field_name) => {
if sorted_fields.contains(&field_name) { if sorted_fields.contains(&field_name) {
continue; continue;
} }
sorted_fields.insert(field_name.clone()); sorted_fields.insert(field_name.clone());
ranking_rules.push(Box::new(Sort::new(ctx.index, ctx.txn, field_name, true)?)); ranking_rules.push(Box::new(Sort::new(ctx.index, ctx.txn, field_name, true)?));
} }
crate::Criterion::Desc(field_name) => { crate::RankingRule::Desc(field_name) => {
if sorted_fields.contains(&field_name) { if sorted_fields.contains(&field_name) {
continue; continue;
} }
@ -268,10 +268,10 @@ fn get_ranking_rules_for_query_graph_search<'ctx>(
for rr in settings_ranking_rules { for rr in settings_ranking_rules {
// Add Words before any of: typo, proximity, attribute // Add Words before any of: typo, proximity, attribute
match rr { match rr {
crate::Criterion::Typo crate::RankingRule::Typo
| crate::Criterion::Attribute | crate::RankingRule::Attribute
| crate::Criterion::Proximity | crate::RankingRule::Proximity
| crate::Criterion::Exactness => { | crate::RankingRule::Exactness => {
if !words { if !words {
ranking_rules.push(Box::new(Words::new(terms_matching_strategy))); ranking_rules.push(Box::new(Words::new(terms_matching_strategy)));
words = true; words = true;
@ -280,28 +280,28 @@ fn get_ranking_rules_for_query_graph_search<'ctx>(
_ => {} _ => {}
} }
match rr { match rr {
crate::Criterion::Words => { crate::RankingRule::Words => {
if words { if words {
continue; continue;
} }
ranking_rules.push(Box::new(Words::new(terms_matching_strategy))); ranking_rules.push(Box::new(Words::new(terms_matching_strategy)));
words = true; words = true;
} }
crate::Criterion::Typo => { crate::RankingRule::Typo => {
if typo { if typo {
continue; continue;
} }
typo = true; typo = true;
ranking_rules.push(Box::new(Typo::new(None))); ranking_rules.push(Box::new(Typo::new(None)));
} }
crate::Criterion::Proximity => { crate::RankingRule::Proximity => {
if proximity { if proximity {
continue; continue;
} }
proximity = true; proximity = true;
ranking_rules.push(Box::new(Proximity::new(None))); ranking_rules.push(Box::new(Proximity::new(None)));
} }
crate::Criterion::Attribute => { crate::RankingRule::Attribute => {
if attribute { if attribute {
continue; continue;
} }
@ -309,7 +309,7 @@ fn get_ranking_rules_for_query_graph_search<'ctx>(
ranking_rules.push(Box::new(Fid::new(None))); ranking_rules.push(Box::new(Fid::new(None)));
ranking_rules.push(Box::new(Position::new(None))); ranking_rules.push(Box::new(Position::new(None)));
} }
crate::Criterion::Sort => { crate::RankingRule::Sort => {
if sort { if sort {
continue; continue;
} }
@ -323,7 +323,7 @@ fn get_ranking_rules_for_query_graph_search<'ctx>(
)?; )?;
sort = true; sort = true;
} }
crate::Criterion::Exactness => { crate::RankingRule::Exactness => {
if exactness { if exactness {
continue; continue;
} }
@ -331,14 +331,14 @@ fn get_ranking_rules_for_query_graph_search<'ctx>(
ranking_rules.push(Box::new(Exactness::new())); ranking_rules.push(Box::new(Exactness::new()));
exactness = true; exactness = true;
} }
crate::Criterion::Asc(field_name) => { crate::RankingRule::Asc(field_name) => {
if sorted_fields.contains(&field_name) { if sorted_fields.contains(&field_name) {
continue; continue;
} }
sorted_fields.insert(field_name.clone()); sorted_fields.insert(field_name.clone());
ranking_rules.push(Box::new(Sort::new(ctx.index, ctx.txn, field_name, true)?)); ranking_rules.push(Box::new(Sort::new(ctx.index, ctx.txn, field_name, true)?));
} }
crate::Criterion::Desc(field_name) => { crate::RankingRule::Desc(field_name) => {
if sorted_fields.contains(&field_name) { if sorted_fields.contains(&field_name) {
continue; continue;
} }
@ -580,7 +580,8 @@ fn check_sort_criteria(ctx: &SearchContext, sort_criteria: Option<&Vec<AscDesc>>
// We check that the sort ranking rule exists and throw an // We check that the sort ranking rule exists and throw an
// error if we try to use it and that it doesn't. // error if we try to use it and that it doesn't.
let sort_ranking_rule_missing = !ctx.index.criteria(ctx.txn)?.contains(&crate::Criterion::Sort); let sort_ranking_rule_missing =
!ctx.index.criteria(ctx.txn)?.contains(&crate::RankingRule::Sort);
if sort_ranking_rule_missing { if sort_ranking_rule_missing {
return Err(UserError::SortRankingRuleMissing.into()); return Err(UserError::SortRankingRuleMissing.into());
} }

4
milli/src/search/new/tests/attribute_fid.rs
View File

@ -1,5 +1,5 @@
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -12,7 +12,7 @@ fn create_index() -> TempIndex {
"description".to_owned(), "description".to_owned(),
"plot".to_owned(), "plot".to_owned(),
]); ]);
s.set_criteria(vec![Criterion::Attribute]); s.set_ranking_rules(vec![RankingRule::Attribute]);
}) })
.unwrap(); .unwrap();

4
milli/src/search/new/tests/attribute_position.rs
View File

@ -1,5 +1,5 @@
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::{db_snap, Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{db_snap, RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -12,7 +12,7 @@ fn create_index() -> TempIndex {
"text2".to_owned(), "text2".to_owned(),
"other".to_owned(), "other".to_owned(),
]); ]);
s.set_criteria(vec![Criterion::Attribute]); s.set_ranking_rules(vec![RankingRule::Attribute]);
}) })
.unwrap(); .unwrap();

18
milli/src/search/new/tests/distinct.rs
View File

@ -19,7 +19,7 @@ use maplit::hashset;
use super::collect_field_values; use super::collect_field_values;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::{AscDesc, Criterion, Index, Member, Search, SearchResult, TermsMatchingStrategy}; use crate::{AscDesc, Index, Member, RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -30,7 +30,7 @@ fn create_index() -> TempIndex {
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_sortable_fields(hashset! { S("rank1"), S("letter") }); s.set_sortable_fields(hashset! { S("rank1"), S("letter") });
s.set_distinct_field("letter".to_owned()); s.set_distinct_field("letter".to_owned());
s.set_criteria(vec![Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Words]);
}) })
.unwrap(); .unwrap();
@ -252,7 +252,7 @@ fn test_distinct_placeholder_sort() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Sort]); s.set_ranking_rules(vec![RankingRule::Sort]);
}) })
.unwrap(); .unwrap();
@ -387,7 +387,7 @@ fn test_distinct_words() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Words]);
}) })
.unwrap(); .unwrap();
@ -440,7 +440,11 @@ fn test_distinct_sort_words() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Sort, Criterion::Words, Criterion::Desc(S("rank1"))]); s.set_ranking_rules(vec![
RankingRule::Sort,
RankingRule::Words,
RankingRule::Desc(S("rank1")),
]);
}) })
.unwrap(); .unwrap();
@ -513,7 +517,7 @@ fn test_distinct_all_candidates() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Sort]); s.set_ranking_rules(vec![RankingRule::Sort]);
}) })
.unwrap(); .unwrap();
@ -536,7 +540,7 @@ fn test_distinct_typo() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Typo]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Typo]);
}) })
.unwrap(); .unwrap();

54
milli/src/search/new/tests/exactness.rs
View File

@ -21,7 +21,7 @@ Then these rules will only work with
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index_simple_ordered() -> TempIndex { fn create_index_simple_ordered() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -30,7 +30,7 @@ fn create_index_simple_ordered() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -89,7 +89,7 @@ fn create_index_simple_reversed() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -147,7 +147,7 @@ fn create_index_simple_random() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -201,7 +201,7 @@ fn create_index_attribute_starts_with() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -251,7 +251,7 @@ fn create_index_simple_ordered_with_typos() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -350,7 +350,11 @@ fn create_index_with_varying_proximities() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness, Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![
RankingRule::Exactness,
RankingRule::Words,
RankingRule::Proximity,
]);
}) })
.unwrap(); .unwrap();
@ -404,7 +408,7 @@ fn create_index_with_typo_and_prefix() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -442,7 +446,11 @@ fn create_index_all_equal_except_proximity_between_ignored_terms() -> TempIndex
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Exactness, Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![
RankingRule::Exactness,
RankingRule::Words,
RankingRule::Proximity,
]);
}) })
.unwrap(); .unwrap();
@ -698,7 +706,7 @@ fn test_exactness_after_words() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Exactness]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Exactness]);
}) })
.unwrap(); .unwrap();
@ -747,7 +755,7 @@ fn test_words_after_exactness() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Exactness, Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Exactness, RankingRule::Words]);
}) })
.unwrap(); .unwrap();
@ -796,7 +804,11 @@ fn test_proximity_after_exactness() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Exactness, Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![
RankingRule::Exactness,
RankingRule::Words,
RankingRule::Proximity,
]);
}) })
.unwrap(); .unwrap();
@ -834,7 +846,11 @@ fn test_proximity_after_exactness() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Exactness, Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![
RankingRule::Exactness,
RankingRule::Words,
RankingRule::Proximity,
]);
}) })
.unwrap(); .unwrap();
@ -868,7 +884,11 @@ fn test_exactness_followed_by_typo_prefer_no_typo_prefix() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Exactness, Criterion::Words, Criterion::Typo]); s.set_ranking_rules(vec![
RankingRule::Exactness,
RankingRule::Words,
RankingRule::Typo,
]);
}) })
.unwrap(); .unwrap();
@ -904,7 +924,11 @@ fn test_typo_followed_by_exactness() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Typo, Criterion::Exactness]); s.set_ranking_rules(vec![
RankingRule::Words,
RankingRule::Typo,
RankingRule::Exactness,
]);
}) })
.unwrap(); .unwrap();

4
milli/src/search/new/tests/geo_sort.rs
View File

@ -9,7 +9,7 @@ use maplit::hashset;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::score_details::ScoreDetails; use crate::score_details::ScoreDetails;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{AscDesc, Criterion, GeoSortStrategy, Member, Search, SearchResult}; use crate::{AscDesc, GeoSortStrategy, Member, RankingRule, Search, SearchResult};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -18,7 +18,7 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_sortable_fields(hashset! { S("_geo") }); s.set_sortable_fields(hashset! { S("_geo") });
s.set_criteria(vec![Criterion::Words, Criterion::Sort]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Sort]);
}) })
.unwrap(); .unwrap();
index index

8
milli/src/search/new/tests/integration.rs
View File

@ -6,10 +6,10 @@ use maplit::{btreemap, hashset};
use crate::documents::{DocumentsBatchBuilder, DocumentsBatchReader}; use crate::documents::{DocumentsBatchBuilder, DocumentsBatchReader};
use crate::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings}; use crate::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings};
use crate::{db_snap, Criterion, Index, Object}; use crate::{db_snap, Index, Object, RankingRule};
pub const CONTENT: &str = include_str!("../../../../tests/assets/test_set.ndjson"); pub const CONTENT: &str = include_str!("../../../../tests/assets/test_set.ndjson");
pub fn setup_search_index_with_criteria(criteria: &[Criterion]) -> Index { pub fn setup_search_index_with_criteria(criteria: &[RankingRule]) -> Index {
let path = tempfile::tempdir().unwrap(); let path = tempfile::tempdir().unwrap();
let mut options = EnvOpenOptions::new(); let mut options = EnvOpenOptions::new();
options.map_size(10 * 1024 * 1024); // 10 MB options.map_size(10 * 1024 * 1024); // 10 MB
@ -20,7 +20,7 @@ pub fn setup_search_index_with_criteria(criteria: &[Criterion]) -> Index {
let mut builder = Settings::new(&mut wtxn, &index, &config); let mut builder = Settings::new(&mut wtxn, &index, &config);
builder.set_criteria(criteria.to_vec()); builder.set_ranking_rules(criteria.to_vec());
builder.set_filterable_fields(hashset! { builder.set_filterable_fields(hashset! {
S("tag"), S("tag"),
S("asc_desc_rank"), S("asc_desc_rank"),
@ -70,6 +70,6 @@ pub fn setup_search_index_with_criteria(criteria: &[Criterion]) -> Index {
#[test] #[test]
fn snapshot_integration_dataset() { fn snapshot_integration_dataset() {
let index = setup_search_index_with_criteria(&[Criterion::Attribute]); let index = setup_search_index_with_criteria(&[RankingRule::Attribute]);
db_snap!(index, word_position_docids, @"3c9347a767bceef3beb31465f1e5f3ae"); db_snap!(index, word_position_docids, @"3c9347a767bceef3beb31465f1e5f3ae");
} }

4
milli/src/search/new/tests/ngram_split_words.rs
View File

@ -19,7 +19,7 @@ This module tests the following properties:
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -28,7 +28,7 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Words]);
}) })
.unwrap(); .unwrap();

6
milli/src/search/new/tests/proximity.rs
View File

@ -19,7 +19,7 @@ use std::collections::BTreeMap;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_simple_index() -> TempIndex { fn create_simple_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -28,7 +28,7 @@ fn create_simple_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Proximity]);
}) })
.unwrap(); .unwrap();
@ -94,7 +94,7 @@ fn create_edge_cases_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Proximity]);
}) })
.unwrap(); .unwrap();

8
milli/src/search/new/tests/proximity_typo.rs
View File

@ -8,7 +8,7 @@ implemented.
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -17,7 +17,11 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words, Criterion::Proximity, Criterion::Typo]); s.set_ranking_rules(vec![
RankingRule::Words,
RankingRule::Proximity,
RankingRule::Typo,
]);
}) })
.unwrap(); .unwrap();

6
milli/src/search/new/tests/sort.rs
View File

@ -17,7 +17,7 @@ use maplit::hashset;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{ use crate::{
score_details, AscDesc, Criterion, Member, Search, SearchResult, TermsMatchingStrategy, score_details, AscDesc, Member, RankingRule, Search, SearchResult, TermsMatchingStrategy,
}; };
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
@ -28,7 +28,7 @@ fn create_index() -> TempIndex {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_sortable_fields(hashset! { S("rank"), S("vague"), S("letter") }); s.set_sortable_fields(hashset! { S("rank"), S("vague"), S("letter") });
s.set_criteria(vec![Criterion::Sort]); s.set_ranking_rules(vec![RankingRule::Sort]);
}) })
.unwrap(); .unwrap();
@ -331,7 +331,7 @@ fn test_redacted() {
.update_settings(|s| { .update_settings(|s| {
s.set_displayed_fields(vec!["text".to_owned(), "vague".to_owned()]); s.set_displayed_fields(vec!["text".to_owned(), "vague".to_owned()]);
s.set_sortable_fields(hashset! { S("rank"), S("vague"), S("letter") }); s.set_sortable_fields(hashset! { S("rank"), S("vague"), S("letter") });
s.set_criteria(vec![Criterion::Sort]); s.set_ranking_rules(vec![RankingRule::Sort]);
}) })
.unwrap(); .unwrap();

12
milli/src/search/new/tests/typo.rs
View File

@ -22,7 +22,7 @@ use std::collections::BTreeMap;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -31,7 +31,7 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Words]);
}) })
.unwrap(); .unwrap();
@ -457,7 +457,7 @@ fn test_typo_ranking_rule_not_preceded_by_words_ranking_rule() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Typo]); s.set_ranking_rules(vec![RankingRule::Typo]);
}) })
.unwrap(); .unwrap();
@ -495,7 +495,7 @@ fn test_typo_ranking_rule_not_preceded_by_words_ranking_rule() {
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Typo]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Typo]);
}) })
.unwrap(); .unwrap();
@ -540,7 +540,7 @@ fn test_typo_bucketing() {
drop(txn); drop(txn);
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Typo]); s.set_ranking_rules(vec![RankingRule::Typo]);
}) })
.unwrap(); .unwrap();
let txn = index.read_txn().unwrap(); let txn = index.read_txn().unwrap();
@ -589,7 +589,7 @@ fn test_typo_synonyms() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Typo]); s.set_ranking_rules(vec![RankingRule::Typo]);
let mut synonyms = BTreeMap::new(); let mut synonyms = BTreeMap::new();
synonyms.insert("lackadaisical".to_owned(), vec!["lazy".to_owned()]); synonyms.insert("lackadaisical".to_owned(), vec!["lazy".to_owned()]);

8
milli/src/search/new/tests/typo_proximity.rs
View File

@ -17,7 +17,7 @@ because the typo ranking rule before it only used the derivation `beautiful`.
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -26,7 +26,11 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words, Criterion::Typo, Criterion::Proximity]); s.set_ranking_rules(vec![
RankingRule::Words,
RankingRule::Typo,
RankingRule::Proximity,
]);
}) })
.unwrap(); .unwrap();

10
milli/src/search/new/tests/words_tms.rs
View File

@ -14,7 +14,7 @@ account by the proximity ranking rule.
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::search::new::tests::collect_field_values; use crate::search::new::tests::collect_field_values;
use crate::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use crate::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
fn create_index() -> TempIndex { fn create_index() -> TempIndex {
let index = TempIndex::new(); let index = TempIndex::new();
@ -23,7 +23,7 @@ fn create_index() -> TempIndex {
.update_settings(|s| { .update_settings(|s| {
s.set_primary_key("id".to_owned()); s.set_primary_key("id".to_owned());
s.set_searchable_fields(vec!["text".to_owned()]); s.set_searchable_fields(vec!["text".to_owned()]);
s.set_criteria(vec![Criterion::Words]); s.set_ranking_rules(vec![RankingRule::Words]);
}) })
.unwrap(); .unwrap();
@ -265,7 +265,7 @@ fn test_words_proximity_tms_last_simple() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Proximity]);
}) })
.unwrap(); .unwrap();
@ -346,7 +346,7 @@ fn test_words_proximity_tms_last_phrase() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Proximity]);
}) })
.unwrap(); .unwrap();
@ -416,7 +416,7 @@ fn test_words_tms_all() {
let index = create_index(); let index = create_index();
index index
.update_settings(|s| { .update_settings(|s| {
s.set_criteria(vec![Criterion::Words, Criterion::Proximity]); s.set_ranking_rules(vec![RankingRule::Words, RankingRule::Proximity]);
}) })
.unwrap(); .unwrap();

30
milli/src/update/settings.rs
View File

@ -9,9 +9,9 @@ use time::OffsetDateTime;
use super::index_documents::{IndexDocumentsConfig, Transform}; use super::index_documents::{IndexDocumentsConfig, Transform};
use super::IndexerConfig; use super::IndexerConfig;
use crate::criterion::Criterion;
use crate::error::UserError; use crate::error::UserError;
use crate::index::{DEFAULT_MIN_WORD_LEN_ONE_TYPO, DEFAULT_MIN_WORD_LEN_TWO_TYPOS}; use crate::index::{DEFAULT_MIN_WORD_LEN_ONE_TYPO, DEFAULT_MIN_WORD_LEN_TWO_TYPOS};
use crate::ranking_rule::RankingRule;
use crate::update::index_documents::IndexDocumentsMethod; use crate::update::index_documents::IndexDocumentsMethod;
use crate::update::{IndexDocuments, UpdateIndexingStep}; use crate::update::{IndexDocuments, UpdateIndexingStep};
use crate::{FieldsIdsMap, Index, OrderBy, Result}; use crate::{FieldsIdsMap, Index, OrderBy, Result};
@ -110,7 +110,7 @@ pub struct Settings<'a, 't, 'u, 'i> {
displayed_fields: Setting<Vec<String>>, displayed_fields: Setting<Vec<String>>,
filterable_fields: Setting<HashSet<String>>, filterable_fields: Setting<HashSet<String>>,
sortable_fields: Setting<HashSet<String>>, sortable_fields: Setting<HashSet<String>>,
criteria: Setting<Vec<Criterion>>, ranking_rules: Setting<Vec<RankingRule>>,
stop_words: Setting<BTreeSet<String>>, stop_words: Setting<BTreeSet<String>>,
non_separator_tokens: Setting<BTreeSet<String>>, non_separator_tokens: Setting<BTreeSet<String>>,
separator_tokens: Setting<BTreeSet<String>>, separator_tokens: Setting<BTreeSet<String>>,
@ -142,7 +142,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
displayed_fields: Setting::NotSet, displayed_fields: Setting::NotSet,
filterable_fields: Setting::NotSet, filterable_fields: Setting::NotSet,
sortable_fields: Setting::NotSet, sortable_fields: Setting::NotSet,
criteria: Setting::NotSet, ranking_rules: Setting::NotSet,
stop_words: Setting::NotSet, stop_words: Setting::NotSet,
non_separator_tokens: Setting::NotSet, non_separator_tokens: Setting::NotSet,
separator_tokens: Setting::NotSet, separator_tokens: Setting::NotSet,
@ -194,12 +194,12 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
self.sortable_fields = Setting::Reset; self.sortable_fields = Setting::Reset;
} }
pub fn reset_criteria(&mut self) { pub fn reset_ranking_rules(&mut self) {
self.criteria = Setting::Reset; self.ranking_rules = Setting::Reset;
} }
pub fn set_criteria(&mut self, criteria: Vec<Criterion>) { pub fn set_ranking_rules(&mut self, ranking_rules: Vec<RankingRule>) {
self.criteria = Setting::Set(criteria); self.ranking_rules = Setting::Set(ranking_rules);
} }
pub fn reset_stop_words(&mut self) { pub fn reset_stop_words(&mut self) {
@ -696,7 +696,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
} }
fn update_criteria(&mut self) -> Result<()> { fn update_criteria(&mut self) -> Result<()> {
match &self.criteria { match &self.ranking_rules {
Setting::Set(criteria) => { Setting::Set(criteria) => {
self.index.put_criteria(self.wtxn, criteria)?; self.index.put_criteria(self.wtxn, criteria)?;
} }
@ -924,7 +924,7 @@ mod tests {
use crate::error::Error; use crate::error::Error;
use crate::index::tests::TempIndex; use crate::index::tests::TempIndex;
use crate::update::{ClearDocuments, DeleteDocuments}; use crate::update::{ClearDocuments, DeleteDocuments};
use crate::{Criterion, Filter, SearchResult}; use crate::{Filter, RankingRule, SearchResult};
#[test] #[test]
fn set_and_reset_searchable_fields() { fn set_and_reset_searchable_fields() {
@ -1167,7 +1167,7 @@ mod tests {
index index
.update_settings(|settings| { .update_settings(|settings| {
settings.set_displayed_fields(vec![S("name")]); settings.set_displayed_fields(vec![S("name")]);
settings.set_criteria(vec![Criterion::Asc("age".to_owned())]); settings.set_ranking_rules(vec![RankingRule::Asc("age".to_owned())]);
}) })
.unwrap(); .unwrap();
@ -1473,7 +1473,7 @@ mod tests {
.update_settings(|settings| { .update_settings(|settings| {
settings.set_displayed_fields(vec!["hello".to_string()]); settings.set_displayed_fields(vec!["hello".to_string()]);
settings.set_filterable_fields(hashset! { S("age"), S("toto") }); settings.set_filterable_fields(hashset! { S("age"), S("toto") });
settings.set_criteria(vec![Criterion::Asc(S("toto"))]); settings.set_ranking_rules(vec![RankingRule::Asc(S("toto"))]);
}) })
.unwrap(); .unwrap();
@ -1482,7 +1482,7 @@ mod tests {
assert_eq!(&["hello"][..], index.displayed_fields(&rtxn).unwrap().unwrap()); assert_eq!(&["hello"][..], index.displayed_fields(&rtxn).unwrap().unwrap());
// since no documents have been pushed the primary key is still unset // since no documents have been pushed the primary key is still unset
assert!(index.primary_key(&rtxn).unwrap().is_none()); assert!(index.primary_key(&rtxn).unwrap().is_none());
assert_eq!(vec![Criterion::Asc("toto".to_string())], index.criteria(&rtxn).unwrap()); assert_eq!(vec![RankingRule::Asc("toto".to_string())], index.criteria(&rtxn).unwrap());
drop(rtxn); drop(rtxn);
// We set toto and age as searchable to force reordering of the fields // We set toto and age as searchable to force reordering of the fields
@ -1495,7 +1495,7 @@ mod tests {
let rtxn = index.read_txn().unwrap(); let rtxn = index.read_txn().unwrap();
assert_eq!(&["hello"][..], index.displayed_fields(&rtxn).unwrap().unwrap()); assert_eq!(&["hello"][..], index.displayed_fields(&rtxn).unwrap().unwrap());
assert!(index.primary_key(&rtxn).unwrap().is_none()); assert!(index.primary_key(&rtxn).unwrap().is_none());
assert_eq!(vec![Criterion::Asc("toto".to_string())], index.criteria(&rtxn).unwrap()); assert_eq!(vec![RankingRule::Asc("toto".to_string())], index.criteria(&rtxn).unwrap());
} }
#[test] #[test]
@ -1507,7 +1507,7 @@ mod tests {
.update_settings(|settings| { .update_settings(|settings| {
settings.set_displayed_fields(vec!["hello".to_string()]); settings.set_displayed_fields(vec!["hello".to_string()]);
// It is only Asc(toto), there is a facet database but it is denied to filter with toto. // It is only Asc(toto), there is a facet database but it is denied to filter with toto.
settings.set_criteria(vec![Criterion::Asc(S("toto"))]); settings.set_ranking_rules(vec![RankingRule::Asc(S("toto"))]);
}) })
.unwrap(); .unwrap();
@ -1715,7 +1715,7 @@ mod tests {
displayed_fields, displayed_fields,
filterable_fields, filterable_fields,
sortable_fields, sortable_fields,
criteria, ranking_rules: criteria,
stop_words, stop_words,
non_separator_tokens, non_separator_tokens,
separator_tokens, separator_tokens,

4
milli/tests/search/distinct.rs
View File

@ -2,8 +2,8 @@ use std::collections::HashSet;
use big_s::S; use big_s::S;
use milli::update::Settings; use milli::update::Settings;
use milli::{Criterion, Search, SearchResult, TermsMatchingStrategy}; use milli::{RankingRule, Search, SearchResult, TermsMatchingStrategy};
use Criterion::*; use RankingRule::*;
use crate::search::{self, EXTERNAL_DOCUMENTS_IDS}; use crate::search::{self, EXTERNAL_DOCUMENTS_IDS};

4
milli/tests/search/filters.rs
View File

@ -1,6 +1,6 @@
use either::{Either, Left, Right}; use either::{Either, Left, Right};
use milli::{Criterion, Filter, Search, SearchResult, TermsMatchingStrategy}; use milli::{Filter, RankingRule, Search, SearchResult, TermsMatchingStrategy};
use Criterion::*; use RankingRule::*;
use crate::search::{self, EXTERNAL_DOCUMENTS_IDS}; use crate::search::{self, EXTERNAL_DOCUMENTS_IDS};

28
milli/tests/search/mod.rs
View File

@ -8,7 +8,7 @@ use heed::EnvOpenOptions;
use maplit::{btreemap, hashset}; use maplit::{btreemap, hashset};
use milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader}; use milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader};
use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings}; use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings};
use milli::{AscDesc, Criterion, DocumentId, Index, Member, Object, TermsMatchingStrategy}; use milli::{AscDesc, DocumentId, Index, Member, Object, RankingRule, TermsMatchingStrategy};
use serde::{Deserialize, Deserializer}; use serde::{Deserialize, Deserializer};
use slice_group_by::GroupBy; use slice_group_by::GroupBy;
@ -27,7 +27,7 @@ pub const EXTERNAL_DOCUMENTS_IDS: &[&str; 17] =
pub const CONTENT: &str = include_str!("../assets/test_set.ndjson"); pub const CONTENT: &str = include_str!("../assets/test_set.ndjson");
pub fn setup_search_index_with_criteria(criteria: &[Criterion]) -> Index { pub fn setup_search_index_with_criteria(criteria: &[RankingRule]) -> Index {
let path = tempfile::tempdir().unwrap(); let path = tempfile::tempdir().unwrap();
let mut options = EnvOpenOptions::new(); let mut options = EnvOpenOptions::new();
options.map_size(10 * 1024 * 1024); // 10 MB options.map_size(10 * 1024 * 1024); // 10 MB
@ -38,7 +38,7 @@ pub fn setup_search_index_with_criteria(criteria: &[Criterion]) -> Index {
let mut builder = Settings::new(&mut wtxn, &index, &config); let mut builder = Settings::new(&mut wtxn, &index, &config);
builder.set_criteria(criteria.to_vec()); builder.set_ranking_rules(criteria.to_vec());
builder.set_filterable_fields(hashset! { builder.set_filterable_fields(hashset! {
S("tag"), S("tag"),
S("asc_desc_rank"), S("asc_desc_rank"),
@ -95,7 +95,7 @@ pub fn internal_to_external_ids(index: &Index, internal_ids: &[DocumentId]) -> V
} }
pub fn expected_order( pub fn expected_order(
criteria: &[Criterion], criteria: &[RankingRule],
optional_words: TermsMatchingStrategy, optional_words: TermsMatchingStrategy,
sort_by: &[AscDesc], sort_by: &[AscDesc],
) -> Vec<TestDocument> { ) -> Vec<TestDocument> {
@ -107,47 +107,47 @@ pub fn expected_order(
let mut new_groups = Vec::new(); let mut new_groups = Vec::new();
for group in groups.iter_mut() { for group in groups.iter_mut() {
match criterion { match criterion {
Criterion::Attribute => { RankingRule::Attribute => {
group.sort_by_key(|d| d.attribute_rank); group.sort_by_key(|d| d.attribute_rank);
new_groups new_groups
.extend(group.linear_group_by_key(|d| d.attribute_rank).map(Vec::from)); .extend(group.linear_group_by_key(|d| d.attribute_rank).map(Vec::from));
} }
Criterion::Exactness => { RankingRule::Exactness => {
group.sort_by_key(|d| d.exact_rank); group.sort_by_key(|d| d.exact_rank);
new_groups.extend(group.linear_group_by_key(|d| d.exact_rank).map(Vec::from)); new_groups.extend(group.linear_group_by_key(|d| d.exact_rank).map(Vec::from));
} }
Criterion::Proximity => { RankingRule::Proximity => {
group.sort_by_key(|d| d.proximity_rank); group.sort_by_key(|d| d.proximity_rank);
new_groups new_groups
.extend(group.linear_group_by_key(|d| d.proximity_rank).map(Vec::from)); .extend(group.linear_group_by_key(|d| d.proximity_rank).map(Vec::from));
} }
Criterion::Sort if sort_by == [AscDesc::Asc(Member::Field(S("tag")))] => { RankingRule::Sort if sort_by == [AscDesc::Asc(Member::Field(S("tag")))] => {
group.sort_by_key(|d| d.sort_by_rank); group.sort_by_key(|d| d.sort_by_rank);
new_groups.extend(group.linear_group_by_key(|d| d.sort_by_rank).map(Vec::from)); new_groups.extend(group.linear_group_by_key(|d| d.sort_by_rank).map(Vec::from));
} }
Criterion::Sort if sort_by == [AscDesc::Desc(Member::Field(S("tag")))] => { RankingRule::Sort if sort_by == [AscDesc::Desc(Member::Field(S("tag")))] => {
group.sort_by_key(|d| Reverse(d.sort_by_rank)); group.sort_by_key(|d| Reverse(d.sort_by_rank));
new_groups.extend(group.linear_group_by_key(|d| d.sort_by_rank).map(Vec::from)); new_groups.extend(group.linear_group_by_key(|d| d.sort_by_rank).map(Vec::from));
} }
Criterion::Typo => { RankingRule::Typo => {
group.sort_by_key(|d| d.typo_rank); group.sort_by_key(|d| d.typo_rank);
new_groups.extend(group.linear_group_by_key(|d| d.typo_rank).map(Vec::from)); new_groups.extend(group.linear_group_by_key(|d| d.typo_rank).map(Vec::from));
} }
Criterion::Words => { RankingRule::Words => {
group.sort_by_key(|d| d.word_rank); group.sort_by_key(|d| d.word_rank);
new_groups.extend(group.linear_group_by_key(|d| d.word_rank).map(Vec::from)); new_groups.extend(group.linear_group_by_key(|d| d.word_rank).map(Vec::from));
} }
Criterion::Asc(field_name) if field_name == "asc_desc_rank" => { RankingRule::Asc(field_name) if field_name == "asc_desc_rank" => {
group.sort_by_key(|d| d.asc_desc_rank); group.sort_by_key(|d| d.asc_desc_rank);
new_groups new_groups
.extend(group.linear_group_by_key(|d| d.asc_desc_rank).map(Vec::from)); .extend(group.linear_group_by_key(|d| d.asc_desc_rank).map(Vec::from));
} }
Criterion::Desc(field_name) if field_name == "asc_desc_rank" => { RankingRule::Desc(field_name) if field_name == "asc_desc_rank" => {
group.sort_by_key(|d| Reverse(d.asc_desc_rank)); group.sort_by_key(|d| Reverse(d.asc_desc_rank));
new_groups new_groups
.extend(group.linear_group_by_key(|d| d.asc_desc_rank).map(Vec::from)); .extend(group.linear_group_by_key(|d| d.asc_desc_rank).map(Vec::from));
} }
Criterion::Asc(_) | Criterion::Desc(_) | Criterion::Sort => { RankingRule::Asc(_) | RankingRule::Desc(_) | RankingRule::Sort => {
new_groups.push(group.clone()) new_groups.push(group.clone())
} }
} }

6
milli/tests/search/phrase_search.rs
View File

@ -1,7 +1,7 @@
use milli::update::{IndexerConfig, Settings}; use milli::update::{IndexerConfig, Settings};
use milli::{Criterion, Index, Search, TermsMatchingStrategy}; use milli::{Index, RankingRule, Search, TermsMatchingStrategy};
use crate::search::Criterion::{Attribute, Exactness, Proximity}; use crate::search::RankingRule::{Attribute, Exactness, Proximity};
fn set_stop_words(index: &Index, stop_words: &[&str]) { fn set_stop_words(index: &Index, stop_words: &[&str]) {
let mut wtxn = index.write_txn().unwrap(); let mut wtxn = index.write_txn().unwrap();
@ -14,7 +14,7 @@ fn set_stop_words(index: &Index, stop_words: &[&str]) {
wtxn.commit().unwrap(); wtxn.commit().unwrap();
} }
fn test_phrase_search_with_stop_words_given_criteria(criteria: &[Criterion]) { fn test_phrase_search_with_stop_words_given_criteria(criteria: &[RankingRule]) {
let index = super::setup_search_index_with_criteria(criteria); let index = super::setup_search_index_with_criteria(criteria);
// Add stop_words // Add stop_words

10
milli/tests/search/query_criteria.rs
View File

@ -7,9 +7,9 @@ use itertools::Itertools;
use maplit::hashset; use maplit::hashset;
use milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader}; use milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader};
use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings}; use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings};
use milli::{AscDesc, Criterion, Index, Member, Search, SearchResult, TermsMatchingStrategy}; use milli::{AscDesc, Index, Member, RankingRule, Search, SearchResult, TermsMatchingStrategy};
use rand::Rng; use rand::Rng;
use Criterion::*; use RankingRule::*;
use crate::search::{self, EXTERNAL_DOCUMENTS_IDS}; use crate::search::{self, EXTERNAL_DOCUMENTS_IDS};
@ -88,7 +88,7 @@ test_criterion!(
#[test] #[test]
fn criteria_mixup() { fn criteria_mixup() {
use Criterion::*; use RankingRule::*;
let index = search::setup_search_index_with_criteria(&[ let index = search::setup_search_index_with_criteria(&[
Words, Words,
Attribute, Attribute,
@ -233,7 +233,7 @@ fn criteria_mixup() {
//update criteria //update criteria
let mut wtxn = index.write_txn().unwrap(); let mut wtxn = index.write_txn().unwrap();
let mut builder = Settings::new(&mut wtxn, &index, &config); let mut builder = Settings::new(&mut wtxn, &index, &config);
builder.set_criteria(criteria.clone()); builder.set_ranking_rules(criteria.clone());
builder.execute(|_| (), || false).unwrap(); builder.execute(|_| (), || false).unwrap();
wtxn.commit().unwrap(); wtxn.commit().unwrap();
@ -324,7 +324,7 @@ fn criteria_ascdesc() {
let mut wtxn = index.write_txn().unwrap(); let mut wtxn = index.write_txn().unwrap();
let mut builder = Settings::new(&mut wtxn, &index, &config); let mut builder = Settings::new(&mut wtxn, &index, &config);
builder.set_criteria(vec![criterion.clone()]); builder.set_ranking_rules(vec![criterion.clone()]);
builder.execute(|_| (), || false).unwrap(); builder.execute(|_| (), || false).unwrap();
wtxn.commit().unwrap(); wtxn.commit().unwrap();

2
milli/tests/search/sort.rs
View File

@ -1,5 +1,5 @@
use big_s::S; use big_s::S;
use milli::Criterion::{Attribute, Exactness, Proximity, Typo, Words}; use milli::RankingRule::{Attribute, Exactness, Proximity, Typo, Words};
use milli::{AscDesc, Error, Member, Search, TermsMatchingStrategy, UserError}; use milli::{AscDesc, Error, Member, Search, TermsMatchingStrategy, UserError};
use crate::search::{self, EXTERNAL_DOCUMENTS_IDS}; use crate::search::{self, EXTERNAL_DOCUMENTS_IDS};

4
milli/tests/search/typo_tolerance.rs
View File

@ -2,10 +2,10 @@ use std::collections::BTreeSet;
use heed::EnvOpenOptions; use heed::EnvOpenOptions;
use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings}; use milli::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig, Settings};
use milli::{Criterion, Index, Search, TermsMatchingStrategy}; use milli::{Index, RankingRule, Search, TermsMatchingStrategy};
use serde_json::json; use serde_json::json;
use tempfile::tempdir; use tempfile::tempdir;
use Criterion::*; use RankingRule::*;
#[test] #[test]
fn test_typo_tolerance_one_typo() { fn test_typo_tolerance_one_typo() {