Struct ipfs_sqlite_block_store::Transaction

pub struct Transaction<'a, S> { /* private fields */ }

Implementations

impl<'a, S> Transaction<'a, S> where
    S: StoreParams,
    Ipld: References<S::Codecs>, 

pub fn alias(
    &mut self,
    name: impl AsRef<[u8]>,
    link: Option<&Cid>
) -> Result<()>

Set or delete an alias

pub fn reverse_alias(&mut self, cid: &Cid) -> Result<Option<HashSet<Vec<u8>>>>

Returns the aliases referencing a cid.

pub fn resolve(&mut self, name: impl AsRef<[u8]>) -> Result<Option<Cid>>

Resolves an alias to a cid.

pub fn temp_pin(&mut self) -> TempPin

Get a temporary pin for safely adding blocks to the store

pub fn extend_temp_pin(&mut self, pin: &mut TempPin, link: &Cid) -> Result<()>

Extend temp pin with an additional cid

pub fn has_cid(&mut self, cid: &Cid) -> Result<bool>

Checks if the store knows about the cid.

Note that this does not necessarily mean that the store has the data for the cid.

pub fn has_block(&mut self, cid: &Cid) -> Result<bool>

Checks if the store has the data for a cid

pub fn get_known_cids<C: FromIterator<Cid>>(&mut self) -> Result<C>

Get all cids that the store knows about

pub fn get_block_cids<C: FromIterator<Cid>>(&mut self) -> Result<C>

Get all cids for which the store has blocks

pub fn get_descendants<C: FromIterator<Cid>>(&mut self, cid: &Cid) -> Result<C>

Get descendants of a cid

pub fn get_missing_blocks<C: FromIterator<Cid>>(
    &mut self,
    cid: &Cid
) -> Result<C>

Given a root of a dag, gives all cids which we do not have data for.

pub fn aliases<C: FromIterator<(Vec<u8>, Cid)>>(&mut self) -> Result<C>

list all aliases

pub fn put_block(
    &mut self,
    block: &Block<S>,
    pin: Option<&mut TempPin>
) -> Result<()>

Put a block. This will only be completed once the transaction is successfully committed

pub fn get_block(&mut self, cid: &Cid) -> Result<Option<Vec<u8>>>

Get a block

pub fn get_store_stats(&mut self) -> Result<StoreStats>

Get the stats for the store.

The stats are kept up to date, so this is fast.

pub fn commit(self) -> Result<()>

Commit and consume the transaction. Default is to not commit.