refactor(odbc): improve SQL execution handling and row count extraction

- Streamlined SQL execution logic to handle results immediately, reducing borrowing conflicts.
- Introduced a new function to extract the number of affected rows from ODBC statements, enhancing error handling and logging.
- Added a test to verify the correct reporting of affected rows for various SQL operations.

Author: lovasoa

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

@@ -449,31 +449,45 @@ fn execute_sql<'conn>(
     let params = prepare_parameters(args);
     let stmt = stmt_manager.get_or_create_direct_stmt()?;
     log::trace!("Starting execution of SQL: {}", sql);
-    let cursor_result = stmt.execute(sql, &params[..]);
-    log::trace!("Received cursor result for SQL: {}", sql);
-    send_exec_result(cursor_result, tx)?;
+
+    // Execute and handle result immediately to avoid borrowing conflicts
+    if let Some(mut cursor) = stmt.execute(sql, &params[..])? {
+        handle_cursor(&mut cursor, tx);
+        return Ok(());
+    }
+
+    // Execution completed without result set, get affected rows
+    let affected = extract_rows_affected(stmt);
+    let _ = send_done(tx, affected);
     Ok(())
 }
 
-// Unified execution logic for both direct and prepared statements
-fn send_exec_result<C>(
-    execution_result: Result<Option<C>, odbc_api::Error>,
-    tx: &ExecuteSender,
-) -> Result<(), Error>
-where
-    C: Cursor + ResultSetMetadata,
-{
-    match execution_result {
-        Ok(Some(mut cursor)) => {
-            handle_cursor(&mut cursor, tx);
-            Ok(())
+fn extract_rows_affected(stmt: &mut Preallocated<StatementImpl<'_>>) -> u64 {
+    let count_opt = match stmt.row_count() {
+        Ok(count_opt) => count_opt,
+        Err(e) => {
+            log::warn!("Failed to get ODBC row count: {}", e);
+            return 0;
         }
-        Ok(None) => {
-            let _ = send_done(tx, 0);
-            Ok(())
+    };
+
+    let count = match count_opt {
+        Some(count) => count,
+        None => {
+            log::debug!("ODBC row count is not available");
+            return 0;
         }
-        Err(e) => Err(Error::from(e)),
-    }
+    };
+
+    let affected = match u64::try_from(count) {
+        Ok(count) => count,
+        Err(e) => {
+            log::warn!("Failed to convert ODBC row count to u64: {}", e);
+            return 0;
+        }
+    };
+    log::trace!("ODBC statement affected {} rows", affected);
+    affected
 }
 
 fn prepare_parameters(

tests/any/any.rs

@@ -276,3 +276,34 @@ async fn it_has_unsigned_integers() -> anyhow::Result<()> {
     assert_eq!(max_value, get_val::<u64>(&expr).await?);
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn it_reports_rows_affected() -> anyhow::Result<()> {
+    let mut conn = new::<Any>().await?;
+
+    let dbms = conn.dbms_name().await.unwrap_or_default().to_lowercase();
+    let (create_sql, insert_sql, delete_sql) =
+        if dbms.contains("mssql") || dbms.contains("sql server") {
+            (
+                "CREATE TABLE #temp_rows_affected (id INT PRIMARY KEY)",
+                "INSERT INTO #temp_rows_affected (id) VALUES (1)",
+                "DELETE FROM #temp_rows_affected WHERE id = 1",
+            )
+        } else {
+            (
+                "CREATE TEMPORARY TABLE temp_rows_affected (id INTEGER PRIMARY KEY)",
+                "INSERT INTO temp_rows_affected (id) VALUES (1)",
+                "DELETE FROM temp_rows_affected WHERE id = 1",
+            )
+        };
+
+    conn.execute(create_sql).await?;
+
+    let insert_done = conn.execute(insert_sql).await?;
+    assert_eq!(insert_done.rows_affected(), 1);
+
+    let delete_done = conn.execute(delete_sql).await?;
+    assert_eq!(delete_done.rows_affected(), 1);
+
+    Ok(())
+}