Enum TableError 

pub enum TableError {
    TransactionLog {
        source: CommitError,
    },
    OptimizeNotApplicable {
        table_root: String,
    },
    OptimizeRewrite {
        source: EntityRewriteError,
    },
    OptimizeInvariant {
        reason: String,
    },
    OptimizeCountOverflow {
        field: &'static str,
    },
    OptimizeRollback {
        source: Box<TableError>,
        cleanup_errors: Vec<String>,
    },
    AppendRollback {
        source: Box<TableError>,
        cleanup_errors: Vec<String>,
    },
    ExternalParquetRollback {
        path: String,
        source: Box<TableError>,
        cleanup_error: StorageError,
    },
    EmptyTable,
    NotTimeSeries {
        kind: TableKind,
    },
    UnsupportedFormatVersion {
        expected: u32,
        found: u32,
    },
    AlreadyExists {
        current_version: u64,
    },
    IndexSpec {
        source: IndexSpecError,
    },
    CoverageBucket {
        source: BucketError,
    },
    InvalidSegmentBounds {
        source: IndexValueError,
    },
    SegmentMeta {
        source: SegmentError,
    },
    SchemaCompatibility {
        source: SchemaCompatibilityError,
    },
    SegmentSchemaCompatibility {
        path: String,
        source: SchemaCompatibilityError,
    },
    MissingCanonicalSchema {
        version: u64,
    },
    Storage {
        source: StorageError,
    },
    InvalidRange {
        source: IndexValueError,
    },
    EntityIdentityRequired {
        entity_columns: Vec<String>,
    },
    EntityIdentityNotConfigured,
    MissingEntityIdentityColumn {
        column: String,
    },
    DuplicateEntityIdentityColumn {
        column: String,
    },
    UnexpectedEntityIdentityColumn {
        column: String,
    },
    ParquetRead {
        path: String,
        source: ParquetError,
    },
    Arrow {
        path: String,
        column: String,
        source: ArrowError,
    },
    MissingIndexColumn {
        path: String,
        column: String,
    },
    IndexColumnTypeMismatch {
        path: String,
        column: String,
        expected: &'static str,
        datatype: DataType,
    },
    TimeConversionOverflow {
        path: String,
        column: String,
        timestamp: DateTime<Utc>,
    },
    SegmentCoverage {
        source: SegmentCoverageError,
    },
    TableCoverageIndexKindMismatch {
        expected: IndexKind,
        actual: IndexKind,
        pointer_version: u64,
    },
    CoverageSidecar {
        source: CoverageError,
    },
    CoverageOverlap {
        segment_path: String,
        overlap_count: u64,
        example_bucket: Option<u64>,
        example_bucket_range: LogicalBucketRange,
    },
    EntityCoverageOverlap {
        segment_path: String,
        overlap_count: u128,
        example_identity: EntityIdentity,
        example_bucket: u64,
        example_bucket_range: LogicalBucketRange,
    },
    EmptySegmentEntityCoverage {
        segment_path: String,
    },
    EntityWithoutIndexCoverage {
        segment_path: String,
        identity: EntityIdentity,
    },
    DuplicateSegmentPath {
        path: String,
    },
    ExistingSegmentMissingCoverage {
        path: String,
    },
    SegmentCoverageSidecarRead {
        path: String,
        coverage_path: String,
        source: Box<CoverageError>,
    },
    MissingTableCoveragePointer,
}

Errors from high-level time-series table operations.

Each variant carries enough context for callers to surface actionable messages to users or implement retries where appropriate (for example, conflicts on optimistic concurrency control).

Variants

TransactionLog

Any error coming from the transaction log / commit machinery (for example, OCC conflicts, storage failures, or corrupt commits).

Fields

source: CommitError

Underlying transaction log / commit error.

OptimizeNotApplicable

Entity-layout optimization does not apply to a table without entities.

Fields

table_root: String

User-facing table root.

OptimizeRewrite

Rewriting one mixed source into staged replacements failed.

