feat(error): add MismatchedTypeError for improved type mismatch handling

This commit introduces a new error type, MismatchedTypeError, to provide detailed information when a Rust type is incompatible with a SQL type. The error includes fields for the Rust type, its SQL representation, the actual SQL type, and an optional source error. Additionally, the mismatched_types function is updated to utilize this new error type, enhancing error reporting in type decoding scenarios. The Any module is also refactored to remove the obsolete error handling code.

Author: lovasoa

sqlx-core/src/any/error.rs

@@ -18,7 +18,6 @@ mod arguments;
 pub(crate) mod column;
 mod connection;
 mod database;
-mod error;
 mod kind;
 mod options;
 mod query_result;

sqlx-core/src/any/mod.rs

@@ -1,8 +1,8 @@
-use crate::any::error::mismatched_types;
 use crate::any::{Any, AnyColumn, AnyColumnIndex};
 use crate::column::ColumnIndex;
 use crate::database::HasValueRef;
 use crate::decode::Decode;
+use crate::error::mismatched_types;
 use crate::error::Error;
 use crate::row::Row;
 use crate::type_info::TypeInfo;
@@ -91,7 +91,7 @@ impl Row for AnyRow {
         let ty = value.type_info();
 
         if !value.is_null() && !ty.is_null() && !T::compatible(&ty) {
-            Err(mismatched_types::<T>(&ty))
+            Err(mismatched_types::<Self::Database, T>(&ty))
         } else {
             T::decode(value)
         }

sqlx-core/src/any/row.rs

@@ -1,10 +1,9 @@
 use std::borrow::Cow;
 
-use crate::any::error::mismatched_types;
 use crate::any::{Any, AnyTypeInfo};
 use crate::database::HasValueRef;
 use crate::decode::Decode;
-use crate::error::Error;
+use crate::error::mismatched_types;
 use crate::type_info::TypeInfo;
 use crate::types::Type;
 use crate::value::{Value, ValueRef};
@@ -113,15 +112,18 @@ impl Value for AnyValue {
         }
     }
 
