Enum Durability 

pub enum Durability {
    SyncEachWrite,
    Disabled,
}

WAL durability mode for the write engine.

Controls whether write and write_async append to and fsync the write-ahead log on every call. The default (SyncEachWrite) matches the pre-existing behavior and is the only safe choice for production workloads — a process crash between a successful write and a later flush will lose mutations written with Disabled.

When to use Disabled

• Bulk-load / import pipelines where the source data is replayable and you are willing to re-run the load on failure.
• Benchmarking where you want to isolate CPU-bound write throughput from fsync latency. The companion write/ingest_wal_off Criterion bench uses this variant (see cqlite-core/benches/write.rs).

In both cases, call WriteEngine::flush (and, optionally, WriteEngine::close) when the load is finished so the data is durably persisted to SSTables.

WAL replay on restart

When Disabled, no WAL entries are written. Reopening the engine on the same wal_dir after a crash will replay zero mutations, even if flush was never called. If you need crash-safe recovery, use SyncEachWrite.

Example

use cqlite_core::storage::write_engine::{Durability, WriteEngineConfig};

// Production (default)
let config = WriteEngineConfig::new(data, wal, schema);

// Bulk-load / benchmarking
let config = WriteEngineConfig::new(data, wal, schema)
    .with_durability(Durability::Disabled);

Variants

SyncEachWrite

Append to the WAL and call fsync on every write / write_async call. A successful return guarantees the mutation is durable on disk.

This is the default and the safe choice for all production workloads.

Disabled

Skip WAL append and fsync on every write / write_async call. Mutations are buffered in the memtable only. Data is durable only after a successful WriteEngine::flush.

Use only for bulk-load pipelines and benchmarks where durability can be traded for throughput.

Trait Implementations

impl Clone for Durability

fn clone(&self) -> Durability

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Durability

impl Debug for Durability

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

Formats the value using the given formatter.

impl Default for Durability

fn default() -> Durability

Returns the “default value” for a type.

impl Eq for Durability

impl PartialEq for Durability

fn eq(&self, other: &Durability) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Durability