| Class | Description |
|---|---|
| ArithmeticOptions |
\addtogroup compute-concrete-options
\{
|
| Arity |
\brief Contains the number of required arguments for the function.
|
| Array |
\brief Array base type
Immutable data array with some logical type and some length.
|
| ArrayBuilder |
Base class for all data array builders.
|
| ArrayBuilderVector | |
| ArrayBuilderVector.Iterator | |
| 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).
|
| ArrayDataResult | |
| ArrayDataVector | |
| ArrayDataVector.Iterator | |
| ArrayKernel |
\brief Common kernel base data structure for ScalarKernel and
VectorKernel.
|
| ArrayResult | |
| ArraySortOptions | |
| ArrayVector | |
| ArrayVector.Iterator | |
| ArrayVectorResult | |
| ArrayVectorVector | |
| ArrayVectorVector.Iterator | |
| ArrayVisitor | |
| ArrowBuffer |
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| AssignMessageDecoderListener |
\class AssignMessageDecoderListener
\brief Assign a message decoded by MessageDecoder.
|
| AsyncContext | |
| BaseBaseDate32Scalar | |
| BaseBaseDate64Scalar | |
| BaseBaseDayTimeIntervalScalar | |
| BaseBaseMonthIntervalType | |
| BaseBaseTime32Scalar | |
| BaseBaseTime64Scalar | |
| BaseBinaryBuilder | |
| BaseBinaryScalar | |
| BaseBinaryType |
\brief Base class for all variable-size binary data types
|
| BaseDate32Scalar | |
| BaseDate64Scalar | |
| BaseDayTimeIntervalScalar | |
| BaseDoubleScalar | |
| BaseDurationScalar | |
| BaseFloatScalar | |
| BaseHalfFloatScalar | |
| BaseInt16Type | |
| BaseInt32Type | |
| BaseInt64Type | |
| BaseInt8Type | |
| 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.
|
| BasicDecimal256 | |
| BasicUnionBuilder |
\brief Base class for union array builds.
|
| BinaryArray | |
| BinaryArrayResult | |
| BinaryBuilder |
\class BinaryBuilder
\brief Builder class for variable-length binary data
|
| BinaryScalar | |
| BinaryType |
\brief Concrete type class for variable-size binary data
|
| BooleanArray |
Concrete Array class for boolean data
|
| BooleanBuilder | |
| BooleanScalar |
\addtogroup concrete-scalar-classes Concrete Scalar subclasses
\{
|
| BooleanType | |
| BoolResult |
A class for representing either a usable value, or an error.
|
| 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 | |
| BufferInputStream | |
| 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 | |
| BufferUniqueResult | |
| BufferVector | |
| BufferVector.Iterator | |
| BufferVectorResult | |
| BuildInfo | |
| Byte16Array | |
| Byte32Array | |
| CacheOptions | |
| call_traits |
Helper struct for examining lambdas and other callables.
|
| CastOptions |
\addtogroup compute-concrete-options
\{
|
| ChunkedArray |
\class ChunkedArray
\brief A data structure managing a list of primitive Arrow arrays logically
as one large array
Data chunking is treated throughout this project largely as an
implementation detail for performance and memory use optimization.
|
| ChunkedArrayResult | |
| ChunkedArrayVector | |
| ChunkedArrayVector.Iterator | |
| ChunkedArrayVectorResult | |
| ChunkedBinaryBuilder | |
| ChunkedStringBuilder | |
| Codec |
\brief Compression codec
|
| CodecResult | |
| CollectListener |
\brief Collect schema and record batches decoded by StreamDecoder.
|
| CompareOptions | |
| CompressedInputStream | |
| CompressedInputStreamConcurrencyWrapper | |
| CompressedInputStreamResult | |
| CompressedOutputStream | |
| CompressedOutputStreamResult | |
| Compression | |
| CompressionTypeResult | |
| Compressor |
\brief Streaming compressor interface
|
| Compressor.CompressResult | |
| Compressor.EndResult | |
| Compressor.FlushResult | |
| CompressorResult | |
| CompressResultResult | |
| ConcatenateTablesOptions |
\defgroup concat-tables ConcatenateTables function.
|
| ConvertOptions | |
| CountOptions |
\addtogroup compute-concrete-options
\{
|
| CpuInfo | |
| CsvParseOptions | |
| DataType |
\brief Base class for all data types
Data types in this library are all *logical*.
|
| DataTypeLayout |
EXPERIMENTAL: Layout specification for a data type
|
| DataTypeLayout.BufferSpec |
Layout specification for a single data type buffer
|
| DataTypeResult | |
| DataTypeVector | |
| DataTypeVector.Iterator | |
| 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
|
| Datum.Empty | |
| 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 | |
| Decimal128Builder | |
| Decimal128Pair | |
| Decimal128PairResult | |
| Decimal128Result | |
| Decimal128Scalar | |
| Decimal128Type |
\brief Concrete type class for 128-bit decimal data
|
| Decimal256 |
Represents a signed 256-bit integer in two's complement.
|
| Decimal256Array | |
| Decimal256Builder | |
| Decimal256Pair | |
| Decimal256PairResult | |
| Decimal256Result | |
| Decimal256Scalar | |
| Decimal256Type |
\brief Concrete type class for 256-bit decimal data
|
| DecimalType |
\brief Base type class for (fixed-size) decimal data
|
| Decompressor |
\brief Streaming decompressor interface
|
| Decompressor.DecompressResult | |
| DecompressorResult | |
| DecompressResultResult | |
| DenseUnionArray |
\brief Concrete Array class for dense union data
Note that union types do not have a validity bitmap
|
| DenseUnionBuilder |
\class DenseUnionBuilder
This API is EXPERIMENTAL.
|
| DenseUnionScalar | |
| DenseUnionType | |
| Device | |
| DictionaryArray | |
| DictionaryFieldMapper |
\brief Map fields in a schema to dictionary ids
The mapping is structural, i.e.
|
| DictionaryMemo |
\brief Memoization data structure for reading dictionaries from IPC streams
This structure tracks the following associations:
- field position (structural) -> dictionary id
- dictionary id -> value type
- dictionary id -> dictionary (value) data
Together, they allow resolving dictionary data when reading an IPC stream,
using metadata recorded in the schema message and data recorded in the
dictionary batch messages (see ResolveDictionaries).
|
| DictionaryMemoTable | |
| DictionaryScalar | |
| DictionaryType |
\brief Dictionary-encoded value type with data-dependent
dictionary.
|
| DictionaryUnifier |
\brief Helper class for incremental dictionary unification
|
| DictionaryUnifierResult | |
| DictionaryVector | |
| DictionaryVectorResult | |
| DoubleArray | |
| DoubleBuilder | |
| DoubleScalar | |
| DoubleType | |
| DurationArray | |
| DurationScalar | |
| DurationType |
\brief Represents an elapsed time without any relation to a calendar artifact.
|
| EndResultResult | |
| EnsureResult | |
| EqualOptions |
A container of options for equality comparisons
|
| ExecBatch |
\brief A unit of work for kernel execution.
|
| ExecContext |
\brief Context for expression-global variables and options used by
function evaluation
|
| Executor | |
| explicit_copy_constructor | |
| ExtensionArray |
\brief Base array class for user-defined extension types
|
| ExtensionScalar | |
| ExtensionType |
\brief The base class for custom / user-defined types.
|
| ExtensionTypeRegistry | |
| FeatherReaderResult | |
| 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. |
| FieldPath |
\class FieldPath
Represents a path to a nested field using indices of child fields.
|
| FieldPath.Hash | |
| FieldPosition | |
| FieldRef |
\class FieldRef
\brief Descriptor of a (potentially nested) field within a schema.
|
| FieldRef.Hash | |
| FieldRefDatumMap | |
| FieldRefDatumMap.Iterator | |
| FieldRefDatumMapResult | |
| FieldRefResult | |
| FieldResult | |
| FieldVector | |
| FieldVector.Iterator | |
| FileInfo |
\brief FileSystem entry info
|
| FileInfo.ByPath |
Function object implementing less-than comparison and hashing by
path, to support sorting infos, using them as keys, and other
interactions with the STL.
|
| FileInfoResult | |
| FileInfoVectorResult | |
| FileInterface | |
| FileLocator |
\brief FileSystem, path pair
|
| FileMode | |
| FileOutputStream |
\brief An operating system file open in write-only mode.
|
| FileOutputStreamResult | |
| FileSelector |
\brief File selector for filesystem APIs
|
| FileStatistics |
DEPRECATED.
|
| FileSystem |
\brief Abstract file system API
|
| FileSystemGlobalOptions | |
| FileSystemResult | |
| FilterIterator |
\brief Like MapIterator, but where the function can fail.
|
| FilterOptions |
\addtogroup compute-concrete-options
\{
|
| Fingerprintable | |
| first | |
| FixedSizeBinaryArray | |
| 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 | |
| ForReturnImpl | |
| Function |
\brief Base class for compute functions.
|
| FunctionDoc | |
| FunctionOptions |
\defgroup compute-functions Abstract compute function API
\{
|
| FunctionRegistry |
\brief A mutable central function registry for built-in functions as well
as user-defined functions.
|
| FunctionResult | |
| FutureWaiter | |
| HadoopFileSystem | |
| HalfFloatArray | |
| HalfFloatBuilder | |
| HalfFloatScalar | |
| HalfFloatType | |
| HdfsConnectionConfig | |
| HdfsOptions |
Options for the HDFS implementation.
|
| HDFSOptionsResult | |
| HdfsOutputStream | |
| HdfsPathInfo | |
| HdfsReadableFile | |
| InputStream | |
| InputStreamResult | |
| InputStreamSlowInputStreamBase | |
| InputType |
\brief An object used for type- and shape-checking arguments to be passed
to a kernel and stored in a KernelSignature.
|
| 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 | |
| IntResult | |
| IOFileSystem | |
| IpcPayload |
\brief Intermediate data structure with metadata header, and zero
or more buffers for the message body.
|
| IpcPayloadWriter | |
| IpcPayloadWriterResult | |
| IpcReadOptions |
\brief Options for reading Arrow IPC messages
|
| IpcWriteOptions |
\brief Options for writing Arrow IPC messages
|
| JsonParseOptions | |
| Kernel |
\brief Base type for kernels.
|
| KernelContext |
\brief Context/state for the execution of a particular kernel.
|
| KernelInitArgs |
\brief Arguments to pass to a KernelInit function.
|
| KernelResult | |
| KernelSignature |
\brief Holds the input types and output type of the kernel.
|
| KernelState |
\brief Base class for opaque kernel-specific state.
|
| KeyValueMetadata |
\brief A container for key-value pair type metadata.
|
| LargeBinaryArray | |
| 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)
|
| LargeListArrayResult | |
| 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 | |
| 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 offsets and null values.
|
| Listener |
\brief A general listener class to receive events.
|
| 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.
|
| LocalFileSystemOptionsResult | |
| LoggingMemoryPool | |
| Long4Array | |
| 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 offsets 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.
|
| MatchSubstringOptions | |
| MemAllocation |
\brief The preference for memory preallocation of fixed-width type outputs
in kernel execution.
|
| MemoryManager | |
| 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 on the CPU.
|
| MemoryPoolStats | |
| Message |
\class Message
\brief An IPC message including metadata and body
|
| MessageDecoder |
\class MessageDecoder
\brief Push style message decoder that receives data from user.
|
| MessageDecoderListener |
\class MessageDecoderListener
\brief An abstract class to listen events from MessageDecoder.
|
| MessageReader |
\brief Abstract interface for a sequence of messages
|
| MessageSharedResult | |
| MessageUniqueResult | |
| MetaFunction |
\brief A function that dispatches to other functions.
|
| MinMaxOptions |
\brief Control MinMax kernel behavior
By default, null values are ignored
|
| MockDirInfo | |
| MockFileInfo | |
| 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.
|
| ModeOptions |
\brief Control Mode kernel behavior
Returns top-n common values and counts.
|
| MonthIntervalArray | |
| MonthIntervalScalar | |
| MonthIntervalType |
\brief Represents a number of months.
|
| MultipleChunkIterator |
\brief EXPERIMENTAL: Utility for incremental iteration over contiguous
pieces of potentially differently-chunked ChunkedArray objects
|
| MutableBuffer |
\}
|
| NestedType | |
| NullArray |
Degenerate null type Array
|
| NullBuilder | |
| NullHandling |
\brief The strategy to use for propagating or otherwise populating the
validity bitmap of a kernel output.
|
| NullScalar |
\defgroup concrete-scalar-classes Concrete Scalar subclasses
\{
|
| NullType |
Concrete type class for always-null data
|
| NumberType |
\brief Base class for all numeric data types
|
| ObjectType |
DEPRECATED.
|
| OutputStream | |
| OutputStreamResult | |
| OutputType |
\brief Container to capture both exact and input-dependent output types.
|
| ParametricType |
\brief Base class for all parametric data types
|
| PartitionNthOptions |
\brief Partitioning options for NthToIndices
|
| PathForest |
\brief A PathForest is a utility to transform a vector of FileInfo 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
|
| PrimitiveScalarBase |
\}
|
| ProjectOptions | |
| 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 | |
| Reader |
\class Reader
\brief An interface for reading columns from Feather files
|
| ReadOptions | |
| ReadRange | |
| ReadRangeCache |
\brief A read cache designed to hide IO latencies when reading.
|
| ReadStats | |
| 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
|
| RecordBatchFileReaderResult | |
| RecordBatchIterator | |
| RecordBatchIterator.RangeIterator | |
| RecordBatchIteratorResult | |
| RecordBatchReader |
\brief Abstract interface for reading stream of record batches
|
| RecordBatchReaderSharedResult | |
| RecordBatchResult | |
| 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.
|
| RecordBatchStreamReaderResult | |
| RecordBatchStreamWriter | |
| RecordBatchVector | |
| RecordBatchVector.Iterator | |
| RecordBatchVectorResult | |
| 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
|
| ResizableResult | |
| ResizableUniqueResult | |
| S3FileSystem | |
| Scalar |
\brief Base class for scalar values
A Scalar represents a single value with a specific DataType.
|
| Scalar.Hash | |
| ScalarAggregateFunction | |
| ScalarAggregateKernel |
\brief Kernel data structure for implementations of
ScalarAggregateFunction.
|
| ScalarAggregateKernelResult | |
| ScalarFunction |
\brief A function that executes elementwise operations on arrays or
scalars, and therefore whose results generally do not depend on the order
of the values in the arguments.
|
| ScalarKernel |
\brief Kernel data structure for implementations of ScalarFunction.
|
| ScalarKernelResult | |
| 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 |
\brief Convenience class to incrementally construct/merge schemas.
|
| SchemaResult | |
| SchemaVector | |
| SchemaVector.Iterator | |
| SchemaVectorResult | |
| Seekable | |
| SelectionVector |
\brief Container for an array of value selection indices that were
materialized from a filter.
|
| SelectionVectorResult | |
| SetLookupOptions |
Options for IsIn and IndexIn functions
|
| SharedExclusiveChecker | |
| SharedExclusiveCheckerExclusiveLockGuard | |
| SharedExclusiveCheckerSharedLockGuard | |
| SimdLevel |
\brief A function may contain multiple variants of a kernel for a given
type combination for different SIMD levels.
|
| 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.
|
| SortKey |
\brief One sort key for PartitionNthIndices (TODO) and SortIndices
|
| SortOptions | |
| SparseTensor | |
| SparseTensorResult | |
| SparseUnionArray |
Concrete Array class for sparse union data
|
| SparseUnionBuilder |
\class SparseUnionBuilder
This API is EXPERIMENTAL.
|
| SparseUnionScalar | |
| SparseUnionType | |
| SplitOptions | |
| SplitPatternOptions | |
| 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.
|
| StreamDecoder |
\brief Push style stream decoder that receives data from user.
|
| StreamingReader |
Experimental
|
| StreamingReaderResult | |
| StringArray | |
| StringBuilder |
\class StringBuilder
\brief Builder class for UTF8 strings
|
| StringDataTypeMap | |
| StringDataTypeMap.Iterator | |
| StringPair | |
| StringPairResult | |
| StringResult | |
| StringScalar | |
| StringStreamWrapper | |
| StringStringMap | |
| StringStringMap.Iterator | |
| StringStringPairVector | |
| StringType |
\brief Concrete type class for variable-size string data, utf8-encoded
|
| StringVector | |
| StringVector.Iterator | |
| StringViewResult | |
| StrptimeOptions | |
| StructArray |
Concrete Array class for struct data
|
| StructArrayResult | |
| StructBuilder |
Append, Resize and Reserve methods are acting on StructBuilder.
|
| StructScalar | |
| StructScalarResult | |
| 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 | |
| TakeOptions | |
| TaskGroup |
\brief A group of related tasks
A TaskGroup executes tasks with the signature
Status(). |
| TaskHints | |
| TemporalType |
\brief Base type for all date and time types
|
| Tensor | |
| TensorResult | |
| ThreadPool | |
| ThreadPool.State | |
| ThreadPoolResult | |
| 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 | |
| TimestampParser | |
| 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
|
| TypeIdTraits | |
| TypeMatcher |
\brief An type-checking interface to permit customizable validation rules
for use with InputType and KernelSignature.
|
| TypeVisitor | |
| UInt16Array | |
| UInt16Builder | |
| UInt16Scalar | |
| UInt16Type | |
| UInt32Array | |
| UInt32Builder | |
| UInt32Scalar | |
| UInt32Type | |
| UInt64Array | |
| UInt64Builder | |
| UInt64Scalar | |
| UInt64Type | |
| UInt8Array | |
| UInt8Builder | |
| UInt8Scalar | |
| UInt8Type | |
| UnionArray |
Base class for SparseUnionArray and DenseUnionArray
|
| UnionMode | |
| UnionScalar | |
| UnionType |
\brief Concrete type class for union data
|
| Uri | |
| ValueDescr |
\brief A descriptor type that gives the shape (array or scalar) and
DataType of a Value, but without the data
|
| ValueDescrResult | |
| ValueDescrVector | |
| ValueDescrVector.Iterator | |
| VarianceOptions |
\brief Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel
The divisor used in calculations is N - ddof, where N is the number of elements.
|
| VectorFunction |
\brief A function that executes general array operations that may yield
outputs of different sizes or have results that depend on the whole array
contents.
|
| VectorKernel |
\brief Kernel data structure for implementations of VectorFunction.
|
| VectorKernelResult | |
| Writable | |
| WritableFile | |
| WriteProperties | |
| WriteStats |
| Enum | Description |
|---|---|
| Compression.type |
\brief Compression algorithm
|
| CountOptions.Mode | |
| DataTypeLayout.BufferKind | |
| Datum.Kind | |
| FileMode.type | |
| FilterIterator.Action | |
| FilterOptions.NullSelectionBehavior |
Configure the action taken when a slot of the selection mask is null
|
| FloatingPointType.Precision | |
| Function.Kind |
\brief The kind of function, which indicates in what contexts it is
valid for use.
|
| FutureWaiter.Kind | |
| InputType.Kind |
\brief The kind of type-checking rule that the InputType contains.
|
| IntervalType.type | |
| MemAllocation.type | |
| MessageDecoder.State |
\brief State for reading a message
|
| MinMaxOptions.Mode | |
| NullHandling.type | |
| ObjectType.type | |
| OutputType.ResolveKind |
\brief An enum indicating whether the value type is an invariant fixed
value or one that's computed by a kernel-defined resolver function.
|
| SchemaBuilder.ConflictPolicy | |
| SimdLevel.type | |
| TimeUnit.type |
The unit for a time or timestamp DataType
|
| UnionMode.type | |
| ValueDescr.Shape |
Copyright © 2021. All rights reserved.