Enum EngineErrorKind 

#[non_exhaustive]
pub enum EngineErrorKind {
    Invalid,
    OutOfRange,
    Conversion,
    UnknownType,
    Decimal,
    MismatchType,
    DivideByZero,
    ObjectSize,
    InvalidType,
    Serialization,
    Transaction,
    NotImplemented,
    Expression,
    Catalog,
    Parser,
    Planner,
    Scheduler,
    Executor,
    Constraint,
    Index,
    Stat,
    Connection,
    Syntax,
    Settings,
    Binder,
    Network,
    Optimizer,
    NullPointer,
    Io,
    Interrupt,
    Fatal,
    Internal,
    InvalidInput,
    OutOfMemory,
    Permission,
    ParameterNotResolved,
    ParameterNotAllowed,
    Dependency,
    Http,
    MissingExtension,
    Autoload,
    Sequence,
    InvalidConfiguration,
    Unknown(duckdb_error_type),
    Unavailable,
}

How DuckDB itself classified an engine error.

Mirrors duckdb_error_type. Marked #[non_exhaustive] because DuckDB adds error types across releases: a value this build does not recognise is kept verbatim in EngineErrorKind::Unknown rather than being flattened into a catch-all, so no information is lost and matching stays forward-compatible.

EngineErrorKind::Unavailable is distinct from Unknown: it means the DuckDB API in question exposes only a status code and a message, with no typed classification at all. This driver never invents a concrete kind by parsing message text.

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.

Invalid

DUCKDB_ERROR_INVALID

OutOfRange

DUCKDB_ERROR_OUT_OF_RANGE

Conversion

DUCKDB_ERROR_CONVERSION

UnknownType

DUCKDB_ERROR_UNKNOWN_TYPE

Decimal

DUCKDB_ERROR_DECIMAL

MismatchType

DUCKDB_ERROR_MISMATCH_TYPE

DivideByZero

DUCKDB_ERROR_DIVIDE_BY_ZERO

ObjectSize

DUCKDB_ERROR_OBJECT_SIZE

InvalidType

DUCKDB_ERROR_INVALID_TYPE

Serialization

DUCKDB_ERROR_SERIALIZATION

Transaction

DUCKDB_ERROR_TRANSACTION

NotImplemented

DUCKDB_ERROR_NOT_IMPLEMENTED

Expression

DUCKDB_ERROR_EXPRESSION

Catalog

DUCKDB_ERROR_CATALOG

Parser

DUCKDB_ERROR_PARSER

Planner

DUCKDB_ERROR_PLANNER

Scheduler

DUCKDB_ERROR_SCHEDULER

Executor

DUCKDB_ERROR_EXECUTOR

Constraint

DUCKDB_ERROR_CONSTRAINT — DuckDB does not say which constraint.

Index

DUCKDB_ERROR_INDEX

Stat

DUCKDB_ERROR_STAT

Connection

DUCKDB_ERROR_CONNECTION

Syntax

DUCKDB_ERROR_SYNTAX

Settings

DUCKDB_ERROR_SETTINGS

Binder

DUCKDB_ERROR_BINDER

Network

DUCKDB_ERROR_NETWORK

Optimizer

DUCKDB_ERROR_OPTIMIZER

NullPointer

DUCKDB_ERROR_NULL_POINTER

Io

DUCKDB_ERROR_IO

Interrupt

DUCKDB_ERROR_INTERRUPT

Fatal

DUCKDB_ERROR_FATAL

Internal

DUCKDB_ERROR_INTERNAL

InvalidInput

DUCKDB_ERROR_INVALID_INPUT

OutOfMemory

DUCKDB_ERROR_OUT_OF_MEMORY

Permission

DUCKDB_ERROR_PERMISSION

ParameterNotResolved

DUCKDB_ERROR_PARAMETER_NOT_RESOLVED

ParameterNotAllowed

DUCKDB_ERROR_PARAMETER_NOT_ALLOWED

Dependency

DUCKDB_ERROR_DEPENDENCY

Http

DUCKDB_ERROR_HTTP

MissingExtension

DUCKDB_ERROR_MISSING_EXTENSION

Autoload

DUCKDB_ERROR_AUTOLOAD

Sequence

DUCKDB_ERROR_SEQUENCE

InvalidConfiguration

DUCKDB_INVALID_CONFIGURATION

Unknown(duckdb_error_type)

DuckDB reported a classification this build does not know; the raw value is preserved so nothing is lost across DuckDB upgrades.

Unavailable

The originating DuckDB API offers no typed classification — only a status code and a message (prepare, extracted statements, pending, table description). Not a guess: an explicit absence.

Implementations

impl EngineErrorKind

pub const KNOWN: &'static [EngineErrorKind]

Every kind that maps 1:1 onto a duckdb_error_type this build knows.

Excludes Unknown and Unavailable, which have no single raw value.

pub fn from_raw(raw: duckdb_error_type) -> EngineErrorKind

Classifies a raw duckdb_error_type, preserving unrecognised values.

pub fn to_raw(self) -> duckdb_error_type

Returns the raw duckdb_error_type for this kind.

Unavailable has no DuckDB counterpart and maps to DUCKDB_ERROR_INVALID, which is what DuckDB itself uses for an unclassified error.

Trait Implementations

impl Clone for EngineErrorKind

fn clone(&self) -> EngineErrorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EngineErrorKind

impl Debug for EngineErrorKind

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

Formats the value using the given formatter.

impl Display for EngineErrorKind

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

Formats the value using the given formatter.

impl Eq for EngineErrorKind

impl Hash for EngineErrorKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EngineErrorKind

fn eq(&self, other: &EngineErrorKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for EngineErrorKind