Function createStringArray

test/include/arrow_test_utils.h:203–268

Helper to create a string array from vector

// Helper to create a string array from vector
inline void createStringArray(ArrowArray* array, const std::vector<std::string>& data) {
    struct ArrayPrivateData {
        void* validity = nullptr;
        void* data = nullptr;
        int32_t* offsets = nullptr;
    };

    auto* private_data = new ArrayPrivateData();
    private_data->validity = nullptr; // No nulls

    // Calculate total string length
    int32_t total_length = 0;
    for (const auto& str : data) {
        total_length += str.length();
    }

    // Create offsets buffer (n+1 offsets for n strings)
    private_data->offsets = static_cast<int32_t*>(malloc((data.size() + 1) * sizeof(int32_t)));
    private_data->offsets[0] = 0;
    for (size_t i = 0; i < data.size(); i++) {
        private_data->offsets[i + 1] = private_data->offsets[i] + data[i].length();
    }

    // Create data buffer
    private_data->data = malloc(total_length);
    char* data_ptr = static_cast<char*>(private_data->data);
    for (const auto& str : data) {
        memcpy(data_ptr, str.data(), str.length());
        data_ptr += str.length();
    }

    array->length = data.size();
    array->null_count = 0;
    array->offset = 0;
    array->n_buffers = 3; // validity, offsets, and data
    array->n_children = 0;
    array->buffers = static_cast<const void**>(malloc(sizeof(void*) * 3));
    array->buffers[0] = nullptr; // validity buffer (no nulls)
    array->buffers[1] = private_data->offsets;
    array->buffers[2] = private_data->data;
    array->children = nullptr;
    array->dictionary = nullptr;
    array->release = [](ArrowArray* a) {
        if (a->private_data) {
            auto* pd = static_cast<ArrayPrivateData*>(a->private_data);
            free(pd->validity);
            free(pd->data);
            free(pd->offsets);
            delete pd;
        }
        if (a->buffers) {
            free(const_cast<void**>(a->buffers));
        }
        if (a->children) {
            for (int64_t i = 0; i < a->n_children; i++) {
                if (a->children[i]->release) {
                    a->children[i]->release(a->children[i]);
                }