feoxdb 0.5.0

Iron-oxide fast embedded database - nanosecond-level key-value storage
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

use std::io;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum FeoxError {
    #[error(
        "Invalid key size: key must be 1-{} bytes",
        crate::constants::MAX_KEY_SIZE
    )]
    InvalidKeySize,

    #[error(
        "Invalid value size: value must be 1-{} bytes",
        crate::constants::MAX_VALUE_SIZE
    )]
    InvalidValueSize,

    #[error("Key not found")]
    KeyNotFound,

    #[error("Database is full")]
    DatabaseFull,

    #[error("Out of memory")]
    OutOfMemory,

    #[error("Timestamp is older than existing record")]
    OlderTimestamp,

    #[error("Invalid numeric value")]
    InvalidNumericValue,

    #[error("Numeric overflow")]
    NumericOverflow,

    #[error("Invalid range: start key must be <= end key")]
    InvalidRange,

    #[error("Multi-tenant mode is disabled")]
    MultiTenantDisabled,

    #[error("No device configured")]
    NoDevice,

    #[error("Invalid metadata")]
    InvalidMetadata,

    #[error("Corrupted record")]
    CorruptedRecord,

    #[error("Invalid record")]
    InvalidRecord,

    #[error("Invalid device")]
    InvalidDevice,

    #[error("Invalid operation")]
    InvalidOperation,

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

    #[error("System error: {0}")]
    SystemError(i32),

    #[error("JSON patch error: {0}")]
    JsonPatchError(String),

    #[error("Allocation failed")]
    AllocationFailed,

    #[error("Lock poisoned")]
    LockPoisoned,

    #[error("Channel closed")]
    ChannelClosed,

    #[error("Channel error")]
    ChannelError,

    #[error("System shutting down")]
    ShuttingDown,

    #[error("Operation timed out")]
    Timeout,

    #[error("Not implemented")]
    NotImplemented,

    #[error("Unsupported on this platform")]
    Unsupported,

    #[error("Size mismatch: expected {expected} bytes, got {actual} bytes")]
    SizeMismatch { expected: usize, actual: usize },

    #[error("Invalid argument")]
    InvalidArgument,

    #[error("Out of space")]
    OutOfSpace,

    #[error("Corrupted data")]
    CorruptedData,

    #[error("Duplicate key")]
    DuplicateKey,

    #[error("TTL feature is not enabled")]
    TtlNotEnabled,
}

pub type Result<T> = std::result::Result<T, FeoxError>;

impl From<i32> for FeoxError {
    fn from(errno: i32) -> Self {
        match errno {
            2 => FeoxError::KeyNotFound,
            12 => FeoxError::OutOfMemory,
            17 => FeoxError::OlderTimestamp,
            22 => FeoxError::InvalidKeySize,
            28 => FeoxError::DatabaseFull,
            75 => FeoxError::NumericOverflow,
            90 => FeoxError::SizeMismatch {
                expected: 0,
                actual: 0,
            },
            _ => FeoxError::SystemError(errno),
        }
    }
}

impl FeoxError {
    pub fn errno(&self) -> i32 {
        match self {
            FeoxError::InvalidKeySize | FeoxError::InvalidValueSize => crate::constants::EINVAL,
            FeoxError::KeyNotFound => crate::constants::ENOENT,
            FeoxError::DatabaseFull => crate::constants::ENOSPC,
            FeoxError::OutOfMemory | FeoxError::AllocationFailed => crate::constants::ENOMEM,
            FeoxError::OlderTimestamp => crate::constants::EEXIST,
            FeoxError::NumericOverflow => crate::constants::EOVERFLOW,
            FeoxError::InvalidRange => crate::constants::EINVAL,
            FeoxError::MultiTenantDisabled => crate::constants::ENODEV,
            FeoxError::NoDevice => crate::constants::ENODEV,
            FeoxError::InvalidMetadata | FeoxError::CorruptedRecord => crate::constants::EIO,
            FeoxError::IoError(_) => crate::constants::EIO,
            FeoxError::SystemError(e) => *e,
            FeoxError::Timeout => crate::constants::EAGAIN,
            FeoxError::SizeMismatch { .. } => crate::constants::EMSGSIZE,
            _ => crate::constants::EIO,
        }
    }
}