Struct ColumnarOutbound 

pub struct ColumnarOutbound<S: StorageEngine> { /* private fields */ }

Durable outbound queue for columnar inserts.

Held as Arc<ColumnarOutbound<S>> by NodeDbLite and shared with ColumnarEngine via Arc. The inner storage is accessed only for enqueue (from the sync insert path) and drain_batch/ack_keys (from the async sync transport path).

Implementations

impl<S: StorageEngine> ColumnarOutbound<S>

pub async fn open(storage: Arc<S>) -> Result<Self, LiteError>

Open the durable queue backed by Namespace::ColumnarPending.

pub async fn open_with_cap( storage: Arc<S>, cap: usize, ) -> Result<Self, LiteError>

Open with a custom cap.

pub async fn enqueue_row( &self, collection: &str, row: Vec<Value>, schema_bytes: Vec<u8>, ) -> Result<(), LiteError>

Durably enqueue a single row for a collection.

Rows for the same collection are not coalesced here — each call produces one durable entry. The sync transport batches by collection when building wire frames.

Returns LiteError::Backpressure when the queue is at cap.

pub async fn drain_batch( &self, limit: usize, ) -> Result<Vec<(Vec<u8>, PendingColumnarBatch)>, LiteError>

Drain up to limit pending batches in FIFO order, skipping any entries currently in-flight (sent but not yet acked by Origin).

Returns (durable_key, batch) pairs. On send success, call [mark_in_flight] with the batch_id and key. The durable entry is deleted only when Origin’s ack arrives via [ack_in_flight].

Does not remove entries from storage.

pub async fn mark_in_flight(&self, batch_id: u64, durable_key: Vec<u8>)

Record that a batch has been sent to Origin and is awaiting its ack.

The durable entry is kept in storage until [ack_in_flight] is called.

pub async fn ack_in_flight(&self, batch_id: u64) -> Option<Vec<u8>>

Remove the in-flight record for batch_id and return its durable key.

Returns Some(key) if the entry was in-flight; None if already acked or not tracked (e.g. the entry was un-encodable and dropped at send time).

pub async fn clear_in_flight(&self)

Clear all in-flight records on reconnect.

The durable entries are still in storage and will be re-drained on the next push tick. Origin’s idempotent gate deduplicates re-sent batches.

pub async fn ack_keys(&self, keys: &[Vec<u8>]) -> Result<(), LiteError>

Delete the durable entries identified by keys (Origin ack path).

pub async fn update_entry( &self, key: &[u8], batch: &PendingColumnarBatch, ) -> Result<(), LiteError>

Update the durable payload for key with the new seq stamped into batch.

pub async fn len(&self) -> Result<u64, LiteError>

Number of pending entries in durable storage.

pub async fn is_empty(&self) -> Result<bool, LiteError>

Returns true if no pending entries remain.