duckdb::ArrowBuffer Struct Reference

Public Member Functions
	ArrowBuffer (const ArrowBuffer &other)=delete
ArrowBuffer &	operator= (const ArrowBuffer &)=delete
	ArrowBuffer (ArrowBuffer &&other) noexcept
	enable move constructors
ArrowBuffer &	operator= (ArrowBuffer &&other) noexcept
void	reserve (idx_t bytes)
void	resize (idx_t bytes)
void	resize (idx_t bytes, data_t value)
template<class T >
void	push_back (T value)
idx_t	size ()
data_ptr_t	data ()
template<class T >
T *	GetData ()

Static Public Attributes
static constexpr const idx_t	MINIMUM_SHRINK_SIZE = 4096

Private Member Functions
void	ReserveInternal (idx_t bytes)

Private Attributes
data_ptr_t	dataptr = nullptr
idx_t	count = 0
idx_t	capacity = 0

Constructor & Destructor Documentation

ArrowBuffer() [1/2]

duckdb::ArrowBuffer::ArrowBuffer ( )

inline

                  : dataptr(nullptr), count(0), capacity(0) {
    }

~ArrowBuffer()

duckdb::ArrowBuffer::~ArrowBuffer ( )

inline

                   {
        if (!dataptr) {
            return;
        }
        free(dataptr);
        dataptr = nullptr;
        count = 0;
        capacity = 0;
    }

ArrowBuffer() [2/2]

duckdb::ArrowBuffer::ArrowBuffer ( ArrowBuffer &&  other )

inlinenoexcept

enable move constructors

                                              : count(0), capacity(0) {
        std::swap(dataptr, other.dataptr);
        std::swap(count, other.count);
        std::swap(capacity, other.capacity);
    }

Member Function Documentation

operator=()

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

inlinenoexcept

                                                         {
        std::swap(dataptr, other.dataptr);
        std::swap(count, other.count);
        std::swap(capacity, other.capacity);
        return *this;
    }

reserve()

void duckdb::ArrowBuffer::reserve ( idx_t  bytes )

inline

                              { // NOLINT
        auto new_capacity = NextPowerOfTwo(bytes);
        if (new_capacity <= capacity) {
            return;
        }
        ReserveInternal(new_capacity);
    }

resize() [1/2]

void duckdb::ArrowBuffer::resize ( idx_t  bytes )

inline

                             { // NOLINT
        reserve(bytes);
        count = bytes;
    }

resize() [2/2]

void duckdb::ArrowBuffer::resize ( idx_t  bytes, data_t  value  )

inline

                                           { // NOLINT
        reserve(bytes);
        for (idx_t i = count; i < bytes; i++) {
            dataptr[i] = value;
        }
        count = bytes;
    }

push_back()

template<class T >

void duckdb::ArrowBuffer::push_back ( T  value )

inline

                            {
        reserve(sizeof(T) * (count + 1));
        reinterpret_cast<T *>(dataptr)[count] = value;
        count++;
    }

size()

idx_t duckdb::ArrowBuffer::size ( )

inline

                 { // NOLINT
        return count;
    }

data()

data_ptr_t duckdb::ArrowBuffer::data ( )

inline

                      { // NOLINT
        return dataptr;
    }

GetData()

template<class T >

T * duckdb::ArrowBuffer::GetData ( )

inline

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

ReserveInternal()

void duckdb::ArrowBuffer::ReserveInternal ( idx_t  bytes )

inlineprivate

                                      {
        data_ptr_t new_ptr;
        if (dataptr) {
            new_ptr = data_ptr_cast(realloc(dataptr, bytes));
        } else {
            new_ptr = data_ptr_cast(malloc(bytes));
        }
        if (!new_ptr) {
            throw OutOfMemoryException("ArrowBuffer: failed to allocate %llu bytes", bytes);
        }
        dataptr = new_ptr;
        capacity = bytes;
    }

---

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

• external/duckdb/duckdb.cpp