-    fn try_decode<'r, T>(&'r self) -> Result<T, Error>
+    fn try_decode<'r, T>(&'r self) -> crate::error::Result<T>
     where
         T: Decode<'r, Self::Database> + Type<Self::Database>,
     {
         if !self.is_null() {
             let ty = self.type_info();
 
             if !ty.is_null() && !T::compatible(&ty) {
-                return Err(Error::Decode(mismatched_types::<T>(&ty)));
+                return Err(crate::error::Error::Decode(mismatched_types::<
+                    Self::Database,
+                    T,
+                >(&ty)));
             }
         }
 

sqlx-core/src/any/value.rs

@@ -26,6 +26,43 @@ pub type BoxDynError = Box<dyn StdError + 'static + Send + Sync>;
 #[error("unexpected null; try decoding as an `Option`")]
 pub struct UnexpectedNullError;
 
+/// Error indicating that a Rust type is not compatible with a SQL type.
+#[derive(thiserror::Error, Debug)]
+#[error("mismatched types; Rust type `{rust_type}` (as SQL type `{rust_sql_type}`) could not be decoded into SQL type `{sql_type}`")]
+pub struct MismatchedTypeError {
+    /// The name of the Rust type.
+    pub rust_type: String,
+    /// The SQL type name that the Rust type would map to.
+    pub rust_sql_type: String,
+    /// The actual SQL type from the database.
+    pub sql_type: String,
+    /// Optional source error that caused the mismatch.
+    #[source]
+    pub source: Option<BoxDynError>,
+}
+
+impl MismatchedTypeError {
+    /// Create a new mismatched type error without a source.
+    pub fn new<DB: Database, T: Type<DB>>(ty: &DB::TypeInfo) -> Self {
+        Self {
+            rust_type: type_name::<T>().to_string(),
+            rust_sql_type: T::type_info().name().to_string(),
+            sql_type: ty.name().to_string(),
+            source: None,
+        }
+    }
+
+    /// Create a new mismatched type error with a source error.
+    pub fn with_source<DB: Database, T: Type<DB>>(ty: &DB::TypeInfo, source: BoxDynError) -> Self {
+        Self {
+            rust_type: type_name::<T>().to_string(),
+            rust_sql_type: T::type_info().name().to_string(),
+            sql_type: ty.name().to_string(),
+            source: Some(source),
+        }
+    }
+}
+
 /// Represents all the ways a method can fail within SQLx.
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
@@ -145,23 +182,17 @@ impl Error {
 }
 
 pub(crate) fn mismatched_types<DB: Database, T: Type<DB>>(ty: &DB::TypeInfo) -> BoxDynError {
-    // TODO: `#name` only produces `TINYINT` but perhaps we want to show `TINYINT(1)`
-    if T::compatible(ty) {
-        format!(
-            "mismatched types; Rust type `{}` (as SQL type `{}`) is compatible with SQL type `{}` but decoding failed",
-            type_name::<T>(),
-            T::type_info().name(),
-            ty.name()
-        )
-    } else {
-        format!(
-            "mismatched types; Rust type `{}` (as SQL type `{}`) is not compatible with SQL type `{}`",
+    Box::new(MismatchedTypeError {
+        rust_type: format!(
+            "{} ({}compatible with SQL type `{}`)",
             type_name::<T>(),
-            T::type_info().name(),
-            ty.name()
-        )
-    }
-    .into()
+            if T::compatible(ty) { "" } else { "in" },
+            T::type_info().name()
+        ),
+        rust_sql_type: T::type_info().name().to_string(),
+        sql_type: ty.name().to_string(),
+        source: None,
+    })
 }
 
 /// An error that was returned from the database.

sqlx-core/src/error.rs

@@ -459,17 +459,17 @@ where
     fn push_binary(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
-        vec: &mut Vec<Option<Vec<u8>>>,
+        vec: &mut Vec<Vec<u8>>,
         nulls: &mut Vec<bool>,
     ) {
         let mut buf = Vec::new();
         match cursor_row.get_text(col_index, &mut buf) {
             Ok(true) => {
-                vec.push(Some(buf));
+                vec.push(buf);
                 nulls.push(false);
             }
             Ok(false) | Err(_) => {
-                vec.push(None);
+                vec.push(Vec::new());
                 nulls.push(true);
             }
         }
@@ -478,21 +478,13 @@ where
     fn push_text(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
-        vec: &mut Vec<Option<String>>,
+        vec: &mut Vec<String>,
         nulls: &mut Vec<bool>,
     ) {
-        let mut buf = Vec::new();
-        match cursor_row.get_text(col_index, &mut buf) {
-            Ok(true) => {
-                let s = String::from_utf8_lossy(&buf).to_string();
-                vec.push(Some(s));
-                nulls.push(false);
-            }
-            Ok(false) | Err(_) => {
-                vec.push(None);
-                nulls.push(true);
-            }
-        }
+        let mut buf = Vec::<u16>::new();
+        let txt = cursor_row.get_wide_text(col_index, &mut buf);
+        vec.push(String::from_utf16_lossy(&buf).to_string());
+        nulls.push(!txt.unwrap_or(false));
     }
 
     fn push_from_cursor_row(

sqlx-core/src/odbc/connection/odbc_bridge.rs

@@ -113,7 +113,7 @@ mod tests {
                 nulls: vec![false],
             }),
             Arc::new(ColumnData {
-                values: OdbcValueVec::Text(vec![Some("test".to_string())]),
+                values: OdbcValueVec::Text(vec!["test".to_string()]),
                 type_info: OdbcTypeInfo::new(DataType::Varchar { length: None }),
                 nulls: vec![false],
             }),

sqlx-core/src/odbc/row.rs

@@ -115,7 +115,7 @@ mod tests {
     }
 
     fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
-        make_ref(OdbcValueVec::Text(vec![Some(text.to_string())]), data_type)
+        make_ref(OdbcValueVec::Text(vec![text.to_string()]), data_type)
     }
 
     fn create_test_value_int(value: i64, data_type: DataType) -> OdbcValueRef<'static> {
@@ -316,7 +316,7 @@ mod tests {
     #[test]
     fn test_bool_decode_error_handling() {
         let column = ColumnData {
-            values: OdbcValueVec::Text(vec![Some("not_a_bool".to_string())]),
+            values: OdbcValueVec::Text(vec!["not_a_bool".to_string()]),
             type_info: OdbcTypeInfo::BIT,
             nulls: vec![false],
         };

sqlx-core/src/odbc/types/bool.rs

@@ -96,11 +96,11 @@ mod tests {
     }
 
     fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
-        make_ref(OdbcValueVec::Text(vec![Some(text.to_string())]), data_type)
+        make_ref(OdbcValueVec::Text(vec![text.to_string()]), data_type)
     }
 
     fn create_test_value_blob(data: &'static [u8], data_type: DataType) -> OdbcValueRef<'static> {
-        make_ref(OdbcValueVec::Binary(vec![Some(data.to_vec())]), data_type)
+        make_ref(OdbcValueVec::Binary(vec![data.to_vec()]), data_type)
     }
 
     #[test]
@@ -196,7 +196,7 @@ mod tests {
     #[test]
     fn test_decode_error_handling() {
         let column = ColumnData {
-            values: OdbcValueVec::Text(vec![Some("not_bytes".to_string())]),
+            values: OdbcValueVec::Text(vec!["not_bytes".to_string()]),
             type_info: OdbcTypeInfo::varbinary(None),
             nulls: vec![false],
         };

sqlx-core/src/odbc/types/bytes.rs

@@ -489,7 +489,7 @@ mod tests {
     }
 
     fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
-        make_ref(OdbcValueVec::Text(vec![Some(text.to_string())]), data_type)
+        make_ref(OdbcValueVec::Text(vec![text.to_string()]), data_type)
     }
 
     fn create_test_value_int(value: i64, data_type: DataType) -> OdbcValueRef<'static> {
@@ -501,7 +501,7 @@ mod tests {
     }
 
     fn create_test_value_blob(data: &'static [u8], data_type: DataType) -> OdbcValueRef<'static> {
-        make_ref(OdbcValueVec::Binary(vec![Some(data.to_vec())]), data_type)
+        make_ref(OdbcValueVec::Binary(vec![data.to_vec()]), data_type)
     }
 
     #[test]
@@ -636,7 +636,7 @@ mod tests {
 
         // From empty
         let column = ColumnData {
-            values: OdbcValueVec::Text(vec![None]),
+            values: OdbcValueVec::Text(vec![String::new()]),
             type_info: OdbcTypeInfo::new(DataType::Date),
             nulls: vec![true],
         };