Struct RiHybridCache 

pub struct RiHybridCache { /* private fields */ }

Hybrid cache combining in-memory and Redis cache for optimal performance Hybrid cache implementation combining memory and Redis backends.

This struct implements a two-level caching strategy that leverages both in-memory caching for speed and Redis for persistence and distributed caching.

Implementations

impl RiHybridCache

pub async fn new(redis_url: &str) -> RiResult<Self>

Creates a new hybrid cache instance.

Parameters

• redis_url: Redis connection URL (e.g., “redis://localhost:6379”)

Returns

A new instance of RiHybridCache

Trait Implementations

impl RiCache for RiHybridCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = RiResult<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets a value from the hybrid cache.

Follows a two-level lookup strategy:

1. First checks the in-memory cache for fast access
2. If not found, checks Redis
3. If found in Redis, caches the result in memory for future requests

Parameters

• key: Cache key to retrieve

Returns

Option<String> containing the value if the key exists in either cache, otherwise None

fn set<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 str, ttl_seconds: Option<u64>, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Sets a value in both caches.

Writes the value to both the in-memory cache and Redis simultaneously to ensure consistency across both cache levels.

Parameters

• key: Cache key to set
• value: Value to store in the cache
• ttl_seconds: Optional TTL in seconds

Returns

Ok(()) if the value was successfully set in both caches

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = RiResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes a value from both caches.

Removes the value from both the in-memory cache and Redis to ensure consistency across both cache levels.

Parameters

• key: Cache key to delete

Returns

Ok(bool) indicating whether the key was found in either cache

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Checks if a key exists in either cache.

First checks the in-memory cache, then Redis if not found.

Parameters

• key: Cache key to check

Returns

true if the key exists in either cache, otherwise false

fn keys<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RiResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all cache keys from both caches.

Returns keys from both the in-memory cache and Redis.

Returns

A RiResult<Vec<String>> containing all cache keys

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clears both caches.

Removes all entries from both the in-memory cache and Redis.

Returns

Ok(()) if both caches were successfully cleared

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RiCacheStats> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets combined statistics from both caches.

Aggregates statistics from both the in-memory cache and Redis, including total keys, memory usage, hit/miss counts, and eviction counts.

Returns

A RiCacheStats struct containing combined statistics from both caches

fn cleanup_expired<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RiResult<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleans up expired entries from both caches.

Removes expired entries from both the in-memory cache and Redis.

Returns

The total number of expired entries cleaned up from both caches

fn get_multi<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = RiResult<Vec<Option<String>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves multiple values from the cache in a single operation.

fn set_multi<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, items: &'life1 [(&'life2 str, &'life3 str)], ttl_seconds: Option<u64>, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Stores multiple key-value pairs in the cache.

fn delete_multi<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = RiResult<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes multiple keys from the cache.

fn exists_multi<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = RiResult<Vec<bool>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Checks if multiple keys exist in the cache.

fn delete_by_pattern<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 str, ) -> Pin<Box<dyn Future<Output = RiResult<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Removes all keys matching a regex pattern.