| Class | Description |
|---|---|
| AggregateFunction | |
| Array |
\brief Array base type
Immutable data array with some logical type and some length.
|
| ArrayBuilder |
Base class for all data array builders.
|
| ArrayData |
\class ArrayData
\brief Mutable container for generic Arrow array data
This data structure is a self-contained representation of the memory and
metadata inside an Arrow array data structure (called vectors in Java).
|
| ArrayDataVector | |
| ArrayDataVector.Iterator | |
| ArrayResult | |
| ArrayVector | |
| ArrayVector.Iterator | |
| ArrayVectorVector | |
| ArrayVectorVector.Iterator | |
| ArrayVisitor | |
| ArrowBuffer |
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| ArrowBufferVector | |
| ArrowBufferVector.Iterator | |
| ArrowBuilderVector | |
| ArrowBuilderVector.Iterator | |
| BaseBaseDate32Scalar | |
| BaseBaseDate64Scalar | |
| BaseBaseDayTimeIntervalScalar | |
| BaseBaseMonthIntervalType | |
| BaseBaseTime32Scalar | |
| BaseBaseTime64Scalar | |
| BaseBinaryArray |
Base class for variable-sized binary arrays, regardless of offset size
and logical interpretation.
|
| BaseBinaryBuilder | |
| BaseBinaryScalar | |
| BaseBinaryType |
\brief Base class for all variable-size binary data types
|
| BaseDate32Scalar | |
| BaseDate64Scalar | |
| BaseDayTimeIntervalScalar | |
| BaseDoubleScalar | |
| BaseDurationScalar | |
| BaseFloatScalar | |
| BaseHalfFloatScalar | |
| BaseInt16Type | |
| BaseInt32Type | |
| BaseInt64Type | |
| BaseInt8Type | |
| BaseLargeBinaryArray | |
| BaseLargeBinaryBuilder | |
| BaseLargeListArray | |
| BaseLargeListBuilder | |
| BaseListArray |
Base class for variable-sized list arrays, regardless of offset size.
|
| BaseListBuilder | |
| BaseListScalar | |
| BaseListType |
\brief Base class for all variable-size list data types
|
| BaseMonthIntervalScalar | |
| BaseTime32Scalar | |
| BaseTime64Scalar | |
| BaseTimestampScalar | |
| BaseUInt16Type | |
| BaseUInt32Type | |
| BaseUInt64Type | |
| BaseUInt8Type | |
| BasicDecimal128 |
Represents a signed 128-bit integer in two's complement.
|
| BasicUnionBuilder | |
| BinaryArray |
Concrete Array class for variable-size binary data
|
| BinaryArrayResult | |
| BinaryBuilder |
\class BinaryBuilder
\brief Builder class for variable-length binary data
|
| BinaryDictionary32Builder | |
| BinaryDictionaryBuilder | |
| BinaryKernel |
\class BinaryKernel
\brief An array-valued function of a two input arguments
|
| BinaryScalar | |
| BinaryType |
\brief Concrete type class for variable-size binary data
|
| BitmapReader | |
| BitmapWriter | |
| BitsetStack |
\brief Store a stack of bitsets efficiently.
|
| BooleanArray |
Concrete Array class for boolean data
|
| BooleanBuilder | |
| BooleanScalar | |
| BooleanType | |
| BoolResult |
A Result object either contains a value of type
T or a Status object
explaining why such a value is not present. |
| BoolVector | |
| BoolVector.Iterator | |
| BufferBuilder |
\class BufferBuilder
\brief A class for incrementally building a contiguous chunk of in-memory
data
|
| BufferedInputStream |
\class BufferedInputStream
\brief An InputStream that performs buffered reads from an unbuffered
InputStream, which can mitigate the overhead of many small reads in some
cases
|
| BufferedInputStreamConcurrencyWrapper | |
| BufferedInputStreamResult | |
| BufferedOutputStream | |
| BufferedOutputStreamResult | |
| BufferIterator |
\brief A generic Iterator that can return errors
|
| BufferIterator.RangeIterator | |
| BufferIteratorResult | |
| BufferOutputStream |
\brief An output stream that writes to a resizable buffer
|
| BufferOutputStreamResult | |
| BufferReader |
\class BufferReader
\brief Random access zero-copy reads on an arrow::Buffer
|
| BufferReaderRandomAccessFileConcurrencyWrapper | |
| BufferResult | |
| Byte16Array | |
| call_traits |
Helper struct for examining lambdas and other callables.
|
| CastOptions | |
| ChunkedArray |
\class ChunkedArray
\brief A data structure managing a list of primitive Arrow arrays logically
as one large array
|
| ChunkedArrayVector | |
| ChunkedArrayVector.Iterator | |
| ChunkedBinaryBuilder | |
| ChunkedStringBuilder | |
| Codec |
\brief Compression codec
|
| CodecResult | |
| CompareOptions | |
| CompressedInputStream | |
| CompressedInputStreamConcurrencyWrapper | |
| CompressedInputStreamResult | |
| CompressedOutputStream | |
| CompressedOutputStreamResult | |
| Compression | |
| Compressor |
\brief Streaming compressor interface
|
| Compressor.CompressResult | |
| Compressor.EndResult | |
| Compressor.FlushResult | |
| CompressorResult | |
| CompressResultResult | |
| ConcatenateTablesOptions |
\defgroup concat-tables ConcatenateTables function.
|
| ConvertOptions | |
| CountOptions |
\class CountOptions
The user control the Count kernel behavior with this class.
|
| CpuInfo | |
| CsvParseOptions | |
| DataType |
\brief Base class for all data types
Data types in this library are all *logical*.
|
| DataTypeLayout | |
| DataTypeResult | |
| Date32Array | |
| Date32Scalar | |
| Date32Type |
Concrete type class for 32-bit date data (as number of days since UNIX epoch)
|
| Date64Array | |
| Date64Scalar | |
| Date64Type |
Concrete type class for 64-bit date data (as number of milliseconds since UNIX epoch)
|
| DateType |
\brief Base type class for date data
|
| Datum |
\class Datum
\brief Variant type for various Arrow C++ data structures
|
| DatumResult | |
| DatumVector | |
| DatumVector.Iterator | |
| DayTimeIntervalArray |
DayTimeArray
---------------------
\brief Array of Day and Millisecond values.
|
| DayTimeIntervalBuilder | |
| DayTimeIntervalScalar | |
| DayTimeIntervalType |
\brief Represents a number of days and milliseconds (fraction of day).
|
| DayTimeIntervalType.DayMilliseconds | |
| Decimal128 |
Represents a signed 128-bit integer in two's complement.
|
| Decimal128Array |
Concrete Array class for 128-bit decimal data
|
| Decimal128Builder | |
| Decimal128Pair | |
| Decimal128PairResult | |
| Decimal128Result | |
| Decimal128Scalar | |
| Decimal128Type |
\brief Concrete type class for 128-bit decimal data
|
| DecimalType |
\brief Base type class for (fixed-size) decimal data
|
| Decompressor |
\brief Streaming decompressor interface
|
| Decompressor.DecompressResult | |
| DecompressorResult | |
| DecompressResultResult | |
| DenseUnionBuilder |
\class DenseUnionBuilder
This API is EXPERIMENTAL.
|
| DictionaryArray |
\brief Array type for dictionary-encoded data with a
data-dependent dictionary
A dictionary array contains an array of non-negative integers (the
"dictionary indices") along with a data type containing a "dictionary"
corresponding to the distinct values represented in the data.
|
| DictionaryMemo |
\brief Memoization data structure for assigning id numbers to
dictionaries and tracking their current state through possible
deltas in an IPC stream
|
| DictionaryMemoTable | |
| DictionaryScalar | |
| DictionaryType |
\brief Dictionary-encoded value type with data-dependent
dictionary
|
| DictionaryUnifier |
\brief Helper class for incremental dictionary unification
|
| DirInfo | |
| DoubleArray | |
| DoubleBuilder | |
| DoubleScalar | |
| DoubleType | |
| DurationArray | |
| DurationScalar | |
| DurationType | |
| EndResultResult | |
| EqualOptions |
A container of options for equality comparisons
|
| ExtensionArray |
\brief Base array class for user-defined extension types
|
| ExtensionScalar | |
| ExtensionType |
\brief The base class for custom / user-defined types.
|
| ExtensionTypeRegistry | |
| Field |
\brief The combination of a field name and data type, with optional metadata
Fields are used to describe the individual constituents of a
nested DataType or a Schema.
|
| Field.MergeOptions |
\brief Options that control the behavior of
MergeWith. |
| FieldResult | |
| FieldVector | |
| FieldVector.Iterator | |
| FileInfo | |
| FileInterface | |
| FileMode | |
| FileOutputStream |
\brief An operating system file open in write-only mode.
|
| FileOutputStreamResult | |
| FileSelector |
\brief File selector for filesystem APIs
|
| FileStatistics |
DEPRECATED.
|
| FileStats |
\brief FileSystem entry stats
|
| FileStats.ByPath |
Function object implementing less-than comparison and hashing
by path, to support sorting stats, using them as keys, and other
interactions with the STL.
|
| FileStatsResult | |
| FileStatsVector | |
| FileStatsVector.Iterator | |
| FileStatsVectorResult | |
| FileSystem |
\brief Abstract file system API
|
| FileSystemResult | |
| FilterIterator |
\brief Like MapIterator, but where the function can fail.
|
| FilterKernel |
\brief BinaryKernel implementing Filter operation
|
| Fingerprintable | |
| FirstTimeBitmapWriter | |
| FixedSizeBinaryArray |
Concrete Array class for fixed-size binary data
|
| FixedSizeBinaryBuilder | |
| FixedSizeBinaryScalar | |
| FixedSizeBinaryType |
\brief Concrete type class for fixed-size binary data
|
| FixedSizeBufferWriter |
\brief An output stream that writes into a fixed-size mutable buffer
|
| FixedSizeListArray |
Concrete Array class for fixed size list data
|
| FixedSizeListBuilder |
\class FixedSizeListBuilder
\brief Builder class for fixed-length list array value types
|
| FixedSizeListScalar | |
| FixedSizeListType |
\brief Concrete type class for fixed size list data
|
| FixedWidthType |
\brief Base class for all fixed-width data types
|
| FlatArray |
Base class for non-nested arrays
|
| FloatArray | |
| FloatBuilder | |
| FloatingPointType |
\brief Base class for all floating-point data types
|
| FloatScalar | |
| FloatType | |
| FlushResultResult | |
| FunctionContext |
\brief Container for variables and options used by function evaluation
|
| HadoopFileSystem | |
| HalfFloatArray | |
| HalfFloatBuilder | |
| HalfFloatScalar | |
| HalfFloatType | |
| HdfsConnectionConfig | |
| HdfsOutputStream | |
| HdfsPathInfo | |
| HdfsReadableFile | |
| InputStream | |
| InputStreamResult | |
| InputStreamSlowInputStreamBase | |
| Int16Array | |
| Int16Builder | |
| Int16Scalar | |
| Int16Type | |
| Int32Array | |
| Int32Builder | |
| Int32Scalar | |
| Int32Type | |
| Int64Array | |
| Int64Builder | |
| Int64Scalar | |
| Int64Type | |
| Int8Array |
Concrete Array class for numeric data.
|
| Int8Builder |
Base class for all Builders that emit an Array of a scalar numerical type.
|
| Int8Scalar | |
| Int8Type | |
| IntegerType |
\brief Base class for all integral data types
|
| IntervalType | |
| IOFileSystem |
DEPRECATED.
|
| IpcOptions | |
| IpcPayload | |
| IpcPayloadWriter | |
| JsonParseOptions | |
| KeyValueMetadata |
\brief A container for key-value pair type metadata.
|
| LargeBinaryArray |
Concrete Array class for large variable-size binary data
|
| LargeBinaryBuilder |
\class LargeBinaryBuilder
\brief Builder class for large variable-length binary data
|
| LargeBinaryScalar | |
| LargeBinaryType |
\brief Concrete type class for large variable-size binary data
|
| LargeListArray |
Concrete Array class for large list data (with 64-bit offsets)
|
| LargeListBuilder |
\class LargeListBuilder
\brief Builder class for large variable-length list array value types
Like ListBuilder, but to create large list arrays (with 64-bit offsets).
|
| LargeListScalar | |
| LargeListType |
\brief Concrete type class for large list data
LargeListType is like ListType but with 64-bit rather than 32-bit offsets.
|
| LargeStringArray |
Concrete Array class for large variable-size string (utf-8) data
|
| LargeStringBuilder |
\class LargeStringBuilder
\brief Builder class for large UTF8 strings
|
| LargeStringScalar | |
| LargeStringType |
\brief Concrete type class for large variable-size string data, utf8-encoded
|
| LatencyGenerator | |
| ListArray |
Concrete Array class for list data
|
| ListArrayResult | |
| ListBuilder |
\class ListBuilder
\brief Builder class for variable-length list array value types
To use this class, you must append values to the child array builder and use
the Append function to delimit each distinct list value (once the values
have been appended to the child array) or use the bulk API to append
a sequence of offests and null values.
|
| ListScalar | |
| ListType |
\brief Concrete type class for list data
List data is nested data where each value is a variable number of
child items.
|
| LocalFileSystem |
\brief A FileSystem implementation accessing files on the local machine.
|
| LocalFileSystemOptions |
Options for the LocalFileSystem implementation.
|
| LoggingMemoryPool | |
| LongResult | |
| MapArray |
Concrete Array class for map data
NB: "value" in this context refers to a pair of a key and the corresponding item
|
| MapBuilder |
\class MapBuilder
\brief Builder class for arrays of variable-size maps
To use this class, you must append values to the key and item array builders
and use the Append function to delimit each distinct map (once the keys and items
have been appended) or use the bulk API to append a sequence of offests and null
maps.
|
| MapScalar | |
| MapType |
\brief Concrete type class for map data
Map data is nested data where each value is a variable number of
key-item pairs.
|
| MemoryMappedFile |
\brief A file interface that uses memory-mapped files for memory interactions
This implementation supports zero-copy reads.
|
| MemoryMappedFileResult | |
| MemoryPool |
Base class for memory allocation.
|
| MemoryPoolStats | |
| Message |
\class Message
\brief An IPC message including metadata and body
|
| MessageReader |
\brief Abstract interface for a sequence of messages
|
| MockFileSystem |
A mock FileSystem implementation that holds its contents in memory.
|
| MockFileSystem.Impl | |
| MockOutputStream |
\brief A helper class to tracks the size of allocations
Writes to this stream do not copy or retain any data, they just bump
a size counter that can be later used to know exactly which data size
needs to be allocated for actual writing.
|
| MonthIntervalArray | |
| MonthIntervalScalar | |
| MonthIntervalType |
\brief Represents a some number of months.
|
| MutableBuffer |
\}
|
| NestedType | |
| NullArray |
Degenerate null type Array
|
| NullBuilder | |
| NullScalar |
\brief A scalar value for NullType.
|
| NullType |
Concrete type class for always-null data
|
| NumberType |
\brief Base class for all numeric data types
|
| ObjectType | |
| OpKernel |
\class OpKernel
\brief Base class for operator kernels
Note to implementors:
Operator kernels are intended to be the lowest level of an analytics/compute
engine.
|
| OutputStream | |
| OutputStreamResult | |
| ParametricType |
\brief Base class for all parametric data types
|
| PathForest |
\brief A PathForest is a utility to transform a vector of FileStats into a
forest representation for tree traversal purposes.
|
| PathForest.Ref |
Reference to a node in the forest
|
| PathForestResult | |
| PrettyPrintOptions | |
| PrimitiveArray |
Base class for arrays of fixed-size logical types
|
| PrimitiveCType |
\brief Base class for all data types representing primitive values
|
| ProxyMemoryPool |
Derived class for memory allocation.
|
| RandomAccessFile | |
| RandomAccessFileResult | |
| RandomAccessFileSlowInputStreamBase | |
| Readable | |
| ReadableFile |
\brief An operating system file open in read-only mode.
|
| ReadableFileRandomAccessFileConcurrencyWrapper | |
| ReadableFileResult | |
| ReadaheadPromise | |
| ReadaheadQueue | |
| ReadOptions | |
| ReadWriteFileInterface | |
| RecordBatch |
\class RecordBatch
\brief Collection of equal-length arrays matching a particular Schema
A record batch is table-like data structure that is semantically a sequence
of fields, each a contiguous Arrow array
|
| RecordBatchBuilder |
\class RecordBatchBuilder
\brief Helper class for creating record batches iteratively given a known
schema
|
| RecordBatchFileReader |
\brief Reads the record batch file format
|
| RecordBatchFileWriter |
\brief Creates the Arrow record batch file format
Implements the random access file format, which structurally is a record
batch stream followed by a metadata footer at the end of the file.
|
| RecordBatchIterator | |
| RecordBatchIterator.RangeIterator | |
| RecordBatchIteratorResult | |
| RecordBatchReader |
\brief Abstract interface for reading stream of record batches
|
| RecordBatchResult | |
| RecordBatchStreamReader |
\class RecordBatchStreamReader
\brief Synchronous batch stream reader that reads from io::InputStream
This class reads the schema (plus any dictionaries) as the first messages
in the stream, followed by record batches.
|
| RecordBatchStreamWriter |
\class RecordBatchStreamWriter
\brief Synchronous batch stream writer that writes the Arrow streaming
format
|
| RecordBatchVector | |
| RecordBatchVector.Iterator | |
| RecordBatchWriter |
\class RecordBatchWriter
\brief Abstract interface for writing a stream of record batches
|
| RecordBatchWriterSharedResult | |
| RecordBatchWriterUniqueResult | |
| ResizableBuffer |
\class ResizableBuffer
\brief A mutable buffer that can be resized
|
| Scalar |
\brief Base class for scalar values, representing a single value occupying
an array "slot"
|
| ScalarResult | |
| ScalarVector | |
| ScalarVector.Iterator | |
| ScalarVisitor | |
| Schema |
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| SchemaBuilder |
\}
|
| SchemaResult | |
| SchemaVector | |
| SchemaVector.Iterator | |
| SchemaVectorResult | |
| Seekable | |
| SharedExclusiveChecker | |
| SharedExclusiveCheckerExclusiveLockGuard | |
| SharedExclusiveCheckerSharedLockGuard | |
| SizeTResult | |
| SlowFileSystem |
\brief A FileSystem implementation that delegates to another
implementation but inserts latencies at various points.
|
| SlowInputStream |
\brief An InputStream wrapper that makes reads slower.
|
| SlowRandomAccessFile |
\brief A RandomAccessFile wrapper that makes reads slower.
|
| SparseTensor | |
| SparseTensorResult | |
| SparseUnionBuilder |
\class SparseUnionBuilder
This API is EXPERIMENTAL.
|
| Status |
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| StatusDetail |
\brief An opaque class that allows subsystems to retain
additional information inside the Status.
|
| StringArray |
Concrete Array class for variable-size string (utf-8) data
|
| StringBuilder |
\class StringBuilder
\brief Builder class for UTF8 strings
|
| StringDataTypeMap | |
| StringDataTypeMap.Iterator | |
| StringDictionary32Builder | |
| StringDictionaryBuilder | |
| StringScalar | |
| StringStreamWrapper | |
| StringStringMap | |
| StringStringMap.Iterator | |
| StringStringPairVector | |
| StringType |
\brief Concrete type class for variable-size string data, utf8-encoded
|
| StringVector | |
| StringVector.Iterator | |
| StringViewResult | |
| StructArray |
Concrete Array class for struct data
|
| StructArrayResult | |
| StructBuilder |
Append, Resize and Reserve methods are acting on StructBuilder.
|
| StructScalar | |
| StructType |
\brief Concrete type class for struct data
|
| SubTreeFileSystem |
\brief A FileSystem implementation that delegates to another
implementation after prepending a fixed base path.
|
| Table |
\class Table
\brief Logical table as sequence of chunked arrays
|
| TableBatchReader |
\brief Compute a stream of record batches from a (possibly chunked) Table
The conversion is zero-copy: each record batch is a view over a slice
of the table's columns.
|
| TableReader |
A class that reads an entire CSV file into a Arrow Table
|
| TableReaderResult | |
| TableResult | |
| TableVector | |
| TableVector.Iterator | |
| TableWriter |
\class TableWriter
\brief Interface for writing Feather files
|
| TakeKernel |
\brief BinaryKernel implementing Take operation
|
| TakeOptions | |
| TemporalType |
\brief Base type for all date and time types
|
| Tensor | |
| TensorResult | |
| Time32Array | |
| Time32Scalar | |
| Time32Type |
Concrete type class for 32-bit time data (as number of seconds or milliseconds
since midnight)
|
| Time64Array | |
| Time64Scalar | |
| Time64Type |
Concrete type class for 64-bit time data (as number of microseconds or nanoseconds
since midnight)
|
| TimestampArray | |
| TimestampScalar | |
| TimestampType |
\brief Concrete type class for datetime data (as number of seconds, milliseconds,
microseconds or nanoseconds since UNIX epoch)
If supplied, the timezone string should take either the form (i) "Area/Location",
with values drawn from the names in the IANA Time Zone Database (such as
"Europe/Zurich"); or (ii) "(+|-)HH:MM" indicating an absolute offset from GMT
(such as "-08:00").
|
| TimeType |
Base type class for time data
|
| TimeUnit | |
| Type | |
| TypedBufferBuilder |
\brief A BufferBuilder for building a buffer containing a bitmap
|
| TypeVisitor | |
| UInt16Array | |
| UInt16Builder | |
| UInt16Scalar | |
| UInt16Type | |
| UInt32Array | |
| UInt32Builder | |
| UInt32Scalar | |
| UInt32Type | |
| UInt64Array | |
| UInt64Builder | |
| UInt64Scalar | |
| UInt64Type | |
| UInt8Array | |
| UInt8Builder | |
| UInt8Scalar | |
| UInt8Type | |
| UnaryKernel |
\class UnaryKernel
\brief An array-valued function of a single input argument.
|
| UnionArray |
Concrete Array class for union data
|
| UnionMode | |
| UnionScalar | |
| UnionType |
\brief Concrete type class for union data
|
| Writable | |
| WritableFile |
| Enum | Description |
|---|---|
| Compression.type |
\brief Compression algorithm
|
| CountOptions.mode | |
| FileMode.type | |
| FilterIterator.Action | |
| FloatingPointType.Precision | |
| IntervalType.type | |
| Message.Type | |
| ObjectType.type | |
| SchemaBuilder.ConflictPolicy | |
| TimeUnit.type |
The unit for a time or timestamp DataType
|
| UnionMode.type |
Copyright © 2020. All rights reserved.