Struct LogDb 

pub struct LogDb { /* private fields */ }

The main log interface providing read and write operations.

LogDb is the primary entry point for interacting with OpenData Log. It provides methods to append records, scan entries, and count records within a key’s log.

Read Operations

Read operations are provided via the LogRead trait, which LogDb implements. This allows generic code to work with either LogDb or LogDbReader.

Thread Safety

LogDb is designed to be shared across threads. All methods take &self and internal synchronization is handled automatically.

Writer Semantics

Currently, each log supports a single writer. Multi-writer support may be added in the future, but would require each key to have a single writer to maintain monotonic ordering within that key’s log.

Example

use log::{LogDb, LogRead, Record, WriteOptions};
use bytes::Bytes;

// Open a log (implementation details TBD)
let log = LogDb::open(config).await?;

// Append records
let records = vec![
    Record { key: Bytes::from("user:123"), value: Bytes::from("event-a") },
    Record { key: Bytes::from("user:456"), value: Bytes::from("event-b") },
];
log.append(records).await?;

// Scan entries for a specific key
let mut iter = log.scan(Bytes::from("user:123"), ..).await?;
while let Some(entry) = iter.next().await? {
    println!("seq={}: {:?}", entry.sequence, entry.value);
}

Implementations

impl LogDb

pub async fn open(config: Config) -> Result<Self>

Opens or creates a log with the given configuration.

This is the primary entry point for creating a LogDb instance. The configuration specifies the storage backend and other settings.

Arguments

• config - Configuration specifying storage backend and settings.

Errors

Returns an error if the storage backend cannot be initialized.

Example

use log::{LogDb, Config};

let log = LogDb::open(test_config()).await?;

pub async fn append(&self, records: Vec<Record>) -> Result<AppendResult>

Appends records to the log.

Records are assigned sequence numbers in the order they appear in the input vector. All records in a single append call are written atomically.

This method uses default write options. Use append_with_options for custom durability settings.

Arguments

• records - The records to append. Each record specifies its target key and value.

Returns

On success, returns an AppendResult containing the starting sequence number assigned to the batch.

Errors

Returns an error if the write fails due to storage issues.

Example

let records = vec![
    Record { key: Bytes::from("events"), value: Bytes::from("event-1") },
    Record { key: Bytes::from("events"), value: Bytes::from("event-2") },
];
let result = log.append(records).await?;
println!("Appended at seq {}", result.start_sequence);

pub async fn append_with_options( &self, records: Vec<Record>, options: WriteOptions, ) -> Result<AppendResult>

Appends records to the log with custom options.

Records are assigned sequence numbers in the order they appear in the input vector. All records in a single append call are written atomically.

Arguments

• records - The records to append. Each record specifies its target key and value.
• options - Write options controlling durability behavior.

Returns

On success, returns an AppendResult containing the starting sequence number assigned to the batch.

Errors

Returns an error if the write fails due to storage issues.

Example

let records = vec![
    Record { key: Bytes::from("events"), value: Bytes::from("critical-event") },
];
let options = WriteOptions { await_durable: true };
let result = log.append_with_options(records, options).await?;
println!("Started at sequence {}", result.start_sequence);

pub async fn check_storage(&self) -> Result<()>

Checks if the underlying storage is accessible.

This performs a lightweight read operation to verify that the storage backend is responding. Use this for health/readiness checks.

Returns

Returns Ok(()) if storage is accessible, or an error if the check fails.

pub async fn flush(&self) -> Result<()>

Flushes all pending writes to durable storage.

This ensures that all writes that have been acknowledged are persisted to durable storage. For SlateDB-backed storage, this flushes the memtable to the WAL and object store.

pub async fn close(self) -> Result<()>

Closes the log, releasing any resources.

This method should be called before dropping the log to ensure proper cleanup. For SlateDB-backed storage, this releases the database fence.

Trait Implementations

impl LogRead for LogDb

fn scan_with_options<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, options: ScanOptions, ) -> Pin<Box<dyn Future<Output = Result<LogIterator>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Scans entries for a key within a sequence number range with custom options.

fn count_with_options<'life0, 'async_trait>( &'life0 self, _key: Bytes, _seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, _options: CountOptions, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Counts entries for a key within a sequence number range with custom options.

fn list_keys<'life0, 'async_trait>( &'life0 self, segment_range: impl 'async_trait + RangeBounds<SegmentId> + Send, ) -> Pin<Box<dyn Future<Output = Result<LogKeyIterator>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists distinct keys within a segment range.

fn list_segments<'life0, 'async_trait>( &'life0 self, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<Vec<Segment>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists segments overlapping a sequence number range.

fn scan<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<LogIterator>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Scans entries for a key within a sequence number range.

fn count<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Counts entries for a key within a sequence number range.