fix(odbc): improve error handling in column collection and statement preparation

This commit updates the `collect_columns` and `create_column` functions to return `Result` types, enhancing error handling during column collection. Additionally, it refines tests for prepared statements to ensure proper error assertions when executing invalid SQL queries and binding incorrect parameter types.

Author: lovasoa

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

@@ -24,22 +24,24 @@ mod executor;
 type PreparedStatement = Prepared<StatementConnection<SharedConnection<'static>>>;
 type SharedPreparedStatement = Arc<Mutex<PreparedStatement>>;
 
-fn collect_columns(prepared: &mut PreparedStatement) -> Vec<OdbcColumn> {
-    let count = prepared.num_result_cols().unwrap_or(0);
-    (1..=count)
-        .map(|i| create_column(prepared, i as u16))
-        .collect()
+fn collect_columns(prepared: &mut PreparedStatement) -> Result<Vec<OdbcColumn>, Error> {
+    let count = prepared.num_result_cols()?;
+    let mut columns = Vec::with_capacity(count as usize);
+    for i in 1..=count {
+        columns.push(create_column(prepared, i as u16)?);
+    }
+    Ok(columns)
 }
 
-fn create_column(stmt: &mut PreparedStatement, index: u16) -> OdbcColumn {
+fn create_column(stmt: &mut PreparedStatement, index: u16) -> Result<OdbcColumn, Error> {
     let mut cd = odbc_api::ColumnDescription::default();
-    let _ = stmt.describe_col(index, &mut cd);
+    stmt.describe_col(index, &mut cd)?;
 
-    OdbcColumn {
+    Ok(OdbcColumn {
         name: decode_column_name(cd.name, index),
         type_info: OdbcTypeInfo::new(cd.data_type),
         ordinal: usize::from(index.checked_sub(1).unwrap()),
-    }
+    })
 }
 
 pub(super) trait ColumnNameDecode {
@@ -191,8 +193,8 @@ impl OdbcConnection {
         let (prepared, metadata) = spawn_blocking(move || {
             let mut prepared = conn.into_prepared(&sql_clone)?;
             let metadata = OdbcStatementMetadata {
-                columns: collect_columns(&mut prepared),
-                parameters: usize::from(prepared.num_params().unwrap_or(0)),
+                columns: collect_columns(&mut prepared)?,
+                parameters: usize::from(prepared.num_params()?),
             };
             Ok::<_, Error>((prepared, metadata))
         })

tests/odbc/odbc.rs

@@ -947,34 +947,17 @@ async fn it_handles_prepare_statement_errors() -> anyhow::Result<()> {
     }
 
     // Test executing prepared SQL with syntax errors
-    match conn
+    let res = conn
         .prepare("SELECT idonotexist FROM idonotexist WHERE idonotexist")
-        .await
-    {
-        Ok(stmt) => match stmt.query().fetch_one(&mut conn).await {
-            Ok(_) => panic!("should be an error"),
-            Err(sqlx_oldapi::Error::Database(err)) => {
-                assert!(
-                    err.to_string().contains("idonotexist"),
-                    "{:?} should contain 'idonotexist'",
-                    err
-                );
-            }
-            Err(err) => {
-                panic!("should be a database error, got {:?}", err);
-            }
-        },
-        Err(sqlx_oldapi::Error::Database(err)) => {
-            assert!(
-                err.to_string().to_lowercase().contains("idonotexist"),
-                "{:?} should contain 'idonotexist'",
-                err
-            );
-        }
-        Err(err) => {
-            panic!("should be an error, got {:?}", err);
-        }
-    }
+        .await;
+    let Err(sqlx_oldapi::Error::Database(err)) = res else {
+        panic!("should be an error, got {:?}", res);
+    };
+    assert!(
+        err.to_string().to_lowercase().contains("idonotexist"),
+        "{:?} should contain 'idonotexist'",
+        err
+    );
     Ok(())
 }
 
@@ -1185,23 +1168,25 @@ async fn it_handles_concurrent_error_scenarios() -> anyhow::Result<()> {
 }
 
 #[tokio::test]
-async fn it_handles_prepared_statement_with_wrong_parameters() -> anyhow::Result<()> {
+async fn it_handles_prepared_statement_with_wrong_parameter_count() -> anyhow::Result<()> {
     let mut conn = new::<Odbc>().await?;
 
     // Prepare a statement expecting specific parameter types
-    let stmt = conn.prepare("SELECT ? + ? AS sum").await?;
+    let stmt = conn.prepare("SELECT ? AS a, ? as b").await?;
 
     // Test binding incompatible types (if the database is strict about types)
     // Some databases/drivers are permissive, others are strict
-    let result = stmt
-        .query()
-        .bind("not_a_number")
-        .bind("also_not_a_number")
-        .fetch_one(&mut conn)
-        .await;
-    // This may or may not error depending on the database's type system
-    let _ = result;
-
+    let result = stmt.query().bind(42_i32).fetch_one(&mut conn).await;
+    let Err(sqlx_oldapi::Error::Database(err)) = result else {
+        panic!("should be an error, got {:?}", result);
+    };
+    // https://learn.microsoft.com/en-us/sql/odbc/reference/appendixes/appendix-a-odbc-error-codes?view=sql-server-ver17
+    // 07002 -> COUNT field incorrect
+    assert!(
+        err.to_string().contains("07002"),
+        "{:?} should contain '07002' (COUNT field incorrect)",
+        err
+    );
     Ok(())
 }