Enum DbError 

pub enum DbError {
    ClaimPending,
    NoClaim,
    ProviderRequestRunning,
    ClaimUnsettled,
    ClaimNumberExhausted,
    WriteNumberExhausted,
    InvalidClaimCoverage,
    SequenceGap {
        applied: u64,
        received: Slot,
    },
    WriteWaiting(WriteWait),
    StateEncoding(Error),
    StatePersistence(Arc<DbError>),
    RollbackFailed,
    CheckpointFailed(Arc<DbError>),
    StatisticsFailed(Arc<DbError>),
    WallTimer(WallTimerError),
    UpkeepThread(Error),
    ClaimRead(Error),
    StoreClosed,
    Shutdown(Shutdown),
    Bug(Bug),
    StoreFailed(Bug),
    Sqlite(Error),
    DamagedDatabase,
    Invariant {
        what: &'static str,
    },
    StoreSettingsMismatch {
        store: StoreId,
    },
    Schema(SchemaError),
    PreparedElsewhere,
    DeviceOnlyUnreferenced {
        file: FileId,
    },
    PinChanged {
        file: FileId,
    },
    StepFailed,
    StatementFailed,
    InternalTable {
        table: String,
    },
    TriggerTarget {
        trigger: String,
        table: String,
    },
    SyncedTableInBulkWrite {
        table: String,
    },
    TransactionEnded,
    StatementForbidden {
        operation: &'static str,
    },
    WalUnavailable {
        mode: String,
    },
    SqliteSettingOutOfRange {
        setting: &'static str,
        maximum: u64,
    },
    ReservedCollation {
        name: String,
    },
    DuplicateCollation {
        name: String,
    },
    ReservedFunction {
        name: String,
    },
    DuplicateFunction {
        name: String,
    },
    ConstantFunction {
        name: String,
    },
    VersionChangeRefused {
        name: String,
        table: String,
    },
    VersionNotRebuilt {
        name: String,
        built: u32,
        registered: u32,
    },
    ClockOutOfRange,
    InputBudgetExceeded {
        required: u64,
        maximum: u64,
    },
    TooLarge {
        field: &'static str,
        actual: u64,
        maximum: u64,
    },
    ReferenceAudience {
        table: String,
        key: RowKey,
        column: String,
    },
    DeletedCircle(CircleId),
    NotInCircle(CircleId),
    AudienceReloading(Audience),
    NotOwner {
        table: String,
        key: RowKey,
        owner: MemberId,
    },
    InvalidForeignKeyEffect {
        table: String,
        key: RowKey,
    },
    KeyNotUuid {
        table: String,
        key: RowKey,
    },
    InvalidAudience {
        table: String,
        key: RowKey,
    },
    InvalidWrite {
        write: WriteId,
        error: MergeError,
    },
    MissingWriteSources(Vec<ChangeId>),
    WriteFormat(Error),
    MigrationKindMismatch {
        version: u32,
    },
    MigrationReference {
        table: String,
        column: String,
    },
    MigrationDuplicateColumn {
        table: String,
        column: String,
    },
    MigrationColumnMissing {
        table: String,
        column: String,
    },
    MigrationPrimaryKeyMissing {
        table: String,
    },
    MigrationKeyArity {
        table: String,
        expected: usize,
        actual: usize,
    },
    MigrationTableMissing {
        table: String,
    },
    MigrationReferenceCollision {
        table: String,
        reference: ForeignKey,
    },
    DismissedRowChanged {
        table: String,
        key: RowKey,
    },
    FileWriteOnce {
        table: String,
        key: RowKey,
    },
    UserFileMissing {
        path: PathBuf,
    },
    UserFileChanged {
        path: PathBuf,
    },
    UndeclaredNamespace {
        namespace: String,
    },
    NamespaceKind {
        namespace: String,
        kind: Provenance,
    },
    FileNameReused {
        name: String,
    },
    FileUnreferenced {
        namespace: String,
        file: FileId,
    },
    FileUnknown {
        table: String,
        column: String,
        file: String,
    },
    FileAbsent {
        file: FileId,
    },
    NotThisDevice {
        file: FileId,
    },
    NotDeviceOnlyHere {
        file: FileId,
    },
    FileInMove {
        file: FileId,
        id: MoveId,
    },
    BoundFileTooLarge {
        table: String,
        column: String,
        size: u64,
        limit: u64,
    },
    DeviceOnly {
        file: FileId,
    },
    MoveUnknown {
        id: MoveId,
    },
    MoveFinished {
        id: MoveId,
    },
    MoveBound {
        id: MoveId,
    },
    NotInCloud {
        file: FileId,
    },
    NoLongerStored {
        file: FileId,
    },
    CopyPathTaken {
        path: PathBuf,
    },
    Disk(FileError),
    FileKey(CryptoError),
    Lock(StoreLockError),
    FileCleanup {
        write: Result<(), Box<DbError>>,
        failures: Vec<DbError>,
    },
    StagingCleanup {
        operation: Box<DbError>,
        cleanup: Box<DbError>,
    },
    OperationChanged(OperationId),
    OperationRunning(OperationId),
    OperationUnknown(OperationId),
    MemberKeysChanging,
    CaptureChanged,
    RaiseWaiting,
    Snapshot(SnapshotError),
    Closing {
        failures: Vec<DbError>,
    },
    Rollback {
        operation: Box<DbError>,
        rollback: Error,
    },
}

