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 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 flush(&self) -> Result<()>

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

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

pub fn temp_pin(&self) -> TempPin

Get a temporary alias for safely adding blocks to the store

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

Add a permanent named alias/pin for a root

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: &TempPin,
    links: impl IntoIterator<Item = Cid>
) -> Result<()>

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

Returns the aliases referencing a block.

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

Add a number of blocks to the store

• blocks the blocks to add.
• alias an optional temporary alias. This can be used to incrementally add blocks without having to worry about them being garbage collected before they can be pinned with a permanent alias.

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

Add a single block

this is just a convenience method that calls put_blocks internally.

• cid the cid This should be a hash of the data, with some format specifier.
• data a blob
• links links extracted from the data
• alias an optional temporary alias

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

Get data for a block

Will return None if we don’t have the data

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

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

do a full garbage collection

for a large block store, this can take several seconds to minutes. If that is not acceptable, consider using incremental gc.

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. Also note that when doing incremental gc, the actual blocks are not yet deleted. So a call to this method should usually be followed by a call to incremental_delete_orphaned.

• min_blocks the minium number of blocks to collect in any case
• max_duration the maximum duration that should be spent on gc

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

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

Incrementally delete orphaned blocks

Orphaned blocks are blocks for which we have deleted the metadata in incremental_gc.

Will delete orphaned blocks until either all orphaned blocks are deleted, or at minimum min_blocks blocks are deleted. Then it will continue deleting blocks until max_duration is elapsed.

Note that this might significantly exceed max_duration for various reasons.

• min_blocks the minium number of blocks to delete in any case
• max_duration the maximum duration that should be spent on gc

Returns true if all orphaned blocks are deleted