fixup! Add edge crate

ffuugoo · ffuugoo · commit 4e285fa392f3 · 2025-09-24T11:43:11.000+02:00
Implement segment config compatibility check
diff --git a/lib/edge/src/lib.rs b/lib/edge/src/lib.rs
@@ -102,10 +102,10 @@ impl Shard {
             };
 
             if let Some(config) = &config {
-                // TODO: Is simple equality check sufficient? 🤔
-                if config != segment.config() {
+                if !config.is_compatible(segment.config()) {
                     return Err(OperationError::service_error(format!(
-                        "segment {} does not match expected segment config: expected {:?}, but received {:?}",
+                        "segment {} is incompatible with provided config or previously loaded segments: \
+                         expected {:?}, but received {:?}",
                         segment_path.display(),
                         config,
                         segment.config(),
diff --git a/lib/segment/src/types.rs b/lib/segment/src/types.rs
@@ -1405,6 +1405,56 @@ impl SegmentConfig {
             )
             .all(|v| v)
     }
+
+    pub fn is_compatible(&self, other: &Self) -> bool {
+        // Vector data have to be compatible between two segments.
+        // Sparse vector data can be different, but a placeholder check is implemented to catch
+        // and enforce compatibility check for future changes.
+        // Payload storage type can be different.
+
+        // Assert segment config fields
+        let Self {
+            vector_data: _,
+            sparse_vector_data: _,
+            payload_storage_type: _,
+        } = self;
+
+        let is_vector_config_compatible = is_compatible(
+            &self.vector_data,
+            &other.vector_data,
+            VectorDataConfig::is_compatible,
+        );
+
+        let is_sparse_vector_config_compatible = is_compatible(
+            &self.sparse_vector_data,
+            &other.sparse_vector_data,
+            SparseVectorDataConfig::is_compatible,
+        );
+
+        is_vector_config_compatible && is_sparse_vector_config_compatible
+    }
+}
+
+fn is_compatible<V, C, F>(this: &HashMap<V, C>, other: &HashMap<V, C>, check: F) -> bool
+where
+    V: Eq + Hash,
+    F: Fn(&C, &C) -> bool,
+{
+    if this.len() != other.len() {
+        return false;
+    }
+
+    for (vector_name, config) in this {
+        let Some(other_config) = other.get(vector_name) else {
+            return false;
+        };
+
+        if !check(config, other_config) {
+            return false;
+        }
+    }
+
+    true
 }
 
 /// Storage types for vectors
@@ -1526,6 +1576,29 @@ impl VectorDataConfig {
         };
         is_index_appendable && is_storage_appendable
     }
+
+    pub fn is_compatible(&self, other: &Self) -> bool {
+        // Size and distance have to be the same for both segments.
+        // Storage type, index and quantization config can be different.
+        //
+        // TODO: Can multivector config and datatype be different?
+
+        // Assert vector data config fields
+        let Self {
+            size: _,
+            distance: _,
+            storage_type: _,
+            index: _,
+            quantization_config: _,
+            multivector_config: _,
+            datatype: _,
+        } = self;
+
+        self.size == other.size
+            && self.distance == other.distance
+            && self.multivector_config == other.multivector_config // TODO: 🤔
+            && self.datatype == other.datatype // TODO: 🤔
+    }
 }
 
 #[derive(
@@ -1582,6 +1655,18 @@ impl SparseVectorDataConfig {
     pub fn is_indexed(&self) -> bool {
         true
     }
+
+    pub fn is_compatible(&self, _other: &Self) -> bool {
+        // Both index and storage type can be different for two segments to be compatible
+
+        // Assert sparse vector config fields
+        let Self {
+            index: _,
+            storage_type: _,
+        } = self;
+
+        true
+    }
 }
 
 /// Default value based on experiments and observations
