graphlite 0.0.1

GraphLite - A lightweight ISO GQL Graph Database
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

// Copyright (c) 2024-2025 DeepGraph Inc.
// SPDX-License-Identifier: Apache-2.0
//
//! Error types for the indexing system

use crate::storage::persistent::types::StorageDriverError;
use crate::storage::StorageError;
use thiserror::Error;

/// Errors that can occur during index operations
#[derive(Error, Debug)]
pub enum IndexError {
    #[error("Index '{0}' already exists")]
    AlreadyExists(String),

    #[error("Index '{0}' not found")]
    NotFound(String),

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

    #[error("Dimension mismatch: expected {expected}, got {got}")]
    DimensionMismatch { expected: usize, got: usize },

    #[error("Serialization error: {0}")]
    SerializationError(#[from] bincode::Error),

    #[error("Storage error: {0}")]
    StorageError(#[from] StorageError),

    #[error("Storage driver error: {0}")]
    StorageDriverError(#[from] StorageDriverError),

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("Query error: {0}")]
    QueryError(String),

    #[error("Index is not ready for operations")]
    NotReady,

    #[error("Operation not supported by this index type")]
    UnsupportedOperation,

    #[error("Index maintenance failed: {0}")]
    MaintenanceError(String),

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

    #[error("Index corruption detected: {0}")]
    CorruptionError(String),
}

impl IndexError {
    /// Create a query error
    pub fn query<S: Into<String>>(msg: S) -> Self {
        Self::QueryError(msg.into())
    }

    /// Create a configuration error
    pub fn config<S: Into<String>>(msg: S) -> Self {
        Self::InvalidConfiguration(msg.into())
    }

    /// Create a maintenance error
    pub fn maintenance<S: Into<String>>(msg: S) -> Self {
        Self::MaintenanceError(msg.into())
    }

    /// Create an IO error
    pub fn io<S: Into<String>>(msg: S) -> Self {
        Self::IoError(std::io::Error::new(std::io::ErrorKind::Other, msg.into()))
    }

    /// Create a creation error (alias for config)
    pub fn creation<S: Into<String>>(msg: S) -> Self {
        Self::InvalidConfiguration(msg.into())
    }

    /// Create a serialization error
    pub fn serialization<S: Into<String>>(msg: S) -> Self {
        Self::IoError(std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            msg.into(),
        ))
    }

    /// Create a deserialization error
    pub fn deserialization<S: Into<String>>(msg: S) -> Self {
        Self::IoError(std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            msg.into(),
        ))
    }
}