restructure project

meilisearch-http/src/index/mod.rs

@@ -0,0 +1,126 @@
+mod search;
+mod updates;
+
+use std::sync::Arc;
+use std::ops::Deref;
+
+use anyhow::{bail, Context};
+use serde_json::{Value, Map};
+use milli::obkv_to_json;
+
+pub use search::{SearchQuery, SearchResult, DEFAULT_SEARCH_LIMIT};
+pub use updates::{Settings, Facets, UpdateResult};
+
+pub type Document = Map<String, Value>;
+
+#[derive(Clone)]
+pub struct Index(pub Arc<milli::Index>);
+
+impl Deref for Index {
+    type Target = milli::Index;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref()
+    }
+}
+
+impl Index {
+    pub fn settings(&self) -> anyhow::Result<Settings> {
+        let txn = self.read_txn()?;
+
+        let displayed_attributes = self
+            .displayed_fields(&txn)?
+            .map(|fields| fields.into_iter().map(String::from).collect())
+            .unwrap_or_else(|| vec!["*".to_string()]);
+
+        let searchable_attributes = self
+            .searchable_fields(&txn)?
+            .map(|fields| fields.into_iter().map(String::from).collect())
+            .unwrap_or_else(|| vec!["*".to_string()]);
+
+        let faceted_attributes = self
+            .faceted_fields(&txn)?
+            .into_iter()
+            .map(|(k, v)| (k, v.to_string()))
+            .collect();
+
+        Ok(Settings {
+            displayed_attributes: Some(Some(displayed_attributes)),
+            searchable_attributes: Some(Some(searchable_attributes)),
+            faceted_attributes: Some(Some(faceted_attributes)),
+            criteria: None,
+        })
+    }
+
+    pub fn retrieve_documents<S>(
+        &self,
+        offset: usize,
+        limit: usize,
+        attributes_to_retrieve: Option<Vec<S>>,
+    ) -> anyhow::Result<Vec<Map<String, Value>>>
+    where
+        S: AsRef<str> + Send + Sync + 'static,
+    {
+        let txn = self.read_txn()?;
+
+        let fields_ids_map = self.fields_ids_map(&txn)?;
+
+        let attributes_to_retrieve_ids = match attributes_to_retrieve {
+            Some(attrs) => attrs
+                .iter()
+                .filter_map(|f| fields_ids_map.id(f.as_ref()))
+                .collect::<Vec<_>>(),
+            None => fields_ids_map.iter().map(|(id, _)| id).collect(),
+        };
+
+        let iter = self.documents.range(&txn, &(..))?.skip(offset).take(limit);
+
+        let mut documents = Vec::new();
+
+        for entry in iter {
+            let (_id, obkv) = entry?;
+            let object = obkv_to_json(&attributes_to_retrieve_ids, &fields_ids_map, obkv)?;
+            documents.push(object);
+        }
+
+        Ok(documents)
+    }
+
+    pub fn retrieve_document<S: AsRef<str>>(
+        &self,
+        doc_id: String,
+        attributes_to_retrieve: Option<Vec<S>>,
+    ) -> anyhow::Result<Map<String, Value>> {
+            let txn = self.read_txn()?;
+
+            let fields_ids_map = self.fields_ids_map(&txn)?;
+
+            let attributes_to_retrieve_ids = match attributes_to_retrieve {
+                Some(attrs) => attrs
+                    .iter()
+                    .filter_map(|f| fields_ids_map.id(f.as_ref()))
+                    .collect::<Vec<_>>(),
+                None => fields_ids_map.iter().map(|(id, _)| id).collect(),
+            };
+
+            let internal_id = self
+                .external_documents_ids(&txn)?
+                .get(doc_id.as_bytes())
+                .with_context(|| format!("Document with id {} not found", doc_id))?;
+
+            let document = self
+                .documents(&txn, std::iter::once(internal_id))?
+                .into_iter()
+                .next()
+                .map(|(_, d)| d);
+
+            match document {
+                Some(document) => Ok(obkv_to_json(
+                    &attributes_to_retrieve_ids,
+                    &fields_ids_map,
+                    document,
+                )?),
+                None => bail!("Document with id {} not found", doc_id),
+            }
+    }
+}

