Enum TableError 

pub enum TableError {
    TransactionLog {
        source: CommitError,
    },
    EmptyTable,
    NotTimeSeries {
        kind: TableKind,
    },
    AlreadyExists {
        current_version: u64,
    },
    SegmentMeta {
        source: SegmentError,
    },
    SchemaCompatibility {
        source: SchemaCompatibilityError,
    },
    MissingCanonicalSchema {
        version: u64,
    },
    Storage {
        source: StorageError,
    },
    InvalidRange {
        start: DateTime<Utc>,
        end: DateTime<Utc>,
    },
    ParquetRead {
        source: ParquetError,
    },
    Arrow {
        source: ArrowError,
    },
    MissingTimeColumn {
        column: String,
    },
    UnsupportedTimeType {
        column: String,
        datatype: DataType,
    },
    TimeConversionOverflow {
        column: String,
        timestamp: DateTime<Utc>,
    },
    SegmentCoverage {
        source: SegmentCoverageError,
    },
    TableCoverageBucketMismatch {
        expected: TimeBucket,
        actual: TimeBucket,
        pointer_version: u64,
    },
    CoverageSidecar {
        source: CoverageError,
    },
    CoverageOverlap {
        segment_path: String,
        overlap_count: u64,
        example_bucket: Option<u32>,
    },
    ExistingSegmentMissingCoverage {
        segment_id: SegmentId,
    },
    SegmentCoverageSidecarRead {
        segment_id: SegmentId,
        coverage_path: String,
        source: Box<CoverageError>,
    },
    BucketDomainOverflow {
        last_bucket_id: u64,
        max: u32,
    },
    MissingTableCoveragePointer,
    SegmentEntityIdentity {
        source: SegmentEntityIdentityError,
    },
    EntityMismatch {
        segment_path: String,
        expected: BTreeMap<String, String>,
        found: BTreeMap<String, String>,
    },
}

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.

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.

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.

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.

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

Start and end timestamps must satisfy start < end when scanning.

Fields

start: DateTime<Utc>

Inclusive/lower timestamp bound supplied by caller.

end: DateTime<Utc>

Exclusive/upper timestamp bound supplied by caller.

ParquetRead

Parquet read/IO error during scanning or schema extraction.

Fields

source: ParquetError

Underlying Parquet error raised during read or schema extraction.

Arrow

Arrow compute or conversion error while materializing or filtering batches.

Fields

source: ArrowError

Underlying Arrow error raised during batch conversion or filtering.

MissingTimeColumn

Segment is missing the configured time column required for scans.

Fields

column: String

Name of the expected time column that was not found in the segment.

UnsupportedTimeType

Time column exists but has an unsupported Arrow type for scanning.

Fields

column: String

Name of the time column with an unsupported type.

datatype: DataType

Arrow data type encountered for the time column.

TimeConversionOverflow

Converting a timestamp to the requested unit would overflow i64.

Fields

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.

TableCoverageBucketMismatch

Table coverage pointer uses a bucket spec that doesn’t match the table’s index bucket.

Fields

expected: TimeBucket

Bucket spec defined by the table’s time index.

actual: TimeBucket

Bucket spec 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 coverage for the same segment path.

Fields

segment_path: String

Relative path of the segment being appended.

overlap_count: u64

Number of overlapping buckets detected.

example_bucket: Option<u32>

Example overlapping bucket (if available) to aid debugging.

ExistingSegmentMissingCoverage

Existing segment lacks a coverage_path when coverage is required.

Fields

segment_id: SegmentId

Segment ID missing a coverage_path entry.

SegmentCoverageSidecarRead

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

Fields

segment_id: SegmentId

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).

BucketDomainOverflow

Building an expected bucket bitmap would exceed the u32 bucket domain.

In v0.1 we store bucket ids in RoaringBitmap (u32). If the requested time range maps to bucket ids > u32::MAX, we must fail instead of truncating in release builds.

Fields

last_bucket_id: u64

The last bucket id in the requested range (inclusive).

max: u32

Always u32::MAX, included to make the error self-describing.

MissingTableCoveragePointer

Table state is missing a coverage snapshot pointer when required.

SegmentEntityIdentity

Failed to read or validate the entity identity stored in a segment.

Fields

source: SegmentEntityIdentityError

Underlying entity identity extraction error.

EntityMismatch

Segment entity identity does not match the expected table identity.

Fields

segment_path: String

Relative path of the segment being appended.

expected: BTreeMap<String, String>

Expected entity identity derived from table metadata or state.

found: BTreeMap<String, String>

Entity identity observed in the segment.

Trait Implementations

impl Debug for TableError

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

Formats the value using the given formatter.

impl Display for TableError

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

Formats the value using the given formatter.

impl Error for TableError

where TableError: Debug + Display,

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 source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

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.