Struct SegmentedStore 

pub struct SegmentedStore { /* private fields */ }

A WalStore that stripes one flat byte space across fixed-size segment files in a directory.

Open one with SegmentedStore::open and hand it to Wal::with_store, or use the Wal::open_segmented convenience constructor. Segments are created lazily as the log grows, and sync flushes only the segments with unwritten changes, not the whole history.

Examples

use wal_db::{SegmentedStore, Wal};

// 1 MiB segments. Records larger than a segment simply span several.
let store = SegmentedStore::open(dir.path(), 1024 * 1024)?;
let wal = Wal::with_store(store)?;
wal.append(b"spans nothing yet")?;
wal.sync()?;

Implementations

impl SegmentedStore

pub fn open(dir: impl AsRef<Path>, segment_size: u64) -> Result<Self>

Open the segmented log in dir, creating the directory if needed, with segments of segment_size bytes.

Existing segment files are picked up so the log can be recovered. The store does not validate record contents — that is Wal::open’s recovery scan, which runs unchanged over the flat space.

Errors

Returns WalError::Io if segment_size is zero, or if the directory cannot be created or read.

pub fn dir(&self) -> &Path

The directory holding the segment files.

pub fn segment_size(&self) -> u64

The configured segment size in bytes.

Trait Implementations

impl Debug for SegmentedStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl WalStore for SegmentedStore

fn write_at(&self, offset: u64, bytes: &[u8]) -> Result<()>

Write bytes at byte offset, growing the store and zero-filling any gap if offset is beyond the current end.

fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize>

Read into buf starting at byte offset, returning the number of bytes read.

fn truncate(&self, len: u64) -> Result<()>

Discard every byte at or after len, shrinking the store to exactly len bytes.

fn sync(&self) -> Result<()>

Flush every preceding write_at to stable storage.

fn len(&self) -> Result<u64>

The current size of the store in bytes.

fn head(&self) -> Result<u64>

The lowest offset that still holds data.

fn truncate_before(&self, offset: u64) -> Result<u64>

Discard storage entirely below offset, if the backend can, returning the new head.

fn is_empty(&self) -> Result<bool>

Whether the store holds no bytes.