oasysdb 0.6.0

Fast embedded vector database with incremental HNSW indexing.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use std::fmt::{Display, Formatter, Result};

// Other error types.
use bincode::ErrorKind as BincodeError;
use sled::Error as SledError;
use std::error::Error as StandardError;
use std::io::Error as IOError;

#[cfg(feature = "py")]
use super::*;

#[cfg(feature = "py")]
use pyo3::exceptions::PyValueError;

#[cfg(feature = "gen")]
use reqwest::Error as ReqwestError;

#[cfg(feature = "json")]
use serde_json::Error as JSONError;

/// The type of error.
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ErrorKind {
    StandardError,
    IOError,
    DatabaseError,
    CollectionError,
    DistanceError,
    SerializationError,
    RequestError,
}

/// A custom error object with error type and message.
#[derive(Debug)]
pub struct Error {
    /// Type of error.
    pub kind: ErrorKind,
    /// Why the error occurred.
    pub message: String,
}

impl Error {
    /// Create a new error with the given message.
    pub fn new(kind: &ErrorKind, message: &str) -> Self {
        Self { kind: *kind, message: message.to_string() }
    }

    /// Returns the error message.
    pub fn message(&self) -> &str {
        &self.message
    }

    // Common errors.

    /// Creates error: The collection is not found.
    pub fn collection_not_found() -> Self {
        let message = "The collection is not found.";
        let kind = ErrorKind::DatabaseError;
        Error::new(&kind, message)
    }

    /// Creates error when the collection record limit is reached.
    pub fn collection_limit() -> Self {
        let max = u32::MAX;
        let brief = "The collection limit is reached.";
        let detail = format!("The max number of records is {max}.");

        let message = format!("{brief} {detail}");
        let kind = ErrorKind::CollectionError;
        Error::new(&kind, &message)
    }

    /// Creates error when vector record is not found.
    pub fn record_not_found() -> Self {
        let message = "The vector record is not found.";
        let kind = ErrorKind::CollectionError;
        Error::new(&kind, message)
    }

    /// Creates error when getting vector with invalid dimension.
    pub fn invalid_dimension(found: usize, expected: usize) -> Self {
        let brief = "Invalid vector dimension.";
        let detail = format!("Expected {expected}, found {found}.");

        let message = format!("{brief} {detail}");
        let kind = ErrorKind::CollectionError;
        Error::new(&kind, &message)
    }

    /// Error when the distance function is not supported.
    pub fn invalid_distance() -> Self {
        let message = "Distance function not supported.";
        let kind = ErrorKind::DistanceError;
        Error::new(&kind, message)
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter) -> Result {
        let kind = &self.kind;
        let message = &self.message;
        write!(f, "{kind:?}: {message}")
    }
}

// Interoperability with other error types.

impl StandardError for Error {}

impl From<Box<dyn StandardError>> for Error {
    fn from(err: Box<dyn StandardError>) -> Self {
        let kind = ErrorKind::StandardError;
        Error::new(&kind, &err.to_string())
    }
}

impl From<SledError> for Error {
    fn from(err: SledError) -> Self {
        let kind = ErrorKind::DatabaseError;
        Error::new(&kind, &err.to_string())
    }
}

impl From<IOError> for Error {
    fn from(err: IOError) -> Self {
        let kind = ErrorKind::IOError;
        Error::new(&kind, &err.to_string())
    }
}

impl From<Box<BincodeError>> for Error {
    fn from(err: Box<BincodeError>) -> Self {
        let kind = ErrorKind::SerializationError;
        Error::new(&kind, &err.to_string())
    }
}

#[cfg(feature = "py")]
impl From<Error> for PyErr {
    fn from(err: Error) -> Self {
        PyErr::new::<PyValueError, String>(err.message)
    }
}

#[cfg(feature = "gen")]
impl From<ReqwestError> for Error {
    fn from(err: ReqwestError) -> Self {
        let kind = ErrorKind::RequestError;
        Error::new(&kind, &err.to_string())
    }
}

#[cfg(feature = "json")]
impl From<JSONError> for Error {
    fn from(err: JSONError) -> Self {
        let kind = ErrorKind::SerializationError;
        Error::new(&kind, &err.to_string())
    }
}