Struct TransactionWeak

pub struct TransactionWeak<'t, S> { /* private fields */ }

This is the weak version of TransactionMut.

The reason that it is called weak is because TransactionWeak can not guarantee that TableRows prove the existence of their particular row.

TransactionWeak is useful because it allowes deleting rows.

Implementations

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

pub fn delete<T: Table<Schema = S>>( &mut self, val: TableRow<'t, T>, ) -> Result<bool, T::Referer>

Try to delete a row from the database.

This will return an Err if there is a row that references the row that is being deleted. When this method returns Ok it will contain a bool that is either

• true if the row was just deleted.
• false if the row was deleted previously in this transaction.

pub fn delete_ok<T: Table<Referer = Infallible, Schema = S>>( &mut self, val: TableRow<'t, T>, ) -> bool

Delete a row from the database.

This is the infallible version of TransactionWeak::delete.

To be able to use this method you have to mark the table as #[no_reference] in the schema.

pub fn rusqlite_transaction(&mut self) -> &Transaction<'_>

This allows you to do (almost) anything you want with the internal rusqlite::Transaction.

Note that there are some things that you should not do with the transaction, such as:

• Changes to the schema, these will result in a panic as described in Database.
• Changes to the connection configuration such as disabling foreign key checks.

When this method is used to break rust_query invariants, all other rust_query function calls may result in a panic.

pub fn commit(self)

Make the changes made in this TransactionWeak permanent.

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