Struct SegmentStore 

pub struct SegmentStore { /* private fields */ }

Append-only, content-addressed packed object store with an in-memory index.

Implementations

impl SegmentStore

pub fn open(objects_root: &Path) -> Result<Self>

Open (or create) the segment store under {objects_root}/segments.

pub fn open_with_max( objects_root: &Path, max_segment_bytes: u64, ) -> Result<Self>

Like open, with an explicit rollover size (used by tests).

pub fn contains(&self, hash: &str) -> bool

True if this hash is already stored in a segment.

pub fn put(&self, hash: &str, content: &[u8]) -> Result<()>

Append content under hash (idempotent). hash must equal BLAKE2b(content); the caller computes it (parallel, outside the lock).

pub fn get(&self, hash: &str) -> Result<Option<Vec<u8>>>

Read the raw content bytes for hash, or None if not stored in any segment (caller then falls back to the loose-object path). Re-verifies.

pub fn all_hashes(&self) -> Vec<String>

All hashes currently stored in segments.

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

Flush + fsync the active segment. One durability point per batch.

pub fn compact(&self, live: &HashSet<String>) -> Result<CompactStats>

Rewrite the live object set into fresh segments and drop everything else, reclaiming dead (superseded/spent/pruned) records.

live is the set of hashes to KEEP — typically the current version of every document (from the id-index). Hashes not in live are pruned, so historical versions / AS OF / TRACE for dropped objects are discarded by design (that is what reclaims space).

Crash-safe: new segments are written + fsynced BEFORE any old segment is deleted, so live data is never lost. A crash mid-compaction leaves both the old and new segments (a re-open re-indexes the union — dead objects merely linger until the next compaction); it never loses a live object.

Must be called when the store is quiescent (no concurrent reads): writes are blocked for the duration via the active lock, and the in-memory index is swapped in place.