Struct SledBlockStore 

pub struct SledBlockStore { /* private fields */ }

Block storage using Sled embedded database.

Available only when the sled-backend feature is enabled (the default). Not available on wasm32 targets — use crate::MemoryBlockStore there.

Implementations

impl SledBlockStore

pub fn new(config: BlockStoreConfig) -> Result<Self>

Create a new block store with default compaction settings.

pub fn new_with_compaction( config: BlockStoreConfig, compaction_config: CompactionConfig, ) -> Result<Self>

Create a new block store with a custom compaction configuration.

pub async fn put_if_absent(&self, block: &Block) -> Result<bool>

Write the block only when its CID is not already present.

Returns true if the block was written, false if it was deduplicated (CID already existed).

pub async fn put_batch_dedup(&self, blocks: &[Block]) -> Result<(usize, usize)>

Batch put with write-time deduplication.

Returns (written, deduped).

pub fn dedup_stats(&self) -> Arc<DeduplicationStats>

Return a shared handle to the deduplication statistics.

pub async fn maybe_compact(&self) -> Result<bool>

Flush the Sled WAL if the compaction scheduler determines it is time.

Returns true when a flush was actually performed.

pub fn compaction_scheduler(&self) -> Arc<CompactionScheduler>

Return a shared handle to the compaction scheduler.

pub fn snapshot_pin_registry(&self) -> Result<SledSnapshotPinRegistry>

Open (or re-open) the SledSnapshotPinRegistry backed by this store’s Sled database.

Trait Implementations

impl BlockStore for SledBlockStore

fn put<'life0, 'life1, 'async_trait>( &'life0 self, block: &'life1 Block, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a block.

If the CID already exists the write is skipped (content-addressed data is immutable, so the stored bytes are guaranteed to be identical).

fn get<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<Option<Block>>> + Send + 'async_trait>>

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

Retrieve a block by CID

fn has<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Check if a block exists

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete a block

fn len(&self) -> usize

Get the number of blocks stored

fn is_empty(&self) -> bool

Check if the store is empty

fn list_cids(&self) -> Result<Vec<Cid>>

Get all CIDs in the store

fn put_many<'life0, 'life1, 'async_trait>( &'life0 self, blocks: &'life1 [Block], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store multiple blocks atomically using Sled’s batch API

fn get_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Block>>>> + Send + 'async_trait>>

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

Retrieve multiple blocks efficiently

fn has_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<Vec<bool>>> + Send + 'async_trait>>

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

Check if multiple blocks exist efficiently

fn delete_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete multiple blocks atomically

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

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

Flush pending writes to disk

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

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

Close the store and release resources