Merge with upstream

Author: martin-kolarik

.github/workflows/sqlx.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
     strategy:
       matrix:
-        runtime: [async-std, tokio]
+        runtime: [async-global-executor, async-std, tokio]
         tls: [native-tls, rustls, none]
     steps:
       - uses: actions/checkout@v4
@@ -116,7 +116,7 @@ jobs:
     runs-on: ubuntu-22.04
     strategy:
       matrix:
-        runtime: [async-std, tokio]
+        runtime: [async-global-executor, async-std, tokio]
         linking: [sqlite, sqlite-unbundled]
     needs: check
     steps:
@@ -183,7 +183,7 @@ jobs:
     strategy:
       matrix:
         postgres: [17, 13]
-        runtime: [async-std, tokio]
+        runtime: [async-global-executor, async-std, tokio]
         tls: [native-tls, rustls-aws-lc-rs, rustls-ring, none]
     needs: check
     steps:
@@ -283,7 +283,7 @@ jobs:
     strategy:
       matrix:
         mysql: [8]
-        runtime: [async-std, tokio]
+        runtime: [async-global-executor, async-std, tokio]
         tls: [native-tls, rustls-aws-lc-rs, rustls-ring, none]
     needs: check
     steps:
@@ -371,7 +371,7 @@ jobs:
     strategy:
       matrix:
         mariadb: [verylatest, 11_4, 10_11, 10_4]
-        runtime: [async-std, tokio]
+        runtime: [async-global-executor, async-std, tokio]
         tls: [native-tls, rustls-aws-lc-rs, rustls-ring, none]
     needs: check
     steps:

Cargo.lock

@@ -76,6 +76,7 @@ _unstable-all-types = [
 ]
 
 # Base runtime features without TLS
+runtime-async-global-executor = ["_rt-async-global-executor", "sqlx-core/_rt-async-global-executor", "sqlx-macros?/_rt-async-global-executor"]
 runtime-async-std = ["_rt-async-std", "sqlx-core/_rt-async-std", "sqlx-macros?/_rt-async-std"]
 runtime-tokio = ["_rt-tokio", "sqlx-core/_rt-tokio", "sqlx-macros?/_rt-tokio"]
 
@@ -92,13 +93,17 @@ tls-none = []
 
 # Legacy Runtime + TLS features
 
+runtime-async-global-executor-native-tls = ["runtime-async-global-executor", "tls-native-tls"]
+runtime-async-global-executor-rustls = ["runtime-async-global-executor", "tls-rustls-ring"]
+
 runtime-async-std-native-tls = ["runtime-async-std", "tls-native-tls"]
 runtime-async-std-rustls = ["runtime-async-std", "tls-rustls-ring"]
 
 runtime-tokio-native-tls = ["runtime-tokio", "tls-native-tls"]
 runtime-tokio-rustls = ["runtime-tokio", "tls-rustls-ring"]
 
 # for conditional compilation
+_rt-async-global-executor = []
 _rt-async-std = []
 _rt-tokio = []
 _sqlite = []
@@ -154,6 +159,11 @@ uuid = "1.1.2"
 dotenvy = { version = "0.15.0", default-features = false }
 
 # Runtimes
+[workspace.dependencies.async-global-executor]
+version = "3.1"
+default-features = false
+features = ["async-io"]
+
 [workspace.dependencies.async-std]
 version = "1.12"
 

Cargo.toml

@@ -19,7 +19,12 @@ any = []
 json = ["serde", "serde_json"]
 
 # for conditional compilation
-_rt-async-std = ["async-std", "async-io"]
+_rt-async-global-executor = [
+    "async-global-executor",
+    "async-io-global-executor",
+    "async-net",
+]
+_rt-async-std = ["async-std", "async-io-std"]
 _rt-tokio = ["tokio", "tokio-stream"]
 _tls-native-tls = ["native-tls"]
 _tls-rustls-aws-lc-rs = ["_tls-rustls", "rustls/aws-lc-rs", "webpki-roots"]
@@ -33,6 +38,7 @@ offline = ["serde", "either/serde"]
 
 [dependencies]
 # Runtimes
+async-global-executor = { workspace = true, optional = true }
 async-std = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true }
 
@@ -52,7 +58,9 @@ ipnetwork = { workspace = true, optional = true }
 mac_address = { workspace = true, optional = true }
 uuid = { workspace = true, optional = true }
 
