Enum mz_adapter::AdapterError

pub enum AdapterError {
    AbsurdSubscribeBounds {
        as_of: Timestamp,
        up_to: Timestamp,
    },
    AmbiguousSystemColumnReference,
    Catalog(Error),
    ChangedPlan,
    DuplicateCursor(String),
    Eval(EvalError),
    Explain(ExplainError),
    IdExhaustionError,
    Internal(String),
    IntrospectionDisabled {
        log_names: Vec<String>,
    },
    InvalidLogDependency {
        object_type: String,
        log_names: Vec<String>,
    },
    InvalidClusterReplicaAz {
        az: String,
        expected: Vec<String>,
    },
    InvalidClusterReplicaSize {
        size: String,
        expected: Vec<String>,
    },
    InvalidSetIsolationLevel,
    InvalidSetCluster,
    InvalidStorageClusterSize {
        size: String,
        expected: Vec<String>,
    },
    SourceOrSinkSizeRequired {
        expected: Vec<String>,
    },
    InvalidTableMutationSelection,
    BadItemInStorageCluster {
        cluster_name: String,
    },
    ConstraintViolation(NotNullViolation),
    ConcurrentClusterDrop,
    NoClusterReplicasAvailable(String),
    OperationProhibitsTransaction(String),
    OperationRequiresTransaction(String),
    PlanError(PlanError),
    VarError(VarError),
    PreparedStatementExists(String),
    ParseError(ParserStatementError),
    ReadOnlyTransaction,
    ReadWriteUnavailable,
    RecursionLimit(RecursionLimitError),
    RelationOutsideTimeDomain {
        relations: Vec<String>,
        names: Vec<String>,
    },
    ResourceExhaustion {
        resource_type: String,
        limit_name: String,
        desired: String,
        limit: String,
        current: String,
    },
    ResultSize(String),
    SafeModeViolation(String),
    StatementTimeout,
    Canceled,
    IdleInTransactionSessionTimeout,
    SubscribeOnlyTransaction,
    Transform(TransformError),
    UnallowedOnCluster {
        depends_on: SmallVec<[String; 2]>,
        cluster: String,
    },
    Unauthorized(UnauthorizedError),
    UncallableFunction {
        func: UnmaterializableFunc,
        context: &'static str,
    },
    UnknownCursor(String),
    UnknownLoginRole(String),
    UnknownPreparedStatement(String),
    UnknownClusterReplica {
        cluster_name: String,
        replica_name: String,
    },
    UnknownWebhookSource {
        database: String,
        schema: String,
        name: String,
    },
    UnrecognizedConfigurationParam(String),
    Unstructured(Error),
    Unsupported(&'static str),
    UnmaterializableFunction(UnmaterializableFunc),
    UnstableDependency {
        object_type: String,
        unstable_dependencies: Vec<String>,
    },
    UntargetedLogRead {
        log_names: Vec<String>,
    },
    WriteOnlyTransaction,
    MultiTableWriteTransaction,
    SingleStatementTransaction,
    DDLOnlyTransaction,
    DDLTransactionRace,
    DDLTransactionDryRun {
        new_ops: Vec<Op>,
        new_state: CatalogState,
    },
    Storage(StorageError),
    Compute(Error),
    Orchestrator(Error),
    DependentObject(BTreeMap<String, Vec<String>>),
    InvalidAlter(&'static str, PlanError),
}

Errors that can occur in the coordinator.

Variants

AbsurdSubscribeBounds

Fields

as_of: Timestamp

up_to: Timestamp

A SUBSCRIBE was requested whose UP TO bound precedes its as_of timestamp

AmbiguousSystemColumnReference

Attempted to use a potentially ambiguous column reference expression with a system table.

Catalog(Error)

An error occurred in a catalog operation.

ChangedPlan

The cached plan or descriptor changed.

DuplicateCursor(String)

The cursor already exists.

Eval(EvalError)

An error while evaluating an expression.

Explain(ExplainError)

An error occurred while planning the statement.

IdExhaustionError

The ID allocator exhausted all valid IDs.

Internal(String)

Unexpected internal state was encountered.

IntrospectionDisabled

Fields

log_names: Vec<String>

Attempted to read from log sources of a replica with disabled introspection.

InvalidLogDependency

Fields

object_type: String

log_names: Vec<String>

Attempted to create an object dependent on log sources that doesn’t support log dependencies.

InvalidClusterReplicaAz

Fields

az: String

expected: Vec<String>

No such cluster replica size has been configured.

InvalidClusterReplicaSize

Fields

size: String

expected: Vec<String>

No such cluster replica size has been configured.

InvalidSetIsolationLevel

SET TRANSACTION ISOLATION LEVEL was called in the middle of a transaction.

InvalidSetCluster

SET cluster was called in the middle of a transaction.

InvalidStorageClusterSize

Fields

size: String

expected: Vec<String>

No such storage instance size has been configured.

SourceOrSinkSizeRequired

Fields

expected: Vec<String>

Creating a source or sink without specifying its size is forbidden.

InvalidTableMutationSelection

The selection value for a table mutation operation refers to an invalid object.

BadItemInStorageCluster

Fields

cluster_name: String

An operation attempted to create an illegal item in a storage-only cluster

ConstraintViolation(NotNullViolation)

Expression violated a column’s constraint

ConcurrentClusterDrop

Transaction cluster was dropped in the middle of a transaction.

NoClusterReplicasAvailable(String)

Target cluster has no replicas to service query.

OperationProhibitsTransaction(String)

The named operation cannot be run in a transaction.

OperationRequiresTransaction(String)

The named operation requires an active transaction.

PlanError(PlanError)

An error occurred while planning the statement.

VarError(VarError)

An error occurred with a session variable.

PreparedStatementExists(String)

The named prepared statement already exists.

ParseError(ParserStatementError)

Wrapper around parsing error

ReadOnlyTransaction

The transaction is in read-only mode.

ReadWriteUnavailable

The transaction in in read-only mode and a read already occurred.

RecursionLimit(RecursionLimitError)

The recursion limit of some operation was exceeded.

RelationOutsideTimeDomain

Fields

relations: Vec<String>

names: Vec<String>

A query in a transaction referenced a relation outside the first query’s time domain.

ResourceExhaustion

Fields

resource_type: String

limit_name: String

desired: String

limit: String

current: String

A query tried to create more resources than is allowed in the system configuration.

ResultSize(String)

Result size of a query is too large.

SafeModeViolation(String)

The specified feature is not permitted in safe mode.

StatementTimeout

Waiting on a query timed out.

Note this differs slightly from PG’s implementation/semantics.

Canceled

The user canceled the query

IdleInTransactionSessionTimeout

An idle session in a transaction has timed out.

SubscribeOnlyTransaction

The transaction is in single-subscribe mode.

Transform(TransformError)

An error occurred in the MIR stage of the optimizer.

UnallowedOnCluster

Fields

depends_on: SmallVec<[String; 2]>

cluster: String

A query depends on items which are not allowed to be referenced from the current cluster.

Unauthorized(UnauthorizedError)

A user tried to perform an action that they were unauthorized to do.

UncallableFunction

Fields

func: UnmaterializableFunc

context: &'static str

The specified function cannot be called

UnknownCursor(String)

The named cursor does not exist.

UnknownLoginRole(String)

The named role does not exist.

UnknownPreparedStatement(String)

UnknownClusterReplica

Fields

cluster_name: String

replica_name: String

The named cluster replica does not exist.

UnknownWebhookSource

Fields

database: String

schema: String

name: String

The named webhook source does not exist.

UnrecognizedConfigurationParam(String)

The named setting does not exist.

Unstructured(Error)

A generic error occurred.

Unsupported(&'static str)

The named feature is not supported and will (probably) not be.

UnmaterializableFunction(UnmaterializableFunc)

The specified function cannot be materialized.

UnstableDependency

Fields

object_type: String

unstable_dependencies: Vec<String>

Attempted to create an object that has unstable dependencies.

UntargetedLogRead

Fields

log_names: Vec<String>

Attempted to read from log sources without selecting a target replica.

WriteOnlyTransaction

The transaction is in write-only mode.

MultiTableWriteTransaction

The transaction only supports single table writes

SingleStatementTransaction

The transaction can only execute a single statement.

DDLOnlyTransaction

The transaction can only execute simple DDL.

DDLTransactionRace

Another session modified the Catalog while this transaction was open.

DDLTransactionDryRun

Fields

new_ops: Vec<Op>

New operations that were run in the transaction.

new_state: CatalogState

New resulting CatalogState.

Used to prevent us from durably committing state while a DDL transaction is open, should never be returned to the user.

Storage(StorageError)

An error occurred in the storage layer

Compute(Error)

An error occurred in the compute layer

Orchestrator(Error)

An error in the orchestrator layer

DependentObject(BTreeMap<String, Vec<String>>)

A statement tried to drop a role that had dependent objects.

The map keys are role names and values are detailed error messages.

InvalidAlter(&'static str, PlanError)

When performing an ALTER of some variety, re-planning the statement errored.

Implementations

impl AdapterError

pub fn into_response(self, severity: Severity) -> ErrorResponse

pub fn detail(&self) -> Option<String>

Reports additional details about the error, if any are available.

pub fn hint(&self) -> Option<String>

Reports a hint for the user about how the error could be fixed.

pub fn code(&self) -> SqlState

pub fn internal<E: Display>(context: &str, e: E) -> AdapterError

Trait Implementations

impl Debug for AdapterError

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

Formats the value using the given formatter.

impl Display for AdapterError

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

Formats the value using the given formatter.

impl Error for AdapterError

fn source(&self) -> Option<&(dyn Error + 'static)>

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<AdapterError> for OptimizerError

fn from(source: AdapterError) -> Self

Converts to this type from the input type.

impl From<CatalogError> for AdapterError

fn from(e: CatalogError) -> Self

Converts to this type from the input type.

impl From<CatalogError> for AdapterError

fn from(e: CatalogError) -> AdapterError

Converts to this type from the input type.

impl From<ConnectionError> for AdapterError

fn from(value: ConnectionError) -> Self

Converts to this type from the input type.

impl From<Error> for AdapterError

fn from(e: Error) -> AdapterError

Converts to this type from the input type.

impl From<Error> for AdapterError

fn from(e: Error) -> AdapterError

Converts to this type from the input type.

impl From<EvalError> for AdapterError

fn from(e: EvalError) -> AdapterError

Converts to this type from the input type.

impl From<ExplainError> for AdapterError

fn from(e: ExplainError) -> AdapterError

Converts to this type from the input type.

impl From<IdentError> for AdapterError

fn from(value: IdentError) -> Self

Converts to this type from the input type.

impl From<InstanceExists> for AdapterError

fn from(e: InstanceExists) -> Self

Converts to this type from the input type.

impl From<NotNullViolation> for AdapterError

fn from(e: NotNullViolation) -> AdapterError

Converts to this type from the input type.

impl From<OptimizerError> for AdapterError

fn from(value: OptimizerError) -> Self

Converts to this type from the input type.

impl From<ParserStatementError> for AdapterError

fn from(e: ParserStatementError) -> Self

Converts to this type from the input type.

impl From<PlanError> for AdapterError

fn from(e: PlanError) -> AdapterError

Converts to this type from the input type.

impl From<RecursionLimitError> for AdapterError

fn from(e: RecursionLimitError) -> AdapterError

Converts to this type from the input type.

impl From<RecvError> for AdapterError

fn from(e: RecvError) -> AdapterError

Converts to this type from the input type.

impl From<StorageError> for AdapterError

fn from(e: StorageError) -> Self

Converts to this type from the input type.

impl From<TimeoutType> for AdapterError

fn from(timeout: TimeoutType) -> Self

Converts to this type from the input type.

impl From<TimestampError> for AdapterError

fn from(e: TimestampError) -> Self

Converts to this type from the input type.

impl From<TransformError> for AdapterError

fn from(e: TransformError) -> AdapterError

Converts to this type from the input type.

impl From<TryFromDecimalError> for AdapterError

fn from(e: TryFromDecimalError) -> AdapterError

Converts to this type from the input type.

impl From<TryFromIntError> for AdapterError

fn from(e: TryFromIntError) -> AdapterError

Converts to this type from the input type.

impl From<UnauthorizedError> for AdapterError

fn from(e: UnauthorizedError) -> Self

Converts to this type from the input type.

impl From<VarError> for AdapterError

fn from(e: VarError) -> Self

Converts to this type from the input type.

impl ShouldHalt for AdapterError

fn should_halt(&self) -> bool

Reports whether the error should halt rather than panic the process.