manifoldb 0.1.4

A multi-paradigm embedded database for graph, vector, and relational data
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

//! Collection API errors.
//!
//! This module provides error types specific to the programmatic collection API.

use manifoldb_core::PointId;
use thiserror::Error;

use super::manager::CollectionError;

/// Errors that can occur during collection API operations.
#[derive(Debug, Error)]
pub enum ApiError {
    /// Collection operation failed.
    #[error(transparent)]
    Collection(#[from] CollectionError),

    /// Point not found in collection.
    #[error("point {point_id} not found in collection '{collection}'")]
    PointNotFound {
        /// The ID of the point that was not found.
        point_id: PointId,
        /// The name of the collection.
        collection: String,
    },

    /// Point already exists in collection.
    #[error("point {point_id} already exists in collection '{collection}'")]
    PointAlreadyExists {
        /// The ID of the point that already exists.
        point_id: PointId,
        /// The name of the collection.
        collection: String,
    },

    /// Vector dimension mismatch.
    #[error("vector '{vector_name}' dimension mismatch: expected {expected}, got {actual}")]
    DimensionMismatch {
        /// The name of the vector.
        vector_name: String,
        /// The expected dimension.
        expected: usize,
        /// The actual dimension.
        actual: usize,
    },

    /// Vector type mismatch.
    #[error("vector '{vector_name}' type mismatch: expected {expected}, got {actual}")]
    VectorTypeMismatch {
        /// The name of the vector.
        vector_name: String,
        /// The expected type.
        expected: String,
        /// The actual type.
        actual: String,
    },

    /// Named vector not found in collection schema.
    #[error("vector '{vector_name}' not found in collection '{collection}'")]
    VectorNotInSchema {
        /// The name of the vector.
        vector_name: String,
        /// The name of the collection.
        collection: String,
    },

    /// Search query vector is empty.
    #[error("search query vector cannot be empty")]
    EmptyQueryVector,

    /// Invalid filter expression.
    #[error("invalid filter: {0}")]
    InvalidFilter(String),

    /// Storage operation failed.
    #[error("storage error: {0}")]
    Storage(String),

    /// Serialization/deserialization failed.
    #[error("serialization error: {0}")]
    Serialization(String),

    /// Collection handle is invalid (collection was deleted).
    #[error("collection '{0}' no longer exists")]
    InvalidHandle(String),

    /// Search limit must be greater than zero.
    #[error("search limit must be greater than zero")]
    InvalidSearchLimit,

    /// Hybrid search requires multiple vectors.
    #[error("hybrid search requires at least two vector names")]
    InsufficientVectorsForHybrid,

    /// Invalid state for the requested operation.
    #[error("invalid state: {0}")]
    InvalidState(String),
}

impl From<manifoldb_vector::error::VectorError> for ApiError {
    fn from(err: manifoldb_vector::error::VectorError) -> Self {
        Self::Storage(err.to_string())
    }
}

/// A specialized `Result` type for collection API operations.
pub type ApiResult<T> = std::result::Result<T, ApiError>;

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

    #[test]
    fn test_error_display() {
        let err = ApiError::PointNotFound {
            point_id: PointId::new(42),
            collection: "documents".to_string(),
        };
        assert!(err.to_string().contains("42"));
        assert!(err.to_string().contains("documents"));

        let err = ApiError::DimensionMismatch {
            vector_name: "text".to_string(),
            expected: 768,
            actual: 384,
        };
        assert!(err.to_string().contains("768"));
        assert!(err.to_string().contains("384"));
    }
}