duckdb::buffer_handle_map_t Class Reference

Collaboration diagram for duckdb::buffer_handle_map_t:

Public Member Functions
pair< iterator, bool >	emplace (const uint32_t &id, BufferHandle &&handle)
iterator	erase (const iterator &it)
iterator	find (const uint32_t &id)
iterator	begin ()
iterator	end ()
void	clear ()
void	acquire_handles (vector< BufferHandle > &pins)

Private Types
using	iterator = unsafe_vector< pair< uint32_t, BufferHandle > >::iterator

Private Attributes
unsafe_vector< pair< uint32_t, BufferHandle > >	handles

Detailed Description

Instead of an unordered_map from uint32 -> BufferHandle, we have a vector. The lookup speed is OK since these maps should be very small. The benefit of this is that we aren't doing any other heap allocations than the one vector. For unordered_map, we would get a heap allocation for every inserted entry.

Constructor & Destructor Documentation

buffer_handle_map_t()

duckdb::buffer_handle_map_t::buffer_handle_map_t ( )

inline

                          {
    }

Member Function Documentation

emplace()

pair< iterator, bool > duckdb::buffer_handle_map_t::emplace ( const uint32_t &  id, BufferHandle &&  handle  )

inline

                                                                            {
        D_ASSERT(find(id) == end()); // Should have been checked by the caller
        handles.emplace_back(id, std::move(handle));
        return make_pair(--end(), true);
    }

erase()

iterator duckdb::buffer_handle_map_t::erase ( const iterator &  it )

inline

                                       {
        return handles.erase(it);
    }

find()

iterator duckdb::buffer_handle_map_t::find ( const uint32_t &  id )

inline

                                      {
        auto it = handles.begin();
        for (; it != handles.end(); it++) {
            if (it->first == id) {
                break;
            }
        }
        return it;
    }

begin()

iterator duckdb::buffer_handle_map_t::begin ( )

inline

                     {
        return handles.begin();
    }

end()

iterator duckdb::buffer_handle_map_t::end ( )

inline

                   {
        return handles.end();
    }

clear()

void duckdb::buffer_handle_map_t::clear ( )

inline

                 {
        handles.clear();
    }

acquire_handles()

void duckdb::buffer_handle_map_t::acquire_handles ( vector< BufferHandle > &  pins )

inline

                                                     {
        for (auto &handle : handles) {
            pins.emplace_back(std::move(handle.second));
        }
        handles.clear();
    }

---

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

• external/duckdb/duckdb.cpp