duckdb::SegmentHandle Class Reference

Collaboration diagram for duckdb::SegmentHandle:

Public Member Functions
	SegmentHandle (FixedSizeBuffer &buffer_p, const idx_t offset)
	SegmentHandle (const SegmentHandle &)=delete
SegmentHandle &	operator= (const SegmentHandle &)=delete
	SegmentHandle (SegmentHandle &&other) noexcept
SegmentHandle &	operator= (SegmentHandle &&other) noexcept
template<class T >
const T &	GetRef () const
template<class T >
T &	GetRef ()
template<class T = data_t>
T *	GetPtr ()
template<class T = data_t>
const T *	GetPtr () const
void	MarkModified ()

Private Attributes
optional_ptr< FixedSizeBuffer >	buffer_ptr
data_ptr_t	ptr

Constructor & Destructor Documentation

SegmentHandle() [1/2]

duckdb::SegmentHandle::SegmentHandle ( FixedSizeBuffer &  buffer_p, const idx_t  offset  )

inline

                                                                 : buffer_ptr(buffer_p) {
        lock_guard<mutex> l(buffer_ptr->lock);
 
        if (!buffer_ptr->InMemory() && !buffer_ptr->loaded) {
            buffer_ptr->LoadFromDisk();
        }
        if (!buffer_ptr->InMemory() && buffer_ptr->loaded) {
            buffer_ptr->block_manager.buffer_manager.Pin(buffer_ptr->block_handle);
        }
 
        ptr = buffer_ptr->buffer_handle.Ptr() + offset;
        buffer_ptr->readers++;
    }

~SegmentHandle()

duckdb::SegmentHandle::~SegmentHandle ( )

inline

                     {
        if (!buffer_ptr) {
            return;
        }
        buffer_ptr->readers--;
        buffer_ptr = nullptr;
        ptr = nullptr;
 
        // FIXME: Enable unpinning buffers with zero readers while preventing oscillation.
        // FIXME: loaded must be set to true.
    }

SegmentHandle() [2/2]

duckdb::SegmentHandle::SegmentHandle ( SegmentHandle &&  other )

inlinenoexcept

                                                  : buffer_ptr(other.buffer_ptr), ptr(other.ptr) {
        other.buffer_ptr = nullptr;
        other.ptr = nullptr;
    }

Member Function Documentation

operator=()

SegmentHandle & duckdb::SegmentHandle::operator= ( SegmentHandle &&  other )

inlinenoexcept

                                                             {
        if (this != &other) {
            // Decrement reader count for existing handle if it exists
            if (buffer_ptr) {
                buffer_ptr->readers--;
            }
            buffer_ptr = other.buffer_ptr;
            ptr = other.ptr;
            other.buffer_ptr = nullptr;
            other.ptr = nullptr;
        }
        return *this;
    }

GetRef() [1/2]

template<class T >

const T & duckdb::SegmentHandle::GetRef ( ) const

inline

                            {
        return *reinterpret_cast<const T *>(ptr);
    }

GetRef() [2/2]

template<class T >

T & duckdb::SegmentHandle::GetRef ( )

inline

                {
        return *reinterpret_cast<T *>(ptr);
    }

GetPtr() [1/2]

template<class T = data_t>

T * duckdb::SegmentHandle::GetPtr ( )

inline

                {
        return reinterpret_cast<T *>(ptr);
    }

GetPtr() [2/2]

template<class T = data_t>

const T * duckdb::SegmentHandle::GetPtr ( ) const

inline

                            {
        return reinterpret_cast<T *>(ptr);
    }

MarkModified()

void duckdb::SegmentHandle::MarkModified ( )

inline

                        {
        lock_guard<mutex> l(buffer_ptr->lock);
        buffer_ptr->dirty = true;
    }

---

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

• external/duckdb/duckdb.cpp