oxirs-vec 0.2.4

Vector index abstractions for semantic similarity and AI-augmented querying
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

//! Core types for DiskANN

use serde::{Deserialize, Serialize};
use thiserror::Error;

/// Result type for DiskANN operations
pub type DiskAnnResult<T> = Result<T, DiskAnnError>;

/// Node ID in the Vamana graph
pub type NodeId = u32;

/// Vector ID (external identifier)
pub type VectorId = String;

/// Errors that can occur in DiskANN operations
#[derive(Debug, Error, Clone, Serialize, Deserialize)]
pub enum DiskAnnError {
    #[error("Vector not found: {id}")]
    VectorNotFound { id: VectorId },

    #[error("Invalid dimension: expected {expected}, got {actual}")]
    DimensionMismatch { expected: usize, actual: usize },

    #[error("Index not built")]
    IndexNotBuilt,

    #[error("IO error: {message}")]
    IoError { message: String },

    #[error("Serialization error: {message}")]
    SerializationError { message: String },

    #[error("Invalid configuration: {message}")]
    InvalidConfiguration { message: String },

    #[error("Graph error: {message}")]
    GraphError { message: String },

    #[error("Storage error: {message}")]
    StorageError { message: String },

    #[error("Memory limit exceeded: {message}")]
    MemoryLimitExceeded { message: String },

    #[error("Concurrent modification detected")]
    ConcurrentModification,

    #[error("Internal error: {message}")]
    InternalError { message: String },
}

impl From<std::io::Error> for DiskAnnError {
    fn from(err: std::io::Error) -> Self {
        DiskAnnError::IoError {
            message: err.to_string(),
        }
    }
}

impl From<oxicode::Error> for DiskAnnError {
    fn from(err: oxicode::Error) -> Self {
        DiskAnnError::SerializationError {
            message: err.to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display() {
        let err = DiskAnnError::VectorNotFound {
            id: "vec123".to_string(),
        };
        assert!(err.to_string().contains("vec123"));

        let err = DiskAnnError::DimensionMismatch {
            expected: 128,
            actual: 256,
        };
        assert!(err.to_string().contains("128"));
        assert!(err.to_string().contains("256"));
    }

    #[test]
    fn test_io_error_conversion() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
        let disk_err: DiskAnnError = io_err.into();
        assert!(matches!(disk_err, DiskAnnError::IoError { .. }));
    }
}