Struct diesel_async::pg::TransactionBuilder

pub struct TransactionBuilder<'a, C> { /* private fields */ }

Used to build a transaction, specifying additional details.

This struct is returned by AsyncPgConnection::build_transaction. See the documentation for methods on this struct for usage examples. See the PostgreSQL documentation for SET TRANSACTION for details on the behavior of each option.

Implementations

impl<'a, C> TransactionBuilder<'a, C>

where C: AsyncConnection<Backend = Pg, TransactionManager = AnsiTransactionManager>,

pub fn read_only(self) -> Self

Makes the transaction READ ONLY

Example

use diesel_async::RunQueryDsl;
conn.build_transaction()
    .read_only()
    .run::<_, diesel::result::Error, _>(|conn| Box::pin(async move {
        let read_attempt = users.select(name).load::<String>(conn).await;
        assert!(read_attempt.is_ok());

        let write_attempt = diesel::insert_into(users)
            .values(name.eq("Ruby"))
            .execute(conn)
            .await;
        assert!(write_attempt.is_err());

        Ok(())
    }) as _).await?;

pub fn read_write(self) -> Self

Makes the transaction READ WRITE

This is the default, unless you’ve changed the default_transaction_read_only configuration parameter.

Example

use diesel_async::RunQueryDsl;

conn.build_transaction()
    .read_write()
    .run(|conn| Box::pin( async move {
        let read_attempt = users.select(name).load::<String>(conn).await;
        assert!(read_attempt.is_ok());

        let write_attempt = diesel::insert_into(users)
            .values(name.eq("Ruby"))
            .execute(conn)
            .await;
        assert!(write_attempt.is_ok());

        Ok(())
    }) as _)
    .await

pub fn deferrable(self) -> Self

Makes the transaction DEFERRABLE

Example

conn.build_transaction()
    .deferrable()
    .run(|conn| Box::pin(async { Ok(()) }))
    .await

pub fn not_deferrable(self) -> Self

Makes the transaction NOT DEFERRABLE

This is the default, unless you’ve changed the default_transaction_deferrable configuration parameter.

Example

conn.build_transaction()
    .not_deferrable()
    .run(|conn| Box::pin(async { Ok(()) }) as _)
    .await

pub fn read_committed(self) -> Self

Makes the transaction ISOLATION LEVEL READ COMMITTED

This is the default, unless you’ve changed the default_transaction_isolation_level configuration parameter.

Example

conn.build_transaction()
    .read_committed()
    .run(|conn| Box::pin(async { Ok(()) }) as _)
    .await

pub fn repeatable_read(self) -> Self

Makes the transaction ISOLATION LEVEL REPEATABLE READ

Example

conn.build_transaction()
    .repeatable_read()
    .run(|conn| Box::pin(async { Ok(()) }) as _)
    .await

pub fn serializable(self) -> Self

Makes the transaction ISOLATION LEVEL SERIALIZABLE

Example

conn.build_transaction()
    .serializable()
    .run(|conn| Box::pin(async { Ok(()) }) as _)
    .await

pub async fn run<'b, T, E, F>(&mut self, f: F) -> Result<T, E>

where F: for<'r> FnOnce(&'r mut C) -> ScopedBoxFuture<'b, 'r, Result<T, E>> + Send + 'a, T: 'b, E: From<Error> + 'b,

Runs the given function inside of the transaction with the parameters given to this builder.

Returns an error if the connection is already inside a transaction, or if the transaction fails to commit or rollback

If the transaction fails to commit due to a SerializationFailure or a ReadOnlyTransaction a rollback will be attempted. If the rollback succeeds, the original error will be returned, otherwise the error generated by the rollback will be returned. In the second case the connection should be considered broken as it contains a uncommitted unabortable open transaction.

Trait Implementations

impl<'a, C> QueryFragment<Pg> for TransactionBuilder<'a, C>

fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, Pg>) -> QueryResult<()>

Walk over this QueryFragment for all passes.

fn to_sql( &self, out: &mut <DB as Backend>::QueryBuilder, backend: &DB, ) -> Result<(), Error>

Converts this QueryFragment to its SQL representation.

fn collect_binds<'b>( &'b self, out: &mut <DB as Backend>::BindCollector<'b>, metadata_lookup: &mut <DB as TypeMetadata>::MetadataLookup, backend: &'b DB, ) -> Result<(), Error>

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self, backend: &DB) -> Result<bool, Error>

Is this query safe to store in the prepared statement cache?

fn is_noop(&self, backend: &DB) -> Result<bool, Error>

Does walking this AST have any effect?