Struct TransactionMut

pub struct TransactionMut<'a, S> { /* private fields */ }

Same as Transaction, but allows inserting new rows.

TransactionMut always uses the latest version of the database, with the effects of all previous TransactionMuts applied.

To make mutations to the database permanent you need to use TransactionMut::commit. This is to make sure that if a function panics while holding a mutable transaction, it will roll back those changes.

Implementations

impl<'t, S: 'static> TransactionMut<'t, S>

pub fn try_insert<T: Table<Schema = S>, C>( &mut self, val: impl Writable<'t, T = T, Conflict = C, Schema = S>, ) -> Result<TableRow<'t, T>, C>

Try inserting a value into the database.

Returns Ok with a reference to the new inserted value or an Err with conflict information. The type of conflict information depends on the number of unique constraints on the table:

• 0 unique constraints => Infallible
• 1 unique constraint => TableRow reference to the conflicting table row.
• 2+ unique constraints => () no further information is provided.

pub fn insert<T: Table<Schema = S>>( &mut self, val: impl Writable<'t, T = T, Conflict = Infallible, Schema = S>, ) -> TableRow<'t, T>

This is a convenience function to make using TransactionMut::try_insert easier for tables without unique constraints.

The new row is added to the table and the row reference is returned.

pub fn find_or_insert<T: Table<Schema = S>>( &mut self, val: impl Writable<'t, T = T, Conflict = TableRow<'t, T>, Schema = S>, ) -> TableRow<'t, T>

This is a convenience function to make using TransactionMut::try_insert easier for tables with exactly one unique constraints.

The new row is inserted and the reference to the row is returned OR an existing row is found which conflicts with the new row and a reference to the conflicting row is returned.

pub fn try_update<T: Table<Schema = S>, C>( &mut self, row: impl IntoColumn<'t, S, Typ = T>, val: impl Writable<'t, T = T, Conflict = C, Schema = S>, ) -> Result<(), C>

Try updating a row in the database to have new column values.

Updating can fail just like TransactionMut::try_insert because of unique constraint conflicts. This happens when the new values are in conflict with an existing different row.

When the update succeeds, this function returns [Ok<()>], when it fails it returns Err with one of three conflict types:

• 0 unique constraints => Infallible
• 1 unique constraint => TableRow reference to the conflicting table row.
• 2+ unique constraints => () no further information is provided.

pub fn update<T: Table<Schema = S>>( &mut self, row: impl IntoColumn<'t, S, Typ = T>, val: impl Writable<'t, T = T, Conflict = Infallible, Schema = S>, )

This is a convenience function to use TransactionMut::try_update on tables without unique constraints.

pub fn find_and_update<T: Table<Schema = S>>( &mut self, val: impl Writable<'t, T = T, Conflict = TableRow<'t, T>, Schema = S>, ) -> Result<TableRow<'t, T>, ()>

This is a convenience function to use TransactionMut::try_update on tables with exactly one unique constraint.

This function works slightly different in that it does not receive a row reference. Instead it tries to update the row that would conflict if the new row would be inserted. When such a conflicting row is found, it is updated to the new column values and Ok is returned with a reference to the found row. If it can not find a conflicting row, then nothing happens and the function returns Err

pub fn commit(self)

Make the changes made in this TransactionMut permanent.

If the TransactionMut is dropped without calling this function, then the changes are rolled back.

pub fn downgrade(self) -> TransactionWeak<'t, S>

Methods from Deref<Target = Transaction<'a, S>>

pub fn query<F, R>(&self, f: F) -> R

where F: for<'a> FnOnce(&'a mut Query<'t, 'a, S>) -> R,

Execute a query with multiple results.

Please take a look at the documentation of Query for how to use it.

pub fn query_one<O>(&self, val: impl Dummy<'t, 't, S, Out = O>) -> O

where S: 'static,

Retrieve a single result from the database.

Instead of using Self::query_one in a loop, it is better to call Self::query and return all results at once.

Trait Implementations

impl<'a, S> Deref for TransactionMut<'a, S>

type Target = Transaction<'a, S>

The resulting type after dereferencing.

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

Dereferences the value.