refactor(odbc): update binary data handling in tests

This commit modifies the test for binary data handling to use UTF-8 safe bytes, ensuring compatibility with PostgreSQL. The data fetching logic is simplified by using `fetch_optional` and adjusting the assertion to directly compare the fetched result with the expected binary data.

Author: lovasoa

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

@@ -472,6 +472,18 @@ where
         nulls.push(!txt.unwrap_or(false));
     }
 
+    fn push_bit(
+        cursor_row: &mut odbc_api::CursorRow<'_>,
+        col_index: u16,
+        vec: &mut Vec<bool>,
+        nulls: &mut Vec<bool>,
+    ) {
+        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());
+    }
+
     fn push_from_cursor_row(
         cursor_row: &mut odbc_api::CursorRow<'_>,
         col_index: u16,
@@ -485,9 +497,7 @@ where
             OdbcValueVec::BigInt(v) => push_get_data(cursor_row, col_index, v, nulls),
             OdbcValueVec::Real(v) => push_get_data(cursor_row, col_index, v, nulls),
             OdbcValueVec::Double(v) => push_get_data(cursor_row, col_index, v, nulls),
-            OdbcValueVec::Bit(v) => {
-                push_get_data_with_default(cursor_row, col_index, v, nulls, odbc_api::Bit(0))
-            }
+            OdbcValueVec::Bit(v) => push_bit(cursor_row, col_index, v, nulls),
             OdbcValueVec::Date(v) => push_get_data(cursor_row, col_index, v, nulls),
             OdbcValueVec::Time(v) => push_get_data(cursor_row, col_index, v, nulls),
             OdbcValueVec::Timestamp(v) => push_get_data(cursor_row, col_index, v, nulls),

sqlx-core/src/odbc/value.rs

@@ -20,7 +20,7 @@ pub enum OdbcValueVec {
     Double(Vec<f64>),
 
     // Bit type
-    Bit(Vec<odbc_api::Bit>),
+    Bit(Vec<bool>),
 
     // Text types (inherently nullable in ODBC)
     Text(Vec<String>),
@@ -245,7 +245,7 @@ pub enum OdbcValueType {
     BigInt(i64),
     Real(f32),
     Double(f64),
-    Bit(odbc_api::Bit),
+    Bit(bool),
     Text(String),
     Binary(Vec<u8>),
     Date(odbc_api::sys::Date),
@@ -301,7 +301,10 @@ pub fn convert_any_slice_to_value_vec(slice: AnySlice<'_>) -> (OdbcValueVec, Vec
         AnySlice::F64(s) => handle_non_nullable_slice(s, OdbcValueVec::Double),
 
         // Non-nullable other types
-        AnySlice::Bit(s) => handle_non_nullable_slice(s, OdbcValueVec::Bit),
+        AnySlice::Bit(s) => {
+            let vec: Vec<bool> = s.iter().map(|bit| bit.as_bool()).collect();
+            (OdbcValueVec::Bit(vec), vec![false; s.len()])
+        }
         AnySlice::Date(s) => handle_non_nullable_slice(s, OdbcValueVec::Date),
         AnySlice::Time(s) => handle_non_nullable_slice(s, OdbcValueVec::Time),
         AnySlice::Timestamp(s) => handle_non_nullable_slice(s, OdbcValueVec::Timestamp),
@@ -320,7 +323,7 @@ pub fn convert_any_slice_to_value_vec(slice: AnySlice<'_>) -> (OdbcValueVec, Vec
                 OdbcValueVec::Bit(
                     values
                         .into_iter()
-                        .map(|opt| opt.unwrap_or(odbc_api::Bit(0)))
+                        .map(|opt| opt.map_or(false, |bit| bit.as_bool()))
                         .collect(),
                 ),
                 nulls,
@@ -332,33 +335,17 @@ pub fn convert_any_slice_to_value_vec(slice: AnySlice<'_>) -> (OdbcValueVec, Vec
             let mut values = Vec::with_capacity(s.len());
             let mut nulls = Vec::with_capacity(s.len());
             for bytes_opt in s.iter() {
-                match bytes_opt {
-                    Some(bytes) => {
-                        values.push(String::from_utf8_lossy(bytes).to_string());
-                        nulls.push(false);
-                    }
-                    None => {
-                        values.push(String::new());
-                        nulls.push(true);
-                    }
-                }
+                nulls.push(bytes_opt.is_none());
+                values.push(String::from_utf8_lossy(bytes_opt.unwrap_or_default()).into_owned());
             }
             (OdbcValueVec::Text(values), nulls)
         }
         AnySlice::Binary(s) => {
             let mut values = Vec::with_capacity(s.len());
             let mut nulls = Vec::with_capacity(s.len());
             for bytes_opt in s.iter() {
-                match bytes_opt {
-                    Some(bytes) => {
-                        values.push(bytes.to_vec());
-                        nulls.push(false);
-                    }
-                    None => {
-                        values.push(Vec::new());
-                        nulls.push(true);
-                    }
-                }
+                nulls.push(bytes_opt.is_none());
+                values.push(bytes_opt.unwrap_or_default().to_vec());
             }
             (OdbcValueVec::Binary(values), nulls)
         }
@@ -444,9 +431,6 @@ macro_rules! impl_int_conversion {
     ($vec:expr, $row_index:expr, $type:ty) => {
         <$type>::try_from(*$vec.get($row_index)?).ok()
     };
-    ($vec:expr, $row_index:expr, $type:ty, bit) => {
-        <$type>::try_from($vec.get($row_index)?.0).ok()
-    };
     ($vec:expr, $row_index:expr, $type:ty, text) => {
         if let Some(Some(text)) = $vec.get($row_index) {
             text.trim().parse().ok()
@@ -465,7 +449,7 @@ fn value_vec_int<T: TryFromInt>(column_data: &ColumnData, row_index: usize) -> O
         OdbcValueVec::SmallInt(v) => impl_int_conversion!(v, row_index, T),
         OdbcValueVec::Integer(v) => impl_int_conversion!(v, row_index, T),
         OdbcValueVec::BigInt(v) => impl_int_conversion!(v, row_index, T),
-        OdbcValueVec::Bit(v) => impl_int_conversion!(v, row_index, T, bit),
+        OdbcValueVec::Bit(v) => T::try_from(*v.get(row_index)? as u8).ok(),
         OdbcValueVec::Text(v) => v.get(row_index).and_then(|text| text.trim().parse().ok()),
         _ => None,
     }

tests/odbc/odbc.rs

@@ -440,16 +440,17 @@ async fn it_handles_binary_data() -> anyhow::Result<()> {
     let mut conn = new::<Odbc>().await?;
 
     // Test binary data - use UTF-8 safe bytes for PostgreSQL compatibility
-    let binary_data = b"ABCDE";
+    let binary_data = "Héllö world! 😀".as_bytes();
     let stmt = conn.prepare("SELECT ? AS binary_data").await?;
     let row = stmt
-        .query()
-        .bind(&binary_data[..])
-        .fetch_one(&mut conn)
-        .await?;
+        .query_as::<(Vec<u8>,)>()
+        .bind(binary_data)
+        .fetch_optional(&mut conn)
+        .await
+        .expect("query failed")
+        .expect("row expected");
 
-    let result = row.try_get_raw(0)?.to_owned().decode::<Vec<u8>>();
-    assert_eq!(result, binary_data);
+    assert_eq!(row.0, binary_data);
     Ok(())
 }