Struct CachedMongoCollection 

pub struct CachedMongoCollection<K, T, I = K>
where
    T: Send + Sync,
{ /* private fields */ }

A typed MongoDB collection with bounded positive/negative record caching.

Implementations

impl<K, T, I> CachedMongoCollection<K, T, I>

where K: Clone + Eq + Hash, I: Clone + Eq + Hash, T: Clone + Send + Sync,

pub fn new(collection: Collection<T>, config: MongoCacheConfig) -> Self

pub fn collection(&self) -> &Collection<T>

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

where F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<Option<T>, DriverError>>,

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

where F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<Option<(K, T)>, DriverError>>,

Returns a document selected by a secondary key while caching its primary-key mapping.

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

where PI: IntoIterator<Item = K>, F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<R, DriverError>>,

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

where PI: IntoIterator<Item = K>, SI: IntoIterator<Item = I>, F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<R, DriverError>>,

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

Learned mappings for the primary keys are removed automatically. Pass changed/new index keys as well so negative index entries cannot hide inserts or updates.

pub async fn insert_one<SI>( &self, primary_key: K, index_keys: SI, document: T, ) -> Result<InsertOneResult, DriverError>

where SI: IntoIterator<Item = I>, T: Serialize,

Inserts one document and invalidates any cached negative primary or secondary lookups.

pub async fn insert_many<PI, SI>( &self, primary_keys: PI, index_keys: SI, documents: Vec<T>, ) -> Result<InsertManyResult, DriverError>

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

Inserts documents in one native MongoDB operation and invalidates their cached keys.

pub async fn update_one<PI, SI>( &self, primary_keys: PI, index_keys: SI, filter: Document, update: Document, ) -> Result<UpdateResult, DriverError>

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

Updates one document and invalidates all affected primary and secondary cache entries.

pub async fn replace_one<PI, SI>( &self, primary_keys: PI, index_keys: SI, filter: Document, replacement: T, ) -> Result<UpdateResult, DriverError>

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

Replaces one document and invalidates all affected primary and secondary cache entries.

pub async fn delete_one<PI, SI>( &self, primary_keys: PI, index_keys: SI, filter: Document, ) -> Result<DeleteResult, DriverError>

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

Deletes one document and invalidates all affected primary and secondary cache entries.

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

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