diff --git a/libs/driver-adapters/src/error.rs b/libs/driver-adapters/src/error.rs
index 2411feae85a1..b77d58110548 100644
--- a/libs/driver-adapters/src/error.rs
+++ b/libs/driver-adapters/src/error.rs
@@ -52,6 +52,41 @@ pub(crate) enum DriverAdapterError {
     InvalidIsolationLevel {
         level: String,
     },
+    LengthMismatch {
+        column: Option<String>,
+    },
+    UniqueConstraintViolation {
+        fields: Vec<String>,
+    },
+    NullConstraintViolation {
+        fields: Vec<String>,
+    },
+    ForeignKeyConstraintViolation {
+        constraint: DriverAdapterConstraint,
+    },
+    DatabaseDoesNotExist {
+        db: Option<String>,
+    },
+    DatabaseAlreadyExists {
+        db: Option<String>,
+    },
+    DatabaseAccessDenied {
+        db: Option<String>,
+    },
+    AuthenticationFailed {
+        user: Option<String>,
+    },
+    TransactionWriteConflict,
+
+    TableDoesNotExist {
+        table: Option<String>,
+    },
+    ColumnNotFound {
+        column: Option<String>,
+    },
+    TooManyConnections {
+        cause: String,
+    },
     #[cfg(feature = "postgresql")]
     #[serde(rename = "postgres")]
     Postgres(#[serde(with = "PostgresErrorDef")] PostgresError),
@@ -62,3 +97,11 @@ pub(crate) enum DriverAdapterError {
     #[serde(rename = "sqlite")]
     Sqlite(#[serde(with = "SqliteErrorDef")] SqliteError),
 }
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) enum DriverAdapterConstraint {
+    Fields(Vec<String>),
+    Index(String),
+    ForeignKey,
+}
diff --git a/libs/driver-adapters/src/lib.rs b/libs/driver-adapters/src/lib.rs
index 96dac52bd0ca..960d51aa7929 100644
--- a/libs/driver-adapters/src/lib.rs
+++ b/libs/driver-adapters/src/lib.rs
@@ -17,7 +17,7 @@ pub(crate) mod transaction;
 pub(crate) mod types;
 
 use crate::error::DriverAdapterError;
-use quaint::error::{Error as QuaintError, ErrorKind};
+use quaint::error::{DatabaseConstraint, Error as QuaintError, ErrorKind};
 
 #[cfg(target_arch = "wasm32")]
 pub(crate) use wasm::result::AdapterResult;
@@ -37,6 +37,53 @@ impl From<DriverAdapterError> for QuaintError {
             DriverAdapterError::InvalidIsolationLevel { level } => {
                 QuaintError::builder(ErrorKind::InvalidIsolationLevel(level)).build()
             }
+            DriverAdapterError::LengthMismatch { column } => {
+                QuaintError::builder(ErrorKind::LengthMismatch { column: column.into() }).build()
+            }
+            DriverAdapterError::UniqueConstraintViolation { fields } => {
+                QuaintError::builder(ErrorKind::UniqueConstraintViolation {
+                    constraint: DatabaseConstraint::Fields(fields),
+                })
+                .build()
+            }
+            DriverAdapterError::NullConstraintViolation { fields } => {
+                QuaintError::builder(ErrorKind::NullConstraintViolation {
+                    constraint: DatabaseConstraint::Fields(fields),
+                })
+                .build()
+            }
+            DriverAdapterError::ForeignKeyConstraintViolation { constraint } => {
+                let constraint = match constraint {
+                    error::DriverAdapterConstraint::Fields(fields) => DatabaseConstraint::Fields(fields),
+                    error::DriverAdapterConstraint::Index(index) => DatabaseConstraint::Index(index),
+                    error::DriverAdapterConstraint::ForeignKey => DatabaseConstraint::ForeignKey,
+                };
+                QuaintError::builder(ErrorKind::ForeignKeyConstraintViolation { constraint }).build()
+            }
+            DriverAdapterError::DatabaseDoesNotExist { db } => {
+                QuaintError::builder(ErrorKind::DatabaseDoesNotExist { db_name: db.into() }).build()
+            }
+            DriverAdapterError::DatabaseAlreadyExists { db } => {
+                QuaintError::builder(ErrorKind::DatabaseAlreadyExists { db_name: db.into() }).build()
+            }
+            DriverAdapterError::DatabaseAccessDenied { db } => {
+                QuaintError::builder(ErrorKind::DatabaseAccessDenied { db_name: db.into() }).build()
+            }
+            DriverAdapterError::AuthenticationFailed { user } => {
+                QuaintError::builder(ErrorKind::AuthenticationFailed { user: user.into() }).build()
+            }
+            DriverAdapterError::TransactionWriteConflict => {
+                QuaintError::builder(ErrorKind::TransactionWriteConflict).build()
+            }
+            DriverAdapterError::TableDoesNotExist { table } => {
+                QuaintError::builder(ErrorKind::TableDoesNotExist { table: table.into() }).build()
+            }
+            DriverAdapterError::ColumnNotFound { column } => {
+                QuaintError::builder(ErrorKind::ColumnNotFound { column: column.into() }).build()
+            }
+            DriverAdapterError::TooManyConnections { cause } => {
+                QuaintError::builder(ErrorKind::TooManyConnections(cause.into())).build()
+            }
             DriverAdapterError::GenericJs { id } => QuaintError::external_error(id),
             #[cfg(feature = "postgresql")]
             DriverAdapterError::Postgres(e) => e.into(),
diff --git a/query-engine/connectors/sql-query-connector/src/error.rs b/query-engine/connectors/sql-query-connector/src/error.rs
index 1eff6424a8e4..a468dd73604f 100644
--- a/query-engine/connectors/sql-query-connector/src/error.rs
+++ b/query-engine/connectors/sql-query-connector/src/error.rs
@@ -65,7 +65,11 @@ impl From<quaint::error::Error> for RawError {
     fn from(e: quaint::error::Error) -> Self {
         let default_value: RawError = Self::Database {
             code: e.original_code().map(ToString::to_string),
-            message: e.original_message().map(ToString::to_string),
+            message: Some(
+                e.original_message()
+                    .map(ToString::to_string)
+                    .unwrap_or_else(|| e.to_string()),
+            ),
         };
 
         match e.kind() {