Enum ChiselError 

#[non_exhaustive]
pub enum ChiselError {
    InvalidHandle(u64),
    NoActiveTransaction,
    TransactionAlreadyActive,
    SavepointNotFound(String),
    DuplicateSavepoint(String),
    ReadOnlyMode,
    FileNotFound,
    InvalidRootName,
    RootNameTableFull,
    InvalidSuperblockCount {
        value: u32,
    },
    CacheFull {
        limit: usize,
    },
    SpillwayFull {
        limit_bytes: u64,
    },
    TransactionInProgress,
    TagMismatch {
        handle: u64,
        expected: u32,
        actual: u32,
    },
    IoError(Error),
    ChecksumMismatch {
        page_id: u64,
    },
    CorruptSuperblock {
        defects: Vec<SlotDefect>,
    },
    FileSizeMismatch {
        expected: u64,
        actual: u64,
    },
    LockFailed,
    UnsupportedFormatVersion {
        found: u32,
        expected: u32,
    },
    Poisoned,
    CorruptPage {
        page_id: u64,
    },
    InvalidPageId {
        page_id: u64,
    },
    UnsupportedPageSize {
        stored: u32,
        compiled: u32,
    },
    NoEncryptionKey,
    InvalidEncryptionKey,
    EncryptionNotSupported,
    NoFreeKeySlot,
    LastKeySlot,
    DecryptionFailed {
        page_id: u64,
    },
}

I36 (ISSUES.md, 2026-05-22): #[non_exhaustive] so adding a new error variant (a future operational signal, a new fatal-corruption flavor) is not a breaking change. External match arms over ChiselError need a _ => … catchall; the conventional path is if e.is_fatal() { … } else { … } which never enumerates variants and is therefore unaffected. The Display impl below is exhaustive — adding a variant still requires updating its prose.

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.

InvalidHandle(u64)

NoActiveTransaction

TransactionAlreadyActive

SavepointNotFound(String)

DuplicateSavepoint(String)

ReadOnlyMode

FileNotFound

InvalidRootName

RootNameTableFull

InvalidSuperblockCount

Fields

value: u32

CacheFull

Fields

limit: usize

SpillwayFull

Fields

limit_bytes: u64

TransactionInProgress

TagMismatch

Fields

handle: u64

expected: u32

actual: u32

IoError(Error)

ChecksumMismatch

Fields

page_id: u64

CorruptSuperblock

Fields

defects: Vec<SlotDefect>

FileSizeMismatch

Fields

expected: u64

actual: u64

LockFailed

UnsupportedFormatVersion

Fields

found: u32

expected: u32

Poisoned

CorruptPage

Fields

page_id: u64

InvalidPageId

Fields

page_id: u64

UnsupportedPageSize

Fields

stored: u32

compiled: u32

NoEncryptionKey

InvalidEncryptionKey

EncryptionNotSupported

NoFreeKeySlot

LastKeySlot

DecryptionFailed

Fields

page_id: u64

Implementations

impl ChiselError

pub fn is_fatal(&self) -> bool

True for error variants that indicate a violation of storage integrity or an unrecoverable I/O condition. Operational errors (caller mistakes like InvalidHandle) return false. Used by TransactionManager to decide whether an error should poison the manager — see ISSUES.md I1.

Poisoned itself is NOT fatal by this definition: it just means the manager is already dead, so seeing it again should not trigger a redundant state change.

INVARIANT: this match must list exactly the variants in the “Fatal” block of the enum above. Adding a fatal variant without adding it here silently leaves it classified operational, so the manager would keep serving requests over questionable on-disk state — a durability hole, not a compile error (the #[non_exhaustive] enum has no exhaustiveness check to catch the omission).

Trait Implementations

impl Debug for ChiselError

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

Formats the value using the given formatter.

impl Display for ChiselError

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

Formats the value using the given formatter.

impl Error for ChiselError

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

I41 (ISSUES.md, 2026-05-22): expose the wrapped io::Error from the IoError variant so error-chain walkers (anyhow::Error::root_cause, structured-logging adapters, eyre reports, std::error::Error::chain) can see the underlying cause. Returns None for every other variant because no other variant carries an inner error today. If a future variant grows an inner cause, extend this match.

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 ChiselError

fn from(e: Error) -> Self

Converts to this type from the input type.