Struct ipfs_sqlite_block_store::BlockStore

pub struct BlockStore<S> { /* fields omitted */ }

Implementations

impl<S> BlockStore<S> where
    S: StoreParams,
    Ipld: References<S::Codecs>, 

pub fn open_path(db_path: DbPath, config: Config) -> Result<Self>

pub fn additional_connection(&self) -> Result<Self>

Create another connection to the underlying database

This allows you to perform operations in parallel.

pub fn memory(config: Config) -> Result<Self>

Create an in memory block store with the given config

pub fn open(path: impl AsRef<Path>, config: Config) -> Result<Self>

Create a persistent block store with the given config

pub fn open_test(path: impl AsRef<Path>, config: Config) -> Result<Self>

Open the file at the given path for testing.

This will create a writeable in-memory database that is initialized with the content of the file at the given path.

pub fn backup(&mut self, path: impl AsRef<Path>) -> Result<()>

pub fn flush(&mut self) -> Result<()>

pub fn integrity_check(&mut self) -> Result<()>

pub fn transaction(&mut self) -> Transaction<'_, S>

pub fn temp_pin(&self) -> TempPin

Get a temporary alias for safely adding blocks to the store

pub fn vacuum(&mut self) -> Result<()>

Run a full VACUUM on the SQLITE database

This may take a while, blocking all other writes to the store.

pub fn cleanup_temp_pins(&mut self) -> Result<()>

Perform maintenance on the TempPins

This is done automatically upon every (incremental) GC, so you normally don’t need to call this.

pub fn gc(&mut self) -> Result<()>

Perform full GC

This is the same as running incremental GC without limits, plus a full SQLITE VACUUM.

pub fn incremental_gc(
    &mut self,
    min_blocks: usize,
    max_duration: Duration
) -> Result<bool>

Perform an incremental garbage collection.

Will collect unpinned blocks until either the size targets are met again, or at minimum min_blocks blocks are collected. Then it will continue connecting blocks until max_duration is elapsed.

Note that this might significantly exceed max_duration for various reasons.

Returns true if either size targets are met or there are no unpinned blocks left.

impl<S> BlockStore<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 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 put_blocks<I>(
    &mut self,
    blocks: I,
    pin: Option<&mut TempPin>
) -> Result<()> where
    I: IntoIterator<Item = Block<S>>,