Struct RangeResultCache 

pub(crate) struct RangeResultCache {
    cache: SyncCache<RangeScanCacheKey, Arc<Entry>>,
    state: Mutex<State>,
    cleanup_tx: Sender<RangeCacheCleanup>,
    cleanup_rx: Mutex<Receiver<RangeCacheCleanup>>,
    retention_memory: Arc<RangeResultMemoryLimiter>,
    concat_memory: Arc<RangeResultMemoryLimiter>,
}

Stores completed range results and coordinates reader-owned shared scans.

Fields

cache: SyncCache<RangeScanCacheKey, Arc<Entry>>

state: Mutex<State>

cleanup_tx: Sender<RangeCacheCleanup>

Eviction callbacks and the last scan owner can run while state is locked. Queue their cleanup instead of reentering the coordinator lock.

cleanup_rx: Mutex<Receiver<RangeCacheCleanup>>

retention_memory: Arc<RangeResultMemoryLimiter>

Covers loads and completed deliveries, separately from cache residency and the temporary concat-memory limiter. Never wait for this budget.

concat_memory: Arc<RangeResultMemoryLimiter>

Bounds temporary allocations while compacting a completed result.

Implementations

impl RangeResultCache

pub(crate) async fn read<F, Fut>( self: &Arc<Self>, key: RangeScanCacheKey, part_metrics: Arc<dyn RangeCacheMetricsReport>, files: Vec<FileHandle>, scope: RangeCacheScope, build: F, ) -> Result<(BoxedRecordBatchStream, usize)>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<(BoxedRecordBatchStream, usize)>>,

Replays a cached result or subscribes to one reader-owned streaming scan.

pub(crate) fn new(capacity: u64) -> Arc<Self>

Creates independent retention and compaction budgets with the cache capacity.

async fn finish_scan( self: Arc<Self>, load: Arc<RangeLoad>, batches: Vec<CachedBatchSlice>, batch_size: usize, metrics: Arc<dyn RangeCacheMetricsReport>, )

Compacts a completed scan, then publishes it under the retirement fence.

fn drain_cleanup(&self, state: &mut State)

fn get_for_delivery(&self, key: &RangeScanCacheKey) -> Option<RangeCacheLookup>

fn publish( &self, state: &mut State, key: RangeScanCacheKey, value: Arc<RangeScanCacheValue>, )

pub(crate) fn invalidate_file(&self, file: FileId)

Called at logical retirement, before the last snapshot releases the SST. Existing readers may finish, but their results must not refill this cache.

fn get_or_register( self: &Arc<Self>, key: RangeScanCacheKey, files: Vec<FileHandle>, scope: RangeCacheScope, ) -> RangeCacheLookup

Looks up a retained result or registers one reader-owned streaming scan.

fn complete(&self, load: &RangeLoad, value: Arc<RangeScanCacheValue>) -> bool

Publishes only the current, successful scan of live files. Existing readers may still finish an invalidated scan, but it cannot refill the cache.