Fields

source: EntityRewriteError

Storage-level mixed segment rewrite failure.

OptimizeInvariant

A staged optimization plan violated an atomic publication invariant.

Fields

reason: String

Failed plan invariant.

OptimizeCountOverflow

An optimization count could not be represented without wrapping.

Fields

field: &'static str

Report or version field that overflowed.

OptimizeRollback

Optimization failed and one or more owned staged objects could not be removed.

Fields

source: Box<TableError>

Original optimization failure.

cleanup_errors: Vec<String>

Every private path whose cleanup failed.

AppendRollback

Append failed and one or more owned coverage sidecars could not be removed.

Fields

source: Box<TableError>

Original append failure that triggered rollback.

cleanup_errors: Vec<String>

Cleanup failures, including each affected sidecar path.

ExternalParquetRollback

Append failed and its provisional external Parquet copy could not be removed.

Fields

path: String

Table-relative path of the provisional copy that may remain.

source: Box<TableError>

Original append failure that triggered rollback.

cleanup_error: StorageError

Storage failure encountered while removing the provisional copy.

EmptyTable

Attempting to open a table that has no commits at all (CURRENT == 0).

NotTimeSeries

The underlying table is not a time-series table (TableKind mismatch).

Fields

kind: TableKind

The actual kind of the underlying table that was discovered.

UnsupportedFormatVersion

Attempting to create a table with an unsupported metadata format version.

Fields

expected: u32

Format version supported by this writer.

found: u32

Format version supplied by the caller.

AlreadyExists

Attempt to create a table where commits already exist (idempotency guard for create).

Fields

current_version: u64

Current transaction log version that indicates the table already exists.

IndexSpec

The ordered-index specification is structurally invalid.

Fields

source: IndexSpecError

Structural or bucket configuration failure.

CoverageBucket

An ordered value could not be mapped to its coverage bucket.

Fields

source: BucketError

Domain, range, or bucket configuration failure.

InvalidSegmentBounds

Segment bounds cannot be ordered in one native index domain.

Fields

source: IndexValueError

Domain or bound-order failure.

SegmentMeta

Segment-level metadata / Parquet error during append (for example, missing time column, unsupported type, corrupt stats).

Fields

source: SegmentError

Underlying segment metadata error.

SchemaCompatibility

Schema compatibility error when appending a segment with incompatible schema (no evolution allowed in v0.1).

Fields

source: SchemaCompatibilityError

Underlying schema compatibility error.

SegmentSchemaCompatibility

A segment’s schema is incompatible with the table or index specification.

Fields

path: String

Table-relative segment path.

source: SchemaCompatibilityError

Underlying schema compatibility error.

MissingCanonicalSchema

Table has progressed past the initial metadata commit but still lacks a canonical logical schema (invariant violation for v0.1).

Fields

version: u64

The transaction log version missing a canonical logical schema.

Storage

Storage error while accessing table data (read/write failure at the storage layer).

Fields

source: StorageError

Underlying storage error while reading or writing table data.

InvalidRange

Ordered-index range validation failed.

Fields

source: IndexValueError

Domain, kind, or bound-order failure.

EntityIdentityRequired

An identity-free coverage query was used on an entity-aware table.

Fields

entity_columns: Vec<String>

Entity columns that require values from the caller.

EntityIdentityNotConfigured

An entity-aware coverage query was used on a table with global coverage.

MissingEntityIdentityColumn

A required entity column has no caller-provided value.

Fields

column: String

Configured entity column missing from the caller input.

DuplicateEntityIdentityColumn

Caller input repeats one entity column.

Fields

column: String

Repeated entity column name.

UnexpectedEntityIdentityColumn

Caller input contains a column that is not part of the entity identity.

Fields

column: String

Unknown entity column name.

ParquetRead

Parquet read/IO error during scanning or schema extraction.

Fields

path: String

Normalized table-relative path of the segment being scanned.

source: ParquetError

Underlying Parquet error raised during read or schema extraction.

