Enum EitherWriter 

pub enum EitherWriter<'a, CURSOR, N> {
    Database(CURSOR),
    StaticFile(StaticFileProviderRWRefMut<'a, N>),
    RocksDB(RocksDBBatch<'a>),
}

Available on crate feature provider only.

Represents a destination for writing data, either to database, static files, or RocksDB.

Variants

Database(CURSOR)

Write to database table via cursor

StaticFile(StaticFileProviderRWRefMut<'a, N>)

Write to static file

RocksDB(RocksDBBatch<'a>)

Available on Unix and crate feature rocksdb only.

Write to RocksDB using a write-only batch (historical tables).

Implementations

impl<'a> EitherWriter<'a, (), ()>

pub fn new_receipts<P>( provider: &'a P, block_number: u64, ) -> Result<EitherWriter<'a, <<P as DBProvider>::Tx as DbTxMut>::CursorMut<Receipts<<<P as NodePrimitivesProvider>::Primitives as NodePrimitives>::Receipt>>, <P as NodePrimitivesProvider>::Primitives>, ProviderError>

where P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + StaticFileProviderFactory, <P as DBProvider>::Tx: DbTxMut, <<P as NodePrimitivesProvider>::Primitives as NodePrimitives>::Receipt: Value,

Creates a new EitherWriter for receipts based on storage settings and prune modes.

pub fn receipts_destination<P>(provider: &P) -> EitherWriterDestination

where P: DBProvider + StorageSettingsCache,

Returns the destination for writing receipts.

The rules are as follows:

• If the node should not always write receipts to static files, and any receipt pruning is enabled, write to the database.
• If the node should always write receipts to static files, but receipt log filter pruning is enabled, write to the database.
• Otherwise, write to static files.

pub fn new_senders<P>( provider: &'a P, block_number: u64, ) -> Result<EitherWriter<'a, <<P as DBProvider>::Tx as DbTxMut>::CursorMut<TransactionSenders>, <P as NodePrimitivesProvider>::Primitives>, ProviderError>

where P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + StaticFileProviderFactory, <P as DBProvider>::Tx: DbTxMut,

Creates a new EitherWriter for senders based on storage settings.

pub fn new_storages_history<P>( provider: &P, _rocksdb_batch: RocksDBBatch<'a>, ) -> Result<EitherWriter<'a, <<P as DBProvider>::Tx as DbTxMut>::CursorMut<StoragesHistory>, <P as NodePrimitivesProvider>::Primitives>, ProviderError>

where P: DBProvider + NodePrimitivesProvider + StorageSettingsCache, <P as DBProvider>::Tx: DbTxMut,

Creates a new EitherWriter for storages history based on storage settings.

pub fn new_transaction_hash_numbers<P>( provider: &P, _rocksdb_batch: RocksDBBatch<'a>, ) -> Result<EitherWriter<'a, <<P as DBProvider>::Tx as DbTxMut>::CursorMut<TransactionHashNumbers>, <P as NodePrimitivesProvider>::Primitives>, ProviderError>

where P: DBProvider + NodePrimitivesProvider + StorageSettingsCache, <P as DBProvider>::Tx: DbTxMut,

Creates a new EitherWriter for transaction hash numbers based on storage settings.

pub fn new_accounts_history<P>( provider: &P, _rocksdb_batch: RocksDBBatch<'a>, ) -> Result<EitherWriter<'a, <<P as DBProvider>::Tx as DbTxMut>::CursorMut<AccountsHistory>, <P as NodePrimitivesProvider>::Primitives>, ProviderError>

where P: DBProvider + NodePrimitivesProvider + StorageSettingsCache, <P as DBProvider>::Tx: DbTxMut,

Creates a new EitherWriter for account history based on storage settings.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives,

pub fn into_raw_rocksdb_batch(self) -> Option<WriteBatchWithTransaction<true>>

Available on Unix and crate feature rocksdb only.

Extracts the raw RocksDB write batch from this writer, if it contains one.

Returns Some(WriteBatchWithTransaction) for Self::RocksDB variant, None for other variants.

This is used to defer RocksDB commits to the provider level, ensuring all storage commits (MDBX, static files, RocksDB) happen atomically in a single place.

pub fn increment_block( &mut self, expected_block_number: u64, ) -> Result<(), ProviderError>

Increment the block number.

Relevant only for Self::StaticFile. It is a no-op for Self::Database.

pub fn ensure_at_block( &mut self, block_number: u64, ) -> Result<(), ProviderError>

Ensures that the writer is positioned at the specified block number.

If the writer is positioned at a greater block number than the specified one, the writer will NOT be unwound and the error will be returned.

Relevant only for Self::StaticFile. It is a no-op for Self::Database.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives, <N as NodePrimitives>::Receipt: Value, CURSOR: DbCursorRW<Receipts<<N as NodePrimitives>::Receipt>>,

pub fn append_receipt( &mut self, tx_num: u64, receipt: &<N as NodePrimitives>::Receipt, ) -> Result<(), ProviderError>

Append a transaction receipt.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives, CURSOR: DbCursorRW<TransactionSenders>,

pub fn append_sender( &mut self, tx_num: u64, sender: &Address, ) -> Result<(), ProviderError>

Append a transaction sender to the destination

pub fn append_senders<I>(&mut self, senders: I) -> Result<(), ProviderError>

where I: Iterator<Item = (u64, Address)>,

Append transaction senders to the destination

pub fn prune_senders( &mut self, unwind_tx_from: u64, block: u64, ) -> Result<(), ProviderError>

where CURSOR: DbCursorRO<TransactionSenders>,

Removes all transaction senders above the given transaction number, and stops at the given block number.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives, CURSOR: DbCursorRW<TransactionHashNumbers> + DbCursorRO<TransactionHashNumbers>,

pub fn put_transaction_hash_number( &mut self, hash: FixedBytes<32>, tx_num: u64, append_only: bool, ) -> Result<(), ProviderError>

Puts a transaction hash number mapping.

When append_only is true, uses cursor.append() which is significantly faster but requires entries to be inserted in order and the table to be empty. When false, uses cursor.insert() which handles arbitrary insertion order.

pub fn delete_transaction_hash_number( &mut self, hash: FixedBytes<32>, ) -> Result<(), ProviderError>

Deletes a transaction hash number mapping.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives, CURSOR: DbCursorRW<StoragesHistory> + DbCursorRO<StoragesHistory>,

pub fn put_storage_history( &mut self, key: StorageShardedKey, value: &IntegerList, ) -> Result<(), ProviderError>

Puts a storage history entry.

pub fn delete_storage_history( &mut self, key: StorageShardedKey, ) -> Result<(), ProviderError>

Deletes a storage history entry.

impl<'a, CURSOR, N> EitherWriter<'a, CURSOR, N>

where N: NodePrimitives, CURSOR: DbCursorRW<AccountsHistory> + DbCursorRO<AccountsHistory>,

pub fn put_account_history( &mut self, key: ShardedKey<Address>, value: &IntegerList, ) -> Result<(), ProviderError>

Puts an account history entry.

pub fn delete_account_history( &mut self, key: ShardedKey<Address>, ) -> Result<(), ProviderError>

Deletes an account history entry.

Trait Implementations

impl<'a, CURSOR, N> Debug for EitherWriter<'a, CURSOR, N>

where CURSOR: Debug, N: Debug,

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

Formats the value using the given formatter.

impl<'a, CURSOR, N> Display for EitherWriter<'a, CURSOR, N>

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.