Struct holochain_sqlite::db::DbRead

pub struct DbRead<Kind: DbKindT> { /* private fields */ }

A read-only version of DbWrite. This environment can only generate read-only transactions, never read-write.

Implementations

impl<Kind: DbKindT> DbRead<Kind>

pub fn kind(&self) -> &Kind

Accessor for the DbKindT of the DbWrite

pub fn path(&self) -> &PathBuf

The environment’s path

pub async fn read_async<E, R, F>(&self, f: F) -> Result<R, E>

where E: From<DatabaseError> + Send + 'static, F: FnOnce(Transaction<'_>) -> Result<R, E> + Send + 'static, R: Send + 'static,

Execute a read closure on the database by acquiring a connection from the pool, starting a new transaction and running the closure with that transaction.

Note that it is not enforced that your closure runs read-only operations or that it finishes quickly so it is up to the caller to use this function as intended.

pub async fn get_read_txn(&self) -> DatabaseResult<PTxnGuard>

Intended to be used for transactions that need to be kept open for a longer period of time than just running a sequence of reads using read_async. You should default to read_async and only call this if you have a good reason.

A valid reason for this is holding read transactions across multiple databases as part of a cascade query.

pub fn test_read<R, F>(&self, f: F) -> R

where F: FnOnce(Transaction<'_>) -> R + Send + 'static, R: Send + 'static,

Trait Implementations

impl AsP2pStateReadExt for DbRead<DbKindP2pAgents>

fn p2p_get_agent<'life0, 'life1, 'async_trait>( &'life0 self, agent: &'life1 KitsuneAgent ) -> Pin<Box<dyn Future<Output = DatabaseResult<Option<AgentInfoSigned>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an AgentInfoSigned record from the p2p_store

fn p2p_list_agents<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = DatabaseResult<Vec<AgentInfoSigned>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all AgentInfoSigned records within a space in the p2p_agent_store

fn p2p_count_agents<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = DatabaseResult<u32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Count agent records within a space in the p2p_agent_store

fn p2p_gossip_query_agents<'life0, 'async_trait>( &'life0 self, since_ms: u64, until_ms: u64, arcset: DhtArcSet ) -> Pin<Box<dyn Future<Output = DatabaseResult<Vec<AgentInfoSigned>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Query agent list for gossip

fn p2p_query_near_basis<'life0, 'async_trait>( &'life0 self, basis: u32, limit: u32 ) -> Pin<Box<dyn Future<Output = DatabaseResult<Vec<AgentInfoSigned>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Query agents sorted by nearness to basis loc

fn p2p_extrapolated_coverage<'life0, 'async_trait>( &'life0 self, dht_arc_set: DhtArcSet ) -> Pin<Box<dyn Future<Output = DatabaseResult<Vec<f64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Extrapolate coverage from agents within our own storage arc

impl<Kind: DbKindT> AsRef<DbRead<Kind>> for DbWrite<Kind>

fn as_ref(&self) -> &DbRead<Kind>

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

impl<Kind: DbKindT> Borrow<DbRead<Kind>> for DbWrite<Kind>

fn borrow(&self) -> &DbRead<Kind>

Immutably borrows from an owned value.

impl<Kind: Clone + DbKindT> Clone for DbRead<Kind>

fn clone(&self) -> DbRead<Kind>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Kind: DbKindT> Debug for DbRead<Kind>

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

Formats the value using the given formatter.

impl<Kind: DbKindT> From<DbWrite<Kind>> for DbRead<Kind>

fn from(original: DbWrite<Kind>) -> Self

Converts to this type from the input type.

impl<Kind: DbKindT> ReadAccess<Kind> for DbRead<Kind>

fn read_async<'life0, 'async_trait, E, R, F>( &'life0 self, f: F ) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>

where E: From<DatabaseError> + Send + 'static + 'async_trait, F: FnOnce(Transaction<'_>) -> Result<R, E> + Send + 'static + 'async_trait, R: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Run an async read transaction on a background thread.

fn kind(&self) -> &Kind

Access the kind of database.