Struct CachedSqlStore 

pub struct CachedSqlStore<DB, K, V, E, I = K>
where
    DB: Database,
{ /* private fields */ }

A typed SQL pool with cache-aside record loading and mutation invalidation.

Both present records and missing records are cached, which protects the database from repeated lookups for absent keys. Concurrent misses for one key are coalesced. Successful mutations invalidate their keys while coordinating with in-flight loads, preventing an older query from restoring stale data after the mutation completes.

Implementations

impl<DB, K, V, E, I> CachedSqlStore<DB, K, V, E, I>

where DB: Database, K: Clone + Eq + Hash, I: Clone + Eq + Hash, V: Clone,

pub fn new(store: SqlStore<DB>, config: SqlCacheConfig) -> Self

pub fn store(&self) -> &SqlStore<DB>

pub fn pool(&self) -> &Pool<DB>

pub async fn find<F, Fut>( &self, key: K, query: F, ) -> Result<Option<V>, SingleFlightError<E>>

where F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<Option<V>, E>>,

Returns a cached record or loads it from SQL once across concurrent callers.

The query receives a cheap clone of the underlying SQLx pool, allowing its returned future to own everything it needs without boxed futures or lifetime plumbing.

pub async fn find_by_index<F, Fut>( &self, index: I, query: F, ) -> Result<Option<V>, SingleFlightError<E>>

where F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<Option<(K, V)>, E>>,

Returns a record selected by a secondary key.

Successful lookups cache both the primary record and the secondary-to-primary mapping. Missing secondary keys use the configured not-found policy. Concurrent misses for the same secondary key are coalesced independently from primary-key lookups.

pub async fn execute<PI, F, Fut, R>( &self, keys: PI, operation: F, ) -> Result<R, E>

where PI: IntoIterator<Item = K>, F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<R, E>>,

Runs a SQL mutation and invalidates the affected cache keys after it succeeds.

pub async fn execute_indexed<PI, SI, F, Fut, R>( &self, primary_keys: PI, index_keys: SI, operation: F, ) -> Result<R, E>

where PI: IntoIterator<Item = K>, SI: IntoIterator<Item = I>, F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<R, E>>,

Runs a mutation and invalidates primary keys plus explicitly affected secondary keys.

Learned secondary mappings for each primary key are removed automatically. Callers should also pass newly introduced or changed secondary keys so a previously cached not-found result cannot hide an insert or update.

pub fn invalidate(&self, key: &K) -> bool

Invalidates a key and reports whether it held a positive or negative cached record.

pub fn invalidate_many<PI>(&self, keys: PI)

where PI: IntoIterator<Item = K>,

pub fn invalidate_index(&self, index: &I) -> bool

pub fn invalidate_related<PI, SI>(&self, primary_keys: PI, index_keys: SI)

where PI: IntoIterator<Item = K>, SI: IntoIterator<Item = I>,

pub fn cache_stats(&self) -> CacheStats

pub fn index_cache_stats(&self) -> CacheStats