duckdb::ArrowAppendData Struct Reference

Collaboration diagram for duckdb::ArrowAppendData:

Public Member Functions
	ArrowAppendData (const ClientProperties &options_p)
ArrowBuffer &	GetValidityBuffer ()
	Getters for the Buffers.
ArrowBuffer &	GetMainBuffer ()
ArrowBuffer &	GetAuxBuffer ()
ArrowBuffer &	GetBufferSizeBuffer ()
void	SetNull (uint8_t *validity_data, idx_t current_byte, uint8_t current_bit)
void	AppendValidity (UnifiedVectorFormat &format, idx_t from, idx_t to)

Static Public Member Functions
static void	GetBitPosition (idx_t row_idx, idx_t &current_byte, uint8_t &current_bit)
static void	UnsetBit (uint8_t *data, idx_t current_byte, uint8_t current_bit)
static void	NextBit (idx_t &current_byte, uint8_t &current_bit)
static void	ResizeValidity (ArrowBuffer &buffer, idx_t row_count)

Public Attributes
idx_t	row_count = 0
idx_t	null_count = 0
initialize_t	initialize = nullptr
	function pointers for construction
append_vector_t	append_vector = nullptr
shared_ptr< ArrowTypeExtensionData >	extension_data = nullptr
	Arrow Extension Type information.
finalize_t	finalize = nullptr
vector< unique_ptr< ArrowAppendData > >	child_data
	child data (if any)
unique_ptr< ArrowArray >	array
	the arrow array C API data, only set after Finalize
duckdb::array< const void *, 4 >	buffers = {{nullptr, nullptr, nullptr, nullptr}}
vector< ArrowArray * >	child_pointers
vector< ArrowArray >	child_arrays
	Arrays so the children can be moved.
ArrowArray	dictionary
ClientProperties	options
idx_t	offset = 0
	Offset used to keep data positions when producing a mix of inlined and not-inlined arrow string views.

Private Attributes
vector< ArrowBuffer >	arrow_buffers
	The buffers of the arrow vector.

Constructor & Destructor Documentation

ArrowAppendData()

duckdb::ArrowAppendData::ArrowAppendData ( const ClientProperties &  options_p )

inlineexplicit

                                                                : options(options_p) {
        dictionary.release = nullptr;
        arrow_buffers.resize(3);
    }

Member Function Documentation

GetValidityBuffer()

ArrowBuffer & duckdb::ArrowAppendData::GetValidityBuffer ( )

inline

Getters for the Buffers.

                                     {
        return arrow_buffers[0];
    }

GetMainBuffer()

ArrowBuffer & duckdb::ArrowAppendData::GetMainBuffer ( )

inline

                                 {
        return arrow_buffers[1];
    }

GetAuxBuffer()

ArrowBuffer & duckdb::ArrowAppendData::GetAuxBuffer ( )

inline

                                {
        return arrow_buffers[2];
    }

GetBufferSizeBuffer()

ArrowBuffer & duckdb::ArrowAppendData::GetBufferSizeBuffer ( )

inline

This is a special case, we resize it if necessary since it's a different size than set in the constructor

                                       {
        if (arrow_buffers.size() == 3) {
            arrow_buffers.resize(4);
        }
        return arrow_buffers[3];
    }

GetBitPosition()

static void duckdb::ArrowAppendData::GetBitPosition ( idx_t  row_idx, idx_t &  current_byte, uint8_t &  current_bit  )

inlinestatic

                                                                                         {
        current_byte = row_idx / 8;
        current_bit = row_idx % 8;
    }

UnsetBit()

static void duckdb::ArrowAppendData::UnsetBit ( uint8_t *  data, idx_t  current_byte, uint8_t  current_bit  )

inlinestatic

                                                                                 {
        data[current_byte] &= ~((uint64_t)1 << current_bit);
    }

NextBit()

static void duckdb::ArrowAppendData::NextBit ( idx_t &  current_byte, uint8_t &  current_bit  )

inlinestatic

                                                                   {
        current_bit++;
        if (current_bit == 8) {
            current_byte++;
            current_bit = 0;
        }
    }

ResizeValidity()

static void duckdb::ArrowAppendData::ResizeValidity ( ArrowBuffer &  buffer, idx_t  row_count  )

inlinestatic

                                                                     {
        auto byte_count = (row_count + 7) / 8;
        buffer.resize(byte_count, 0xFF);
    }

SetNull()

void duckdb::ArrowAppendData::SetNull ( uint8_t *  validity_data, idx_t  current_byte, uint8_t  current_bit  )

inline

                                                                                  {
        UnsetBit(validity_data, current_byte, current_bit);
        null_count++;
    }

AppendValidity()

void duckdb::ArrowAppendData::AppendValidity	(	UnifiedVectorFormat &	format,
		idx_t	from,
		idx_t	to
	)

                                                                                      {
    // resize the buffer, filling the validity buffer with all valid values
    idx_t size = to - from;
    ResizeValidity(GetValidityBuffer(), row_count + size);
    if (format.validity.AllValid()) {
        // if all values are valid we don't need to do anything else
        return;
    }
 
    // otherwise we iterate through the validity mask
    auto validity_data = (uint8_t *)GetValidityBuffer().data();
    uint8_t current_bit;
    idx_t current_byte;
    GetBitPosition(row_count, current_byte, current_bit);
    for (idx_t i = from; i < to; i++) {
        auto source_idx = format.sel->get_index(i);
        // append the validity mask
        if (!format.validity.RowIsValid(source_idx)) {
            SetNull(validity_data, current_byte, current_bit);
        }
        NextBit(current_byte, current_bit);
    }
}

Member Data Documentation

buffers

duckdb::array<const void *, 4> duckdb::ArrowAppendData::buffers = {{nullptr, nullptr, nullptr, nullptr}}

{{nullptr, nullptr, nullptr, nullptr}};

---

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

• external/duckdb/duckdb.cpp