| 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 |
|---|
| 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.
|
| 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 |
| 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.
|
| 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.
|
| ConvertOptions |
| CountOptions
\addtogroup compute-concrete-options
\{
|
| CountOptions.Mode |
| 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 |
| 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
|
| 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
|
| 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
|
| 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).
|
| DictionaryScalar |
| 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.
|
| EndResultResult |
| 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
|
| 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 |
| 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 |
| 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 |
| 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
\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.Kind |
| HadoopFileSystem |
| HalfFloatArray |
| 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.
|
| InputType.Kind
\brief The kind of type-checking rule that the InputType contains.
|
| Int16Array |
| Int16Scalar |
| Int16Type |
| Int32Array |
| Int32Scalar |
| Int32Type |
| Int64Array |
| Int64Scalar |
| Int64Type |
| Int8Array
Concrete Array class for numeric data.
|
| Int8Scalar |
| Int8Type |
| IntervalType |
| IntervalType.type |
| 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 |
| 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 |
| 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
|
| 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.
|
| MessageReader
\brief Abstract interface for a sequence of messages
|
| MessageSharedResult |
| MessageUniqueResult |
| MinMaxOptions
\brief Control MinMax kernel behavior
By default, null values are ignored
|
| MinMaxOptions.Mode |
| MockDirInfo |
| MockFileInfo |
| 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.
|
| 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 |
| 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.
|
| 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 |
| RandomAccessFile |
| RandomAccessFileResult |
| RandomAccessFileSlowInputStreamBase |
| Readable |
| ReadableFile
\brief An operating system file open in read-only mode.
|
| ReadableFileRandomAccessFileConcurrencyWrapper |
| ReadableFileResult |
| ReadaheadPromise |
| 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
|
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| SortKey
\brief One sort key for PartitionNthIndices (TODO) and SortIndices
|
| SortOptions |
| SparseTensor |
| SparseTensorResult |
| SparseUnionArray
Concrete Array class for sparse union data
|
| 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.
|
| 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 |
| StructScalar |
| StructScalarResult |
| StructType
\brief Concrete type class for struct data
|
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| 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 |
| 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
|
| 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 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
|
| 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 |
| Writable |
| WritableFile |
| WriteProperties |
| WriteStats |
| Class and Description |
|---|
| 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 |
| ArrayVector |
| ArrayVectorVector |
| 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.
|
| 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.
|
| ChunkedArrayResult |
| Codec
\brief Compression codec
|
| CompareOptions |
| Compression.type
\brief Compression algorithm
|
| ConcatenateTablesOptions
\defgroup concat-tables ConcatenateTables function.
|
| CountOptions
\addtogroup compute-concrete-options
\{
|
| DataType
\brief Base class for all data types
Data types in this library are all *logical*.
|
| Datum
\class Datum
\brief Variant type for various Arrow C++ data structures
|
| DatumResult |
| DatumVector |
| 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 |
| EqualOptions
A container of options for equality comparisons
|
| ExecContext
\brief Context for expression-global variables and options used by
function evaluation
|
| 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.
|
| FieldRefDatumMap |
| FieldRefDatumMapResult |
| FieldVector |
| FileInfo
\brief FileSystem entry info
|
| 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
|
| 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.
|
| InputStream |
| 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 |
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| ListArray
Concrete Array class for list data
|
| ListArrayResult |
| 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.
|
| MessageUniqueResult |
| ModeOptions
\brief Control Mode kernel behavior
Returns top-n common values and counts.
|
| OutputStream |
| PathForest
\brief A PathForest is a utility to transform a vector of FileInfo into a
forest representation for tree traversal purposes.
|
| PrettyPrintOptions |
| RandomAccessFile |
| 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
|
| RecordBatchResult |
| RecordBatchVector |
| RecordBatchVectorResult |
| RecordBatchWriterSharedResult |
| RecordBatchWriterUniqueResult |
| ResizableBuffer
\class ResizableBuffer
\brief A mutable buffer that can be resized
|
| ResizableUniqueResult |
| Scalar
\brief Base class for scalar values
A Scalar represents a single value with a specific DataType.
|
| Schema
\class Schema
\brief Sequence of arrow::Field objects describing the columns of a record
batch or table data structure
|
| SchemaResult |
| SchemaVector |
| 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.
|
| StringStringMap |
| StringVector |
| StructArray
Concrete Array class for struct data
|
| StructArrayResult |
| Table
\class Table
\brief Logical table as sequence of chunked arrays
|
| TableResult |
| TableVector |
| TakeOptions |
| Tensor |
| TensorResult |
| ThreadPool |
| 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.
|
| UnionMode.type |
| 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.
|
| WriteProperties |
| Class and Description |
|---|
| ArrayVector |
| ArrowBuffer
\class Buffer
\brief Object containing a pointer to a piece of contiguous memory with a
particular size.
|
| BoolResult
A class for representing either a usable value, or an error.
|
| Compression.type
\brief Compression algorithm
|
| CsvParseOptions |
| Datum
\class Datum
\brief Variant type for various Arrow C++ data structures
|
| ExecContext
\brief Context for expression-global variables and options used by
function evaluation
|
| FieldRef
\class FieldRef
\brief Descriptor of a (potentially nested) field within a schema.
|
| FileInfo
\brief FileSystem entry info
|
| FileSelector
\brief File selector for filesystem APIs
|
| FileSystem
\brief Abstract file system API
|
| Function
\brief Base class for compute functions.
|
| FunctionOptions
\defgroup compute-functions Abstract compute function API
\{
|
| IpcWriteOptions
\brief Options for writing Arrow IPC messages
|
| Kernel
\brief Base type for kernels.
|
| KernelState
\brief Base class for opaque kernel-specific state.
|
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| MemoryPool
Base class for memory allocation on the CPU.
|
| OutputStream |
| RandomAccessFile |
| RandomAccessFileResult |
| 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
|
| RecordBatchIterator |
| RecordBatchIteratorResult |
| RecordBatchReader
\brief Abstract interface for reading stream of record batches
|
| RecordBatchResult |
| RecordBatchVector |
| Scalar
\brief Base class for scalar values
A Scalar represents a single value with a specific DataType.
|
| 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(). |
| ValueDescr
\brief A descriptor type that gives the shape (array or scalar) and
DataType of a Value, but without the data
|
| 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.
|
| 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.
|
| AsyncContext |
| BufferResult |
| 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
|
| FileInterface |
| InputStream |
| KeyValueMetadata
\brief A container for key-value pair type metadata.
|
| LongResult |
| 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 © 2021. All rights reserved.