velesdb-core 1.7.0

High-performance vector database engine written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! HNSW Backend Trait Abstraction
//!
//! This module defines the `HnswBackend` trait that abstracts HNSW graph operations,
//! enabling:
//! - Mock backends for testing
//! - Custom backend implementations
//!
//! # Native Implementation (v1.0+)
//!
//! Uses `NativeNeighbour` from the native HNSW implementation.

use std::path::Path;

use super::native::NativeNeighbour as Neighbour;

/// Trait for HNSW backend operations.
///
/// This trait abstracts the core HNSW graph operations, allowing `HnswIndex`
/// to work with different backend implementations.
///
/// # Thread Safety
///
/// All implementations must be `Send + Sync` to support concurrent access
/// patterns used by `HnswIndex`.
///
/// # Example
///
/// ```rust,ignore
/// use velesdb_core::index::hnsw::HnswBackend;
///
/// fn search_with_backend<B: HnswBackend>(backend: &B, query: &[f32]) -> Vec<Neighbour> {
///     backend.search(query, 10, 100)
/// }
/// ```
// FT-1: Trait prepared for RF-2 (index.rs split). Will be used in production after RF-2.
#[allow(dead_code)]
pub trait HnswBackend: Send + Sync {
    /// Searches the HNSW graph and returns raw neighbors with distances.
    ///
    /// # Arguments
    ///
    /// * `query` - The query vector
    /// * `k` - Number of nearest neighbors to return
    /// * `ef_search` - Search expansion factor (higher = more accurate, slower)
    ///
    /// # Returns
    ///
    /// Vector of `Neighbour` structs containing (distance, index) pairs.
    fn search(&self, query: &[f32], k: usize, ef_search: usize) -> Vec<Neighbour>;

    /// Inserts a single vector into the HNSW graph.
    ///
    /// # Arguments
    ///
    /// * `data` - Tuple of (vector slice, internal index)
    fn insert(&self, data: (&[f32], usize));

    /// Batch parallel insert into the HNSW graph.
    ///
    /// Uses rayon internally for parallel insertion.
    ///
    /// # Arguments
    ///
    /// * `data` - Slice of (vector reference, internal index) pairs
    fn parallel_insert(&self, data: &[(&[f32], usize)]);

    /// Sets the index to searching mode after bulk insertions.
    ///
    /// This optimizes the graph structure for search queries.
    ///
    /// # Arguments
    ///
    /// * `mode` - `true` to enable searching mode, `false` to disable
    fn set_searching_mode(&mut self, mode: bool);

    /// Dumps the HNSW graph to files for persistence.
    ///
    /// # Arguments
    ///
    /// * `path` - Directory path for output files
    /// * `basename` - Base name for output files
    ///
    /// # Errors
    ///
    /// Returns `io::Error` if file operations fail.
    fn file_dump(&self, path: &Path, basename: &str) -> std::io::Result<()>;

    /// Transforms raw HNSW distance to the appropriate score based on metric type.
    ///
    /// Different distance metrics require different score transformations:
    /// - **Cosine**: `(1.0 - distance).clamp(0.0, 1.0)` (similarity in `[0,1]`)
    /// - **Euclidean**/**Hamming**/**Jaccard**: raw distance (lower is better)
    /// - **`DotProduct`**: `-distance` (`hnsw_rs` stores negated dot product)
    ///
    /// # Arguments
    ///
    /// * `raw_distance` - The raw distance value from HNSW search
    ///
    /// # Returns
    ///
    /// Transformed score appropriate for the metric type.
    fn transform_score(&self, raw_distance: f32) -> f32;
}

// Note: impl HnswBackend for HnswInner is in index.rs to avoid method name
// conflicts with the inherent impl methods.