Struct ModelCache 

pub struct ModelCache { /* private fields */ }

A second-level cache for models.

Cheap to clone; every clone shares one backend and one set of counters.

Implementations

impl ModelCache

pub fn new(store: impl Cache) -> ModelCache

A cache over any Cache backend — memory, file, or Redis.

pub fn shared(store: &CacheStore) -> ModelCache

The store the application already built, shared rather than duplicated.

pub fn region<M: Model>(self, region: Region) -> ModelCache

Register a model, with settings.

Panics on settings that contradict each other — a read-only region with no expiry, say. That is a startup failure by design: the alternative is a stale row six weeks from now with nothing to trace it to.

pub fn cache_everything(self, region: Region) -> ModelCache

Cache every model, registered or not, with these settings.

For an application that has decided it wants this everywhere. A model with its own region still uses that.

pub fn stats(&self) -> &Stats

pub async fn find<M: Model + Send>( &self, db: &Database, key: M::Key, ) -> Result<Option<M>>

A model by primary key, from the cache when it is there.

pub async fn get<M: Model + Send>( &self, db: &Database, query: QueryBuilder, ) -> Result<Vec<M>>

A query’s results, from the cache when they are there and still current.

pub async fn first<M: Model + Send>( &self, db: &Database, query: QueryBuilder, ) -> Result<Option<M>>

The first result, from the cache when it is there.

pub async fn insert<M: Model + Send + Sync>( &self, db: &Database, model: &mut M, ) -> Result<()>

Insert, and invalidate what the insert makes stale.

pub async fn update<M: Model + Send + Sync>( &self, db: &Database, model: &M, ) -> Result<u64>

Update, and invalidate the entity and the table’s cached queries.

pub async fn delete<M: Model + Send + Sync>( &self, db: &Database, model: &M, ) -> Result<u64>

Delete, and the same.

pub async fn forget<M: Model>(&self, key: M::Key) -> Result<()>

Drop one entity from the cache. The table’s queries are left alone.

For a write this cache did not make — a raw UPDATE, a migration, a change from another process. Almost always wanted together with invalidate_table.

pub async fn invalidate_table<M: Model>(&self) -> Result<()>

Make every cached query for this table a miss.

One counter, bumped. There is no way to enumerate the result sets a write invalidates — a cached WHERE role = 'admin' is invalidated by an insert whose shape this cache never sees — so the generation is what stands in for that enumeration.

pub async fn invalidate_all(&self) -> Result<()>

Everything this cache put in the store, for every table.

Bumps each registered table’s generation rather than flushing the backend, because the backend is shared: flushing it would take the session store and the rate limiter with it.

impl ModelCache

The store, for a caller that wants to reach past this.

pub fn store(&self) -> &Arc<dyn Cache>

Trait Implementations

impl Clone for ModelCache

fn clone(&self) -> ModelCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.