Enum StoreError 

pub enum StoreError {
    CascadeCycle {
        cycle: Vec<String>,
    },
    Io {
        path: PathBuf,
        source: Error,
    },
    NotDirectory {
        path: PathBuf,
    },
    StoreBusy {
        path: PathBuf,
    },
    Lock(StoreLockError),
    Durability(DurabilityPolicyError),
    Kernel(KernelInitError),
    Manifest(ManifestError),
    Tokenizer(TokenizerError),
    EpochMismatch(EpochMismatch),
    EpochUndeclared,
    EpochUnstamped,
    SchemaMismatch {
        persisted: Schema,
        declared: Schema,
    },
    ScanStale {
        cursor_generation: u64,
        current_generation: u64,
    },
    InvalidScan {
        detail: String,
    },
    GroupLimitExceeded {
        limit: usize,
    },
    Segment(SegmentError),
    DuplicateLiveDocument {
        doc_id: DocId,
    },
    GraphUnavailable {
        segment_id: SegmentId,
    },
    Wal(WalReadError),
    WalRecovery(WalRecoveryError),
    WalRecord {
        seq: LogSeq,
        source: VisibleRecordError,
    },
    WalMutation {
        seq: LogSeq,
        op: u16,
        source: PayloadError,
    },
    WalRevisionOrder {
        seq: LogSeq,
        doc_id: DocId,
        current: Revision,
        attempted: Revision,
    },
    UnsupportedWalMutation {
        seq: LogSeq,
        op: u16,
    },
    WalVector {
        seq: LogSeq,
        source: QuantError,
    },
    WalWrite(WalWriteError),
    WalRetire(WalRetireError),
    Statistics {
        component: &'static str,
        source: Error,
    },
    BudgetExceeded {
        needed: u64,
        budget: u64,
        component: &'static str,
    },
    RecoveryLimit {
        component: &'static str,
    },
    AllocationFailed {
        needed: u64,
        component: &'static str,
    },
    DimensionMismatch {
        expected: usize,
        actual: usize,
    },
    ActiveRowOverflow,
    EmptyActiveSegment,
    SealCancelled,
    ReadOnly,
    SealedTombstoneRecoveryRequired,
    ForeignPreparedSegment,
    GenerationOverflow,
    ConcurrentActiveMutation {
        expected_generation: u64,
        actual_generation: u64,
    },
    PartitionBytesOverflow,
    PurgeRecovery {
        detail: String,
    },
    Closing,
    Closed,
    ReadCancelled,
    BackgroundStart {
        source: Error,
    },
    BackgroundHandshake,
    BackgroundThreadPanicked,
    QueryPoolStart {
        source: Error,
    },
    QueryPoolHandshake,
    QueryPoolThreadPanicked,
    QueryPoolCapacity {
        source: String,
    },
    Synchronization {
        component: &'static str,
    },
    NativeGraphDirectory {
        path: PathBuf,
    },
    SnapshotTarget {
        path: PathBuf,
        reason: SnapshotTargetReason,
    },
    SnapshotPin {
        detail: &'static str,
    },
    SnapshotPurgePending,
    SnapshotViewsOpen,
}

An open, lifecycle, or close operation was rejected.

Variants

CascadeCycle

A declaration would introduce a namespace ownership cycle.

Fields

cycle: Vec<String>

Closed path of namespace names, in traversal order.

Io

A filesystem operation failed for the named store path.

Fields

path: PathBuf

Store path being opened.

source: Error

Underlying filesystem failure.

NotDirectory

The supplied path exists but is not a directory.

Fields

path: PathBuf

Invalid store path.

StoreBusy

Another writer owns the store’s process or kernel lock.

Fields

path: PathBuf

Busy store directory.

Lock(StoreLockError)

The writer lock could not be opened or acquired.

Durability(DurabilityPolicyError)

The selected durability mode/tier is unsupported.

Kernel(KernelInitError)

Runtime kernel selection or an explicit override was invalid.

Manifest(ManifestError)

The committed manifest could not be loaded or validated.

Tokenizer(TokenizerError)

The selected tokenizer configuration could not be compiled.

EpochMismatch(EpochMismatch)

The caller’s declared interpretation differs from the persisted one.

EpochUndeclared

Persisted bytes name an epoch but the caller did not declare one.

EpochUnstamped

A pre-epoch manifest cannot be retroactively assigned an identity.

SchemaMismatch

A schema declaration on reopen differed from the committed schema.

Fields

persisted: Schema

Schema already committed in the manifest.

declared: Schema

Schema supplied by the opening caller.

ScanStale

A scan continuation names a different published generation.

Fields

cursor_generation: u64

Generation encoded by the caller’s continuation.

current_generation: u64

Generation pinned by this scan call.

InvalidScan

A document-scan request or predicate is invalid.

Fields

detail: String

Precise validation failure.

GroupLimitExceeded

A grouped count found more distinct values than its group limit.

Fields

limit: usize

Group limit supplied by the caller.

Segment(SegmentError)

A referenced immutable segment could not be mapped or validated.

DuplicateLiveDocument

More than one live row carried the same stable document id.

Fields

doc_id: DocId

Stable id whose uniqueness invariant was violated.

GraphUnavailable

The caller selected graph traversal for a sealed segment without a graph.

Fields

segment_id: SegmentId

Immutable segment that cannot satisfy the explicit graph-tier request.

Wal(WalReadError)

The checked durable WAL prefix could not be opened.

WalRecovery(WalRecoveryError)

A non-empty WAL did not replay through a clean end boundary.

