odbc fetch batch

sqlx-core/src/any/mod.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/row.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/value.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/error.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,14 +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)`
-    format!(
-        "mismatched types; Rust type `{}` (as SQL type `{}`) is not compatible with SQL type `{}`",
-        type_name::<T>(),
-        T::type_info().name(),
-        ty.name()
-    )
-    .into()
+    Box::new(MismatchedTypeError {
+        rust_type: format!(
+            "{} ({}compatible with SQL type `{}`)",
+            type_name::<T>(),
+            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/odbc/connection/mod.rs

@@ -1,7 +1,8 @@
 use crate::connection::Connection;
 use crate::error::Error;
 use crate::odbc::{
-    Odbc, OdbcArguments, OdbcColumn, OdbcConnectOptions, OdbcQueryResult, OdbcRow, OdbcTypeInfo,
+    Odbc, OdbcArguments, OdbcBufferSettings, OdbcColumn, OdbcConnectOptions, OdbcQueryResult,
+    OdbcRow, OdbcTypeInfo,
 };
 use crate::transaction::Transaction;
 use either::Either;
@@ -67,12 +68,14 @@ pub(super) fn decode_column_name<T: ColumnNameDecode>(name: T, index: u16) -> St
 pub struct OdbcConnection {
     pub(crate) conn: SharedConnection<'static>,
     pub(crate) stmt_cache: HashMap<Arc<str>, SharedPreparedStatement>,
+    pub(crate) buffer_settings: OdbcBufferSettings,
 }
 
 impl std::fmt::Debug for OdbcConnection {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("OdbcConnection")
             .field("conn", &self.conn)
+            .field("buffer_settings", &self.buffer_settings)
             .finish()
     }
 }
@@ -108,6 +111,7 @@ impl OdbcConnection {
         Ok(Self {
             conn: shared_conn,
             stmt_cache: HashMap::new(),
+            buffer_settings: options.buffer_settings,
         })
     }
 
@@ -162,9 +166,10 @@ impl OdbcConnection {
         };
 
         let conn = Arc::clone(&self.conn);
+        let buffer_settings = self.buffer_settings;
         sqlx_rt::spawn(sqlx_rt::spawn_blocking(move || {
             let mut conn = conn.lock().expect("failed to lock connection");
-            if let Err(e) = execute_sql(&mut conn, maybe_prepared, args, &tx) {
+            if let Err(e) = execute_sql(&mut conn, maybe_prepared, args, &tx, buffer_settings) {
                 let _ = tx.send(Err(e));
             }
         }));