Struct SqlPlanCache 

pub struct SqlPlanCache<P> { /* private fields */ }

In-memory LRU cache of prepared SQL statement plans.

P is the caller-supplied plan representation — typically a compiled query plan, a byte buffer, or a Box<dyn Any>. The cache is generic so it can accommodate any backend’s plan type without imposing a common trait.

Plans are never expired by TTL (they are considered stable for the lifetime of a connection). TTL can be added via SqlPlanCache::put_with_ttl when plans have limited validity (e.g. after schema changes).

Keys are normalised SQL text (same rules as SqlQueryCache).

Example

use oxisql_cache::SqlPlanCache;

// Use Vec<u8> as a stand-in for a serialised plan.
let mut plan_cache: SqlPlanCache<Vec<u8>> = SqlPlanCache::new(512);
plan_cache.put("SELECT 1", vec![0x01, 0x02]);
assert!(plan_cache.get("select  1").is_some());

Implementations

impl<P: Clone> SqlPlanCache<P>

pub fn new(capacity: usize) -> Self

Create a new plan cache with the given maximum entry count.

pub fn get(&mut self, sql: &str) -> Option<&P>

Look up a plan by SQL text.

Returns a reference to the cached plan on a hit, None on a miss.

pub fn put(&mut self, sql: &str, plan: P)

Store a plan for sql.

pub fn put_with_ttl(&mut self, sql: &str, plan: P, ttl: Duration)

Store a plan for sql that expires after ttl.

pub fn invalidate(&mut self, sql: &str) -> Option<P>

Remove the cached plan for sql, returning it if present.

pub fn clear(&mut self)

Remove all cached plans.

pub fn contains(&mut self, sql: &str) -> bool

Return true if a live plan is cached for sql.

pub fn len(&self) -> usize

Return the number of plans currently in the cache.

pub fn is_empty(&self) -> bool

Return true if the cache is empty.

pub fn cap(&self) -> usize

Return the maximum number of plans.

pub fn hits(&self) -> u64

Return the number of cache hits since creation.

pub fn misses(&self) -> u64

Return the number of cache misses since creation.

pub fn hit_rate(&self) -> f64

Return the hit rate as a fraction in [0.0, 1.0].

pub fn resize(&mut self, new_cap: usize)

Dynamically resize the cache.