fix(odbc): update type retrieval for integer and float conversions

This commit modifies the type retrieval logic in the OdbcValueRef implementation to use `std::any::type_name` for better accuracy. Additionally, it updates the handling of column data in the OdbcBridge, ensuring correct data types are used for SQLite's INTEGER and enhancing null handling in data fetching methods.

Author: lovasoa

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

@@ -10,7 +10,7 @@ use flume::{SendError, Sender};
 use odbc_api::buffers::{AnySlice, BufferDesc, ColumnarAnyBuffer};
 use odbc_api::handles::{AsStatementRef, CDataMut, Nullability, Statement};
 use odbc_api::parameter::CElement;
-use odbc_api::{Cursor, IntoParameter, ResultSetMetadata};
+use odbc_api::{Cursor, IntoParameter, Nullable, ResultSetMetadata};
 use std::sync::Arc;
 
 // Bulk fetch implementation using columnar buffers instead of row-by-row fetching
@@ -281,10 +281,11 @@ fn build_columns_from_cursor<C>(cursor: &mut C) -> Vec<OdbcColumn>
 where
     C: ResultSetMetadata,
 {
-    let column_count = cursor.num_result_cols().unwrap_or(0);
-    let mut columns = Vec::with_capacity(column_count as usize);
+    let column_count = cursor.num_result_cols().expect("no column count found");
+    let column_count = u16::try_from(column_count).expect("invalid column count");
+    let mut columns = Vec::with_capacity(usize::from(column_count));
     for index in 1..=column_count {
-        columns.push(create_column(cursor, index as u16));
+        columns.push(create_column(cursor, index));
     }
     columns
 }
@@ -408,7 +409,7 @@ where
         match dt {
             DataType::TinyInt => OdbcValueVec::TinyInt(Vec::with_capacity(capacity)),
             DataType::SmallInt => OdbcValueVec::SmallInt(Vec::with_capacity(capacity)),
-            DataType::Integer => OdbcValueVec::Integer(Vec::with_capacity(capacity)),
+            DataType::Integer => OdbcValueVec::BigInt(Vec::with_capacity(capacity)), // the SQLite driver reports "INTEGER" even though it supports 64-bit integers
             DataType::BigInt => OdbcValueVec::BigInt(Vec::with_capacity(capacity)),
             DataType::Real => OdbcValueVec::Real(Vec::with_capacity(capacity)),
             DataType::Float { .. } | DataType::Double => {
@@ -430,63 +431,62 @@ where
         col_index: u16,
         vec: &mut Vec<T>,
         nulls: &mut Vec<bool>,
-    ) {
-        push_get_data_with_default(cursor_row, col_index, vec, nulls, T::default());
-    }
-
-    fn push_get_data_with_default<T: Copy + CElement + CDataMut>(
-        cursor_row: &mut odbc_api::CursorRow<'_>,
-        col_index: u16,
-        vec: &mut Vec<T>,
-        nulls: &mut Vec<bool>,
-        default_val: T,
-    ) {
-        let mut tmp = default_val;
-        nulls.push(cursor_row.get_data(col_index, &mut tmp).is_err());
-        vec.push(tmp);
+    ) -> Result<(), odbc_api::Error>
+    where
+        Nullable<T>: CElement + CDataMut,
+    {
+        let mut tmp = Nullable::null();
+        cursor_row.get_data(col_index, &mut tmp)?;
+        let option = tmp.into_opt();
+        nulls.push(option.is_none());
+        vec.push(option.unwrap_or_default());
+        Ok(())
     }
 
     fn push_binary(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
         vec: &mut Vec<Vec<u8>>,
         nulls: &mut Vec<bool>,
-    ) {
+    ) -> Result<(), odbc_api::Error> {
         let mut buf = Vec::new();
         nulls.push(cursor_row.get_binary(col_index, &mut buf).is_err());
         vec.push(buf);
+        Ok(())
     }
 
     fn push_text(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
         vec: &mut Vec<String>,
         nulls: &mut Vec<bool>,
-    ) {
+    ) -> Result<(), odbc_api::Error> {
         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));
+        Ok(())
     }
 
     fn push_bit(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
         vec: &mut Vec<bool>,
         nulls: &mut Vec<bool>,
-    ) {
+    ) -> Result<(), odbc_api::Error> {
         let mut bit_val = odbc_api::Bit(0);
         let result = cursor_row.get_data(col_index, &mut bit_val);
         vec.push(bit_val.as_bool());
         nulls.push(result.is_err());
+        Ok(())
     }
 
     fn push_from_cursor_row(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
         values: &mut OdbcValueVec,
         nulls: &mut Vec<bool>,
-    ) {
+    ) -> Result<(), odbc_api::Error> {
         match values {
             OdbcValueVec::TinyInt(v) => push_get_data(cursor_row, col_index, v, nulls),
             OdbcValueVec::SmallInt(v) => push_get_data(cursor_row, col_index, v, nulls),
@@ -522,7 +522,7 @@ where
                     col_idx,
                     &mut value_vecs[col],
                     &mut nulls_vecs[col],
-                );
+                )?;
             }
             num_rows += 1;
             if num_rows == batch_size {

sqlx-core/src/odbc/value.rs

@@ -159,7 +159,7 @@ impl<'r> OdbcValueRef<'r> {
     pub fn try_int<T: TryFromInt + crate::types::Type<Odbc>>(&self) -> crate::error::Result<T> {
         self.int::<T>().ok_or_else(|| {
             crate::error::Error::Decode(Box::new(crate::error::MismatchedTypeError {
-                rust_type: T::type_info().name().to_string(),
+                rust_type: std::any::type_name::<T>().to_string(),
                 rust_sql_type: T::type_info().name().to_string(),
                 sql_type: self.batch.column_data[self.column_index]
                     .type_info
@@ -173,7 +173,7 @@ impl<'r> OdbcValueRef<'r> {
     pub fn try_float<T: TryFromFloat + crate::types::Type<Odbc>>(&self) -> crate::error::Result<T> {
         self.float::<T>().ok_or_else(|| {
             crate::error::Error::Decode(Box::new(crate::error::MismatchedTypeError {
-                rust_type: T::type_info().name().to_string(),
+                rust_type: std::any::type_name::<T>().to_string(),
                 rust_sql_type: T::type_info().name().to_string(),
                 sql_type: self.batch.column_data[self.column_index]
                     .type_info

tests/odbc/odbc.rs

@@ -543,6 +543,7 @@ async fn it_handles_mixed_null_and_values() -> anyhow::Result<()> {
         .fetch_all(&mut conn)
         .await?;
 
+    dbg!(&rows);
     assert_eq!(rows.len(), 2, "should have 2 rows");
     assert_eq!(rows[0].get::<Option<i32>, _>(0), Some(42));
     assert_eq!(rows[0].get::<Option<i32>, _>(1), None);