Method search

nodedb-vector/src/collection/search.rs:123–207

Search across all segments, merging results by distance.

(&self, query: &[f32], top_k: usize, ef: usize)

impl VectorCollection {
    /// Search across all segments, merging results by distance.
    pub fn search(&self, query: &[f32], top_k: usize, ef: usize) -> Vec<SearchResult> {
        // Codec-dispatch fast path: if a collection-level HnswCodecIndex has
        // been built (RaBitQ or BBQ), use it exclusively for sealed-segment
        // results and fall back to the growing/building flat segments only.
        if let Some(ref dispatch) = self.codec_dispatch {
            let mut all: Vec<SearchResult> = Vec::new();

            let codec_results = dispatch.search(query, top_k, ef);
            for r in codec_results {
                all.push(SearchResult {
                    id: r.id,
                    distance: r.distance,
                });
            }

            // Growing segment (brute-force, not yet in codec index).
            let growing_results = self.growing.search(query, top_k);
            for mut r in growing_results {
                r.id += self.growing_base_id;
                all.push(r);
            }

            // Building segments (brute-force while codec index rebuilds).
            for seg in &self.building {
                let results = seg.flat.search(query, top_k);
                for mut r in results {
                    r.id += seg.base_id;
                    all.push(r);
                }
            }

            all.sort_by(|a, b| {
                a.distance
                    .partial_cmp(&b.distance)
                    .unwrap_or(std::cmp::Ordering::Equal)
            });
            all.truncate(top_k);
            return all;
        }

        let mut all: Vec<SearchResult> = Vec::new();

        // Search growing segment (brute-force).
        let growing_results = self.growing.search(query, top_k);
        for mut r in growing_results {
            r.id += self.growing_base_id;
            all.push(r);
        }

        // Search sealed segments.
        for seg in &self.sealed {
            let results = if seg.pq.is_some() || seg.sq8.is_some() {
                match quantized_search(seg, query, top_k, ef, self.params.metric) {
                    Ok(r) => r,
                    Err(e) => {
                        tracing::warn!(error = %e, "quantized_search budget exhausted; skipping segment");
                        seg.index.search(query, top_k, ef)
                    }