Introduce the criteria update setting

src/criterion.rs

@@ -1,5 +1,7 @@
-use crate::FieldId;
+use crate::{FieldsIdsMap, FieldId};
 
+use anyhow::{Context, bail};
+use regex::Regex;
 use serde::{Serialize, Deserialize};
 
 #[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq, Eq)]
@@ -24,6 +26,38 @@ pub enum Criterion {
     Desc(FieldId),
 }
 
+impl Criterion {
+    pub fn from_str(fields_ids_map: &mut FieldsIdsMap, txt: &str) -> anyhow::Result<Criterion> {
+        match txt {
+            "typo" => Ok(Criterion::Typo),
+            "words" => Ok(Criterion::Words),
+            "proximity" => Ok(Criterion::Proximity),
+            "attribute" => Ok(Criterion::Attribute),
+            "wordsposition" => Ok(Criterion::WordsPosition),
+            "exactness" => Ok(Criterion::Exactness),
+            text => {
+                let re = Regex::new(r#"(asc|desc)\(([\w_-]+)\)"#)?;
+                let caps = re.captures(text).with_context(|| format!("unknown criterion name: {}", text))?;
+                let order = caps.get(1).unwrap().as_str();
+                let field_name = caps.get(2).unwrap().as_str();
+                let field_id = fields_ids_map.insert(field_name).context("field id limit reached")?;
+                match order {
+                    "asc" => Ok(Criterion::Asc(field_id)),
+                    "desc" => Ok(Criterion::Desc(field_id)),
+                    otherwise => bail!("unknown criterion name: {}", otherwise),
+                }
+            },
+        }
+    }
+
+    pub fn field_id(&self) -> Option<FieldId> {
+        match *self {
+            Criterion::Asc(fid) | Criterion::Desc(fid) => Some(fid),
+            _ => None,
+        }
+    }
+}
+
 pub fn default_criteria() -> Vec<Criterion> {
     vec![
         Criterion::Typo,

src/update/settings.rs

@@ -8,7 +8,7 @@ use rayon::ThreadPool;
 use crate::update::index_documents::{Transform, IndexDocumentsMethod};
 use crate::update::{ClearDocuments, IndexDocuments, UpdateIndexingStep};
 use crate::facet::FacetType;
-use crate::{Index, FieldsIdsMap};
+use crate::{Index, FieldsIdsMap, Criterion};
 
 pub struct Settings<'a, 't, 'u, 'i> {
     wtxn: &'t mut heed::RwTxn<'i, 'u>,
@@ -27,6 +27,7 @@ pub struct Settings<'a, 't, 'u, 'i> {
     searchable_fields: Option<Option<Vec<String>>>,
     displayed_fields: Option<Option<Vec<String>>>,
     faceted_fields: Option<HashMap<String, String>>,
+    criteria: Option<Option<Vec<String>>>,
 }
 
 impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
@@ -45,6 +46,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
             searchable_fields: None,
             displayed_fields: None,
             faceted_fields: None,
+            criteria: None,
         }
     }
 
@@ -68,6 +70,14 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
         self.faceted_fields = Some(names_facet_types);
     }
 
+    pub fn reset_criteria(&mut self) {
+        self.criteria = Some(None);
+    }
+
+    pub fn set_criteria(&mut self, criteria: Vec<String>) {
+        self.criteria = Some(Some(criteria));
+    }
+
     pub fn execute<F>(self, progress_callback: F) -> anyhow::Result<()>
     where
         F: Fn(UpdateIndexingStep) + Sync
@@ -75,6 +85,7 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
         let mut updated_searchable_fields = None;
         let mut updated_faceted_fields = None;
         let mut updated_displayed_fields = None;
+        let mut updated_criteria = None;
 
         // Construct the new FieldsIdsMap based on the searchable fields order.
         let fields_ids_map = self.index.fields_ids_map(self.wtxn)?;
@@ -113,9 +124,8 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
             None => fields_ids_map.insert("id").context("field id limit reached")?,
         };
 
+        let current_faceted_fields = self.index.faceted_fields(self.wtxn)?;
         if let Some(fields_names_facet_types) = self.faceted_fields {
-            let current_faceted_fields = self.index.faceted_fields(self.wtxn)?;
-
             let mut faceted_fields = HashMap::new();
             for (name, sftype) in fields_names_facet_types {
                 let ftype = FacetType::from_str(&sftype).with_context(|| format!("parsing facet type {:?}", sftype))?;
@@ -147,6 +157,25 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
             }
         }
 
+        if let Some(criteria) = self.criteria {
+            match criteria {
+                Some(criteria_names) => {
+                    let mut new_criteria = Vec::new();
+                    for name in criteria_names {
+                        let criterion = Criterion::from_str(&mut fields_ids_map, &name)?;
+                        if let Some(fid) = criterion.field_id() {
+                            let name = fields_ids_map.name(fid).unwrap();
+                            let faceted_fields = updated_faceted_fields.as_ref().unwrap_or(&current_faceted_fields);
+                            ensure!(faceted_fields.contains_key(&fid), "criterion field {} must be faceted", name);
+                        }
+                        new_criteria.push(criterion);
+                    }
+                    updated_criteria = Some(Some(new_criteria));
+                },
+                None => updated_criteria = Some(None),
+            }
+        }
+
         // If any setting have modified any of the datastructures it means that we need
         // to retrieve the documents and then reindex then with the new settings.
         if updated_searchable_fields.is_some() || updated_faceted_fields.is_some() {
@@ -202,14 +231,19 @@ impl<'a, 't, 'u, 'i> Settings<'a, 't, 'u, 'i> {
         }
 
         if let Some(displayed_fields) = updated_displayed_fields {
-            // We write the displayed fields into the database here
-            // to make sure that the right fields are displayed.
             match displayed_fields {
                 Some(fields) => self.index.put_displayed_fields(self.wtxn, &fields)?,
                 None => self.index.delete_displayed_fields(self.wtxn).map(drop)?,
             }
         }
 
+        if let Some(criteria) = updated_criteria {
+            match criteria {
+                Some(criteria) => self.index.put_criteria(self.wtxn, &criteria)?,
+                None => self.index.delete_criteria(self.wtxn).map(drop)?,
+            }
+        }
+
         Ok(())
     }
 }