Struct SharedSqlite 

pub struct SharedSqlite { /* private fields */ }

Clonable handle onto a SqliteStore’s connection pool and serialization semaphore. Obtained via SqliteStore::shared. Holding one does not keep any device row alive — it is purely connection plumbing.

Implementations

impl SharedSqlite

pub async fn run<F, T>(&self, f: F) -> Result<T>

where F: FnOnce(&mut SqliteConnection) -> Result<T> + Send + 'static, T: Send + 'static,

Run f on a pooled connection from a blocking thread, holding one of the store’s serialization permits for the duration. The closure owns error mapping into StoreError so callers can also run non-query work (e.g. their own embedded migrations) through the same choke point.

This is the write path: everything that can modify the database belongs here, because the permit is what keeps two writers off SQLite at once. For work that only reads, read skips that queue.

pub async fn read<F, T>(&self, f: F) -> Result<T>

where F: FnOnce(&mut SqliteConnection) -> Result<T> + Send + 'static, T: Send + 'static,

Run a read-only f without queueing behind the write permit.

WAL lets readers run alongside the single writer, which is the whole reason a slow query should not be able to stall the rest of a session. Reads still take a permit — one per reader connection — so the number of blocking threads stays bounded by the pool.

f runs inside a deferred transaction, so every statement in it sees one snapshot. The write permit used to supply that for free — while a read held it the writer could not commit between its statements — and a reader that resolves a chat’s identity keys and then queries by them, or collects search hits and then hydrates them, would otherwise straddle two committed states and come back short. A deferred transaction over read-only statements never asks for the write lock, so it pins the snapshot without contending with the writer.

Only correct for statements that cannot write. A write sent through here escapes the serialization the store relies on and can deadlock against the real writer on the transaction upgrade, which busy_timeout cannot resolve. When a store has no reader connections configured (SqliteStoreConfig::read_pool_size left at 0) this queues on the write permit exactly like run, so it is always safe to call — it simply buys no concurrency until the embedder opts in.

Trait Implementations

impl Clone for SharedSqlite

fn clone(&self) -> SharedSqlite

Returns a duplicate of the value.

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

Performs copy-assignment from source.