Struct holochain_types::db::DbWrite

pub struct DbWrite<Kind>(_)
where
    Kind: DbKindT;

The canonical representation of a (singleton) database. The wrapper contains methods for managing transactions and database connections,

Implementations

impl<Kind> DbWrite<Kind>where
    Kind: 'static + DbKindT + Send + Sync,

pub fn open(
    path_prefix: &Path,
    kind: Kind
) -> Result<DbWrite<Kind>, DatabaseError>

Create or open an existing database reference,

pub async fn conn_write_permit(&self) -> impl Future<Output = PConnPermit>

pub fn open_with_sync_level(
    path_prefix: &Path,
    kind: Kind,
    sync_level: DbSyncLevel
) -> Result<DbWrite<Kind>, DatabaseError>

pub fn test(path: &Path, kind: Kind) -> Result<DbWrite<Kind>, DatabaseError>

Create a unique db in a temp dir with no static management of the connection pool, useful for testing.

pub fn test_in_mem(kind: Kind) -> Result<DbWrite<Kind>, DatabaseError>

pub async fn remove(self) -> impl Future<Output = Result<(), DatabaseError>>

👎Deprecated: is this used?

Remove the db and directory

pub async fn async_commit<E, R, F>(
    &self,
    f: F
) -> impl Future<Output = Result<R, E>>where
    E: 'static + From<DatabaseError> + Send,
    F: 'static + FnOnce(&mut Transaction<'_>) -> Result<R, E> + Send,
    R: 'static + Send,

pub fn test_commit<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&mut Transaction<'_>) -> R,

pub async fn async_commit_in_place<E, R, F>(
    &self,
    f: F
) -> impl Future<Output = Result<R, E>>where
    E: From<DatabaseError>,
    F: FnOnce(&mut Transaction<'_>) -> Result<R, E>,
    R: Send,

If possible prefer async_commit as this is slower and can starve chained futures.

Methods from Deref<Target = DbRead<Kind>>

pub fn conn(&self) -> Result<PConn, DatabaseError>

pub async fn conn_permit(&self) -> impl Future<Output = PConnPermit>

pub fn kind(&self) -> &Kind

Accessor for the DbKindT of the DbWrite

pub fn path(&self) -> &PathBuf

The environment’s path

pub async fn async_reader<E, R, F>(
    &self,
    f: F
) -> impl Future<Output = Result<R, E>>where
    E: 'static + From<DatabaseError> + Send,
    F: 'static + FnOnce(Transaction<'_>) -> Result<R, E> + Send,
    R: 'static + Send,

Trait Implementations

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

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

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

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

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

Immutably borrows from an owned value.

impl<Kind> Clone for DbWrite<Kind>where
    Kind: Clone + DbKindT,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Kind> Deref for DbWrite<Kind>where
    Kind: DbKindT,

type Target = DbRead<Kind>

The resulting type after dereferencing.

fn deref(&self) -> &<DbWrite<Kind> as Deref>::Target

Dereferences the value.

impl From<DbWrite<DbKindDht>> for DhtDbQueryCache

fn from(db: DbWrite<DbKindDht>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<Kind> PermittedConn for DbWrite<Kind>where
    Kind: DbKindT,

fn with_permit(&self, permit: PConnPermit) -> Result<PConnGuard, DatabaseError>

impl<Kind> ReadAccess<Kind> for DbWrite<Kind>where
    Kind: DbKindT,

fn async_reader<'life0, 'async_trait, E, R, F>(
    &'life0 self,
    f: F
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    E: 'static + From<DatabaseError> + Send + 'async_trait,
    F: 'static + FnOnce(Transaction<'_>) -> Result<R, E> + Send + 'async_trait,
    R: 'static + Send + 'async_trait,
    DbWrite<Kind>: 'async_trait,

Run an async read transaction on a background thread.

fn sync_reader<E, R, F>(&self, f: F) -> Result<R, E>where
    E: From<DatabaseError>,
    F: FnOnce(Transaction<'_>) -> Result<R, E>,

Run an sync read transaction on a the current thread.

fn kind(&self) -> &Kind

Access the kind of database.