Struct ExtensionCacheStore

Source

pub struct ExtensionCacheStore { /* private fields */ }

Expand description

Bounded type-erased cache storage owned by an extension executor.

Implementations§

Source §

impl ExtensionCacheStore

Source

pub fn new() -> Self

Create an empty cache store with default limits.

§Examples

use tenferro_runtime::ExtensionCacheStore;

let store = ExtensionCacheStore::new();
assert_eq!(store.len(), 0);

Source

pub fn with_limits(limits: ExtensionCacheLimits) -> Self

Create an empty cache store with explicit limits.

Source

pub const fn limits(&self) -> ExtensionCacheLimits

Return the active cache limits.

Source

pub fn set_limits(&mut self, limits: ExtensionCacheLimits)

Resize the store and evict least-recently-used entries if needed.

Source

pub fn len(&self) -> usize

Current entry count.

Source

pub fn is_empty(&self) -> bool

Return whether the store contains no entries.

Source

pub fn put<T>( &mut self, key: ExtensionCacheKey, value: T, retained_bytes: usize, )
where T: Any + Send + Sync + 'static,

Insert or replace a typed cache entry.

Source

pub fn put_with_retained_bytes<T, F>( &mut self, key: ExtensionCacheKey, value: T, retained_bytes: F, )
where T: Any + Send + Sync + 'static, F: Fn(&T) -> usize + Send + Sync + 'static,

Insert or replace a typed cache entry whose retained bytes are computed from the current value whenever stats are requested.

Use this for entries that mutate after insertion, such as compiled execution plans with backend-owned nested caches.

§Examples

use tenferro_runtime::{ExtensionCacheKey, ExtensionCacheStore, ExtensionCacheSelector};

let mut store = ExtensionCacheStore::new();
let key = ExtensionCacheKey::new("example.cache.v1", "plans", 0);
store.put_with_retained_bytes(key, Vec::<usize>::with_capacity(2), |values| {
    values.capacity().saturating_mul(std::mem::size_of::<usize>())
});
let values = store.get_mut::<Vec<usize>>(&key).unwrap();
values.reserve_exact(4);
let retained_capacity = values.capacity();

assert_eq!(
    store.stats(ExtensionCacheSelector::All).retained_bytes,
    retained_capacity * std::mem::size_of::<usize>()
);