From 66020cd9239c98658ba7824a632d8c1df944edd5 Mon Sep 17 00:00:00 2001 From: ad hoc Date: Thu, 31 Mar 2022 18:23:12 +0200 Subject: [PATCH] rename min_word_len* to use plain letter numbers --- milli/src/index.rs | 30 ++++++++++---------- milli/src/search/query_tree.rs | 23 ++++++++-------- milli/src/update/settings.rs | 50 +++++++++++++++++----------------- 3 files changed, 52 insertions(+), 51 deletions(-) diff --git a/milli/src/index.rs b/milli/src/index.rs index 98f0093b8..853e7537d 100644 --- a/milli/src/index.rs +++ b/milli/src/index.rs @@ -23,8 +23,8 @@ use crate::{ Search, StrBEU32Codec, StrStrU8Codec, BEU32, }; -pub const DEFAULT_MIN_WORD_LEN_1_TYPO: u8 = 5; -pub const DEFAULT_MIN_WORD_LEN_2_TYPOS: u8 = 9; +pub const DEFAULT_MIN_WORD_LEN_ONE_TYPO: u8 = 5; +pub const DEFAULT_MIN_WORD_LEN_TWO_TYPOS: u8 = 9; pub mod main_key { pub const CRITERIA_KEY: &str = "criteria"; @@ -892,17 +892,17 @@ impl Index { Ok(()) } - pub fn min_word_len_1_typo(&self, txn: &RoTxn) -> heed::Result { + pub fn min_word_len_one_typo(&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. Ok(self .main .get::<_, Str, OwnedType>(txn, main_key::ONE_TYPO_WORD_LEN)? - .unwrap_or(DEFAULT_MIN_WORD_LEN_1_TYPO)) + .unwrap_or(DEFAULT_MIN_WORD_LEN_ONE_TYPO)) } - pub(crate) fn put_min_word_len_1_typo(&self, txn: &mut RwTxn, val: u8) -> heed::Result<()> { + pub(crate) fn put_min_word_len_one_typo(&self, txn: &mut RwTxn, val: u8) -> 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. @@ -910,17 +910,17 @@ impl Index { Ok(()) } - pub fn min_word_len_2_typos(&self, txn: &RoTxn) -> heed::Result { + pub fn min_word_len_two_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. Ok(self .main .get::<_, Str, OwnedType>(txn, main_key::TWO_TYPOS_WORD_LEN)? - .unwrap_or(DEFAULT_MIN_WORD_LEN_2_TYPOS)) + .unwrap_or(DEFAULT_MIN_WORD_LEN_TWO_TYPOS)) } - pub(crate) fn put_min_word_len_2_typos(&self, txn: &mut RwTxn, val: u8) -> heed::Result<()> { + pub(crate) fn put_min_word_len_two_typos(&self, txn: &mut RwTxn, val: u8) -> 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. @@ -937,7 +937,7 @@ pub(crate) mod tests { use maplit::btreemap; use tempfile::TempDir; - use crate::index::{DEFAULT_MIN_WORD_LEN_1_TYPO, DEFAULT_MIN_WORD_LEN_2_TYPOS}; + use crate::index::{DEFAULT_MIN_WORD_LEN_ONE_TYPO, DEFAULT_MIN_WORD_LEN_TWO_TYPOS}; use crate::update::{IndexDocuments, IndexDocumentsConfig, IndexerConfig}; use crate::Index; @@ -1071,16 +1071,16 @@ pub(crate) mod tests { let index = TempIndex::new(); let mut txn = index.write_txn().unwrap(); - assert_eq!(index.min_word_len_1_typo(&txn).unwrap(), DEFAULT_MIN_WORD_LEN_1_TYPO); - assert_eq!(index.min_word_len_2_typos(&txn).unwrap(), DEFAULT_MIN_WORD_LEN_2_TYPOS); + assert_eq!(index.min_word_len_one_typo(&txn).unwrap(), DEFAULT_MIN_WORD_LEN_ONE_TYPO); + assert_eq!(index.min_word_len_two_typos(&txn).unwrap(), DEFAULT_MIN_WORD_LEN_TWO_TYPOS); - index.put_min_word_len_1_typo(&mut txn, 3).unwrap(); - index.put_min_word_len_2_typos(&mut txn, 15).unwrap(); + index.put_min_word_len_one_typo(&mut txn, 3).unwrap(); + index.put_min_word_len_two_typos(&mut txn, 15).unwrap(); txn.commit().unwrap(); let txn = index.read_txn().unwrap(); - assert_eq!(index.min_word_len_1_typo(&txn).unwrap(), 3); - assert_eq!(index.min_word_len_2_typos(&txn).unwrap(), 15); + assert_eq!(index.min_word_len_one_typo(&txn).unwrap(), 3); + assert_eq!(index.min_word_len_two_typos(&txn).unwrap(), 15); } } diff --git a/milli/src/search/query_tree.rs b/milli/src/search/query_tree.rs index 5d78eb674..c1803f40b 100644 --- a/milli/src/search/query_tree.rs +++ b/milli/src/search/query_tree.rs @@ -182,8 +182,8 @@ impl<'a> Context for QueryTreeBuilder<'a> { } fn min_word_len_for_typo(&self) -> heed::Result<(u8, u8)> { - let one = self.index.min_word_len_1_typo(&self.rtxn)?; - let two = self.index.min_word_len_2_typos(&self.rtxn)?; + let one = self.index.min_word_len_one_typo(&self.rtxn)?; + let two = self.index.min_word_len_two_typos(&self.rtxn)?; Ok((one, two)) } } @@ -267,8 +267,8 @@ fn split_best_frequency(ctx: &impl Context, word: &str) -> heed::Result QueryKind { if authorize_typos { let count = word.chars().count().min(u8::MAX as usize) as u8; - if (0..config.word_len_1_typo).contains(&count) { + if (0..config.word_len_one_typo).contains(&count) { QueryKind::exact(word) - } else if (config.word_len_1_typo..config.word_len_2_typo).contains(&count) { + } else if (config.word_len_one_typo..config.word_len_two_typo).contains(&count) { QueryKind::tolerant(1.min(config.max_typos), word) } else { QueryKind::tolerant(2.min(config.max_typos), word) @@ -332,8 +332,8 @@ fn create_query_tree( if let Some(child) = split_best_frequency(ctx, &word)? { children.push(child); } - let (word_len_1_typo, word_len_2_typo) = ctx.min_word_len_for_typo()?; - let config = TypoConfig { max_typos: 2, word_len_1_typo, word_len_2_typo }; + let (word_len_one_typo, word_len_two_typo) = ctx.min_word_len_for_typo()?; + let config = TypoConfig { max_typos: 2, word_len_one_typo, word_len_two_typo }; children.push(Operation::Query(Query { prefix, kind: typos(word, authorize_typos, config), @@ -383,9 +383,10 @@ fn create_query_tree( .collect(); let mut operations = synonyms(ctx, &words)?.unwrap_or_default(); let concat = words.concat(); - let (word_len_1_typo, word_len_2_typo) = ctx.min_word_len_for_typo()?; + let (word_len_one_typo, word_len_two_typo) = + ctx.min_word_len_for_typo()?; let config = - TypoConfig { max_typos: 1, word_len_1_typo, word_len_2_typo }; + TypoConfig { max_typos: 1, word_len_one_typo, word_len_two_typo }; let query = Query { prefix: is_prefix, kind: typos(concat, authorize_typos, config), @@ -1223,7 +1224,7 @@ mod test { #[test] fn test_min_word_len_typo() { - let config = TypoConfig { max_typos: 2, word_len_1_typo: 5, word_len_2_typo: 7 }; + let config = TypoConfig { max_typos: 2, word_len_one_typo: 5, word_len_two_typo: 7 }; assert_eq!( typos("hello".to_string(), true, config.clone()), diff --git a/milli/src/update/settings.rs b/milli/src/update/settings.rs index 26ed5730a..94ae29595 100644 --- a/milli/src/update/settings.rs +++ b/milli/src/update/settings.rs @@ -90,8 +90,8 @@ pub struct Settings<'a, 't, 'u, 'i> { synonyms: Setting>>, primary_key: Setting, authorize_typos: Setting, - min_2_typos_word_len: Setting, - min_1_typo_word_len: Setting, + min_word_len_two_typos: Setting, + min_word_len_one_typo: Setting, } impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { @@ -114,8 +114,8 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { primary_key: Setting::NotSet, authorize_typos: Setting::NotSet, indexer_config, - min_2_typos_word_len: Setting::Reset, - min_1_typo_word_len: Setting::Reset, + min_word_len_two_typos: Setting::Reset, + min_word_len_one_typo: Setting::Reset, } } @@ -200,20 +200,20 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { self.authorize_typos = Setting::Reset; } - pub fn set_min_2_typos_word_len(&mut self, val: u8) { - self.min_2_typos_word_len = Setting::Set(val); + pub fn set_min_word_len_two_typos(&mut self, val: u8) { + self.min_word_len_two_typos = Setting::Set(val); } - pub fn reset_min_2_typos_word_len(&mut self) { - self.min_2_typos_word_len = Setting::Reset; + pub fn reset_min_word_len_two_typos(&mut self) { + self.min_word_len_two_typos = Setting::Reset; } - pub fn set_min_1_typo_word_len(&mut self, val: u8) { - self.min_1_typo_word_len = Setting::Set(val); + pub fn set_min_word_len_one_typo(&mut self, val: u8) { + self.min_word_len_one_typo = Setting::Set(val); } - pub fn reset_min_1_typos_word_len(&mut self) { - self.min_1_typo_word_len = Setting::Reset; + pub fn reset_min_word_len_one_typo(&mut self) { + self.min_word_len_one_typo = Setting::Reset; } fn reindex(&mut self, cb: &F, old_fields_ids_map: FieldsIdsMap) -> Result<()> @@ -495,29 +495,29 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> { } fn update_min_typo_word_len(&mut self) -> Result<()> { - match (&self.min_1_typo_word_len, &self.min_2_typos_word_len) { + match (&self.min_word_len_one_typo, &self.min_word_len_two_typos) { (Setting::Set(one), Setting::Set(two)) => { if one > two { return Err(UserError::InvalidMinTypoWordLenSetting(*one, *two).into()); } else { - self.index.put_min_word_len_1_typo(&mut self.wtxn, *one)?; - self.index.put_min_word_len_2_typos(&mut self.wtxn, *two)?; + self.index.put_min_word_len_one_typo(&mut self.wtxn, *one)?; + self.index.put_min_word_len_two_typos(&mut self.wtxn, *two)?; } } (Setting::Set(one), _) => { - let two = self.index.min_word_len_2_typos(&self.wtxn)?; + let two = self.index.min_word_len_two_typos(&self.wtxn)?; if *one > two { return Err(UserError::InvalidMinTypoWordLenSetting(*one, two).into()); } else { - self.index.put_min_word_len_1_typo(&mut self.wtxn, *one)?; + self.index.put_min_word_len_one_typo(&mut self.wtxn, *one)?; } } (_, Setting::Set(two)) => { - let one = self.index.min_word_len_1_typo(&self.wtxn)?; + let one = self.index.min_word_len_one_typo(&self.wtxn)?; if one > *two { return Err(UserError::InvalidMinTypoWordLenSetting(one, *two).into()); } else { - self.index.put_min_word_len_2_typos(&mut self.wtxn, *two)?; + self.index.put_min_word_len_two_typos(&mut self.wtxn, *two)?; } } _ => (), @@ -1295,16 +1295,16 @@ mod tests { // Set the genres setting let mut txn = index.write_txn().unwrap(); let mut builder = Settings::new(&mut txn, &index, &config); - builder.set_min_1_typo_word_len(8); - builder.set_min_2_typos_word_len(8); + builder.set_min_word_len_one_typo(8); + builder.set_min_word_len_two_typos(8); builder.execute(|_| ()).unwrap(); txn.commit().unwrap(); let txn = index.read_txn().unwrap(); - assert_eq!(index.min_word_len_1_typo(&txn).unwrap(), 8); - assert_eq!(index.min_word_len_2_typos(&txn).unwrap(), 8); + assert_eq!(index.min_word_len_one_typo(&txn).unwrap(), 8); + assert_eq!(index.min_word_len_two_typos(&txn).unwrap(), 8); } #[test] @@ -1315,8 +1315,8 @@ mod tests { // Set the genres setting let mut txn = index.write_txn().unwrap(); let mut builder = Settings::new(&mut txn, &index, &config); - builder.set_min_1_typo_word_len(10); - builder.set_min_2_typos_word_len(7); + builder.set_min_word_len_one_typo(10); + builder.set_min_word_len_two_typos(7); assert!(builder.execute(|_| ()).is_err()); } }