A failed database call or a write the database refuses (§4, §9, §15, §17).

Variants

ClaimPending

Another claim must settle before this device reserves a new number.

NoClaim

No current claim exists for this operation.

ProviderRequestRunning

A request to a provider account is between its target being fixed and its reply, so a revocation queued now could precede the grants it must follow (§20.9). The call is made again once the request ends.

ClaimUnsettled

Uncertain publication cannot be abandoned or resealed; a landed writes batch cannot finish until its consumed state has committed.

ClaimNumberExhausted

The installation has exhausted its claim-number representation.

WriteNumberExhausted

This installation has exhausted its positive original-write identities.

InvalidClaimCoverage

The supplied floor evidence does not cover the attempted slot.

SequenceGap

Slot application must extend the previously committed prefix.

Fields

applied: u64

Previously committed coverage.

received: Slot

The received slot.

WriteWaiting(WriteWait)

A slot’s readable original awaits an external prerequisite.

StateEncoding(Error)

A pending record, its subject, the sync status or an operation’s data could not be encoded, or a stored pending record could not be decoded as the requested record type (E5).

StatePersistence(Arc<DbError>)

Saving pending state or the sync status failed. The call that lost the update and every later call and live query fail with this same cause until reopened (E5).

RollbackFailed

An earlier call’s rollback failed, so a connection may still be inside that transaction, holding its uncommitted changes or its old snapshot; this handle, read-only or not, refuses calls until reopened (§4).

CheckpointFailed(Arc<DbError>)

One of coven’s own WAL checkpoints failed with this cause, other than on a busy or locked database, so the store’s checkpointing stopped. Rather than stay open while its WAL grows without bound, this handle and every live query fail with this same cause until reopened (§4).

StatisticsFailed(Arc<DbError>)

Checking or gathering the query planner’s statistics while the store stays open failed with this cause, other than on a busy or locked database, so keeping them stopped. Rather than stay open while the planner plans with statistics that no longer hold, this handle and every live query fail with this same cause until reopened (§4).

WallTimer(WallTimerError)

The handle’s clock could not wait for an open invite’s expiry, so the invite would outlive its lifetime. Rather than stay open without writing expiries, this handle and every live query fail with this same cause until reopened, and opening writes each expiry already past (§13.2).

UpkeepThread(Error)

The system refused a thread of coven’s upkeep, the one that checkpoints a WAL or the one that keeps the planner’s statistics, so the store did not open (§4).

ClaimRead(Error)

Reading a claim’s sealed bytes to retain them failed, and the claim’s transaction did not commit (§11).

StoreClosed

This handle or a clone has closed the store (E1).

Shutdown(Shutdown)

The call’s runtime is shutting down and dropped its work (E15). A call the blocking pool dropped unstarted changed nothing (ShutdownOutcome::NotRun); closing, which runs as its own task, may have closed some connections (ShutdownOutcome::Unknown).

