Struct MetadataCache

pub struct MetadataCache {
    pool: Pool<MySql>,
    cache: HashMap<String, String>,
}

Cache implementation for metadata to reduce database access.

This cache maintains an in-memory copy of metadata values to minimize database queries. It provides methods to get and set values, as well as to refresh the entire cache from the database.

Fields

• pool - Database connection pool for executing queries
• cache - In-memory hash map storing key-value pairs

Thread Safety

This struct is not thread-safe on its own and should either be used from a single thread or wrapped in a synchronization primitive like Arc<Mutex<MetadataCache>>.

Performance Considerations

The cache can significantly reduce database load for frequently accessed metadata values, but it can become stale if other processes modify the metadata table directly. Use refresh_cache periodically or after expected external changes.

Fields

pool: Pool<MySql>

Database connection pool for executing queries

cache: HashMap<String, String>

In-memory cache of metadata key-value pairs

Implementations

impl MetadataCache

pub fn new(pool: Pool<MySql>) -> Self

Creates a new metadata cache with an empty cache and the provided database pool.

Arguments

• pool - Database connection pool for executing queries

Returns

A new MetadataCache instance with an empty cache

pub async fn get(&mut self, key: &str) -> Result<String>

Retrieves a metadata value by its key, using the cache when possible.

This method first checks the in-memory cache for the requested key. If the key is not found in the cache, it queries the database and updates the cache with the result.

Arguments

• key - The unique key whose value to retrieve

Returns

• Ok(String) - Successfully retrieved the value for the key
• Err(anyhow::Error) - Failed to fetch the value or key doesn’t exist

Cache Behavior

This method:

• Returns cached values without querying the database when possible
• Automatically populates the cache with values fetched from the database
• Does not refresh existing cache entries (use refresh_cache for that)

pub async fn set(&mut self, key: &str, value: &str) -> Result<()>

Sets a metadata value for a specific key and updates the cache.

This method updates both the database and the in-memory cache with the new key-value pair. This ensures that subsequent get calls will return the updated value without requiring a database query.

Arguments

• key - The unique key to associate with the value
• value - The value to store

Returns

• Ok(()) - Successfully stored the key-value pair
• Err(anyhow::Error) - Failed to store the key-value pair

Error Handling

If the database update fails, the cache is not updated, ensuring consistency between the cache and the database.

pub async fn refresh_cache(&mut self) -> Result<()>

Refreshes the entire cache from the database.

This method clears the in-memory cache and reloads all metadata entries from the database. It’s useful when the cache might be stale due to external changes to the metadata table.

Returns

• Ok(()) - Successfully refreshed the cache
• Err(anyhow::Error) - Failed to refresh the cache

Use Cases

This method is particularly useful in scenarios such as:

• After application startup to prime the cache
• After scheduled maintenance that might have modified metadata
• When cache staleness is detected or suspected
• Periodically in long-running applications to ensure cache freshness