文件格式#
CSV 读取器#
-
struct ConvertOptions#
-
公共成员
-
bool check_utf8 = true#
是否检查字符串列的 UTF8 有效性。
-
std::vector<std::string> null_values#
用于标识空值的字符串表示。
-
std::vector<std::string> true_values#
用于标识布尔值 true 的字符串表示。
-
std::vector<std::string> false_values#
用于标识布尔值 false 的字符串表示。
-
bool strings_can_be_null = false#
字符串/二进制列是否可以包含空值。
如果为 true，则在字符串列中，“null_values”中的字符串将被视为 null。如果为 false，则所有字符串均为有效的字符串值。
-
bool quoted_strings_can_be_null = true#
带引号的值是否可以为空。
如果为 true，则“null_values”中的字符串在 CSV 文件中以引号出现时也被视为 null。否则，带引号的值永远不会被视为 null。
-
bool auto_dict_encode = false#
是否尝试自动对字符串/二进制数据进行字典编码。
如果为 true，则当类型推断检测到字符串或二进制列时，它会进行字典编码，直到达到
auto_dict_max_cardinality个不同值（每个块），之后它将切换为常规编码。此设置对于非推断列（在
column_types中定义的列）将被忽略。
-
char decimal_point = '.'#
用于浮点数和十进制数据的小数点字符。
-
std::vector<std::string> include_columns#
如果不为空，则表示需要实际读取和转换的 CSV 文件列名（按向量中的顺序）。
不在此向量中的列将被忽略。
-
bool include_missing_columns = false#
如果为 false，则存在于
include_columns但不在 CSV 文件中的列将导致错误。如果为 true，则存在于
include_columns但不在 CSV 文件中的列将生成空值列（其类型使用column_types选择，否则默认为 null）。如果include_columns为空，则此选项将被忽略。
-
std::vector<std::shared_ptr<TimestampParser>> timestamp_parsers#
用户定义的时间戳解析器，使用 arrow/util/value_parsing.h 中的虚拟解析器接口。
可以指定多个解析器，CSV 转换逻辑将尝试从该向量的开头解析值。如果没有指定解析器，将使用默认的内置 ISO-8601 解析器。
公共静态函数
-
static ConvertOptions Defaults()#
创建具有默认值的转换选项，包括
null_values、true_values和false_values的常规值。
-
bool check_utf8 = true#
-
struct ParseOptions#
-
公共成员
-
bool quoting = true#
是否使用引用。
-
char quote_char = '"'#
引用字符（如果
quoting为 true）
-
bool double_quote = true#
值内部的引号是否被双重引用。
-
bool escaping = false#
是否使用转义。
-
char escape_char = kDefaultEscapeChar#
转义字符（如果
escaping为 true）
-
bool newlines_in_values = false#
值中是否允许包含 CR (0x0d) 和 LF (0x0a) 字符。
-
bool ignore_empty_lines = true#
是否忽略空行。
如果为 false，则空行表示单个空值（假设是单列 CSV 文件）。
-
InvalidRowHandler invalid_row_handler#
用于处理列数不正确的行的处理程序函数。
公共静态函数
-
static ParseOptions Defaults()#
创建具有默认值的解析选项。
-
bool quoting = true#
-
struct ReadOptions#
-
公共成员
-
bool use_threads = true#
是否使用全局 CPU 线程池。
-
int32_t block_size = 1 << 20#
从 IO 层请求的块大小。
这将决定多线程的粒度以及单个记录批次的大小。块大小的最小有效值为 1。
-
int32_t skip_rows = 0#
要跳过的标题行数（不包括列名行（如有））。
-
int32_t skip_rows_after_names = 0#
读取列名后要跳过的行数（如有）。
-
std::vector<std::string> column_names#
目标表的列名。
如果为空，则回退到 autogenerate_column_names。
-
bool autogenerate_column_names = false#
如果
column_names为空，是否自动生成列名。如果为 true，列名将采用“f0”、“f1”等格式。如果为 false，列名将从
skip_rows之后的第一行 CSV 数据中读取。
公共静态函数
-
static ReadOptions Defaults()#
创建具有默认值的读取选项。
-
bool use_threads = true#
-
class TableReader#
将整个 CSV 文件读取为 Arrow Table 的类。
公共函数
公共静态函数
创建 TableReader 实例。
-
class StreamingReader : public arrow::RecordBatchReader#
增量读取 CSV 文件的类。
注意事项
目前，它是单线程的（无论
ReadOptions::use_threads如何设置）。类型推断在第一个块上进行，之后类型将被冻结；为确保推断出正确的数据类型，请将
ReadOptions::block_size设置为足够大的值，或使用ConvertOptions::column_types显式设置所需的数据类型。
公共函数
-
virtual int64_t bytes_read() const = 0#
返回已读取和处理的字节数。
返回的数字包括 StreamingReader 已完成处理的 CSV 字节，但不包括仍在处理中的字节（例如 CSV 解析或转换为 Arrow 布局）。
此外，适用以下规则：
由
ReadOptions.skip_rows跳过的字节在返回任何记录之前被计算为已读取。解析标题时读取的字节在返回任何记录之前被计算为已读取。
由
ReadOptions.skip_rows_after_names跳过的字节在第一个批次返回后计算。
公共静态函数
创建 StreamingReader 实例。
这涉及一些 I/O 操作，因为第一个批次必须在创建过程中加载，因此它作为 Future 返回。
目前，StreamingReader 不具备异步可重入性，并且不进行任何扇出解析（请参阅 ARROW-11889）。
CSV 写入器#
-
struct WriteOptions#
-
公共成员
-
bool include_header = true#
是否写入包含列名的初始标题行。
-
int32_t batch_size = 1024#
一次处理的最大行数。
CSV 写入器以 N 行的批次转换和写入数据。此数字可能会影响性能。
-
std::string null_string#
用于写入空值的字符串。此字符串中不允许出现引号。
-
io::IOContext io_context#
写入的 IO 上下文。
-
std::string eol = "\n"#
用于结束行的行尾字符。
-
QuotingStyle quoting_style = QuotingStyle::Needed#
引用样式。
-
QuotingStyle quoting_header = QuotingStyle::Needed#
标题的引用样式。
请注意，
QuotingStyle::Needed和QuotingStyle::AllValid在引用所有列名时具有相同的效果。
公共静态函数
-
static WriteOptions Defaults()#
创建具有默认值的写入选项。
-
bool include_header = true#
-
Status WriteCSV(const Table &table, const WriteOptions &options, arrow::io::OutputStream *output)#
将表转换为 CSV 并将结果写入输出流。
实验性
-
Status WriteCSV(const RecordBatch &batch, const WriteOptions &options, arrow::io::OutputStream *output)#
将批次转换为 CSV 并将结果写入输出流。
实验性
将通过 RecordBatchReader 读取的批次转换为 CSV 并将结果写入输出流。
实验性
创建一个新的 CSV 写入器。
用户需负责关闭实际的 OutputStream。
- 参数:
sink – [in] 要写入的输出流
schema – [in] 要写入的记录批次的模式 (schema)
options – [in] 序列化选项
- 返回：
Result<std::shared_ptr<RecordBatchWriter>>
创建一个新的 CSV 写入器。
- 参数:
sink – [in] 要写入的输出流（不取得所有权）
schema – [in] 要写入的记录批次的模式 (schema)
options – [in] 序列化选项
- 返回：
Result<std::shared_ptr<RecordBatchWriter>>
行分隔 JSON#
-
enum class arrow::json::UnexpectedFieldBehavior : char#
值
-
enumerator Ignore#
忽略意外的 JSON 字段。
-
enumerator Error#
遇到意外的 JSON 字段时报错。
-
enumerator InferType#
对意外的 JSON 字段进行类型推断并包含在输出中。
-
enumerator Ignore#
-
struct ReadOptions#
公共成员
-
bool use_threads = true#
是否使用全局 CPU 线程池。
-
int32_t block_size = 1 << 20#
从 IO 层请求的块大小；当 use_threads 为 true 时，它也决定了块的大小。
公共静态函数
-
static ReadOptions Defaults()#
创建具有默认值的读取选项。
-
bool use_threads = true#
-
struct ParseOptions#
公共成员
-
bool newlines_in_values = false#
对象是否可以跨多行打印（例如格式化打印）
如果为 true，解析可能会更慢。
-
UnexpectedFieldBehavior unexpected_field_behavior = UnexpectedFieldBehavior::InferType#
如何处理显式模式（如果提供）之外的 JSON 字段。
公共静态函数
-
static ParseOptions Defaults()#
创建具有默认值的解析选项。
-
bool newlines_in_values = false#
-
class TableReader#
将整个 JSON 文件读取为 Arrow Table 的类。
文件预期由单独的行分隔的 JSON 对象组成。
公共静态函数
创建 TableReader 实例。
-
class StreamingReader : public arrow::RecordBatchReader#
增量读取 JSON 文件的类。
JSON 数据以固定大小的块从流中读取（可通过
ReadOptions::block_size配置）。每个块被转换为一个RecordBatch。生成的批次具有一致的模式，但行数可能不同。提供的
ParseOptions用于确定模式，基于提供的显式模式或从第一个非空块中推断出来。之后，目标模式被冻结。如果指定了UnexpectedFieldBehavior::InferType，则仅会对第一个块中的意外字段进行推断。之后，它们将被视为错误。如果
ReadOptions::use_threads 为true，则每个块的解析/解码任务将在给定的cpu_executor上并行化（预取与执行程序的容量对应）。如果未提供执行程序，将使用全局线程池。如果
ReadOptions::use_threads为false，则计算将在调用线程上运行，并且cpu_executor将被忽略。公共函数
-
virtual Future<std::shared_ptr<RecordBatch>> ReadNextAsync() = 0#
异步读取下一个
RecordBatch。此函数是异步可重入的（但不是同步可重入的）。然而，如果禁用了线程，此函数将阻塞直到完成。
-
virtual int64_t bytes_processed() const = 0#
获取已成功转换为记录批次并被消费的字节数。
公共静态函数
通过
InputStream创建一个StreamingReader。在加载初始批次前会发生阻塞。- 参数:
stream – [in] JSON 源流
read_options – [in] 读取选项
parse_options – [in] 分块、解析和转换选项
io_context – [in] IO 操作上下文（可选）
cpu_executor – [in] 计算任务执行器（可选）
- 返回：
已初始化的读取器
通过
InputStream异步创建StreamingReader。返回的 future 将在加载第一个批次后完成。- 参数:
stream – [in] JSON 源流
read_options – [in] 读取选项
parse_options – [in] 分块、解析和转换选项
io_context – [in] IO 操作上下文（可选）
cpu_executor – [in] 计算任务执行器（可选）
- 返回：
用于已初始化读取器的
Future
-
virtual Future<std::shared_ptr<RecordBatch>> ReadNextAsync() = 0#
Parquet 读取器#
-
class ReaderProperties#
公共函数
-
inline bool is_buffered_stream_enabled() const#
缓冲流读取允许用户控制 Parquet 读取器的内存使用。
这确保了所有
RandomAccessFile::ReadAt调用都被封装在一个缓冲读取器中，该读取器使用固定大小的缓冲区（大小为buffer_size()），而不是使用完整的 ReadAt 大小。这种控制旋钮的主要原因是用于资源控制，而非性能考虑。
-
inline void enable_buffered_stream()#
启用缓冲流读取。
-
inline void disable_buffered_stream()#
禁用缓冲流读取。
-
inline int64_t buffer_size() const#
返回缓冲流缓冲区的大小。
-
inline void set_buffer_size(int64_t size)#
设置缓冲流缓冲区的大小（以字节为单位）。
-
inline int32_t thrift_string_size_limit() const#
返回 Thrift 字符串的大小限制。
此限制有助于防止文件中的空间和时间炸弹，但在读取具有特别大文件头的文档时可能需要增加此限制。
-
inline void set_thrift_string_size_limit(int32_t size)#
设置 Thrift 字符串的大小限制。
-
inline int32_t thrift_container_size_limit() const#
返回 Thrift 容器的大小限制。
此限制有助于防止文件中的空间和时间炸弹，但在读取具有特别大文件头的文档时可能需要增加此限制。
-
inline void set_thrift_container_size_limit(int32_t size)#
设置 Thrift 容器的大小限制。
设置解密属性。
-
inline const std::shared_ptr<FileDecryptionProperties> &file_decryption_properties() const#
返回解密属性。
-
inline bool is_buffered_stream_enabled() const#
-
class ArrowReaderProperties#
实验性功能：用于配置 FileReader 行为的属性。
公共函数
-
inline void set_use_threads(bool use_threads)#
设置是否使用 IO 线程池来并行解析列。
默认为 false。
-
inline bool use_threads() const#
返回是否将使用多线程。
-
inline void set_read_dictionary(int column_index, bool read_dict)#
设置是否以字典编码方式读取特定列。
如果文件元数据包含序列化的 Arrow 模式，则……
这仅支持 Parquet 物理类型为 BYTE_ARRAY 的列，例如字符串或二进制类型。
-
inline bool read_dictionary(int column_index) const#
返回指定索引处的列是否将作为字典读取。
-
inline void set_binary_type(::arrow::Type::type value)#
设置读取 BYTE_ARRAY 列时使用的 Arrow 二进制类型。
允许的值为 Type::BINARY、Type::LARGE_BINARY 和 Type::BINARY_VIEW。默认值为 Type::BINARY。
如果 BYTE_ARRAY 列具有 STRING 逻辑类型，它将作为与配置的二进制类型相对应的 Arrow 字符串类型进行读取（例如，如果配置的二进制类型是 Type::LARGE_BINARY，则读取为 Type::LARGE_STRING）。
然而，如果在 Parquet 元数据中找到了序列化的 Arrow 模式，此设置将被忽略，Arrow 模式将具有优先权（请参阅 ArrowWriterProperties::store_schema）。
-
inline void set_list_type(::arrow::Type::type value)#
设置读取 Parquet 列表列时使用的 Arrow 列表类型。
允许的值为 Type::LIST 和 Type::LARGE_LIST。默认值为 Type::LIST。
然而，如果在 Parquet 元数据中找到了序列化的 Arrow 模式，此设置将被忽略，Arrow 模式将具有优先权（请参阅 ArrowWriterProperties::store_schema）。
-
inline void set_batch_size(int64_t batch_size)#
设置读取到单个记录批次中的最大行数。
只有在文件中没有更多行时，读取的行数才会少于此值。请注意，某些 API（如 ReadTable）可能会忽略此设置。
-
inline int64_t batch_size() const#
返回批次大小（以行为单位）。
请注意，某些 API（如 ReadTable）可能会忽略此设置。
-
inline void set_pre_buffer(bool pre_buffer)#
启用读取合并（默认 false）。
启用后，Arrow 读取器将把必要的文件区域预先缓冲到内存中。这旨在提高在高延迟文件系统（如 Amazon S3）上的读取性能。
-
inline bool pre_buffer() const#
返回是否启用了读取合并。
-
inline void set_cache_options(::arrow::io::CacheOptions options)#
设置读取合并选项。
这可用于根据不同文件系统的特性来调整实现。
-
inline const ::arrow::io::CacheOptions &cache_options() const#
返回读取合并的选项。
-
inline void set_io_context(const ::arrow::io::IOContext &ctx)#
设置读取合并的执行上下文。
-
inline const ::arrow::io::IOContext &io_context() const#
返回用于读取合并的执行上下文。
-
inline void set_coerce_int96_timestamp_unit(::arrow::TimeUnit::type unit)#
设置用于已弃用的 INT96 编码时间戳的时间戳单位（默认为 NANO）。
-
inline void set_arrow_extensions_enabled(bool extensions_enabled)#
启用 Parquet 支持的 Arrow 扩展类型。
启用后，Parquet 逻辑类型将在读取时映射到其对应的 Arrow 扩展类型（如果存在）。目前仅支持
arrow::extension::json()扩展类型。LogicalType 为 JSON 的列将被解释为arrow::extension::json()，其存储类型将根据序列化的 Arrow 模式（如果存在）推断，否则默认为utf8。
-
inline void set_should_load_statistics(bool should_load_statistics)#
设置是否尽可能多地加载统计信息。
默认为 false。
-
inline bool should_load_statistics() const#
返回是否正在尽可能多地加载统计信息。
-
inline void set_smallest_decimal_enabled(bool smallest_decimal_enable)#
设置是否从 Parquet 十进制逻辑类型推断 Decimal32/64。
为了兼容性，默认值为 false，这意味着仅能推断出 Decimal128 和 Decimal256。
-
inline bool smallest_decimal_enabled() const#
是否从 Parquet 十进制逻辑类型推断 Decimal32/64。
启用后，Parquet 十进制列将被推断为尽可能小的 Arrow 十进制类型。禁用时，Parquet 十进制列将被推断为 Decimal128 或 Decimal256，而不会是 Decimal32/64。
注意：如果 Parquet 元数据中存在 Arrow 模式，它将具有优先级，此设置将被忽略。
-
inline void set_use_threads(bool use_threads)#
-
class ParquetFileReader#
公共函数
-
std::shared_ptr<PageIndexReader> GetPageIndexReader()#
返回 PageIndexReader。
只会创建一个实例。
如果文件没有页面索引，可能会返回 nullptr。由于检查文件是否存在页面索引需要成本，即使页面索引不存在，也有可能返回非空值。调用者有责任检查返回值并进行后续的 PageIndexReader 调用。
警告：返回的 PageIndexReader 的生命周期不得超过 ParquetFileReader。初始化 GetPageIndexReader() 不是线程安全的。
-
BloomFilterReader &GetBloomFilterReader()#
返回 BloomFilterReader。
只会创建一个实例。
警告：返回的 BloomFilterReader 的生命周期不得超过 ParquetFileReader。初始化 GetBloomFilterReader() 不是线程安全的。
-
void PreBuffer(const std::vector<int> &row_groups, const std::vector<int> &column_indices, const ::arrow::io::IOContext &ctx, const ::arrow::io::CacheOptions &options)#
预先缓冲所有行组中指定的列索引。
读取器可以选择调用此方法，以便在反序列化之前将必要的文件切片缓存到内存中。Arrow 读取器可以通过选项自动执行此操作。这旨在提高从高延迟文件系统（如 Amazon S3）读取时的性能。
调用此方法后，为未缓冲的行组/列索引创建读取器可能会失败。为缓冲区域的子集创建多个读取器是可以的。可以再次调用此方法以缓冲另一组行组/列。
如果内存使用是一个问题，请注意数据将保留在内存中，直到再次调用 PreBuffer() 或者读取器本身被销毁。一次只读取和缓冲一个行组可能很有用。
此方法可能会抛出异常。
-
::arrow::Result<std::vector<::arrow::io::ReadRange>> GetReadRanges(const std::vector<int> &row_groups, const std::vector<int> &column_indices, int64_t hole_size_limit = 1024 * 1024, int64_t range_size_limit = 64 * 1024 * 1024)#
检索为获取指定行组和列索引的数据而需要读取的字节范围列表。
如果读取器希望处理自己的缓存和文件读取管理（或将其卸载到其他读取器），可以选择调用此方法。与 PreBuffer() 不同，此方法不会执行任何实际的缓存或读取操作，而是仅使用文件元数据来确定如果消耗指定行组中提供的列的全部列块，则需要读取哪些字节范围。
如果 row_groups 或 column_indices 为空，则结果也将为空。
hole_size_limit 表示两个连续范围之间的最大距离（以字节为单位）；超过此值，范围将不会合并。默认值为 1MB。
range_size_limit 是合并后范围的最大大小（以字节为单位）；如果合并两个连续范围会产生比这更大的范围，则它们不会合并。默认值为 64MB。此值必须大于 hole_size_limit。
这不会考虑页面索引或可能可用的任何其他谓词下推优势。
-
struct Contents#
-
std::shared_ptr<PageIndexReader> GetPageIndexReader()#
-
class FileReader#
用于将 Parquet 文件反序列化为 Arrow 行批次的 Arrow 读取适配器类。
此接口迎合了不同的用例，因此提供了不同的接口。在其最简单的形式中，我们满足希望使用
FileReader::ReadTable方法一次读取整个 Parquet 文件的用户。更高级的用户如果还想在每个单个 Parquet 文件之上实现并行性，应在行组 (RowGroup) 级别进行。为此，他们可以调用
FileReader::RowGroup(i)->ReadTable以仅将指定的行组接收为表格。在最复杂的情况下，消费者希望独立地并行读取行组并单独消费每一列，他们可以调用
FileReader::RowGroup(i)->Column(j)->Read并接收一个arrow::Column实例。最后，还可以使用
FileReader::GetRecordBatchReader()获取记录批次流。如果已在 ArrowReaderProperties 中启用了use_threads，则可以在内部并行解码列。Parquet 格式支持一个可选的整数
field_id，可以将其分配给字段。Arrow 会将这些字段 ID 转换为相应字段上名为PARQUET:field_id的元数据键。公共函数
-
::arrow::Result<std::unique_ptr<FileReader>> Make(::arrow::MemoryPool *pool, std::unique_ptr<ParquetFileReader> reader, const ArrowReaderProperties &properties)#
用于从 ParquetFileReader 和属性创建 FileReader 的工厂函数。
-
::arrow::Result<std::unique_ptr<FileReader>> Make(::arrow::MemoryPool *pool, std::unique_ptr<ParquetFileReader> reader)#
用于从 ParquetFileReader 创建 FileReader 的工厂函数。
返回所有列的 Arrow 模式。
将整列读取为分块数组 (ChunkedArray)。
索引 i 指的是顶层模式字段的索引，该字段可能是嵌套的或平铺的 - 例如
0 foo.bar foo.bar.baz foo.qux 1 foo2 2 foo3
i=0 将读取整个 foo 结构体，i=1 将读取 foo2 原始列等
-
virtual ::arrow::Result<std::unique_ptr<::arrow::RecordBatchReader>> GetRecordBatchReader() = 0#
返回所有行组和列的 RecordBatchReader。
-
virtual ::arrow::Result<std::unique_ptr<::arrow::RecordBatchReader>> GetRecordBatchReader(const std::vector<int> &row_group_indices) = 0#
返回从 row_group_indices 中选择的行组的 RecordBatchReader。
请注意，row_group_indices 中的顺序很重要。FileReaders 的生命周期必须长于其 RecordBatchReaders。
- 返回：
如果 row_group_indices 包含无效索引，则返回错误 Result
-
virtual ::arrow::Result<std::unique_ptr<::arrow::RecordBatchReader>> GetRecordBatchReader(const std::vector<int> &row_group_indices, const std::vector<int> &column_indices) = 0#
返回从 row_group_indices 中选择的行组的 RecordBatchReader，其列由 column_indices 选择。
请注意，row_group_indices 和 column_indices 中的顺序很重要。FileReaders 的生命周期必须长于其 RecordBatchReaders。
- 返回：
如果 row_group_indices 或 column_indices 包含无效索引，则返回错误 Result
返回从 row_group_indices 中选择的行组的 RecordBatchReader，其列由 column_indices 选择。
请注意，row_group_indices 和 column_indices 中的顺序很重要。FileReaders 的生命周期必须长于其 RecordBatchReaders。
- 已弃用
在 21.0.0 版本中弃用。请改用 arrow::Result 版本。
- 参数:
row_group_indices – 要读取哪些行组（顺序决定读取顺序）。
column_indices – 要读取哪些列（顺序决定输出模式）。
out – [out] 来自 parquet 数据的记录批次流。
- 返回：
如果 row_group_indices 或 column_indices 包含无效索引，则返回错误 Status
- 已弃用
在 21.0.0 版本中弃用。请改用 arrow::Result 版本。
- 已弃用
在 21.0.0 版本中弃用。请改用 arrow::Result 版本。
返回一个记录批次的生成器。
FileReader 的生命周期必须长于该生成器，因此这要求您传入一个 shared_ptr。
- 返回：
如果 row_group_indices 或 column_indices 包含无效索引，则返回错误 Result
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
-
virtual ::arrow::Result<std::shared_ptr<::arrow::Table>> ReadTable(const std::vector<int> &column_indices) = 0#
将给定的列读取到一个 Table 中。
所指示的列索引是相对于 Parquet 表的内部表示的。例如：0 foo.bar foo.bar.baz 0 foo.bar.baz2 1 foo.qux 2 1 foo2 3 2 foo3 4
i=0 将读取 foo.bar.baz，i=1 将仅读取 foo.bar.baz2，依此类推。只有叶子字段才有索引；foo 本身没有索引。要获取特定叶子字段的索引，可以使用 manifest().schema_fields 来获取顶层字段，然后遍历树以确定相关的叶子字段并访问其 column_index。要获取叶子字段的总数，请使用 FileMetadata.num_columns()。
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
-
virtual ::arrow::Result<std::shared_ptr<::arrow::Table>> ReadRowGroup(int i, const std::vector<int> &column_indices) = 0#
将给定的行组列读取到一个 Table 中。
-
virtual ::arrow::Result<std::shared_ptr<::arrow::Table>> ReadRowGroup(int i) = 0#
将给定的行组读取到一个 Table 中。
-
virtual ::arrow::Result<std::shared_ptr<::arrow::Table>> ReadRowGroups(const std::vector<int> &row_groups, const std::vector<int> &column_indices) = 0#
将给定的行组列读取到一个 Table 中。
-
virtual ::arrow::Result<std::shared_ptr<::arrow::Table>> ReadRowGroups(const std::vector<int> &row_groups) = 0#
将给定的行组读取到一个 Table 中。
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
- 已弃用
在 24.0.0 版本中已弃用。请改用 arrow::Result 版本。
-
virtual ::arrow::Status ScanContents(std::vector<int> columns, const int32_t column_batch_size, int64_t *num_rows) = 0#
使用单个线程扫描文件内容，返回行数。
-
virtual std::shared_ptr<RowGroupReader> RowGroup(int row_group_index) = 0#
返回 RowGroup 的读取器，该对象的生命周期不得超过 FileReader。
-
virtual int num_row_groups() const = 0#
文件中的行组数量。
-
virtual void set_use_threads(bool use_threads) = 0#
设置在读取多个列时是否使用多线程。
默认情况下仅使用一个线程。
-
virtual void set_batch_size(int64_t batch_size) = 0#
设置 RecordBatchReader 每批读取的记录数。
公共静态函数
-
static ::arrow::Status Make(::arrow::MemoryPool *pool, std::unique_ptr<ParquetFileReader> reader, const ArrowReaderProperties &properties, std::unique_ptr<FileReader> *out)#
用于从 ParquetFileReader 和属性创建 FileReader 的工厂函数。
- 已弃用
在 23.0.0 版本中已弃用。请改用 arrow::Result 版本。
-
static ::arrow::Status Make(::arrow::MemoryPool *pool, std::unique_ptr<ParquetFileReader> reader, std::unique_ptr<FileReader> *out)#
用于从 ParquetFileReader 创建 FileReader 的工厂函数。
- 已弃用
在 23.0.0 版本中已弃用。请改用 arrow::Result 版本。
-
::arrow::Result<std::unique_ptr<FileReader>> Make(::arrow::MemoryPool *pool, std::unique_ptr<ParquetFileReader> reader, const ArrowReaderProperties &properties)#
-
class FileReaderBuilder#
实验性的辅助类，用于处理在 std::move 或 C++ 异常方面存在困难的绑定（如 Python）。
公共函数
根据 Arrow 文件及可选的属性/元数据创建 FileReaderBuilder。
根据文件路径及可选的属性/元数据创建 FileReaderBuilder。
-
FileReaderBuilder *memory_pool(::arrow::MemoryPool *pool)#
设置用于内存分配的 Arrow MemoryPool。
-
FileReaderBuilder *properties(const ArrowReaderProperties &arg_properties)#
设置 Arrow 读取器属性。
-
::arrow::Status Build(std::unique_ptr<FileReader> *out)#
构建 FileReader 实例。
根据 Arrow 文件及 MemoryPool 构建 FileReader。
高级设置可以通过 FileReaderBuilder 类进行支持。
-
class StreamReader#
用于使用输出流 API 读取 Parquet 文件的类。
提供的值必须类型正确，即该类型必须与文件模式精确匹配，否则将抛出 ParquetException。
用户必须使用 EndRow() 函数或 EndRow 输入操作符显式跳转到下一行。
支持必选字段和可选字段。
使用 operator>>(T) 读取必选字段。
使用 operator>>(std::optional<T>) 读取可选字段。
注意，operator>>(std::optional<T>) 可用于读取必选字段。
同样，operator>>(T) 也可用于读取可选字段。但是，如果该值不存在，则会引发 ParquetException。
目前不支持重复字段。
公共函数
-
explicit StreamReader(std::unique_ptr<ParquetFileReader> reader)#
读取器在其模式中至少定义了一个字段。
-
void EndRow()#
结束当前行并跳转到下一行。
- 抛出：
ParquetException – 如果行中的所有列未被读取或跳过。
-
int64_t SkipColumns(int64_t num_columns_to_skip)#
跳过后续列中的数据。
如果列数超过了当前行剩余的列数，则跳过操作终止——它不会继续跳过下一行的列。即使所有剩余的列都被跳过，跳过列仍需要使用‘EndRow’。
- 返回：
实际跳过的列数。
-
int64_t SkipRows(int64_t num_rows_to_skip)#
跳过后续行中的数据。
如果尚未完成当前行的数据读取，则不允许跳过行。如果到达文件末尾，跳过行操作将终止。
- 返回：
实际跳过的行数。
Parquet 写入器#
-
class WriterProperties#
-
class Builder#
公共函数
-
inline Builder *enable_content_defined_chunking()#
实验性功能：为所有列启用基于内容的页面分块。
通过根据内容定义的分块边界写入数据页面，优化内容寻址存储（CAS）系统的 Parquet 文件。这允许在多个文件间更高效地进行数据去重，从而提高网络传输和存储效率。分块基于滚动哈希算法，该算法根据数据的实际内容识别分块边界。
注意，目前仅支持 WriteArrow() 接口。
-
inline Builder *content_defined_chunking_options(const CdcOptions &options)#
实验性功能：指定基于内容的分块选项，请参阅 CdcOptions。
为
path指定的列启用字典编码。默认为启用。
为
path指定的列禁用字典编码。默认为启用。
-
inline Builder *write_batch_size(int64_t write_batch_size)#
指定将 Arrow 值批次写入 Parquet 时的写入批次大小。
默认为 1024。
-
inline Builder *encoding(Encoding::type encoding_type)#
定义在不使用字典编码时所使用的编码方式。
这仅在禁用字典编码时适用。如果字典变得过大，我们总是会回退到 PLAIN 编码。
-
inline Builder *encoding(const std::string &path, Encoding::type encoding_type)#
定义在不使用字典编码时所使用的编码方式。
这仅在禁用字典编码时适用。如果字典变得过大，我们总是会回退到 PLAIN 编码。
定义在不使用字典编码时所使用的编码方式。
这仅在禁用字典编码时适用。如果字典变得过大，我们总是会回退到 PLAIN 编码。
-
inline Builder *compression(const std::string &path, Compression::type codec)#
为
path指定的列设置压缩编码。默认为 UNCOMPRESSED（未压缩）。
为
path指定的列设置压缩编码。默认为 UNCOMPRESSED（未压缩）。
-
inline Builder *compression_level(int compression_level)#
为每一列的压缩器指定默认压缩级别。
如果某列未明确指定压缩级别，则使用默认级别。
所提供的压缩级别是特定于压缩器的。用户需要熟悉所选压缩器的可用级别。如果压缩器不允许选择不同的压缩级别，调用此函数将无效。Parquet 和 Arrow 不会对传入的压缩级别进行校验。如果用户未选择级别，或者传入了特殊的 std::numeric_limits<int>::min() 值，则 Arrow 将自动选择压缩级别。
如果除了压缩级别之外还需要设置其他压缩器特定选项，请使用 codec_options 方法。
-
inline Builder *compression_level(const std::string &path, int compression_level)#
为 path 所描述的列指定压缩器的压缩级别。
所提供的压缩级别是特定于压缩器的。用户需要熟悉所选压缩器的可用级别。如果压缩器不允许选择不同的压缩级别，调用此函数将无效。Parquet 和 Arrow 不会对传入的压缩级别进行校验。如果用户未选择级别，或者传入了特殊的 std::numeric_limits<int>::min() 值，则 Arrow 将自动选择压缩级别。
为 path 所描述的列指定压缩器的压缩级别。
所提供的压缩级别是特定于压缩器的。用户需要熟悉所选压缩器的可用级别。如果压缩器不允许选择不同的压缩级别，调用此函数将无效。Parquet 和 Arrow 不会对传入的压缩级别进行校验。如果用户未选择级别，或者传入了特殊的 std::numeric_limits<int>::min() 值，则 Arrow 将自动选择压缩级别。
指定每一列中压缩器的默认编解码器选项。
编解码器选项允许配置压缩级别以及其他特定于编解码器的选项。
为 path 所描述的列指定压缩器的编解码器选项。
为 path 所描述的列指定压缩器的编解码器选项。
定义文件加密属性。
默认为 NULL。
为
path指定的列启用统计信息。默认为启用。
-
inline Builder *set_sorting_columns(std::vector<SortingColumn> sorting_columns)#
定义排序的列。
默认为空。
如果设置了排序的列，用户应确保记录已按照这些列进行排序。否则，存储的数据将与 sorting_columns 元数据不一致。
为
path指定的列禁用统计信息。默认为启用。
为
path指定的列禁用布隆过滤器。默认禁用。
-
inline Builder *enable_bloom_filter(const std::string &path, const BloomFilterOptions &bloom_filter_options)#
为
path指定的列启用布隆过滤器。默认禁用。
注意
布隆过滤器不支持布尔列。如果列是布尔类型，写入时将抛出 ParquetException。
为
path指定的列启用布隆过滤器。默认禁用。
注意
布隆过滤器不支持布尔列。如果列是布尔类型，写入时将抛出 ParquetException。
-
inline Builder *enable_store_decimal_as_integer()#
允许将精度 1 <= precision <= 18 的 decimal 类型存储为整数。
在 Parquet 中，DECIMAL 可以存储为以下任意物理类型：
int32：适用于 1 <= precision <= 9。
int64：适用于 10 <= precision <= 18。
fixed_len_byte_array：精度受数组大小限制。长度为 n 可以存储 <= floor(log_10(2^(8*n - 1) - 1)) 个十进制数字。
binary：精度不受限制。使用存储未缩放值所需的最少字节数。
默认情况下，此功能已禁用，所有 decimal 类型均注解为 fixed_len_byte_array。
启用此功能后，C++ 写入器将使用以下物理类型存储 decimal：
int32：适用于 1 <= precision <= 9。
int64：适用于 10 <= precision <= 18。
fixed_len_byte_array：适用于 precision > 18。
因此，以整数类型存储的 decimal 列更为紧凑。
-
inline Builder *disable_store_decimal_as_integer()#
禁用将精度 1 <= precision <= 18 的 decimal 逻辑类型存储为整数物理类型。
默认禁用。
-
inline Builder *enable_write_page_index()#
常规启用所有列的页面索引写入。
默认为启用。
将统计信息写入页面索引会禁用将统计信息写入每个数据页头的旧方法。页面索引比页面头更有效地进行过滤，因为它将 Parquet 文件的所有统计信息收集在一个地方，避免了分散的 I/O。
请查看以下链接以获取更多详细信息：https://github.com/apache/parquet-format/blob/master/PageIndex.md
为
path指定的列启用页面索引写入。默认启用。
为
path指定的列禁用页面索引写入。默认启用。
-
inline Builder *set_size_statistics_level(SizeStatisticsLevel level)#
设置所有列的大小的统计信息写入级别。
默认为 PageAndColumnChunk。
- 参数:
level – 大小统计信息的写入级别。注意，如果未启用页面索引，即使级别设置为 PageAndColumnChunk，也不会写入页面级别的大小统计信息。
-
inline std::shared_ptr<WriterProperties> build()#
使用构建器参数构建 WriterProperties。
- 返回：
由构建器定义的 WriterProperties。
-
inline Builder *enable_content_defined_chunking()#
-
class Builder#
-
class ArrowWriterProperties#
公共函数
-
inline bool compliant_nested_types() const#
启用符合 Parquet 规范的嵌套类型命名。
旧版本的 Arrow 基于字段名称为嵌套列表编写字段名称。根据 Parquet 规范，它们应该始终为“element”。
-
inline EngineVersion engine_version() const#
编写 Arrow 数据时使用的底层引擎版本。
V2 目前是最新版本，V1 被视为已弃用，但保留以防在 V2 中检测到错误。
-
inline bool use_threads() const#
返回写入器是否会在缓冲行组模式下使用多线程并行写入列。
-
::arrow::internal::Executor *executor() const#
返回用于并行写入列的执行器。
-
inline bool write_time_adjusted_to_utc() const#
编写 TIME 列时 isAdjustedTOUTC 的值。
注意此设置不会影响 TIMESTAMP 数据。
-
class Builder#
公共函数
-
inline Builder *enable_deprecated_int96_timestamps()#
启用编写遗留的 int96 时间戳（默认禁用）。
可以开启以编写与旧 Parquet 写入器兼容的时间戳。这比 coerce_timestamps 具有更高优先级。
-
inline Builder *coerce_timestamps(::arrow::TimeUnit::type unit)#
将所有时间戳强制转换为指定的时间单位。
- 参数:
unit – 要截断到的时间单位。对于 Parquet 1.0 和 2.4 版本，纳秒会被转换为微秒。
-
inline Builder *store_schema()#
实验性功能：将二进制序列化的 Arrow schema 写入文件，以允许自动设置某些读取选项（例如“read_dictionary”）。
-
inline Builder *enable_compliant_nested_types()#
启用后，将不会为列表类型保留 Arrow 字段名称。
它将使用“element”（如 Parquet 规范中所述），而不是使用 Arrow 为列表类型的 values 数组使用的字段名称（默认“item”）。
默认启用。
-
inline Builder *set_use_threads(bool use_threads)#
设置是否在缓冲行组模式下使用多线程并行写入列。
警告：如果在同一个执行器中并行写入多个文件，且 use_threads 为 true，则可能会发生死锁。在这种情况下，请禁用它。
默认为 false。
-
inline Builder *set_executor(::arrow::internal::Executor *executor)#
设置在缓冲行组模式下并行写入列的执行器。
默认为 nullptr，并将使用默认的 CPU 执行器。
-
inline Builder *set_time_adjusted_to_utc(bool adjusted)#
设置编写 TIME 列时 isAdjustedTOUTC 的值。
默认为 false，因为 Arrow TIME 数据以未指定的时区表示。注意此设置不会影响 TIMESTAMP 数据。
-
inline std::shared_ptr<ArrowWriterProperties> build()#
创建最终属性。
-
inline Builder *enable_deprecated_int96_timestamps()#
-
inline bool compliant_nested_types() const#
-
class FileWriter#
迭代式 FileWriter 类。
对于基本用法，可以一次编写一个 Table，每次写入调用创建一个或多个行组。
对于高级用法，可以逐列写入：使用 NewRowGroup 启动一个新的行组或块，然后逐列写入整个列块。
如果字段上存在 PARQUET:field_id 作为元数据键，且相应的值是非负整数，则它将被用作 Parquet 文件中的 field_id。
公共函数
尝试创建 Arrow 到 Parquet 文件写入器。
- 自
11.0.0
- 参数:
schema – 将要传递的数据的 schema。
pool – 要使用的内存池。
sink – 用于写入 Parquet 数据的输出流。
properties – 通用的 Parquet 写入器属性。
arrow_properties – Arrow 特定的写入器属性。
-
virtual ::arrow::Status WriteTable(const ::arrow::Table &table, int64_t chunk_size = DEFAULT_MAX_ROW_GROUP_LENGTH) = 0#
将 Table 写入 Parquet。
- 参数:
table – 要写入的 Arrow 表。
chunk_size – 每个行组 (row group) 写入的最大行数。
使用 ChunkedArray 的切片将 ColumnChunk 写入行组。
使用 ChunkedArray 将 ColumnChunk 写入行组。
-
virtual ::arrow::Status NewBufferedRowGroup() = 0#
开始一个新的缓冲行组 (buffered row group)。
如果尚未写入所有列，则返回错误。
-
virtual ::arrow::Status WriteRecordBatch(const ::arrow::RecordBatch &batch) = 0#
将 RecordBatch 写入缓冲行组。
通过此方法可以将多个 RecordBatch 写入同一个行组中。
WriterProperties.max_row_group_length() 将被遵循，如果当前行组超过限制，将创建一个新的行组。
一旦调用 NewBufferedRowGroup() 或 Close()，批次数据就会被刷入输出流。
警告：如果您在同一个执行器中并行写入多个文件，并且设置 ArrowWriterProperties::use_threads 为 true 以并行写入列，则可能会发生死锁。在这种情况下，请禁用 use_threads 选项。
向文件添加键值元数据。
警告：如果启用了
store_schema，ARROW:schema将存储在键值元数据中。覆盖此键将导致store_schema在读取时无法使用。注意
这将覆盖具有相同键的任何现有元数据。
- 参数:
key_value_metadata – [in] 要添加的元数据。
- 返回：
如果已调用 Close()，则返回错误。
将 Table 写入 Parquet。
此函数一次性写入一个表。若要迭代地写入包含多个表的 Parquet 文件，请参阅 parquet::arrow::FileWriter。
- 参数:
table – 要写入的表。
pool – 要使用的内存池。
sink – 用于写入 Parquet 数据的输出流。
chunk_size – 每个行组 (row group) 写入的最大行数。
properties – 通用的 Parquet 写入器属性。
arrow_properties – Arrow 特定的写入器属性。
-
class StreamWriter#
一个使用输出流类型 API 写入 Parquet 文件的类。
提供的值必须类型正确，即该类型必须与文件模式精确匹配，否则将抛出 ParquetException。
用户必须使用 EndRow() 函数或 EndRow 输出操作符明确指示行结束。
可以配置最大行组大小，默认大小为 512MB。或者，可以将行组大小设置为零，用户可以通过调用 EndRowGroup() 函数或使用 EndRowGroup 输出操作符来创建新的行组。
支持必选字段和可选字段。
必需字段使用 operator<<(T) 写入。
可选字段使用 operator<<(std::optional<T>) 写入。
请注意，operator<<(T) 也可用于写入可选字段。
同样，operator<<(std::optional<T>) 也可用于写入必需字段。但是，如果可选参数没有值（即它是 nullopt），则会引发 ParquetException。
目前不支持重复字段。
公共类型
-
using RawDataView = std::span<const uint8_t>#
用于写入可变长度原始数据的辅助类。
公共函数
-
StreamWriter &operator<<(bool v)#
必需字段的输出操作符。
当必须设置值时，这些操作符也可用于可选字段。
-
template<int N>
inline StreamWriter &operator<<(const char (&v)[N])# 固定长度字符串的输出操作符。
-
StreamWriter &operator<<(const char *v)#
可变长度字符串的输出操作符。
-
StreamWriter &operator<<(RawDataView v)#
可变长度原始数据的输出操作符。
-
template<typename T>
inline StreamWriter &operator<<(const optional<T> &v)# 可选字段的输出操作符。
-
int64_t SkipColumns(int num_columns_to_skip)#
跳过接下来的 N 列可选数据。
如果剩余列数少于 N，则忽略多出的列。
- 抛出：
ParquetException – 如果尝试跳过任何必需列。
- 返回：
实际跳过的列数。
-
void EndRow()#
终止当前行并前进到下一行。
- 抛出：
ParquetException – 如果该行中的所有列未被写入或跳过。
-
void EndRowGroup()#
终止当前行组并创建一个新行组。
-
struct FixedStringView#
用于写入固定长度字符串的辅助类。
这很有用，因为标准字符串视图（例如 std::string_view）是针对可变长度数据的。
ORC#
-
class ORCFileReader#
从 ORC 文件读取 Arrow Table 或 RecordBatch。
公共函数
-
Result<std::shared_ptr<Table>> Read()#
将文件读取为 Table。
该表将由每个 stripe 一个记录批次 (record batch) 组成。
- 返回：
返回的 Table
-
Result<std::shared_ptr<Table>> Read(const std::vector<int> &include_indices)#
将文件读取为 Table。
该表将由每个 stripe 一个记录批次 (record batch) 组成。
- 参数:
include_indices – [in] 要读取的选定字段索引
- 返回：
返回的 Table
-
Result<std::shared_ptr<Table>> Read(const std::vector<std::string> &include_names)#
将文件读取为 Table。
该表将由每个 stripe 一个记录批次 (record batch) 组成。
- 参数:
include_names – [in] 要读取的选定字段名称
- 返回：
返回的 Table
将文件读取为 Table。
该表将由每个 stripe 一个记录批次 (record batch) 组成。
-
Result<std::shared_ptr<RecordBatch>> ReadStripe(int64_t stripe)#
将单个 stripe 读取为 RecordBatch。
- 参数:
stripe – [in] stripe 索引
- 返回：
返回的 RecordBatch
-
Result<std::shared_ptr<RecordBatch>> ReadStripe(int64_t stripe, const std::vector<int> &include_indices)#
将单个 stripe 读取为 RecordBatch。
- 参数:
stripe – [in] stripe 索引
include_indices – [in] 要读取的选定字段索引
- 返回：
返回的 RecordBatch
-
Result<std::shared_ptr<RecordBatch>> ReadStripe(int64_t stripe, const std::vector<std::string> &include_names)#
将单个 stripe 读取为 RecordBatch。
- 参数:
stripe – [in] stripe 索引
include_names – [in] 要读取的选定字段名称
- 返回：
返回的 RecordBatch
-
Status Seek(int64_t row_number)#
跳转到指定的行。
在 seek 之后调用 NextStripeReader() 将返回从指定行开始的 stripe 读取器。
- 参数:
row_number – [in] 要跳转的行号
-
Result<std::shared_ptr<RecordBatchReader>> NextStripeReader(int64_t batch_size)#
获取 stripe 级别的记录批次迭代器。
每个记录批次最多包含
batch_size行。NextStripeReader 是 ReadStripe 的细粒度替代方案，ReadStripe 可能会通过将整个 stripe 加载到内存中而导致内存溢出 (OOM) 问题。请注意，这只会读取当前 stripe 的行，而不是整个文件。
- 参数:
batch_size – [in] 每个记录批次中的最大行数
- 返回：
返回的 stripe 读取器
-
Result<std::shared_ptr<RecordBatchReader>> NextStripeReader(int64_t batch_size, const std::vector<int> &include_indices)#
获取 stripe 级别的记录批次迭代器。
每个记录批次最多包含
batch_size行。NextStripeReader 是 ReadStripe 的细粒度替代方案，ReadStripe 可能会通过将整个 stripe 加载到内存中而导致内存溢出 (OOM) 问题。请注意，这只会读取当前 stripe 的行，而不是整个文件。
- 参数:
batch_size – [in] 每个记录批次中的最大行数
include_indices – [in] 要读取的选定字段索引
- 返回：
stripe 读取器
-
Result<std::shared_ptr<RecordBatchReader>> GetRecordBatchReader(int64_t batch_size, const std::vector<std::string> &include_names)#
获取整个文件的记录批次迭代器。
每个记录批次最多包含
batch_size行。- 参数:
batch_size – [in] 每个记录批次中的最大行数
include_names – [in] 要读取的选定字段名称，如果不为空（否则将读取所有字段）
- 返回：
记录批次迭代器
-
int64_t NumberOfStripes()#
文件中的 stripe 数量。
-
int64_t NumberOfRows()#
文件中的行数。
-
StripeInformation GetStripeInformation(int64_t stripe)#
每个 stripe 的 StripeInformation。
-
FileVersion GetFileVersion()#
获取文件的格式版本。
目前已知的值为 0.11 和 0.12。
- 返回：
ORC 文件的 FileVersion。
-
std::string GetSoftwareVersion()#
获取写入此文件的软件实例和版本。
- 返回：
指定软件版本的面向用户的字符串
-
int64_t GetCompressionSize()#
获取压缩的缓冲区大小。
- 返回：
为压缩编解码器缓冲的字节数。
-
int64_t GetRowIndexStride()#
获取行索引中每个条目的行数。
- 返回：
行索引中每个条目的行数，如果不存在行索引，则为 0。
-
WriterId GetWriterId()#
获取生成该文件的写入器 ID。
- 返回：
如果写入器 ID 未定义，则为 UNKNOWN_WRITER
-
int32_t GetWriterIdValue()#
当 getWriterId() 返回未知写入器时获取写入器 ID 值。
- 返回：
写入器 ID 的整数值。
-
WriterVersion GetWriterVersion()#
获取写入器的版本。
- 返回：
写入器的版本。
-
int64_t GetNumberOfStripeStatistics()#
获取文件中 stripe 统计信息的数量。
- 返回：
stripe 统计信息的数量
-
int64_t GetContentLength()#
获取文件中数据 stripe 的长度。
- 返回：
返回 stripe 中的字节数
-
int64_t GetStripeStatisticsLength()#
获取文件 stripe 统计信息的长度。
- 返回：
文件 stripe 统计信息中的压缩字节数
获取文件尾 (footer) 的长度。
- 返回：
文件尾中的压缩字节数
-
int64_t GetFilePostscriptLength()#
获取文件附言 (postscript) 的长度。
- 返回：
文件附言中的字节数
-
int64_t GetFileLength()#
获取文件的总长度。
- 返回：
文件中的字节数
-
std::string GetSerializedFileTail()#
获取序列化的文件尾。
如果同一文件的其他读取器想要避免重新读取文件尾，这会很有用。请参阅 ReadOptions.SetSerializedFileTail()。
- 返回：
包含文件尾的字节字符串
-
Result<std::shared_ptr<const KeyValueMetadata>> ReadMetadata()#
返回从 ORC 文件中读取的元数据。
- 返回：
包含 ORC 元数据的 KeyValueMetadata 对象
公共静态函数
创建一个新的 ORC 读取器。
- 参数:
file – [in] 数据源
pool – [in] 用于缓冲区分配的 MemoryPool
- 返回：
返回的读取器对象
-
Result<std::shared_ptr<Table>> Read()#
-
struct WriteOptions#
ORC 写入器的选项。
公共成员
-
int64_t batch_size = 1024#
ORC 写入器一次写入的行数，默认 1024。
-
FileVersion file_version = FileVersion(0, 12)#
要使用的 ORC 文件版本，默认 FileVersion(0, 12)
-
int64_t stripe_size = 64 * 1024 * 1024#
每个 ORC stripe 的大小（字节），默认 64 MiB。
-
Compression::type compression = Compression::UNCOMPRESSED#
ORC 文件的压缩编解码器，默认不压缩。
-
int64_t compression_block_size = 64 * 1024#
每个压缩块的大小（字节），默认 64 KiB。
-
CompressionStrategy compression_strategy = CompressionStrategy::kSpeed#
压缩策略，即速度与减小尺寸之间的权衡。
默认 CompressionStrategy::kSpeed
-
int64_t row_index_stride = 10000#
行索引中每个条目的行数，默认 10000。
-
double padding_tolerance = 0.0#
填充容差，默认 0.0。
-
double dictionary_key_size_threshold = 0.0#
字典键大小阈值。
0 表示禁用字典编码。1 表示始终启用字典编码，默认为 0.0
-
std::vector<int64_t> bloom_filter_columns#
使用布隆过滤器的列数组，默认为空。
-
double bloom_filter_fpp = 0.05#
布隆过滤器的假阳性率上限，默认为 0.05。
-
int64_t batch_size = 1024#
-
class ORCFileWriter#
将 Arrow Table 或 RecordBatch 写入 ORC 文件。
公共函数
-
Status Write(const Table &table)#
写入一个表。
此方法可多次调用。
后续调用中传递的表必须与首次写入的表结构（schema）匹配。
- 参数:
table – [in] 提取数据的 Arrow 表。
- 返回：
-
Status Write(const RecordBatch &record_batch)#
写入一个 RecordBatch。
此方法可多次调用。
后续调用中传递的 RecordBatches 必须与首次写入的 RecordBatch 结构（schema）匹配。
- 参数:
record_batch – [in] 提取数据的 Arrow RecordBatch。
- 返回：
公共静态函数
-
static Result<std::unique_ptr<ORCFileWriter>> Open(io::OutputStream *output_stream, const WriteOptions &write_options = WriteOptions())#
创建一个新的 ORC 写入器。
- 参数:
output_stream – [in] 指向写入目标的 io::OutputStream 指针
write_options – [in] Arrow 的 ORC 写入选项
- 返回：
返回的写入器对象
-
Status Write(const Table &table)#