Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    Integrity,
    Validation,
    Vector,
    Temporal,
    Writer,
    Budget,
    Branch,
    Cancelled,
    Diagnostic,
    Engine,
    Migration,
    NotFound,
}

What kind of failure a DbError is, as a value (0.14.25, §14.1 C-3, D-242).

Why this exists

DbError is #[non_exhaustive] (D-207), so a downstream match needs a wildcard arm and can never be checked for completeness by the compiler. That was a deliberate trade — a ledger that will certainly add error variants after 1.0 cannot make each addition a major version — and its price was paid by callers, who lost the one guarantee that told them they had considered everything.

This buys part of it back, and the part it buys back is inside this crate: DbError::kind is one exhaustive match with no wildcard, so a variant added without a classification does not compile. The decision moves to the person adding the variant, at the line that needs it, which is exactly what crate::DbError’s binding lost in 0.13.34.

The taxonomy is not new

These twelve names are the hierarchy the Python bindings have published since they existed — seven groups a caller can catch as a set, and five failures that belong to no group. Inventing a second, Rust-only taxonomy here would be D-227’s finding again: a surface that spells its own version of a shared thing misses every repair made to the shared thing, quietly. binding_parity_tests pins the two spellings together.

What it is not

It is not a replacement for matching on DbError itself. A caller who needs the path a snapshot failed to write still matches the variant; this answers the coarser question — whose problem is this, and can I retry it — and, being Copy + Eq + Hash, answers it somewhere a DbError cannot go: a metrics key, a log field, a counter.

It is #[non_exhaustive] for the same reason DbError is. An exhaustive ErrorKind would give downstream its compile-time completeness back, and would do it by making a genuinely new category of failure a major version — which is the trap D-207 rejected by name, one level up: the category would then not get added, and the ledger would report the wrong kind rather than a new one.

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.

Integrity

The ledger’s own invariants: overlap, drift, a leaked archive session, a rebuild that failed or was interrupted. Something is wrong with the data or with a repair of it, and no retry fixes it.

Validation

The caller’s input was refused before anything was attempted.

Vector

Embeddings and the model registry.

Temporal

Time, snapshots and the archive — the bitemporal machinery.

Writer

The write actor could not take, keep, or answer the request.

Budget

A bound the caller set, or one the crate sets on the caller’s behalf.

Branch

Lineage: a branch that does not exist, cannot be forked, or may not be named from where the caller is standing.

Cancelled

A chunked bulk write stopped between chunks. Distinct from every other kind because part of it landed — see BulkInterrupted.

Diagnostic

The read-only diagnostic connection.

Engine

libSQL itself, passed through.

Migration

Schema migration.

NotFound

The thing asked for is not there.

Implementations

impl ErrorKind

pub fn as_str(self) -> &'static str

A stable name, for logs and metrics labels.

Stable in the sense that matters for a label: these strings are part of the public surface from 1.0 and will not be re-spelled. New kinds may appear, which is what #[non_exhaustive] says.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ErrorKind

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl Eq for ErrorKind

impl Hash for ErrorKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ErrorKind

fn cmp(&self, other: &ErrorKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for ErrorKind

fn partial_cmp(&self, other: &ErrorKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for ErrorKind