WalRecord

A replayed record’s retained encoded bytes could not be decoded.

Fields

seq: LogSeq

Sequence assigned to the invalid retained record.

source: VisibleRecordError

Checked record-access failure.

WalMutation

A checksummed WAL mutation payload violated its versioned contract.

Fields

seq: LogSeq

Sequence assigned to the invalid mutation.

op: u16

Persisted operation identifier.

source: PayloadError

Typed mutation-payload failure.

WalRevisionOrder

A recovered upsert would make one document’s revision non-monotonic.

Fields

seq: LogSeq

Sequence assigned to the invalid upsert.

doc_id: DocId

Document whose recovered history is invalid.

current: Revision

Revision already rebuilt from the trusted prefix.

attempted: Revision

Revision carried by this record.

UnsupportedWalMutation

A valid mutation kind has no active-segment application path yet.

Fields

seq: LogSeq

Sequence assigned to the unsupported mutation.

op: u16

Persisted operation identifier.

WalVector

A recovered vector passed payload validation but failed quantization.

Fields

seq: LogSeq

Sequence assigned to the invalid vector mutation.

source: QuantError

Typed vector-contract failure.

WalWrite(WalWriteError)

The store-owned WAL writer could not be created or advanced.

WalRetire(WalRetireError)

Retained WAL visibility could not be released through a committed seal.

Statistics

A kernel probe needed for an exact statistics snapshot failed.

Fields

component: &'static str

Counter or residency component that could not be read.

source: Error

Underlying operating-system failure.

BudgetExceeded

An accounted allocation would exceed a configured ceiling.

Fields

needed: u64

Total live bytes that would be needed if the operation proceeded.

budget: u64

Configured ceiling in bytes.

component: &'static str

Engine component requesting the allocation.

RecoveryLimit

Native recovery exhausted a checked work or scratch allowance.

Fields

component: &'static str

Recovery resource whose allowance was exhausted.

AllocationFailed

The allocator rejected a checked reservation without aborting.

Fields

needed: u64

Exact requested bytes.

component: &'static str

Engine component requesting the allocation.

DimensionMismatch

An active vector did not match the collection’s established dimension.

Fields

expected: usize

Established active dimension.

actual: usize

Supplied vector dimension.

ActiveRowOverflow

The active segment exceeded its dense u32 row address space.

EmptyActiveSegment

An explicit seal was requested without any active rows.

SealCancelled

Caller cancellation stopped a seal before its manifest commit point.

ReadOnly

A write-only lifecycle operation was requested from a read-only handle.

SealedTombstoneRecoveryRequired

WAL replay requires sealed tombstone repair that a read-only open cannot publish.

ForeignPreparedSegment

A prepared segment was accounted to a different store handle.

GenerationOverflow

The current snapshot generation cannot be incremented.

ConcurrentActiveMutation

The active generation changed while a serialized writer prepared a commit.

Fields

expected_generation: u64

Generation snapshotted before preparing the mutation.

actual_generation: u64

Generation found when the writer re-acquired the active state.

PartitionBytesOverflow

Exact reclaimed-byte reporting overflowed its u64 contract.

PurgeRecovery

A durable physical-purge intent could not be resumed during open.

Fields

detail: String

Typed purge failure rendered without discarding its actionable values.

Closing

A new operation raced with close after admissions stopped.

Closed

The handle has completed teardown.

ReadCancelled

Close cancelled an admitted read after its drain grace period elapsed.

BackgroundStart

The lifecycle background thread could not be created.

Fields

source: Error

Operating-system thread creation failure.

BackgroundHandshake

The lifecycle background thread exited before its startup handshake.

BackgroundThreadPanicked

The lifecycle background thread panicked before close joined it.

QueryPoolStart

A persistent query worker thread could not be created.

Fields

source: Error

Operating-system thread creation failure.

QueryPoolHandshake

A persistent query worker exited before its startup handshake.

QueryPoolThreadPanicked

A persistent query worker panicked before close joined it.

QueryPoolCapacity

The operating system could not report a usable query-worker count.

Fields

source: String

CPU-topology failure text.

Synchronization

A lifecycle synchronization primitive was poisoned.

Fields

component: &'static str

Synchronization component that rejected the operation.

NativeGraphDirectory

The directory holds a native graph store, which this legacy store cannot open. Nothing in the directory was changed.

Fields

path: PathBuf

Native graph store directory.

SnapshotTarget

A snapshot target cannot receive a snapshot. Nothing was written.

Fields

path: PathBuf

Target path as the caller supplied it.

reason: SnapshotTargetReason

Why the target was rejected.

SnapshotPin

The state pinned for a snapshot failed a consistency check. Nothing was published.

Fields

detail: &'static str

The violated pin invariant.

SnapshotPurgePending

A physical purge is pending; a snapshot would copy bytes it must remove. Await the purge, then snapshot. Nothing was written.

SnapshotViewsOpen

A physical removal must wait for open in-place snapshots to close.

Implementations

impl StoreError

pub fn kind(&self) -> StoreErrorKind

Classifies this error; see StoreErrorKind.

Trait Implementations

impl Debug for StoreError

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

Formats the value using the given formatter.

impl Display for StoreError

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

Formats the value using the given formatter.

impl Error for StoreError

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<StoreError> for EpochTransitionError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for GraphBuildError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for ConsolidateError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for RefinementError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for DeleteMatchingError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for PurgeError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for IngestError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<StoreError> for StoreLexicalError

fn from(error: StoreError) -> Self

Converts to this type from the input type.