Struct CovenReadHandle 

pub struct CovenReadHandle { /* private fields */ }

A read-only handle over one coven store, for a same-store secondary reader.

Open it with Coven::builder(store_dir, cfg).open_read_only(). Cheap to clone — every field is shared (an Arc or a Clone handle), so a clone reads the same database and storage as the original.

What it can do

• Rows — read via read. The closure receives a SqlReadContext that exposes queries without the retained connection.
• Blobs — read_blob and open_blob_stream resolve a blob’s locality and serve it from the local store, the cache, or a cloud fetch into the per-device cache. is_pinned reports whether a set is kept offline.

It builds read storage from the current crate::Config on a cloud miss, exactly as a home-less full handle does — there is no sync loop to reuse.

Implementations

impl CovenReadHandle

pub fn read<F, R>(&self, f: F) -> Read<'_, F>

where F: for<'connection> FnOnce(SqlReadContext<'connection>) -> CovenResult<R> + Send + 'static, R: Send + 'static,

Run a pure read against the connection coven owns and await the result.

This is the read handle’s form of CovenHandle::read: the closure receives the same SqlReadContext, and Coven runs the query in one transaction on an available read-only worker. Attach process before awaiting to process owned results on separate workers after releasing the connection.

pub async fn row_blob_ref( &self, table: &str, row_id: &str, ) -> Result<RowBlobRef, DbError>

Capture the exact current blob-bearing row version from this reader’s database snapshot.

pub async fn read_blob( &self, blob: &RowBlobRef, ) -> Result<Vec<u8>, BlobCacheError>

Read a blob’s whole plaintext through coven’s locality-aware read: served from the user’s file (Local user-provided), coven’s local store (Local host-provided), the pinned/evictable cache on a Remote hit, or fetched from the cloud into the cache on a Remote miss. The read counterpart of CovenHandle::read_blob.

A cloud fetch writes the fetched bytes into the per-device cache (storage/cache/) with an atomic temp-then-rename — device scratch, no synced state touched — so a File Provider materializing remote content works through a read-only handle. The supplied RowBlobRef already carries the exact stored object and authority, so the read performs no database write or cloud listing.

pub async fn open_blob_stream( &self, blob: &RowBlobRef, ) -> Result<BlobStream, BlobCacheError>

Open an exact row blob’s plaintext for ranged reading, for streaming or seeking without loading the whole file. The ranged sibling of read_blob; the read counterpart of CovenHandle::open_blob_stream.

Opening resolves the blob’s locality, proves the plaintext’s size and content hash against the row, and holds the open file, so every BlobStream::read_at costs only the bytes it returns. A Remote miss fetches the exact cloud object once and populates the per-device cache (storage/cache/) with an atomic temp-then-link — device scratch, no synced state touched — so a File Provider serving ranges through a read-only handle downloads the object once per opened stream, not once per range.

pub fn open_app_data( &self, sealed: &[u8], aad: &[u8], ) -> Result<Vec<u8>, SealError>

Open a payload CovenHandle::seal_app_data produced, resolving the store’s master keyring through this handle’s custody. The read side of app-data sealing: a secondary reader opens what the writer sealed, under whichever generation the payload names.

There is no seal counterpart here — sealing writes new ciphertext, which is the writer’s job; this handle only reads.

SealError::Locked if the store is locked; a wrong aad, a tampered payload, an unreadable version, or a generation this store’s keyring lacks each surface their own typed error.

pub async fn is_pinned( &self, blobs: &[RowBlobRef], ) -> Result<bool, BlobCacheError>

Whether every blob in blobs is pinned for offline — present in coven’s kept cache folder (storage/pinned/). An empty set is vacuously pinned. A read; it stats the folder, never writes.

Trait Implementations

impl Clone for CovenReadHandle

fn clone(&self) -> CovenReadHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.