Struct Tx 

pub struct Tx<K: TransactionKind> {
    pub inner: Transaction<K>,
    /* private fields */
}

Available on crate feature mdbx only.

Wrapper for the libmdbx transaction.

Fields

inner: Transaction<K>

Libmdbx-sys transaction.

Implementations

impl<K: TransactionKind> Tx<K>

pub fn id(&self) -> Result<u64>

Gets this transaction ID.

pub fn get_dbi<T: Table>(&self) -> Result<MDBX_dbi, DatabaseError>

Gets a table database handle if it exists, otherwise creates it.

pub fn new_cursor<T: Table>(&self) -> Result<Cursor<K, T>, DatabaseError>

Create db Cursor

Trait Implementations

impl<K: TransactionKind> DbTx for Tx<K>

fn cursor_dup_read<T: DupSort>( &self, ) -> Result<Self::DupCursor<T>, DatabaseError>

Iterate over read only values in database.

fn entries<T: Table>(&self) -> Result<usize, DatabaseError>

Returns number of entries in the table using cheap DB stats invocation.

fn disable_long_read_transaction_safety(&mut self)

Disables long-lived read transaction safety guarantees, such as backtrace recording and timeout.

type Cursor<T: Table> = Cursor<K, T>

Cursor type for this read-only transaction

type DupCursor<T: DupSort> = Cursor<K, T>

DupCursor type for this read-only transaction

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

Get value by an owned key

fn get_by_encoded_key<T: Table>( &self, key: &<T::Key as Encode>::Encoded, ) -> Result<Option<T::Value>, DatabaseError>

Get value by a reference to the encoded key, especially useful for “raw” keys that encode to themselves like Address and B256. Doesn’t need to clone a reference key like get.

fn commit(self) -> Result<bool, DatabaseError>

Commit for read only transaction will consume and free transaction and allows freeing of memory pages

fn abort(self)

Aborts transaction

fn cursor_read<T: Table>(&self) -> Result<Self::Cursor<T>, DatabaseError>

Iterate over read only values in table.

impl DbTxMut for Tx<RW>

type CursorMut<T: Table> = Cursor<RW, T>

Read-Write Cursor type

type DupCursorMut<T: DupSort> = Cursor<RW, T>

Read-Write DupCursor type

fn put<T: Table>( &self, key: T::Key, value: T::Value, ) -> Result<(), DatabaseError>

Put value to database

fn append<T: Table>( &self, key: T::Key, value: T::Value, ) -> Result<(), DatabaseError>

Append value with the largest key to database. This should have the same outcome as put, but databases like MDBX provide dedicated modes to make it much faster, typically from O(logN) down to O(1) thanks to no lookup.

fn delete<T: Table>( &self, key: T::Key, value: Option<T::Value>, ) -> Result<bool, DatabaseError>

Delete value from database

fn clear<T: Table>(&self) -> Result<(), DatabaseError>

Clears database.

fn cursor_write<T: Table>(&self) -> Result<Self::CursorMut<T>, DatabaseError>

Cursor mut

fn cursor_dup_write<T: DupSort>( &self, ) -> Result<Self::DupCursorMut<T>, DatabaseError>

DupCursor mut.

impl<K: Debug + TransactionKind> Debug for Tx<K>

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

Formats the value using the given formatter.

impl TableImporter for Tx<RW>

fn import_table<T, R>(&self, source_tx: &R) -> Result<(), DatabaseError>

where T: Table, R: DbTx,

Imports all table data from another transaction.

fn import_table_with_range<T, R>( &self, source_tx: &R, from: Option<<T as Table>::Key>, to: <T as Table>::Key, ) -> Result<(), DatabaseError>

where T: Table, R: DbTx, <T as Table>::Key: Default,

Imports table data from another transaction within a range.

fn import_dupsort<T, R>(&self, source_tx: &R) -> Result<(), DatabaseError>

where T: DupSort, R: DbTx,

Imports all dupsort data from another transaction.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 120 bytes