pub trait AsyncConnection:
Sized
+ SimpleAsyncConnection
+ Send {
type ExecuteFuture<'conn, 'query>: Future<Output = Result<usize, Error>> + Send
where Self: 'conn;
type LoadFuture<'conn, 'query>: Future<Output = Result<Self::Stream<'conn, 'query>, Error>> + Send
where Self: 'conn;
type Stream<'conn, 'query>: Stream<Item = Result<Self::Row<'conn, 'query>, Error>> + Send
where Self: 'conn;
type Row<'conn, 'query>: Row<'conn, Self::Backend>
where Self: 'conn;
type Backend: Backend;
// Required method
fn establish<'life0, 'async_trait>(
database_url: &'life0 str,
) -> Pin<Box<dyn Future<Output = Result<Self, ConnectionError>> + Send + 'async_trait>>
where 'life0: 'async_trait,
Self: 'async_trait;
// Provided methods
fn transaction<'a, 'life0, 'async_trait, R, E, F>(
&'life0 mut self,
callback: F,
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>
where 'a: 'async_trait,
'life0: 'async_trait,
F: for<'r> FnOnce(&'r mut Self) -> Pin<Box<dyn ScopedFuture<'a, 'r, PhantomData<&'r &'a ()>, Output = Result<R, E>> + Send + 'r>> + Send + 'a + 'async_trait,
E: From<Error> + Send + 'a + 'async_trait,
R: Send + 'a + 'async_trait,
Self: 'async_trait { ... }
fn begin_test_transaction<'life0, 'async_trait>(
&'life0 mut self,
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait,
Self: 'async_trait { ... }
fn test_transaction<'a, 'async_trait, R, E, F>(
&'a mut self,
f: F,
) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>
where 'a: 'async_trait,
F: for<'r> FnOnce(&'r mut Self) -> Pin<Box<dyn ScopedFuture<'a, 'r, PhantomData<&'r &'a ()>, Output = Result<R, E>> + Send + 'r>> + Send + 'a + 'async_trait,
E: Debug + Send + 'a + 'async_trait,
R: Send + 'a + 'async_trait,
Self: 'a + 'async_trait { ... }
}Expand description
An async connection to a database
This trait represents a n async database connection. It can be used to query the database through
the query dsl provided by diesel, custom extensions or raw sql queries. It essentially mirrors
the sync diesel Connection implementation
Required Associated Types§
Sourcetype ExecuteFuture<'conn, 'query>: Future<Output = Result<usize, Error>> + Send
where
Self: 'conn
type ExecuteFuture<'conn, 'query>: Future<Output = Result<usize, Error>> + Send where Self: 'conn
The future returned by AsyncConnection::execute
Sourcetype LoadFuture<'conn, 'query>: Future<Output = Result<Self::Stream<'conn, 'query>, Error>> + Send
where
Self: 'conn
type LoadFuture<'conn, 'query>: Future<Output = Result<Self::Stream<'conn, 'query>, Error>> + Send where Self: 'conn
The future returned by AsyncConnection::load
Sourcetype Stream<'conn, 'query>: Stream<Item = Result<Self::Row<'conn, 'query>, Error>> + Send
where
Self: 'conn
type Stream<'conn, 'query>: Stream<Item = Result<Self::Row<'conn, 'query>, Error>> + Send where Self: 'conn
The inner stream returned by AsyncConnection::load
Required Methods§
Sourcefn establish<'life0, 'async_trait>(
database_url: &'life0 str,
) -> Pin<Box<dyn Future<Output = Result<Self, ConnectionError>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn establish<'life0, 'async_trait>(
database_url: &'life0 str,
) -> Pin<Box<dyn Future<Output = Result<Self, ConnectionError>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
Establishes a new connection to the database
The argument to this method and the method’s behavior varies by backend. See the documentation for that backend’s connection class for details about what it accepts and how it behaves.
Provided Methods§
Sourcefn transaction<'a, 'life0, 'async_trait, R, E, F>(
&'life0 mut self,
callback: F,
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>
fn transaction<'a, 'life0, 'async_trait, R, E, F>( &'life0 mut self, callback: F, ) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>
Executes the given function inside of a database transaction
This function executes the provided closure f inside a database
transaction. If there is already an open transaction for the current
connection savepoints will be used instead. The connection is committed if
the closure returns Ok(_), it will be rolled back if it returns Err(_).
For both cases the original result value will be returned from this function.
If the transaction fails to commit due to a SerializationFailure or a
ReadOnlyTransaction a rollback will be attempted.
If the rollback fails, the error will be returned in a
Error::RollbackErrorOnCommit,
from which you will be able to extract both the original commit error and
the rollback error.
In addition, the connection will be considered broken
as it contains a uncommitted unabortable open transaction. Any further
interaction with the transaction system will result in an returned error
in this case.
If the closure returns an Err(_) and the rollback fails the function
will return that rollback error directly, and the transaction manager will
be marked as broken as it contains a uncommitted unabortable open transaction.
If a nested transaction fails to release the corresponding savepoint the error will be returned directly.
WARNING: Canceling the returned future does currently not close an already open transaction. You may end up with a connection containing a dangling transaction.
§Example
use diesel::result::Error;
use scoped_futures::ScopedFutureExt;
use diesel_async::{RunQueryDsl, AsyncConnection};
conn.transaction::<_, Error, _>(|conn| async move {
diesel::insert_into(users)
.values(name.eq("Ruby"))
.execute(conn)
.await?;
let all_names = users.select(name).load::<String>(conn).await?;
assert_eq!(vec!["Sean", "Tess", "Ruby"], all_names);
Ok(())
}.scope_boxed()).await?;
conn.transaction::<(), _, _>(|conn| async move {
diesel::insert_into(users)
.values(name.eq("Pascal"))
.execute(conn)
.await?;
let all_names = users.select(name).load::<String>(conn).await?;
assert_eq!(vec!["Sean", "Tess", "Ruby", "Pascal"], all_names);
// If we want to roll back the transaction, but don't have an
// actual error to return, we can return `RollbackTransaction`.
Err(Error::RollbackTransaction)
}.scope_boxed()).await;
let all_names = users.select(name).load::<String>(conn).await?;
assert_eq!(vec!["Sean", "Tess", "Ruby"], all_names);Sourcefn begin_test_transaction<'life0, 'async_trait>(
&'life0 mut self,
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn begin_test_transaction<'life0, 'async_trait>(
&'life0 mut self,
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction
Sourcefn test_transaction<'a, 'async_trait, R, E, F>(
&'a mut self,
f: F,
) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>
fn test_transaction<'a, 'async_trait, R, E, F>( &'a mut self, f: F, ) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>
Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.
§Example
use diesel::result::Error;
use scoped_futures::ScopedFutureExt;
use diesel_async::{RunQueryDsl, AsyncConnection};
conn.test_transaction::<_, Error, _>(|conn| async move {
diesel::insert_into(users)
.values(name.eq("Ruby"))
.execute(conn)
.await?;
let all_names = users.select(name).load::<String>(conn).await?;
assert_eq!(vec!["Sean", "Tess", "Ruby"], all_names);
Ok(())
}.scope_boxed()).await;
// Even though we returned `Ok`, the transaction wasn't committed.
let all_names = users.select(name).load::<String>(conn).await?;
assert_eq!(vec!["Sean", "Tess"], all_names);Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.