slatedb 0.5.2

A cloud native embedded storage engine built on object 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

use std::any::Any;
use std::sync::Mutex;
use std::{path::PathBuf, sync::Arc};
use thiserror::Error;
use uuid::Uuid;

use crate::merge_operator::MergeOperatorError;

#[non_exhaustive]
#[derive(Clone, Debug, Error)]
pub enum SlateDBError {
    #[error("IO error: {0}")]
    IoError(#[from] Arc<std::io::Error>),

    #[error("Checksum mismatch")]
    ChecksumMismatch,

    #[error("Empty SSTable")]
    EmptySSTable,

    #[error("Empty block metadata")]
    EmptyBlockMeta,

    #[error("Empty block")]
    EmptyBlock,

    #[error("Empty manifest")]
    EmptyManifest,

    #[error("Object store error: {0}")]
    ObjectStoreError(#[from] Arc<object_store::Error>),

    #[error("Manifest file already exists")]
    ManifestVersionExists,

    #[error("Failed to find manifest with id {0}")]
    ManifestMissing(u64),

    #[error("Failed to find latest manifest")]
    LatestManifestMissing,

    #[error("Invalid deletion")]
    InvalidDeletion,

    #[error("Invalid sst error: {0}")]
    InvalidFlatbuffer(#[from] flatbuffers::InvalidFlatbuffer),

    #[error("Invalid DB state error")]
    InvalidDBState,

    #[error("Invalid Compaction")]
    InvalidCompaction,

    #[error(
        "Invalid clock tick, most be monotonic. Last tick: {}, Next tick: {}",
        last_tick,
        next_tick
    )]
    InvalidClockTick { last_tick: i64, next_tick: i64 },

    #[error("Detected newer DB client")]
    Fenced,

    #[error("Invalid cache part size bytes, it must be multiple of 1024 and greater than 0")]
    InvalidCachePartSize,

    #[error("Invalid Compression Codec")]
    InvalidCompressionCodec,

    #[error("Error Decompressing Block")]
    BlockDecompressionError,

    #[error("Error Compressing Block")]
    BlockCompressionError,

    #[error("Invalid RowFlags (encoded_bits: {encoded_bits:#b}, known_bits: {known_bits:#b}): {message}"
    )]
    InvalidRowFlags {
        encoded_bits: u8,
        known_bits: u8,
        message: String,
    },

    #[error("Error flushing immutable wals: channel closed")]
    WalFlushChannelError,

    #[error("Error flushing memtables: channel closed")]
    MemtableFlushChannelError,

    #[error("Error creating checkpoint: channel closed")]
    CheckpointChannelError,

    #[error("Read channel error: {0}")]
    ReadChannelError(#[from] tokio::sync::oneshot::error::RecvError),

    #[error("Iterator invalidated after unexpected error {0}")]
    InvalidatedIterator(#[from] Box<SlateDBError>),

    #[error("Invalid Argument: {msg}")]
    InvalidArgument { msg: String },

    #[error("background task panic'd")]
    // we need to wrap the panic args in an Arc so SlateDbError is Clone
    // we need to wrap the panic args in a mutex so that SlateDbError is Sync
    BackgroundTaskPanic(Arc<Mutex<Box<dyn Any + Send>>>),

    #[error("background task shutdown")]
    BackgroundTaskShutdown,

    #[error("Merge Operator error: {0}")]
    MergeOperatorError(#[from] MergeOperatorError),

    #[error("Checkpoint {0} missing")]
    CheckpointMissing(Uuid),

    #[error("Database already exists: {msg}")]
    DatabaseAlreadyExists { msg: String },

    #[error("Byte format version mismatch: expected {expected_version}, actual {actual_version}")]
    InvalidVersion {
        expected_version: u16,
        actual_version: u16,
    },
}

impl From<std::io::Error> for SlateDBError {
    fn from(value: std::io::Error) -> Self {
        Self::IoError(Arc::new(value))
    }
}

impl From<object_store::Error> for SlateDBError {
    fn from(value: object_store::Error) -> Self {
        Self::ObjectStoreError(Arc::new(value))
    }
}

/// Represents errors that can occur during the database configuration.
///
/// This enum encapsulates various error conditions that may arise
/// when parsing or processing database configuration options.
#[non_exhaustive]
#[derive(Error, Debug)]
pub enum DbOptionsError {
    #[error("Unknown configuration file format: {0}")]
    UnknownFormat(PathBuf),

    #[error("Invalid configuration format: {0}")]
    InvalidFormat(#[from] figment::Error),
}