Added enum for SQLx Error and basic functions for it

src/error.rs

@@ -144,18 +144,17 @@ where
 #[derive(Error, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum SqlErr {
-    /// error for inserting a record with a key that already exists in the table
-    #[error("Cannot have record with same key")]
-    UniqueConstraintViolation(),
-    /// error for Foreign key is not primary key
-    #[error("Cannot add non-primary key from other table")]
-    ForeignKeyConstraintViolation(),
+    /// error for duplicate record in unique field or primary key field
+    #[error("Unique Constraint Violated")]
+    UniqueConstraintViolation,
+    /// error for Foreign key constraint
+    #[error("Foreign Key Constraint Violated")]
+    ForeignKeyConstraintViolation,
 }
 
 #[allow(dead_code)]
 impl DbErr {
-    /// convert generic DbErr by sqlx to SqlErr
-    /// return none if input is not any of SqlErr
+    /// Convert generic DbErr by sqlx to SqlErr, return none if the error is not any type of SqlErr
     pub fn sql_err(&self) -> Option<SqlErr> {
         #[cfg(any(
             feature = "sqlx-mysql",
@@ -168,33 +167,52 @@ impl DbErr {
             | DbErr::Query(RuntimeErr::SqlxError(sqlx::Error::Database(e))) = self
             {
                 let error_code = e.code().unwrap_or_default();
-                let error_code_expanded = error_code.deref();
+                let _error_code_expanded = error_code.deref();
                 #[cfg(feature = "sqlx-mysql")]
                 if e.try_downcast_ref::<sqlx::mysql::MySqlDatabaseError>()
                     .is_some()
                 {
-                    match error_code_expanded {
-                        "23000" => return Some(SqlErr::UniqueConstraintViolation()),
-                        "1586" => return Some(SqlErr::UniqueConstraintViolation()),
-                        "1452" => return Some(SqlErr::ForeignKeyConstraintViolation()),
+                    let error_number = e
+                        .try_downcast_ref::<sqlx::mysql::MySqlDatabaseError>()?
+                        .number();
+                    match error_number {
+                        // 1022 Can't write; duplicate key in table '%s'
+                        // 1062 Duplicate entry '%s' for key %d
+                        // 1169 Can't write, because of unique constraint, to table '%s'
+                        // 1586 Duplicate entry '%s' for key '%s'
+                        1022 | 1062 | 1169 | 1586 => {
+                            return Some(SqlErr::UniqueConstraintViolation)
+                        }
+                        // 1216 Cannot add or update a child row: a foreign key constraint fails
+                        // 1217 Cannot delete or update a parent row: a foreign key constraint fails
+                        // 1451 Cannot delete or update a parent row: a foreign key constraint fails (%s)
+                        // 1452 Cannot add or update a child row: a foreign key constraint fails (%s)
+                        // 1557 Upholding foreign key constraints for table '%s', entry '%s', key %d would lead to a duplicate entry
+                        // 1761 Foreign key constraint for table '%s', record '%s' would lead to a duplicate entry in table '%s', key '%s'
+                        // 1762 Foreign key constraint for table '%s', record '%s' would lead to a duplicate entry in a child table
+                        1216 | 1217 | 1451 | 1452 | 1557 | 1761 | 1762 => {
+                            return Some(SqlErr::ForeignKeyConstraintViolation)
+                        }
                         _ => return None,
                     }
                 }
                 #[cfg(feature = "sqlx-postgres")]
                 if e.try_downcast_ref::<sqlx::postgres::PgDatabaseError>()
                     .is_some()
                 {
-                    match error_code_expanded {
-                        "23505" => return Some(SqlErr::UniqueConstraintViolation()),
-                        "23503" => return Some(SqlErr::ForeignKeyConstraintViolation()),
+                    match _error_code_expanded {
+                        "23505" => return Some(SqlErr::UniqueConstraintViolation),
+                        "23503" => return Some(SqlErr::ForeignKeyConstraintViolation),
                         _ => return None,
                     }
                 }
                 #[cfg(feature = "sqlx-sqlite")]
                 if e.try_downcast_ref::<sqlx::sqlite::SqliteError>().is_some() {
-                    match error_code_expanded {
-                        "1555" => return Some(SqlErr::UniqueConstraintViolation()),
-                        "787" => return Some(SqlErr::ForeignKeyConstraintViolation()),
+                    match _error_code_expanded {
+                        // error code 1555 refers to the primary key's unique constraint violation
+                        // error code 2067 refers to the UNIQUE unique constraint violation
+                        "1555" | "2067" => return Some(SqlErr::UniqueConstraintViolation),
+                        "787" => return Some(SqlErr::ForeignKeyConstraintViolation),
                         _ => return None,
                     }
                 }

tests/sql_err_tests.rs

@@ -1,17 +1,9 @@
 pub mod common;
-mod crud;
-use rust_decimal_macros::dec;
-pub use sea_orm::entity::*;
-use sea_orm::error::*;
-pub use sea_orm::{sea_query, tests_cfg, ConnectionTrait, EntityName, QueryFilter, QuerySelect};
-// use sea_query::ForeignKey;
-use uuid::Uuid;
-
 pub use common::{bakery_chain::*, setup::*, TestContext};
 use pretty_assertions::assert_eq;
-
-pub use crud::*;
-use sea_orm::DatabaseConnection;
+use rust_decimal_macros::dec;
+pub use sea_orm::{entity::*, error::*, tests_cfg, DatabaseConnection, EntityName, ExecResult};
+use uuid::Uuid;
 
 #[sea_orm_macros::test]
 #[cfg(any(
@@ -24,11 +16,6 @@ async fn main() {
     create_tables(&ctx.db).await.unwrap();
     test_error(&ctx.db).await;
     ctx.delete().await;
-
-    // let ctx = TestContext::new("bakery_chain_sql_err_tests_2").await;
-    // create_tables(&ctx.db2).await.unwrap();
-    // test_error_foreign(&ctx.db1, &ctx.db2).await;
-    // ctx.delete().await;
 }
 
 pub async fn test_error(db: &DatabaseConnection) {
@@ -52,10 +39,24 @@ pub async fn test_error(db: &DatabaseConnection) {
         .await
         .expect_err("inserting should fail due to duplicate primary key");
 
-    let sqlerr = error.sql_err();
-    assert_eq!(sqlerr.unwrap(), SqlErr::UniqueConstraintViolation())
-}
+    assert_eq!(error.sql_err(), Some(SqlErr::UniqueConstraintViolation));
 
-// pub async fn test_error_foreign(db1: &DatabaseConnection, db2: &DatabaseConnection) {
+    let fk_cake = cake::ActiveModel {
+        name: Set("fk error Cake".to_owned()),
+        price: Set(dec!(10.25)),
+        gluten_free: Set(false),
+        serial: Set(Uuid::new_v4()),
+        bakery_id: Set(Some(1000)),
+        ..Default::default()
+    };
 
-// }
+    let fk_error = fk_cake
+        .insert(db)
+        .await
+        .expect_err("create foreign key should fail with non-primary key");
+
+    assert_eq!(
+        fk_error.sql_err(),
+        Some(SqlErr::ForeignKeyConstraintViolation)
+    );
+}