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(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 sql_read. The closure receives the &Connection coven owns; because the connection is read-only, any write statement fails at the SQLite layer.
• 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 Config on a cloud miss, exactly as a home-less full handle does — there is no sync loop to reuse.

Implementations

impl CovenReadHandle

pub async fn sql_read<F, R>(&self, f: F) -> CovenResult<R>

where F: FnOnce(&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::sql_read: the closure receives the &Connection directly (coven serializes access on its connection thread, so this never races the writer’s process), and a host closure written against CovenHandle::sql_read ports unchanged here. The connection is SQLITE_OPEN_READONLY: a SELECT/PRAGMA reads normally, and any INSERT/UPDATE/DELETE/DDL is refused by SQLite — the read-only guarantee is enforced at the connection, not left to the caller.

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, offset: u64, len: u64, ) -> Result<Vec<u8>, BlobCacheError>

Serve len plaintext bytes of an exact row blob starting at offset, for streaming or seeking without loading the whole file. The RowBlobRef carries the plaintext length used to bound the range. The ranged sibling of read_blob; a Remote-miss range read fetches from the cloud but writes no cache file (only a whole-file read populates).

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: &[BlobRef]) -> 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.