Struct L0Manager 

pub struct L0Manager { /* private fields */ }

Implementations

impl L0Manager

pub fn new(start_version: u64, wal: Option<Arc<WriteAheadLog>>) -> Self

pub fn from_snapshot( current: Arc<RwLock<L0Buffer>>, pending_flush: Vec<Arc<RwLock<L0Buffer>>>, ) -> Self

Create a read-only snapshot L0Manager from existing buffers.

Used by the algorithm execution path to provide L0 visibility without owning the actual L0 lifecycle (rotation, flush, WAL).

pub fn get_current(&self) -> Arc<RwLock<L0Buffer>>

Get the current L0 buffer.

pub fn get_all_readable(&self) -> Vec<Arc<RwLock<L0Buffer>>>

Get all L0 buffers that should be visible to reads. This includes the current L0 plus any L0s being flushed.

pub fn get_pending_flush(&self) -> Vec<Arc<RwLock<L0Buffer>>>

Get L0 buffers currently being flushed (for QueryContext).

pub fn rotate( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> Arc<RwLock<L0Buffer>>

Rotate L0. Returns the OLD L0 buffer. The new L0 is initialized with next_version and new_wal.

pub fn begin_flush( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> Arc<RwLock<L0Buffer>>

Begin flush: rotate L0 and add old L0 to pending flush list. The old L0 remains visible to reads until complete_flush is called. Returns the old L0 buffer to be flushed.

pub fn complete_flush(&self, l0: &Arc<RwLock<L0Buffer>>)

Complete flush: remove the flushed L0 from pending list. Call this only after L1 writes have succeeded.

pub fn snapshot_isolated( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> (Arc<RwLock<L0Buffer>>, Vec<Arc<RwLock<L0Buffer>>>)

Captures an isolated snapshot of the current L0 (strategy D).

Freezes the current buffer by rotating it aside — writers re-fetch get_current() at write time, so they move to the fresh buffer and can never mutate the frozen one — and keeps it readable via the pending list. Returns the (frozen_main, pending) pair used to build a QueryContext whose reads are isolated from later writes. Capture is O(1): one empty-buffer allocation and an Arc move, with no deep copy.

The caller must coordinate with the commit path (e.g. hold the writer’s flush_lock) so the rotation does not race an in-flight merge into the current buffer. The frozen generation currently rides the pending-flush list; a dedicated generation list with reader-count GC is the production follow-up (see the proposal’s open questions).

pub fn pin_snapshot(&self) -> SnapshotView

Pins an isolated view of the current L0 tier for a transaction.

O(1): clones the current buffer handle, the pending-flush set, and the generation’s pin token. No freeze happens here — the current buffer keeps taking writes; it is frozen aside lazily, and only if still pinned, when a commit would next mutate it (see Self::freeze_current_for_snapshot and Self::is_current_pinned). Holds the current read lock across the buffer and token clones so both come from the same generation even if a rotate races. Does not require the writer’s flush_lock.

Examples

let snap = writer.l0_manager().pin_snapshot();
// build a QueryContext from `snap.main` + `snap.extra`

pub fn is_current_pinned(&self) -> bool

Returns true if any live SnapshotView pins the current generation.

strong_count > 1 means a snapshot besides the manager holds the token. Call under the writer’s flush_lock at commit so the decision and any resulting freeze are atomic with respect to the merge.

pub fn freeze_current_for_snapshot(&self)

Clones the current (pinned) generation aside so a commit can mutate a fresh buffer without the pinning snapshots observing the write — lazy copy-on-write, performed only when Self::is_current_pinned holds.

The outgoing buffer — which the pinning SnapshotViews hold via main — becomes immutable: a deep copy carrying the same data is installed as the new current, the commit merges into that copy, and the original is never mutated again. L0Buffer::clone drops the WAL handle, so the original’s WAL (already flushed at this commit’s WAL step) is handed to the copy; the frozen original keeps none, as it takes no more writes. The original is not placed on the pending-flush list — it is reclaimed by Arc refcount once the last snapshot drops, so nothing leaks. The new generation starts unpinned (the pin token is reset). Must be called under the writer’s flush_lock, since it swaps the current buffer.

pub fn min_pending_wal_lsn(&self) -> Option<u64>

Get the minimum WAL LSN across all pending flush L0s. WAL truncation should not go past this LSN to preserve data for pending flushes. Returns None if no pending flushes exist.