refactor(odbc): remove run_blocking helper and directly use spawn_blocking

This commit eliminates the run_blocking function from the ODBC module, replacing its usage with the spawn_blocking function directly in the OdbcConnection implementation. This change simplifies the code and enhances clarity in handling blocking tasks.

Author: lovasoa

sqlx-core/src/odbc/blocking.rs

@@ -1,19 +1,18 @@
 use crate::connection::Connection;
 use crate::error::Error;
-use crate::odbc::blocking::run_blocking;
 use crate::odbc::{
     Odbc, OdbcArguments, OdbcColumn, OdbcConnectOptions, OdbcQueryResult, OdbcRow, OdbcTypeInfo,
 };
 use crate::transaction::Transaction;
 use either::Either;
+use sqlx_rt::spawn_blocking;
 mod odbc_bridge;
+use crate::odbc::{OdbcStatement, OdbcStatementMetadata};
 use futures_core::future::BoxFuture;
 use futures_util::future;
 use odbc_api::ConnectionTransitions;
-use odbc_bridge::{establish_connection, execute_sql};
-// no direct spawn_blocking here; use run_blocking helper
-use crate::odbc::{OdbcStatement, OdbcStatementMetadata};
 use odbc_api::{handles::StatementConnection, Prepared, ResultSetMetadata, SharedConnection};
+use odbc_bridge::{establish_connection, execute_sql};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
@@ -70,7 +69,7 @@ impl OdbcConnection {
         S: std::fmt::Display + Send + 'static,
     {
         let conn = Arc::clone(&self.conn);
-        run_blocking(move || {
+        spawn_blocking(move || {
             let mut conn_guard = conn.lock().map_err(|_| {
                 Error::Protocol(format!("ODBC {}: failed to lock connection", operation))
             })?;
@@ -80,7 +79,7 @@ impl OdbcConnection {
     }
 
     pub(crate) async fn establish(options: &OdbcConnectOptions) -> Result<Self, Error> {
-        let shared_conn = run_blocking({
+        let shared_conn = spawn_blocking({
             let options = options.clone();
             move || {
                 let conn = establish_connection(&options)?;
@@ -174,13 +173,13 @@ impl OdbcConnection {
         let conn = Arc::clone(&self.conn);
         let sql_arc = Arc::from(sql.to_string());
         let sql_clone = Arc::clone(&sql_arc);
-        let (prepared, metadata) = run_blocking(move || {
+        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)),
             };
-            Ok((prepared, metadata))
+            Ok::<_, Error>((prepared, metadata))
         })
         .await?;
         self.stmt_cache

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

@@ -24,7 +24,6 @@
 use crate::executor::Executor;
 
 mod arguments;
-mod blocking;
 mod column;
 mod connection;
 mod database;

sqlx-core/src/odbc/mod.rs

@@ -1,7 +1,7 @@
 pub use tokio::{
     self, fs, io::AsyncRead, io::AsyncReadExt, io::AsyncWrite, io::AsyncWriteExt, io::ReadBuf,
-    net::TcpStream, runtime::Handle, sync::Mutex as AsyncMutex, task::spawn, task::spawn_blocking,
-    task::yield_now, time::sleep, time::timeout,
+    net::TcpStream, runtime::Handle, sync::Mutex as AsyncMutex, task::spawn, task::yield_now,
+    time::sleep, time::timeout,
 };
 
 #[cfg(unix)]
@@ -45,3 +45,14 @@ pub fn test_block_on<F: std::future::Future>(future: F) -> F::Output {
         .expect("failed to initialize Tokio test runtime")
         .block_on(future)
 }
+
+/// Spawn a blocking task. Panics if the task panics.
+pub async fn spawn_blocking<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R + Send + 'static,
+    R: Send + 'static,
+{
+    tokio::task::spawn_blocking(f)
+        .await
+        .expect("blocking task panicked")
+}