duckdb::ObjectCache Class Reference

Collaboration diagram for duckdb::ObjectCache:

Public Member Functions
	ObjectCache (BufferPool &buffer_pool_p)
	ObjectCache (idx_t max_memory, BufferPool &buffer_pool_p)
shared_ptr< ObjectCacheEntry >	GetObject (const string &key)
template<class T >
shared_ptr< T >	Get (const string &key)
template<class T , class... ARGS>
shared_ptr< T >	GetOrCreate (const string &key, ARGS &&... args)
void	Put (string key, shared_ptr< ObjectCacheEntry > value)
void	Delete (const string &key)
idx_t	GetMaxMemory () const
idx_t	GetCurrentMemory () const
size_t	GetEntryCount () const
bool	IsEmpty () const
idx_t	EvictToReduceMemory (idx_t target_bytes)

Static Public Member Functions
static DUCKDB_API ObjectCache &	GetObjectCache (ClientContext &context)

Static Public Attributes
static constexpr idx_t	DEFAULT_MAX_MEMORY = 8ULL * 1024 * 1024 * 1024
	Default max memory 8GiB for non-evictable cache entries.

Private Attributes
mutex	lock_mutex
SharedLruCache< string, ObjectCacheEntry, duckdb::BufferPoolPayload >	lru_cache
	LRU cache for evictable entries.
unordered_map< string, shared_ptr< ObjectCacheEntry > >	non_evictable_entries
	Separate storage for non-evictable entries (i.e., encryption keys)
BufferPool &	buffer_pool
	Used to create buffer pool reservation on entries creation.

Constructor & Destructor Documentation

ObjectCache() [1/2]

duckdb::ObjectCache::ObjectCache ( BufferPool &  buffer_pool_p )

inlineexplicit

                                                    : ObjectCache(DEFAULT_MAX_MEMORY, buffer_pool_p) {
    }

ObjectCache() [2/2]

duckdb::ObjectCache::ObjectCache ( idx_t  max_memory, BufferPool &  buffer_pool_p  )

inline

                                                             : lru_cache(max_memory), buffer_pool(buffer_pool_p) {
    }

Member Function Documentation

GetObject()

shared_ptr< ObjectCacheEntry > duckdb::ObjectCache::GetObject ( const string &  key )

inline

                                                              {
        const lock_guard<mutex> lock(lock_mutex);
        auto non_evictable_it = non_evictable_entries.find(key);
        if (non_evictable_it != non_evictable_entries.end()) {
            return non_evictable_it->second;
        }
        return lru_cache.Get(key);
    }

Get()

template<class T >

shared_ptr< T > duckdb::ObjectCache::Get ( const string &  key )

inline

                                         {
        shared_ptr<ObjectCacheEntry> object = GetObject(key);
        if (!object || object->GetObjectType() != T::ObjectType()) {
            return nullptr;
        }
        return shared_ptr_cast<ObjectCacheEntry, T>(object);
    }

GetOrCreate()

template<class T , class... ARGS>

shared_ptr< T > duckdb::ObjectCache::GetOrCreate ( const string &  key, ARGS &&...  args  )

inline

                                                                  {
        const lock_guard<mutex> lock(lock_mutex);
 
        // Check non-evictable entries first
        auto non_evictable_it = non_evictable_entries.find(key);
        if (non_evictable_it != non_evictable_entries.end()) {
            auto &existing = non_evictable_it->second;
            if (existing->GetObjectType() != T::ObjectType()) {
                return nullptr;
            }
            return shared_ptr_cast<ObjectCacheEntry, T>(existing);
        }
 
        // Check evictable cache
        auto existing = lru_cache.Get(key);
        if (existing) {
            if (existing->GetObjectType() != T::ObjectType()) {
                return nullptr;
            }
            return shared_ptr_cast<ObjectCacheEntry, T>(existing);
        }
 
        // Create new entry while holding lock
        auto value = make_shared_ptr<T>(args...);
        const auto estimated_memory = value->GetEstimatedCacheMemory();
        const bool is_evictable = estimated_memory.IsValid();
        if (!is_evictable) {
            non_evictable_entries[key] = value;
            return value;
        }
 
        auto reservation =
            make_uniq<TempBufferPoolReservation>(MemoryTag::OBJECT_CACHE, buffer_pool, estimated_memory.GetIndex());
        lru_cache.Put(key, value, std::move(reservation));
        return value;
    }

Put()

void duckdb::ObjectCache::Put ( string  key, shared_ptr< ObjectCacheEntry >  value  )

inline

                                                             {
        if (!value) {
            return;
        }
 
        const lock_guard<mutex> lock(lock_mutex);
        const auto estimated_memory = value->GetEstimatedCacheMemory();
        const bool is_evictable = estimated_memory.IsValid();
        if (!is_evictable) {
            non_evictable_entries[std::move(key)] = std::move(value);
            return;
        }
 
        auto reservation =
            make_uniq<TempBufferPoolReservation>(MemoryTag::OBJECT_CACHE, buffer_pool, estimated_memory.GetIndex());
        lru_cache.Put(std::move(key), std::move(value), std::move(reservation));
    }

Delete()

void duckdb::ObjectCache::Delete ( const string &  key )

inline

                                   {
        const lock_guard<mutex> lock(lock_mutex);
        auto iter = non_evictable_entries.find(key);
        if (iter != non_evictable_entries.end()) {
            non_evictable_entries.erase(iter);
            return;
        }
        lru_cache.Delete(key);
    }

GetMaxMemory()

idx_t duckdb::ObjectCache::GetMaxMemory ( ) const

inline

                               {
        const lock_guard<mutex> lock(lock_mutex);
        return lru_cache.Capacity();
    }

GetCurrentMemory()

idx_t duckdb::ObjectCache::GetCurrentMemory ( ) const

inline

                                   {
        const lock_guard<mutex> lock(lock_mutex);
        return lru_cache.CurrentTotalWeight();
    }

GetEntryCount()

size_t duckdb::ObjectCache::GetEntryCount ( ) const

inline

                                 {
        const lock_guard<mutex> lock(lock_mutex);
        return lru_cache.Size() + non_evictable_entries.size();
    }

IsEmpty()

bool duckdb::ObjectCache::IsEmpty ( ) const

inline

                         {
        const lock_guard<mutex> lock(lock_mutex);
        return lru_cache.IsEmpty() && non_evictable_entries.empty();
    }

EvictToReduceMemory()

idx_t duckdb::ObjectCache::EvictToReduceMemory ( idx_t  target_bytes )

inline

                                                  {
        const lock_guard<mutex> lock(lock_mutex);
        return lru_cache.EvictToReduceAtLeast(target_bytes);
    }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp