diff --git a/meilisearch-core/src/database.rs b/meilisearch-core/src/database.rs index f66d292f0..3326eb9cd 100644 --- a/meilisearch-core/src/database.rs +++ b/meilisearch-core/src/database.rs @@ -1059,12 +1059,12 @@ mod tests { let data = r#" { "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)" ], "searchableAttributes": ["name", "release_date"], diff --git a/meilisearch-core/src/settings.rs b/meilisearch-core/src/settings.rs index 01790bd8a..11344a833 100644 --- a/meilisearch-core/src/settings.rs +++ b/meilisearch-core/src/settings.rs @@ -5,6 +5,10 @@ use std::iter::IntoIterator; use serde::{Deserialize, Deserializer, Serialize}; use once_cell::sync::Lazy; +use self::RankingRule::*; + +pub const DEFAULT_RANKING_RULES: [RankingRule; 6] = [Typo, Words, Proximity, Attribute, WordsPosition, Exactness]; + static RANKING_RULE_REGEX: Lazy = Lazy::new(|| { let regex = regex::Regex::new(r"(asc|dsc)\(([a-zA-Z0-9-_]*)\)").unwrap(); regex @@ -16,7 +20,7 @@ pub struct Settings { #[serde(default, deserialize_with = "deserialize_some")] pub ranking_rules: Option>>, #[serde(default, deserialize_with = "deserialize_some")] - pub ranking_distinct: Option>, + pub distinct_attribute: Option>, #[serde(default, deserialize_with = "deserialize_some")] pub searchable_attributes: Option>>, #[serde(default, deserialize_with = "deserialize_some")] @@ -26,7 +30,7 @@ pub struct Settings { #[serde(default, deserialize_with = "deserialize_some")] pub synonyms: Option>>>, #[serde(default, deserialize_with = "deserialize_some")] - pub index_new_fields: Option>, + pub accept_new_fields: Option>, } // Any value that is present is considered Some value, including null. @@ -49,13 +53,13 @@ impl Settings { Ok(SettingsUpdate { ranking_rules, - ranking_distinct: settings.ranking_distinct.into(), + distinct_attribute: settings.distinct_attribute.into(), identifier: UpdateState::Nothing, searchable_attributes: settings.searchable_attributes.into(), displayed_attributes: settings.displayed_attributes.into(), stop_words: settings.stop_words.into(), synonyms: settings.synonyms.into(), - index_new_fields: settings.index_new_fields.into(), + accept_new_fields: settings.accept_new_fields.into(), }) } } @@ -98,17 +102,17 @@ pub enum RankingRule { Dsc(String), } -impl ToString for RankingRule { - fn to_string(&self) -> String { +impl std::fmt::Display for RankingRule { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { match self { - RankingRule::Typo => "_typo".to_string(), - RankingRule::Words => "_words".to_string(), - RankingRule::Proximity => "_proximity".to_string(), - RankingRule::Attribute => "_attribute".to_string(), - RankingRule::WordsPosition => "_words_position".to_string(), - RankingRule::Exactness => "_exactness".to_string(), - RankingRule::Asc(field) => format!("asc({})", field), - RankingRule::Dsc(field) => format!("dsc({})", field), + RankingRule::Typo => f.write_str("typo"), + RankingRule::Words => f.write_str("words"), + RankingRule::Proximity => f.write_str("proximity"), + RankingRule::Attribute => f.write_str("attribute"), + RankingRule::WordsPosition => f.write_str("wordsPosition"), + RankingRule::Exactness => f.write_str("exactness"), + RankingRule::Asc(field) => write!(f, "asc({})", field), + RankingRule::Dsc(field) => write!(f, "dsc({})", field), } } } @@ -118,12 +122,12 @@ impl FromStr for RankingRule { fn from_str(s: &str) -> Result { let rule = match s { - "_typo" => RankingRule::Typo, - "_words" => RankingRule::Words, - "_proximity" => RankingRule::Proximity, - "_attribute" => RankingRule::Attribute, - "_words_position" => RankingRule::WordsPosition, - "_exactness" => RankingRule::Exactness, + "typo" => RankingRule::Typo, + "words" => RankingRule::Words, + "proximity" => RankingRule::Proximity, + "attribute" => RankingRule::Attribute, + "wordsPosition" => RankingRule::WordsPosition, + "exactness" => RankingRule::Exactness, _ => { let captures = RANKING_RULE_REGEX.captures(s).ok_or(RankingRuleConversionError)?; match (captures.get(1).map(|m| m.as_str()), captures.get(2)) { @@ -155,26 +159,26 @@ impl RankingRule { #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SettingsUpdate { pub ranking_rules: UpdateState>, - pub ranking_distinct: UpdateState, + pub distinct_attribute: UpdateState, pub identifier: UpdateState, pub searchable_attributes: UpdateState>, pub displayed_attributes: UpdateState>, pub stop_words: UpdateState>, pub synonyms: UpdateState>>, - pub index_new_fields: UpdateState, + pub accept_new_fields: UpdateState, } impl Default for SettingsUpdate { fn default() -> Self { Self { ranking_rules: UpdateState::Nothing, - ranking_distinct: UpdateState::Nothing, + distinct_attribute: UpdateState::Nothing, identifier: UpdateState::Nothing, searchable_attributes: UpdateState::Nothing, displayed_attributes: UpdateState::Nothing, stop_words: UpdateState::Nothing, synonyms: UpdateState::Nothing, - index_new_fields: UpdateState::Nothing, + accept_new_fields: UpdateState::Nothing, } } } diff --git a/meilisearch-core/src/store/main.rs b/meilisearch-core/src/store/main.rs index 2e13d52ec..a156cee4b 100644 --- a/meilisearch-core/src/store/main.rs +++ b/meilisearch-core/src/store/main.rs @@ -12,7 +12,7 @@ use crate::settings::RankingRule; const CREATED_AT_KEY: &str = "created-at"; const RANKING_RULES_KEY: &str = "ranking-rules"; -const RANKING_DISTINCT_KEY: &str = "ranking-distinct"; +const DISTINCT_ATTRIBUTE_KEY: &str = "distinct-attribute"; const STOP_WORDS_KEY: &str = "stop-words"; const SYNONYMS_KEY: &str = "synonyms"; const CUSTOMS_KEY: &str = "customs"; @@ -200,19 +200,19 @@ impl Main { self.main.delete::<_, Str>(writer, RANKING_RULES_KEY) } - pub fn ranking_distinct(&self, reader: &heed::RoTxn) -> ZResult> { - if let Some(value) = self.main.get::<_, Str, Str>(reader, RANKING_DISTINCT_KEY)? { + pub fn distinct_attribute(&self, reader: &heed::RoTxn) -> ZResult> { + if let Some(value) = self.main.get::<_, Str, Str>(reader, DISTINCT_ATTRIBUTE_KEY)? { return Ok(Some(value.to_owned())) } return Ok(None) } - pub fn put_ranking_distinct(self, writer: &mut heed::RwTxn, value: &str) -> ZResult<()> { - self.main.put::<_, Str, Str>(writer, RANKING_DISTINCT_KEY, value) + pub fn put_distinct_attribute(self, writer: &mut heed::RwTxn, value: &str) -> ZResult<()> { + self.main.put::<_, Str, Str>(writer, DISTINCT_ATTRIBUTE_KEY, value) } - pub fn delete_ranking_distinct(self, writer: &mut heed::RwTxn) -> ZResult { - self.main.delete::<_, Str>(writer, RANKING_DISTINCT_KEY) + pub fn delete_distinct_attribute(self, writer: &mut heed::RwTxn) -> ZResult { + self.main.delete::<_, Str>(writer, DISTINCT_ATTRIBUTE_KEY) } pub fn put_customs(self, writer: &mut heed::RwTxn, customs: &[u8]) -> ZResult<()> { diff --git a/meilisearch-core/src/update/settings_update.rs b/meilisearch-core/src/update/settings_update.rs index e733adac7..d0f10eb80 100644 --- a/meilisearch-core/src/update/settings_update.rs +++ b/meilisearch-core/src/update/settings_update.rs @@ -58,22 +58,22 @@ pub fn apply_settings_update( UpdateState::Nothing => (), } - match settings.ranking_distinct { + match settings.distinct_attribute { UpdateState::Update(v) => { - index.main.put_ranking_distinct(writer, &v)?; + index.main.put_distinct_attribute(writer, &v)?; }, UpdateState::Clear => { - index.main.delete_ranking_distinct(writer)?; + index.main.delete_distinct_attribute(writer)?; }, UpdateState::Nothing => (), } - match settings.index_new_fields { + match settings.accept_new_fields { UpdateState::Update(v) => { - schema.set_index_new_fields(v); + schema.set_accept_new_fields(v); }, UpdateState::Clear => { - schema.set_index_new_fields(true); + schema.set_accept_new_fields(true); }, UpdateState::Nothing => (), } @@ -84,8 +84,7 @@ pub fn apply_settings_update( must_reindex = true; }, UpdateState::Clear => { - let clear: Vec<&str> = Vec::new(); - schema.update_indexed(clear)?; + schema.set_all_fields_as_indexed(); must_reindex = true; }, UpdateState::Nothing => (), @@ -93,8 +92,7 @@ pub fn apply_settings_update( match settings.displayed_attributes.clone() { UpdateState::Update(v) => schema.update_displayed(v)?, UpdateState::Clear => { - let clear: Vec<&str> = Vec::new(); - schema.update_displayed(clear)?; + schema.set_all_fields_as_displayed(); }, UpdateState::Nothing => (), } diff --git a/meilisearch-http/src/data.rs b/meilisearch-http/src/data.rs index 3cd6a514b..5d05c02dd 100644 --- a/meilisearch-http/src/data.rs +++ b/meilisearch-http/src/data.rs @@ -6,8 +6,8 @@ use chrono::{DateTime, Utc}; use heed::types::{SerdeBincode, Str}; use log::error; use meilisearch_core::{Database, Error as MError, MResult, MainT, UpdateT}; -use sysinfo::Pid; use sha2::Digest; +use sysinfo::Pid; use crate::option::Opt; use crate::routes::index::index_update_callback; @@ -117,9 +117,7 @@ impl DataInner { // convert attributes to their names let frequency: HashMap<_, _> = fields_frequency .into_iter() - .filter_map(|(a, c)| { - schema.name(a).map(|name| (name.to_string(), c)) - }) + .filter_map(|(a, c)| schema.name(a).map(|name| (name.to_string(), c))) .collect(); index diff --git a/meilisearch-http/src/helpers/tide.rs b/meilisearch-http/src/helpers/tide.rs index 96003ce91..ce3bbe82a 100644 --- a/meilisearch-http/src/helpers/tide.rs +++ b/meilisearch-http/src/helpers/tide.rs @@ -6,7 +6,7 @@ use tide::Request; pub enum ACL { Admin, Private, - Public + Public, } pub trait RequestExt { @@ -23,31 +23,33 @@ impl RequestExt for Request { match acl { ACL::Admin => { if user_api_key == self.state().api_keys.master.as_deref() { - return Ok(()) + return Ok(()); } - }, + } ACL::Private => { if user_api_key == self.state().api_keys.master.as_deref() { - return Ok(()) + return Ok(()); } if user_api_key == self.state().api_keys.private.as_deref() { - return Ok(()) + return Ok(()); } - }, + } ACL::Public => { if user_api_key == self.state().api_keys.master.as_deref() { - return Ok(()) + return Ok(()); } if user_api_key == self.state().api_keys.private.as_deref() { - return Ok(()) + return Ok(()); } if user_api_key == self.state().api_keys.public.as_deref() { - return Ok(()) + return Ok(()); } } } - Err(ResponseError::InvalidToken(user_api_key.unwrap_or("Need a token").to_owned())) + Err(ResponseError::InvalidToken( + user_api_key.unwrap_or("Need a token").to_owned(), + )) } fn url_param(&self, name: &str) -> SResult { diff --git a/meilisearch-http/src/main.rs b/meilisearch-http/src/main.rs index 7d24e53a0..124bb9c47 100644 --- a/meilisearch-http/src/main.rs +++ b/meilisearch-http/src/main.rs @@ -18,19 +18,21 @@ mod analytics; static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc; pub fn main() -> Result<(), MainError> { - let opt = Opt::from_args(); match opt.env.as_ref() { "production" => { if opt.master_key.is_none() { - return Err("In production mode, the environment variable MEILI_MASTER_KEY is mandatory".into()); + return Err( + "In production mode, the environment variable MEILI_MASTER_KEY is mandatory" + .into(), + ); } env_logger::init(); - }, + } "development" => { env_logger::from_env(env_logger::Env::default().default_filter_or("info")).init(); - }, + } _ => unreachable!(), } @@ -58,7 +60,6 @@ pub fn main() -> Result<(), MainError> { Ok(()) } - pub fn print_launch_resume(opt: &Opt, data: &Data) { let ascii_name = r#" 888b d888 d8b 888 d8b .d8888b. 888 @@ -77,8 +78,14 @@ pub fn print_launch_resume(opt: &Opt, data: &Data) { info!("Start server on: {:?}", opt.http_addr); info!("Environment: {:?}", opt.env); info!("Commit SHA: {:?}", env!("VERGEN_SHA").to_string()); - info!("Build date: {:?}", env!("VERGEN_BUILD_TIMESTAMP").to_string()); - info!("Package version: {:?}", env!("CARGO_PKG_VERSION").to_string()); + info!( + "Build date: {:?}", + env!("VERGEN_BUILD_TIMESTAMP").to_string() + ); + info!( + "Package version: {:?}", + env!("CARGO_PKG_VERSION").to_string() + ); if let Some(master_key) = &data.api_keys.master { info!("Master Key: {:?}", master_key); diff --git a/meilisearch-http/src/routes/document.rs b/meilisearch-http/src/routes/document.rs index 1e70db296..e0ab4e88d 100644 --- a/meilisearch-http/src/routes/document.rs +++ b/meilisearch-http/src/routes/document.rs @@ -145,7 +145,7 @@ async fn update_multiple_documents(mut ctx: Request, is_partial: bool) -> None => return Err(ResponseError::bad_request("Could not infer a schema")), }, }; - let settings_update = SettingsUpdate{ + let settings_update = SettingsUpdate { identifier: UpdateState::Update(id), ..SettingsUpdate::default() }; diff --git a/meilisearch-http/src/routes/index.rs b/meilisearch-http/src/routes/index.rs index eb12145d0..6625d24c3 100644 --- a/meilisearch-http/src/routes/index.rs +++ b/meilisearch-http/src/routes/index.rs @@ -42,7 +42,7 @@ pub async fn list_indexes(ctx: Request) -> SResult { let identifier = match index.main.schema(&reader) { Ok(Some(schema)) => Some(schema.identifier().to_owned()), - _ => None + _ => None, }; let index_response = IndexResponse { @@ -89,7 +89,7 @@ pub async fn get_index(ctx: Request) -> SResult { let identifier = match index.main.schema(&reader) { Ok(Some(schema)) => Some(schema.identifier().to_owned()), - _ => None + _ => None, }; let response_body = IndexResponse { @@ -97,7 +97,7 @@ pub async fn get_index(ctx: Request) -> SResult { uid, created_at, updated_at, - identifier + identifier, }; Ok(tide::Response::new(200).body_json(&response_body)?) @@ -220,9 +220,13 @@ pub async fn update_index(mut ctx: Request) -> SResult { if let Some(identifier) = body.identifier { if let Ok(Some(_)) = index.main.schema(&writer) { - return Err(ResponseError::bad_request("The index identifier cannot be updated")); + return Err(ResponseError::bad_request( + "The index identifier cannot be updated", + )); } - index.main.put_schema(&mut writer, &Schema::with_identifier(&identifier))?; + index + .main + .put_schema(&mut writer, &Schema::with_identifier(&identifier))?; } index.main.put_updated_at(&mut writer)?; @@ -235,7 +239,7 @@ pub async fn update_index(mut ctx: Request) -> SResult { let identifier = match index.main.schema(&reader) { Ok(Some(schema)) => Some(schema.identifier().to_owned()), - _ => None + _ => None, }; let response_body = UpdateIndexResponse { @@ -243,7 +247,7 @@ pub async fn update_index(mut ctx: Request) -> SResult { uid: index_uid, created_at, updated_at, - identifier + identifier, }; Ok(tide::Response::new(200).body_json(&response_body)?) diff --git a/meilisearch-http/src/routes/key.rs b/meilisearch-http/src/routes/key.rs index 6ab85645b..fe0feacf4 100644 --- a/meilisearch-http/src/routes/key.rs +++ b/meilisearch-http/src/routes/key.rs @@ -1,18 +1,17 @@ -use tide::{Request, Response}; -use serde_json::json; use crate::error::SResult; use crate::helpers::tide::RequestExt; use crate::helpers::tide::ACL::*; use crate::Data; +use serde_json::json; +use tide::{Request, Response}; pub async fn list(ctx: Request) -> SResult { ctx.is_allowed(Admin)?; let keys = &ctx.state().api_keys; - Ok(tide::Response::new(200) - .body_json(&json!({ - "private": keys.private, - "public": keys.public, - }))?) + Ok(tide::Response::new(200).body_json(&json!({ + "private": keys.private, + "public": keys.public, + }))?) } diff --git a/meilisearch-http/src/routes/mod.rs b/meilisearch-http/src/routes/mod.rs index 24e7f2203..e9188100a 100644 --- a/meilisearch-http/src/routes/mod.rs +++ b/meilisearch-http/src/routes/mod.rs @@ -23,19 +23,15 @@ async fn into_response( } pub fn load_routes(app: &mut tide::Server) { - app.at("/").get(|_| { - async move { - tide::Response::new(200) - .body_string(include_str!("../../public/interface.html").to_string()) - .set_mime(mime::TEXT_HTML_UTF_8) - } + app.at("/").get(|_| async { + tide::Response::new(200) + .body_string(include_str!("../../public/interface.html").to_string()) + .set_mime(mime::TEXT_HTML_UTF_8) }); - app.at("/bulma.min.css").get(|_| { - async { - tide::Response::new(200) - .body_string(include_str!("../../public/bulma.min.css").to_string()) - .set_mime(mime::TEXT_CSS_UTF_8) - } + app.at("/bulma.min.css").get(|_| async { + tide::Response::new(200) + .body_string(include_str!("../../public/bulma.min.css").to_string()) + .set_mime(mime::TEXT_CSS_UTF_8) }); app.at("/indexes") @@ -82,7 +78,7 @@ pub fn load_routes(app: &mut tide::Server) { .post(|ctx| into_response(setting::update_rules(ctx))) .delete(|ctx| into_response(setting::delete_rules(ctx))); - app.at("/indexes/:index/settings/ranking-distinct") + app.at("/indexes/:index/settings/distinct-attribute") .get(|ctx| into_response(setting::get_distinct(ctx))) .post(|ctx| into_response(setting::update_distinct(ctx))) .delete(|ctx| into_response(setting::delete_distinct(ctx))); @@ -101,8 +97,8 @@ pub fn load_routes(app: &mut tide::Server) { .delete(|ctx| into_response(setting::delete_displayed(ctx))); app.at("/indexes/:index/settings/index-new-field") - .get(|ctx| into_response(setting::get_index_new_fields(ctx))) - .post(|ctx| into_response(setting::update_index_new_fields(ctx))); + .get(|ctx| into_response(setting::get_accept_new_fields(ctx))) + .post(|ctx| into_response(setting::update_accept_new_fields(ctx))); app.at("/indexes/:index/settings/synonyms") .get(|ctx| into_response(synonym::get(ctx))) @@ -117,8 +113,7 @@ pub fn load_routes(app: &mut tide::Server) { app.at("/indexes/:index/stats") .get(|ctx| into_response(stats::index_stats(ctx))); - app.at("/keys/") - .get(|ctx| into_response(key::list(ctx))); + app.at("/keys/").get(|ctx| into_response(key::list(ctx))); app.at("/health") .get(|ctx| into_response(health::get_health(ctx))) diff --git a/meilisearch-http/src/routes/search.rs b/meilisearch-http/src/routes/search.rs index bfb8372aa..2dffd9356 100644 --- a/meilisearch-http/src/routes/search.rs +++ b/meilisearch-http/src/routes/search.rs @@ -7,10 +7,10 @@ use rayon::iter::{IntoParallelIterator, ParallelIterator}; use serde::{Deserialize, Serialize}; use tide::{Request, Response}; -use crate::helpers::tide::ACL::*; use crate::error::{ResponseError, SResult}; use crate::helpers::meilisearch::{Error, IndexSearchExt, SearchHit}; use crate::helpers::tide::RequestExt; +use crate::helpers::tide::ACL::*; use crate::Data; #[derive(Deserialize)] diff --git a/meilisearch-http/src/routes/setting.rs b/meilisearch-http/src/routes/setting.rs index 277170fad..b0b5ce8ea 100644 --- a/meilisearch-http/src/routes/setting.rs +++ b/meilisearch-http/src/routes/setting.rs @@ -1,4 +1,4 @@ -use meilisearch_core::settings::{Settings, SettingsUpdate, UpdateState}; +use meilisearch_core::settings::{Settings, SettingsUpdate, UpdateState, DEFAULT_RANKING_RULES}; use serde::Deserialize; use std::collections::{BTreeMap, BTreeSet, HashSet}; use tide::{Request, Response}; @@ -46,16 +46,21 @@ pub async fn get_all(ctx: Request) -> SResult { None }; - let ranking_rules = match index.main.ranking_rules(&reader)? { - Some(rules) => Some(rules.iter().map(|r| r.to_string()).collect()), - None => None, - }; - let ranking_distinct = index.main.ranking_distinct(&reader)?; + let ranking_rules = index + .main + .ranking_rules(&reader)? + .unwrap_or(DEFAULT_RANKING_RULES.to_vec()) + .into_iter() + .map(|r| r.to_string()) + .collect(); + + let distinct_attribute = index.main.distinct_attribute(&reader)?; let schema = index.main.schema(&reader)?; let searchable_attributes = schema.clone().map(|s| { - let attrs = s.indexed_name() + let attrs = s + .indexed_name() .iter() .map(|s| (*s).to_string()) .collect::>(); @@ -67,7 +72,8 @@ pub async fn get_all(ctx: Request) -> SResult { }); let displayed_attributes = schema.clone().map(|s| { - let attrs = s.displayed_name() + let attrs = s + .displayed_name() .iter() .map(|s| (*s).to_string()) .collect::>(); @@ -77,16 +83,16 @@ pub async fn get_all(ctx: Request) -> SResult { Some(attrs) } }); - let index_new_fields = schema.map(|s| s.index_new_fields()); + let accept_new_fields = schema.map(|s| s.accept_new_fields()); let settings = Settings { - ranking_rules: Some(ranking_rules), - ranking_distinct: Some(ranking_distinct), + ranking_rules: Some(Some(ranking_rules)), + distinct_attribute: Some(distinct_attribute), searchable_attributes, displayed_attributes, stop_words: Some(stop_words), synonyms: Some(synonyms), - index_new_fields: Some(index_new_fields), + accept_new_fields: Some(accept_new_fields), }; Ok(tide::Response::new(200).body_json(&settings).unwrap()) @@ -96,13 +102,13 @@ pub async fn get_all(ctx: Request) -> SResult { #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct UpdateSettings { pub ranking_rules: Option>, - pub ranking_distinct: Option, + pub distinct_attribute: Option, pub identifier: Option, pub searchable_attributes: Option>, pub displayed_attributes: Option>, pub stop_words: Option>, pub synonyms: Option>>, - pub index_new_fields: Option, + pub accept_new_fields: Option, } pub async fn update_all(mut ctx: Request) -> SResult { @@ -114,12 +120,12 @@ pub async fn update_all(mut ctx: Request) -> SResult { let settings = Settings { ranking_rules: Some(settings_update.ranking_rules), - ranking_distinct: Some(settings_update.ranking_distinct), + distinct_attribute: Some(settings_update.distinct_attribute), searchable_attributes: Some(settings_update.searchable_attributes), displayed_attributes: Some(settings_update.displayed_attributes), stop_words: Some(settings_update.stop_words), synonyms: Some(settings_update.synonyms), - index_new_fields: Some(settings_update.index_new_fields), + accept_new_fields: Some(settings_update.accept_new_fields), }; let mut writer = db.update_write_txn()?; @@ -138,13 +144,13 @@ pub async fn delete_all(ctx: Request) -> SResult { let settings = SettingsUpdate { ranking_rules: UpdateState::Clear, - ranking_distinct: UpdateState::Clear, + distinct_attribute: UpdateState::Clear, identifier: UpdateState::Clear, searchable_attributes: UpdateState::Clear, displayed_attributes: UpdateState::Clear, stop_words: UpdateState::Clear, synonyms: UpdateState::Clear, - index_new_fields: UpdateState::Clear, + accept_new_fields: UpdateState::Clear, }; let update_id = index.settings_update(&mut writer, settings)?; @@ -161,10 +167,13 @@ pub async fn get_rules(ctx: Request) -> SResult { let db = &ctx.state().db; let reader = db.main_read_txn()?; - let ranking_rules: Option> = match index.main.ranking_rules(&reader)? { - Some(rules) => Some(rules.iter().map(|r| r.to_string()).collect()), - None => None, - }; + let ranking_rules = index + .main + .ranking_rules(&reader)? + .unwrap_or(DEFAULT_RANKING_RULES.to_vec()) + .into_iter() + .map(|r| r.to_string()) + .collect::>(); Ok(tide::Response::new(200).body_json(&ranking_rules).unwrap()) } @@ -214,22 +223,22 @@ pub async fn get_distinct(ctx: Request) -> SResult { let db = &ctx.state().db; let reader = db.main_read_txn()?; - let ranking_distinct = index.main.ranking_distinct(&reader)?; + let distinct_attribute = index.main.distinct_attribute(&reader)?; Ok(tide::Response::new(200) - .body_json(&ranking_distinct) + .body_json(&distinct_attribute) .unwrap()) } pub async fn update_distinct(mut ctx: Request) -> SResult { ctx.is_allowed(Private)?; let index = ctx.index()?; - let ranking_distinct: Option = + let distinct_attribute: Option = ctx.body_json().await.map_err(ResponseError::bad_request)?; let db = &ctx.state().db; let settings = Settings { - ranking_distinct: Some(ranking_distinct), + distinct_attribute: Some(distinct_attribute), ..Settings::default() }; @@ -248,7 +257,7 @@ pub async fn delete_distinct(ctx: Request) -> SResult { let mut writer = db.update_write_txn()?; let settings = SettingsUpdate { - ranking_distinct: UpdateState::Clear, + distinct_attribute: UpdateState::Clear, ..SettingsUpdate::default() }; @@ -385,7 +394,7 @@ pub async fn delete_displayed(ctx: Request) -> SResult { Ok(tide::Response::new(202).body_json(&response_body)?) } -pub async fn get_index_new_fields(ctx: Request) -> SResult { +pub async fn get_accept_new_fields(ctx: Request) -> SResult { ctx.is_allowed(Private)?; let index = ctx.index()?; let db = &ctx.state().db; @@ -393,22 +402,22 @@ pub async fn get_index_new_fields(ctx: Request) -> SResult { let schema = index.main.schema(&reader)?; - let index_new_fields = schema.map(|s| s.index_new_fields()); + let accept_new_fields = schema.map(|s| s.accept_new_fields()); Ok(tide::Response::new(200) - .body_json(&index_new_fields) + .body_json(&accept_new_fields) .unwrap()) } -pub async fn update_index_new_fields(mut ctx: Request) -> SResult { +pub async fn update_accept_new_fields(mut ctx: Request) -> SResult { ctx.is_allowed(Private)?; let index = ctx.index()?; - let index_new_fields: Option = + let accept_new_fields: Option = ctx.body_json().await.map_err(ResponseError::bad_request)?; let db = &ctx.state().db; let settings = Settings { - index_new_fields: Some(index_new_fields), + accept_new_fields: Some(accept_new_fields), ..Settings::default() }; diff --git a/meilisearch-http/tests/common.rs b/meilisearch-http/tests/common.rs index a9bb0848b..605caa833 100644 --- a/meilisearch-http/tests/common.rs +++ b/meilisearch-http/tests/common.rs @@ -57,16 +57,16 @@ pub fn enrich_server_with_movies_settings( ) -> Result<(), Box> { let json = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)", ], - "rankingDistinct": null, + "distinctAttribute": null, "searchableAttributes": [ "title", "tagline", @@ -92,7 +92,7 @@ pub fn enrich_server_with_movies_settings( ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); let body = json.to_string().into_bytes(); @@ -179,7 +179,7 @@ pub fn wait_update_id(server: &mut TestBackend>, update_id: u64) { let response: Value = serde_json::from_slice(&buf).unwrap(); if response["status"] == "processed" { - return + return; } block_on(sleep(Duration::from_secs(1))); } diff --git a/meilisearch-http/tests/search.rs b/meilisearch-http/tests/search.rs index eb510c90b..b03ff4a0d 100644 --- a/meilisearch-http/tests/search.rs +++ b/meilisearch-http/tests/search.rs @@ -626,16 +626,16 @@ fn search_with_settings_basic() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "title", @@ -662,7 +662,7 @@ fn search_with_settings_basic() { ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -732,16 +732,16 @@ fn search_with_settings_stop_words() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "title", @@ -768,7 +768,7 @@ fn search_with_settings_stop_words() { ], "stopWords": ["the"], "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -839,16 +839,16 @@ fn search_with_settings_synonyms() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "title", @@ -880,7 +880,7 @@ fn search_with_settings_synonyms() { "Iron Man" ] }, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -951,16 +951,16 @@ fn search_with_settings_ranking_rules() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "asc(vote_average)", - "_exactness", + "exactness", "dsc(popularity)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "title", @@ -987,7 +987,7 @@ fn search_with_settings_ranking_rules() { ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -1058,16 +1058,16 @@ fn search_with_settings_searchable_attributes() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "tagline", @@ -1093,7 +1093,7 @@ fn search_with_settings_searchable_attributes() { ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -1164,16 +1164,16 @@ fn search_with_settings_displayed_attributes() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "title", @@ -1194,7 +1194,7 @@ fn search_with_settings_displayed_attributes() { ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); @@ -1235,16 +1235,16 @@ fn search_with_settings_searchable_attributes_2() { let config = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", "dsc(popularity)", - "_exactness", + "exactness", "dsc(vote_average)" ], - "rankingDistinct": null, + "distinctAttribute": null, "identifier": "id", "searchableAttributes": [ "tagline", @@ -1265,7 +1265,7 @@ fn search_with_settings_searchable_attributes_2() { ], "stopWords": null, "synonyms": null, - "indexNewFields": false, + "acceptNewFields": false, }); common::update_config(&mut server, config); diff --git a/meilisearch-http/tests/settings.rs b/meilisearch-http/tests/settings.rs index 19d4ff092..09a8c96bd 100644 --- a/meilisearch-http/tests/settings.rs +++ b/meilisearch-http/tests/settings.rs @@ -41,16 +41,16 @@ fn write_all_and_delete() { let json = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", "dsc(rank)", ], - "rankingDistinct": "movie_id", + "distinctAttribute": "movie_id", "searchableAttributes": [ "id", "movie_id", @@ -76,7 +76,7 @@ fn write_all_and_delete() { "wolverine": ["xmen", "logan"], "logan": ["wolverine"], }, - "indexNewFields": false, + "acceptNewFields": false, }); let body = json.to_string().into_bytes(); @@ -126,13 +126,36 @@ fn write_all_and_delete() { let res_value: Value = serde_json::from_slice(&buf).unwrap(); let json = json!({ - "rankingRules": null, - "rankingDistinct": null, - "searchableAttributes": null, - "displayedAttributes": null, + "rankingRules": [ + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness" + ], + "distinctAttribute": null, + "searchableAttributes": [ + "id", + "release_date", + "poster", + "description", + "title", + "movie_id", + "rank" + ], + "displayedAttributes": [ + "movie_id", + "description", + "poster", + "id", + "release_date", + "rank", + "title" + ], "stopWords": null, "synonyms": null, - "indexNewFields": true, + "acceptNewFields": true, }); assert_json_eq!(json, res_value, ordered: false); @@ -169,16 +192,16 @@ fn write_all_and_update() { let json = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", "dsc(rank)", ], - "rankingDistinct": "movie_id", + "distinctAttribute": "movie_id", "searchableAttributes": [ "uid", "movie_id", @@ -204,7 +227,7 @@ fn write_all_and_update() { "wolverine": ["xmen", "logan"], "logan": ["wolverine"], }, - "indexNewFields": false, + "acceptNewFields": false, }); let body = json.to_string().into_bytes(); @@ -235,12 +258,12 @@ fn write_all_and_update() { let json_update = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", ], "searchableAttributes": [ @@ -261,7 +284,7 @@ fn write_all_and_update() { "wolverine": ["xmen", "logan"], "logan": ["wolverine", "xmen"], }, - "indexNewFields": false, + "acceptNewFields": false, }); let body_update = json_update.to_string().into_bytes(); @@ -288,15 +311,15 @@ fn write_all_and_update() { let res_expected = json!({ "rankingRules": [ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", ], - "rankingDistinct": null, + "distinctAttribute": null, "searchableAttributes": [ "title", "description", @@ -314,7 +337,7 @@ fn write_all_and_update() { "wolverine": ["xmen", "logan"], "logan": ["wolverine", "xmen"], }, - "indexNewFields": false + "acceptNewFields": false }); assert_json_eq!(res_expected, res_value, ordered: false); diff --git a/meilisearch-http/tests/settings_ranking_rules.rs b/meilisearch-http/tests/settings_ranking_rules.rs index b310df3cd..f221aacfb 100644 --- a/meilisearch-http/tests/settings_ranking_rules.rs +++ b/meilisearch-http/tests/settings_ranking_rules.rs @@ -39,12 +39,12 @@ fn write_all_and_delete() { // 2 - Send the settings let json = json!([ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", "dsc(rank)", ]); @@ -95,7 +95,14 @@ fn write_all_and_delete() { block_on(res.into_body().read_to_end(&mut buf)).unwrap(); let res_value: Value = serde_json::from_slice(&buf).unwrap(); - let json = json!(null); + let json = json!([ + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness" + ]); assert_json_eq!(json, res_value, ordered: false); } @@ -130,12 +137,12 @@ fn write_all_and_update() { // 2 - Send the settings let json = json!([ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", "dsc(rank)", ]); @@ -167,12 +174,12 @@ fn write_all_and_update() { // 4 - Update all settings let json_update = json!([ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", ]); @@ -199,12 +206,12 @@ fn write_all_and_update() { let res_value: Value = serde_json::from_slice(&buf).unwrap(); let res_expected = json!([ - "_typo", - "_words", - "_proximity", - "_attribute", - "_words_position", - "_exactness", + "typo", + "words", + "proximity", + "attribute", + "wordsPosition", + "exactness", "dsc(release_date)", ]); diff --git a/meilisearch-schema/src/fields_map.rs b/meilisearch-schema/src/fields_map.rs index 6243a554b..76d98f4da 100644 --- a/meilisearch-schema/src/fields_map.rs +++ b/meilisearch-schema/src/fields_map.rs @@ -1,4 +1,5 @@ use std::collections::HashMap; +use std::collections::hash_map::Iter; use serde::{Deserialize, Serialize}; @@ -45,6 +46,10 @@ impl FieldsMap { pub fn name>(&self, id: I) -> Option<&str> { self.id_map.get(&id.into()).map(|s| s.as_str()) } + + pub fn iter(&self) -> Iter<'_, String, FieldId> { + self.name_map.iter() + } } #[cfg(test)] diff --git a/meilisearch-schema/src/schema.rs b/meilisearch-schema/src/schema.rs index 5a3858f0d..7a4180cb5 100644 --- a/meilisearch-schema/src/schema.rs +++ b/meilisearch-schema/src/schema.rs @@ -13,7 +13,7 @@ pub struct Schema { indexed: Vec, indexed_map: HashMap, - index_new_fields: bool, + accept_new_fields: bool, } impl Schema { @@ -28,7 +28,7 @@ impl Schema { displayed: HashSet::new(), indexed: Vec::new(), indexed_map: HashMap::new(), - index_new_fields: true, + accept_new_fields: true, } } @@ -68,7 +68,7 @@ impl Schema { Ok(id) } None => { - if self.index_new_fields { + if self.accept_new_fields { self.set_indexed(name)?; self.set_displayed(name) } else { @@ -190,11 +190,30 @@ impl Schema { Ok(()) } - pub fn index_new_fields(&self) -> bool { - self.index_new_fields + pub fn set_all_fields_as_indexed(&mut self) { + self.indexed.clear(); + self.indexed_map.clear(); + + for (_name, id) in self.fields_map.iter() { + let pos = self.indexed.len() as u16; + self.indexed.push(*id); + self.indexed_map.insert(*id, pos.into()); + } } - pub fn set_index_new_fields(&mut self, value: bool) { - self.index_new_fields = value; + pub fn set_all_fields_as_displayed(&mut self) { + self.displayed.clear(); + + for (_name, id) in self.fields_map.iter() { + self.displayed.insert(*id); + } + } + + pub fn accept_new_fields(&self) -> bool { + self.accept_new_fields + } + + pub fn set_accept_new_fields(&mut self, value: bool) { + self.accept_new_fields = value; } }