Struct WriteTransaction

pub struct WriteTransaction { /* private fields */ }

Transaction that allows both reading and writing.

At most one task can hold a write transaction at any time. Any other tasks are blocked on calling begin_write until the task that currently holds it is done with it (commits it or rolls it back). Performing read-only operations concurrently while a write transaction is in use is still allowed. Those operations will not see the writes performed via the write transaction until that transaction is committed however.

Implementations

impl WriteTransaction

pub async fn commit(self) -> Result<(), Error>

Commits the transaction.

Cancel safety

If the future returned by this function is cancelled before completion, the transaction is guaranteed to be either committed or rolled back but there is no way to tell in advance which of the two operations happens.

pub async fn commit_and_then<F, R>(self, f: F) -> Result<R, Error>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Commits the transaction and if (and only if) the commit completes successfully, runs the given closure.

Atomicity

If the commit succeeds, the closure is guaranteed to complete before another write transaction begins.

Cancel safety

The commits completes and if it succeeds the closure gets called. This is guaranteed to happen even if the future returned from this function is cancelled before completion.

Insufficient alternatives

Calling commit().await? and then calling f()

This is not enough because it has these possible outcomes depending on whether and when cancellation happened:

1. commit completes successfully and f is called
2. commit completes with error and f is not called
3. commit is cancelled but the transaction is still committed and f is not called
4. commit is cancelled and the transaction rolls back and f is not called

Number 3 is typically not desirable.

Calling f using a RAII guard

This is still not enough because it has the following possible outcomes:

1. commit completes successfully and f is called
2. commit completes with error and f is called
3. commit is cancelled but the transaction is still committed and f is called
4. commit is cancelled and the transaction rolls back and f is called

Numbers 2 and 4 are not desirable. Number 2 can be handled by explicitly handling the error case and disabling the guard but there is nothing to do about number 4.

Trait Implementations

impl Debug for WriteTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for WriteTransaction

type Target = ReadTransaction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for WriteTransaction

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'t> Executor<'t> for &'t mut WriteTransaction

type Database = Sqlite

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<SqliteQueryResult, SqliteRow>, Error>>

where E: Execute<'q, Sqlite> + 'q, 't: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<SqliteRow>, Error>>

where E: Execute<'q, Sqlite> + 'q, 't: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [SqliteTypeInfo], ) -> BoxFuture<'e, Result<SqliteStatement<'q>, Error>>

where 't: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.