nidx-binding 6.10.0.post718__tar.gz → 6.10.0.post719__tar.gz

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.10.0.post718
+Version: 6.10.0.post719
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_paragraph/tests/common/mod.rs

@@ -38,11 +38,11 @@ impl TestOpener {
 }
 
 impl OpenIndexMetadata<TantivyMeta> for TestOpener {
-    fn segments(&self) -> impl Iterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
+    fn segments(&self) -> impl DoubleEndedIterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
         self.segments.iter().cloned()
     }
 
-    fn deletions(&self) -> impl Iterator<Item = (&String, nidx_types::Seq)> {
+    fn deletions(&self) -> impl DoubleEndedIterator<Item = (&String, nidx_types::Seq)> {
         self.deletions.iter().map(|(key, seq)| (key, *seq))
     }
 }

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_protos/noderesources.proto

@@ -165,6 +165,20 @@ message Resource {
     // Boleans to indicate if the indexing needs to be done
     bool skip_texts = 18;
     bool skip_paragraphs = 19;
+
+    repeated RelationNodeVector relation_node_vectors = 20;
+    repeated RelationVector relation_vectors = 21;
+}
+
+message RelationNodeVector {
+    utils.RelationNode node = 1;
+    repeated float vector = 2;
+}
+
+message RelationVector {
+    utils.Relation.RelationType relation_type = 1;
+    string relation_label = 2;
+    repeated float vector = 3;
 }
 
 message ShardMetadata {

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_protos/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.10.0.post718"
+version = "6.10.0.post719"
 license = "AGPL-3.0-or-later"
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [{ name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_relation/tests/common/mod.rs

@@ -38,11 +38,11 @@ impl TestOpener {
 }
 
 impl OpenIndexMetadata<TantivyMeta> for TestOpener {
-    fn segments(&self) -> impl Iterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
+    fn segments(&self) -> impl DoubleEndedIterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
         self.segments.iter().cloned()
     }
 
-    fn deletions(&self) -> impl Iterator<Item = (&String, nidx_types::Seq)> {
+    fn deletions(&self) -> impl DoubleEndedIterator<Item = (&String, nidx_types::Seq)> {
         self.deletions.iter().map(|(key, seq)| (key, *seq))
     }
 }

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_text/tests/common/mod.rs

@@ -42,11 +42,11 @@ impl TestOpener {
 }
 
 impl OpenIndexMetadata<TantivyMeta> for TestOpener {
-    fn segments(&self) -> impl Iterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
+    fn segments(&self) -> impl DoubleEndedIterator<Item = (nidx_types::SegmentMetadata<TantivyMeta>, nidx_types::Seq)> {
         self.segments.iter().cloned()
     }
 
-    fn deletions(&self) -> impl Iterator<Item = (&String, nidx_types::Seq)> {
+    fn deletions(&self) -> impl DoubleEndedIterator<Item = (&String, nidx_types::Seq)> {
         self.deletions.iter().map(|(key, seq)| (key, *seq))
     }
 }

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_types/src/lib.rs

@@ -55,7 +55,7 @@ pub struct SegmentMetadata<T> {
 /// The metadata needed to open an index: a list of segments and deletions.
 pub trait OpenIndexMetadata<T> {
     /// List of segments and Seq
-    fn segments(&self) -> impl Iterator<Item = (SegmentMetadata<T>, Seq)>;
+    fn segments(&self) -> impl DoubleEndedIterator<Item = (SegmentMetadata<T>, Seq)>;
     /// List of deletions and Seq
-    fn deletions(&self) -> impl Iterator<Item = (&String, Seq)>;
+    fn deletions(&self) -> impl DoubleEndedIterator<Item = (&String, Seq)>;
 }

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/config.rs

@@ -95,6 +95,13 @@ pub enum VectorCardinality {
     Multi,
 }
 
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub enum IndexEntity {
+    #[default]
+    Paragraph,
+    Relation,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct VectorConfig {
     #[serde(default)]
@@ -107,10 +114,32 @@ pub struct VectorConfig {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub flags: Vec<String>,
     #[serde(default)]
-    pub disable_indexes: bool,
+    pub entity: IndexEntity,
 }
 
 impl VectorConfig {
+    pub const fn for_paragraphs(vector_type: VectorType) -> Self {
+        Self {
+            vector_type,
+            similarity: Similarity::Dot,
+            normalize_vectors: false,
+            vector_cardinality: VectorCardinality::Single,
+            flags: vec![],
+            entity: IndexEntity::Paragraph,
+        }
+    }
+
+    pub const fn for_relations(vector_type: VectorType) -> Self {
+        Self {
+            vector_type,
+            similarity: Similarity::Dot,
+            normalize_vectors: false,
+            vector_cardinality: VectorCardinality::Single,
+            flags: vec![],
+            entity: IndexEntity::Relation,
+        }
+    }
+
     pub fn similarity_function(&self) -> fn(&[u8], &[u8]) -> f32 {
         match (&self.similarity, &self.vector_type) {
             (Similarity::Dot, VectorType::DenseF32 { .. }) => dense_f32::dot_similarity,
@@ -146,7 +175,7 @@ impl TryFrom<VectorIndexConfig> for VectorConfig {
             vector_type,
             flags: vec![],
             vector_cardinality: VectorCardinality::Single,
-            disable_indexes: false,
+            entity: IndexEntity::Paragraph,
         })
     }
 }

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/data_store/v1/store.rs

@@ -211,16 +211,9 @@ pub fn merge(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{config::VectorCardinality, segment::Elem};
-
-    const VECTOR_CONFIG: VectorConfig = VectorConfig {
-        vector_type: VectorType::DenseF32 { dimension: 3 },
-        similarity: crate::config::Similarity::Dot,
-        normalize_vectors: false,
-        flags: vec![],
-        vector_cardinality: VectorCardinality::Single,
-        disable_indexes: false,
-    };
+    use crate::segment::Elem;
+
+    const VECTOR_CONFIG: VectorConfig = VectorConfig::for_paragraphs(VectorType::DenseF32 { dimension: 3 });
 
     #[test]
     fn store_test() {

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/data_store/v2/paragraph_store.rs

@@ -146,12 +146,13 @@ impl ParagraphStoreWriter {
         paragraph: ParagraphRef,
         first_vector: u32,
         num_vectors: u32,
+        override_metadata: Option<&[u8]>,
     ) -> VectorR<u32> {
         let labels = paragraph.labels();
         let paragraph = StoredParagraph {
             key: paragraph.id(),
             labels: labels.iter().map(|x| x.as_str()).collect(),
-            metadata: paragraph.metadata(),
+            metadata: override_metadata.unwrap_or(paragraph.metadata()),
             first_vector,
             num_vectors,
         };

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/data_store/v2.rs

@@ -29,7 +29,7 @@ use crate::{
 use super::{DataStore, OpenReason, ParagraphAddr, VectorAddr};
 pub use paragraph_store::StoredParagraph;
 use paragraph_store::{ParagraphStore, ParagraphStoreWriter};
-use std::path::Path;
+use std::{collections::HashMap, path::Path};
 use vector_store::{VectorStore, VectorStoreWriter};
 
 mod paragraph_store;
@@ -88,6 +88,7 @@ impl DataStoreV2 {
         path: &Path,
         producers: Vec<(impl Iterator<Item = ParagraphAddr>, &dyn DataStore)>,
         config: &VectorConfig,
+        mut paragraph_deduplicator: Option<HashMap<String, Vec<u8>>>,
     ) -> VectorR<()> {
         let mut paragraphs = ParagraphStoreWriter::new(path)?;
         let mut vectors = VectorStoreWriter::new(path, &config.vector_type)?;
@@ -104,6 +105,17 @@ impl DataStoreV2 {
                 let paragraph = store.get_paragraph(paragraph_addr);
                 let p_vectors = paragraph.vectors(&paragraph_addr).map(|v| store.get_vector(v).vector());
 
+                let metadata = if let Some(paragraph_deduplicator) = &mut paragraph_deduplicator {
+                    // Entry is removed so if it appears in other segments it is not copied again
+                    let metadata = paragraph_deduplicator.remove(paragraph.id());
+                    if metadata.is_none() {
+                        continue;
+                    };
+                    metadata
+                } else {
+                    None
+                };
+
                 // Write to new store
                 let (first_vector, last_vector) = vectors.write(p_idx, p_vectors)?;
                 if let Some(quantized) = &mut quantized {
@@ -120,7 +132,13 @@ impl DataStoreV2 {
                     }
                 }
 
-                paragraphs.write_paragraph_ref(paragraph, first_vector, last_vector - first_vector + 1)?;
+                paragraphs.write_paragraph_ref(
+                    paragraph,
+                    first_vector,
+                    last_vector - first_vector + 1,
+                    metadata.as_deref(),
+                )?;
+
                 p_idx += 1;
             }
         }

nidx_binding-6.10.0.post719/nidx_vector/src/field_list_metadata.rs

@@ -0,0 +1,46 @@
+// Copyright (C) 2021 Bosutech XXI S.L.
+//
+// nucliadb is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at info@nuclia.com.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+use std::collections::HashSet;
+
+use crate::{data_store::ParagraphRef, utils::FieldKey};
+
+pub fn encode_field_list_metadata(encoded_fields: &[FieldKey]) -> Vec<u8> {
+    bincode::encode_to_vec(encoded_fields, bincode::config::standard()).unwrap()
+}
+
+pub fn decode_field_list_metadata(data: &[u8]) -> Vec<FieldKey<'_>> {
+    let (fields, _) = bincode::borrow_decode_from_slice(data, bincode::config::standard()).unwrap();
+    fields
+}
+
+pub fn paragraph_alive_fields<'a>(
+    paragraph: &'a ParagraphRef,
+    keys: &HashSet<FieldKey<'a>>,
+) -> impl Iterator<Item = FieldKey<'a>> {
+    let fields = decode_field_list_metadata(paragraph.metadata());
+    fields
+        .into_iter()
+        .filter(|f| !keys.contains(f) && !keys.contains(&FieldKey::from_bytes(f.resource_id())))
+}
+
+pub fn paragraph_is_deleted(paragraph: &ParagraphRef, keys: &HashSet<FieldKey>) -> bool {
+    paragraph_alive_fields(paragraph, keys).next().is_none()
+}

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/formula.rs

@@ -95,6 +95,9 @@ impl Formula {
     {
         self.clauses.push(clause.into())
     }
+    pub fn non_empty(&self) -> bool {
+        !self.clauses.is_empty()
+    }
 }
 
 impl Default for Formula {

{nidx_binding-6.10.0.post718 → nidx_binding-6.10.0.post719}/nidx_vector/src/indexer.rs

@@ -18,13 +18,15 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 use crate::config::{VectorCardinality, VectorConfig};
+use crate::field_list_metadata::encode_field_list_metadata;
 use crate::multivector::extract_multi_vectors;
 use crate::segment::{self, Elem};
+use crate::utils::FieldKey;
 use crate::{VectorSegmentMetadata, utils};
-use nidx_protos::{noderesources, prost::*};
-use std::collections::HashMap;
+use anyhow::anyhow;
+use nidx_protos::{Resource, noderesources, prost::*};
+use std::collections::{HashMap, HashSet};
 use std::path::Path;
-use std::time::Instant;
 use tracing::*;
 
 pub const SEGMENT_TAGS: &[&str] = &["/q/h"];
@@ -102,11 +104,7 @@ pub fn index_resource(
     output_path: &Path,
     config: &VectorConfig,
 ) -> anyhow::Result<Option<VectorSegmentMetadata>> {
-    let time = Instant::now();
-
-    debug!("Updating main index");
-    let v = time.elapsed().as_millis();
-    debug!("Creating elements for the main index: starts {v} ms");
+    debug!("Creating elements for the main index");
 
     let mut elems = Vec::new();
     let normalize_vectors = config.normalize_vectors;
@@ -136,11 +134,6 @@ pub fn index_resource(
             }
         }
     }
-    let v = time.elapsed().as_millis();
-    debug!("Creating elements for the main index: ends {v} ms");
-
-    let v = time.elapsed().as_millis();
-    debug!("Main index set resource: starts {v} ms");
 
     if elems.is_empty() {
         return Ok(None);
@@ -152,10 +145,82 @@ pub fn index_resource(
         .filter(|t| SEGMENT_TAGS.contains(&t.as_str()))
         .cloned()
         .collect();
+
+    debug!("Creating the segment");
     let segment = segment::create(output_path, elems, config, tags)?;
 
-    let v = time.elapsed().as_millis();
-    debug!("Main index set resource: ends {v} ms");
+    Ok(Some(segment.into_metadata()))
+}
+
+fn encode_metadata_field(rid: &str, fields: &HashSet<&String>) -> Vec<u8> {
+    let encoded_fields: Vec<_> = fields
+        .iter()
+        .map(|f| format!("{rid}/{f}"))
+        .filter_map(|f| FieldKey::from_field_id(&f))
+        .collect();
+    encode_field_list_metadata(&encoded_fields)
+}
+
+pub fn index_relations(
+    resource: &Resource,
+    output_path: &Path,
+    config: &VectorConfig,
+) -> anyhow::Result<Option<VectorSegmentMetadata>> {
+    debug!("Creating elements for the main index");
+
+    let mut entity_fields = HashMap::new();
+    let Some(resource_id) = &resource.resource else {
+        return Err(anyhow!("resource_id required"));
+    };
+    let rid = &resource_id.uuid;
+
+    for (field, relations) in &resource.field_relations {
+        for relation in &relations.relations {
+            let Some(relation) = &relation.relation else {
+                return Err(anyhow!("relation required"));
+            };
+            let Some(source) = &relation.source else {
+                return Err(anyhow!("relation source node required"));
+            };
+            entity_fields
+                .entry(source.value.clone())
+                .or_insert_with(HashSet::new)
+                .insert(field);
+
+            let Some(to) = &relation.to else {
+                return Err(anyhow!("relation to node required"));
+            };
+            entity_fields
+                .entry(to.value.clone())
+                .or_insert_with(HashSet::new)
+                .insert(field);
+        }
+    }
+
+    let mut elems = Vec::new();
+    for node_vector in &resource.relation_node_vectors {
+        let vector = node_vector.vector.clone();
+        let Some(node) = &node_vector.node else {
+            return Err(anyhow!("relation node required"));
+        };
+        let fields = entity_fields.get(&node.value);
+        let Some(fields) = fields else {
+            continue;
+        };
+        elems.push(Elem::new(
+            node.value.clone(),
+            vector,
+            vec![],
+            Some(encode_metadata_field(rid, fields)),
+        ));
+    }
+
+    if elems.is_empty() {
+        return Ok(None);
+    }
+
+    debug!("Creating the segment");
+    let segment = segment::create(output_path, elems, config, HashSet::new())?;
 
     Ok(Some(segment.into_metadata()))
 }

nidx_binding-6.10.0.post718/nidx_vector/src/inverted_index.rs → nidx_binding-6.10.0.post719/nidx_vector/src/inverted_index/paragraph.rs

@@ -17,27 +17,27 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-use std::{collections::BTreeMap, path::Path, sync::Arc};
+use std::{path::Path, sync::Arc};
 
 use bit_set::BitSet;
 use bit_vec::BitVec;
-use fst_index::{FstIndexReader, FstIndexWriter};
-use map::{InvertedMapReader, InvertedMapWriter};
-use tracing::warn;
 
+use super::{
+    IndexBuilder, OpenOptions, file,
+    fst_index::{FstIndexReader, FstIndexWriter},
+    map::{InvertedMapReader, InvertedMapWriter},
+};
 use crate::{
     ParagraphAddr, VectorR,
     data_store::{DataStore, iter_paragraphs},
     formula::{BooleanOperator, Clause, Formula},
+    utils::FieldKey,
 };
 
-mod fst_index;
-mod map;
-
-mod file {
-    pub const INDEX_MAP: &str = "index.map";
-    pub const FIELD_INDEX: &str = "field.fst";
-    pub const LABEL_INDEX: &str = "label.fst";
+pub struct ParagraphInvertedIndexes {
+    field_index: FstIndexReader,
+    label_index: FstIndexReader,
+    records: usize,
 }
 
 pub struct FilterBitSet(BitSet);
@@ -64,110 +64,46 @@ impl FilterBitSet {
     }
 }
 
-/// The key for the field index. [uuid_as_bytes, field_type/field_name]
-fn field_id_key(paragraph_key: &str) -> Option<Vec<u8>> {
-    let mut parts = paragraph_key.split('/');
-    if let Some(uuid) = parts.next() {
-        if let Some(field_type) = parts.next() {
-            if let Some(field_name) = parts.next() {
-                return Some(
-                    [
-                        uuid::Uuid::parse_str(uuid).unwrap().as_bytes(),
-                        field_type.as_bytes(),
-                        "/".as_bytes(),
-                        field_name.as_bytes(),
-                    ]
-                    .concat(),
-                );
-            }
-        } else {
-            return Some(uuid::Uuid::parse_str(uuid).unwrap().as_bytes().to_vec());
-        }
-    }
-    warn!(?paragraph_key, "Unable to parse field id from key");
-    None
-}
-
 /// The key for the labels, ending with a separator to allow for easy prefix search
 fn labels_key(label: &str) -> Vec<u8> {
     [&label.as_bytes()[1..], "/".as_bytes()].concat()
 }
 
-/// Helper to build indexes when the input is not sorted by key
-struct IndexBuilder {
-    ordered_keys: BTreeMap<Vec<u8>, Vec<u32>>,
-}
-
-impl IndexBuilder {
-    pub fn new() -> Self {
-        Self {
-            ordered_keys: Default::default(),
-        }
-    }
-
-    pub fn insert(&mut self, key: Vec<u8>, ParagraphAddr(id): ParagraphAddr) {
-        self.ordered_keys.entry(key).or_default().push(id);
-    }
-
-    pub fn write(self, index_writer: &mut FstIndexWriter) -> VectorR<()> {
-        for (key, mut values) in self.ordered_keys {
-            values.sort();
-            index_writer.write(&key, &values)?;
-        }
-
-        Ok(())
+impl ParagraphInvertedIndexes {
+    pub fn space_usage(&self) -> usize {
+        self.field_index.space_usage() + self.label_index.space_usage()
     }
-}
 
-/// Build indexes from a nodes.kv file.
-pub fn build_indexes(work_path: &Path, data_store: &impl DataStore) -> VectorR<()> {
-    let mut field_builder = IndexBuilder::new();
-    let mut label_builder = IndexBuilder::new();
+    pub fn build(work_path: &Path, data_store: &impl DataStore) -> VectorR<()> {
+        let mut field_builder = IndexBuilder::new();
+        let mut label_builder = IndexBuilder::new();
 
-    for paragraph_addr in iter_paragraphs(data_store) {
-        let paragraph = data_store.get_paragraph(paragraph_addr);
-        let key = paragraph.id();
-        let labels = paragraph.labels();
+        for paragraph_addr in iter_paragraphs(data_store) {
+            let paragraph = data_store.get_paragraph(paragraph_addr);
+            let key = paragraph.id();
+            let labels = paragraph.labels();
 
-        if let Some(key) = field_id_key(key) {
-            field_builder.insert(key, paragraph_addr);
-        }
-        for l in labels {
-            label_builder.insert(labels_key(&l), paragraph_addr);
+            if let Some(key) = FieldKey::from_field_id(key) {
+                field_builder.insert(key.bytes().to_vec(), paragraph_addr);
+            }
+            for l in labels {
+                label_builder.insert(labels_key(&l), paragraph_addr);
+            }
         }
-    }
-
-    let mut map = InvertedMapWriter::new(&work_path.join(file::INDEX_MAP))?;
-    let mut field_index = FstIndexWriter::new(&work_path.join(file::FIELD_INDEX), &mut map)?;
-    field_builder.write(&mut field_index)?;
-    field_index.finish()?;
-
-    let mut label_index = FstIndexWriter::new(&work_path.join(file::LABEL_INDEX), &mut map)?;
-    label_builder.write(&mut label_index)?;
-    label_index.finish()?;
-
-    map.finish()?;
 
-    Ok(())
-}
+        let mut map = InvertedMapWriter::new(&work_path.join(file::INDEX_MAP))?;
 
-pub struct OpenOptions {
-    pub prewarm: bool,
-}
+        let mut field_index = FstIndexWriter::new(&work_path.join(file::FIELD_INDEX), &mut map)?;
+        field_builder.write(&mut field_index)?;
+        field_index.finish()?;
 
-pub struct InvertedIndexes {
-    field_index: FstIndexReader,
-    label_index: FstIndexReader,
-    records: usize,
-}
+        let mut label_index = FstIndexWriter::new(&work_path.join(file::LABEL_INDEX), &mut map)?;
+        label_builder.write(&mut label_index)?;
+        label_index.finish()?;
 
-impl InvertedIndexes {
-    pub fn space_usage(&self) -> usize {
-        self.field_index.space_usage() + self.label_index.space_usage()
-    }
+        map.finish()?;
 
-    pub fn exists(path: &Path) -> bool {
-        path.join(file::INDEX_MAP).exists()
+        Ok(())
     }
 
     pub fn open(work_path: &Path, records: usize, options: OpenOptions) -> VectorR<Self> {
@@ -185,8 +121,8 @@ impl InvertedIndexes {
         })
     }
 
-    pub fn ids_for_deletion_key(&self, key: &str) -> Option<impl Iterator<Item = ParagraphAddr>> {
-        field_id_key(key).map(|key| self.field_index.get_prefix(&key).into_iter().map(ParagraphAddr))
+    pub fn ids_for_deletion_key(&self, key: &FieldKey) -> impl Iterator<Item = ParagraphAddr> {
+        self.field_index.get_prefix(key.bytes()).into_iter().map(ParagraphAddr)
     }
 
     pub fn filter(&self, formula: &Formula) -> Option<FilterBitSet> {
@@ -214,7 +150,7 @@ impl InvertedIndexes {
                     }
                     crate::formula::AtomClause::KeyPrefixSet(field_ids) => &mut field_ids
                         .iter()
-                        .filter_map(|id| field_id_key(id).map(|k| self.field_index.get(&k)))
+                        .filter_map(|id| FieldKey::from_field_id(id).map(|k| self.field_index.get(k.bytes())))
                         .flatten()
                         .flatten(),
                 };