Struct TransactionWeak 

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

This is the weak version of Transaction.

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<S: Schema> TransactionWeak<S>

pub fn delete<T: Table<Schema = S>>( &mut self, val: TableRow<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>, ) -> 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<R>( &mut self, f: impl FnOnce(&Transaction<'_>) -> R, ) -> R

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.
• Making changes that violate foreign-key constraints (see below).

Sadly it is not possible to enable (or disable) the foreign_keys pragma during a transaction. This means that whether this pragma is enabled depends on which [crate::migrate::ForeignKeys] option is used and can not be changed.