nidx-binding 6.3.4.post123__tar.gz → 6.3.4.post129__tar.gz

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/Cargo.lock

@@ -2128,9 +2128,11 @@ dependencies = [
  "nidx_tantivy",
  "nidx_tests",
  "nidx_types",
+ "serde",
  "tantivy",
  "tempfile",
  "tracing",
+ "uuid",
 ]
 
 [[package]]
@@ -3141,15 +3143,14 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.8"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
@@ -3519,9 +3520,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
  "serde_derive",
 ]
@@ -3538,9 +3539,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4742,9 +4743,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.13.1"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced87ca4be083373936a67f8de945faa23b6b42384bd5b64434850802c6dccd0"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
  "getrandom 0.3.1",
  "serde",

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.3.4.post123
+Version: 6.3.4.post129
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_protos/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.3.4.post123"
+version = "6.3.4.post129"
 license = { text = "AGPL" }
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [ { name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_relation/Cargo.toml

@@ -10,8 +10,10 @@ deunicode = "1.3.2"
 nidx_protos = { version = "0.1.0", path = "../nidx_protos" }
 nidx_tantivy = { version = "0.1.0", path = "../nidx_tantivy" }
 nidx_types = { version = "0.1.0", path = "../nidx_types" }
+serde = { version = "1.0.219", features = ["derive"] }
 tantivy = "0.22"
 tracing = "0.1.41"
+uuid = "1.16.0"
 
 [dev-dependencies]
 tempfile = "3"

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_relation/src/graph_collector.rs

@@ -68,21 +68,18 @@ pub struct TopUniqueRelationSegmentCollector {
 }
 
 impl TopUniqueNodeCollector {
-    pub fn new(selector: NodeSelector, limit: usize) -> Self {
+    pub fn new(schema: crate::schema::Schema, selector: NodeSelector, limit: usize) -> Self {
         Self {
             limit,
             selector,
-            schema: crate::schema::Schema::new(),
+            schema,
         }
     }
 }
 
 impl TopUniqueRelationCollector {
-    pub fn new(limit: usize) -> Self {
-        Self {
-            limit,
-            schema: crate::schema::Schema::new(),
-        }
+    pub fn new(schema: crate::schema::Schema, limit: usize) -> Self {
+        Self { limit, schema }
     }
 }
 

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_relation/src/graph_query_parser.rs

@@ -23,9 +23,10 @@ use nidx_protos::relation_node::NodeType;
 use nidx_types::query_language::{BooleanExpression, BooleanOperation, Operator};
 use tantivy::query::{AllQuery, BooleanQuery, FuzzyTermQuery, Occur, Query, TermQuery};
 use tantivy::schema::{Field, IndexRecordOption};
+use tantivy::tokenizer::TokenizerManager;
 
+use crate::io_maps;
 use crate::schema::Schema;
-use crate::{io_maps, schema};
 
 const DEFAULT_NODE_VALUE_FUZZY_DISTANCE: u8 = 1;
 
@@ -119,20 +120,32 @@ enum NodePosition {
 pub struct BoolNodeQuery(BooleanExpression<Node>);
 pub struct BoolGraphQuery(BooleanExpression<GraphQuery>);
 
+#[derive(Clone, Copy)]
+struct TokenizedNodeFields {
+    exact: Field,
+    tokenized: Field,
+}
+
+#[derive(Clone, Copy)]
+enum NodeValueField {
+    Normalized(Field),
+    Tokenized(TokenizedNodeFields),
+}
+
 #[derive(Clone, Copy)]
 struct NodeSchemaFields {
-    normalized_value: Field,
+    value: NodeValueField,
     node_type: Field,
     node_subtype: Field,
 }
 
-pub struct GraphQueryParser {
-    schema: Schema,
+pub struct GraphQueryParser<'a> {
+    schema: &'a Schema,
 }
 
-impl GraphQueryParser {
-    pub fn new() -> Self {
-        Self { schema: Schema::new() }
+impl<'a> GraphQueryParser<'a> {
+    pub fn new(schema: &'a Schema) -> Self {
+        Self { schema }
     }
 
     pub fn parse_bool(&self, query: BoolGraphQuery) -> Box<dyn Query> {
@@ -143,9 +156,10 @@ impl GraphQueryParser {
         match query {
             BooleanExpression::Literal(query) => self.parse(query),
             BooleanExpression::Not(subquery) => {
-                let mut subqueries = vec![];
-                subqueries.push((Occur::Must, Box::new(AllQuery) as Box<dyn Query>));
-                subqueries.push((Occur::MustNot, self.inner_parse_bool(*subquery)));
+                let subqueries = vec![
+                    (Occur::Must, Box::new(AllQuery) as Box<dyn Query>),
+                    (Occur::MustNot, self.inner_parse_bool(*subquery)),
+                ];
                 Box::new(BooleanQuery::new(subqueries))
             }
             BooleanExpression::Operation(operation) => {
@@ -180,9 +194,10 @@ impl GraphQueryParser {
                 ))),
             },
             BooleanExpression::Not(subquery) => {
-                let mut subqueries = vec![];
-                subqueries.push((Occur::Must, Box::new(AllQuery) as Box<dyn Query>));
-                subqueries.push((Occur::MustNot, self.inner_parse_bool_node(*subquery, position)));
+                let subqueries = vec![
+                    (Occur::Must, Box::new(AllQuery) as Box<dyn Query>),
+                    (Occur::MustNot, self.inner_parse_bool_node(*subquery, position)),
+                ];
                 Box::new(BooleanQuery::new(subqueries))
             }
             BooleanExpression::Operation(operation) => {
@@ -247,7 +262,7 @@ impl GraphQueryParser {
                 let mut subqueries = vec![];
 
                 subqueries.extend(self.has_node_expression_as_source(&source_expression));
-                subqueries.extend(self.has_relation(&relation_expression).into_iter());
+                subqueries.extend(self.has_relation(&relation_expression));
                 subqueries.extend(self.has_node_expression_as_destination(&destination_expression));
 
                 // Due to implementation details on tantivy, a query containing only MustNot won't
@@ -271,10 +286,18 @@ impl GraphQueryParser {
 
     #[inline]
     fn has_node_expression_as_source(&self, expression: &Expression<Node>) -> Vec<(Occur, Box<dyn Query>)> {
+        let value = if self.schema.version == 1 {
+            NodeValueField::Normalized(self.schema.normalized_source_value)
+        } else {
+            NodeValueField::Tokenized(TokenizedNodeFields {
+                exact: self.schema.normalized_source_value,
+                tokenized: self.schema.source_value,
+            })
+        };
         self.has_node_expression(
             expression,
             NodeSchemaFields {
-                normalized_value: self.schema.normalized_source_value,
+                value,
                 node_type: self.schema.source_type,
                 node_subtype: self.schema.source_subtype,
             },
@@ -283,10 +306,18 @@ impl GraphQueryParser {
 
     #[inline]
     fn has_node_expression_as_destination(&self, expression: &Expression<Node>) -> Vec<(Occur, Box<dyn Query>)> {
+        let value = if self.schema.version == 1 {
+            NodeValueField::Normalized(self.schema.normalized_target_value)
+        } else {
+            NodeValueField::Tokenized(TokenizedNodeFields {
+                exact: self.schema.normalized_target_value,
+                tokenized: self.schema.target_value,
+            })
+        };
         self.has_node_expression(
             expression,
             NodeSchemaFields {
-                normalized_value: self.schema.normalized_target_value,
+                value,
                 node_type: self.schema.target_type,
                 node_subtype: self.schema.target_subtype,
             },
@@ -315,16 +346,16 @@ impl GraphQueryParser {
             Expression::Not(query) => {
                 // NOT granularity is a node, so we to use a Must { MustNot { X } } instead of
                 // unnest it in multiple MustNot { x }
-                let subquery: Box<dyn Query> = Box::new(BooleanQuery::intersection(self.has_node(&query, fields)));
+                let subquery: Box<dyn Query> = Box::new(BooleanQuery::intersection(self.has_node(query, fields)));
                 queries.push((Occur::MustNot, subquery));
             }
             Expression::Or(nodes) => {
                 // OR needs careful treatment. If there's only one node query matching, we can
                 // behave as it was a Value(Node). Otherwise we need a nested query with its parts
                 let mut subqueries: Vec<_> = nodes
-                    .into_iter()
+                    .iter()
                     .flat_map(|node| {
-                        let node_queries = self.has_node(&node, fields);
+                        let node_queries = self.has_node(node, fields);
                         if node_queries.is_empty() {
                             // We don't care about nodes that match everything as they don't provide any
                             // filtering value
@@ -346,7 +377,7 @@ impl GraphQueryParser {
                         // When there's multiple nodes to match, we must do a nested query and force
                         // that any of these matches
                         let or_subqueries = subqueries.into_iter().map(|mut node_queries| {
-                            debug_assert!(node_queries.len() > 0, "already validated above");
+                            debug_assert!(!node_queries.is_empty(), "already validated above");
                             let node_query: (Occur, Box<dyn Query>) = if node_queries.len() == 1 {
                                 // To avoid a nested boolean query for a node matching only in
                                 // one field, we can directly add a subquery
@@ -372,7 +403,7 @@ impl GraphQueryParser {
         let value_query = node
             .value
             .as_ref()
-            .and_then(|value| self.has_node_value(value, fields.normalized_value));
+            .and_then(|value| self.has_node_value(value, fields.value));
         if let Some(query) = value_query {
             subqueries.push(query);
         }
@@ -420,7 +451,7 @@ impl GraphQueryParser {
             }
 
             Expression::Or(relations) => {
-                subqueries.extend(relations.into_iter().flat_map(|relation| {
+                subqueries.extend(relations.iter().flat_map(|relation| {
                     if let Some(label) = &relation.value {
                         if label.is_empty() {
                             None
@@ -437,47 +468,79 @@ impl GraphQueryParser {
         subqueries
     }
 
-    fn has_node_value(&self, value: &Term, field: Field) -> Option<Box<dyn Query>> {
-        match value {
-            Term::Exact(value) => {
-                if value.is_empty() {
-                    return None;
+    fn has_node_value(&self, value: &Term, field: NodeValueField) -> Option<Box<dyn Query>> {
+        let text_value = match value {
+            Term::Exact(value) => value,
+            Term::Fuzzy(fuzzy) => &fuzzy.value,
+        };
+        if text_value.is_empty() {
+            return None;
+        }
+        let exact_term = match field {
+            NodeValueField::Normalized(field) => {
+                tantivy::Term::from_field_text(field, &self.schema.normalize(text_value))
+            }
+            NodeValueField::Tokenized(TokenizedNodeFields { exact, .. }) => {
+                tantivy::Term::from_field_text(exact, &self.schema.normalize(text_value))
+            }
+        };
+        let tokenized_terms = match field {
+            NodeValueField::Normalized(field) => {
+                vec![tantivy::Term::from_field_text(
+                    field,
+                    &self.schema.normalize(text_value),
+                )]
+            }
+            NodeValueField::Tokenized(TokenizedNodeFields { tokenized, .. }) => {
+                let mut tokenizer = TokenizerManager::default().get("default").unwrap();
+                let mut token_stream = tokenizer.token_stream(text_value);
+                let mut terms = Vec::new();
+                while let Some(token) = token_stream.next() {
+                    terms.push(tantivy::Term::from_field_text(tokenized, &token.text));
                 }
-                let normalized_value = schema::normalize(&value);
-                let query = Box::new(TermQuery::new(
-                    tantivy::Term::from_field_text(field, &normalized_value),
-                    IndexRecordOption::Basic,
-                ));
-                Some(query)
+                terms
             }
+        };
 
-            Term::Fuzzy(fuzzy) => {
-                let normalized_value = schema::normalize(&fuzzy.value);
-                match fuzzy {
-                    FuzzyTerm { value, .. } if value.is_empty() => None,
-
-                    FuzzyTerm {
-                        fuzzy_distance: distance,
-                        is_prefix: true,
-                        ..
-                    } => Some(Box::new(FuzzyTermQuery::new_prefix(
-                        tantivy::Term::from_field_text(field, &normalized_value),
-                        *distance,
-                        true,
-                    ))),
-
-                    FuzzyTerm {
-                        fuzzy_distance: distance,
-                        is_prefix: false,
-                        ..
-                    } => Some(Box::new(FuzzyTermQuery::new(
-                        tantivy::Term::from_field_text(field, &normalized_value),
-                        *distance,
-                        true,
-                    ))),
+        // TODO: Rethink this
+        // Current logic:
+        // - Exact match always match the search term against the full field
+        // - Fuzzy + prefix search works does a prefix fuzzy match of the whole entity name
+        // - Fuzzy search looks for entities containing all words in the term with a fuzzy match (tokenized)
+        //
+        // Questions:
+        // - Do we want exact match of a word in the entity? (kind of supported by setting fuzzy distance = 0)
+        let query: Box<dyn Query> = match value {
+            Term::Exact(_) => Box::new(TermQuery::new(exact_term, IndexRecordOption::Basic)),
+            Term::Fuzzy(fuzzy) => match fuzzy {
+                FuzzyTerm {
+                    fuzzy_distance,
+                    is_prefix: true,
+                    ..
+                } => Box::new(FuzzyTermQuery::new_prefix(exact_term, *fuzzy_distance, true)),
+
+                FuzzyTerm { fuzzy_distance, .. } => {
+                    if tokenized_terms.len() > 1 {
+                        Box::new(BooleanQuery::intersection(
+                            tokenized_terms
+                                .into_iter()
+                                .map(|term| -> Box<dyn Query> {
+                                    Box::new(FuzzyTermQuery::new(term, *fuzzy_distance, true))
+                                })
+                                .collect(),
+                        ))
+                    } else {
+                        Box::new(FuzzyTermQuery::new(
+                            tokenized_terms.into_iter().next().unwrap(),
+                            *fuzzy_distance,
+                            true,
+                        ))
+                    }
                 }
-            }
-        }
+            },
+        };
+
+        Some(query)
     }
 
     fn has_node_type(&self, node_type: NodeType, field: Field) -> Box<dyn Query> {
@@ -497,7 +560,7 @@ impl GraphQueryParser {
 
     fn has_relation_label(&self, label: &str) -> Box<dyn Query> {
         Box::new(TermQuery::new(
-            tantivy::Term::from_field_text(self.schema.label, &label),
+            tantivy::Term::from_field_text(self.schema.label, label),
             IndexRecordOption::Basic,
         ))
     }
@@ -533,7 +596,7 @@ impl TryFrom<&nidx_protos::graph_query::PathQuery> for BoolNodeQuery {
                     if !(path.source.is_some()
                         && path.relation.is_none()
                         && path.destination.is_none()
-                        && path.undirected == true)
+                        && path.undirected)
                     {
                         // We are doing something wrong between search API and nidx
                         return Err(anyhow!(
@@ -664,7 +727,7 @@ impl TryFrom<&nidx_protos::graph_query::Node> for Node {
         let value = node_pb.value.clone().map(|value| match node_pb.match_kind() {
             nidx_protos::graph_query::node::MatchKind::Exact => Term::Exact(value),
             nidx_protos::graph_query::node::MatchKind::Fuzzy => Term::Fuzzy(FuzzyTerm {
-                value: value,
+                value,
                 fuzzy_distance: DEFAULT_NODE_VALUE_FUZZY_DISTANCE,
                 is_prefix: true,
             }),

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_relation/src/io_maps.rs

@@ -18,13 +18,14 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 
-use nidx_protos::prost::*;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
+use nidx_protos::{IndexRelation, prost::*};
 use nidx_protos::{Relation as ProtosRelation, RelationMetadata, RelationNode};
 use tantivy::TantivyDocument;
+use tantivy::schema::Value;
 
-use crate::schema::Schema;
+use crate::schema::{Schema, decode_field_id};
 
 pub fn decode_metadata(schema: &Schema, doc: &TantivyDocument) -> Option<RelationMetadata> {
     schema
@@ -108,6 +109,28 @@ pub fn doc_to_relation(schema: &Schema, doc: &TantivyDocument) -> ProtosRelation
     }
 }
 
+pub fn doc_to_index_relation(schema: &Schema, doc: &TantivyDocument) -> IndexRelation {
+    let resource_field_id = schema.resource_field_id.and_then(|f| {
+        doc.get_first(f).map(|v| {
+            let (rid, fid) = decode_field_id(v.as_bytes().unwrap());
+            format!("{}/{}", rid.simple(), fid)
+        })
+    });
+    let facets = schema
+        .facets
+        .map(|field| {
+            doc.get_all(field)
+                .map(|f| f.as_facet().unwrap().to_path_string())
+                .collect()
+        })
+        .unwrap_or_default();
+    IndexRelation {
+        relation: Some(doc_to_relation(schema, doc)),
+        resource_field_id,
+        facets,
+    }
+}
+
 pub fn doc_to_graph_relation(schema: &Schema, doc: &TantivyDocument) -> nidx_protos::graph_search_response::Relation {
     nidx_protos::graph_search_response::Relation {
         relation_type: u64_to_relation_type::<i32>(schema.relationship(doc)),

{nidx_binding-6.3.4.post123 → nidx_binding-6.3.4.post129}/nidx_relation/src/lib.rs

@@ -38,6 +38,8 @@ use nidx_types::OpenIndexMetadata;
 use reader::{HashedRelationNode, RelationsReaderService};
 use resource_indexer::index_relations;
 pub use schema::Schema as RelationSchema;
+use schema::encode_field_id;
+use serde::{Deserialize, Serialize};
 use std::{collections::HashSet, path::Path};
 use tantivy::{
     Term,
@@ -46,26 +48,77 @@ use tantivy::{
     query::{Query, TermSetQuery},
     schema::Field,
 };
-use tracing::instrument;
+use tracing::{error, instrument};
+use uuid::Uuid;
 
 /// Minimum length for a word to be accepted as a entity to search for
 /// suggestions. Low values can provide too much noise and higher ones can
 /// remove important words from suggestion
 const MIN_SUGGEST_PREFIX_LENGTH: usize = 2;
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct RelationConfig {
+    #[serde(default = "default_version")]
+    pub version: u64,
+}
+
+impl Default for RelationConfig {
+    fn default() -> Self {
+        Self {
+            // This is the default version when creating a new index.
+            // Should typically be set to the latest supported version
+            version: 1,
+        }
+    }
+}
+
+// This is the default version when reading from serde, i.e: no info on database
+// This should always be 1
+fn default_version() -> u64 {
+    1
+}
+
 pub struct RelationIndexer;
 
-pub struct RelationDeletionQueryBuilder(Field);
+pub struct RelationDeletionQueryBuilder {
+    resource: Field,
+    field: Option<Field>,
+}
 impl DeletionQueryBuilder for RelationDeletionQueryBuilder {
     fn query<'a>(&self, keys: impl Iterator<Item = &'a String>) -> Box<dyn Query> {
-        Box::new(TermSetQuery::new(
-            keys.map(|k| Term::from_field_bytes(self.0, k.as_bytes())),
-        ))
+        if let Some(field) = self.field {
+            Box::new(TermSetQuery::new(keys.filter_map(|k| {
+                // Our keys can be resource or field ids, match the corresponding tantivy field
+                if k.len() < 32 {
+                    error!(?k, "Invalid deletion key for nidx_relation");
+                    return None;
+                }
+
+                let Ok(rid) = Uuid::parse_str(&k[..32]) else {
+                    error!(?k, "Invalid deletion key for nidx_relation");
+                    return None;
+                };
+
+                let is_field = k.len() > 32;
+                if is_field {
+                    Some(Term::from_field_bytes(field, &encode_field_id(rid, &k[33..])))
+                } else {
+                    Some(Term::from_field_bytes(self.resource, rid.as_bytes()))
+                }
+            })))
+        } else {
+            Box::new(TermSetQuery::new(
+                keys.map(|k| Term::from_field_bytes(self.resource, k.as_bytes())),
+            ))
+        }
     }
 }
 impl RelationDeletionQueryBuilder {
     fn new(schema: &RelationSchema) -> Self {
-        RelationDeletionQueryBuilder(schema.resource_id)
+        RelationDeletionQueryBuilder {
+            resource: schema.resource_id,
+            field: schema.resource_field_id,
+        }
     }
 }
 
@@ -74,9 +127,10 @@ impl RelationIndexer {
     pub fn index_resource(
         &self,
         output_dir: &Path,
+        config: &RelationConfig,
         resource: &nidx_protos::Resource,
     ) -> anyhow::Result<Option<TantivySegmentMetadata>> {
-        let field_schema = RelationSchema::new();
+        let field_schema = RelationSchema::new(config.version);
         let mut indexer = TantivyIndexer::new(output_dir.to_path_buf(), field_schema.schema.clone())?;
 
         if resource.status == ResourceStatus::Delete as i32 {
@@ -87,17 +141,27 @@ impl RelationIndexer {
         indexer.finalize()
     }
 
-    pub fn deletions_for_resource(&self, resource: &nidx_protos::Resource) -> Vec<String> {
-        vec![resource.resource.as_ref().unwrap().uuid.clone()]
+    pub fn deletions_for_resource(&self, config: &RelationConfig, resource: &nidx_protos::Resource) -> Vec<String> {
+        if config.version == 2 {
+            let rid = &resource.resource.as_ref().unwrap().uuid;
+            resource
+                .relation_fields_to_delete
+                .iter()
+                .map(|f| format!("{rid}/{f}"))
+                .collect()
+        } else {
+            vec![resource.resource.as_ref().unwrap().uuid.clone()]
+        }
     }
 
     #[instrument(name = "relation::merge", skip_all)]
     pub fn merge(
         &self,
         work_dir: &Path,
+        config: RelationConfig,
         open_index: impl OpenIndexMetadata<TantivyMeta>,
     ) -> anyhow::Result<TantivySegmentMetadata> {
-        let schema = RelationSchema::new();
+        let schema = RelationSchema::new(config.version);
         let deletions_query = RelationDeletionQueryBuilder::new(&schema);
         let index = open_index_with_deletions(schema.schema, open_index, deletions_query)?;
 
@@ -120,15 +184,15 @@ pub struct RelationSearcher {
 
 impl RelationSearcher {
     #[instrument(name = "relation::open", skip_all)]
-    pub fn open(open_index: impl OpenIndexMetadata<TantivyMeta>) -> anyhow::Result<Self> {
-        let schema = RelationSchema::new();
+    pub fn open(config: RelationConfig, open_index: impl OpenIndexMetadata<TantivyMeta>) -> anyhow::Result<Self> {
+        let schema = RelationSchema::new(config.version);
         let deletions_query = RelationDeletionQueryBuilder::new(&schema);
         let index = open_index_with_deletions(schema.schema, open_index, deletions_query)?;
 
         Ok(Self {
             reader: RelationsReaderService {
                 index: index.clone(),
-                schema: RelationSchema::new(),
+                schema: RelationSchema::new(config.version),
                 reader: index
                     .reader_builder()
                     .reload_policy(tantivy::ReloadPolicy::Manual)