C++中Apache Arrow/Parquet高效读写及结构体映射技术问询

1. 高效读写Parquet数据 #

Apache Arrow的Parquet读写模块本身已做深度优化，要保障高效性，核心注意以下几点：

• 批量操作优先：避免单条数据读写，用Arrow的RecordBatch或数组批量处理，适配Parquet列存储特性，最大化IO和CPU利用率。
• 复用内存池：使用Arrow默认内存池管理内存分配，减少频繁申请释放的开销，大数据量场景下效果明显。
• 固定Schema读写：预定义Schema能跳过动态类型推断步骤，直接匹配数据格式，大幅提升读写速度，后续可通过自动生成机制维护Schema（见下文）。
• 匹配压缩策略：根据数据类型选合适的压缩算法，比如Snappy兼顾速度和压缩比，适合多数通用场景；GZIP压缩比更高但速度稍慢，适合冷数据存储。

2. 从C++结构体自动生成Schema #

可以通过编译期模板元编程或离线代码生成两种方式实现，避免手动维护Schema的耦合问题：

模板元编程方案（编译期自动生成） #

利用C模板特性，为结构体字段映射Arrow类型并生成Schema，适配C17及以上版本：

#include <arrow/schema.h>
#include <arrow/type.h>

// 基础类型到Arrow类型的映射模板
template<typename T>
struct ArrowTypeMapper;

template<>
struct ArrowTypeMapper<std::string> {
    static std::shared_ptr<arrow::DataType> Get() { return arrow::utf8(); }
};

template<>
struct ArrowTypeMapper<int> {
    static std::shared_ptr<arrow::DataType> Get() { return arrow::int32(); }
};

// Widget结构体的Schema生成器
template<>
struct SchemaGenerator<Widget> {
    static std::shared_ptr<arrow::Schema> Generate() {
        std::vector<std::shared_ptr<arrow::Field>> fields = {
            arrow::field("foo", ArrowTypeMapper<std::string>::Get()),
            arrow::field("bar", ArrowTypeMapper<std::string>::Get()),
            arrow::field("baz", ArrowTypeMapper<int>::Get())
        };
        return arrow::schema(fields);
    }
};

若需更通用的自动遍历结构体成员，可借助C++20反射特性或第三方库（如Boost.PFR）进一步封装，实现结构体修改后Schema自动同步。

离线代码生成方案 #

用脚本工具解析结构体头文件，自动生成Schema代码。比如用Python的pycparser解析C++头文件，提取Widget的字段名和类型，输出对应的Arrow Schema定义代码。每次结构体修改后重新运行脚本即可，完全解耦结构体定义与Schema代码。

3. 读取完整行并映射为结构体 #

通过批量列转行的方式实现高效转换，避免逐行遍历的低效问题：

#include <arrow/array.h>
#include <parquet/arrow/reader.h>
#include <vector>

std::vector<Widget> ReadParquetToWidgets(const std::string& file_path) {
    std::vector<Widget> widgets;

    // 初始化Parquet文件读取器
    std::shared_ptr<parquet::arrow::FileReader> reader;
    PARQUET_THROW_NOT_OK(parquet::arrow::OpenFile(file_path, arrow::default_memory_pool(), &reader));

    // 读取整个数据表
    std::shared_ptr<arrow::Table> table;
    PARQUET_THROW_NOT_OK(reader->ReadTable(&table));

    // 获取各列的批量数组
    auto foo_col = std::static_pointer_cast<arrow::StringArray>(table->column(0)->chunk(0));
    auto bar_col = std::static_pointer_cast<arrow::StringArray>(table->column(1)->chunk(0));
    auto baz_col = std::static_pointer_cast<arrow::Int32Array>(table->column(2)->chunk(0));

    // 批量转换为Widget结构体
    const int row_count = table->num_rows();
    widgets.reserve(row_count);
    for (int i = 0; i < row_count; ++i) {
        Widget w;
        w.foo = foo_col->GetString(i);
        w.bar = bar_col->GetString(i);
        w.baz = baz_col->Value(i);
        widgets.push_back(w);
    }

    // 处理多chunk场景（若文件分块存储）
    for (int chunk_idx = 1; chunk_idx < table->column(0)->num_chunks(); ++chunk_idx) {
        auto foo_chunk = std::static_pointer_cast<arrow::StringArray>(table->column(0)->chunk(chunk_idx));
        auto bar_chunk = std::static_pointer_cast<arrow::StringArray>(table->column(1)->chunk(chunk_idx));
        auto baz_chunk = std::static_pointer_cast<arrow::Int32Array>(table->column(2)->chunk(chunk_idx));
        
        const int chunk_rows = foo_chunk->length();
        for (int i = 0; i < chunk_rows; ++i) {
            Widget w;
            w.foo = foo_chunk->GetString(i);
            w.bar = bar_chunk->GetString(i);
            w.baz = baz_chunk->Value(i);
            widgets.push_back(w);
        }
    }

    return widgets;
}

这种方式直接操作列数组的原始数据，比转换为行式数据结构再遍历高效数倍。数值类型字段还可直接获取内存指针实现零拷贝，字符串类型因Arrow的存储特性无法完全零拷贝，但批量转换已是最优方案。

内容的提问来源于stack exchange，提问作者remo