Struct PathRefreshingWalBackend 

pub struct PathRefreshingWalBackend<V: Vfs>
where
    V::File: Send + Sync + 'static,
{ /* private fields */ }

WAL backend that can recover when the path-visible -wal sidecar is removed or replaced while this process still owns an old file descriptor.

Real SQLite can checkpoint and unlink/reset db-wal when it does not know about a live FrankenSQLite handle. WalFile::refresh is intentionally descriptor-local, so it cannot notice that path-level mutation. This wrapper performs a path probe before mutable WAL operations and swaps in a freshly opened/created WalFile when the path-visible sidecar no longer matches the open handle.

Implementations

impl<V> PathRefreshingWalBackend<V>

where V: Vfs + 'static, V::File: Send + Sync + 'static,

pub fn new( vfs: V, db_path: impl AsRef<Path>, wal_path: impl AsRef<Path>, page_size: u32, wal: WalFile<V::File>, create_missing: bool, namespace_binding: Option<Arc<DatabaseNamespaceBinding>>, ) -> Self

pub fn into_inner(self) -> WalBackendAdapter<V::File>

Trait Implementations

impl<V> WalBackend for PathRefreshingWalBackend<V>

where V: Vfs + 'static, V::File: Send + Sync + 'static,

fn begin_transaction<'a>(&'a mut self, cx: &'a Cx) -> WalFuture<'a, ()>

Prepare WAL state for a newly-started transaction.

fn published_snapshot(&self) -> Option<WalPublicationSnapshot>

Capture the currently published WAL visibility summary for this handle.

fn pinned_read_snapshot(&self) -> Option<WalPublicationSnapshot>

Capture the currently pinned read snapshot for this handle, if any.

fn pinned_logical_read_snapshot<'a>( &'a self, cx: &'a Cx, ) -> WalFuture<'a, Option<WalLogicalReadSnapshot>>

Return an authorized logical horizon for the currently pinned reader snapshot, if the backend can prove one.

fn refresh_published_snapshot<'a>( &'a mut self, cx: &'a Cx, ) -> WalFuture<'a, Option<WalPublicationSnapshot>>

Refresh the published WAL visibility summary without pinning a new read transaction.

fn publish_authorized_deferred_commit<'a>( &'a mut self, cx: &'a Cx, ) -> WalFuture<'a, ()>

Publish a commit batch that the pager’s parallel-WAL protocol has already authorized after every tracked write completed.

fn append_frame<'a>( &'a mut self, cx: &'a Cx, page_number: u32, page_data: &'a [u8], db_size_if_commit: u32, ) -> WalFuture<'a, ()>

Append a single frame to the WAL.

fn append_frames<'a>( &'a mut self, cx: &'a Cx, frames: &'a [WalFrameRef<'a>], ) -> WalFuture<'a, ()>

Append a batch of frames to the WAL.

fn append_frames_tracked<'a>( &'a mut self, cx: &'a Cx, frames: &'a [WalFrameRef<'a>], completion: VfsWriteCompletion, ) -> WalFuture<'a, ()>

Append a batch while retaining a source-level completion observation.

fn prepare_append_frames( &self, frames: &[WalFrameRef<'_>], ) -> Result<Option<PreparedWalFrameBatch>>

Prepare a batch of frames for a later append.

fn finalize_prepared_frames( &self, cx: &Cx, prepared: &mut PreparedWalFrameBatch, ) -> Result<()>

Optionally finalize a prepared batch before the serialized append.

fn append_prepared_frames<'a>( &'a mut self, cx: &'a Cx, prepared: &'a mut PreparedWalFrameBatch, ) -> WalFuture<'a, ()>

Append a previously prepared frame batch.

fn append_prepared_frames_tracked<'a>( &'a mut self, cx: &'a Cx, prepared: &'a mut PreparedWalFrameBatch, completion: VfsWriteCompletion, ) -> WalFuture<'a, ()>

Append a prepared batch with a caller-retained completion token.

fn persist_parallel_wal_commit_certificate<'a>( &'a mut self, cx: &'a Cx, certificate: &'a ParallelWalCommitCertificate, wal_frame_start: u64, wal_frame_end: u64, sync: bool, ) -> WalFuture<'a, ()>

Append the certificate proof that authorizes the next WAL frame interval. Implementations must bind the record to their current WAL generation and make it durable when sync is true.

fn persist_parallel_wal_commit_certificate_tracked<'a>( &'a mut self, cx: &'a Cx, certificate: &'a ParallelWalCommitCertificate, wal_frame_start: u64, wal_frame_end: u64, sync: bool, completion: VfsWriteCompletion, ) -> WalFuture<'a, ()>

Persist the certificate sidecar write with source-level completion evidence retained independently of this future.

fn reconcile_parallel_wal_commit<'a>( &'a mut self, cx: &'a Cx, certificate: &'a ParallelWalCommitCertificate, wal_frame_start: u64, wal_frame_end: u64, sync: bool, ) -> WalFuture<'a, ParallelWalCommitReconciliation>

Reconcile one exact in-doubt certificate and WAL interval while the caller retains the external writer gate.

fn latest_authorized_parallel_wal_commit_certificate<'a>( &'a mut self, cx: &'a Cx, ) -> WalFuture<'a, Option<ParallelWalCommitCertificate>>

Return the newest durable certificate usable to seed the next logical commit clock.

fn read_page<'a>( &'a mut self, cx: &'a Cx, page_number: u32, ) -> WalFuture<'a, Option<Vec<u8>>>

Look up the latest version of a page in the current visible WAL snapshot.

fn read_page_pinned<'a>( &'a self, cx: &'a Cx, page_number: u32, ) -> WalFuture<'a, Option<Vec<u8>>>

Read a page from the WAL using a previously pinned read snapshot.

fn supports_pinned_reads(&self) -> bool

Whether this backend supports read_page_pinned (shared-lock reads).

fn committed_txns_since_page<'a>( &'a mut self, cx: &'a Cx, page_number: u32, ) -> WalFuture<'a, u64>

Count committed transactions that occur after the latest committed frame for page_number in the current visible WAL snapshot.

fn conflicting_pages_since_snapshot<'a>( &'a mut self, cx: &'a Cx, snapshot: TransactionConflictSnapshot, page_numbers: &'a [u32], page_baselines: &'a [TransactionConflictPageBaseline], ) -> WalFuture<'a, Vec<u32>>

Return conflict pages that were committed after snapshot.

fn committed_txn_count<'a>(&'a mut self, cx: &'a Cx) -> WalFuture<'a, u64>

Count committed transactions visible in the current WAL snapshot.

fn sync(&mut self, cx: &Cx) -> Result<()>

Sync the WAL file to stable storage.

fn frame_count(&self) -> usize

Number of valid frames currently in the WAL.

fn checkpoint<'a>( &'a mut self, cx: &'a Cx, mode: CheckpointMode, writer: &'a mut dyn CheckpointPageWriter, backfilled_frames: u32, oldest_reader_frame: Option<u32>, ) -> WalFuture<'a, CheckpointResult>

Run a checkpoint to transfer frames from the WAL to the database.