Bug(Bug)

The call’s work panicked: a bug in coven or in the app’s callback, which the caller reports (E15). A write that panicked rolled back, and the bytes it released or staged are removed as after any failed write.

StoreFailed(Bug)

An earlier bug may have left this handle’s state wrong, so the handle failed with it, and every call and live query fails with it until the store is reopened (E15). The call whose work hit the bug returned it as Bug, or the store’s bug sink heard it, so the app shows this and doesn’t report it again.

Sqlite(Error)

SQLite refused or failed a statement, preserving its error.

DamagedDatabase

A statement met damage SQLite reports (SQLITE_CORRUPT, SQLITE_NOTADB), decoding stored facts found damage (§19.3), or a snapshot’s staged records differ from a second staging’s (§19.1).

Invariant

Coven’s own code broke a rule it relies on, such as a caller’s contract or a step its state machine cannot reach: a bug, not damage. Sync reports it as Failed(LocalFailure::Bug) (§19.1).

Fields

what: &'static str

The broken rule.

StoreSettingsMismatch

Directory settings disagree with a store’s creation entry (§10).

Fields

store: StoreId

The id in the creation entry.

Schema(SchemaError)

A synced table declaration or schema is invalid.

PreparedElsewhere

A write was given files staged, or a pin prepared, in another open store, or in this one before it closed: the copies they name aren’t reserved here (§17.3, §17.8).

DeviceOnlyUnreferenced

A write made a file device-only and also removed its last reference, so the copy kept as its original would name no file (§17.3). Nothing committed.

Fields

file: FileId

The file.

PinChanged

A pin prepared over a whole copy already kept found that copy gone when its write committed it, evicted or unpinned since: nothing was pinned, and preparing again downloads it. A prepare whose partial download the app’s unpin ended meanwhile fails with it too (§17.8).

Fields

file: FileId

The file.

StepFailed

One of coven’s steps in this write failed, and the write’s closure went on to return success: the write rolls back, since a failed step may have made only part of its change (§4).

StatementFailed

One of the app’s statements in this write failed, and the write’s closure went on to return success: the write rolls back, since SQLite may have kept part of the statement’s change or undone rows coven saw it change (§4).

InternalTable

App SQL read, changed or defined one of coven’s internal objects (§4).

Fields

table: String

The reserved object.

TriggerTarget

A local trigger wrote a synced table or a shared trigger a local one (§9.4).

Fields

trigger: String

The trigger doing the write.

table: String

The target table.

SyncedTableInBulkWrite

A bulk write’s statement, or a trigger or foreign-key action it would run, writes a synced table (§4, E3). Nothing committed.

Fields

table: String

The synced table.

TransactionEnded

SQLite rolled the owned transaction back itself, so it can’t go on (E3, E13).

StatementForbidden

App SQL tried transaction control, a PRAGMA, ATTACH, loading an extension, changing a hidden rowid, or changing the schema outside a migration (§4, E13).

Fields

operation: &'static str

The refused operation.

WalUnavailable

SQLite kept another journal mode instead of WAL (§4).

Fields

mode: String

The journal mode SQLite selected.

SqliteSettingOutOfRange

An app’s SQLite setting is larger than SQLite can hold (api.md E1).

Fields

setting: &'static str

The setting’s PRAGMA name.

maximum: u64

The largest value SQLite holds for it.

ReservedCollation

An app collation has the name of one of SQLite’s own (api.md E1).

Fields

name: String

The name as the app gave it.

DuplicateCollation

The app gave two collations one name, which SQLite compares without regard to ASCII case (api.md E1).

Fields

name: String

The second registration’s name.

ReservedFunction

An app function has the name of one SQLite or coven already has, or coven’s reserved prefix (api.md E1).

Fields

name: String

The name as the app gave it.

DuplicateFunction

The app gave two functions one name, which SQLite compares without regard to ASCII case (api.md E1).

Fields

name: String

The second registration’s name.

ConstantFunction

An app function is deterministic and takes no arguments, which SQLite evaluates while planning in a way coven can’t receive (api.md E1).

Fields

name: String

The function’s name.

VersionChangeRefused

