nidx-binding 6.6.1.post444__tar.gz → 6.6.1.post447__tar.gz

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.6.1.post444
+Version: 6.6.1.post447
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_protos/pyproject.toml

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

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/data_store/v1/store.rs

@@ -211,7 +211,7 @@ pub fn merge(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{config::VectorCardinality, data_point::Elem};
+    use crate::{config::VectorCardinality, segment::Elem};
 
     const VECTOR_CONFIG: VectorConfig = VectorConfig {
         vector_type: VectorType::DenseF32 { dimension: 3 },

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/data_store/v1.rs

@@ -20,7 +20,7 @@
 
 use crate::{
     config::{VectorConfig, VectorType},
-    data_point::Elem,
+    segment::Elem,
 };
 use memmap2::Mmap;
 use node::Node;

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/data_store/v2/paragraph_store.rs

@@ -23,9 +23,9 @@ use std::{fs::File, io::Write as _, path::Path};
 
 use crate::{
     VectorR,
-    data_point::Elem,
     data_store::{OpenReason, ParagraphAddr, ParagraphRef},
     data_types::usize_utils::U32_LEN,
+    segment::Elem,
 };
 
 const FILENAME_DATA: &str = "paragraphs.bin";

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/data_store/v2.rs

@@ -18,7 +18,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 
-use crate::{VectorR, config::VectorType, data_point::Elem};
+use crate::{VectorR, config::VectorType, segment::Elem};
 
 use super::{DataStore, OpenReason, ParagraphAddr, VectorAddr};
 pub use paragraph_store::StoredParagraph;

{nidx_binding-6.6.1.post444/nidx_vector/src/data_point → nidx_binding-6.6.1.post447/nidx_vector/src/hnsw}/disk_hnsw.rs

@@ -260,7 +260,7 @@ impl DiskHnsw {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::data_point::ram_hnsw::RAMLayer;
+    use crate::hnsw::ram_hnsw::RAMLayer;
     fn layer_check<L: Layer>(buf: L, no_nodes: usize, cnx: &[Vec<(Address, Edge)>]) {
         let no_cnx = vec![];
         for i in 0..no_nodes {

{nidx_binding-6.6.1.post444/nidx_vector/src/data_point → nidx_binding-6.6.1.post447/nidx_vector/src/hnsw}/ops_hnsw.rs

@@ -27,8 +27,11 @@ use rand::rngs::SmallRng;
 use std::cmp::{Ordering, Reverse};
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
+use crate::ParagraphAddr;
+use crate::inverted_index::FilterBitSet;
+
+use super::params;
 use super::*;
-use crate::data_point::params;
 
 /// Implementors of this trait can guide the hnsw search
 pub trait DataRetriever: std::marker::Sync {

nidx_binding-6.6.1.post447/nidx_vector/src/hnsw.rs

@@ -0,0 +1,48 @@
+// 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/>.
+//
+
+mod disk_hnsw;
+mod ops_hnsw;
+mod params;
+mod ram_hnsw;
+
+pub use disk_hnsw::DiskHnsw;
+pub use ops_hnsw::Cnx;
+pub use ops_hnsw::DataRetriever;
+pub use ops_hnsw::HnswOps;
+pub use ram_hnsw::RAMHnsw;
+
+use crate::VectorAddr;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct Address(pub(super) usize);
+
+// VectorAddr and HNSW Address are the same thing with a different data type for serialization purposes
+impl From<Address> for VectorAddr {
+    fn from(value: Address) -> Self {
+        Self(value.0 as u32)
+    }
+}
+
+impl From<VectorAddr> for Address {
+    fn from(value: VectorAddr) -> Self {
+        Self(value.0 as usize)
+    }
+}

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/indexer.rs

@@ -18,8 +18,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 use crate::config::{VectorCardinality, VectorConfig};
-use crate::data_point::{self, Elem};
 use crate::multivector::extract_multi_vectors;
+use crate::segment::{self, Elem};
 use crate::{VectorSegmentMetadata, utils};
 use nidx_protos::{noderesources, prost::*};
 use std::collections::HashMap;
@@ -157,10 +157,10 @@ pub fn index_resource(
         .filter(|t| SEGMENT_TAGS.contains(&t.as_str()))
         .cloned()
         .collect();
-    let data_point = data_point::create(output_path, elems, config, tags)?;
+    let segment = segment::create(output_path, elems, config, tags)?;
 
     let v = time.elapsed().as_millis();
     debug!("{id:?} - Main index set resource: ends {v} ms");
 
-    Ok(Some(data_point.into_metadata()))
+    Ok(Some(segment.into_metadata()))
 }

{nidx_binding-6.6.1.post444 → nidx_binding-6.6.1.post447}/nidx_vector/src/lib.rs

@@ -19,26 +19,27 @@
 //
 
 pub mod config;
-mod data_point;
-mod data_point_provider;
 mod data_store;
 mod data_types;
 mod formula;
+mod hnsw;
 mod indexer;
 mod inverted_index;
 mod multivector;
 mod query_io;
 mod request_types;
+mod searcher;
+mod segment;
 mod utils;
 mod vector_types;
 
 use config::VectorConfig;
-use data_point::{Address, OpenDataPoint};
-use data_point_provider::reader::Reader;
 use indexer::{ResourceWrapper, index_resource};
 use nidx_protos::{Resource, VectorSearchResponse};
 use nidx_types::prefilter::PrefilterResult;
 use nidx_types::{OpenIndexMetadata, SegmentMetadata};
+use searcher::Searcher;
+use segment::OpenSegment;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::path::Path;
@@ -52,19 +53,6 @@ pub use request_types::VectorSearchRequest;
 pub struct ParagraphAddr(u32);
 pub struct VectorAddr(u32);
 
-// VectorAddr and HNSW Address are the same thing with a different data type for serialization purposes
-impl From<Address> for VectorAddr {
-    fn from(value: Address) -> Self {
-        Self(value.0 as u32)
-    }
-}
-
-impl From<VectorAddr> for Address {
-    fn from(value: VectorAddr) -> Self {
-        Self(value.0 as usize)
-    }
-}
-
 #[derive(Clone, Serialize, Deserialize)]
 pub struct VectorSegmentMeta {
     pub tags: HashSet<String>,
@@ -105,25 +93,25 @@ impl VectorIndexer {
         config: VectorConfig,
         open_index: impl OpenIndexMetadata<VectorSegmentMeta>,
     ) -> anyhow::Result<VectorSegmentMetadata> {
-        let open_data_points = open_segments(open_index, &config)?;
-        let open_data_points_ref = open_data_points.iter().collect::<Vec<_>>();
+        let open_segments = open_segments(open_index, &config)?;
+        let open_segments_ref = open_segments.iter().collect::<Vec<_>>();
 
         // Do the merge
-        let open_destination = data_point::merge(work_dir, &open_data_points_ref, &config)?;
+        let open_destination = segment::merge(work_dir, &open_segments_ref, &config)?;
 
         Ok(open_destination.into_metadata())
     }
 }
 
 pub struct VectorSearcher {
-    reader: Reader,
+    searcher: Searcher,
 }
 
 impl VectorSearcher {
     #[instrument(name = "vector::open", skip_all)]
     pub fn open(config: VectorConfig, open_index: impl OpenIndexMetadata<VectorSegmentMeta>) -> anyhow::Result<Self> {
         Ok(VectorSearcher {
-            reader: Reader::open(open_segments(open_index, &config)?, config)?,
+            searcher: Searcher::open(open_segments(open_index, &config)?, config)?,
         })
     }
 
@@ -133,35 +121,35 @@ impl VectorSearcher {
         request: &VectorSearchRequest,
         prefilter: &PrefilterResult,
     ) -> anyhow::Result<VectorSearchResponse> {
-        self.reader.search(request, prefilter)
+        self.searcher.search(request, prefilter)
     }
 
     pub fn space_usage(&self) -> usize {
-        self.reader.space_usage()
+        self.searcher.space_usage()
     }
 }
 
 fn open_segments(
     open_index: impl OpenIndexMetadata<VectorSegmentMeta>,
     config: &VectorConfig,
-) -> VectorR<Vec<OpenDataPoint>> {
-    let mut open_data_points = Vec::new();
+) -> VectorR<Vec<OpenSegment>> {
+    let mut open_segments = Vec::new();
 
     for (metadata, seq) in open_index.segments() {
-        let open_data_point = data_point::open(metadata, config)?;
+        let open_segment = segment::open(metadata, config)?;
 
-        open_data_points.push((open_data_point, seq));
+        open_segments.push((open_segment, seq));
     }
 
     for (deletion, deletion_seq) in open_index.deletions() {
-        for (segment, segment_seq) in &mut open_data_points {
+        for (segment, segment_seq) in &mut open_segments {
             if deletion_seq > *segment_seq {
                 segment.apply_deletion(deletion.as_str());
             }
         }
     }
 
-    Ok(open_data_points.into_iter().map(|(dp, _)| dp).collect())
+    Ok(open_segments.into_iter().map(|(dp, _)| dp).collect())
 }
 
 #[derive(Debug, Error)]
@@ -176,7 +164,7 @@ pub enum VectorErr {
     UncommittedChangesError,
     #[error("Merger is already initialized")]
     MergerAlreadyInitialized,
-    #[error("Can not merge zero datapoints")]
+    #[error("Can not merge zero segments")]
     EmptyMerge,
     #[error("Inconsistent dimensions. Index={index_config} Vector={vector}")]
     InconsistentDimensions { index_config: usize, vector: usize },

nidx_binding-6.6.1.post444/nidx_vector/src/data_point_provider/reader.rs → nidx_binding-6.6.1.post447/nidx_vector/src/searcher.rs

@@ -20,13 +20,12 @@
 
 use crate::ParagraphAddr;
 use crate::config::VectorCardinality;
-use crate::data_point::OpenDataPoint;
-use crate::data_point_provider::SearchRequest;
-use crate::data_point_provider::VectorConfig;
+use crate::config::VectorConfig;
 use crate::data_store::ParagraphRef;
 use crate::multivector::extract_multi_vectors;
 use crate::multivector::maxsim_similarity;
 use crate::request_types::VectorSearchRequest;
+use crate::segment::OpenSegment;
 use crate::utils;
 use crate::{VectorErr, VectorR};
 use crate::{formula::*, query_io};
@@ -40,12 +39,35 @@ use std::collections::HashSet;
 use std::time::Instant;
 use tracing::*;
 
+struct SearchRequest<'a> {
+    request: &'a VectorSearchRequest,
+    formula: Formula,
+}
+
+impl SearchRequest<'_> {
+    fn with_duplicates(&self) -> bool {
+        self.request.with_duplicates
+    }
+    fn get_filter(&self) -> &Formula {
+        &self.formula
+    }
+    fn get_query(&self) -> &[f32] {
+        &self.request.vector
+    }
+    fn no_results(&self) -> usize {
+        self.request.result_per_page as usize
+    }
+    fn min_score(&self) -> f32 {
+        self.request.min_score
+    }
+}
+
 #[derive(Clone)]
 pub struct ScoredParagraph<'a> {
     score: f32,
     paragraph: ParagraphRef<'a>,
     address: ParagraphAddr,
-    data_point: &'a OpenDataPoint,
+    segment: &'a OpenSegment,
 }
 impl Eq for ScoredParagraph<'_> {}
 impl std::hash::Hash for ScoredParagraph<'_> {
@@ -79,9 +101,9 @@ impl PartialEq for ScoredParagraph<'_> {
 }
 
 impl<'a> ScoredParagraph<'a> {
-    pub fn new(data_point: &'a OpenDataPoint, address: ParagraphAddr, paragraph: ParagraphRef<'a>, score: f32) -> Self {
+    pub fn new(segment: &'a OpenSegment, address: ParagraphAddr, paragraph: ParagraphRef<'a>, score: f32) -> Self {
         Self {
-            data_point,
+            segment,
             paragraph,
             score,
             address,
@@ -103,7 +125,7 @@ impl<'a> ScoredParagraph<'a> {
     pub fn vectors(&self) -> Vec<&[u8]> {
         self.paragraph
             .vectors(&self.address)
-            .map(|va| self.data_point.get_vector(va).vector())
+            .map(|va| self.segment.get_vector(va).vector())
             .collect()
     }
 }
@@ -160,9 +182,9 @@ impl<'a> Fssc<'a> {
     }
 }
 
-pub struct Reader {
+pub struct Searcher {
     config: VectorConfig,
-    open_data_points: Vec<OpenDataPoint>,
+    open_segments: Vec<OpenSegment>,
 }
 
 fn segment_matches(expression: &BooleanExpression<String>, labels: &HashSet<String>) -> bool {
@@ -180,24 +202,6 @@ fn segment_matches(expression: &BooleanExpression<String>, labels: &HashSet<Stri
     }
 }
 
-impl SearchRequest for (&VectorSearchRequest, Formula) {
-    fn with_duplicates(&self) -> bool {
-        self.0.with_duplicates
-    }
-    fn get_filter(&self) -> &Formula {
-        &self.1
-    }
-    fn get_query(&self) -> &[f32] {
-        &self.0.vector
-    }
-    fn no_results(&self) -> usize {
-        self.0.result_per_page as usize
-    }
-    fn min_score(&self) -> f32 {
-        self.0.min_score
-    }
-}
-
 impl TryFrom<ScoredParagraph<'_>> for DocumentScored {
     type Error = String;
     fn try_from(paragraph: ScoredParagraph) -> Result<Self, Self::Error> {
@@ -216,21 +220,21 @@ impl TryFrom<ScoredParagraph<'_>> for DocumentScored {
     }
 }
 
-impl Reader {
-    pub fn open(open_data_points: Vec<OpenDataPoint>, config: VectorConfig) -> VectorR<Reader> {
-        Ok(Reader {
+impl Searcher {
+    pub fn open(open_data_points: Vec<OpenSegment>, config: VectorConfig) -> VectorR<Searcher> {
+        Ok(Searcher {
             config,
-            open_data_points,
+            open_segments: open_data_points,
         })
     }
 
     pub fn space_usage(&self) -> usize {
-        self.open_data_points.iter().map(|dp| dp.space_usage()).sum()
+        self.open_segments.iter().map(|dp| dp.space_usage()).sum()
     }
 
-    pub fn _search(
+    fn _search(
         &self,
-        request: &dyn SearchRequest,
+        request: &SearchRequest,
         segment_filter: &Option<BooleanExpression<String>>,
     ) -> VectorR<Vec<ScoredParagraph>> {
         let normalized_query;
@@ -257,21 +261,21 @@ impl Reader {
         let min_score = request.min_score();
         let mut ffsv = Fssc::new(request.no_results(), with_duplicates);
 
-        for open_data_point in &self.open_data_points {
+        for open_segment in &self.open_segments {
             // Skip this segment if it doesn't match the segment filter
             if !segment_filter
                 .as_ref()
-                .is_none_or(|f| segment_matches(f, open_data_point.tags()))
+                .is_none_or(|f| segment_matches(f, open_segment.tags()))
             {
                 continue;
             }
             let partial_solution =
-                open_data_point.search(query, filter, with_duplicates, no_results, &self.config, min_score);
+                open_segment.search(query, filter, with_duplicates, no_results, &self.config, min_score);
 
             for candidate in partial_solution {
                 let addr = candidate.paragraph();
-                let paragraph = open_data_point.get_paragraph(addr);
-                let scored_paragraph = ScoredParagraph::new(open_data_point, addr, paragraph, candidate.score());
+                let paragraph = open_segment.get_paragraph(addr);
+                let scored_paragraph = ScoredParagraph::new(open_segment, addr, paragraph, candidate.score());
                 ffsv.add(scored_paragraph, candidate.vector());
             }
         }
@@ -310,9 +314,10 @@ impl Reader {
 
         let v = time.elapsed().as_millis();
         debug!("{id:?} - Searching: starts at {v} ms");
+        let search_request = &SearchRequest { request, formula };
         let result = match self.config.vector_cardinality {
-            VectorCardinality::Single => self.search_single_vector(request, formula)?,
-            VectorCardinality::Multi => self.search_multi_vector(request, formula)?,
+            VectorCardinality::Single => self._search(search_request, &request.segment_filtering_formula)?,
+            VectorCardinality::Multi => self.search_multi_vector(search_request)?,
         };
 
         let v = time.elapsed().as_millis();
@@ -337,13 +342,8 @@ impl Reader {
         })
     }
 
-    fn search_single_vector(&self, request: &VectorSearchRequest, formula: Formula) -> VectorR<Vec<ScoredParagraph>> {
-        let search_request = (request, formula);
-        self._search(&search_request, &request.segment_filtering_formula)
-    }
-
-    fn search_multi_vector(&self, request: &VectorSearchRequest, formula: Formula) -> VectorR<Vec<ScoredParagraph>> {
-        let search_vectors = extract_multi_vectors(&request.vector, &self.config.vector_type)?;
+    fn search_multi_vector(&self, search: &SearchRequest) -> VectorR<Vec<ScoredParagraph>> {
+        let search_vectors = extract_multi_vectors(&search.request.vector, &self.config.vector_type)?;
         let encoded_query = search_vectors
             .iter()
             .map(|v| self.config.vector_type.encode(v))
@@ -353,18 +353,21 @@ impl Reader {
         let results = search_vectors
             .into_par_iter()
             .map(|v| {
-                let mut subreq = request.clone();
+                let mut request = search.request.clone();
 
-                subreq.vector = v;
+                request.vector = v;
                 // We are OK with duplicate individual vectors. We always deduplicate by paragraphs anyway (NodeFilter.paragraphs)
-                subreq.with_duplicates = true;
+                request.with_duplicates = true;
                 // We don't care about min_score in this first pass, we apply min_score on top of maxsim similarity
-                subreq.min_score = f32::MIN;
+                request.min_score = f32::MIN;
                 // Request at least a few vectors, since the rerank may offer different results later
-                subreq.result_per_page = request.result_per_page.max(10);
+                request.result_per_page = search.request.result_per_page.max(10);
 
-                let search_request = (&subreq, formula.clone());
-                self._search(&search_request, &request.segment_filtering_formula)
+                let search_request = SearchRequest {
+                    request: &request,
+                    formula: search.formula.clone(),
+                };
+                self._search(&search_request, &search.request.segment_filtering_formula)
             })
             .collect::<Result<Vec<_>, _>>()?;
 
@@ -379,13 +382,13 @@ impl Reader {
             .into_par_iter()
             .filter_map(|mut sp| {
                 sp.score = maxsim_similarity(similarity_function, &encoded_query, &sp.vectors());
-                (sp.score() > request.min_score).then_some(sp)
+                (sp.score() > search.request.min_score).then_some(sp)
             })
             .collect::<Vec<_>>();
 
         // Select top_k
         results.sort_unstable_by(|a, b| b.score().partial_cmp(&a.score()).unwrap());
-        results.truncate(request.result_per_page as usize);
+        results.truncate(search.request.result_per_page as usize);
 
         Ok(results)
     }
@@ -402,8 +405,8 @@ mod tests {
 
     use super::*;
     use crate::config::{Similarity, VectorCardinality, VectorConfig, VectorType};
-    use crate::data_point;
     use crate::indexer::{ResourceWrapper, index_resource};
+    use crate::segment;
 
     #[test]
     fn test_key_prefix_search() -> anyhow::Result<()> {
@@ -474,7 +477,7 @@ mod tests {
 
         let segment = index_resource(ResourceWrapper::from(&resource), segment_path, &vsc)?.unwrap();
 
-        let reader = Reader::open(vec![data_point::open(segment, &vsc)?], vsc).unwrap();
+        let searcher = Searcher::open(vec![segment::open(segment, &vsc)?], vsc).unwrap();
         let request = VectorSearchRequest {
             id: "".to_string(),
             vector_set: "".to_string(),
@@ -487,13 +490,13 @@ mod tests {
             resource_id: uuid::Uuid::parse_str("6c5fc1f7a69042d4b24b7f18ea354b4a").unwrap(),
             field_id: "/f/field1".to_string(),
         };
-        let result = reader
+        let result = searcher
             .search(&request, &PrefilterResult::Some(vec![field_filter.clone()]))
             .unwrap();
         assert_eq!(result.documents.len(), 4);
 
         field_filter.field_id = "/f/field2".to_string();
-        let result = reader
+        let result = searcher
             .search(&request, &PrefilterResult::Some(vec![field_filter]))
             .unwrap();
         assert_eq!(result.documents.len(), 0);
@@ -570,7 +573,7 @@ mod tests {
 
         let segment = index_resource(ResourceWrapper::from(&resource), segment_path, &vsc)?.unwrap();
 
-        let reader = Reader::open(vec![data_point::open(segment, &vsc)?], vsc).unwrap();
+        let searcher = Searcher::open(vec![segment::open(segment, &vsc)?], vsc).unwrap();
         let request = VectorSearchRequest {
             id: "".to_string(),
             vector_set: "".to_string(),
@@ -579,7 +582,7 @@ mod tests {
             with_duplicates: true,
             ..Default::default()
         };
-        let result = reader.search(&request, &PrefilterResult::All).unwrap();
+        let result = searcher.search(&request, &PrefilterResult::All).unwrap();
         assert_eq!(result.documents.len(), 4);
 
         let request = VectorSearchRequest {
@@ -590,7 +593,7 @@ mod tests {
             with_duplicates: false,
             ..Default::default()
         };
-        let result = reader.search(&request, &PrefilterResult::All).unwrap();
+        let result = searcher.search(&request, &PrefilterResult::All).unwrap();
         assert_eq!(result.documents.len(), 3);
 
         // Check that min_score works
@@ -603,7 +606,7 @@ mod tests {
             min_score: 900.0,
             ..Default::default()
         };
-        let result = reader.search(&request, &PrefilterResult::All).unwrap();
+        let result = searcher.search(&request, &PrefilterResult::All).unwrap();
         assert_eq!(result.documents.len(), 0);
 
         let bad_request = VectorSearchRequest {
@@ -614,7 +617,7 @@ mod tests {
             with_duplicates: false,
             ..Default::default()
         };
-        assert!(reader.search(&bad_request, &PrefilterResult::All).is_err());
+        assert!(searcher.search(&bad_request, &PrefilterResult::All).is_err());
 
         Ok(())
     }
@@ -680,7 +683,7 @@ mod tests {
 
         let segment = index_resource(ResourceWrapper::from(&resource), segment_path, &vsc)?.unwrap();
 
-        let reader = Reader::open(vec![data_point::open(segment, &vsc)?], vsc).unwrap();
+        let searcher = Searcher::open(vec![segment::open(segment, &vsc)?], vsc).unwrap();
         let request = VectorSearchRequest {
             id: "".to_string(),
             vector_set: "".to_string(),
@@ -689,7 +692,7 @@ mod tests {
             with_duplicates: true,
             ..Default::default()
         };
-        let result = reader.search(&request, &PrefilterResult::All).unwrap();
+        let result = searcher.search(&request, &PrefilterResult::All).unwrap();
         assert_eq!(result.documents.len(), 2);
 
         let request = VectorSearchRequest {
@@ -700,7 +703,7 @@ mod tests {
             with_duplicates: false,
             ..Default::default()
         };
-        let result = reader.search(&request, &PrefilterResult::All).unwrap();
+        let result = searcher.search(&request, &PrefilterResult::All).unwrap();
         assert_eq!(result.documents.len(), 1);
 
         Ok(())