From c4653347fd296cbc4fb289bdb448dee313c35d79 Mon Sep 17 00:00:00 2001 From: ad hoc Date: Wed, 16 Mar 2022 10:03:18 +0100 Subject: [PATCH] add authorize typo setting --- milli/src/index.rs | 20 ++++++++++++++++++++ milli/src/search/mod.rs | 6 +++++- milli/src/search/query_tree.rs | 2 -- milli/src/update/settings.rs | 25 +++++++++++++++++++++++++ 4 files changed, 50 insertions(+), 3 deletions(-) diff --git a/milli/src/index.rs b/milli/src/index.rs index 568d50ad8..4e43e404e 100644 --- a/milli/src/index.rs +++ b/milli/src/index.rs @@ -46,6 +46,7 @@ pub mod main_key { pub const WORDS_PREFIXES_FST_KEY: &str = "words-prefixes-fst"; pub const CREATED_AT_KEY: &str = "created-at"; pub const UPDATED_AT_KEY: &str = "updated-at"; + pub const AUTHORIZE_TYPOS: &str = "authorize-typos"; } pub mod db_name { @@ -866,6 +867,25 @@ impl Index { ) -> heed::Result<()> { self.main.put::<_, Str, SerdeJson>(wtxn, main_key::UPDATED_AT_KEY, &time) } + + pub fn authorize_typos(&self, txn: &RoTxn) -> heed::Result { + // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We + // identify 0 as being false, and anything else as true. The absence of a value is true, + // because by default, we authorize typos. + match self.main.get::<_, Str, OwnedType>(txn, main_key::AUTHORIZE_TYPOS)? { + Some(0) => Ok(false), + _ => Ok(true), + } + } + + pub(crate) fn put_authorize_typos(&self, txn: &mut RwTxn, flag: bool) -> heed::Result<()> { + // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We + // identify 0 as being false, and anything else as true. The absence of a value is true, + // because by default, we authorize typos. + self.main.put::<_, Str, OwnedType>(txn, main_key::AUTHORIZE_TYPOS, &(flag as u8))?; + + Ok(()) + } } #[cfg(test)] diff --git a/milli/src/search/mod.rs b/milli/src/search/mod.rs index 40e4bca24..c9eef5a0d 100644 --- a/milli/src/search/mod.rs +++ b/milli/src/search/mod.rs @@ -112,7 +112,11 @@ impl<'a> Search<'a> { Some(query) => { let mut builder = QueryTreeBuilder::new(self.rtxn, self.index); builder.optional_words(self.optional_words); - builder.authorize_typos(self.authorize_typos); + + // only authorize typos if both the index and the query allow it. + let index_authorizes_typos = self.index.authorize_typos(self.rtxn)?; + builder.authorize_typos(self.authorize_typos && index_authorizes_typos); + builder.words_limit(self.words_limit); // We make sure that the analyzer is aware of the stop words // this ensures that the query builder is able to properly remove them. diff --git a/milli/src/search/query_tree.rs b/milli/src/search/query_tree.rs index f3ee99d9e..5437199e1 100644 --- a/milli/src/search/query_tree.rs +++ b/milli/src/search/query_tree.rs @@ -191,7 +191,6 @@ impl<'a> QueryTreeBuilder<'a> { /// generated forcing all query words to be present in each matching documents /// (the criterion `words` will be ignored). /// default value if not called: `true` - #[allow(unused)] pub fn optional_words(&mut self, optional_words: bool) -> &mut Self { self.optional_words = optional_words; self @@ -201,7 +200,6 @@ impl<'a> QueryTreeBuilder<'a> { /// forcing all query words to match documents without any typo /// (the criterion `typo` will be ignored). /// default value if not called: `true` - #[allow(unused)] pub fn authorize_typos(&mut self, authorize_typos: bool) -> &mut Self { self.authorize_typos = authorize_typos; self diff --git a/milli/src/update/settings.rs b/milli/src/update/settings.rs index c413f81c3..25f3e92a3 100644 --- a/milli/src/update/settings.rs +++ b/milli/src/update/settings.rs @@ -89,6 +89,7 @@ pub struct Settings<'a, 't, 'u, 'i> { distinct_field: Setting, synonyms: Setting>>, primary_key: Setting, + authorize_typos: Setting, } impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { @@ -109,6 +110,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { distinct_field: Setting::NotSet, synonyms: Setting::NotSet, primary_key: Setting::NotSet, + authorize_typos: Setting::NotSet, indexer_config, } } @@ -186,6 +188,14 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { self.primary_key = Setting::Set(primary_key); } + pub fn set_autorize_typos(&mut self, val: bool) { + self.authorize_typos = Setting::Set(val); + } + + pub fn reset_authorize_typos(&mut self) { + self.authorize_typos = Setting::Reset; + } + fn reindex(&mut self, cb: &F, old_fields_ids_map: FieldsIdsMap) -> Result<()> where F: Fn(UpdateIndexingStep) + Sync, @@ -450,6 +460,20 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { } } + fn update_authorize_typos(&mut self) -> Result<()> { + match self.authorize_typos { + Setting::Set(flag) => { + self.index.put_authorize_typos(self.wtxn, flag)?; + Ok(()) + } + Setting::Reset => { + self.index.put_authorize_typos(self.wtxn, true)?; + Ok(()) + } + Setting::NotSet => Ok(()), + } + } + pub fn execute(mut self, progress_callback: F) -> Result<()> where F: Fn(UpdateIndexingStep) + Sync, @@ -465,6 +489,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { self.update_distinct_field()?; self.update_criteria()?; self.update_primary_key()?; + self.update_authorize_typos()?; // If there is new faceted fields we indicate that we must reindex as we must // index new fields as facets. It means that the distinct attribute,