lib/segment/src/vector_storage/dense/memmap_dense_vector_storage.rs (1)

191-205: Unused AccessPattern generic parameter.

The generic parameter P: AccessPattern is declared but never used in this implementation. The method always delegates to read_vectors_async regardless of the access pattern. If this is intentional for the experimental async scroll feature, consider adding a comment explaining this behavior. Otherwise, the sequential/random access hints could potentially be used to optimize the async read strategy.

Additionally, the .unwrap() on line 204 will panic if read_vectors_async fails. Based on learnings from this codebase, the io_uring feature is experimental and designed to panic rather than silently fall back. If this is the intended behavior here, a brief comment would clarify the design decision.

lib/shard/src/proxy_segment/segment_entry.rs (1)

350-369: Avoid allocation when there are no deleted points.
You can skip building filtered_point_ids if deleted_points is empty to avoid an extra allocation and copy on the hot path.

♻️ Suggested tweak

     fn retrieve(
         &self,
         point_ids: &[PointIdType],
         with_payload: &WithPayload,
         with_vector: &WithVector,
         hw_counter: &HardwareCounterCell,
         is_stopped: &AtomicBool,
     ) -> OperationResult<Vec<SegmentRecord>> {
+        if self.deleted_points.is_empty() {
+            return self.wrapped_segment.get().read().retrieve(
+                point_ids,
+                with_payload,
+                with_vector,
+                hw_counter,
+                is_stopped,
+            );
+        }
         let filtered_point_ids: Vec<PointIdType> = point_ids
             .iter()
             .copied()
             .filter(|id| !self.deleted_points.contains_key(id))
             .collect();
         self.wrapped_segment.get().read().retrieve(

lib/segment/src/segment/vectors.rs (1)

20-44: Preserve first lookup error and avoid partial callbacks.

Right now a lookup error still allows callbacks to run and overwrites earlier errors. If an error is returned, it’s safer to avoid partial side effects and to keep the first failure for determinism.

♻️ Suggested refactor

-        let mut error = None;
-        let internal_ids = point_ids
-            .iter()
-            .copied()
-            .stop_if(is_stopped)
-            .filter_map(|point_id| match self.lookup_internal_id(point_id) {
-                Ok(point_offset) => Some(point_offset),
-                Err(err) => {
-                    error = Some(err);
-                    None
-                }
-            });
-        self.vectors_by_offsets(
-            vector_names,
-            internal_ids,
-            hw_counter,
-            |point_offset, vector_internal| {
-                if let Some(point_id) = self.id_tracker.borrow().external_id(point_offset) {
-                    callback(point_id, vector_internal);
-                }
-            },
-        )?;
-        if let Some(err) = error {
-            return Err(err);
-        }
+        let mut error = None;
+        let mut internal_ids = Vec::with_capacity(point_ids.len());
+        for point_id in point_ids.iter().copied().stop_if(is_stopped) {
+            match self.lookup_internal_id(point_id) {
+                Ok(point_offset) => internal_ids.push(point_offset),
+                Err(err) => {
+                    error.get_or_insert(err);
+                    break; // avoid partial callbacks when returning Err
+                }
+            }
+        }
+        if let Some(err) = error {
+            return Err(err);
+        }
+        self.vectors_by_offsets(
+            vector_names,
+            internal_ids,
+            hw_counter,
+            |point_offset, vector_internal| {
+                if let Some(point_id) = self.id_tracker.borrow().external_id(point_offset) {
+                    callback(point_id, vector_internal);
+                }
+            },
+        )?;