duckdb::ArrowEnumData< TGT > Struct Template Reference

Inheritance diagram for duckdb::ArrowEnumData< TGT >:

Collaboration diagram for duckdb::ArrowEnumData< TGT >:

Static Public Member Functions
static idx_t	GetLength (string_t input)
static void	WriteData (data_ptr_t target, string_t input)
static void	EnumAppendVector (ArrowAppendData &append_data, const Vector &input, idx_t size)
static void	Initialize (ArrowAppendData &result, const LogicalType &type, idx_t capacity)
static void	Finalize (ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result)
Static Public Member Functions inherited from duckdb::ArrowScalarBaseData< TGT, SRC, OP >
static void	Append (ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size)

Member Function Documentation

GetLength()

template<class TGT >

static idx_t duckdb::ArrowEnumData< TGT >::GetLength ( string_t  input )

inlinestatic

                                           {
        return input.GetSize();
    }

WriteData()

template<class TGT >

static void duckdb::ArrowEnumData< TGT >::WriteData ( data_ptr_t  target, string_t  input  )

inlinestatic

                                                             {
        memcpy(target, input.GetData(), input.GetSize());
    }

EnumAppendVector()

template<class TGT >

static void duckdb::ArrowEnumData< TGT >::EnumAppendVector ( ArrowAppendData &  append_data, const Vector &  input, idx_t  size  )

inlinestatic

                                                                                                {
        D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
        auto &main_buffer = append_data.GetMainBuffer();
        auto &aux_buffer = append_data.GetAuxBuffer();
        // resize the validity mask and set up the validity buffer for iteration
        ArrowAppendData::ResizeValidity(append_data.GetValidityBuffer(), append_data.row_count + size);
 
        // resize the offset buffer - the offset buffer holds the offsets into the child array
        main_buffer.resize(main_buffer.size() + sizeof(int32_t) * (size + 1));
        auto data = FlatVector::GetData<string_t>(input);
        auto offset_data = main_buffer.GetData<int32_t>();
        if (append_data.row_count == 0) {
            // first entry
            offset_data[0] = 0;
        }
        // now append the string data to the auxiliary buffer
        // the auxiliary buffer's length depends on the string lengths, so we resize as required
        auto last_offset = offset_data[append_data.row_count];
        for (idx_t i = 0; i < size; i++) {
            auto offset_idx = append_data.row_count + i + 1;
 
            auto string_length = GetLength(data[i]);
 
            // append the offset data
            auto current_offset = UnsafeNumericCast<idx_t>(last_offset) + string_length;
            offset_data[offset_idx] = UnsafeNumericCast<int32_t>(current_offset);
 
            // resize the string buffer if required, and write the string data
            aux_buffer.resize(current_offset);
            WriteData(aux_buffer.data() + last_offset, data[i]);
 
            last_offset = UnsafeNumericCast<int32_t>(current_offset);
        }
        append_data.row_count += size;
    }

Initialize()

template<class TGT >

static void duckdb::ArrowEnumData< TGT >::Initialize ( ArrowAppendData &  result, const LogicalType &  type, idx_t  capacity  )

inlinestatic

                                                                                             {
        result.GetMainBuffer().reserve(capacity * sizeof(TGT));
        // construct the enum child data
        auto enum_data = ArrowAppender::InitializeChild(LogicalType::VARCHAR, EnumType::GetSize(type), result.options);
        EnumAppendVector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
        result.child_data.push_back(std::move(enum_data));
    }

Finalize()

template<class TGT >

static void duckdb::ArrowEnumData< TGT >::Finalize ( ArrowAppendData &  append_data, const LogicalType &  type, ArrowArray *  result  )

inlinestatic

                                                                                                    {
        result->n_buffers = 2;
        result->buffers[1] = append_data.GetMainBuffer().data();
        // finalize the enum child data, and assign it to the dictionary
        result->dictionary = &append_data.dictionary;
        append_data.dictionary =
            *ArrowAppender::FinalizeChild(LogicalType::VARCHAR, std::move(append_data.child_data[0]));
    }

---

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

• external/duckdb/duckdb.cpp