Struct ReadCache

pub(crate) struct ReadCache<C> {
    file_cache: Arc<C>,
    mem_cache: Cache<String, ReadResult>,
}

Local read cache for files in object storage

Fields

file_cache: Arc<C>

Local file cache backend

mem_cache: Cache<String, ReadResult>

Local memory cache to track local cache files

Implementations

impl<C: Access> ReadCache<C>

pub(crate) fn new(file_cache: Arc<C>, capacity: usize) -> Self

Create a ReadCache with capacity in bytes.

pub(crate) async fn cache_stat(&self) -> (u64, u64)

Returns the cache’s entry count and total approximate entry size in bytes.

pub(crate) fn invalidate_entries_with_prefix(&self, path: &str)

Invalidate all cache items belong to the specific path.

pub(crate) async fn recover_cache(&self) -> Result<(u64, u64)>

Recover existing cache items from file_cache to mem_cache. Return entry count and total approximate entry size in bytes.

pub(crate) async fn contains_file(&self, path: &str) -> bool

Returns true when the read cache contains the specific file.

pub(crate) async fn read_from_cache<I>( &self, inner: &I, path: &str, args: OpRead, ) -> Result<(RpRead, Reader)>

where I: Access,

Read from a specific path using the OpRead operation. It will attempt to retrieve the data from the local cache. If the data is not found in the local cache, it will fall back to retrieving it from remote object storage and cache the result locally.

async fn try_write_cache<I>( &self, reader: I::Reader, read_key: &str, ) -> Result<usize>

where I: Access,

async fn read_remote<I>( &self, inner: &I, read_key: &str, path: &str, args: OpRead, ) -> Result<ReadResult>

where I: Access,

Read the file from remote storage. If success, write the content into local cache.

Trait Implementations

impl<C> Clone for ReadCache<C>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for ReadCache<C>

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

Formats the value using the given formatter.