A writable open found a new version of an app collation or function that a CHECK or generated column uses. Coven rebuilds only indexes, so the open changed nothing (§4).

Fields

name: String

The collation’s or function’s name, ASCII lowercase.

table: String

The table whose CHECK or generated column uses it.

VersionNotRebuilt

A read-only open found the store’s indexes built with another version of an app collation or function than the one registered. Only a writable open rebuilds them (§4).

Fields

name: String

The collation’s or function’s name, ASCII lowercase.

built: u32

The version the store’s indexes were built with.

registered: u32

The version this open registered.

ClockOutOfRange

The wall clock or next timestamp exceeds its representation (§7.2).

InputBudgetExceeded

Protected remote input fills the configured disk budget. No input or budget change was committed; increase the budget or finish pending work.

Fields

required: u64

Bytes required after evicting every eligible range.

maximum: u64

Configured encrypted-input limit.

TooLarge

A value or row exceeds the format (format.md D1, D2, D5), or a write’s plaintext and sealing key ids cannot fit in its SQLite queue row (§6.3).

Fields

field: &'static str

The bounded field or collection.

actual: u64

Its actual length.

maximum: u64

Its maximum length.

ReferenceAudience

A reference reaches an audience the source row’s readers cannot read (§15.3).

Fields

table: String

The referencing table.

key: RowKey

Its row’s primary key.

column: String

The referencing column.

DeletedCircle(CircleId)

A write targets a circle whose deletion has been applied (§15.9).

NotInCircle(CircleId)

A local write targets a circle this member is not in or the store does not have (§15).

AudienceReloading(Audience)

This audience still exposes its previous data while its selected boundary reloads (§16.5).

NotOwner

The write directly changed another member’s row of an owner_only() table: a statement, a shared trigger, or coven copying or dismissing it for the app (§9.6). The transaction, including its upload record, did not commit.

Fields

table: String

The owned row’s table.

key: RowKey

Its primary key, in declared key order.

owner: MemberId

The member who originally created it.

InvalidForeignKeyEffect

The write’s foreign-key actions on this row are not the schema’s exact consequence of its direct changes, so every receiver would refuse them (§9.6). The transaction, including its upload record, did not commit.

Fields

table: String

The row’s table.

key: RowKey

Its primary key, in declared key order.

KeyNotUuid

An inserted row’s independent key holds no UUID (§9.2).

Fields

table: String

The inserted row’s table.

key: RowKey

Its primary key, in declared key order.

InvalidAudience

A root row’s audience cell is neither store nor a circle id in canonical lowercase form (§15).

Fields

table: String

The written row’s table.

key: RowKey

Its primary key, in declared key order.

InvalidWrite

A downloaded write fails the merge’s checks and is never applied (§19.1).

Fields

write: WriteId

The refused write’s device and write number.

error: MergeError

The merge rule it broke.

MissingWriteSources(Vec<ChangeId>)

Original row-change evidence is unavailable. Receipt waits without consuming the position; local authoring rolls back instead of guessing.

WriteFormat(Error)

A waiting record or its conversion violates the write format (E13).

MigrationKindMismatch

A migration’s declared kind disagrees with its runtime classification.

Fields

version: u32

The refused migration’s version.

MigrationReference

A conversion changed or introduced a reference whose generation it cannot know (E13).

Fields

table: String

The referencing table in the converted change.

column: String

The referencing column in the converted change.

MigrationDuplicateColumn

A converted row names the same column twice.

Fields

table: String

The converted table.

column: String

The repeated column.

MigrationColumnMissing

A converted column is absent from the target schema.

Fields

table: String

The converted table.

column: String

The absent column.

MigrationPrimaryKeyMissing

A converted table has no primary index.

Fields

table: String

The converted table.

MigrationKeyArity

A converted key has the wrong number of values.

Fields

table: String

The converted table.

expected: usize

The primary index width.

actual: usize

The supplied key width.

MigrationTableMissing

A converted row or reference names an absent table.

Fields

table: String

The absent table.

MigrationReferenceCollision

Distinct original references became the same converted reference.

Fields

table: String

The original referencing table.

reference: ForeignKey

The repeated converted reference.

DismissedRowChanged

