Remove unnecessary BoxFutures

Author: joeydewaal

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

@@ -71,40 +71,40 @@ impl Connection for AnyConnection {
 
     type Options = AnyConnectOptions;
 
-    fn close(self) -> BoxFuture<'static, Result<(), Error>> {
-        self.backend.close()
+    async fn close(self) -> Result<(), Error> {
+        self.backend.close().await
     }
 
-    fn close_hard(self) -> BoxFuture<'static, Result<(), Error>> {
-        self.backend.close()
+    async fn close_hard(self) -> Result<(), Error> {
+        self.backend.close().await
     }
 
-    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>> {
-        self.backend.ping()
+    async fn ping(&mut self) -> Result<(), Error> {
+        self.backend.ping().await
     }
 
-    fn begin(&mut self) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    async fn begin(&mut self) -> Result<Transaction<'_, Self::Database>, Error>
     where
         Self: Sized,
     {
-        Transaction::begin(self)
+        Transaction::begin(self).await
     }
 
     fn cached_statements_size(&self) -> usize {
         self.backend.cached_statements_size()
     }
 
-    fn clear_cached_statements(&mut self) -> BoxFuture<'_, crate::Result<()>> {
-        self.backend.clear_cached_statements()
+    async fn clear_cached_statements(&mut self) -> crate::Result<()> {
+        self.backend.clear_cached_statements().await
     }
 
     fn shrink_buffers(&mut self) {
         self.backend.shrink_buffers()
     }
 
     #[doc(hidden)]
-    fn flush(&mut self) -> BoxFuture<'_, Result<(), Error>> {
-        self.backend.flush()
+    async fn flush(&mut self) -> Result<(), Error> {
+        self.backend.flush().await
     }
 
     #[doc(hidden)]

sqlx-core/src/any/options.rs

@@ -48,8 +48,8 @@ impl ConnectOptions for AnyConnectOptions {
     }
 
     #[inline]
-    fn connect(&self) -> BoxFuture<'_, Result<AnyConnection, Error>> {
-        AnyConnection::connect(self)
+    async fn connect(&self) -> Result<AnyConnection, Error> {
+        AnyConnection::connect(self).await
     }
 
     fn log_statements(mut self, level: LevelFilter) -> Self {

sqlx-core/src/any/transaction.rs

@@ -1,5 +1,3 @@
-use futures_util::future::BoxFuture;
-
 use crate::any::{Any, AnyConnection};
 use crate::error::Error;
 use crate::transaction::TransactionManager;
@@ -9,16 +7,16 @@ pub struct AnyTransactionManager;
 impl TransactionManager for AnyTransactionManager {
     type Database = Any;
 
-    fn begin(conn: &mut AnyConnection) -> BoxFuture<'_, Result<(), Error>> {
-        conn.backend.begin()
+    async fn begin(conn: &mut AnyConnection) -> Result<(), Error> {
+        conn.backend.begin().await
     }
 
-    fn commit(conn: &mut AnyConnection) -> BoxFuture<'_, Result<(), Error>> {
-        conn.backend.commit()
+    async fn commit(conn: &mut AnyConnection) -> Result<(), Error> {
+        conn.backend.commit().await
     }
 
-    fn rollback(conn: &mut AnyConnection) -> BoxFuture<'_, Result<(), Error>> {
-        conn.backend.rollback()
+    async fn rollback(conn: &mut AnyConnection) -> Result<(), Error> {
+        conn.backend.rollback().await
     }
 
     fn start_rollback(conn: &mut AnyConnection) {

sqlx-core/src/connection.rs

@@ -1,4 +1,5 @@
 use crate::database::{Database, HasStatementCache};
+use std::future::Future;
 use crate::error::Error;
 
 use crate::transaction::Transaction;
@@ -31,21 +32,21 @@ pub trait Connection: Send {
     ///
     /// Therefore it is recommended to call `.close()` on a connection when you are done using it
     /// and to `.await` the result to ensure the termination message is sent.
-    fn close(self) -> BoxFuture<'static, Result<(), Error>>;
+    fn close(self) -> impl Future<Output = Result<(), Error>> + Send + 'static;
 
     /// Immediately close the connection without sending a graceful shutdown.
     ///
     /// This should still at least send a TCP `FIN` frame to let the server know we're dying.
     #[doc(hidden)]
-    fn close_hard(self) -> BoxFuture<'static, Result<(), Error>>;
+    fn close_hard(self) -> impl Future<Output = Result<(), Error>> + Send + 'static;
 
     /// Checks if a connection to the database is still valid.
-    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>;
+    fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     /// Begin a new transaction or establish a savepoint within the active transaction.
     ///
     /// Returns a [`Transaction`] for controlling and tracking the new transaction.
-    fn begin(&mut self) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    fn begin(&mut self) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized;
 
@@ -66,7 +67,7 @@ pub trait Connection: Send {
     /// })).await
     /// # }
     /// ```
-    fn transaction<'a, F, R, E>(&'a mut self, callback: F) -> BoxFuture<'a, Result<R, E>>
+    fn transaction<'a, F, R, E>(&'a mut self, callback: F) -> impl Future<Output = Result<R, E>> + Send + 'a
     where
         for<'c> F: FnOnce(&'c mut Transaction<'_, Self::Database>) -> BoxFuture<'c, Result<R, E>>
             + 'a
@@ -105,11 +106,11 @@ pub trait Connection: Send {
 
     /// Removes all statements from the cache, closing them on the server if
     /// needed.
-    fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>
+    fn clear_cached_statements(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_
     where
         Self::Database: HasStatementCache,
     {
-        Box::pin(async move { Ok(()) })
+        async { Ok(()) }
     }
 
     /// Restore any buffers in the connection to their default capacity, if possible.
@@ -127,7 +128,7 @@ pub trait Connection: Send {
     fn shrink_buffers(&mut self);
 
     #[doc(hidden)]
-    fn flush(&mut self) -> BoxFuture<'_, Result<(), Error>>;
+    fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     #[doc(hidden)]
     fn should_flush(&self) -> bool;
@@ -136,7 +137,7 @@ pub trait Connection: Send {
     ///
     /// A value of [`Options`][Self::Options] is parsed from the provided connection string. This parsing
     /// is database-specific.
-    #[inline]
+     #[inline]
     fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>>
     where
         Self: Sized,
@@ -146,12 +147,13 @@ pub trait Connection: Send {
         Box::pin(async move { Self::connect_with(&options?).await })
     }
 
+
     /// Establish a new database connection with the provided options.
-    fn connect_with(options: &Self::Options) -> BoxFuture<'_, Result<Self, Error>>
+    fn connect_with<'a>(options: &'a Self::Options) -> BoxFuture<'_, Result<Self, Error>>
     where
-        Self: Sized,
+        Self: Sized + 'a,
     {
-        options.connect()
+        Box::pin(options.connect())
     }
 }
 
@@ -219,7 +221,7 @@ pub trait ConnectOptions: 'static + Send + Sync + FromStr<Err = Error> + Debug +
     }
 
     /// Establish a new database connection with the options specified by `self`.
-    fn connect(&self) -> BoxFuture<'_, Result<Self::Connection, Error>>
+    fn connect(&self) -> impl Future<Output = Result<Self::Connection, Error>> + Send + '_
     where
         Self::Connection: Sized;
 

sqlx-core/src/transaction.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::future::Future;
 use std::fmt::{self, Debug, Formatter};
 use std::ops::{Deref, DerefMut};
 
@@ -18,17 +19,18 @@ pub trait TransactionManager {
     /// Begin a new transaction or establish a savepoint within the active transaction.
     fn begin(
         conn: &mut <Self::Database as Database>::Connection,
-    ) -> BoxFuture<'_, Result<(), Error>>;
+    ) -> impl Future<Output = Result<(), Error>> + Send;
 
     /// Commit the active transaction or release the most recent savepoint.
     fn commit(
         conn: &mut <Self::Database as Database>::Connection,
-    ) -> BoxFuture<'_, Result<(), Error>>;
+    ) -> impl Future<Output = Result<(), Error>> + Send;
 
     /// Abort the active transaction or restore from the most recent savepoint.
     fn rollback(
         conn: &mut <Self::Database as Database>::Connection,
-    ) -> BoxFuture<'_, Result<(), Error>>;
+    ) -> impl Future<Output = Result<(), Error>> + Send;
+
 
     /// Starts to abort the active transaction or restore from the most recent snapshot.
     fn start_rollback(conn: &mut <Self::Database as Database>::Connection);

sqlx-mysql/src/connection/mod.rs

@@ -1,6 +1,5 @@
 use std::fmt::{self, Debug, Formatter};
 
-use futures_core::future::BoxFuture;
 use futures_util::FutureExt;
 pub(crate) use sqlx_core::connection::*;
 pub(crate) use stream::{MySqlStream, Waiting};
@@ -52,66 +51,58 @@ impl Connection for MySqlConnection {
 
     type Options = MySqlConnectOptions;
 
-    fn close(mut self) -> BoxFuture<'static, Result<(), Error>> {
-        Box::pin(async move {
-            self.inner.stream.send_packet(Quit).await?;
-            self.inner.stream.shutdown().await?;
+    async fn close(mut self) -> Result<(), Error> {
+        self.inner.stream.send_packet(Quit).await?;
+        self.inner.stream.shutdown().await?;
 
-            Ok(())
-        })
+        Ok(())
     }
 
-    fn close_hard(mut self) -> BoxFuture<'static, Result<(), Error>> {
-        Box::pin(async move {
-            self.inner.stream.shutdown().await?;
-            Ok(())
-        })
+    async fn close_hard(mut self) -> Result<(), Error> {
+        self.inner.stream.shutdown().await?;
+        Ok(())
     }
 
-    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async move {
-            self.inner.stream.wait_until_ready().await?;
-            self.inner.stream.send_packet(Ping).await?;
-            self.inner.stream.recv_ok().await?;
+    async fn ping(&mut self) -> Result<(), Error> {
+        self.inner.stream.wait_until_ready().await?;
+        self.inner.stream.send_packet(Ping).await?;
+        self.inner.stream.recv_ok().await?;
 
-            Ok(())
-        })
+        Ok(())
     }
 
     #[doc(hidden)]
-    fn flush(&mut self) -> BoxFuture<'_, Result<(), Error>> {
-        self.inner.stream.wait_until_ready().boxed()
+    async fn flush(&mut self) -> Result<(), Error> {
+        self.inner.stream.wait_until_ready().await
     }
 
     fn cached_statements_size(&self) -> usize {
         self.inner.cache_statement.len()
     }
 
-    fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async move {
-            while let Some((statement_id, _)) = self.inner.cache_statement.remove_lru() {
-                self.inner
-                    .stream
-                    .send_packet(StmtClose {
-                        statement: statement_id,
-                    })
-                    .await?;
-            }
-
-            Ok(())
-        })
+    async fn clear_cached_statements(&mut self) -> Result<(), Error> {
+        while let Some((statement_id, _)) = self.inner.cache_statement.remove_lru() {
+            self.inner
+                .stream
+                .send_packet(StmtClose {
+                    statement: statement_id,
+                })
+                .await?;
+        }
+
+        Ok(())
     }
 
     #[doc(hidden)]
     fn should_flush(&self) -> bool {
         !self.inner.stream.write_buffer().is_empty()
     }
 
-    fn begin(&mut self) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    async fn begin(&mut self) -> Result<Transaction<'_, Self::Database>, Error>
     where
         Self: Sized,
     {
-        Transaction::begin(self)
+        Transaction::begin(self).await
     }
 
     fn shrink_buffers(&mut self) {