错误

Error: error occurred while decoding column 2: mismatched types; Rust type `core::option::Option<derive_type::Email>` (as SQL type `email`) is not compatible with SQL type `TEXT`

Caused by:
    mismatched types; Rust type `core::option::Option<derive_type::Email>` (as SQL type `email`) is not compatible with SQL type `TEXT`

let e = sqlx::query("select 1 where false").fetch_one(&pool).await.unwrap_err();
println!("RowNotFound  {e}");
let held = pool.acquire().await?;
let e = pool.acquire().await.unwrap_err();
println!("PoolTimedOut {e:?} / {e}");
drop(held);
pool.close().await;
let e = pool.acquire().await.unwrap_err();
println!("PoolClosed   {e:?} / {e}");

RowNotFound  no rows returned by a query that expected to return at least one row
PoolTimedOut PoolTimedOut / pool timed out while waiting for an open connection
PoolClosed   PoolClosed / attempted to acquire a connection on a closed pool

pub trait DatabaseError: 'static + Send + Sync + StdError {
    /// The primary, human-readable error message.
    fn message(&self) -> &str;

    /// The (SQLSTATE) code for the error.
    fn code(&self) -> Option<Cow<'_, str>> {
        None
    }
    // ...
    fn constraint(&self) -> Option<&str> {
        None
    }

    fn table(&self) -> Option<&str> {
        None
    }

    fn kind(&self) -> ErrorKind;

    /// Returns whether the error kind is a violation of a unique/primary key constraint.
    fn is_unique_violation(&self) -> bool {
        matches!(self.kind(), ErrorKind::UniqueViolation)
    }

    /// Returns whether the error kind is a violation of a foreign key.
    fn is_foreign_key_violation(&self) -> bool {
        matches!(self.kind(), ErrorKind::ForeignKeyViolation)
    }

    /// Returns whether the error kind is a violation of a check.
    fn is_check_violation(&self) -> bool {
        matches!(self.kind(), ErrorKind::CheckViolation)
    }
}

pub enum ErrorKind {
    /// Unique/primary key constraint violation.
    UniqueViolation,
    /// Foreign key constraint violation.
    ForeignKeyViolation,
    /// Not-null constraint violation.
    NotNullViolation,
    /// Check constraint violation.
    CheckViolation,
    /// Exclusion constraint violation.
    ExclusionViolation,
    /// An unmapped error.
    Other,
}

async fn run(pool: &sqlx::PgPool, label: &str, sql: &'static str) {
  let err = sqlx::query(sql).execute(pool).await.unwrap_err();
  println!("== {label}");
  println!("Display    {err}");
  if let Some(db) = err.as_database_error() {
    let pg = db.downcast_ref::<PgDatabaseError>();
    println!(
      "kind={:?} code={:?} constraint={:?} table={:?}",
      db.kind(),
      db.code(),
      db.constraint(),
      db.table()
    );
    println!(
      "detail={:?} position={:?} file={:?} line={:?} routine={:?}",
      pg.detail(),
      pg.position(),
      pg.file(),
      pg.line(),
      pg.routine()
    );
  }
}

run(&pool, "unique", "insert into person (id, name) values (1, 'dup')").await;
run(&pool, "foreign key", "insert into post values (1, 99, 't')").await;
run(&pool, "not null", "insert into person (id) values (3)").await;
run(&pool, "check (domain)", "insert into person (id, name, email) values (3, 'c', 'nope')").await;
run(&pool, "exclusion", "insert into booking values (2, '[3,8)')").await;
run(&pool, "syntax", "select id,\n  nme\nfrom person").await;

== unique
Display    error returned from database: duplicate key value violates unique constraint "person_pkey" at line 666
kind=UniqueViolation code=Some("23505") constraint=Some("person_pkey") table=Some("person")
detail=Some("Key (id)=(1) already exists.") position=None file=Some("nbtinsert.c") line=Some(666) routine=Some("_bt_check_unique")
== foreign key
Display    error returned from database: insert or update on table "post" violates foreign key constraint "post_person_id_fkey" at line 2608
kind=ForeignKeyViolation code=Some("23503") constraint=Some("post_person_id_fkey") table=Some("post")
detail=Some("Key (person_id)=(99) is not present in table \"person\".") position=None file=Some("ri_triggers.c") line=Some(2608) routine=Some("ri_ReportViolation")
== not null
Display    error returned from database: null value in column "name" of relation "person" violates not-null constraint at line 2057
kind=NotNullViolation code=Some("23502") constraint=None table=Some("person")
detail=Some("Failing row contains (3, null, null, null, 2026-10-24 06:54:14.633239, null, null).") position=None file=Some("execMain.c") line=Some(2057) routine=Some("ExecConstraints")
== check (domain)
Display    error returned from database: value for domain email violates check constraint "email_check" at line 3831
kind=CheckViolation code=Some("23514") constraint=Some("email_check") table=None
detail=None position=None file=Some("execExprInterp.c") line=Some(3831) routine=Some("ExecEvalConstraintCheck")
== exclusion
Display    error returned from database: conflicting key value violates exclusion constraint "booking_during_excl" at line 874
kind=ExclusionViolation code=Some("23P01") constraint=Some("booking_during_excl") table=Some("booking")
detail=Some("Key (during)=([3,8)) conflicts with existing key (during)=([1,5)).") position=None file=Some("execIndexing.c") line=Some(874) routine=Some("check_exclusion_or_unique_constraint")
== syntax
Display    error returned from database: column "nme" does not exist at line 3729
kind=Other code=Some("42703") constraint=None table=None
detail=None position=Some(Original(14)) file=Some("parse_relation.c") line=Some(3729) routine=Some("errorMissingColumn")

impl Display for PgDatabaseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.write_str(self.message())?;
        if let Some(line) = self.line() {
            write!(f, " at line {line}")?;
        }
        Ok(())
    }
}

error returned from database: duplicate key value violates unique constraint "person_pkey"
error returned from database: column "nme" does not exist

error returned from database: duplicate key value violates unique constraint "person_pkey" at line 666
error returned from database: column "nme" does not exist at line 3729

let err = sqlx::query("insert into person (id, name) values ($1, $2)")
  .bind(1_i64)
  .bind("dup")
  .execute(&pool)
  .await
  .unwrap_err();
match &err {
  sqlx::Error::Database(db) if db.is_unique_violation() => {
    println!("is_unique_violation: constraint {:?}", db.constraint());
  }
  _ => println!("other: {err}"),
}
let by_code = err.as_database_error().and_then(|db| db.code()).as_deref() == Some("23505");
println!("code == 23505: {by_code}");
println!("kind == UniqueViolation: {}", err.as_database_error().map(|d| d.kind()) == Some(ErrorKind::UniqueViolation));

is_unique_violation: constraint Some("person_pkey")
code == 23505: true
kind == UniqueViolation: true

Display    error returned from database: column "nme" does not exist at line 3729
detail=None position=Some(Original(14)) file=Some("parse_relation.c") line=Some(3729) routine=Some("errorMissingColumn")