A write dismissed a removed row, deleting it for good, and also changed that row or one its delete cascades to (§8.4).

Fields

table: String

The declared table.

key: RowKey

The row’s key.

FileWriteOnce

A write changed a write-once file reference that named a file (§17.2).

Fields

table: String

The declared table.

key: RowKey

The row’s key.

UserFileMissing

The user’s original disappeared.

Fields

path: PathBuf

The original path.

UserFileChanged

The user’s original changed during preparation or since it was prepared.

Fields

path: PathBuf

The original path.

UndeclaredNamespace

No namespace of this name was declared when the store opened (E1).

Fields

namespace: String

The supplied namespace.

NamespaceKind

A file was staged into a namespace of the other kind: app bytes into a user namespace, or a user’s original into an app one (§17.1); or a bound reference names a user’s file (§17.4).

Fields

namespace: String

The supplied namespace.

kind: Provenance

The kind the namespace was declared with.

FileNameReused

The id source reused the physical name of a kept file: a cache file’s name, a staged copy’s <folder>/<copy>, or a staging’s folder (Appendix C.3).

Fields

name: String

The refused physical name, as this device’s records hold it.

FileUnreferenced

A file the write staged is referenced by none of its rows (§17.2).

Fields

namespace: String

The staged file’s namespace.

file: FileId

The staged file’s id.

FileUnknown

A reference names no file this device has a record of in its row’s audience (§17.2).

Fields

table: String

The referencing table.

column: String

The reference column.

file: String

The value the column holds.

FileAbsent

This device has no record of the file (§17.2): one to move, to make device-only, or to stage a new file over.

Fields

file: FileId

The requested file.

NotThisDevice

The file is on another device only, and only that device has its bytes: one to move to the cloud (§17.3), or one a write makes a new file over (§17.2).

Fields

file: FileId

The file.

NotDeviceOnlyHere

The file to move is in the cloud already (§17.3).

Fields

file: FileId

The file.

FileInMove

The file to move is in a move already, moving or failed: a file is in one move at a time, and the app cancels a failed one to move its files again (§17.3).

Fields

file: FileId

The file.

id: MoveId

The move that holds it.

BoundFileTooLarge

A bound reference names a file larger than its limit (§17.4).

Fields

table: String

The referencing table.

column: String

The bound reference column.

size: u64

The file’s size in bytes.

limit: u64

The column’s limit in bytes.

DeviceOnly

A bound reference names a file on one device only that no bound upload stores (§17.4).

Fields

file: FileId

The file.

MoveUnknown

This device never made the move (§17.3).

Fields

id: MoveId

The move.

MoveFinished

The move finished: its files are in the cloud (§17.3).

Fields

id: MoveId

The move.

MoveBound

The move is a bound file’s: its upload holds a write until the file is stored, so it can’t be cancelled (§17.4).

Fields

id: MoveId

The move.

NotInCloud

The file to make device-only is on one device only already, so storage holds no bytes of it to download (§17.3).

Fields

file: FileId

The file.

NoLongerStored

No record here names the stored bytes a file reference was taken over any more: the record went, or a switch took it off them, as making the file device-only does. The cache keeps bytes only while a record names them, so a pin fetching them keeps nothing (§17.8).

Fields

file: FileId

The file.

CopyPathTaken

Another call making files device-only is writing a copy at this path (§17.3).

Fields

path: PathBuf

The copy’s path.

Disk(FileError)

Reading or keeping file bytes failed.

FileKey(CryptoError)

A write queueing a file’s upload, as staging for the cloud or a move does, could not create the file’s random key (§17.3).

Lock(StoreLockError)

Retaining the store while staging file bytes failed.

FileCleanup

File cleanup failed, retaining every failure: on opening (Ok), or after a failed write, whose error it keeps (Appendix C.3).

Fields

write: Result<(), Box<DbError>>

Ok on opening; otherwise the failed write’s error.

failures: Vec<DbError>

Each failed byte removal or pending-record update.

StagingCleanup

A snapshot load or file check failed, and so did removing the records it staged, which its failure ends (§16.2); both failures are kept, and sync judges the load’s or check’s own as it would alone (§19.1).

Fields

operation: Box<DbError>

