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