Struct ConnectionPool 

pub struct ConnectionPool(/* private fields */);

Access to the node’s DB connection pool and DB-access-related methods.

The handle is safe to clone and share between threads.

Implementations

impl ConnectionPool

pub fn new(conf: &Config) -> Result<Self>

Create the connection pool from the given configuration.

Note that this function does not initialise the node DB tables by default. See the ConnectionPool::with_tables constructor.

pub fn with_tables(conf: &Config) -> Result<Self>

Create the connection pool from the given configuration and ensure the DB tables have been created if they do not already exist before returning.

## Example

let conf = essential_node_db::pool::Config::default();
let db = essential_node_db::ConnectionPool::with_tables(&conf).unwrap();
for block in db.list_blocks(0..100).await.unwrap() {
    println!("Block: {block:?}");
}

pub async fn acquire(&self) -> Result<ConnectionHandle, AcquireError>

Acquire a temporary database ConnectionHandle from the inner pool.

In the case that all connections are busy, waits for the first available connection.

pub fn try_acquire(&self) -> Result<ConnectionHandle, TryAcquireError>

Attempt to synchronously acquire a temporary database ConnectionHandle from the inner pool.

Returns Err in the case that all database connections are busy or if the node has been closed.

pub fn close(&self) -> Result<(), ConnectionCloseErrors>

Close a connection pool, returning a ConnectionCloseErrors in the case of any errors.

impl ConnectionPool

Short-hand methods for async DB access.

pub async fn acquire_then<F, T, E>( &self, f: F, ) -> Result<T, AcquireThenError<E>>

where F: 'static + Send + FnOnce(&mut ConnectionHandle) -> Result<T, E>, T: 'static + Send, E: 'static + Send,

Asynchronous access to the node’s DB via the given function.

Requests and awaits a connection from the connection pool, then spawns a blocking task for the given function providing access to the connection handle.

pub async fn create_tables(&self) -> Result<(), AcquireThenRusqliteError>

Create all database tables.

pub async fn insert_block( &self, block: Arc<Block>, ) -> Result<ContentAddress, AcquireThenRusqliteError>

Insert the given block into the block table and for each of its solution sets, add a row into the solution_set and block_solution_set tables.

pub async fn finalize_block( &self, block_ca: ContentAddress, ) -> Result<(), AcquireThenRusqliteError>

Finalizes the block with the given hash. This sets the block to be the only block at a particular block number.

pub async fn update_state( &self, contract_ca: ContentAddress, key: Key, value: Value, ) -> Result<(), AcquireThenRusqliteError>

Updates the state for a given contract content address and key.

pub async fn delete_state( &self, contract_ca: ContentAddress, key: Key, ) -> Result<(), AcquireThenRusqliteError>

Deletes the state for a given contract content address and key.

pub async fn get_block( &self, block_address: ContentAddress, ) -> Result<Option<Block>, AcquireThenQueryError>

Fetches a block by its hash.

pub async fn get_solution_set( &self, ca: ContentAddress, ) -> Result<SolutionSet, AcquireThenQueryError>

Fetches a solution set by its content address.

pub async fn query_state( &self, contract_ca: ContentAddress, key: Key, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair.

pub async fn query_latest_finalized_block( &self, contract_ca: ContentAddress, key: Key, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair within a range of blocks.

pub async fn query_state_finalized_inclusive_block( &self, contract_ca: ContentAddress, key: Key, block_number: Word, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair within a range of blocks inclusive. ..=block.

pub async fn query_state_finalized_exclusive_block( &self, contract_ca: ContentAddress, key: Key, block_number: Word, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair within a range of blocks exclusive. ..block.

pub async fn query_state_finalized_inclusive_solution_set( &self, contract_ca: ContentAddress, key: Key, block_number: Word, solution_set_ix: u64, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair within a range of blocks and solution sets inclusive. ..block[..=solution_set].

pub async fn query_state_finalized_exclusive_solution_set( &self, contract_ca: ContentAddress, key: Key, block_number: Word, solution_set_ix: u64, ) -> Result<Option<Value>, AcquireThenQueryError>

Fetches the state value for the given contract content address and key pair within a range of blocks and solution sets exclusive. ..=block[..solution_set].

pub async fn get_validation_progress( &self, ) -> Result<Option<ContentAddress>, AcquireThenQueryError>

Get the validation progress, returning the last block hash.

pub async fn get_next_block_addresses( &self, current_block: ContentAddress, ) -> Result<Vec<ContentAddress>, AcquireThenQueryError>

Get next block(s) given the current block hash.

pub async fn update_validation_progress( &self, block_ca: ContentAddress, ) -> Result<(), AcquireThenRusqliteError>

Update the validation progress to point to the block with the given CA.

pub async fn list_blocks( &self, block_range: Range<Word>, ) -> Result<Vec<Block>, AcquireThenQueryError>

Lists all blocks in the given range.

pub async fn list_blocks_by_time( &self, range: Range<Duration>, page_size: i64, page_number: i64, ) -> Result<Vec<Block>, AcquireThenQueryError>

Lists blocks and their solution sets within a specific time range with pagination.

pub fn subscribe_blocks( &self, start_block: Word, await_new_block: impl AwaitNewBlock, ) -> impl Stream<Item = Result<Block, QueryError>>

Subscribe to all blocks from the given starting block number.

Trait Implementations

impl AcquireConnection for ConnectionPool

async fn acquire_connection(&self) -> Option<impl 'static + AsMut<Connection>>

Asynchronously acquire a handle to a Connection.

impl AsRef<AsyncConnectionPool> for ConnectionPool

fn as_ref(&self) -> &AsyncConnectionPool

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

impl Clone for ConnectionPool

fn clone(&self) -> ConnectionPool

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.