Method insert

graphlite/src/cache/plan_cache.rs:181–226

Insert plan into cache

(
        &self,
        key: PlanCacheKey,
        logical_plan: LogicalPlan,
        physical_plan: PhysicalPlan,
        trace: Option<PlanTrace>,
        compilation_time: Duration,
    )

    /// Insert plan into cache
    pub fn insert(
        &self,
        key: PlanCacheKey,
        logical_plan: LogicalPlan,
        physical_plan: PhysicalPlan,
        trace: Option<PlanTrace>,
        compilation_time: Duration,
    ) {
        let estimated_cost = physical_plan.estimated_cost;
        let estimated_rows = physical_plan.estimated_rows;

        let entry = PlanCacheEntry {
            logical_plan,
            physical_plan,
            trace,
            compilation_time,
            estimated_cost,
            estimated_rows,
            metadata: CacheEntryMetadata::new(0, CacheLevel::L1).with_ttl(self.default_ttl),
            usage_count: 0,
            last_used: Instant::now(),
        };

        let size = entry.size_bytes();

        // Check if we need to evict entries
        self.evict_if_needed(size);

        // Insert entry
        {
            let mut entries = self.entries.write().unwrap();
            entries.insert(key, entry);
        }

        {
            let mut current_memory = self.current_memory.write().unwrap();
            *current_memory += size;
        }

        // Update stats
        {
            let mut stats = self.stats.write().unwrap();
            stats.current_entries = self.entries.read().unwrap().len();
            stats.current_memory_bytes = *self.current_memory.read().unwrap();
        }
    }

    fn evict_if_needed(&self, incoming_size: usize) {
        let current_memory = *self.current_memory.read().unwrap();