Struct WalBackendAdapter 

pub struct WalBackendAdapter<F: VfsFile> { /* private fields */ }

Implementations

impl<F: VfsFile> WalBackendAdapter<F>

pub fn new(wal: WalFile<F>) -> Self

Wrap an existing WalFile in the adapter (FEC disabled).

pub fn with_fec_hook(wal: WalFile<F>, hook: FecCommitHook) -> Self

Wrap an existing WalFile with an FEC commit hook.

pub fn has_pending_publication(&self) -> bool

Whether staged, unpublished frames remain.

Staged frames may already be durable — an intermediate sync makes them so without committing them — but they are not yet part of the published visibility plane. Callers that would discard, consume, or replace this adapter must check this first: dropping the staged metadata loses the batch, and a freshly wrapped adapter would republish those frames straight from the WAL with no knowledge of their publication state (GH #187).

pub fn into_inner(self) -> Result<WalFile<F>>

Consume the adapter and return the inner WalFile.

Fails closed while staged, unpublished frames remain: consuming the adapter discards the staged publication metadata, and the WalFile can be rewrapped by an adapter that would then publish those frames without knowing whether they were ever published or fsynced (GH #187). Drain the batch with a successful commit sync first. Returns FrankenError::Busy: this is a retryable ordering condition, not database corruption.

pub fn inner(&self) -> &WalFile<F>

Borrow the inner WalFile.

pub fn inner_mut(&mut self) -> Result<&mut WalFile<F>>

Mutably borrow the inner WalFile for explicit external mutation.

Invalidates the publication plane, since the caller may mutate WAL state arbitrarily. That invalidation discards any staged batch, so this fails closed while one exists rather than silently dropping the commit horizon (GH #187): after the discard, a later publish would see no pending state and could expose frames that were never fsynced. Drain the batch with a successful sync first.

pub fn published_snapshot(&self) -> WalPublicationSnapshot

Capture the currently published WAL visibility summary for this handle.

This is a cheap snapshot of the publication plane the adapter has already materialized. Call Self::refresh_published_snapshot first if the caller needs to bind to the latest on-disk committed prefix.

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

Capture the currently pinned read snapshot, if this handle has one.

pub async fn refresh_published_snapshot( &mut self, cx: &Cx, ) -> Result<WalPublicationSnapshot>

Refresh this handle from disk and republish the latest committed WAL visibility summary without pinning a read transaction.

pub fn take_fec_pending(&mut self) -> Vec<FecCommitResult>

Take any pending FEC commit results for sidecar persistence.

pub fn fec_enabled(&self) -> bool

Whether FEC encoding is active.

pub fn fec_discard(&mut self)

Discard buffered FEC pages (e.g. on transaction rollback).

Trait Implementations

impl<F: VfsFile> WalBackend for WalBackendAdapter<F>

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 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 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.

fn pinned_logical_read_snapshot<'a>( &'a self, _cx: &'a Cx, ) -> Pin<Box<dyn Future<Output = Result<Option<WalLogicalReadSnapshot>, FrankenError>> + Send + 'a>>

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

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, ) -> Pin<Box<dyn Future<Output = Result<(), FrankenError>> + Send + '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, ) -> Pin<Box<dyn Future<Output = Result<(), FrankenError>> + Send + '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, ) -> Pin<Box<dyn Future<Output = Result<ParallelWalCommitReconciliation, FrankenError>> + Send + 'a>>

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, ) -> Pin<Box<dyn Future<Output = Result<Option<ParallelWalCommitCertificate>, FrankenError>> + Send + 'a>>

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