Enum AppendError 

#[non_exhaustive]
pub enum AppendError {
    Protocol {
        source: TableProtocolError,
        backtrace: Backtrace,
    },
    ArrowInput {
        source: ArrowError,
        backtrace: Backtrace,
    },
    ArrowToLogicalSchema {
        source: ArrowToLogicalSchemaError,
        backtrace: Backtrace,
    },
    EmptyInput,
    InvalidMaxRowsPerRowGroup {
        max_rows_per_row_group: usize,
    },
    InvalidMaxBytesPerRowGroup {
        max_bytes_per_row_group: usize,
    },
    SchemaValidation {
        source: Box<SchemaCompatibilityError>,
    },
    GeneratedSegmentSchemaCompatibility {
        segment_path: String,
        source: Box<SchemaCompatibilityError>,
    },
    MissingCanonicalTableSchema {
        version: u64,
    },
    SegmentMetadata {
        source: Box<SegmentError>,
    },
    ParquetWrite {
        source: ParquetError,
        backtrace: Backtrace,
    },
    GeneratedSegmentCoverage {
        source: Box<SegmentCoverageError>,
    },
    IndexIntervalMapping {
        source: IndexIntervalMappingError,
        backtrace: Backtrace,
    },
    CoverageSidecar {
        source: Box<CoverageSidecarError>,
    },
    PersistedIndexIntervalOverlap {
        segment_path: String,
        overlap_count: u128,
        example_identity: Option<EntityIdentity>,
        example_index_interval_id: IndexIntervalId,
        example_index_interval: Box<IndexInterval>,
    },
    EmptySegmentEntityCoverage {
        segment_path: String,
    },
    EntityWithoutIndexCoverage {
        segment_path: String,
        identity: EntityIdentity,
    },
    ExistingSegmentMissingCoverageMetadata {
        segment_path: String,
    },
    ExistingSegmentCoverageSidecarRead {
        segment_path: String,
        coverage_path: String,
        source: Box<CoverageSidecarError>,
    },
    Storage {
        source: StorageError,
    },
    Commit {
        source: CommitError,
    },
    CommitAmbiguous {
        segment_path: String,
        source: Box<CommitError>,
    },
    Rollback {
        source: Box<AppendError>,
        cleanup_errors: Vec<StorageError>,
    },
}

Errors owned by an append operation.

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.

Protocol

The table protocol does not permit this client to append.

Fields

source: TableProtocolError

Complete table protocol failure.

backtrace: Backtrace

Backtrace captured at the append boundary.

ArrowInput

An Arrow input reader or batch normalization failed.

Fields

source: ArrowError

Arrow error returned while reading or normalizing a batch.

backtrace: Backtrace

Backtrace captured at the append input boundary.

ArrowToLogicalSchema

An Arrow schema could not be represented by the table logical schema.

Fields

source: ArrowToLogicalSchemaError

Arrow-to-logical schema conversion failure.

backtrace: Backtrace

Backtrace captured at the append schema boundary.

EmptyInput

An append input contained no rows.

InvalidMaxRowsPerRowGroup

A configured Parquet row group cannot contain zero rows.

Fields

max_rows_per_row_group: usize

Rejected per-append row-group limit.

InvalidMaxBytesPerRowGroup

A configured Parquet row group cannot contain zero estimated bytes.

Fields

max_bytes_per_row_group: usize

Rejected per-append row-group byte limit.

SchemaValidation

Validating the incoming and registered table schemas failed.

Fields

source: Box<SchemaCompatibilityError>

Complete schema compatibility failure.

GeneratedSegmentSchemaCompatibility

A generated segment is incompatible with the table schema.

Fields

segment_path: String

Generated table-relative segment path.

source: Box<SchemaCompatibilityError>

Complete schema compatibility failure.

MissingCanonicalTableSchema

Table state lacks the canonical schema required by append.

Fields

version: u64

Transaction log version missing a canonical logical schema.

SegmentMetadata

Reading metadata from the generated segment failed.

Fields

source: Box<SegmentError>

Complete segment metadata failure.

ParquetWrite

Streaming the append input into Parquet failed.

Fields

source: ParquetError

Parquet writer failure.

