Enum DrizzleError 

pub enum DrizzleError {
    ExecutionError(CompactString),
    PrepareError(CompactString),
    NotFound,
    TransactionError(CompactString),
    Mapping(CompactString),
    Statement(CompactString),
    Query(CompactString),
    QueryFailed {
        ctx: Box<QueryContext>,
        source: Box<DrizzleError>,
    },
    ParameterError(CompactString),
    TryFromInt(TryFromIntError),
    ParseInt(ParseIntError),
    ParseFloat(ParseFloatError),
    ParseBool(ParseBoolError),
    ConversionError(CompactString),
    Schema(CompactString),
    UnsafeMigrationRepair {
        tag: CompactString,
        reason: CompactString,
    },
    UnsupportedMigrationExecution {
        adapter: CompactString,
        requirement: CompactString,
    },
    Other(CompactString),
    Infallible(Infallible),
}

Every error a Drizzle query, conversion or migration can return.

Driver errors are wrapped in a variant for that driver when its feature is enabled. DrizzleError::QueryFailed adds the failing SQL and parameters to another error.

Variants

ExecutionError(CompactString)

The statement failed to execute.

PrepareError(CompactString)

The statement failed to prepare.

NotFound

A query that returns exactly one row, such as an aggregate with no GROUP BY, returned none.

TransactionError(CompactString)

A transaction could not begin, commit or roll back.

Mapping(CompactString)

A row could not be mapped to the target type.

Statement(CompactString)

The statement is invalid.

Query(CompactString)

The query is invalid.

QueryFailed

Another error, with the SQL and parameters of the query that caused it. The message shows the parameter count, not the values; see QueryContext.

Fields

ctx: Box<QueryContext>

Captured SQL and parameter context.

source: Box<DrizzleError>

Original error.

ParameterError(CompactString)

Parameters could not be bound: missing, duplicate or unexpected bindings, or a value that could not be converted.

TryFromInt(TryFromIntError)

An integer did not fit the target type.

ParseInt(ParseIntError)

Text could not be parsed as an integer.

ParseFloat(ParseFloatError)

Text could not be parsed as a float.

ParseBool(ParseBoolError)

Text could not be parsed as a boolean.

ConversionError(CompactString)

A value could not be converted to the requested type.

Schema(CompactString)

The schema is invalid (for example a cycle in table dependencies).

UnsafeMigrationRepair

A dirty migration cannot be repaired without violating its execution safety contract.

Fields

tag: CompactString

Migration tag recorded in the tracking table.

reason: CompactString

Safety requirement that prevents automatic repair.

UnsupportedMigrationExecution

The selected adapter cannot provide a migration’s required execution semantics.

Fields

adapter: CompactString

Runtime adapter that cannot provide the required semantics.

requirement: CompactString

Migration execution capability the adapter does not provide.

Other(CompactString)

Any other error.

Infallible(Infallible)

Never constructed; lets ? work on infallible conversions.

Implementations

impl DrizzleError

pub fn kind(&self) -> ErrorKind

What kind of failure this is, the same on every driver.

It looks through QueryFailed to the driver’s error.

Examples

use drizzle_core::error::{DrizzleError, ErrorKind};

let error = DrizzleError::Other("UNIQUE constraint failed: users.email".into());
assert_eq!(error.kind(), ErrorKind::UniqueViolation);
assert!(!error.is_retryable());

pub fn constraint(&self) -> Option<&str>

The name of the constraint the failure names, when the database reports one: the constraint on PostgreSQL and MySQL, and a CHECK on SQLite, which SQLite names by its expression when it has no name. SQLite names only the columns of a UNIQUE failure, so that is None.

It looks through QueryFailed.

pub fn is_retryable(&self) -> bool

Whether running the statement or transaction again can succeed; see ErrorKind::is_retryable.

pub fn query(&self) -> Option<&QueryContext>

The SQL and parameters of the query that failed, when drizzle ran it.

Trait Implementations

impl Debug for DrizzleError

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

Formats the value using the given formatter.

impl Display for DrizzleError

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

Formats the value using the given formatter.

impl Error for DrizzleError

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 From<!> for DrizzleError

fn from(source: Infallible) -> Self

Converts to this type from the input type.

impl From<ParseBoolError> for DrizzleError

fn from(source: ParseBoolError) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for DrizzleError

fn from(source: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for DrizzleError

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.

impl From<TryFromIntError> for DrizzleError

fn from(source: TryFromIntError) -> Self

Converts to this type from the input type.