Enum Error 

#[non_exhaustive]
pub enum Error {
    Io(Error),
    Decompress(CompressionType),
    InvalidVersion(u8),
    Unrecoverable,
    ChecksumMismatch {
        got: Checksum,
        expected: Checksum,
    },
    HeaderCrcMismatch {
        recomputed: u32,
        stored: u32,
    },
    InvalidTag((&'static str, u8)),
    InvalidTrailer,
    InvalidHeader(&'static str),
    DecompressedSizeTooLarge {
        declared: u64,
        limit: u64,
    },
    Utf8(Utf8Error),
    MergeOperator,
    Encrypt(&'static str),
    Decrypt(&'static str),
    ComparatorMismatch {
        stored: String,
        supplied: &'static str,
    },
    ZstdDictMismatch {
        expected: u32,
        got: Option<u32>,
    },
    RangeTombstoneDecode {
        field: &'static str,
        offset: u64,
    },
    MixedOperationBatch,
    RouteMismatch {
        expected: usize,
        found: usize,
    },
}

Represents errors that can occur in the LSM-tree

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Io(Error)

I/O error

Decompress(CompressionType)

Decompression failed

InvalidVersion(u8)

Invalid or unparsable data format version

Unrecoverable

Some required files could not be recovered from disk

ChecksumMismatch

Checksum mismatch

Fields

got: Checksum

Checksum of loaded block

expected: Checksum

Checksum that was saved in block header

HeaderCrcMismatch

Blob frame header CRC mismatch (V4 format). Distinct from ChecksumMismatch which covers data payload checksums.

Fields

recomputed: u32

CRC recomputed from header fields

stored: u32

CRC stored in the blob frame header

InvalidTag((&'static str, u8))

Invalid enum tag

InvalidTrailer

Invalid block trailer

InvalidHeader(&'static str)

Invalid block header

DecompressedSizeTooLarge

Data size (decompressed, on-disk, or requested) is invalid or exceeds a safety limit

Fields

declared: u64

Size associated with the data being processed. This may come from on-disk/in-memory metadata (e.g., header, block/value handle) or be derived from caller input (e.g., a requested key or value length), and may be zero, invalid, or over the configured limit.

limit: u64

Maximum allowed size for the data or request being processed

Utf8(Utf8Error)

UTF-8 error

MergeOperator

Merge operator failed.

No context payload — consistent with other unit variants (Unrecoverable, InvalidTrailer). Operators should log details before returning this error.

Encrypt(&'static str)

Encryption failed

Decrypt(&'static str)

Decryption failed

ComparatorMismatch

Comparator mismatch on tree reopen.

The tree was created with a comparator whose crate::UserComparator::name differs from the one supplied at reopen time.

Fields

stored: String

Comparator name persisted in the tree metadata.

supplied: &'static str

Comparator name supplied by the caller.

ZstdDictMismatch

Zstd dictionary required but not provided, or dict_id mismatch

Fields

expected: u32

Dictionary ID stored in the block/table metadata

got: Option<u32>

Dictionary ID provided by the caller (None if no dictionary supplied)

RangeTombstoneDecode

Range tombstone block decode failure.

Fields

field: &'static str

Which field or validation failed (e.g. start_len, start, seqno, interval)

offset: u64

Byte offset within the block to the start of the field whose decoding failed (captured before reading bytes for that field).

MixedOperationBatch

A WriteBatch contains mixed operation types (e.g. insert + remove) for the same user key.

Mixed ops at the same logical version are rejected because the memtable/skiplist ordering ties on (user_key, seqno) and does not include value_type as a tie-breaker. That would otherwise make equal-key entries with different operation types ambiguous to later reads and merges, yielding tie-break-dependent “last write wins” semantics.

RouteMismatch

Route-compatibility mismatch on reopen.

Recovery found fewer tables on disk than the manifest expects, and all missing tables are on levels not covered by any current level_routes. This typically means a previously configured route was removed, leaving its directory unreachable.

Re-adding the missing route(s) will usually resolve the error. If missing tables are on levels that are covered by a current route, recovery returns Unrecoverable instead (the SST files were genuinely lost).

Fields

expected: usize

Number of tables listed in the manifest.

found: usize

Number of tables actually found across all configured routes.

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.