Struct MdbxWriteTransaction 

pub struct MdbxWriteTransaction<'db> { /* private fields */ }

Trait Implementations

impl<'db> AsRef<MdbxReadTransaction<'db>> for MdbxWriteTransaction<'db>

fn as_ref(&self) -> &MdbxReadTransaction<'db>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'db> Deref for MdbxWriteTransaction<'db>

type Target = MdbxReadTransaction<'db>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'db> ReadTransaction<'db> for MdbxWriteTransaction<'db>

type Cursor<'txn, T: Table> = CursorProxy<'txn, T> where Self: 'txn

type DupCursor<'txn, T: DupTable> = CursorProxy<'txn, T> where Self: 'txn

fn get<T: Table>(&self, table: &T, key: &T::Key) -> Option<T::Value>

Gets the value at a given key.

fn cursor<'txn, T: RegularTable>(&'txn self, table: &T) -> Self::Cursor<'txn, T>

Creates a cursor for iterating over the table.

fn dup_cursor<'txn, T: DupTable>( &'txn self, table: &T, ) -> Self::DupCursor<'txn, T>

Creates a cursor for iterating over the table with duplicate keys.

fn close(self)

Close the transaction, releasing any resources it holds.

impl<'db> WriteTransaction<'db> for MdbxWriteTransaction<'db>

type WriteCursor<'txn, T: Table> = MdbxCursor<'txn, RW, T> where Self: 'txn

type DupWriteCursor<'txn, T: DupTable> = MdbxCursor<'txn, RW, T> where Self: 'txn

fn put_reserve<T: RegularTable>( &mut self, table: &T, key: &T::Key, value: &T::Value, )

where T::Value: IntoDatabaseValue,

Puts a key/value pair into the database by copying it into a reserved space in the database. This works best for values that need to be serialized into the reserved space. This method will panic when called on a database with duplicate keys!

fn put<T: Table>(&mut self, table: &T, key: &T::Key, value: &T::Value)

Puts a key/value pair into the database by passing a reference to a byte slice. This is more efficient than put_reserve if no serialization is needed, and the existing value can be immediately written into the database.

fn append<T: Table>(&mut self, table: &T, key: &T::Key, value: &T::Value)

Appends a key/value pair to the end of the database. This method is more efficient than put. This operation fails if the key is less than the last key.

fn remove<T: Table>(&mut self, table: &T, key: &T::Key)

Removes the entry with this key from the database. In dup tables, it removes all entries with this key.

fn remove_item<T: Table>(&mut self, table: &T, key: &T::Key, value: &T::Value)

Removes the entry with this key and value from the database. Only matching entries will be deleted.

fn commit(self)

Commits the changes to the database.

fn cursor<'txn, T: RegularTable>( &'txn self, table: &T, ) -> Self::WriteCursor<'txn, T>

Creates a write cursor for the given table.

fn dup_cursor<'txn, T: DupTable>( &'txn self, table: &T, ) -> Self::DupWriteCursor<'txn, T>

Creates a write cursor for the given duplicate table.

fn clear_table<T: Table>(&mut self, table: &T)

Clears the table of all entries.

fn abort(self)

Aborts the transaction and discards all changes.