Method remove_document

nodedb/src/engine/sparse/inverted/indexing.rs:164–247

Remove a document from the inverted index.

(
        &self,
        tid: TenantId,
        collection: &str,
        surrogate: Surrogate,
    )

    /// Remove a document from the inverted index.
    pub fn remove_document(
        &self,
        tid: TenantId,
        collection: &str,
        surrogate: Surrogate,
    ) -> crate::Result<()> {
        let t = tid.as_u64();

        let db = self.inner.backend().db();
        let write_txn = db.begin_write().map_err(|e| inverted_err("write txn", e))?;
        {
            let mut postings_table = write_txn
                .open_table(POSTINGS)
                .map_err(|e| inverted_err("open postings", e))?;

            let terms: Vec<String> = postings_table
                .range((t, collection, "")..=(t, collection, "\u{10ffff}"))
                .map_err(|e| inverted_err("range", e))?
                .filter_map(|r| r.ok().map(|(k, _)| k.value().2.to_string()))
                .collect();

            let mut updates: Vec<(String, Option<Vec<u8>>)> = Vec::new();
            for term in &terms {
                if let Ok(Some(val)) = postings_table.get((t, collection, term.as_str())) {
                    let mut list: Vec<Posting> =
                        zerompk::from_msgpack(val.value()).unwrap_or_default();
                    let before = list.len();
                    list.retain(|p| p.doc_id != surrogate);
                    if list.len() != before {
                        if list.is_empty() {
                            updates.push((term.clone(), None));
                        } else {
                            let bytes = zerompk::to_msgpack_vec(&list).unwrap_or_default();
                            updates.push((term.clone(), Some(bytes)));
                        }
                    }
                }
            }

            for (term, new_val) in &updates {
                match new_val {
                    None => {
                        postings_table
                            .remove((t, collection, term.as_str()))
                            .map_err(|e| inverted_err("remove posting", e))?;
                    }
                    Some(bytes) => {
                        postings_table
                            .insert((t, collection, term.as_str()), bytes.as_slice())
                            .map_err(|e| inverted_err("update posting", e))?;
                    }
                }
            }

            let mut lengths = write_txn
                .open_table(DOC_LENGTHS)
                .map_err(|e| inverted_err("open doc_lengths", e))?;