The load’s or check’s own failure.

cleanup: Box<DbError>

Removing the staged records’ tables.

OperationChanged(OperationId)

An operation no longer has the state expected by its caller.

OperationRunning(OperationId)

The operation the app acknowledges is still running: it has no outcome yet (§11.4).

OperationUnknown(OperationId)

coven_operations lists no operation with this id: the app’s writes never journaled it, or its outcome was acknowledged already (§11.4).

MemberKeysChanging

Self-replacement has paused app writes while queued objects settle and the new binding and custody are installed (§12.3, E9).

CaptureChanged

The prepared raise no longer names the current counted prefix.

RaiseWaiting

An ordinary snapshot of an audience whose raise this device captured and has not published: it would carry a schema version the history doesn’t hold yet (§16.2).

Snapshot(SnapshotError)

Loading plaintext supplied by sync failed without changing the database.

Closing

Closing failed for these connections, after every one was tried (E1).

Fields

failures: Vec<DbError>

Failures in connection-close order.

Rollback

A transaction failed and rolling it back failed too. Later calls fail with RollbackFailed until the store is reopened (§4).

Fields

operation: Box<DbError>

The operation that required rollback.

rollback: Error

SQLite’s rollback failure.

Implementations

impl DbError

pub fn is_disk(&self) -> bool

Whether the disk under the store caused this failure: its files could not be read or kept, or SQLite found the disk full, failing, read-only or damaged. A failure of any other kind, and one that names no disk error, is not the disk’s.

Trait Implementations

impl CarriesBug for DbError

fn bug(&self) -> Option<&Bug>

The bug this error carries, itself or through the failure it keeps.

impl Debug for DbError

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

Formats the value using the given formatter.

impl Display for DbError

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

Formats the value using the given formatter.

impl Error for DbError

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<Bug> for DbError

fn from(source: Bug) -> DbError

Converts to this type from the input type.

impl From<DbError> for BootstrapError

A database call’s or opening’s failure is the store’s.

fn from(error: DbError) -> Self

Converts to this type from the input type.

impl From<DbError> for CovenError

fn from(source: DbError) -> Self

Converts to this type from the input type.

impl From<DbError> for DeviceOnlyError

fn from(error: DbError) -> DeviceOnlyError

Converts to this type from the input type.

impl From<DbError> for FileReadError

fn from(error: DbError) -> FileReadError

Converts to this type from the input type.

impl From<DbError> for ReadOnlyOpenError

A database call’s or opening’s failure is the store’s.

fn from(error: DbError) -> Self

Converts to this type from the input type.

impl From<DbError> for SyncError

fn from(error: DbError) -> SyncError

Converts to this type from the input type.

impl From<Error> for DbError

fn from(error: Error) -> DbError

Converts to this type from the input type.

impl From<FileError> for DbError

fn from(error: FileError) -> DbError

Converts to this type from the input type.

impl From<ObservationError> for DbError

fn from(error: ObservationError) -> DbError

Converts to this type from the input type.

impl From<SchemaError> for DbError

fn from(source: SchemaError) -> DbError

Converts to this type from the input type.

impl From<Shutdown> for DbError

fn from(source: Shutdown) -> DbError

Converts to this type from the input type.

impl From<SnapshotError> for DbError

fn from(source: SnapshotError) -> DbError

Converts to this type from the input type.

impl From<Error> for DbError

fn from(error: Error) -> DbError

Converts to this type from the input type.

impl From<StagingFolderError> for DbError

fn from(error: StagingFolderError) -> DbError

Converts to this type from the input type.

impl From<StoreLockError> for DbError

fn from(error: StoreLockError) -> DbError

Converts to this type from the input type.

impl From<TaskFailed> for DbError

fn from(failed: TaskFailed) -> DbError

Converts to this type from the input type.

impl From<WriterError> for DbError

fn from(error: WriterError) -> DbError

Converts to this type from the input type.

impl WriteFailure for DbError

fn with_rollback(self, rollback: Error) -> DbError

Retain a failed rollback alongside the original failure.

fn with_cleanup(write: DbError, failures: Vec<DbError>) -> DbError

Retain the failed write’s error and every failed byte-removal operation.