Struct SqlQueryCache 

pub struct SqlQueryCache { /* private fields */ }

In-memory LRU cache of SQL query result sets.

Result sets are keyed by their normalised SQL text (leading/trailing whitespace collapsed, consecutive spaces reduced to a single space, ASCII letters upper-cased). Each entry stores a cloned RowSet; callers receive another clone on get so the cached copy is never mutated.

TTL

Insert with a TTL via SqlQueryCache::put_with_ttl. After the TTL elapses, get returns None and the stale entry is lazily removed.

Example

use oxisql_core::{Row, RowSet, Value};
use oxisql_cache::SqlQueryCache;

let mut cache = SqlQueryCache::new(256);
let rows = vec![Row::new(vec!["id".into()], vec![Value::I64(1)])];
let rs = RowSet::from_rows(rows);
cache.put("SELECT id FROM t WHERE id = 1", rs.clone());

// Equivalent queries (different whitespace/case) hit the same entry.
assert!(cache.get("select  id  from  t  where  id = 1").is_some());

Implementations

impl SqlQueryCache

pub fn new(capacity: usize) -> Self

Create a new cache with the given maximum entry count.

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

Look up a query result set by SQL text.

The query is normalised before lookup. Returns a clone of the cached RowSet on a hit, None on a miss or TTL expiry.

pub fn put(&mut self, sql: &str, result: RowSet)

Insert a query result set, replacing any existing entry for the same normalised SQL.

pub fn put_with_ttl(&mut self, sql: &str, result: RowSet, ttl: Duration)

Insert a query result set that expires after ttl.

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

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

pub fn clear(&mut self)

Remove all cached results.

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

Return true if the cache contains a live entry for sql.

pub fn len(&self) -> usize

Return the number of entries 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 entries.

pub fn stats(&self) -> QueryCacheStats

Return a stats snapshot.

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

Dynamically resize the cache capacity.

If new_cap is smaller than the current length, entries are evicted (LRU policy) until len() <= new_cap.