meilisearch-http/src/index/search.rs

@@ -0,0 +1,245 @@
+use std::time::Instant;
+use std::collections::{HashSet, BTreeMap};
+use std::mem;
+
+use either::Either;
+use anyhow::bail;
+use heed::RoTxn;
+use meilisearch_tokenizer::{Analyzer, AnalyzerConfig};
+use milli::{FacetCondition, facet::FacetValue};
+use serde::{Serialize, Deserialize};
+use serde_json::{Value, Map};
+
+use super::Index;
+
+pub const DEFAULT_SEARCH_LIMIT: usize = 20;
+
+const fn default_search_limit() -> usize {
+    DEFAULT_SEARCH_LIMIT
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+#[allow(dead_code)]
+pub struct SearchQuery {
+    pub q: Option<String>,
+    pub offset: Option<usize>,
+    #[serde(default = "default_search_limit")]
+    pub limit: usize,
+    pub attributes_to_retrieve: Option<Vec<String>>,
+    pub attributes_to_crop: Option<Vec<String>>,
+    pub crop_length: Option<usize>,
+    pub attributes_to_highlight: Option<HashSet<String>>,
+    pub filters: Option<String>,
+    pub matches: Option<bool>,
+    pub facet_filters: Option<Value>,
+    pub facet_distributions: Option<Vec<String>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchResult {
+    pub hits: Vec<Map<String, Value>>,
+    pub nb_hits: u64,
+    pub query: String,
+    pub limit: usize,
+    pub offset: usize,
+    pub processing_time_ms: u128,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub facet_distributions: Option<BTreeMap<String, BTreeMap<FacetValue, u64>>>,
+}
+
+impl Index {
+    pub fn perform_search(&self, query: SearchQuery) -> anyhow::Result<SearchResult> {
+        let before_search = Instant::now();
+        let rtxn = self.read_txn()?;
+
+        let mut search = self.search(&rtxn);
+
+        if let Some(ref query) = query.q {
+            search.query(query);
+        }
+
+        search.limit(query.limit);
+        search.offset(query.offset.unwrap_or_default());
+
+        if let Some(ref facets) = query.facet_filters {
+            if let Some(facets) = parse_facets(facets, self, &rtxn)? {
+                search.facet_condition(facets);
+            }
+        }
+
+        let milli::SearchResult {
+            documents_ids,
+            found_words,
+            candidates,
+            ..
+        } = search.execute()?;
+        let mut documents = Vec::new();
+        let fields_ids_map = self.fields_ids_map(&rtxn).unwrap();
+
+        let displayed_fields_ids = self.displayed_fields_ids(&rtxn).unwrap();
+
+        let attributes_to_retrieve_ids = match query.attributes_to_retrieve {
+            Some(ref attrs) if attrs.iter().any(|f| f == "*") => None,
+            Some(ref attrs) => attrs
+                .iter()
+                .filter_map(|f| fields_ids_map.id(f))
+                .collect::<Vec<_>>()
+                .into(),
+            None => None,
+        };
+
+        let displayed_fields_ids = match (displayed_fields_ids, attributes_to_retrieve_ids) {
+            (_, Some(ids)) => ids,
+            (Some(ids), None) => ids,
+            (None, None) => fields_ids_map.iter().map(|(id, _)| id).collect(),
+        };
+
+        let stop_words = fst::Set::default();
+        let highlighter = Highlighter::new(&stop_words);
+
+        for (_id, obkv) in self.documents(&rtxn, documents_ids)? {
+            let mut object = milli::obkv_to_json(&displayed_fields_ids, &fields_ids_map, obkv).unwrap();
+            if let Some(ref attributes_to_highlight) = query.attributes_to_highlight {
+                highlighter.highlight_record(&mut object, &found_words, attributes_to_highlight);
+            }
+            documents.push(object);
+        }
+
+        let nb_hits = candidates.len();
+
+        let facet_distributions = match query.facet_distributions {
+            Some(ref fields) => {
+                let mut facet_distribution = self.facets_distribution(&rtxn);
+                if fields.iter().all(|f| f != "*") {
+                    facet_distribution.facets(fields);
+                }
+                Some(facet_distribution.candidates(candidates).execute()?)
+            }
+            None => None,
+        };
+
+        let result = SearchResult {
+            hits: documents,
+            nb_hits,
+            query: query.q.clone().unwrap_or_default(),
+            limit: query.limit,
+            offset: query.offset.unwrap_or_default(),
+            processing_time_ms: before_search.elapsed().as_millis(),
+            facet_distributions,
+        };
+        Ok(result)
+    }
+}
+
+fn parse_facets_array(
+    txn: &RoTxn,
+    index: &Index,
+    arr: &Vec<Value>,
+) -> anyhow::Result<Option<FacetCondition>> {
+    let mut ands = Vec::new();
+    for value in arr {
+        match value {
+            Value::String(s) => ands.push(Either::Right(s.clone())),
+            Value::Array(arr) => {
+                let mut ors = Vec::new();
+                for value in arr {
+                    match value {
+                        Value::String(s) => ors.push(s.clone()),
+                        v => bail!("Invalid facet expression, expected String, found: {:?}", v),
+                    }
+                }
+                ands.push(Either::Left(ors));
+            }
+            v => bail!(
+                "Invalid facet expression, expected String or [String], found: {:?}",
+                v
+            ),
+        }
+    }
+
+    FacetCondition::from_array(txn, &index.0, ands)
+}
+
+pub struct Highlighter<'a, A> {
+    analyzer: Analyzer<'a, A>,
+}
+
+impl<'a, A: AsRef<[u8]>> Highlighter<'a, A> {
+    pub fn new(stop_words: &'a fst::Set<A>) -> Self {
+        let analyzer = Analyzer::new(AnalyzerConfig::default_with_stopwords(stop_words));
+
+        Self { analyzer }
+    }
+
+    pub fn highlight_value(&self, value: Value, words_to_highlight: &HashSet<String>) -> Value {
+        match value {
+            Value::Null => Value::Null,
+            Value::Bool(boolean) => Value::Bool(boolean),
+            Value::Number(number) => Value::Number(number),
+            Value::String(old_string) => {
+                let mut string = String::new();
+                let analyzed = self.analyzer.analyze(&old_string);
+                for (word, token) in analyzed.reconstruct() {
+                    if token.is_word() {
+                        let to_highlight = words_to_highlight.contains(token.text());
+                        if to_highlight {
+                            string.push_str("<mark>")
+                        }
+                        string.push_str(word);
+                        if to_highlight {
+                            string.push_str("</mark>")
+                        }
+                    } else {
+                        string.push_str(word);
+                    }
+                }
+                Value::String(string)
+            }
+            Value::Array(values) => Value::Array(
+                values
+                .into_iter()
+                .map(|v| self.highlight_value(v, words_to_highlight))
+                .collect(),
+            ),
+            Value::Object(object) => Value::Object(
+                object
+                .into_iter()
+                .map(|(k, v)| (k, self.highlight_value(v, words_to_highlight)))
+                .collect(),
+            ),
+        }
+    }
+
+    pub fn highlight_record(
+        &self,
+        object: &mut Map<String, Value>,
+        words_to_highlight: &HashSet<String>,
+        attributes_to_highlight: &HashSet<String>,
+    ) {
+        // TODO do we need to create a string for element that are not and needs to be highlight?
+        for (key, value) in object.iter_mut() {
+            if attributes_to_highlight.contains(key) {
+                let old_value = mem::take(value);
+                *value = self.highlight_value(old_value, words_to_highlight);
+            }
+        }
+    }
+}
+
+fn parse_facets(
+    facets: &Value,
+    index: &Index,
+    txn: &RoTxn,
+) -> anyhow::Result<Option<FacetCondition>> {
+    match facets {
+        // Disabled for now
+        //Value::String(expr) => Ok(Some(FacetCondition::from_str(txn, index, expr)?)),
+        Value::Array(arr) => parse_facets_array(txn, index, arr),
+        v => bail!(
+            "Invalid facet expression, expected Array, found: {:?}",
+            v
+        ),
+    }
+}

meilisearch-http/src/index/updates.rs

@@ -0,0 +1,229 @@
+use std::collections::HashMap;
+use std::io;
+use std::num::NonZeroUsize;
+
+use flate2::read::GzDecoder;
+use log::info;
+use milli::update::{UpdateFormat, IndexDocumentsMethod, UpdateBuilder, DocumentAdditionResult};
+use serde::{Serialize, Deserialize, de::Deserializer};
+
+use super::Index;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UpdateResult {
+    DocumentsAddition(DocumentAdditionResult),
+    DocumentDeletion { deleted: usize },
+    Other,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+pub struct Settings {
+    #[serde(
+        default,
+        deserialize_with = "deserialize_some",
+        skip_serializing_if = "Option::is_none",
+    )]
+    pub displayed_attributes: Option<Option<Vec<String>>>,
+
+    #[serde(
+        default,
+        deserialize_with = "deserialize_some",
+        skip_serializing_if = "Option::is_none",
+    )]
+    pub searchable_attributes: Option<Option<Vec<String>>>,
+
+    #[serde(default)]
+    pub faceted_attributes: Option<Option<HashMap<String, String>>>,
+
+    #[serde(
+        default,
+        deserialize_with = "deserialize_some",
+        skip_serializing_if = "Option::is_none",
+    )]
+    pub criteria: Option<Option<Vec<String>>>,
+}
+
+impl Settings {
+    pub fn cleared() -> Self {
+        Self {
+            displayed_attributes: Some(None),
+            searchable_attributes: Some(None),
+            faceted_attributes: Some(None),
+            criteria: Some(None),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+pub struct Facets {
+    pub level_group_size: Option<NonZeroUsize>,
+    pub min_level_size: Option<NonZeroUsize>,
+}
+
+fn deserialize_some<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
+where T: Deserialize<'de>,
+      D: Deserializer<'de>
+{
+    Deserialize::deserialize(deserializer).map(Some)
+}
+
+impl Index {
+    pub fn update_documents(
+        &self,
+        format: UpdateFormat,
+        method: IndexDocumentsMethod,
+        content: impl io::Read,
+        update_builder: UpdateBuilder,
+        primary_key: Option<&str>,
+    ) -> anyhow::Result<UpdateResult> {
+        info!("performing document addition");
+        // We must use the write transaction of the update here.
+        let mut wtxn = self.write_txn()?;
+
+        // Set the primary key if not set already, ignore if already set.
+        match (self.primary_key(&wtxn)?, primary_key) {
+            (None, Some(ref primary_key)) => {
+                self.put_primary_key(&mut wtxn, primary_key)?;
+            }
+            _ => (),
+        }
+
+        let mut builder = update_builder.index_documents(&mut wtxn, self);
+        builder.update_format(format);
+        builder.index_documents_method(method);
+
+        let gzipped = false;
+        let reader = if gzipped {
+            Box::new(GzDecoder::new(content))
+        } else {
+            Box::new(content) as Box<dyn io::Read>
+        };
+
+        let result = builder.execute(reader, |indexing_step, update_id| {
+            info!("update {}: {:?}", update_id, indexing_step)
+        });
+
+        info!("document addition done: {:?}", result);
+
+        match result {
+            Ok(addition_result) => wtxn
+                .commit()
+                .and(Ok(UpdateResult::DocumentsAddition(addition_result)))
+                .map_err(Into::into),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn clear_documents(&self, update_builder: UpdateBuilder) -> anyhow::Result<UpdateResult> {
+        // We must use the write transaction of the update here.
+        let mut wtxn = self.write_txn()?;
+        let builder = update_builder.clear_documents(&mut wtxn, self);
+
+        match builder.execute() {
+            Ok(_count) => wtxn
+                .commit()
+                .and(Ok(UpdateResult::Other))
+                .map_err(Into::into),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn update_settings(
+        &self,
+        settings: &Settings,
+        update_builder: UpdateBuilder,
+    ) -> anyhow::Result<UpdateResult> {
+        // We must use the write transaction of the update here.
+        let mut wtxn = self.write_txn()?;
+        let mut builder = update_builder.settings(&mut wtxn, self);
+
+        // We transpose the settings JSON struct into a real setting update.
+        if let Some(ref names) = settings.searchable_attributes {
+            match names {
+                Some(names) => builder.set_searchable_fields(names.clone()),
+                None => builder.reset_searchable_fields(),
+            }
+        }
+
+        // We transpose the settings JSON struct into a real setting update.
+        if let Some(ref names) = settings.displayed_attributes {
+            match names {
+                Some(names) => builder.set_displayed_fields(names.clone()),
+                None => builder.reset_displayed_fields(),
+            }
+        }
+
+        // We transpose the settings JSON struct into a real setting update.
+        if let Some(ref facet_types) = settings.faceted_attributes {
+            let facet_types = facet_types.clone().unwrap_or_else(|| HashMap::new());
+            builder.set_faceted_fields(facet_types);
+        }
+
+        // We transpose the settings JSON struct into a real setting update.
+        if let Some(ref criteria) = settings.criteria {
+            match criteria {
+                Some(criteria) => builder.set_criteria(criteria.clone()),
+                None => builder.reset_criteria(),
+            }
+        }
+
+        let result = builder
+            .execute(|indexing_step, update_id| info!("update {}: {:?}", update_id, indexing_step));
+
+        match result {
+            Ok(()) => wtxn
+                .commit()
+                .and(Ok(UpdateResult::Other))
+                .map_err(Into::into),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn update_facets(
+        &self,
+        levels: &Facets,
+        update_builder: UpdateBuilder,
+    ) -> anyhow::Result<UpdateResult> {
+        // We must use the write transaction of the update here.
+        let mut wtxn = self.write_txn()?;
+        let mut builder = update_builder.facets(&mut wtxn, self);
+        if let Some(value) = levels.level_group_size {
+            builder.level_group_size(value);
+        }
+        if let Some(value) = levels.min_level_size {
+            builder.min_level_size(value);
+        }
+        match builder.execute() {
+            Ok(()) => wtxn
+                .commit()
+                .and(Ok(UpdateResult::Other))
+                .map_err(Into::into),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn delete_documents(
+        &self,
+        document_ids: impl io::Read,
+        update_builder: UpdateBuilder,
+    ) -> anyhow::Result<UpdateResult> {
+        let ids: Vec<String> = serde_json::from_reader(document_ids)?;
+        let mut txn = self.write_txn()?;
+        let mut builder = update_builder.delete_documents(&mut txn, self)?;
+
+        // We ignore unexisting document ids
+        ids.iter().for_each(|id| { builder.delete_external_id(id); });
+
+        match builder.execute() {
+            Ok(deleted) => txn
+                .commit()
+                .and(Ok(UpdateResult::DocumentDeletion { deleted }))
+                .map_err(Into::into),
+            Err(e) => Err(e.into())
+        }
+    }
+}