Arrow

Arrow compute or conversion error while materializing or filtering batches.

Fields

path: String

Normalized table-relative path of the segment being scanned.

column: String

Configured time column being filtered.

source: ArrowError

Underlying Arrow error raised during batch conversion or filtering.

MissingIndexColumn

Segment is missing the configured ordered-index column required for scans.

Fields

path: String

Normalized table-relative path of the segment being scanned.

column: String

Name of the expected ordered-index column that was not found.

IndexColumnTypeMismatch

Ordered-index column has an Arrow type that disagrees with the table index.

Fields

path: String

Normalized table-relative path of the segment being scanned.

column: String

Name of the ordered-index column with the mismatched type.

expected: &'static str

Registered ordered-index domain.

datatype: DataType

Arrow data type encountered for the ordered-index column.

TimeConversionOverflow

Converting a timestamp to the requested unit would overflow i64.

Fields

path: String

Normalized table-relative path of the segment being scanned.

column: String

Name of the time column being converted.

timestamp: DateTime<Utc>

The timestamp value that could not be represented as i64 nanos.

SegmentCoverage

Segment Coverage error.

Fields

source: SegmentCoverageError

Underlying coverage error.

TableCoverageIndexKindMismatch

Table coverage pointer uses a different ordered-index descriptor.

Fields

expected: IndexKind

Index descriptor defined by table metadata.

actual: IndexKind

Index descriptor recorded in the table coverage pointer.

pointer_version: u64

Log version where the mismatching coverage pointer was recorded.

CoverageSidecar

Coverage sidecar read/write or computation error.

Fields

source: CoverageError

Underlying Coverage error.

CoverageOverlap

Appending would overlap existing table coverage.

Fields

segment_path: String

Relative path of the segment being appended.

overlap_count: u64

Number of overlapping buckets detected.

example_bucket: Option<u64>

Internal example bucket retained for programmatic compatibility.

example_bucket_range: LogicalBucketRange

Logical ordered-index range covered by the example bucket.

EntityCoverageOverlap

Appending would overlap entity-scoped table coverage.

Fields

segment_path: String

Relative path of the segment being appended.

overlap_count: u128

Number of overlapping (entity identity, bucket) pairs.

example_identity: EntityIdentity

First overlapping identity in canonical order.

example_bucket: u64

Smallest overlapping bucket for example_identity.

example_bucket_range: LogicalBucketRange

Logical ordered-index range covered by the example bucket.

EmptySegmentEntityCoverage

Entity-aware append produced no entity coverage.

Fields

segment_path: String

Relative path of the segment being appended.

EntityWithoutIndexCoverage

One entity has rows but no usable ordered-index coverage.

Fields

segment_path: String

Relative path of the segment being appended.

identity: EntityIdentity

Complete identity whose rows all have null ordered-index values.

DuplicateSegmentPath

A live segment already uses the normalized path supplied for append.

Fields

path: String

Canonical table-relative path that is already registered.

ExistingSegmentMissingCoverage

Existing segment lacks a coverage_path when coverage is required.

Fields

path: String

Canonical segment path missing a coverage_path entry.

SegmentCoverageSidecarRead

Reading the per-segment coverage sidecar failed while rebuilding coverage.

Fields

path: String

Canonical path of the segment whose coverage sidecar could not be read.

coverage_path: String

Path to the coverage sidecar file that failed to read.

source: Box<CoverageError>

Underlying coverage error (boxed to keep the variant size small).

MissingTableCoveragePointer

Table state is missing a coverage snapshot pointer when required.

Trait Implementations

impl Debug for TableError

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

Formats the value using the given formatter.

impl Display for TableError

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

Formats the value using the given formatter.

impl Error for TableError

where Self: Debug + Display,

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 ErrorCompat for TableError

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

fn iter_chain(&self) -> ChainCompat<'_, '_>

where Self: AsErrorSource,

Returns an iterator for traversing the chain of errors, starting with the current error and continuing with recursive calls to Error::source.