Struct BlockStorage 

pub struct BlockStorage { /* private fields */ }

Implementations

impl BlockStorage

Background auto-sync functionality Handles automatic background synchronization of dirty blocks

pub fn enable_auto_sync(&mut self, interval_ms: u64)

pub fn enable_auto_sync_with_policy(&mut self, policy: SyncPolicy)

pub fn disable_auto_sync(&mut self)

pub fn get_sync_count(&self) -> u64

Get the number of completed sync operations (native only metric)

pub fn get_timer_sync_count(&self) -> u64

Get the number of timer-based background syncs

pub fn get_debounce_sync_count(&self) -> u64

Get the number of debounce-based background syncs

pub fn get_last_sync_duration_ms(&self) -> u64

Get the duration in ms of the last sync operation (>=1 when a sync occurs)

impl BlockStorage

pub fn get_storage_info(&mut self) -> BlockStorageInfo

Get comprehensive block storage information for the viewer

impl BlockStorage

pub async fn new(db_name: &str) -> Result<Self, DatabaseError>

pub async fn new_with_capacity( db_name: &str, capacity: usize, ) -> Result<Self, DatabaseError>

pub async fn new_with_recovery_options( db_name: &str, recovery_opts: RecoveryOptions, ) -> Result<Self, DatabaseError>

pub fn get_recovery_report(&self) -> &RecoveryReport

pub fn now_millis() -> u64

pub fn read_block_sync(&self, block_id: u64) -> Result<Vec<u8>, DatabaseError>

Synchronous block read for environments that require sync access (e.g., VFS callbacks)

pub async fn read_block(&self, block_id: u64) -> Result<Vec<u8>, DatabaseError>

pub fn write_block_sync( &mut self, block_id: u64, data: Vec<u8>, ) -> Result<(), DatabaseError>

pub async fn write_block( &mut self, block_id: u64, data: Vec<u8>, ) -> Result<(), DatabaseError>

pub fn write_blocks_sync( &mut self, items: Vec<(u64, Vec<u8>)>, ) -> Result<(), DatabaseError>

pub async fn write_blocks( &mut self, items: Vec<(u64, Vec<u8>)>, ) -> Result<(), DatabaseError>

pub fn read_blocks_sync( &self, block_ids: &[u64], ) -> Result<Vec<Vec<u8>>, DatabaseError>

Synchronous batch read of blocks, preserving input order

pub async fn read_blocks( &self, block_ids: &[u64], ) -> Result<Vec<Vec<u8>>, DatabaseError>

Async batch read wrapper

pub fn get_block_checksum(&self, block_id: u64) -> Option<u32>

Get block checksum for verification

pub async fn verify_block_checksum( &mut self, block_id: u64, ) -> Result<(), DatabaseError>

pub fn get_block_metadata_for_testing( &mut self, ) -> HashMap<u64, (u64, u32, u64)>

pub fn set_block_checksum_for_testing(&mut self, block_id: u64, checksum: u64)

pub async fn sync(&mut self) -> Result<(), DatabaseError>

pub fn sync_now(&mut self) -> Result<(), DatabaseError>

pub fn drain_and_shutdown(&mut self)

pub fn clear_cache(&self)

pub async fn on_database_import(&mut self) -> Result<(), DatabaseError>

Handle notification that the database has been imported

This method should be called after a database import to ensure that any cached data is invalidated and fresh data is read from storage.

Returns

• Ok(()) - Cache cleared successfully
• Err(DatabaseError) - If cache clearing fails

Example

let mut storage = BlockStorage::new("mydb").await?;
// ... database is imported externally ...
storage.on_database_import().await?;

pub fn get_cache_size(&self) -> usize

pub fn get_dirty_count(&self) -> usize

pub fn get_db_name(&self) -> &str

pub fn is_cached(&self, block_id: u64) -> bool

pub async fn allocate_block(&mut self) -> Result<u64, DatabaseError>

Allocate a new block and return its ID

pub async fn deallocate_block( &mut self, block_id: u64, ) -> Result<(), DatabaseError>

Deallocate a block and mark it as available for reuse

pub fn get_allocated_count(&self) -> usize

Get the number of currently allocated blocks

pub fn get_metrics(&self) -> StorageMetrics

Get comprehensive metrics for observability

pub fn set_sync_callbacks( &mut self, on_sync_start: SyncStartCallback, on_sync_success: SyncSuccessCallback, on_sync_failure: SyncFailureCallback, )

Set sync event callbacks

pub fn set_backpressure_callback(&mut self, callback: BackpressureCallback)

Set backpressure callback

pub fn set_error_callback(&mut self, callback: ErrorCallback)

Set error callback

pub fn is_auto_sync_enabled(&self) -> bool

Check if auto-sync is currently enabled

pub fn get_sync_policy(&self) -> Option<SyncPolicy>

Get the current sync policy (if any)

pub async fn force_sync(&mut self) -> Result<(), DatabaseError>

Force synchronization with durability guarantees

This method ensures that all dirty blocks are persisted to durable storage (IndexedDB in WASM, filesystem in native) and waits for the operation to complete. This is called by VFS xSync to provide SQLite’s durability guarantees.

Trait Implementations

impl Drop for BlockStorage

Available on non-WebAssembly only.

fn drop(&mut self)

Executes the destructor for this type.