overgraph 0.11.0

An absurdly fast embedded graph database. Pure Rust, sub-microsecond reads.
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

use std::fmt;
use std::io;

use crate::types::{GqlSemanticErrorCode, SourceSpan};

#[derive(Debug)]
pub enum EngineError {
    IoError(io::Error),
    CorruptRecord(String),
    CorruptWal(String),
    SerializationError(String),
    ManifestError(String),
    DatabaseNotFound(String),
    DatabaseClosed,
    TxnConflict(String),
    TxnClosed,
    InvalidOperation(String),
    InvalidCursor {
        message: String,
    },
    CompactionCancelled,
    WalSyncFailed(String),
    GqlParse {
        message: String,
        span: SourceSpan,
    },
    GqlUnsupported {
        feature: String,
        message: String,
        span: SourceSpan,
    },
    GqlSemantic {
        code: GqlSemanticErrorCode,
        message: String,
        span: SourceSpan,
    },
    GqlParameter {
        name: String,
        expected: String,
        message: String,
        span: SourceSpan,
    },
}

impl fmt::Display for EngineError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            EngineError::IoError(e) => write!(f, "I/O error: {}", e),
            EngineError::CorruptRecord(msg) => write!(f, "corrupt record: {}", msg),
            EngineError::CorruptWal(msg) => write!(f, "corrupt WAL: {}", msg),
            EngineError::SerializationError(msg) => write!(f, "serialization error: {}", msg),
            EngineError::ManifestError(msg) => write!(f, "manifest error: {}", msg),
            EngineError::DatabaseNotFound(msg) => write!(f, "database not found: {}", msg),
            EngineError::DatabaseClosed => write!(f, "database is closed"),
            EngineError::TxnConflict(msg) => write!(f, "transaction conflict: {}", msg),
            EngineError::TxnClosed => write!(f, "transaction is closed"),
            EngineError::InvalidOperation(msg) => write!(f, "invalid operation: {}", msg),
            EngineError::InvalidCursor { message } => write!(f, "invalid cursor: {message}"),
            EngineError::CompactionCancelled => write!(f, "compaction cancelled by callback"),
            EngineError::WalSyncFailed(msg) => write!(f, "WAL sync failed: {}", msg),
            EngineError::GqlParse { message, span } => write!(
                f,
                "GQL parse error at line {}, column {}: {}",
                span.line, span.column, message
            ),
            EngineError::GqlUnsupported {
                feature,
                message,
                span,
            } => write!(
                f,
                "unsupported GQL feature '{}' at line {}, column {}: {}",
                feature, span.line, span.column, message
            ),
            EngineError::GqlSemantic {
                code,
                message,
                span,
            } => write!(
                f,
                "GQL semantic error {:?} at line {}, column {}: {}",
                code, span.line, span.column, message
            ),
            EngineError::GqlParameter {
                name,
                expected,
                message,
                span,
            } => write!(
                f,
                "GQL parameter error for ${} at line {}, column {} (expected {}): {}",
                name, span.line, span.column, expected, message
            ),
        }
    }
}

impl std::error::Error for EngineError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            EngineError::IoError(e) => Some(e),
            _ => None,
        }
    }
}

impl From<io::Error> for EngineError {
    fn from(e: io::Error) -> Self {
        EngineError::IoError(e)
    }
}