| Package | Description |
|---|---|
| org.bytedeco.arrow | |
| org.bytedeco.arrow.global | |
| org.bytedeco.arrow_dataset | |
| org.bytedeco.arrow_flight | |
| org.bytedeco.gandiva | |
| org.bytedeco.parquet | |
| org.bytedeco.plasma |
| Class and Description |
|---|
| Aggregate
\brief Configure a grouped aggregation
|
| 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.
|
| AssumeTimezoneOptions
Used to control timestamp timezone conversion and handling ambiguous/nonexistent
times.
|
| AssumeTimezoneOptions.Ambiguous
\brief How to interpret ambiguous local times that can be interpreted as
multiple instants (normally two) due to DST shifts.
|
| AssumeTimezoneOptions.Nonexistent
\brief How to handle local times that do not exist due to DST shifts.
|
| AsyncContext |
| AsyncTaskGroup
A utility which keeps track of a collection of asynchronous tasks
This can be used to provide structured concurrency for asynchronous development.
|
| AsyncToggle |
| BackpressureOptions
\brief Options to control backpressure behavior
|
| BaseBaseDate32Scalar |
| BaseBaseDate64Scalar |
| BaseBaseDayTimeIntervalScalar |
| BaseBaseMonthIntervalType |
| BaseBaseTime32Scalar |
| BaseBaseTime64Scalar |
| BaseBinaryBuilder |
| BaseBinaryScalar |
| BaseBinaryType
\}
|
| 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
\}
|
| BaseMonthDayNanoIntervalScalar |
| 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
\addtogroup binary-datatypes
\{
|
| 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 |
| BufferIterator
\brief A generic Iterator that can return errors
|
| BufferIterator.RangeIterator |
| BufferIteratorResult |
| BufferOutputStream
\brief An output stream that writes to a resizable buffer
|
| BufferOutputStreamResult |
| BufferReaderRandomAccessFileConcurrencyWrapper |
| BufferResult |
| BufferUniqueResult |
| BufferVector |
| BufferVector.Iterator |
| BufferVectorResult |
| BuildInfo |
| Byte16Array |
| Byte32Array |
| CacheOptions |
| call_traits
Helper struct for examining lambdas and other callables.
|
| CallbackOptions
\brief Options that control how a continuation is run
|
| 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 |
| Codec
\brief Compression codec
|
| CodecResult |
| CollectListener
\brief Collect schema and record batches decoded by StreamDecoder.
|
| CompareOptions |
| CompressedInputStream |
| CompressedInputStreamConcurrencyWrapper |
| CompressedInputStreamResult |
| CompressedOutputStream |
| CompressedOutputStreamResult |
| Compression |
| Compression.type
\brief Compression algorithm
|
| CompressionTypeResult |
| Compressor
\brief Streaming compressor interface
|
| Compressor.CompressResult |
| Compressor.EndResult |
| Compressor.FlushResult |
| CompressorResult |
| CompressResultResult |
| ConcatenateTablesOptions
\defgroup concat-tables ConcatenateTables function.
|
| Continue
\brief Wait for one of the futures to end, or for the given timeout to expire.
|
| ContinueFuture
Helper that contains information about how to apply a continuation
|
| ConvertOptions |
| CountOptions
\brief Control count aggregate kernel behavior.
|
| CountOptions.CountMode |
| 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.BufferKind |
| 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.Kind |
| DatumResult |
| DatumVector |
| DatumVector.Iterator |
| DatumVectorResult |
| DayOfWeekOptions |
| DayTimeIntervalArray
DayTimeArray
---------------------
\brief Array of Day and Millisecond values.
|
| 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 |
| Decimal128Pair |
| Decimal128PairResult |
| Decimal128Result |
| Decimal128Scalar |
| Decimal128Type
\brief Concrete type class for 128-bit decimal data
Arrow decimals are fixed-point decimal numbers encoded as a scaled
integer.
|
| Decimal256
Represents a signed 256-bit integer in two's complement.
|
| Decimal256Array |
| Decimal256Pair |
| Decimal256PairResult |
| Decimal256Result |
| Decimal256Scalar |
| Decimal256Type
\brief Concrete type class for 256-bit decimal data
Arrow decimals are fixed-point decimal numbers encoded as a scaled
integer.
|
| DecimalType
\}
|
| 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
|
| DenseUnionType
\brief Concrete type class for dense union data
A dense union is a nested type where each logical value is taken from
a single child, at a specific offset.
|
| Device |
| 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.
|
| DictionaryEncodeOptions
\brief Options for the dictionary encode function
|
| DictionaryEncodeOptions.NullEncodingBehavior
Configure how null values will be encoded
|
| 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).
|
| DictionaryScalar
\brief A Scalar value for DictionaryType
is_valid denotes the validity of the index, regardless of
the corresponding value in the dictionary. |
| DictionaryType
\brief Dictionary-encoded value type with data-dependent
/** dictionary.
|
| DictionaryUnifier
\brief Helper class for incremental dictionary unification
|
| DictionaryUnifierResult |
| DictionaryVector |
| DictionaryVectorResult |
| DoubleArray |
| DoubleScalar |
| DoubleType |
| DurationArray |
| DurationScalar |
| DurationType
\brief Represents an elapsed time without any relation to a calendar artifact.
|
| ElementWiseAggregateOptions |
| EndResultResult |
| EqualOptions
A container of options for equality comparisons
|
| ExecBatch
\brief A unit of work for kernel execution.
|
| ExecBatchResult |
| ExecContext
\brief Context for expression-global variables and options used by
function evaluation
|
| ExecNode |
| ExecNodeResult |
| Executor |
| explicit_copy_constructor |
| Expression
An unbound expression which maps a single Datum to another Datum.
|
| Expression.Call |
| Expression.Hash |
| Expression.Parameter |
| ExpressionResult |
| ExtensionArray
\brief Base array class for user-defined extension types
|
| ExtensionScalar
\brief A Scalar value for ExtensionType
The value is the underlying storage scalar.
|
| ExtensionType
\brief The base class for custom / user-defined types.
|
| ExtensionTypeRegistry |
| ExtractRegexOptions |
| 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 |
| FileInfoVector |
| FileInfoVector.Iterator |
| FileInfoVectorFuture |
| FileInfoVectorResult |
| FileInterface |
| FileLocator
\brief FileSystem, path pair
|
| FileMode |
| FileMode.type |
| 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.
|
| FilterIterator.Action |
| FilterOptions
\addtogroup compute-concrete-options
\{
|
| FilterOptions.NullSelectionBehavior
Configure the action taken when a slot of the selection mask is null
|
| Fingerprintable
\defgroup numeric-datatypes Datatypes for numeric data
\{
\}
|
| FixedSizeBinaryArray |
| FixedSizeBinaryBuilder |
| FixedSizeBinaryScalar |
| FixedSizeBinaryType
\brief Concrete type class for fixed-size binary data
|
| FixedSizeListArray
Concrete Array class for fixed size list data
|
| 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 |
| FloatingPointType.Precision |
| FloatScalar |
| FloatType |
| FlushResultResult |
| ForReturnImpl
Helper struct which tells us what kind of Future gets returned from
Then based on
the return type of the OnSuccess callback |
| Function
\brief Base class for compute functions.
|
| Function.Kind
\brief The kind of function, which indicates in what contexts it is
valid for use.
|
| FunctionDoc |
| FunctionOptions
\brief Base class for specifying options configuring a function's behavior,
such as error handling.
|
| FunctionOptionsResult |
| FunctionOptionsType
\defgroup compute-functions Abstract compute function API
\{
|
| FunctionOptionsTypeResult |
| FunctionRegistry
\brief A mutable central function registry for built-in functions as well
as user-defined functions.
|
| FunctionResult |
| Future
\brief EXPERIMENTAL A std::future-like class with more functionality.
|
| FutureWaiter.Kind |
| HadoopFileSystem |
| HalfFloatArray |
| HalfFloatScalar |
| HalfFloatType |
| HashAggregateKernel
\brief Kernel data structure for implementations of
HashAggregateFunction.
|
| HdfsConnectionConfig |
| HdfsOptions
Options for the HDFS implementation.
|
| HDFSOptionsResult |
| HdfsOutputStream |
| HdfsPathInfo |
| HdfsReadableFile |
| IndexOptions
\brief Control Index kernel behavior
|
| InputStream |
| InputStreamFuture |
| InputStreamResult |
| InputStreamSlowInputStreamBase |
| InputType
\brief An object used for type- and shape-checking arguments to be passed
to a kernel and stored in a KernelSignature.
|
| InputType.Kind
\brief The kind of type-checking rule that the InputType contains.
|
| Int16Array |
| Int16Scalar |
| Int16Type |
| Int32Array |
| Int32Scalar |
| Int32Type |
| Int64Array |
| Int64Scalar |
| Int64Type |
| Int8Array
\addtogroup numeric-arrays
\{
|
| Int8Scalar |
| Int8Type |
| IntervalType |
| IntervalType.type |
| IntResult |
| IOContext
EXPERIMENTAL: options provider for IO tasks
Includes an Executor (which will be used to execute asynchronous reads),
a MemoryPool (which will be used to allocate buffers when zero copy reads
are not possible), and an external id (in case the executor receives tasks from
multiple sources and must distinguish tasks associated with this IOContext).
|
| 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
|
| IterationTraits |
| JoinOptions
Options for var_args_join.
|
| JoinOptions.NullHandlingBehavior
How to handle null values.
|
| 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.
|
| KernelStateResult |
| KernelStateVector.Iterator |
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| KeyValueMetadataFuture |
| KeyValueMetadataResult |
| KeyValueMetadataVector |
| KeyValueMetadataVector.Iterator |
| 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 |
| 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 |
| 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 |
| Long2Array |
| Long4Array |
| LongFuture |
| LongOptional |
| LongOptionalFuture |
| LongOptionalResult |
| LongResult |
| MakeStructOptions |
| MapArray
Concrete Array class for map data
NB: "value" in this context refers to a pair of a key and the corresponding item
|
| 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.
|
| MemAllocation.type |
| 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.State
\brief State for reading a message
|
| MessageDecoderListener
\class MessageDecoderListener
\brief An abstract class to listen events from MessageDecoder.
|
| MessageFuture |
| MessageReader
\brief Abstract interface for a sequence of messages
|
| MessageSharedResult |
| MessageUniqueResult |
| MockDirInfo |
| MockFileInfo |
| MockFileSystem
A mock FileSystem implementation that holds its contents in memory.
|
| MockOutputStream
\brief A helper class to track 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.
|
| MonthDayNanoIntervalArray
\brief Array of Month, Day and nanosecond values.
|
| MonthDayNanoIntervalScalar |
| MonthDayNanoIntervalType
\brief Represents a number of months, days and nanoseconds between
two dates.
|
| MonthDayNanoIntervalType.MonthDayNanos |
| MonthIntervalArray |
| MonthIntervalScalar |
| MonthIntervalType
\brief Represents a number of months.
|
| 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.
|
| NullHandling.type |
| NullOptions |
| 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.
|
| ObjectType.type |
| OutputStream |
| OutputStreamResult |
| OutputType
\brief Container to capture both exact and input-dependent output types.
|
| 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.
|
| PadOptions |
| ParametricType
\brief Base class for all parametric data types
|
| PartitionNthOptions
\brief Partitioning options for NthToIndices
|
| PrettyPrintOptions |
| PrimitiveArray
Base class for arrays of fixed-size logical types
|
| PrimitiveCType
\brief Base class for all data types representing primitive values
|
| PrimitiveScalarBase
\}
|
| QuantileOptions
\brief Control Quantile kernel behavior
By default, returns the median value.
|
| QuantileOptions.Interpolation
Interpolation method to use when quantile lies between two data points
|
| RandomAccessFile |
| RandomAccessFileFuture |
| RandomAccessFileResult |
| RandomAccessFileSlowInputStreamBase |
| Readable |
| ReadableFile
\brief An operating system file open in read-only mode.
|
| ReadableFileRandomAccessFileConcurrencyWrapper |
| ReadableFileResult |
| Reader
\class Reader
\brief An interface for reading columns from Feather files
|
| ReadOptions |
| ReadRange |
| 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
|
| RecordBatchEnumerated
\brief Create a generator that takes in a stream of generators and pulls from each
one in sequence.
|
| RecordBatchFileReader
\brief Reads the record batch file format
|
| RecordBatchFileReaderFuture |
| RecordBatchFileReaderResult |
| RecordBatchFuture |
| 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 |
| RecordBatchVector |
| RecordBatchVector.Iterator |
| RecordBatchVectorFuture |
| RecordBatchVectorResult |
| RecordBatchWriter
\class RecordBatchWriter
\brief Abstract interface for writing a stream of record batches
|
| RecordBatchWriterSharedResult |
| RecordBatchWriterUniqueResult |
| ReplaceSliceOptions |
| ReplaceSubstringOptions |
| ResizableBuffer
\class ResizableBuffer
\brief A mutable buffer that can be resized
|
| ResizableResult |
| ResizableUniqueResult |
| RoundOptions |
| RoundToMultipleOptions |
| RuntimeInfo |
| Scalar
\brief Base class for scalar values
A Scalar represents a single value with a specific DataType.
|
| Scalar.Hash |
| ScalarAggregateKernel
\brief Kernel data structure for implementations of
ScalarAggregateFunction.
|
| ScalarAggregateKernelResult |
| ScalarAggregateOptions
\addtogroup compute-concrete-options
\{
|
| 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.
|
| SchemaBuilder.ConflictPolicy |
| SchemaResult |
| SchemaVector |
| SchemaVector.Iterator |
| SchemaVectorResult |
| Seekable |
| SelectionVector
\brief Container for an array of value selection indices that were
materialized from a filter.
|
| SelectionVectorResult |
| SelectKOptions
\brief SelectK options
|
| SerializedAsyncTaskGroup
A task group which serializes asynchronous tasks in a push-based workflow
Tasks will be executed in the order they are added
This will buffer results in an unlimited fashion so it should be combined
with some kind of backpressure
|
| 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.
|
| SimdLevel.type |
| SizeTResult |
| SliceOptions |
| SortKey
\brief One sort key for PartitionNthIndices (TODO) and SortIndices
|
| SortOptions |
| SparseTensor |
| SparseTensorResult |
| SparseUnionArray
Concrete Array class for sparse union data
|
| SparseUnionType
\brief Concrete type class for sparse union data
A sparse union is a nested type where each logical value is taken from
a single child.
|
| 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.
|
| StopSource
EXPERIMENTAL
|
| StopSourceResult |
| StopToken
EXPERIMENTAL
|
| StreamingReader
\brief A class that reads a CSV file incrementally
Caveats:
- For now, this is always single-threaded (regardless of
ReadOptions::use_threads. |
| StreamingReaderFuture |
| StreamingReaderResult |
| StrftimeOptions |
| 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 |
| StructScalar |
| StructScalarResult |
| StructType
\brief Concrete type class for struct data
|
| SyncType |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| TableFuture |
| 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 |
| TDigestOptions
\brief Control TDigest approximate quantile kernel behavior
By default, returns the median value.
|
| TemporalType
\addtogroup temporal-datatypes
/**
/** \{
|
| Tensor |
| TensorResult |
| ThreadPool
An Executor implementation spawning tasks in FIFO manner on a fixed-size
pool of worker threads.
|
| 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 |
| 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 |
| TimeUnit.type
The unit for a time or timestamp DataType
|
| TransformFinish |
| TransformSkip |
| TrimOptions |
| 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 |
| UInt16Scalar |
| UInt16Type |
| UInt32Array |
| UInt32Scalar |
| UInt32Type |
| UInt64Array |
| UInt64Scalar |
| UInt64Type |
| UInt8Array |
| UInt8Scalar |
| UInt8Type |
| UnionArray
Base class for SparseUnionArray and DenseUnionArray
|
| UnionMode |
| UnionMode.type |
| UnionScalar |
| UnionType
\brief Base 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
|
| ValueDescr.Shape |
| 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.
|
| VectorKernel
\brief Kernel data structure for implementations of VectorFunction.
|
| VectorKernelResult |
| WeekOptions |
| Writable |
| WritableFile |
| WriteOptions |
| WriteProperties |
| WriteStats |
| Class and Description |
|---|
| Aggregate
\brief Configure a grouped aggregation
|
| ArithmeticOptions
\addtogroup compute-concrete-options
\{
|
| 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).
|
| ArrayDataResult |
| ArrayDataVector |
| ArrayResult |
| ArraySortOptions |
| ArrayVector |
| ArrayVectorVector |
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| AssumeTimezoneOptions
Used to control timestamp timezone conversion and handling ambiguous/nonexistent
times.
|
| BasicDecimal128
Represents a signed 128-bit integer in two's complement.
|
| BasicDecimal256 |
| BufferIteratorResult |
| BufferOutputStream
\brief An output stream that writes to a resizable buffer
|
| BufferResult |
| BufferUniqueResult |
| BuildInfo |
| 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.
|
| Codec
\brief Compression codec
|
| CompareOptions |
| Compression.type
\brief Compression algorithm
|
| ConcatenateTablesOptions
\defgroup concat-tables ConcatenateTables function.
|
| CountOptions
\brief Control count aggregate kernel behavior.
|
| CsvParseOptions |
| DataType
\brief Base class for all data types
Data types in this library are all *logical*.
|
| DataTypeVector |
| Datum
\class Datum
\brief Variant type for various Arrow C++ data structures
|
| DatumResult |
| DatumVector |
| DatumVectorResult |
| DayOfWeekOptions |
| DayTimeIntervalType.DayMilliseconds |
| DictionaryEncodeOptions
\brief Options for the dictionary encode function
|
| 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).
|
| DictionaryVectorResult |
| ElementWiseAggregateOptions |
| EqualOptions
A container of options for equality comparisons
|
| ExecBatch
\brief A unit of work for kernel execution.
|
| ExecBatchResult |
| ExecContext
\brief Context for expression-global variables and options used by
function evaluation
|
| ExecFactoryRegistry |
| Executor |
| Expression
An unbound expression which maps a single Datum to another Datum.
|
| ExpressionResult |
| ExtensionType
\brief The base class for custom / user-defined types.
|
| 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. |
| FieldRef
\class FieldRef
\brief Descriptor of a (potentially nested) field within a schema.
|
| FieldVector |
| FileInfo
\brief FileSystem entry info
|
| FileInfoVector |
| FileInterface |
| FileLocator
\brief FileSystem, path pair
|
| FileSelector
\brief File selector for filesystem APIs
|
| FileSystem
\brief Abstract file system API
|
| FileSystemGlobalOptions |
| FileSystemResult |
| FilterOptions
\addtogroup compute-concrete-options
\{
|
| FilterOptions.NullSelectionBehavior
Configure the action taken when a slot of the selection mask is null
|
| FixedSizeBinaryType
\brief Concrete type class for fixed-size binary data
|
| FixedWidthType
\brief Base class for all fixed-width data types
|
| Function
\brief Base class for compute functions.
|
| FunctionOptions
\brief Base class for specifying options configuring a function's behavior,
such as error handling.
|
| FunctionRegistry
\brief A mutable central function registry for built-in functions as well
as user-defined functions.
|
| Future
\brief EXPERIMENTAL A std::future-like class with more functionality.
|
| IndexOptions
\brief Control Index kernel behavior
|
| InputStream |
| IntResult |
| IOContext
EXPERIMENTAL: options provider for IO tasks
Includes an Executor (which will be used to execute asynchronous reads),
a MemoryPool (which will be used to allocate buffers when zero copy reads
are not possible), and an external id (in case the executor receives tasks from
multiple sources and must distinguish tasks associated with this IOContext).
|
| 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.
|
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| LongFuture |
| MemoryManager |
| MemoryPool
Base class for memory allocation on the CPU.
|
| Message
\class Message
\brief An IPC message including metadata and body
|
| MessageDecoder
\class MessageDecoder
\brief Push style message decoder that receives data from user.
|
| MessageFuture |
| MessageUniqueResult |
| ModeOptions
\brief Control Mode kernel behavior
Returns top-n common values and counts.
|
| MonthDayNanoIntervalType.MonthDayNanos |
| NullOptions |
| OutputStream |
| PartitionNthOptions
\brief Partitioning options for NthToIndices
|
| PrettyPrintOptions |
| QuantileOptions
\brief Control Quantile kernel behavior
By default, returns the median value.
|
| RandomAccessFile |
| ReadOptions |
| 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
|
| RecordBatchReaderSharedResult |
| RecordBatchResult |
| RecordBatchVector |
| RecordBatchWriterSharedResult |
| RecordBatchWriterUniqueResult |
| ResizableBuffer
\class ResizableBuffer
\brief A mutable buffer that can be resized
|
| ResizableUniqueResult |
| RoundOptions |
| RoundToMultipleOptions |
| RuntimeInfo |
| Scalar
\brief Base class for scalar values
A Scalar represents a single value with a specific DataType.
|
| ScalarAggregateOptions
\addtogroup compute-concrete-options
\{
|
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| SchemaResult |
| SchemaVector |
| SelectKOptions
\brief SelectK options
|
| SetLookupOptions
Options for IsIn and IndexIn functions
|
| SizeTResult |
| SortOptions |
| SparseTensor |
| SparseTensorResult |
| Status
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| StopSourceResult |
| StrftimeOptions |
| StringStringMap |
| StringVector |
| StructArrayResult |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| TableResult |
| TableVector |
| TakeOptions |
| TDigestOptions
\brief Control TDigest approximate quantile kernel behavior
By default, returns the median value.
|
| Tensor |
| TensorResult |
| ThreadPool
An Executor implementation spawning tasks in FIFO manner on a fixed-size
pool of worker threads.
|
| TimeUnit.type
The unit for a time or timestamp DataType
|
| TypeMatcher
\brief An type-checking interface to permit customizable validation rules
for use with InputType and KernelSignature.
|
| ValueDescr.Shape |
| ValueDescrVector |
| 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.
|
| WeekOptions |
| WriteProperties |
| Class and Description |
|---|
| Array
\brief Array base type
Immutable data array with some logical type and some length.
|
| ArrayVector |
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| AsyncToggle |
| BoolResult
A class for representing either a usable value, or an error.
|
| CacheOptions |
| Compression.type
\brief Compression algorithm
|
| ConvertOptions |
| CsvParseOptions |
| ExecNodeOptions |
| Executor |
| Expression
An unbound expression which maps a single Datum to another Datum.
|
| ExpressionResult |
| FileInfo
\brief FileSystem entry info
|
| FileInfoVector |
| FileLocator
\brief FileSystem, path pair
|
| FileSelector
\brief File selector for filesystem APIs
|
| FileSystem
\brief Abstract file system API
|
| Future
\brief EXPERIMENTAL A std::future-like class with more functionality.
|
| InputStreamResult |
| IOContext
EXPERIMENTAL: options provider for IO tasks
Includes an Executor (which will be used to execute asynchronous reads),
a MemoryPool (which will be used to allocate buffers when zero copy reads
are not possible), and an external id (in case the executor receives tasks from
multiple sources and must distinguish tasks associated with this IOContext).
|
| IpcReadOptions
\brief Options for reading Arrow IPC messages
|
| IpcWriteOptions
\brief Options for writing Arrow IPC messages
|
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| LongOptionalFuture |
| LongResult |
| MemoryPool
Base class for memory allocation on the CPU.
|
| OutputStream |
| RandomAccessFile |
| RandomAccessFileResult |
| ReadOptions |
| 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
|
| RecordBatchEnumerated
\brief Create a generator that takes in a stream of generators and pulls from each
one in sequence.
|
| RecordBatchIterator |
| RecordBatchIteratorResult |
| RecordBatchReader
\brief Abstract interface for reading stream of record batches
|
| RecordBatchReaderSharedResult |
| RecordBatchVector |
| RecordBatchVectorFuture |
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| SchemaResult |
| SchemaVectorResult |
| Status
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| StringResult |
| StringVector |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| TableResult |
| TaskGroup
\brief A group of related tasks
A TaskGroup executes tasks with the signature
Status(). |
| TimeUnit.type
The unit for a time or timestamp DataType
|
| WriteOptions |
| Class and Description |
|---|
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| 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).
|
| IpcPayload
\brief Intermediate data structure with metadata header, and zero
or more buffers for the message body.
|
| IpcReadOptions
\brief Options for reading Arrow IPC messages
|
| IpcWriteOptions
\brief Options for writing Arrow IPC messages
|
| 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
|
| RecordBatchReader
\brief Abstract interface for reading stream of record batches
|
| RecordBatchVector |
| RecordBatchWriter
\class RecordBatchWriter
\brief Abstract interface for writing a stream of record batches
|
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| 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.
|
| StopToken
EXPERIMENTAL
|
| StringPairResult |
| StringStringPairVector |
| StringVector |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| Class and Description |
|---|
| ArrayDataVector |
| ArrayVector |
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| BasicDecimal128
Represents a signed 128-bit integer in two's complement.
|
| DataType
\brief Base class for all data types
Data types in this library are all *logical*.
|
| DataTypeVector |
| 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.
|
| FieldVector |
| MemoryPool
Base class for memory allocation on the CPU.
|
| 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
|
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| Status
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| Class and Description |
|---|
| Array
\brief Array base type
Immutable data array with some logical type and some length.
|
| ArrayVector |
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| CacheOptions |
| 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.
|
| Compression.type
\brief Compression algorithm
|
| Future
\brief EXPERIMENTAL A std::future-like class with more functionality.
|
| InputStream |
| IOContext
EXPERIMENTAL: options provider for IO tasks
Includes an Executor (which will be used to execute asynchronous reads),
a MemoryPool (which will be used to allocate buffers when zero copy reads
are not possible), and an external id (in case the executor receives tasks from
multiple sources and must distinguish tasks associated with this IOContext).
|
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| MemoryPool
Base class for memory allocation on the CPU.
|
| OutputStream |
| RandomAccessFile |
| RecordBatchReader
\brief Abstract interface for reading stream of record batches
|
| ResizableBuffer
\class ResizableBuffer
\brief A mutable buffer that can be resized
|
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| Status
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| StringVector |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| TimeUnit.type
The unit for a time or timestamp DataType
|
| Class and Description |
|---|
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| Status
\brief Status outcome object (success or error)
The Status object is an object holding the outcome of an operation.
|
| StringStringMap |
| StringVector |
Copyright © 2022. All rights reserved.