backtrace: Backtrace

Backtrace captured at the append writer boundary.

GeneratedSegmentCoverage

Deriving ordered-index coverage from the generated segment failed.

Fields

source: Box<SegmentCoverageError>

Complete segment coverage derivation failure.

IndexIntervalMapping

An ordered-index interval could not be reconstructed for a diagnostic.

Fields

source: IndexIntervalMappingError

Complete interval mapping failure.

backtrace: Backtrace

Backtrace captured at the append boundary.

CoverageSidecar

A coverage sidecar could not be prepared or written.

Fields

source: Box<CoverageSidecarError>

Complete coverage sidecar failure.

PersistedIndexIntervalOverlap

The generated segment overlaps coverage already persisted by the table.

Fields

segment_path: String

Relative path of the generated segment.

overlap_count: u128

Number of overlapping identity/index interval pairs.

example_identity: Option<EntityIdentity>

First overlapping identity, or None for a table-wide index.

example_index_interval_id: IndexIntervalId

Internal ID of the example interval.

example_index_interval: Box<IndexInterval>

Logical ordered-index interval represented by the example ID.

EmptySegmentEntityCoverage

An entity-aware generated segment produced no entity coverage.

Fields

segment_path: String

Relative path of the generated segment.

EntityWithoutIndexCoverage

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

Fields

segment_path: String

Relative path of the generated segment.

identity: EntityIdentity

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

ExistingSegmentMissingCoverageMetadata

An existing segment lacks coverage metadata required by append.

Fields

segment_path: String

Canonical segment path missing coverage metadata.

ExistingSegmentCoverageSidecarRead

Reading one existing segment’s coverage sidecar during recovery failed.

Fields

segment_path: String

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

coverage_path: String

Path of the failed coverage sidecar.

source: Box<CoverageSidecarError>

Complete coverage sidecar failure.

Storage

Direct storage access for an append artifact failed.

Fields

source: StorageError

Complete storage failure.

Commit

Publishing the append transaction failed with a definite outcome.

Fields

source: CommitError

Complete transaction-log failure.

CommitAmbiguous

The append transaction may have committed, so its artifacts were preserved.

Fields

segment_path: String

Generated table-relative Parquet path that was preserved.

source: Box<CommitError>

Ambiguous transaction-log failure.

Rollback

Append failed and one or more attempt-owned artifacts could not be removed.

Fields

source: Box<AppendError>

Original append failure that triggered rollback.

cleanup_errors: Vec<StorageError>

Typed cleanup failure for every artifact that could not be removed.

Trait Implementations

impl Debug for AppendError

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

Formats the value using the given formatter.

impl Display for AppendError

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

Formats the value using the given formatter.

impl Error for AppendError

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 AppendError

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.

impl From<CommitError> for AppendError

where CommitError: Into<CommitError>,

fn from(error: CommitError) -> Self

Converts to this type from the input type.

impl From<CoverageSidecarError> for AppendError

where CoverageSidecarError: Into<CoverageSidecarError>,

fn from(error: CoverageSidecarError) -> Self

Converts to this type from the input type.

impl From<IndexIntervalMappingError> for AppendError

where IndexIntervalMappingError: Into<IndexIntervalMappingError>,

fn from(error: IndexIntervalMappingError) -> Self

Converts to this type from the input type.

impl From<SchemaCompatibilityError> for AppendError

where SchemaCompatibilityError: Into<SchemaCompatibilityError>,

fn from(error: SchemaCompatibilityError) -> Self

Converts to this type from the input type.

impl From<SegmentCoverageError> for AppendError

where SegmentCoverageError: Into<SegmentCoverageError>,

fn from(error: SegmentCoverageError) -> Self

Converts to this type from the input type.

impl From<SegmentError> for AppendError

where SegmentError: Into<SegmentError>,

fn from(error: SegmentError) -> Self

Converts to this type from the input type.

impl From<StorageError> for AppendError

where StorageError: Into<StorageError>,

fn from(error: StorageError) -> Self

Converts to this type from the input type.

impl From<TableProtocolError> for AppendError

where TableProtocolError: Into<TableProtocolError>,

fn from(error: TableProtocolError) -> Self

Converts to this type from the input type.