-async-io = { version = "1.9.0", optional = true }
+async-io-global-executor = { package = "async-io", version = "2.2", optional = true }
+async-io-std = { package = "async-io", version = "1.9.0", optional = true }
+async-net = { package = "async-net", version = "2.0.0", optional = true }
 base64 = { version = "0.22.0", default-features = false, features = ["std"] }
 bytes = "1.1.0"
 chrono = { version = "0.4.34", default-features = false, features = ["clock"], optional = true }

sqlx-core/Cargo.toml

@@ -17,7 +17,7 @@
 #![allow(clippy::needless_doctest_main, clippy::type_complexity)]
 // The only unsafe code in SQLx is that necessary to interact with native APIs like with SQLite,
 // and that can live in its own separate driver crate.
-#![forbid(unsafe_code)]
+// #![forbid(unsafe_code)]
 // Allows an API be documented as only available in some specific platforms.
 // <https://doc.rust-lang.org/unstable-book/language-features/doc-cfg.html>
 #![cfg_attr(docsrs, feature(doc_cfg))]

sqlx-core/src/lib.rs

@@ -202,9 +202,43 @@ pub async fn connect_tcp<Ws: WithSocket>(
         return Ok(with_socket.with_socket(stream).await);
     }
 
+    #[cfg(feature = "_rt-async-global-executor")]
+    {
+        use async_io_global_executor::Async;
+        use async_net::resolve;
+        use std::net::TcpStream;
+
+        let mut last_err = None;
+
+        // Loop through all the Socket Addresses that the hostname resolves to
+        for socket_addr in resolve((host, port)).await? {
+            let stream = Async::<TcpStream>::connect(socket_addr)
+                .await
+                .and_then(|s| {
+                    s.get_ref().set_nodelay(true)?;
+                    Ok(s)
+                });
+            match stream {
+                Ok(stream) => return Ok(with_socket.with_socket(stream).await),
+                Err(e) => last_err = Some(e),
+            }
+        }
+
+        // If we reach this point, it means we failed to connect to any of the addresses.
+        // Return the last error we encountered, or a custom error if the hostname didn't resolve to any address.
+        return match last_err {
+            Some(err) => Err(err.into()),
+            None => Err(io::Error::new(
+                io::ErrorKind::AddrNotAvailable,
+                "Hostname did not resolve to any addresses",
+            )
+            .into()),
+        };
+    }
+
     #[cfg(feature = "_rt-async-std")]
     {
-        use async_io::Async;
+        use async_io_std::Async;
         use async_std::net::ToSocketAddrs;
         use std::net::TcpStream;
 
@@ -226,17 +260,18 @@ pub async fn connect_tcp<Ws: WithSocket>(
 
         // If we reach this point, it means we failed to connect to any of the addresses.
         // Return the last error we encountered, or a custom error if the hostname didn't resolve to any address.
-        match last_err {
+        return match last_err {
             Some(err) => Err(err.into()),
             None => Err(io::Error::new(
                 io::ErrorKind::AddrNotAvailable,
                 "Hostname did not resolve to any addresses",
             )
             .into()),
-        }
+        };
     }
 
-    #[cfg(not(feature = "_rt-async-std"))]
+    #[cfg(not(all(feature = "_rt-async-global-executor", feature = "_rt-async-std")))]
+    #[allow(unreachable_code)]
     {
         crate::rt::missing_rt((host, port, with_socket))
     }
@@ -260,17 +295,27 @@ pub async fn connect_uds<P: AsRef<Path>, Ws: WithSocket>(
             return Ok(with_socket.with_socket(stream).await);
         }
 
+        #[cfg(feature = "_rt-async-global-executor")]
+        {
+            use async_io_global_executor::Async;
+            use std::os::unix::net::UnixStream;
+
+            let stream = Async::<UnixStream>::connect(path).await?;
+
+            Ok(with_socket.with_socket(stream).await)
+        }
+
         #[cfg(feature = "_rt-async-std")]
         {
-            use async_io::Async;
+            use async_io_std::Async;
             use std::os::unix::net::UnixStream;
 
             let stream = Async::<UnixStream>::connect(path).await?;
 
             Ok(with_socket.with_socket(stream).await)
         }
 
-        #[cfg(not(feature = "_rt-async-std"))]
+        #[cfg(not(all(feature = "_rt-async-global-executor", feature = "_rt-async-std")))]
         {
             crate::rt::missing_rt((path, with_socket))
         }