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 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.

impl Debug for QuickCacheBackend

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

Formats the value using the given formatter.