Struct WAL 

pub struct WAL { /* private fields */ }

Write-Ahead Log for durability.

Uses an append-only on-disk format: each flush_to_disk() call serializes only the new records since the last flush and appends them to the file. The full file is only rewritten during clear() (checkpoint).

Implementations

impl WAL

pub fn new(path: PathBuf) -> Self

pub fn path(&self) -> &PathBuf

pub fn append(&mut self, record: WALRecord)

pub fn log_column_write( &mut self, table_id: u64, col_id: u32, page_id: u64, data: &[u8], )

Log a column page write before it is applied to the BufferManager.

pub fn write_raw_buffer(&mut self, local_wal_buffer: &[u8])

Bulk-copy a LocalWAL’s serialized buffer into this global WAL.

Called during commit path: the transaction’s LocalWAL has already been serialized to a byte buffer; this method appends the raw bytes directly to the in-memory record list.

The caller (StorageManager::commit_transaction()) is responsible for holding the Arc<Mutex<WAL>> lock to serialize concurrent calls.

pub fn records(&self) -> &[WALRecord]

pub fn clear(&mut self) -> Result<()>

Clear all in-memory records and truncate the WAL file on disk.

Called during checkpoint after dirty pages have been flushed — at this point the WAL data is durable in the main DB files and can be discarded.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn total_size(&self) -> usize

pub fn is_dirty(&self) -> bool

pub fn replay<F>(&self, apply: F) -> Result<()>

where F: FnMut(&WALRecord) -> Result<()>,

Replay the WAL to recover state after a crash.

pub fn flush_to_disk(&mut self) -> Result<()>

Append-only flush: serialize only records not yet on disk.

Instead of rewriting the entire WAL file (O(n) per flush → O(n²) total), this method serializes only the new records since the last flush and appends them to the existing file. The header is written once on the first flush after a clear() (checkpoint).

Crash safety: CRC32 per record detects partial appends. A partial final record is silently skipped on recovery.

On-disk format (v2)

┌──────────────────────────────────────────────┐
│ Header: "AKAR" (4 bytes) + version (u16 LE) │
├──────────────────────────────────────────────┤
│ Per record:                                  │
│   CRC32 (u32 LE) of [tag .. payload]        │
│   tag (1 byte)                               │
│   payload (variable)                         │
└──────────────────────────────────────────────┘

pub fn load_from_disk(&mut self) -> Result<()>

Load WAL records from disk.

Supports both v1 (no checksums) and v2 (CRC32 per record) formats. Records with invalid checksums are silently skipped with a warning.