Struct DbCache 

pub struct DbCache<C = PostcardCodec>
where
    C: CacheCodec,
{ /* private fields */ }

A database-oriented view over a HydraCache instance.

DbCache groups query result keys under a namespace while keeping all cache storage, single-flight, tags, TTL, and stats in the shared local cache.

Example

use std::time::Duration;

use hydracache::HydraCache;
use hydracache_db::DbCache;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct User {
    id: i64,
    name: String,
}

let local = HydraCache::local().build();
let queries = DbCache::new(local, "db");

let user = queries
    .cached::<User>()
    // Physical cache key: "db:user:42".
    .key("user:42")
    // Later, invalidate_tag("user:42") removes this result.
    .tag("user:42")
    .ttl(Duration::from_secs(60))
    .fetch_with(|| async {
        // Replace this block with code from sqlx, diesel, sea-orm, or any
        // other database client. It is called only when the cache does not
        // already contain "db:user:42" or when the cached value has expired.
        Ok::<_, std::io::Error>(User {
            id: 42,
            name: "Ada".to_owned(),
        })
    })
    .await?;

assert_eq!(user.id, 42);

Implementations

impl<C> DbCache<C>

where C: CacheCodec,

pub fn new(cache: HydraCache<C>, namespace: impl Into<String>) -> DbCache<C>

Create a database query cache adapter over an existing local cache.

pub fn namespace(&self) -> &str

Return the namespace used for physical cache keys.

pub fn cache(&self) -> &HydraCache<C>

Return the underlying local cache.

pub fn cached<T>(&self) -> DbQuery<T, C>

Start describing a cacheable database-loaded value.

This is the preferred entry point when the query is already visible inside the fetch_with loader through a database client, ORM, or repository method.

pub fn named<T>(&self, name: impl Into<String>) -> DbQuery<T, C>

Start describing a cacheable database-loaded value with a diagnostic name.

pub fn query_as<T>(&self, sql: impl Into<String>) -> DbQuery<T, C>

Start describing a cacheable SQL query result.

Prefer DbCache::cached or DbCache::named when writing new code. This method remains useful if you want the SQL text itself to be the diagnostic label for errors and logs.

Trait Implementations

impl<C> Clone for DbCache<C>

where C: Clone + CacheCodec,

fn clone(&self) -> DbCache<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for DbCache<C>

where C: Debug + CacheCodec,

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

Formats the value using the given formatter.