Struct WriteAheadLog 

pub struct WriteAheadLog { /* private fields */ }

Write-Ahead Log for crash recovery.

All write operations are logged to disk before being applied to the database. This ensures that the database can be recovered to a consistent state after a crash.

Thread Safety

WriteAheadLog is thread-safe and can be shared across multiple threads using Arc.

Implementations

impl WriteAheadLog

pub fn open(path: &Path) -> DbxResult<Self>

Opens or creates a WAL file at the specified path.

If the file exists, it will be opened in append mode. The sequence number is initialized to the highest sequence in the existing log.

Arguments

• path - Path to the WAL file

Example

let wal = WriteAheadLog::open(Path::new("./wal.log"))?;

pub fn append(&self, record: &WalRecord) -> DbxResult<u64>

Appends a record to the WAL.

Returns the sequence number assigned to this record. The record is buffered in memory until sync() is called.

Arguments

• record - The WAL record to append

Returns

The sequence number assigned to this record

Example

let wal = WriteAheadLog::open(Path::new("./wal.log"))?;
let record = WalRecord::Insert {
    table: "users".to_string(),
    key: b"key1".to_vec(),
    value: b"value1".to_vec(),
    ts: 0,
};
let seq = wal.append(&record)?;

pub fn sync(&self) -> DbxResult<()>

Synchronizes the WAL to disk (fsync).

This ensures that all buffered writes are persisted to disk. Call this after critical operations to guarantee durability.

Example

let wal = WriteAheadLog::open(Path::new("./wal.log"))?;
let record = WalRecord::Insert {
    table: "users".to_string(),
    key: b"key1".to_vec(),
    value: b"value1".to_vec(),
    ts: 0,
};
wal.append(&record)?;
wal.sync()?;  // Ensure durability

pub fn replay(&self) -> DbxResult<Vec<WalRecord>>

Replays all records from the WAL.

Reads the entire WAL file and returns all records in order. Used during database recovery to restore the state after a crash.

Returns

A vector of all WAL records in the order they were written

Example

let tmp = tempfile::NamedTempFile::new().unwrap();
let wal = WriteAheadLog::open(tmp.path())?;
let records = wal.replay()?;
for record in records {
    // Apply record to database
}

pub fn current_sequence(&self) -> u64

Returns the current sequence number.