Enum DbErr 

#[non_exhaustive]
pub enum DbErr {
    ConnectionAcquire(ConnAcquireErr),
    TryIntoErr {
        from: &'static str,
        into: &'static str,
        source: Arc<dyn Error + Sync + Send>,
    },
    Conn(RuntimeErr),
    Exec(RuntimeErr),
    Query(RuntimeErr),
    ConvertFromU64(&'static str),
    UnpackInsertId,
    UpdateGetPrimaryKey,
    RecordNotFound(String),
    AttrNotSet(String),
    Custom(String),
    Type(String),
    Json(String),
    Migration(String),
    RecordNotInserted,
    RecordNotUpdated,
    BackendNotSupported {
        db: &'static str,
        ctx: &'static str,
    },
    KeyArityMismatch {
        expected: u8,
        received: u8,
    },
    PrimaryKeyNotSet {
        ctx: &'static str,
    },
    RbacError(String),
    AccessDenied {
        permission: String,
        resource: String,
    },
    MutexPoisonError,
}

An error from unsuccessful database operations

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.

ConnectionAcquire(ConnAcquireErr)

This error can happen when the connection pool is fully-utilized

TryIntoErr

Runtime type conversion error

Fields

from: &'static str

From type

into: &'static str

Into type

source: Arc<dyn Error + Sync + Send>

TryError

Conn(RuntimeErr)

There was a problem with the database connection

Exec(RuntimeErr)

An operation did not execute successfully

Query(RuntimeErr)

An error occurred while performing a query

ConvertFromU64(&'static str)

Type error: the specified type cannot be converted from u64. This is not a runtime error.

UnpackInsertId

After an insert statement it was impossible to retrieve the last_insert_id

UpdateGetPrimaryKey

When updating, a model should know its primary key to check if the record has been correctly updated, otherwise this error will occur

RecordNotFound(String)

The record was not found in the database

AttrNotSet(String)

Thrown by TryFrom<ActiveModel>, which assumes all attributes are set/unchanged

Custom(String)

A custom error

Type(String)

Error occurred while parsing value as target type

Json(String)

Error occurred while parsing json value as target type

Migration(String)

A migration error

RecordNotInserted

None of the records are inserted, that probably means all of them conflict with existing records in the table

RecordNotUpdated

None of the records are updated, that means a WHERE condition has no matches. May be the table is empty or the record does not exist

BackendNotSupported

This operation is not supported by the database backend

Fields

db: &'static str

Database backend

ctx: &'static str

Context

KeyArityMismatch

(Primary) Key arity mismatch

Fields

expected: u8

Expected value

received: u8

Received value

PrimaryKeyNotSet

Primay key not set for update / delete

Fields

ctx: &'static str

Context

RbacError(String)

Error while running RBAC checks

AccessDenied

Access denied after running RBAC checks

Fields

permission: String

The required permission

resource: String

The requested resource

MutexPoisonError

Mutex was poisoned by another thread

Implementations

impl DbErr

pub fn sql_err(&self) -> Option<SqlErr>

Classify this error as a portable SqlErr — a unique-key or foreign-key constraint violation — returning None if it is neither, or if it did not originate from a database driver.

Only the two most common constraint violations are recognized, across MySQL, Postgres and SQLite. For anything else (SQLSTATE codes, check constraints, other driver-specific detail) match on the underlying RuntimeErr::SqlxError and inspect the driver error yourself:

use sea_orm::{DbErr, RuntimeErr};
use std::ops::Deref;

if let Some(sql_err) = err.sql_err() {
    // Portable across MySQL / Postgres / SQLite.
    eprintln!("constraint violation: {sql_err}");
} else if let DbErr::Query(RuntimeErr::SqlxError(e)) | DbErr::Exec(RuntimeErr::SqlxError(e)) =
    &err
    && let sea_orm::sqlx::Error::Database(db_err) = e.deref()
{
    // Backend-specific: inspect the raw driver error.
    eprintln!("SQLSTATE: {:?}", db_err.code());
}

Trait Implementations

impl Clone for DbErr

fn clone(&self) -> DbErr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DbErr

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

Formats the value using the given formatter.

impl Display for DbErr

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

Formats the value using the given formatter.

impl Eq for DbErr

impl Error for DbErr

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<TryGetError> for DbErr

fn from(e: TryGetError) -> DbErr

Converts to this type from the input type.

impl PartialEq for DbErr

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

Equality operator ==.

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

Inequality operator !=.