Struct QuickCacheBackend 

pub struct QuickCacheBackend { /* private fields */ }

Implementations

impl QuickCacheBackend

pub fn with_capacity(capacity: usize) -> Self

Create a backend holding up to capacity bytes of weighted entries (weight = key footprint + declared size), sharded per recommended_cache_shards.

pub fn with_shard_policy( capacity: usize, shard_policy: QuickCacheShardPolicy, ) -> Self

Create a weighted cache with an explicit shard policy.

capacity bounds the sum of key footprints and declared entry sizes. Each shard has an independent share of that bound. In addition, the default Quick admission policy rejects an unpinned entry heavier than approximately 97% of one shard’s share.

Example

use lance_core::cache::{QuickCacheBackend, QuickCacheShardPolicy};

let cache = QuickCacheBackend::with_shard_policy(
    8 << 30,
    QuickCacheShardPolicy::Single,
);

Trait Implementations

impl CacheBackend for QuickCacheBackend

fn peek_resident<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Membership checks only: priority stamps and quick_cache’s reference bits stay unchanged, so a probed entry is evicted as if never probed.

fn get_resident<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up RAM only, without reading or promoting a persistent entry. Backends without a resident lookup return a miss safely.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up an entry by its key.

fn insert<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, entry: CacheEntry, size_bytes: usize, codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store an entry. size_bytes is used for eviction accounting.

fn get_or_insert<'a, 'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, loader: Pin<Box<dyn Future<Output = Result<(CacheEntry, usize)>> + Send + 'a>>, codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Result<(CacheEntry, bool)>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an existing entry or compute it from loader.

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Remove all entries.

fn num_entries<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = usize> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Number of entries currently stored (may flush pending operations).

fn size_bytes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = usize> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Total weighted size in bytes of all stored entries (may flush pending operations).

fn capacity_bytes(&self) -> Option<usize>

Weighted capacity in bytes, or None when the backend has no fixed capacity or cannot report it. Lets callers skip loading entries that could never be retained.

fn approx_num_entries(&self) -> usize

Approximate number of entries, callable from synchronous contexts. Backends that cannot provide this cheaply should return 0.

fn approx_size_bytes(&self) -> usize

Approximate weighted size in bytes, callable from synchronous contexts. Used as a DeepSizeOf fallback when exact entry traversal is unavailable. Backends that cannot provide this cheaply should return 0.

fn deep_size_of_entries( &self, context: &mut Context, size_of_entry: &dyn Fn(&CacheEntry, &mut Context) -> Option<usize>, ) -> Option<usize>

Computes the size of the entries currently held in memory.

fn peek_tier<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, ) -> Pin<Box<dyn Future<Output = CacheTier> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Predict which tier would serve a read of key, without reading the entry or counting as an access, so the check changes neither what the backend evicts next nor its hit statistics. The default knows RAM only, through peek_resident, and reports every other entry as CacheTier::Absent; backends with a local tier below RAM override it.

fn plane_admission_gated(&self) -> bool

Whether layered index planes should gate lower-plane RAM admission on their sign plane being resident. Backends that admit plane entries through their ordinary policy return false, so lower planes are loaded and admitted like any other entry.

fn get_without_promotion<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read an entry without admitting a persistent hit into RAM. Backends without this capability safely fall back to resident entries.

fn get_rows<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _key: &'life1 InternalCacheKey, _rows: &'life2 [u32], _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gather selected rows from persistent storage, without RAM admission.

impl Debug for QuickCacheBackend

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

Formats the value using the given formatter.