arrow (JavaCPP Presets for Arrow 0.16.0-1.5.3 API)

java.lang.Object
- org.bytedeco.arrow.presets.arrow
- - org.bytedeco.arrow.global.arrow

All Implemented Interfaces:

InfoMapper
```
public class arrow
extends arrow
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`arrow.CompareOperator`
`static class`	`arrow.DateUnit` Concrete type class for 64-bit floating-point data (C "double")
`static class`	`arrow.DecimalStatus`
`static class`	`arrow.FileType` \brief FileSystem entry type
`static class`	`arrow.HdfsDriver`
`static class`	`arrow.MetadataVersion`
`static class`	`arrow.StatusCode` \brief Propagate any non-successful Status to the caller
`static class`	`arrow.UnexpectedFieldBehavior`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ARROW_BITNESS`
`static String`	`ARROW_FULL_SO_VERSION`
`static int`	`ARROW_LITTLE_ENDIAN`
`static String`	`ARROW_SO_VERSION`
`static int`	`ARROW_VERSION`
`static int`	`ARROW_VERSION_MAJOR` \brief Top-level namespace for Apache Arrow C++ API
`static int`	`ARROW_VERSION_MINOR`
`static int`	`ARROW_VERSION_PATCH`
`static double`	`kDefaultAbsoluteTolerance`
`static int`	`kFeatherVersion`
`static long`	`kNoSize`

Constructor Summary

Constructors
Constructor and Description

arrow()

Constructors
Constructor and Description
`arrow()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static DataType`	`_boolean()` \brief Return a BooleanType instance
`static DataType`	`_null()` \defgroup type-factories Factory functions for creating data types Factory functions for creating data types \{
`static BasicDecimal128`	`add(BasicDecimal128 left, BasicDecimal128 right)`
`static Status`	`AlignStream(InputStream stream)`
`static Status`	`AlignStream(InputStream stream, int alignment)` \brief Advance stream to an 8-byte offset if its position is not a multiple of 8 already
`static Status`	`AlignStream(OutputStream stream)`
`static Status`	`AlignStream(OutputStream stream, int alignment)` \brief Advance stream to an 8-byte offset if its position is not a multiple of 8 already
`static Status`	`AllocateBitmap(MemoryPool pool, long length, ArrowBuffer out)` \brief Allocate a bitmap buffer from a memory pool no guarantee on values is provided.
`static Status`	`AllocateBuffer(long size, ArrowBuffer out)` \brief Allocate a fixed-size mutable buffer from the default memory pool
`static Status`	`AllocateBuffer(MemoryPool pool, long size, ArrowBuffer out)` \defgroup buffer-allocation-functions Functions for allocating buffers \{
`static Status`	`AllocateEmptyBitmap(long length, ArrowBuffer out)` \brief Allocate a zero-initialized bitmap buffer from the default memory pool
`static Status`	`AllocateEmptyBitmap(MemoryPool pool, long length, ArrowBuffer out)` \brief Allocate a zero-initialized bitmap buffer from a memory pool
`static Status`	`AllocateResizableBuffer(long size, ResizableBuffer out)` \brief Allocate a resizeable buffer from the default memory pool
`static Status`	`AllocateResizableBuffer(MemoryPool pool, long size, ResizableBuffer out)` \brief Allocate a resizeable buffer from a memory pool, zero its padding.
`static Status`	`And(FunctionContext context, Datum left, Datum right, Datum out)` \brief Element-wise AND of two boolean datums which always propagates nulls (null and false is null).
`static boolean`	`ArrayApproxEquals(Array left, Array right)`
`static boolean`	`ArrayApproxEquals(Array left, Array right, EqualOptions arg2)` Returns true if the arrays are approximately equal.
`static boolean`	`ArrayEquals(Array left, Array right)`
`static boolean`	`ArrayEquals(Array left, Array right, EqualOptions arg2)` Returns true if the arrays are exactly equal
`static Status`	`ArrayFromJSON(DataType arg0, BytePointer json, Array out)`
`static Status`	`ArrayFromJSON(DataType arg0, String json, Array out)` \class TableReader \brief An interface for reading columns from Feather files
`static boolean`	`ArrayRangeEquals(Array left, Array right, long start_idx, long end_idx, long other_start_idx)` Returns true if indicated equal-length segment of arrays is exactly equal
`static int`	`ARROW_BITNESS()`
`static int`	`ARROW_LITTLE_ENDIAN()` \brief Readahead iterator that iterates on the underlying iterator in a separate thread, getting up to N values in advance.
`static DataType`	`binary()` \brief Return a BinaryType instance
`static BufferResult`	`BitmapAllButOne(MemoryPool pool, long length, long straggler_pos)`
`static BufferResult`	`BitmapAllButOne(MemoryPool pool, long length, long straggler_pos, boolean value)` \brief Generate Bitmap with all position to `value` except for one found at `straggler_pos`.
`static void`	`BitmapAnd(byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset, byte[] out)`
`static void`	`BitmapAnd(ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset, ByteBuffer out)`
`static void`	`BitmapAnd(BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset, BytePointer out)` \brief Do a "bitmap and" on right and left buffers starting at their respective bit-offsets for the given bit-length and put the results in out starting at the given bit-offset.
`static BufferResult`	`BitmapAnd(MemoryPool pool, byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapAnd(MemoryPool pool, ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapAnd(MemoryPool pool, BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset)` \brief Do a "bitmap and" on right and left buffers starting at their respective bit-offsets for the given bit-length and put the results in out_buffer starting at the given bit-offset.
`static boolean`	`BitmapEquals(byte[] left, long left_offset, byte[] right, long right_offset, long bit_length)`
`static boolean`	`BitmapEquals(ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long bit_length)`
`static boolean`	`BitmapEquals(BytePointer left, long left_offset, BytePointer right, long right_offset, long bit_length)`
`static void`	`BitmapOr(byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset, byte[] out)`
`static void`	`BitmapOr(ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset, ByteBuffer out)`
`static void`	`BitmapOr(BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset, BytePointer out)` \brief Do a "bitmap or" for the given bit length on right and left buffers starting at their respective bit-offsets and put the results in out starting at the given bit-offset.
`static BufferResult`	`BitmapOr(MemoryPool pool, byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapOr(MemoryPool pool, ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapOr(MemoryPool pool, BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset)` \brief Do a "bitmap or" for the given bit length on right and left buffers starting at their respective bit-offsets and put the results in out_buffer starting at the given bit-offset.
`static void`	`BitmapXor(byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset, byte[] out)`
`static void`	`BitmapXor(ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset, ByteBuffer out)`
`static void`	`BitmapXor(BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset, BytePointer out)` \brief Do a "bitmap xor" for the given bit-length on right and left buffers starting at their respective bit-offsets and put the results in out starting at the given bit offset.
`static BufferResult`	`BitmapXor(MemoryPool pool, byte[] left, long left_offset, byte[] right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapXor(MemoryPool pool, ByteBuffer left, long left_offset, ByteBuffer right, long right_offset, long length, long out_offset)`
`static BufferResult`	`BitmapXor(MemoryPool pool, BytePointer left, long left_offset, BytePointer right, long right_offset, long length, long out_offset)` \brief Do a "bitmap xor" for the given bit-length on right and left buffers starting at their respective bit-offsets and put the results in out_buffer starting at the given bit offset.
`static long`	`BytesForBits(long bits)`
`static BufferResult`	`BytesToBits(byte[] arg0)`
`static BufferResult`	`BytesToBits(byte[] arg0, MemoryPool pool)`
`static BufferResult`	`BytesToBits(ByteBuffer arg0)`
`static BufferResult`	`BytesToBits(ByteBuffer arg0, MemoryPool pool)`
`static BufferResult`	`BytesToBits(BytePointer arg0)`
`static BufferResult`	`BytesToBits(BytePointer arg0, MemoryPool pool)` \brief Convert vector of bytes to bitmap buffer
`static int`	`ByteSwap(int value)`
`static long`	`ByteSwap(long value)`
`static void`	`ByteSwap(Pointer dst, Pointer src, int len)`
`static short`	`ByteSwap(short value)`
`static Status`	`Cast(FunctionContext context, Array value, DataType to_type, CastOptions options, Array out)` \brief Cast from one array type to another
`static Status`	`Cast(FunctionContext context, Datum value, DataType to_type, CastOptions options, Datum out)` \brief Cast from one value to another
`static long`	`CeilDiv(long value, long divisor)`
`static Status`	`CheckAligned(FileInterface stream)`
`static Status`	`CheckAligned(FileInterface stream, int alignment)` \brief Return error Status if file position is not a multiple of the indicated alignment
`static Status`	`CheckBufferLength()`
`static Status`	`CheckBufferLength(FixedSizeBinaryType t, ArrowBuffer b)`
`static void`	`ClearBit(byte[] bits, long i)`
`static void`	`ClearBit(ByteBuffer bits, long i)`
`static void`	`ClearBit(BytePointer bits, long i)`
`static Status`	`CollectDictionaries(RecordBatch batch, DictionaryMemo memo)`
`static boolean`	`CollectionEquals(DatumVector left, DatumVector right)` \brief convert an Array produced by BlockParser into an Array of out_type
`static Status`	`Compare(FunctionContext context, Datum left, Datum right, CompareOptions options, Datum out)` \brief Compare a numeric array with a scalar.
`static Status`	`Concatenate(ArrayVector arrays, MemoryPool pool, Array out)` \brief Concatenate arrays
`static Status`	`ConcatenateBuffers(ArrowBufferVector buffers, MemoryPool pool, ArrowBuffer out)` \brief Concatenate multiple buffers into a single buffer
`static TableResult`	`ConcatenateTables(TableVector tables)`
`static TableResult`	`ConcatenateTables(TableVector tables, ConcatenateTablesOptions options, MemoryPool memory_pool)` \brief Construct table from multiple input tables.
`static void`	`CopyBitmap(byte[] bitmap, long offset, long length, byte[] dest, long dest_offset)`
`static void`	`CopyBitmap(byte[] bitmap, long offset, long length, byte[] dest, long dest_offset, boolean restore_trailing_bits)`
`static void`	`CopyBitmap(ByteBuffer bitmap, long offset, long length, ByteBuffer dest, long dest_offset)`
`static void`	`CopyBitmap(ByteBuffer bitmap, long offset, long length, ByteBuffer dest, long dest_offset, boolean restore_trailing_bits)`
`static void`	`CopyBitmap(BytePointer bitmap, long offset, long length, BytePointer dest, long dest_offset)`
`static void`	`CopyBitmap(BytePointer bitmap, long offset, long length, BytePointer dest, long dest_offset, boolean restore_trailing_bits)` Copy a bit range of an existing bitmap into an existing bitmap
`static BufferResult`	`CopyBitmap(MemoryPool pool, byte[] bitmap, long offset, long length)`
`static BufferResult`	`CopyBitmap(MemoryPool pool, ByteBuffer bitmap, long offset, long length)`
`static BufferResult`	`CopyBitmap(MemoryPool pool, BytePointer bitmap, long offset, long length)` Copy a bit range of an existing bitmap
`static Status`	`Count(FunctionContext context, CountOptions options, Array array, Datum out)` \brief Count non-null (or null) values in an array.
`static Status`	`Count(FunctionContext context, CountOptions options, Datum datum, Datum out)` \brief Count non-null (or null) values in an array.
`static int`	`CountLeadingZeros(int value)` \brief Count the number of leading zeros in an unsigned integer.
`static int`	`CountLeadingZeros(long value)`
`static long`	`CountSetBits(byte[] data, long bit_offset, long length)`
`static long`	`CountSetBits(ByteBuffer data, long bit_offset, long length)`
`static long`	`CountSetBits(BytePointer data, long bit_offset, long length)` Compute the number of 1's in the given data array
`static int`	`CountTrailingZeros(int value)`
`static int`	`CountTrailingZeros(long value)`
`static long`	`CoveringBytes(long offset, long length)`
`static DataType`	`date32()` \brief Return a Date32Type instance
`static DataType`	`date64()` \brief Return a Date64Type instance
`static DataType`	`day_time_interval()` \brief Return a DayTimeIntervalType instance
`static Status`	`DebugPrint(Array arr, int indent)`
`static DataType`	`decimal(int precision, int scale)` \brief Create a Decimal128Type instance
`static MemoryPool`	`default_memory_pool()` \}
`static DataType`	`dictionary(DataType index_type, DataType dict_type)`
`static DataType`	`dictionary(DataType index_type, DataType dict_type, boolean ordered)` \brief Create a DictionaryType instance
`static Status`	`DictionaryEncode(FunctionContext context, Datum data, Datum out)` \brief Dictionary-encode values in an array-like object
`static void`	`DieWithMessage(BytePointer msg)`
`static void`	`DieWithMessage(String msg)`
`static BasicDecimal128`	`divide(BasicDecimal128 left, BasicDecimal128 right)`
`static DataType`	`duration(int unit)`
`static DataType`	`duration(TimeUnit.type unit)` \brief Return a Duration instance (naming use _type to avoid namespace conflict with built in time clases).
`static boolean`	`equals(BasicDecimal128 left, BasicDecimal128 right)`
`static Field`	`field(BytePointer name, DataType type)`
`static Field`	`field(BytePointer name, DataType type, boolean nullable, KeyValueMetadata metadata)`
`static Field`	`field(String name, DataType type)`
`static Field`	`field(String name, DataType type, boolean nullable, KeyValueMetadata metadata)` \}
`static Status`	`Filter(FunctionContext ctx, Array values, Array filter, Array out)` \brief Filter an array with a boolean selection filter The output array will be populated with values from the input at positions where the selection filter is not 0.
`static Status`	`Filter(FunctionContext ctx, ChunkedArray values, Array filter, ChunkedArray out)` \brief Filter a chunked array with a boolean selection filter The output chunked array will be populated with values from the input at positions where the selection filter is not 0.
`static Status`	`Filter(FunctionContext ctx, ChunkedArray values, ChunkedArray filter, ChunkedArray out)` \brief Filter a chunked array with a boolean selection filter The output chunked array will be populated with values from the input at positions where the selection filter is not 0.
`static Status`	`Filter(FunctionContext ctx, Datum values, Datum filter, Datum out)` \brief Filter an array with a boolean selection filter
`static Status`	`Filter(FunctionContext ctx, RecordBatch batch, Array filter, RecordBatch out)` \brief Filter a record batch with a boolean selection filter The output record batch's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0.
`static Status`	`Filter(FunctionContext ctx, Table table, Array filter, Table out)` \brief Filter a table with a boolean selection filter The output table's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0.
`static Status`	`Filter(FunctionContext ctx, Table table, ChunkedArray filter, Table out)` \brief Filter a table with a boolean selection filter The output record batch's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0.
`static DataType`	`fixed_size_binary(int byte_width)` \addtogroup type-factories \{
`static DataType`	`fixed_size_list(DataType value_type, int list_size)` \brief Create a FixedSizeListType instance from its child DataType
`static DataType`	`fixed_size_list(Field value_type, int list_size)` \brief Create a FixedSizeListType instance from its child Field type
`static DataType`	`float16()` \brief Return a HalfFloatType instance
`static DataType`	`float32()` \brief Return a FloatType instance
`static DataType`	`float64()` \brief Return a DoubleType instance
`static BytePointer`	`FormatMessageType(int type)`
`static String`	`FormatMessageType(Message.Type type)`
`static Status`	`FuzzIpcFile(byte[] data, long size)`
`static Status`	`FuzzIpcFile(ByteBuffer data, long size)`
`static Status`	`FuzzIpcFile(BytePointer data, long size)`
`static Status`	`FuzzIpcStream(byte[] data, long size)`
`static Status`	`FuzzIpcStream(ByteBuffer data, long size)`
`static Status`	`FuzzIpcStream(BytePointer data, long size)`
`static Status`	`GenericToStatus(Status st)` \endcond
`static boolean`	`GetBit(byte[] bits, long i)`
`static boolean`	`GetBit(ByteBuffer bits, long i)`
`static boolean`	`GetBit(BytePointer bits, long i)`
`static boolean`	`GetBitFromByte(byte _byte, byte i)`
`static Status`	`GetCastFunction(DataType in_type, DataType to_type, CastOptions options, UnaryKernel kernel)`
`static Status`	`GetDictionaryPayload(long id, Array dictionary, IpcOptions options, MemoryPool pool, IpcPayload payload)` \brief Compute IpcPayload for a dictionary
`static ExtensionType`	`GetExtensionType(BytePointer type_name)`
`static ExtensionType`	`GetExtensionType(String type_name)` \brief Retrieve an extension type from the global registry.
`static Status`	`GetRecordBatchPayload(RecordBatch batch, IpcOptions options, MemoryPool pool, IpcPayload out)` \brief Compute IpcPayload for the given record batch
`static Status`	`GetRecordBatchSize(RecordBatch batch, long[] size)`
`static Status`	`GetRecordBatchSize(RecordBatch batch, LongBuffer size)`
`static Status`	`GetRecordBatchSize(RecordBatch batch, LongPointer size)` \brief Compute the number of bytes needed to write a record batch including metadata
`static Status`	`GetSchemaPayload(Schema schema, IpcOptions options, DictionaryMemo dictionary_memo, IpcPayload out)` \brief Compute IpcPayload for the given schema
`static Status`	`GetSparseTensorMessage(SparseTensor sparse_tensor, MemoryPool pool, Message out)` \brief EXPERIMENTAL: Convert arrow::SparseTensor to a Message with minimal memory allocation The message is written out as followed:
`static Status`	`GetSparseTensorPayload(SparseTensor sparse_tensor, MemoryPool pool, IpcPayload out)` \brief Compute IpcPayload for the given sparse tensor
`static Status`	`GetTensorMessage(Tensor tensor, MemoryPool pool, Message out)` \brief EXPERIMENTAL: Convert arrow::Tensor to a Message with minimal memory allocation
`static Status`	`GetTensorSize(Tensor tensor, long[] size)`
`static Status`	`GetTensorSize(Tensor tensor, LongBuffer size)`
`static Status`	`GetTensorSize(Tensor tensor, LongPointer size)` \brief Compute the number of bytes needed to write a tensor including metadata
`static boolean`	`greaterThan(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`greaterThanEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static Status`	`HaveLibHdfs()`
`static Status`	`HaveLibHdfs3()`
`static DataType`	`int16()` \brief Return a Int16Type instance
`static DataType`	`int32()` \brief Return a Int32Type instance
`static DataType`	`int64()` \brief Return a Int64Type instance
`static DataType`	`int8()` \brief Return a Int8Type instance
`static Status`	`Invert(FunctionContext context, Datum value, Datum out)` \brief Invert the values of a boolean datum
`static boolean`	`is_base_binary_like(int type_id)`
`static boolean`	`is_binary_like(int type_id)`
`static boolean`	`is_dictionary(int type_id)`
`static boolean`	`is_fixed_size_binary(int type_id)`
`static boolean`	`is_fixed_width(int type_id)`
`static boolean`	`is_floating(int type_id)`
`static boolean`	`is_integer(int type_id)`
`static boolean`	`is_large_binary_like(int type_id)`
`static boolean`	`is_primitive(int type_id)`
`static boolean`	`is_tensor_supported(int type_id)`
`static Status`	`IsIn(FunctionContext context, Datum left, Datum right, Datum out)` \brief IsIn returns boolean values if the value is in both left and right arrays.
`static boolean`	`IsMultipleOf64(long n)`
`static boolean`	`IsMultipleOf8(long n)`
`static boolean`	`IsPowerOf2(long value)`
`static boolean`	`IsTensorStridesContiguous(DataType type, long[] shape, long[] strides)`
`static boolean`	`IsTensorStridesContiguous(DataType type, LongBuffer shape, LongBuffer strides)`
`static boolean`	`IsTensorStridesContiguous(DataType type, LongPointer shape, LongPointer strides)`
`static Status`	`jemalloc_memory_pool(MemoryPool out)`
`static Status`	`jemalloc_memory_pool(PointerPointer out)` Return a process-wide memory pool based on jemalloc.
`static Status`	`jemalloc_set_decay_ms(int ms)` \brief Set jemalloc memory page purging behavior for future-created arenas to the indicated number of milliseconds.
`static long`	`kBinaryMemoryLimit()`
`static BytePointer`	`kBitmask()`
`static byte`	`kBitmask(int i)`
`static BytePointer`	`kBytePopcount()`
`static byte`	`kBytePopcount(int i)`
`static int`	`kCountsFieldIndex()`
`static String`	`kCountsFieldName()`
`static byte`	`kCountsFieldName(int i)`
`static double`	`kDefaultAbsoluteTolerance()` \brief A BufferBuilder for building a buffer of arithmetic elements
`static byte`	`kDefaultEscapeChar()`
`static String`	`kExtensionMetadataKeyName()`
`static byte`	`kExtensionMetadataKeyName(int i)`
`static String`	`kExtensionTypeKeyName()`
`static byte`	`kExtensionTypeKeyName(int i)`
`static KeyValueMetadata`	`key_value_metadata(StringStringMap pairs)` \brief Create a KeyValueMetadata instance
`static KeyValueMetadata`	`key_value_metadata(StringVector keys, StringVector values)` \brief Create a KeyValueMetadata instance
`static int`	`kFeatherVersion()`
`static BytePointer`	`kFlippedBitmask()`
`static byte`	`kFlippedBitmask(int i)`
`static Status`	`KleeneAnd(FunctionContext context, Datum left, Datum right, Datum out)` \brief Element-wise AND of two boolean datums with a Kleene truth table (null and false is false).
`static Status`	`KleeneOr(FunctionContext context, Datum left, Datum right, Datum out)` \brief Element-wise OR of two boolean datums with a Kleene truth table (null or true is true).
`static long`	`kListMaximumElements()`
`static int`	`kMaxNestingDepth()`
`static long`	`kMinBuilderCapacity()`
`static long`	`kNoSize()`
`static Pointer`	`kNoTime()`
`static BytePointer`	`kPrecedingBitmask()`
`static byte`	`kPrecedingBitmask(int i)`
`static BytePointer`	`kPrecedingWrappingBitmask()`
`static byte`	`kPrecedingWrappingBitmask(int i)`
`static BytePointer`	`kTrailingBitmask()`
`static byte`	`kTrailingBitmask(int i)`
`static long`	`kUnknownLength()`
`static long`	`kUnknownNullCount()`
`static int`	`kUseDefaultCompressionLevel()` \brief is_null_pointer from C++17
`static int`	`kValuesFieldIndex()`
`static String`	`kValuesFieldName()`
`static byte`	`kValuesFieldName(int i)`
`static DataType`	`large_binary()` \brief Return a LargeBinaryType instance
`static DataType`	`large_list(DataType value_type)` \brief Create a LargeListType instance from its child DataType
`static DataType`	`large_list(Field value_type)` \brief Create a LargeListType instance from its child Field type
`static DataType`	`large_utf8()` \brief Return a LargeStringType instance
`static boolean`	`lessThan(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`lessThanEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static DataType`	`list(DataType value_type)` \brief Create a ListType instance from its child DataType
`static DataType`	`list(Field value_type)` \brief Create a ListType instance from its child Field type
`static int`	`Log2(long x)`
`static Array`	`MakeArray(ArrayData data)` \brief Create a strongly-typed Array instance from generic ArrayData
`static Status`	`MakeArrayFromScalar(MemoryPool pool, Scalar scalar, long length, Array out)` \brief Create a strongly-typed Array instance with all elements null
`static Status`	`MakeArrayFromScalar(Scalar scalar, long length, Array out)` \brief Create an Array instance whose slots are the given scalar
`static Status`	`MakeArrayOfNull(DataType type, long length, Array out)` \brief Create a strongly-typed Array instance with all elements null
`static Status`	`MakeArrayOfNull(MemoryPool pool, DataType type, long length, Array out)` \brief Create a strongly-typed Array instance with all elements null
`static Status`	`MakeBuilder(MemoryPool pool, DataType type, ArrayBuilder out)` \brief Construct an empty ArrayBuilder corresponding to the data type
`static Status`	`MakeDictionaryBuilder(MemoryPool pool, DataType type, Array dictionary, ArrayBuilder out)` \brief Construct an empty DictionaryBuilder initialized optionally with a pre-existing dictionary
`static BufferIteratorResult`	`MakeInputStreamIterator(InputStream stream, long block_size)` \brief Return an iterator on an input stream The iterator yields a fixed-size block on each Next() call, except the last block in the stream which may be smaller.
`static AggregateFunction`	`MakeMeanAggregateFunction(DataType type, FunctionContext context)`
`static Scalar`	`MakeNullScalar(DataType type)`
`static Status`	`MakeRecordBatchReader(RecordBatchVector batches, Schema schema, RecordBatchReader out)` \brief Create a RecordBatchReader from a vector of RecordBatch.
`static Scalar`	`MakeScalar(BytePointer value)`
`static Scalar`	`MakeScalar(String value)` \brief type inferring scalar factory
`static AggregateFunction`	`MakeSumAggregateFunction(DataType type, FunctionContext context)` \brief Return a Sum Kernel
`static DataType`	`map(DataType key_type, DataType value_type)`
`static DataType`	`map(DataType key_type, DataType value_type, boolean keys_sorted)` \brief Create a MapType instance from its key and value DataTypes
`static Status`	`Mean(FunctionContext context, Array array, Datum mean)` \brief Compute the mean of a numeric array.
`static Status`	`Mean(FunctionContext context, Datum value, Datum mean)` \brief Compute the mean of a numeric array.
`static Status`	`mimalloc_memory_pool(MemoryPool out)`
`static Status`	`mimalloc_memory_pool(PointerPointer out)` Return a process-wide memory pool based on mimalloc.
`static BasicDecimal128`	`mod(BasicDecimal128 left, BasicDecimal128 right)`
`static DataType`	`month_interval()` \brief Return a MonthIntervalType instance
`static BasicDecimal128`	`multiply(BasicDecimal128 left, BasicDecimal128 right)`
`static long`	`NextPower2(long n)`
`static BasicDecimal128`	`not(BasicDecimal128 operand)`
`static boolean`	`notEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static int`	`NumRequiredBits(long x)`
`static RecordBatchWriterUniqueResult`	`OpenRecordBatchWriter(IpcPayloadWriter sink, Schema schema, IpcOptions options)` Create a new RecordBatchWriter from IpcPayloadWriter and schema.
`static Status`	`OpenRecordBatchWriter(IpcPayloadWriter sink, Schema schema, RecordBatchWriter out)` Create a new RecordBatchWriter from IpcPayloadWriter and schema.
`static Status`	`Or(FunctionContext context, Datum left, Datum right, Datum out)` \brief Element-wise OR of two boolean datums which always propagates nulls (null and true is null).
`static Status`	`ParseOne(JsonParseOptions options, ArrowBuffer json, RecordBatch out)` A class that reads an entire JSON file into a Arrow Table The file is expected to consist of individual line-separated JSON objects
`static Status`	`PrettyPrint(Array arr, int indent, Pointer sink)` \brief Print human-readable representation of Array
`static Status`	`PrettyPrint(Array arr, PrettyPrintOptions options, BytePointer result)` \brief Print human-readable representation of Array
`static Status`	`PrettyPrint(Array arr, PrettyPrintOptions options, Pointer sink)` \brief Print human-readable representation of Array
`static Status`	`PrettyPrint(ChunkedArray chunked_arr, PrettyPrintOptions options, BytePointer result)` \brief Print human-readable representation of ChunkedArray
`static Status`	`PrettyPrint(ChunkedArray chunked_arr, PrettyPrintOptions options, Pointer sink)` \brief Print human-readable representation of ChunkedArray
`static Status`	`PrettyPrint(RecordBatch batch, int indent, Pointer sink)` \brief Print human-readable representation of RecordBatch
`static Status`	`PrettyPrint(RecordBatch batch, PrettyPrintOptions options, Pointer sink)`
`static Status`	`PrettyPrint(Schema schema, PrettyPrintOptions options, BytePointer result)`
`static Status`	`PrettyPrint(Schema schema, PrettyPrintOptions options, Pointer sink)`
`static Status`	`PrettyPrint(Table table, PrettyPrintOptions options, Pointer sink)` \brief Print human-readable representation of Table
`static TableResult`	`PromoteTableToSchema(Table table, Schema schema)`
`static TableResult`	`PromoteTableToSchema(Table table, Schema schema, MemoryPool pool)` \brief Promotes a table to conform to the given schema.
`static Status`	`ReadMessage(InputStream stream, Message message)` \brief Read encapsulated IPC message (metadata and body) from InputStream Returns null if there are not enough bytes available or the message length is 0 (e.g.
`static Status`	`ReadMessage(long offset, int metadata_length, RandomAccessFile file, Message message)` \brief Read encapsulated RPC message from position in file Read a length-prefixed message flatbuffer starting at the indicated file offset.
`static Status`	`ReadMessageCopy(InputStream stream, MemoryPool pool, Message message)` \brief Read encapsulated IPC message (metadata and body) from InputStream Like ReadMessage, except that the metadata is copied in a new buffer.
`static Status`	`ReadRecordBatch(ArrowBuffer metadata, Schema schema, DictionaryMemo dictionary_memo, IpcOptions options, RandomAccessFile file, RecordBatch out)` Read record batch from file given metadata and schema
`static Status`	`ReadRecordBatch(ArrowBuffer metadata, Schema schema, DictionaryMemo dictionary_memo, RandomAccessFile file, RecordBatch out)` \brief Read record batch from file given metadata and schema
`static Status`	`ReadRecordBatch(Message message, Schema schema, DictionaryMemo dictionary_memo, RecordBatch out)` \brief Read record batch from encapsulated Message
`static Status`	`ReadRecordBatch(Schema schema, DictionaryMemo dictionary_memo, InputStream stream, RecordBatch out)` Read record batch as encapsulated IPC message with metadata size prefix and header
`static Status`	`ReadSchema(InputStream stream, DictionaryMemo dictionary_memo, Schema out)` \brief Read Schema from stream serialized as a single IPC message and populate any dictionary-encoded fields into a DictionaryMemo
`static Status`	`ReadSchema(Message message, DictionaryMemo dictionary_memo, Schema out)` \brief Read Schema from encapsulated Message
`static SizeTResult`	`ReadSparseTensorBodyBufferCount(ArrowBuffer metadata)` \brief EXPERIMENTAL: Read arrow::SparseTensorFormat::type from a metadata
`static SparseTensorResult`	`ReadSparseTensorPayload(IpcPayload payload)` \brief EXPERIMENTAL: Read arrow::SparseTensor from an IpcPayload
`static TensorResult`	`ReadTensor(InputStream file)` \brief Read arrow::Tensor as encapsulated IPC message in file
`static TensorResult`	`ReadTensor(Message message)` \brief EXPERIMENTAL: Read arrow::Tensor from IPC message
`static ArrayVectorVector`	`RechunkArraysConsistently(ArrayVectorVector arg0)` Given a number of ArrayVectors, treat each ArrayVector as the chunks of a chunked array.
`static Status`	`RegisterExtensionType(ExtensionType type)` \brief Register an extension type globally.
`static long`	`RoundDown(long value, long factor)`
`static long`	`RoundUp(long value, long factor)`
`static long`	`RoundUpToMultipleOf64(long num)`
`static long`	`RoundUpToMultipleOf8(long num)`
`static long`	`RoundUpToPowerOf2(long value, long factor)`
`static boolean`	`ScalarEquals(Scalar left, Scalar right)` Returns true if scalars are equal
`static Schema`	`schema(FieldVector fields)`
`static Schema`	`schema(FieldVector fields, KeyValueMetadata metadata)` \brief Create a Schema instance
`static Status`	`SerializeRecordBatch(RecordBatch batch, MemoryPool pool, ArrowBuffer out)` \brief Serialize record batch as encapsulated IPC message in a new buffer
`static Status`	`SerializeRecordBatch(RecordBatch batch, MemoryPool pool, OutputStream out)` \brief Write record batch to OutputStream
`static Status`	`SerializeSchema(Schema schema, DictionaryMemo dictionary_memo, MemoryPool pool, ArrowBuffer out)` \brief Serialize schema as encapsulated IPC message
`static void`	`SetBit(byte[] bits, long i)`
`static void`	`SetBit(ByteBuffer bits, long i)`
`static void`	`SetBit(BytePointer bits, long i)`
`static void`	`SetBitsTo(byte[] bits, long start_offset, long length, boolean bits_are_set)`
`static void`	`SetBitsTo(ByteBuffer bits, long start_offset, long length, boolean bits_are_set)`
`static void`	`SetBitsTo(BytePointer bits, long start_offset, long length, boolean bits_are_set)` \brief set or clear a range of bits quickly
`static void`	`SetBitTo(byte[] bits, long i, boolean bit_is_set)`
`static void`	`SetBitTo(ByteBuffer bits, long i, boolean bit_is_set)`
`static void`	`SetBitTo(BytePointer bits, long i, boolean bit_is_set)`
`static Pointer`	`shiftLeft(Pointer os, Array x)`
`static Pointer`	`shiftLeft(Pointer os, arrow.FileType arg1)`
`static Pointer`	`shiftLeft(Pointer os, byte arg1)`
`static Pointer`	`shiftLeft(Pointer os, DataType type)`
`static Pointer`	`shiftLeft(Pointer os, FileStats arg1)`
`static Pointer`	`shiftLeft(Pointer os, int unit)`
`static Pointer`	`shiftLeft(Pointer os, PathForest tree)` \}
`static Pointer`	`shiftLeft(Pointer os, TimeUnit.type unit)`
`static ArrowBuffer`	`SliceBuffer(ArrowBuffer buffer, long offset)` \brief Construct a view on a buffer at the given offset, up to the buffer's end.
`static ArrowBuffer`	`SliceBuffer(ArrowBuffer buffer, long offset, long length)` \defgroup buffer-slicing-functions Functions for slicing buffers \{
`static ArrowBuffer`	`SliceMutableBuffer(ArrowBuffer buffer, long offset)` \brief Like SliceBuffer, but construct a mutable buffer slice.
`static ArrowBuffer`	`SliceMutableBuffer(ArrowBuffer buffer, long offset, long length)` \brief Like SliceBuffer, but construct a mutable buffer slice.
`static Status`	`SortToIndices(FunctionContext ctx, Array values, Array offsets)` \brief Returns the indices that would sort an array.
`static boolean`	`SparseTensorEquals(SparseTensor left, SparseTensor right)` EXPERIMENTAL: Returns true if the given sparse tensors are exactly equal
`static DataType`	`struct_(FieldVector fields)` \brief Create a StructType instance
`static BasicDecimal128`	`subtract(BasicDecimal128 operand)`
`static BasicDecimal128`	`subtract(BasicDecimal128 left, BasicDecimal128 right)`
`static Status`	`Sum(FunctionContext context, Array array, Datum out)` \brief Sum values of a numeric array.
`static Status`	`Sum(FunctionContext context, Datum value, Datum out)` \brief Sum values of a numeric array.
`static MemoryPool`	`system_memory_pool()` Return a process-wide memory pool based on the system allocator.
`static Status`	`Take(FunctionContext ctx, Array values, Array indices, TakeOptions options, Array out)` \brief Take from an array of values at indices in another array The output array will be of the same type as the input values array, with elements taken from the values array at the given indices.
`static Status`	`Take(FunctionContext ctx, Array values, ChunkedArray indices, TakeOptions options, ChunkedArray out)` \brief Take from an array of values at indices in a chunked array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices.
`static Status`	`Take(FunctionContext ctx, ChunkedArray values, Array indices, TakeOptions options, ChunkedArray out)` \brief Take from a chunked array of values at indices in another array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices.
`static Status`	`Take(FunctionContext ctx, ChunkedArray values, ChunkedArray indices, TakeOptions options, ChunkedArray out)` \brief Take from a chunked array of values at indices in a chunked array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices.
`static Status`	`Take(FunctionContext ctx, Datum values, Datum indices, TakeOptions options, Datum out)` \brief Take from an array of values at indices in another array
`static Status`	`Take(FunctionContext ctx, RecordBatch batch, Array indices, TakeOptions options, RecordBatch out)` \brief Take from a record batch at indices in another array The output batch will have the same schema as the input batch, with rows taken from the columns in the batch at the given indices.
`static Status`	`Take(FunctionContext ctx, Table table, Array indices, TakeOptions options, Table out)` \brief Take from a table at indices in an array The output table will have the same schema as the input table, with rows taken from the columns in the table at the given indices.
`static Status`	`Take(FunctionContext ctx, Table table, ChunkedArray indices, TakeOptions options, Table out)` \brief Take from a table at indices in a chunked array The output table will have the same schema as the input table, with rows taken from the values array at the given indices.
`static boolean`	`TensorEquals(Tensor left, Tensor right)`
`static boolean`	`TensorEquals(Tensor left, Tensor right, EqualOptions arg2)`
`static DataType`	`time32(int unit)`
`static DataType`	`time32(TimeUnit.type unit)` \brief Create a 32-bit time type instance Unit can be either SECOND or MILLI
`static DataType`	`time64(int unit)`
`static DataType`	`time64(TimeUnit.type unit)` \brief Create a 64-bit time type instance Unit can be either MICRO or NANO
`static DataType`	`timestamp(int unit)`
`static DataType`	`timestamp(int unit, BytePointer timezone)`
`static DataType`	`timestamp(TimeUnit.type unit)` \brief Create a TimestampType instance from its unit
`static DataType`	`timestamp(TimeUnit.type unit, String timezone)` \brief Create a TimestampType instance from its unit and timezone
`static String`	`ToString(arrow.FileType arg0)`
`static BytePointer`	`ToString(byte arg0)`
`static long`	`TrailingBits(long v, int num_bits)`
`static boolean`	`TypeEquals(DataType left, DataType right)`
`static boolean`	`TypeEquals(DataType left, DataType right, boolean check_metadata)` Returns true if the type metadata are exactly equal
`static DataType`	`uint16()` \brief Return a UInt16Type instance
`static DataType`	`uint32()` \brief Return a UInt32Type instance
`static DataType`	`uint64()` \brief Return a UInt64Type instance
`static DataType`	`uint8()` \brief Return a UInt8Type instance
`static SchemaResult`	`UnifySchemas(SchemaVector schemas)`
`static SchemaResult`	`UnifySchemas(SchemaVector schemas, Field.MergeOptions field_merge_options)` \brief Unifies schemas by merging fields by name.
`static DataType`	`union_()`
`static DataType`	`union_(ArrayVector children)`
`static DataType`	`union_(ArrayVector children, int mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes, int mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes, UnionMode.type mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes, int mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes, UnionMode.type mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes, int mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes, UnionMode.type mode)` \brief Create a UnionType instance
`static DataType`	`union_(ArrayVector children, StringVector field_names, int mode)`
`static DataType`	`union_(ArrayVector children, StringVector field_names, UnionMode.type mode)` \brief Create a UnionType instance
`static DataType`	`union_(ArrayVector children, UnionMode.type mode)` \brief Create a UnionType instance
`static DataType`	`union_(FieldVector child_fields)`
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes)`
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes, int mode)`
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes, UnionMode.type mode)`
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes)`
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes, int mode)`
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes, UnionMode.type mode)`
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes)`
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes, int mode)`
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes, UnionMode.type mode)` \brief Create a UnionType instance
`static DataType`	`union_(FieldVector child_fields, int mode)`
`static DataType`	`union_(FieldVector child_fields, UnionMode.type mode)` \brief Create a UnionType instance
`static DataType`	`union_(int mode)`
`static DataType`	`union_(UnionMode.type mode)` \brief Create a UnionType instance
`static Status`	`Unique(FunctionContext context, Datum datum, Array out)` \brief Compute unique elements from an array-like object Note if a null occurs in the input it will NOT be included in the output.
`static Status`	`UnregisterExtensionType(BytePointer type_name)`
`static Status`	`UnregisterExtensionType(String type_name)` \brief Delete an extension type from the global registry.
`static DataType`	`utf8()` \brief Return a StringType instance
`static Status`	`ValidateTensorParameters(DataType type, ArrowBuffer data, long[] shape, long[] strides, StringVector dim_names)`
`static Status`	`ValidateTensorParameters(DataType type, ArrowBuffer data, LongBuffer shape, LongBuffer strides, StringVector dim_names)`
`static Status`	`ValidateTensorParameters(DataType type, ArrowBuffer data, LongPointer shape, LongPointer strides, StringVector dim_names)`
`static Status`	`ValueCounts(FunctionContext context, Datum value, Array counts)` \brief Return counts of unique elements from an array-like object.
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcOptions options, OutputStream dst, int[] metadata_length)`
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcOptions options, OutputStream dst, IntBuffer metadata_length)`
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcOptions options, OutputStream dst, IntPointer metadata_length)`
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, int[] metadata_length, long[] body_length, IpcOptions options, MemoryPool pool)`
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, IntBuffer metadata_length, LongBuffer body_length, IpcOptions options, MemoryPool pool)`
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, IntPointer metadata_length, LongPointer body_length, IpcOptions options, MemoryPool pool)` \brief Low-level API for writing a record batch (without schema) to an OutputStream as encapsulated IPC message.
`static Status`	`WriteRecordBatchStream(RecordBatchVector batches, IpcOptions options, OutputStream dst)` \brief Write multiple record batches to OutputStream, including schema
`static Status`	`WriteSparseTensor(SparseTensor sparse_tensor, OutputStream dst, int[] metadata_length, long[] body_length)`
`static Status`	`WriteSparseTensor(SparseTensor sparse_tensor, OutputStream dst, IntBuffer metadata_length, LongBuffer body_length)`
`static Status`	`WriteSparseTensor(SparseTensor sparse_tensor, OutputStream dst, IntPointer metadata_length, LongPointer body_length)` \brief EXPERIMENTAL: Write arrow::SparseTensor as a contiguous message.
`static Status`	`WriteTensor(Tensor tensor, OutputStream dst, int[] metadata_length, long[] body_length)`
`static Status`	`WriteTensor(Tensor tensor, OutputStream dst, IntBuffer metadata_length, LongBuffer body_length)`
`static Status`	`WriteTensor(Tensor tensor, OutputStream dst, IntPointer metadata_length, LongPointer body_length)` \brief Write arrow::Tensor as a contiguous message.
`static Status`	`Xor(FunctionContext context, Datum left, Datum right, Datum out)` \brief Element-wise XOR of two boolean datums

Methods inherited from class org.bytedeco.arrow.presets.arrow
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ARROW_VERSION_MAJOR
```
public static final int ARROW_VERSION_MAJOR
```
\brief Top-level namespace for Apache Arrow C++ API

See Also:

Constant Field Values

ARROW_VERSION_MINOR
```
public static final int ARROW_VERSION_MINOR
```
See Also:

Constant Field Values

ARROW_VERSION_PATCH
```
public static final int ARROW_VERSION_PATCH
```
See Also:

Constant Field Values

ARROW_VERSION
```
public static final int ARROW_VERSION
```
See Also:

Constant Field Values

ARROW_SO_VERSION

public static final String ARROW_SO_VERSION

See Also:: Constant Field Values

ARROW_FULL_SO_VERSION

public static final String ARROW_FULL_SO_VERSION

See Also:: Constant Field Values

ARROW_BITNESS
```
public static final int ARROW_BITNESS
```

ARROW_LITTLE_ENDIAN

public static final int ARROW_LITTLE_ENDIAN

kDefaultAbsoluteTolerance

public static final double kDefaultAbsoluteTolerance

kNoSize
```
public static final long kNoSize
```

kFeatherVersion

public static final int kFeatherVersion

Constructor Detail
- arrow
```
public arrow()
```

Method Detail

ARROW_BITNESS

@MemberGetter
public static int ARROW_BITNESS()

kUseDefaultCompressionLevel

@Namespace(value="arrow::util")
 @MemberGetter
public static int kUseDefaultCompressionLevel()

\brief is_null_pointer from C++17

ARROW_LITTLE_ENDIAN
```
@MemberGetter
public static int ARROW_LITTLE_ENDIAN()
```
\brief Readahead iterator that iterates on the underlying iterator in a separate thread, getting up to N values in advance.

kBytePopcount

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kBytePopcount(int i)

kBytePopcount

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kBytePopcount()

CeilDiv

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long CeilDiv(@Cast(value="int64_t")
                                                                                            long value,
                                                                                            @Cast(value="int64_t")
                                                                                            long divisor)

BytesForBits

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long BytesForBits(@Cast(value="int64_t")
                                                                                                 long bits)

IsPowerOf2

@Namespace(value="arrow::BitUtil")
 @Cast(value="const bool")
public static boolean IsPowerOf2(@Cast(value="int64_t")
                                                                                               long value)

NextPower2

@Namespace(value="arrow::BitUtil")
 @Cast(value="int64_t")
public static long NextPower2(@Cast(value="int64_t")
                                                                                         long n)

IsMultipleOf64

@Namespace(value="arrow::BitUtil")
 @Cast(value="const bool")
public static boolean IsMultipleOf64(@Cast(value="int64_t")
                                                                                                   long n)

IsMultipleOf8

@Namespace(value="arrow::BitUtil")
 @Cast(value="const bool")
public static boolean IsMultipleOf8(@Cast(value="int64_t")
                                                                                                  long n)

RoundUp

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long RoundUp(@Cast(value="int64_t")
                                                                                            long value,
                                                                                            @Cast(value="int64_t")
                                                                                            long factor)

RoundDown

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long RoundDown(@Cast(value="int64_t")
                                                                                              long value,
                                                                                              @Cast(value="int64_t")
                                                                                              long factor)

RoundUpToPowerOf2

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long RoundUpToPowerOf2(@Cast(value="int64_t")
                                                                                                      long value,
                                                                                                      @Cast(value="int64_t")
                                                                                                      long factor)

RoundUpToMultipleOf8

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long RoundUpToMultipleOf8(@Cast(value="int64_t")
                                                                                                         long num)

RoundUpToMultipleOf64

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long RoundUpToMultipleOf64(@Cast(value="int64_t")
                                                                                                          long num)

CoveringBytes

@Namespace(value="arrow::BitUtil")
 @Cast(value="const int64_t")
public static long CoveringBytes(@Cast(value="int64_t")
                                                                                                  long offset,
                                                                                                  @Cast(value="int64_t")
                                                                                                  long length)

TrailingBits

@Namespace(value="arrow::BitUtil")
 @Cast(value="uint64_t")
public static long TrailingBits(@Cast(value="uint64_t")
                                                                                            long v,
                                                                                            int num_bits)

CountLeadingZeros

@Namespace(value="arrow::BitUtil")
public static int CountLeadingZeros(@Cast(value="uint32_t")
                                                                       int value)

\brief Count the number of leading zeros in an unsigned integer.

CountLeadingZeros

@Namespace(value="arrow::BitUtil")
public static int CountLeadingZeros(@Cast(value="uint64_t")
                                                                       long value)

CountTrailingZeros

@Namespace(value="arrow::BitUtil")
public static int CountTrailingZeros(@Cast(value="uint32_t")
                                                                        int value)

CountTrailingZeros

@Namespace(value="arrow::BitUtil")
public static int CountTrailingZeros(@Cast(value="uint64_t")
                                                                        long value)

NumRequiredBits

@Namespace(value="arrow::BitUtil")
public static int NumRequiredBits(@Cast(value="uint64_t")
                                                                     long x)

Log2

@Namespace(value="arrow::BitUtil")
public static int Log2(@Cast(value="uint64_t")
                                                          long x)

ByteSwap

@Namespace(value="arrow::BitUtil")
 @Cast(value="int64_t")
public static long ByteSwap(@Cast(value="int64_t")
                                                                                       long value)

ByteSwap

@Namespace(value="arrow::BitUtil")
public static int ByteSwap(int value)

ByteSwap

@Namespace(value="arrow::BitUtil")
public static short ByteSwap(short value)

ByteSwap

@Namespace(value="arrow::BitUtil")
public static void ByteSwap(Pointer dst,
                                                               @Const
                                                               Pointer src,
                                                               int len)

kBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kBitmask(int i)

kBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kBitmask()

kFlippedBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kFlippedBitmask(int i)

kFlippedBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kFlippedBitmask()

kPrecedingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kPrecedingBitmask(int i)

kPrecedingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kPrecedingBitmask()

kPrecedingWrappingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kPrecedingWrappingBitmask(int i)

kPrecedingWrappingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kPrecedingWrappingBitmask()

kTrailingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kTrailingBitmask(int i)

kTrailingBitmask

@Namespace(value="arrow::BitUtil")
 @MemberGetter
 @Cast(value="const uint8_t*")
public static BytePointer kTrailingBitmask()

GetBit

@Namespace(value="arrow::BitUtil")
 @Cast(value="bool")
public static boolean GetBit(@Cast(value="const uint8_t*")
                                                                                     BytePointer bits,
                                                                                     @Cast(value="uint64_t")
                                                                                     long i)

GetBit

@Namespace(value="arrow::BitUtil")
 @Cast(value="bool")
public static boolean GetBit(@Cast(value="const uint8_t*")
                                                                                     ByteBuffer bits,
                                                                                     @Cast(value="uint64_t")
                                                                                     long i)

GetBit

@Namespace(value="arrow::BitUtil")
 @Cast(value="bool")
public static boolean GetBit(@Cast(value="const uint8_t*")
                                                                                     byte[] bits,
                                                                                     @Cast(value="uint64_t")
                                                                                     long i)

GetBitFromByte

@Namespace(value="arrow::BitUtil")
 @Cast(value="bool")
public static boolean GetBitFromByte(@Cast(value="uint8_t")
                                                                                             byte _byte,
                                                                                             @Cast(value="uint8_t")
                                                                                             byte i)

ClearBit

@Namespace(value="arrow::BitUtil")
public static void ClearBit(@Cast(value="uint8_t*")
                                                               BytePointer bits,
                                                               @Cast(value="int64_t")
                                                               long i)

ClearBit

@Namespace(value="arrow::BitUtil")
public static void ClearBit(@Cast(value="uint8_t*")
                                                               ByteBuffer bits,
                                                               @Cast(value="int64_t")
                                                               long i)

ClearBit

@Namespace(value="arrow::BitUtil")
public static void ClearBit(@Cast(value="uint8_t*")
                                                               byte[] bits,
                                                               @Cast(value="int64_t")
                                                               long i)

SetBit

@Namespace(value="arrow::BitUtil")
public static void SetBit(@Cast(value="uint8_t*")
                                                             BytePointer bits,
                                                             @Cast(value="int64_t")
                                                             long i)

SetBit

@Namespace(value="arrow::BitUtil")
public static void SetBit(@Cast(value="uint8_t*")
                                                             ByteBuffer bits,
                                                             @Cast(value="int64_t")
                                                             long i)

SetBit

@Namespace(value="arrow::BitUtil")
public static void SetBit(@Cast(value="uint8_t*")
                                                             byte[] bits,
                                                             @Cast(value="int64_t")
                                                             long i)

SetBitTo

@Namespace(value="arrow::BitUtil")
public static void SetBitTo(@Cast(value="uint8_t*")
                                                               BytePointer bits,
                                                               @Cast(value="int64_t")
                                                               long i,
                                                               @Cast(value="bool")
                                                               boolean bit_is_set)

SetBitTo

@Namespace(value="arrow::BitUtil")
public static void SetBitTo(@Cast(value="uint8_t*")
                                                               ByteBuffer bits,
                                                               @Cast(value="int64_t")
                                                               long i,
                                                               @Cast(value="bool")
                                                               boolean bit_is_set)

SetBitTo

@Namespace(value="arrow::BitUtil")
public static void SetBitTo(@Cast(value="uint8_t*")
                                                               byte[] bits,
                                                               @Cast(value="int64_t")
                                                               long i,
                                                               @Cast(value="bool")
                                                               boolean bit_is_set)

SetBitsTo

@Namespace(value="arrow::BitUtil")
public static void SetBitsTo(@Cast(value="uint8_t*")
                                                                BytePointer bits,
                                                                @Cast(value="int64_t")
                                                                long start_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="bool")
                                                                boolean bits_are_set)

\brief set or clear a range of bits quickly

SetBitsTo

@Namespace(value="arrow::BitUtil")
public static void SetBitsTo(@Cast(value="uint8_t*")
                                                                ByteBuffer bits,
                                                                @Cast(value="int64_t")
                                                                long start_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="bool")
                                                                boolean bits_are_set)

SetBitsTo

@Namespace(value="arrow::BitUtil")
public static void SetBitsTo(@Cast(value="uint8_t*")
                                                                byte[] bits,
                                                                @Cast(value="int64_t")
                                                                long start_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="bool")
                                                                boolean bits_are_set)

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  BytePointer arg0,
                                                                                  MemoryPool pool)

\brief Convert vector of bytes to bitmap buffer

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  BytePointer arg0)

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  ByteBuffer arg0,
                                                                                  MemoryPool pool)

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  ByteBuffer arg0)

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  byte[] arg0,
                                                                                  MemoryPool pool)

BytesToBits

@Namespace(value="arrow::BitUtil")
 @ByVal
public static BufferResult BytesToBits(@Cast(value="uint8_t*") @StdVector
                                                                                  byte[] arg0)

CopyBitmap

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult CopyBitmap(MemoryPool pool,
                                                                                  @Cast(value="const uint8_t*")
                                                                                  BytePointer bitmap,
                                                                                  @Cast(value="int64_t")
                                                                                  long offset,
                                                                                  @Cast(value="int64_t")
                                                                                  long length)

Copy a bit range of an existing bitmap

Parameters:: pool - [in] memory pool to allocate memory from; bitmap - [in] source data; offset - [in] bit offset into the source data; length - [in] number of bits to copy
Returns:: Status message

CopyBitmap

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult CopyBitmap(MemoryPool pool,
                                                                                  @Cast(value="const uint8_t*")
                                                                                  ByteBuffer bitmap,
                                                                                  @Cast(value="int64_t")
                                                                                  long offset,
                                                                                  @Cast(value="int64_t")
                                                                                  long length)

CopyBitmap

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult CopyBitmap(MemoryPool pool,
                                                                                  @Cast(value="const uint8_t*")
                                                                                  byte[] bitmap,
                                                                                  @Cast(value="int64_t")
                                                                                  long offset,
                                                                                  @Cast(value="int64_t")
                                                                                  long length)

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  BytePointer bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  BytePointer dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset,
                                                                  @Cast(value="bool")
                                                                  boolean restore_trailing_bits)

Copy a bit range of an existing bitmap into an existing bitmap

Parameters:: bitmap - [in] source data; offset - [in] bit offset into the source data; length - [in] number of bits to copy; dest_offset - [in] bit offset into the destination; restore_trailing_bits - [in] don't clobber bits outside the destination range; dest - [out] the destination buffer, must have at least space for (offset + length) bits

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  BytePointer bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  BytePointer dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset)

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  ByteBuffer bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  ByteBuffer dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset,
                                                                  @Cast(value="bool")
                                                                  boolean restore_trailing_bits)

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  ByteBuffer bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  ByteBuffer dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset)

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  byte[] bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  byte[] dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset,
                                                                  @Cast(value="bool")
                                                                  boolean restore_trailing_bits)

CopyBitmap

@Namespace(value="arrow::internal")
public static void CopyBitmap(@Cast(value="const uint8_t*")
                                                                  byte[] bitmap,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  @Cast(value="int64_t")
                                                                  long length,
                                                                  @Cast(value="uint8_t*")
                                                                  byte[] dest,
                                                                  @Cast(value="int64_t")
                                                                  long dest_offset)

CountSetBits

@Namespace(value="arrow::internal")
 @Cast(value="int64_t")
public static long CountSetBits(@Cast(value="const uint8_t*")
                                                                                            BytePointer data,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long length)

Compute the number of 1's in the given data array

Parameters:: data - [in] a packed LSB-ordered bitmap as a byte array; bit_offset - [in] a bitwise offset into the bitmap; length - [in] the number of bits to inspect in the bitmap relative to the offset
Returns:: The number of set (1) bits in the range

CountSetBits

@Namespace(value="arrow::internal")
 @Cast(value="int64_t")
public static long CountSetBits(@Cast(value="const uint8_t*")
                                                                                            ByteBuffer data,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long length)

CountSetBits

@Namespace(value="arrow::internal")
 @Cast(value="int64_t")
public static long CountSetBits(@Cast(value="const uint8_t*")
                                                                                            byte[] data,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long length)

BitmapEquals

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean BitmapEquals(@Cast(value="const uint8_t*")
                                                                                            BytePointer left,
                                                                                            @Cast(value="int64_t")
                                                                                            long left_offset,
                                                                                            @Cast(value="const uint8_t*")
                                                                                            BytePointer right,
                                                                                            @Cast(value="int64_t")
                                                                                            long right_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_length)

BitmapEquals

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean BitmapEquals(@Cast(value="const uint8_t*")
                                                                                            ByteBuffer left,
                                                                                            @Cast(value="int64_t")
                                                                                            long left_offset,
                                                                                            @Cast(value="const uint8_t*")
                                                                                            ByteBuffer right,
                                                                                            @Cast(value="int64_t")
                                                                                            long right_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_length)

BitmapEquals

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean BitmapEquals(@Cast(value="const uint8_t*")
                                                                                            byte[] left,
                                                                                            @Cast(value="int64_t")
                                                                                            long left_offset,
                                                                                            @Cast(value="const uint8_t*")
                                                                                            byte[] right,
                                                                                            @Cast(value="int64_t")
                                                                                            long right_offset,
                                                                                            @Cast(value="int64_t")
                                                                                            long bit_length)

BitmapAnd

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapAnd(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 BytePointer left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 BytePointer right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

\brief Do a "bitmap and" on right and left buffers starting at their respective bit-offsets for the given bit-length and put the results in out_buffer starting at the given bit-offset. out_buffer will be allocated and initialized to zeros using pool before the operation.

BitmapAnd

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapAnd(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 ByteBuffer left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 ByteBuffer right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

BitmapAnd

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapAnd(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 byte[] left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 byte[] right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

BitmapAnd

@Namespace(value="arrow::internal")
public static void BitmapAnd(@Cast(value="const uint8_t*")
                                                                 BytePointer left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 BytePointer right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 BytePointer out)

\brief Do a "bitmap and" on right and left buffers starting at their respective bit-offsets for the given bit-length and put the results in out starting at the given bit-offset.

BitmapAnd

@Namespace(value="arrow::internal")
public static void BitmapAnd(@Cast(value="const uint8_t*")
                                                                 ByteBuffer left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 ByteBuffer right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 ByteBuffer out)

BitmapAnd

@Namespace(value="arrow::internal")
public static void BitmapAnd(@Cast(value="const uint8_t*")
                                                                 byte[] left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 byte[] right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 byte[] out)

BitmapOr

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapOr(MemoryPool pool,
                                                                                @Cast(value="const uint8_t*")
                                                                                BytePointer left,
                                                                                @Cast(value="int64_t")
                                                                                long left_offset,
                                                                                @Cast(value="const uint8_t*")
                                                                                BytePointer right,
                                                                                @Cast(value="int64_t")
                                                                                long right_offset,
                                                                                @Cast(value="int64_t")
                                                                                long length,
                                                                                @Cast(value="int64_t")
                                                                                long out_offset)

\brief Do a "bitmap or" for the given bit length on right and left buffers starting at their respective bit-offsets and put the results in out_buffer starting at the given bit-offset. out_buffer will be allocated and initialized to zeros using pool before the operation.

BitmapOr

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapOr(MemoryPool pool,
                                                                                @Cast(value="const uint8_t*")
                                                                                ByteBuffer left,
                                                                                @Cast(value="int64_t")
                                                                                long left_offset,
                                                                                @Cast(value="const uint8_t*")
                                                                                ByteBuffer right,
                                                                                @Cast(value="int64_t")
                                                                                long right_offset,
                                                                                @Cast(value="int64_t")
                                                                                long length,
                                                                                @Cast(value="int64_t")
                                                                                long out_offset)

BitmapOr

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapOr(MemoryPool pool,
                                                                                @Cast(value="const uint8_t*")
                                                                                byte[] left,
                                                                                @Cast(value="int64_t")
                                                                                long left_offset,
                                                                                @Cast(value="const uint8_t*")
                                                                                byte[] right,
                                                                                @Cast(value="int64_t")
                                                                                long right_offset,
                                                                                @Cast(value="int64_t")
                                                                                long length,
                                                                                @Cast(value="int64_t")
                                                                                long out_offset)

BitmapOr

@Namespace(value="arrow::internal")
public static void BitmapOr(@Cast(value="const uint8_t*")
                                                                BytePointer left,
                                                                @Cast(value="int64_t")
                                                                long left_offset,
                                                                @Cast(value="const uint8_t*")
                                                                BytePointer right,
                                                                @Cast(value="int64_t")
                                                                long right_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="int64_t")
                                                                long out_offset,
                                                                @Cast(value="uint8_t*")
                                                                BytePointer out)

\brief Do a "bitmap or" for the given bit length on right and left buffers starting at their respective bit-offsets and put the results in out starting at the given bit-offset.

BitmapOr

@Namespace(value="arrow::internal")
public static void BitmapOr(@Cast(value="const uint8_t*")
                                                                ByteBuffer left,
                                                                @Cast(value="int64_t")
                                                                long left_offset,
                                                                @Cast(value="const uint8_t*")
                                                                ByteBuffer right,
                                                                @Cast(value="int64_t")
                                                                long right_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="int64_t")
                                                                long out_offset,
                                                                @Cast(value="uint8_t*")
                                                                ByteBuffer out)

BitmapOr

@Namespace(value="arrow::internal")
public static void BitmapOr(@Cast(value="const uint8_t*")
                                                                byte[] left,
                                                                @Cast(value="int64_t")
                                                                long left_offset,
                                                                @Cast(value="const uint8_t*")
                                                                byte[] right,
                                                                @Cast(value="int64_t")
                                                                long right_offset,
                                                                @Cast(value="int64_t")
                                                                long length,
                                                                @Cast(value="int64_t")
                                                                long out_offset,
                                                                @Cast(value="uint8_t*")
                                                                byte[] out)

BitmapXor

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapXor(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 BytePointer left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 BytePointer right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

\brief Do a "bitmap xor" for the given bit-length on right and left buffers starting at their respective bit-offsets and put the results in out_buffer starting at the given bit offset. out_buffer will be allocated and initialized to zeros using pool before the operation.

BitmapXor

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapXor(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 ByteBuffer left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 ByteBuffer right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

BitmapXor

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapXor(MemoryPool pool,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 byte[] left,
                                                                                 @Cast(value="int64_t")
                                                                                 long left_offset,
                                                                                 @Cast(value="const uint8_t*")
                                                                                 byte[] right,
                                                                                 @Cast(value="int64_t")
                                                                                 long right_offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length,
                                                                                 @Cast(value="int64_t")
                                                                                 long out_offset)

BitmapXor

@Namespace(value="arrow::internal")
public static void BitmapXor(@Cast(value="const uint8_t*")
                                                                 BytePointer left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 BytePointer right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 BytePointer out)

\brief Do a "bitmap xor" for the given bit-length on right and left buffers starting at their respective bit-offsets and put the results in out starting at the given bit offset.

BitmapXor

@Namespace(value="arrow::internal")
public static void BitmapXor(@Cast(value="const uint8_t*")
                                                                 ByteBuffer left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 ByteBuffer right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 ByteBuffer out)

BitmapXor

@Namespace(value="arrow::internal")
public static void BitmapXor(@Cast(value="const uint8_t*")
                                                                 byte[] left,
                                                                 @Cast(value="int64_t")
                                                                 long left_offset,
                                                                 @Cast(value="const uint8_t*")
                                                                 byte[] right,
                                                                 @Cast(value="int64_t")
                                                                 long right_offset,
                                                                 @Cast(value="int64_t")
                                                                 long length,
                                                                 @Cast(value="int64_t")
                                                                 long out_offset,
                                                                 @Cast(value="uint8_t*")
                                                                 byte[] out)

BitmapAllButOne

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapAllButOne(MemoryPool pool,
                                                                                       @Cast(value="int64_t")
                                                                                       long length,
                                                                                       @Cast(value="int64_t")
                                                                                       long straggler_pos,
                                                                                       @Cast(value="bool")
                                                                                       boolean value)

\brief Generate Bitmap with all position to value except for one found at straggler_pos.

BitmapAllButOne

@Namespace(value="arrow::internal")
 @ByVal
public static BufferResult BitmapAllButOne(MemoryPool pool,
                                                                                       @Cast(value="int64_t")
                                                                                       long length,
                                                                                       @Cast(value="int64_t")
                                                                                       long straggler_pos)

key_value_metadata

@Namespace(value="arrow")
 @SharedPtr
public static KeyValueMetadata key_value_metadata(@Const @ByRef
                                                                                        StringStringMap pairs)

\brief Create a KeyValueMetadata instance

Parameters:: pairs - key-value mapping

key_value_metadata

@Namespace(value="arrow")
 @SharedPtr
public static KeyValueMetadata key_value_metadata(@Const @ByRef
                                                                                        StringVector keys,
                                                                                        @Const @ByRef
                                                                                        StringVector values)

\brief Create a KeyValueMetadata instance

Parameters:: keys - sequence of metadata keys; values - sequence of corresponding metadata values

GenericToStatus

@Namespace(value="arrow::internal")
 @ByVal
public static Status GenericToStatus(@Const @ByRef
                                                                                 Status st)

\endcond

system_memory_pool
```
@Namespace(value="arrow")
public static MemoryPool system_memory_pool()
```
Return a process-wide memory pool based on the system allocator.

jemalloc_memory_pool

@Namespace(value="arrow")
 @ByVal
public static Status jemalloc_memory_pool(@Cast(value="arrow::MemoryPool**")
                                                                            PointerPointer out)

Return a process-wide memory pool based on jemalloc. May return NotImplemented if jemalloc is not available.

jemalloc_memory_pool

@Namespace(value="arrow")
 @ByVal
public static Status jemalloc_memory_pool(@ByPtrPtr
                                                                            MemoryPool out)

jemalloc_set_decay_ms
```
@Namespace(value="arrow")
 @ByVal
public static Status jemalloc_set_decay_ms(int ms)
```
\brief Set jemalloc memory page purging behavior for future-created arenas to the indicated number of milliseconds. See dirty_decay_ms and muzzy_decay_ms options in jemalloc for a description of what these do. The default is configured to 1000 (1 second) which releases memory more aggressively to the operating system than the jemalloc default of 10 seconds. If you set the value to 0, dirty / muzzy pages will be released immediately rather than with a time decay, but this may reduce application performance.

mimalloc_memory_pool

@Namespace(value="arrow")
 @ByVal
public static Status mimalloc_memory_pool(@Cast(value="arrow::MemoryPool**")
                                                                            PointerPointer out)

Return a process-wide memory pool based on mimalloc. May return NotImplemented if mimalloc is not available.

mimalloc_memory_pool

@Namespace(value="arrow")
 @ByVal
public static Status mimalloc_memory_pool(@ByPtrPtr
                                                                            MemoryPool out)

SliceBuffer

@Namespace(value="arrow")
 @SharedPtr
public static ArrowBuffer SliceBuffer(@SharedPtr
                                                                            ArrowBuffer buffer,
                                                                            @Cast(value="const int64_t")
                                                                            long offset,
                                                                            @Cast(value="const int64_t")
                                                                            long length)

\defgroup buffer-slicing-functions Functions for slicing buffers \{

\brief Construct a view on a buffer at the given offset and length. This function cannot fail and does not check for errors (except in debug builds)

SliceBuffer

@Namespace(value="arrow")
 @SharedPtr
public static ArrowBuffer SliceBuffer(@SharedPtr
                                                                            ArrowBuffer buffer,
                                                                            @Cast(value="const int64_t")
                                                                            long offset)

\brief Construct a view on a buffer at the given offset, up to the buffer's end. This function cannot fail and does not check for errors (except in debug builds)

SliceMutableBuffer

@Namespace(value="arrow")
 @SharedPtr
public static ArrowBuffer SliceMutableBuffer(@SharedPtr
                                                                                   ArrowBuffer buffer,
                                                                                   @Cast(value="const int64_t")
                                                                                   long offset,
                                                                                   @Cast(value="const int64_t")
                                                                                   long length)

\brief Like SliceBuffer, but construct a mutable buffer slice. If the parent buffer is not mutable, behavior is undefined (it may abort in debug builds).

SliceMutableBuffer

@Namespace(value="arrow")
 @SharedPtr
public static ArrowBuffer SliceMutableBuffer(@SharedPtr
                                                                                   ArrowBuffer buffer,
                                                                                   @Cast(value="const int64_t")
                                                                                   long offset)

\brief Like SliceBuffer, but construct a mutable buffer slice. If the parent buffer is not mutable, behavior is undefined (it may abort in debug builds).

AllocateBuffer

@Namespace(value="arrow")
 @ByVal
public static Status AllocateBuffer(MemoryPool pool,
                                                                      @Cast(value="const int64_t")
                                                                      long size,
                                                                      @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                      ArrowBuffer out)

\defgroup buffer-allocation-functions Functions for allocating buffers \{

\brief Allocate a fixed size mutable buffer from a memory pool, zero its padding.

Parameters:: pool - [in] a memory pool; size - [in] size of buffer to allocate; out - [out] the allocated buffer (contains padding)
Returns:: Status message

AllocateBuffer

@Namespace(value="arrow")
 @ByVal
public static Status AllocateBuffer(@Cast(value="const int64_t")
                                                                      long size,
                                                                      @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                      ArrowBuffer out)

\brief Allocate a fixed-size mutable buffer from the default memory pool

Parameters:: size - [in] size of buffer to allocate; out - [out] the allocated buffer (contains padding)
Returns:: Status message

AllocateResizableBuffer

@Namespace(value="arrow")
 @ByVal
public static Status AllocateResizableBuffer(MemoryPool pool,
                                                                               @Cast(value="const int64_t")
                                                                               long size,
                                                                               @SharedPtr
                                                                               ResizableBuffer out)

\brief Allocate a resizeable buffer from a memory pool, zero its padding.

Parameters:: pool - [in] a memory pool; size - [in] size of buffer to allocate; out - [out] the allocated buffer
Returns:: Status message

AllocateResizableBuffer

@Namespace(value="arrow")
 @ByVal
public static Status AllocateResizableBuffer(@Cast(value="const int64_t")
                                                                               long size,
                                                                               @SharedPtr
                                                                               ResizableBuffer out)

\brief Allocate a resizeable buffer from the default memory pool

Parameters:: size - [in] size of buffer to allocate; out - [out] the allocated buffer
Returns:: Status message

AllocateBitmap

@Namespace(value="arrow")
 @ByVal
public static Status AllocateBitmap(MemoryPool pool,
                                                                      @Cast(value="int64_t")
                                                                      long length,
                                                                      @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                      ArrowBuffer out)

\brief Allocate a bitmap buffer from a memory pool no guarantee on values is provided.

Parameters:: pool - [in] memory pool to allocate memory from; length - [in] size in bits of bitmap to allocate; out - [out] the resulting buffer
Returns:: Status message

AllocateEmptyBitmap

@Namespace(value="arrow")
 @ByVal
public static Status AllocateEmptyBitmap(MemoryPool pool,
                                                                           @Cast(value="int64_t")
                                                                           long length,
                                                                           @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                           ArrowBuffer out)

\brief Allocate a zero-initialized bitmap buffer from a memory pool

Parameters:: pool - [in] memory pool to allocate memory from; length - [in] size in bits of bitmap to allocate; out - [out] the resulting buffer (zero-initialized).
Returns:: Status message

AllocateEmptyBitmap

@Namespace(value="arrow")
 @ByVal
public static Status AllocateEmptyBitmap(@Cast(value="int64_t")
                                                                           long length,
                                                                           @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                           ArrowBuffer out)

\brief Allocate a zero-initialized bitmap buffer from the default memory pool

Parameters:: length - [in] size in bits of bitmap to allocate; out - [out] the resulting buffer
Returns:: Status message

ConcatenateBuffers

@Namespace(value="arrow")
 @ByVal
public static Status ConcatenateBuffers(@Cast(value="const arrow::BufferVector*") @ByRef
                                                                          ArrowBufferVector buffers,
                                                                          MemoryPool pool,
                                                                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                          ArrowBuffer out)

\brief Concatenate multiple buffers into a single buffer

Parameters:: buffers - [in] to be concatenated; pool - [in] memory pool to allocate the new buffer from; out - [out] the concatenated buffer
Returns:: Status

kDefaultAbsoluteTolerance

@Namespace(value="arrow")
 @MemberGetter
public static double kDefaultAbsoluteTolerance()

\brief A BufferBuilder for building a buffer of arithmetic elements

ArrayEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayEquals(@Const @ByRef
                                                                                 Array left,
                                                                                 @Const @ByRef
                                                                                 Array right,
                                                                                 @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                 EqualOptions arg2)

Returns true if the arrays are exactly equal

ArrayEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayEquals(@Const @ByRef
                                                                                 Array left,
                                                                                 @Const @ByRef
                                                                                 Array right)

TensorEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean TensorEquals(@Const @ByRef
                                                                                  Tensor left,
                                                                                  @Const @ByRef
                                                                                  Tensor right,
                                                                                  @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                  EqualOptions arg2)

TensorEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean TensorEquals(@Const @ByRef
                                                                                  Tensor left,
                                                                                  @Const @ByRef
                                                                                  Tensor right)

SparseTensorEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean SparseTensorEquals(@Const @ByRef
                                                                                        SparseTensor left,
                                                                                        @Const @ByRef
                                                                                        SparseTensor right)

EXPERIMENTAL: Returns true if the given sparse tensors are exactly equal

ArrayApproxEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayApproxEquals(@Const @ByRef
                                                                                       Array left,
                                                                                       @Const @ByRef
                                                                                       Array right,
                                                                                       @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                       EqualOptions arg2)

Returns true if the arrays are approximately equal. For non-floating point types, this is equivalent to ArrayEquals(left, right)

ArrayApproxEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayApproxEquals(@Const @ByRef
                                                                                       Array left,
                                                                                       @Const @ByRef
                                                                                       Array right)

ArrayRangeEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayRangeEquals(@Const @ByRef
                                                                                      Array left,
                                                                                      @Const @ByRef
                                                                                      Array right,
                                                                                      @Cast(value="int64_t")
                                                                                      long start_idx,
                                                                                      @Cast(value="int64_t")
                                                                                      long end_idx,
                                                                                      @Cast(value="int64_t")
                                                                                      long other_start_idx)

Returns true if indicated equal-length segment of arrays is exactly equal

TypeEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean TypeEquals(@Const @ByRef
                                                                                DataType left,
                                                                                @Const @ByRef
                                                                                DataType right,
                                                                                @Cast(value="bool")
                                                                                boolean check_metadata)

Returns true if the type metadata are exactly equal

Parameters:: left - [in] a DataType; right - [in] a DataType; check_metadata - [in] whether to compare KeyValueMetadata for child fields

TypeEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean TypeEquals(@Const @ByRef
                                                                                DataType left,
                                                                                @Const @ByRef
                                                                                DataType right)

ScalarEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ScalarEquals(@Const @ByRef
                                                                                  Scalar left,
                                                                                  @Const @ByRef
                                                                                  Scalar right)

Returns true if scalars are equal

Parameters:: left - [in] a Scalar; right - [in] a Scalar

DieWithMessage

@Namespace(value="arrow::internal")
public static void DieWithMessage(@StdString
                                                                      String msg)

DieWithMessage

@Namespace(value="arrow::internal")
public static void DieWithMessage(@StdString
                                                                      BytePointer msg)

_null

@Namespace(value="arrow")
 @SharedPtr
 @Name(value="null")
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType _null()

\defgroup type-factories Factory functions for creating data types Factory functions for creating data types \{

\brief Return a NullType instance

_boolean

@Namespace(value="arrow")
 @SharedPtr
 @Name(value="boolean")
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType _boolean()

\brief Return a BooleanType instance

int8

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType int8()

\brief Return a Int8Type instance

int16

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType int16()

\brief Return a Int16Type instance

int32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType int32()

\brief Return a Int32Type instance

int64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType int64()

\brief Return a Int64Type instance

uint8

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType uint8()

\brief Return a UInt8Type instance

uint16

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType uint16()

\brief Return a UInt16Type instance

uint32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType uint32()

\brief Return a UInt32Type instance

uint64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType uint64()

\brief Return a UInt64Type instance

float16

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType float16()

\brief Return a HalfFloatType instance

float32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType float32()

\brief Return a FloatType instance

float64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType float64()

\brief Return a DoubleType instance

utf8

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType utf8()

\brief Return a StringType instance

large_utf8

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType large_utf8()

\brief Return a LargeStringType instance

binary

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType binary()

\brief Return a BinaryType instance

large_binary

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType large_binary()

\brief Return a LargeBinaryType instance

date32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType date32()

\brief Return a Date32Type instance

date64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType date64()

\brief Return a Date64Type instance

default_memory_pool

@Namespace(value="arrow")
public static MemoryPool default_memory_pool()

Return the process-wide default memory pool.

is_integer

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_integer(@Cast(value="arrow::Type::type")
                                                                                int type_id)

is_floating

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_floating(@Cast(value="arrow::Type::type")
                                                                                 int type_id)

is_primitive

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_primitive(@Cast(value="arrow::Type::type")
                                                                                  int type_id)

is_base_binary_like

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_base_binary_like(@Cast(value="arrow::Type::type")
                                                                                         int type_id)

is_binary_like

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_binary_like(@Cast(value="arrow::Type::type")
                                                                                    int type_id)

is_large_binary_like

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_large_binary_like(@Cast(value="arrow::Type::type")
                                                                                          int type_id)

is_dictionary

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_dictionary(@Cast(value="arrow::Type::type")
                                                                                   int type_id)

is_fixed_size_binary

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_fixed_size_binary(@Cast(value="arrow::Type::type")
                                                                                          int type_id)

is_fixed_width

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_fixed_width(@Cast(value="arrow::Type::type")
                                                                                    int type_id)

equals

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                        BasicDecimal128 left,
                                                                                                        @Const @ByRef
                                                                                                        BasicDecimal128 right)

notEquals

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                           BasicDecimal128 left,
                                                                                                           @Const @ByRef
                                                                                                           BasicDecimal128 right)

lessThan

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                         BasicDecimal128 left,
                                                                                                         @Const @ByRef
                                                                                                         BasicDecimal128 right)

lessThanEquals

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@Const @ByRef
                                                                                                                BasicDecimal128 left,
                                                                                                                @Const @ByRef
                                                                                                                BasicDecimal128 right)

greaterThan

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@Const @ByRef
                                                                                                            BasicDecimal128 left,
                                                                                                            @Const @ByRef
                                                                                                            BasicDecimal128 right)

greaterThanEquals

@Namespace(value="arrow")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@Const @ByRef
                                                                                                                   BasicDecimal128 left,
                                                                                                                   @Const @ByRef
                                                                                                                   BasicDecimal128 right)

subtract

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator -")
public static BasicDecimal128 subtract(@Const @ByRef
                                                                                                    BasicDecimal128 operand)

not

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator ~")
public static BasicDecimal128 not(@Const @ByRef
                                                                                               BasicDecimal128 operand)

add

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator +")
public static BasicDecimal128 add(@Const @ByRef
                                                                                               BasicDecimal128 left,
                                                                                               @Const @ByRef
                                                                                               BasicDecimal128 right)

subtract

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator -")
public static BasicDecimal128 subtract(@Const @ByRef
                                                                                                    BasicDecimal128 left,
                                                                                                    @Const @ByRef
                                                                                                    BasicDecimal128 right)

multiply

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator *")
public static BasicDecimal128 multiply(@Const @ByRef
                                                                                                    BasicDecimal128 left,
                                                                                                    @Const @ByRef
                                                                                                    BasicDecimal128 right)

divide

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator /")
public static BasicDecimal128 divide(@Const @ByRef
                                                                                                  BasicDecimal128 left,
                                                                                                  @Const @ByRef
                                                                                                  BasicDecimal128 right)

mod

@Namespace(value="arrow")
 @ByVal
 @Name(value="operator %")
public static BasicDecimal128 mod(@Const @ByRef
                                                                                               BasicDecimal128 left,
                                                                                               @Const @ByRef
                                                                                               BasicDecimal128 right)

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                            Pointer os,
                                                                                                                            @Const @ByRef
                                                                                                                            DataType type)

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                            Pointer os,
                                                                                                                            TimeUnit.type unit)

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                            Pointer os,
                                                                                                                            @Cast(value="arrow::TimeUnit::type")
                                                                                                                            int unit)

fixed_size_binary

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType fixed_size_binary(int byte_width)

\addtogroup type-factories \{

\brief Create a FixedSizeBinaryType instance.

decimal

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType decimal(int precision,
                                                                                                                           int scale)

\brief Create a Decimal128Type instance

list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType list(@Const @SharedPtr @ByRef
                                                                                                                        Field value_type)

\brief Create a ListType instance from its child Field type

list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType list(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                        DataType value_type)

\brief Create a ListType instance from its child DataType

large_list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType large_list(@Const @SharedPtr @ByRef
                                                                                                                              Field value_type)

\brief Create a LargeListType instance from its child Field type

large_list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType large_list(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType value_type)

\brief Create a LargeListType instance from its child DataType

map

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType map(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                       DataType key_type,
                                                                                                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                       DataType value_type,
                                                                                                                       @Cast(value="bool")
                                                                                                                       boolean keys_sorted)

\brief Create a MapType instance from its key and value DataTypes

map

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType map(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                       DataType key_type,
                                                                                                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                       DataType value_type)

fixed_size_list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType fixed_size_list(@Const @SharedPtr @ByRef
                                                                                                                                   Field value_type,
                                                                                                                                   int list_size)

\brief Create a FixedSizeListType instance from its child Field type

fixed_size_list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType fixed_size_list(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                                   DataType value_type,
                                                                                                                                   int list_size)

\brief Create a FixedSizeListType instance from its child DataType

duration

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType duration(TimeUnit.type unit)

\brief Return a Duration instance (naming use _type to avoid namespace conflict with built in time clases).

duration

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType duration(@Cast(value="arrow::TimeUnit::type")
                                                                                                                            int unit)

day_time_interval

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType day_time_interval()

\brief Return a DayTimeIntervalType instance

month_interval

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType month_interval()

\brief Return a MonthIntervalType instance

timestamp

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType timestamp(TimeUnit.type unit)

\brief Create a TimestampType instance from its unit

timestamp

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType timestamp(@Cast(value="arrow::TimeUnit::type")
                                                                                                                             int unit)

timestamp

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType timestamp(TimeUnit.type unit,
                                                                                                                             @StdString
                                                                                                                             String timezone)

\brief Create a TimestampType instance from its unit and timezone

timestamp

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType timestamp(@Cast(value="arrow::TimeUnit::type")
                                                                                                                             int unit,
                                                                                                                             @StdString
                                                                                                                             BytePointer timezone)

time32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType time32(TimeUnit.type unit)

\brief Create a 32-bit time type instance Unit can be either SECOND or MILLI

time32

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType time32(@Cast(value="arrow::TimeUnit::type")
                                                                                                                          int unit)

time64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType time64(TimeUnit.type unit)

\brief Create a 64-bit time type instance Unit can be either MICRO or NANO

time64

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType time64(@Cast(value="arrow::TimeUnit::type")
                                                                                                                          int unit)

struct_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType struct_(@Const @ByRef
                                                                                                                           FieldVector fields)

\brief Create a StructType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes,
                                                                                                                          UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes,
                                                                                                                          UnionMode.type mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes,
                                                                                                                          UnionMode.type mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          FieldVector child_fields,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_()

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes,
                                                                                                                          UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes,
                                                                                                                          UnionMode.type mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          BytePointer type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          ByteBuffer type_codes,
                                                                                                                          UnionMode.type mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @StdVector
                                                                                                                          byte[] type_codes,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Const @ByRef
                                                                                                                          StringVector field_names,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          UnionMode.type mode)

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children)

union_

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType union_(@Const @ByRef
                                                                                                                          ArrayVector children,
                                                                                                                          @Cast(value="arrow::UnionMode::type")
                                                                                                                          int mode)

dictionary

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType dictionary(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType index_type,
                                                                                                                              @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType dict_type,
                                                                                                                              @Cast(value="bool")
                                                                                                                              boolean ordered)

\brief Create a DictionaryType instance

Parameters:: index_type - [in] the type of the dictionary indices (must be a signed integer); dict_type - [in] the type of the values in the variable dictionary; ordered - [in] true if the order of the dictionary values has semantic meaning and should be preserved where possible

dictionary

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType dictionary(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType index_type,
                                                                                                                              @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType dict_type)

field

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Field field(@StdString
                                                                        String name,
                                                                        @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                        DataType type,
                                                                        @Cast(value="bool")
                                                                        boolean nullable,
                                                                        @Const @Cast(value="const arrow::KeyValueMetadata*") @SharedPtr @ByRef(nullValue="std::shared_ptr<const arrow::KeyValueMetadata>(nullptr)")
                                                                        KeyValueMetadata metadata)

\defgroup schema-factories Factory functions for fields and schemas Factory functions for fields and schemas \{

\brief Create a Field instance

Parameters:: name - the field name; type - the field value type; nullable - whether the values are nullable, default true; metadata - any custom key-value metadata, default null

field

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Field field(@StdString
                                                                        String name,
                                                                        @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                        DataType type)

field

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Field field(@StdString
                                                                        BytePointer name,
                                                                        @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                        DataType type,
                                                                        @Cast(value="bool")
                                                                        boolean nullable,
                                                                        @Const @Cast(value="const arrow::KeyValueMetadata*") @SharedPtr @ByRef(nullValue="std::shared_ptr<const arrow::KeyValueMetadata>(nullptr)")
                                                                        KeyValueMetadata metadata)

field

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Field field(@StdString
                                                                        BytePointer name,
                                                                        @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                        DataType type)

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@Const @ByRef
                                                                          FieldVector fields,
                                                                          @Const @Cast(value="const arrow::KeyValueMetadata*") @SharedPtr @ByRef(nullValue="std::shared_ptr<const arrow::KeyValueMetadata>(nullptr)")
                                                                          KeyValueMetadata metadata)

\brief Create a Schema instance

Parameters:: fields - the schema's fields; metadata - any custom key-value metadata, default null
Returns:: schema shared_ptr to Schema

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@Const @ByRef
                                                                          FieldVector fields)

UnifySchemas
```
@Namespace(value="arrow")
 @ByVal
public static SchemaResult UnifySchemas(@Const @ByRef
                                                                          SchemaVector schemas,
                                                                          @ByVal(nullValue="arrow::Field::MergeOptions::Defaults()")
                                                                          Field.MergeOptions field_merge_options)
```
\brief Unifies schemas by merging fields by name. The behavior of field merging can be controlled via Field::MergeOptions. The resulting schema will contain the union of fields from all schemas. Fields with the same name will be merged. See Field::MergeOptions. - They are expected to be mergeable under provided field_merge_options. - The unified field will inherit the metadata from the schema where that field is first defined. - The first N fields in the schema will be ordered the same as the N fields in the first schema. The resulting schema will inherit its metadata from the first input schema. Returns an error if: - Any input schema contains fields with duplicate names. - Fields of the same name are not mergeable.

UnifySchemas

@Namespace(value="arrow")
 @ByVal
public static SchemaResult UnifySchemas(@Const @ByRef
                                                                          SchemaVector schemas)

MakeNullScalar

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Scalar>"})
public static Scalar MakeNullScalar(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                              DataType type)

CheckBufferLength

@Namespace(value="arrow::internal")
 @ByVal
public static Status CheckBufferLength()

CheckBufferLength

@Namespace(value="arrow::internal")
 @ByVal
public static Status CheckBufferLength(@Const
                                                                                   FixedSizeBinaryType t,
                                                                                   @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                                   ArrowBuffer b)

MakeScalar

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Scalar>"})
public static Scalar MakeScalar(@StdString
                                                                                                                          String value)

\brief type inferring scalar factory

MakeScalar

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Scalar>"})
public static Scalar MakeScalar(@StdString
                                                                                                                          BytePointer value)

kUnknownNullCount

@Namespace(value="arrow")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kUnknownNullCount()

MakeArray

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Array>"})
public static Array MakeArray(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::ArrayData>"})
                                                                                                                       ArrayData data)

\brief Create a strongly-typed Array instance from generic ArrayData

Parameters:: data - [in] the array contents
Returns:: the resulting Array instance

MakeArrayOfNull

@Namespace(value="arrow")
 @ByVal
public static Status MakeArrayOfNull(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                       DataType type,
                                                                       @Cast(value="int64_t")
                                                                       long length,
                                                                       @SharedPtr
                                                                       Array out)

\brief Create a strongly-typed Array instance with all elements null

Parameters:: type - [in] the array type; length - [in] the array length; out - [out] resulting Array instance

MakeArrayOfNull

@Namespace(value="arrow")
 @ByVal
public static Status MakeArrayOfNull(MemoryPool pool,
                                                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                       DataType type,
                                                                       @Cast(value="int64_t")
                                                                       long length,
                                                                       @SharedPtr
                                                                       Array out)

\brief Create a strongly-typed Array instance with all elements null

Parameters:: pool - [in] the pool from which memory for this array will be allocated; type - [in] the array type; length - [in] the array length; out - [out] resulting Array instance

MakeArrayFromScalar

@Namespace(value="arrow")
 @ByVal
public static Status MakeArrayFromScalar(@Const @ByRef
                                                                           Scalar scalar,
                                                                           @Cast(value="int64_t")
                                                                           long length,
                                                                           @SharedPtr
                                                                           Array out)

\brief Create an Array instance whose slots are the given scalar

Parameters:: scalar - [in] the value with which to fill the array; length - [in] the array length; out - [out] resulting Array instance

MakeArrayFromScalar

@Namespace(value="arrow")
 @ByVal
public static Status MakeArrayFromScalar(MemoryPool pool,
                                                                           @Const @ByRef
                                                                           Scalar scalar,
                                                                           @Cast(value="int64_t")
                                                                           long length,
                                                                           @SharedPtr
                                                                           Array out)

\brief Create a strongly-typed Array instance with all elements null

Parameters:: pool - [in] the pool from which memory for this array will be allocated; scalar - [in] the value with which to fill the array; length - [in] the array length; out - [out] resulting Array instance

RechunkArraysConsistently

@Namespace(value="arrow::internal")
 @ByVal
public static ArrayVectorVector RechunkArraysConsistently(@Const @ByRef
                                                                                                      ArrayVectorVector arg0)

Given a number of ArrayVectors, treat each ArrayVector as the chunks of a chunked array. Then rechunk each ArrayVector such that all ArrayVectors are chunked identically. It is mandatory that all ArrayVectors contain the same total number of elements.

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                            Pointer os,
                                                                                                                            @Const @ByRef
                                                                                                                            Array x)

Concatenate

@Namespace(value="arrow")
 @ByVal
public static Status Concatenate(@Const @ByRef
                                                                   ArrayVector arrays,
                                                                   MemoryPool pool,
                                                                   @SharedPtr
                                                                   Array out)

\brief Concatenate arrays

Parameters:: arrays - [in] a vector of arrays to be concatenated; pool - [in] memory to store the result will be allocated from this memory pool; out - [out] the resulting concatenated array
Returns:: Status

kMinBuilderCapacity

@Namespace(value="arrow")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kMinBuilderCapacity()

kListMaximumElements

@Namespace(value="arrow")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kListMaximumElements()

kBinaryMemoryLimit

@Namespace(value="arrow")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kBinaryMemoryLimit()

MakeBuilder

@Namespace(value="arrow")
 @ByVal
public static Status MakeBuilder(MemoryPool pool,
                                                                   @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                   DataType type,
                                                                   @UniquePtr
                                                                   ArrayBuilder out)

\brief Construct an empty ArrayBuilder corresponding to the data type

Parameters:: pool - [in] the MemoryPool to use for allocations; type - [in] an instance of DictionaryType; out - [out] the created ArrayBuilder

MakeDictionaryBuilder

@Namespace(value="arrow")
 @ByVal
public static Status MakeDictionaryBuilder(MemoryPool pool,
                                                                             @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                             DataType type,
                                                                             @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Array>"})
                                                                             Array dictionary,
                                                                             @UniquePtr
                                                                             ArrayBuilder out)

\brief Construct an empty DictionaryBuilder initialized optionally with a pre-existing dictionary

Parameters:: pool - [in] the MemoryPool to use for allocations; type - [in] an instance of DictionaryType; dictionary - [in] the initial dictionary, if any. May be nullptr; out - [out] the created ArrayBuilder

RegisterExtensionType

@Namespace(value="arrow")
 @ByVal
public static Status RegisterExtensionType(@SharedPtr
                                                                             ExtensionType type)

\brief Register an extension type globally. The name returned by the type's extension_name() method should be unique. This method is thread-safe

Parameters:: type - [in] an instance of the extension type
Returns:: Status

UnregisterExtensionType

@Namespace(value="arrow")
 @ByVal
public static Status UnregisterExtensionType(@StdString
                                                                               String type_name)

\brief Delete an extension type from the global registry. This method is thread-safe

Parameters:: type_name - [in] the unique name of a registered extension type
Returns:: Status error if the type name is unknown

UnregisterExtensionType

@Namespace(value="arrow")
 @ByVal
public static Status UnregisterExtensionType(@StdString
                                                                               BytePointer type_name)

GetExtensionType

@Namespace(value="arrow")
 @SharedPtr
public static ExtensionType GetExtensionType(@StdString
                                                                                   String type_name)

\brief Retrieve an extension type from the global registry. Returns nullptr if not found. This method is thread-safe

Returns:: the globally-registered extension type

GetExtensionType

@Namespace(value="arrow")
 @SharedPtr
public static ExtensionType GetExtensionType(@StdString
                                                                                   BytePointer type_name)

kExtensionTypeKeyName

@Namespace(value="arrow")
 @MemberGetter
public static byte kExtensionTypeKeyName(int i)

kExtensionTypeKeyName

@Namespace(value="arrow")
 @MemberGetter
public static String kExtensionTypeKeyName()

kExtensionMetadataKeyName

@Namespace(value="arrow")
 @MemberGetter
public static byte kExtensionMetadataKeyName(int i)

kExtensionMetadataKeyName

@Namespace(value="arrow")
 @MemberGetter
public static String kExtensionMetadataKeyName()

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   RecordBatch batch,
                                                                   int indent,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

\brief Print human-readable representation of RecordBatch

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   RecordBatch batch,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Table table,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

\brief Print human-readable representation of Table

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Array arr,
                                                                   int indent,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

\brief Print human-readable representation of Array

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Array arr,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

\brief Print human-readable representation of Array

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Array arr,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @StdString @Cast(value={"char*","std::string*"})
                                                                   BytePointer result)

\brief Print human-readable representation of Array

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   ChunkedArray chunked_arr,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

\brief Print human-readable representation of ChunkedArray

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   ChunkedArray chunked_arr,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @StdString @Cast(value={"char*","std::string*"})
                                                                   BytePointer result)

\brief Print human-readable representation of ChunkedArray

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Schema schema,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @Cast(value="std::ostream*")
                                                                   Pointer sink)

PrettyPrint

@Namespace(value="arrow")
 @ByVal
public static Status PrettyPrint(@Const @ByRef
                                                                   Schema schema,
                                                                   @Const @ByRef
                                                                   PrettyPrintOptions options,
                                                                   @StdString @Cast(value={"char*","std::string*"})
                                                                   BytePointer result)

DebugPrint

@Namespace(value="arrow")
 @ByVal
public static Status DebugPrint(@Const @ByRef
                                                                  Array arr,
                                                                  int indent)

MakeRecordBatchReader

@Namespace(value="arrow")
 @ByVal
public static Status MakeRecordBatchReader(@Const @ByRef
                                                                             RecordBatchVector batches,
                                                                             @SharedPtr @ByVal
                                                                             Schema schema,
                                                                             @SharedPtr
                                                                             RecordBatchReader out)

\brief Create a RecordBatchReader from a vector of RecordBatch.

Parameters:: batches - [in] the vector of RecordBatch to read from; schema - [in] schema to conform to. Will be inferred from the first element if not provided.; out - [out] output pointer to store the RecordBatchReader to.
Returns:: Status

ConcatenateTables

@Namespace(value="arrow")
 @ByVal
public static TableResult ConcatenateTables(@Const @ByRef
                                                                              TableVector tables,
                                                                              @ByVal(nullValue="arrow::ConcatenateTablesOptions::Defaults()")
                                                                              ConcatenateTablesOptions options,
                                                                              MemoryPool memory_pool)

\brief Construct table from multiple input tables.

ConcatenateTables

@Namespace(value="arrow")
 @ByVal
public static TableResult ConcatenateTables(@Const @ByRef
                                                                              TableVector tables)

PromoteTableToSchema

@Namespace(value="arrow")
 @ByVal
public static TableResult PromoteTableToSchema(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Table>"})
                                                                                 Table table,
                                                                                 @Const @SharedPtr @ByRef
                                                                                 Schema schema,
                                                                                 MemoryPool pool)

\brief Promotes a table to conform to the given schema. If a field in the schema does not have a corresponding column in the table, a column of nulls will be added to the resulting table. If the corresponding column is of type Null, it will be promoted to the type specified by schema, with null values filled. Returns an error: - if the corresponding column's type is not compatible with the schema. - if there is a column in the table that does not exist in the schema.

Parameters:: table - [in] the input Table; schema - [in] the target schema to promote to; pool - [in] The memory pool to be used if null-filled arrays need to be created.

PromoteTableToSchema

@Namespace(value="arrow")
 @ByVal
public static TableResult PromoteTableToSchema(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Table>"})
                                                                                 Table table,
                                                                                 @Const @SharedPtr @ByRef
                                                                                 Schema schema)

is_tensor_supported

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_tensor_supported(@Cast(value="arrow::Type::type")
                                                                                         int type_id)

IsTensorStridesContiguous

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean IsTensorStridesContiguous(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                         DataType type,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         LongPointer shape,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         LongPointer strides)

IsTensorStridesContiguous

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean IsTensorStridesContiguous(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                         DataType type,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         LongBuffer shape,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         LongBuffer strides)

IsTensorStridesContiguous

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean IsTensorStridesContiguous(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                         DataType type,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         long[] shape,
                                                                                                         @Cast(value="int64_t*") @StdVector
                                                                                                         long[] strides)

ValidateTensorParameters

@Namespace(value="arrow::internal")
 @ByVal
public static Status ValidateTensorParameters(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                          DataType type,
                                                                                          @SharedPtr
                                                                                          ArrowBuffer data,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          LongPointer shape,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          LongPointer strides,
                                                                                          @Const @ByRef
                                                                                          StringVector dim_names)

ValidateTensorParameters

@Namespace(value="arrow::internal")
 @ByVal
public static Status ValidateTensorParameters(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                          DataType type,
                                                                                          @SharedPtr
                                                                                          ArrowBuffer data,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          LongBuffer shape,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          LongBuffer strides,
                                                                                          @Const @ByRef
                                                                                          StringVector dim_names)

ValidateTensorParameters

@Namespace(value="arrow::internal")
 @ByVal
public static Status ValidateTensorParameters(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                          DataType type,
                                                                                          @SharedPtr
                                                                                          ArrowBuffer data,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          long[] shape,
                                                                                          @Cast(value="int64_t*") @StdVector
                                                                                          long[] strides,
                                                                                          @Const @ByRef
                                                                                          StringVector dim_names)

MakeInputStreamIterator

@Namespace(value="arrow::io")
 @ByVal
public static BufferIteratorResult MakeInputStreamIterator(@SharedPtr
                                                                                                 InputStream stream,
                                                                                                 @Cast(value="int64_t")
                                                                                                 long block_size)

\brief Return an iterator on an input stream The iterator yields a fixed-size block on each Next() call, except the last block in the stream which may be smaller. Once the end of stream is reached, Next() returns nullptr (unlike InputStream::Read() which returns an empty buffer).

HaveLibHdfs

@Namespace(value="arrow::io")
 @ByVal
public static Status HaveLibHdfs()

HaveLibHdfs3

@Namespace(value="arrow::io")
 @ByVal
public static Status HaveLibHdfs3()

ToString

@Namespace(value="arrow::fs")
 @StdString
public static String ToString(arrow.FileType arg0)

ToString

@Namespace(value="arrow::fs")
 @StdString
public static BytePointer ToString(@Cast(value="arrow::fs::FileType")
                                                                             byte arg0)

shiftLeft

@Namespace(value="arrow::fs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                arrow.FileType arg1)

shiftLeft

@Namespace(value="arrow::fs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @Cast(value="arrow::fs::FileType")
                                                                                                                                byte arg1)

kNoSize

@Namespace(value="arrow::fs")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kNoSize()

kNoTime

@Namespace(value="arrow::fs")
 @MemberGetter
 @ByRef
 @Cast(value="const arrow::fs::TimePoint*")
public static Pointer kNoTime()

shiftLeft

@Namespace(value="arrow::fs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @Const @ByRef
                                                                                                                                FileStats arg1)

shiftLeft

@Namespace(value="arrow::fs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @Const @ByRef
                                                                                                                                PathForest tree)

\brief Create a new FileSystem by URI A scheme-less URI is considered a local filesystem path. Recognized schemes are "file", "mock" and "hdfs".

Parameters:: uri - [in] a URI-based path, ex: file:///some/local/path; out_fs - [out] FileSystem instance.; out_path - [out] (optional) Path inside the filesystem.
Returns:: Status

kDefaultEscapeChar

@Namespace(value="arrow::csv")
 @MemberGetter
public static byte kDefaultEscapeChar()

ParseOne

@Namespace(value="arrow::json")
 @ByVal
public static Status ParseOne(@ByVal
                                                                      JsonParseOptions options,
                                                                      @SharedPtr
                                                                      ArrowBuffer json,
                                                                      @SharedPtr
                                                                      RecordBatch out)

A class that reads an entire JSON file into a Arrow Table The file is expected to consist of individual line-separated JSON objects

CollectionEquals

@Namespace(value="arrow::compute")
 @Cast(value="bool")
public static boolean CollectionEquals(@Const @ByRef
                                                                                               DatumVector left,
                                                                                               @Const @ByRef
                                                                                               DatumVector right)

\brief convert an Array produced by BlockParser into an Array of out_type

kUnknownLength

@Namespace(value="arrow::compute")
 @MemberGetter
 @Cast(value="const int64_t")
public static long kUnknownLength()

Invert

@Namespace(value="arrow::compute")
 @ByVal
public static Status Invert(FunctionContext context,
                                                                       @Const @ByRef
                                                                       Datum value,
                                                                       Datum out)

\brief Invert the values of a boolean datum

Parameters:: context - [in] the FunctionContext; value - [in] datum to invert; out - [out] resulting datum
Since:: 0.11.0 \note API not yet finalized

And

@Namespace(value="arrow::compute")
 @ByVal
public static Status And(FunctionContext context,
                                                                    @Const @ByRef
                                                                    Datum left,
                                                                    @Const @ByRef
                                                                    Datum right,
                                                                    Datum out)

\brief Element-wise AND of two boolean datums which always propagates nulls (null and false is null).

Parameters:: context - [in] the FunctionContext; left - [in] left operand (array); right - [in] right operand (array); out - [out] resulting datum
Since:: 0.11.0 \note API not yet finalized

KleeneAnd

@Namespace(value="arrow::compute")
 @ByVal
public static Status KleeneAnd(FunctionContext context,
                                                                          @Const @ByRef
                                                                          Datum left,
                                                                          @Const @ByRef
                                                                          Datum right,
                                                                          Datum out)

\brief Element-wise AND of two boolean datums with a Kleene truth table (null and false is false).

Parameters:: context - [in] the FunctionContext; left - [in] left operand (array); right - [in] right operand (array); out - [out] resulting datum
Since:: 1.0.0 \note API not yet finalized

Or

@Namespace(value="arrow::compute")
 @ByVal
public static Status Or(FunctionContext context,
                                                                   @Const @ByRef
                                                                   Datum left,
                                                                   @Const @ByRef
                                                                   Datum right,
                                                                   Datum out)

\brief Element-wise OR of two boolean datums which always propagates nulls (null and true is null).

Parameters:: context - [in] the FunctionContext; left - [in] left operand (array); right - [in] right operand (array); out - [out] resulting datum
Since:: 0.11.0 \note API not yet finalized

KleeneOr

@Namespace(value="arrow::compute")
 @ByVal
public static Status KleeneOr(FunctionContext context,
                                                                         @Const @ByRef
                                                                         Datum left,
                                                                         @Const @ByRef
                                                                         Datum right,
                                                                         Datum out)

\brief Element-wise OR of two boolean datums with a Kleene truth table (null or true is true).

Parameters:: context - [in] the FunctionContext; left - [in] left operand (array); right - [in] right operand (array); out - [out] resulting datum
Since:: 1.0.0 \note API not yet finalized

Xor

@Namespace(value="arrow::compute")
 @ByVal
public static Status Xor(FunctionContext context,
                                                                    @Const @ByRef
                                                                    Datum left,
                                                                    @Const @ByRef
                                                                    Datum right,
                                                                    Datum out)

\brief Element-wise XOR of two boolean datums

Parameters:: context - [in] the FunctionContext; left - [in] left operand (array); right - [in] right operand (array); out - [out] resulting datum
Since:: 0.11.0 \note API not yet finalized

GetCastFunction

@Namespace(value="arrow::compute")
 @ByVal
public static Status GetCastFunction(@Const @ByRef
                                                                                DataType in_type,
                                                                                @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                DataType to_type,
                                                                                @Const @ByRef
                                                                                CastOptions options,
                                                                                @UniquePtr
                                                                                UnaryKernel kernel)

Since:: 0.7.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static Status Cast(FunctionContext context,
                                                                     @Const @ByRef
                                                                     Array value,
                                                                     @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                     DataType to_type,
                                                                     @Const @ByRef
                                                                     CastOptions options,
                                                                     @SharedPtr
                                                                     Array out)

\brief Cast from one array type to another

Parameters:: context - [in] the FunctionContext; value - [in] array to cast; to_type - [in] type to cast to; options - [in] casting options; out - [out] resulting array
Since:: 0.7.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static Status Cast(FunctionContext context,
                                                                     @Const @ByRef
                                                                     Datum value,
                                                                     @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                     DataType to_type,
                                                                     @Const @ByRef
                                                                     CastOptions options,
                                                                     Datum out)

\brief Cast from one value to another

Parameters:: context - [in] the FunctionContext; value - [in] datum to cast; to_type - [in] type to cast to; options - [in] casting options; out - [out] resulting datum
Since:: 0.8.0 \note API not yet finalized

Compare

@Namespace(value="arrow::compute")
 @ByVal
public static Status Compare(FunctionContext context,
                                                                        @Const @ByRef
                                                                        Datum left,
                                                                        @Const @ByRef
                                                                        Datum right,
                                                                        @ByVal
                                                                        CompareOptions options,
                                                                        Datum out)

\brief Compare a numeric array with a scalar.

Parameters:: context - [in] the FunctionContext; left - [in] datum to compare, must be an Array; right - [in] datum to compare, must be a Scalar of the same type than left Datum.; options - [in] compare options; out - [out] resulting datum Note on floating point arrays, this uses ieee-754 compare semantics.
Since:: 0.14.0 \note API not yet finalized

Count

@Namespace(value="arrow::compute")
 @ByVal
public static Status Count(FunctionContext context,
                                                                      @Const @ByRef
                                                                      CountOptions options,
                                                                      @Const @ByRef
                                                                      Datum datum,
                                                                      Datum out)

\brief Count non-null (or null) values in an array.

Parameters:: context - [in] the FunctionContext; options - [in] counting options, see CountOptions for more information; datum - [in] to count; out - [out] resulting datum
Since:: 0.13.0 \note API not yet finalized

Count

@Namespace(value="arrow::compute")
 @ByVal
public static Status Count(FunctionContext context,
                                                                      @Const @ByRef
                                                                      CountOptions options,
                                                                      @Const @ByRef
                                                                      Array array,
                                                                      Datum out)

\brief Count non-null (or null) values in an array.

Parameters:: context - [in] the FunctionContext; options - [in] counting options, see CountOptions for more information; array - [in] to count; out - [out] resulting datum
Since:: 0.13.0 \note API not yet finalized

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       Array values,
                                                                       @Const @ByRef
                                                                       Array filter,
                                                                       @SharedPtr
                                                                       Array out)

\brief Filter an array with a boolean selection filter The output array will be populated with values from the input at positions where the selection filter is not 0. Nulls in the filter will result in nulls in the output. For example given values = ["a", "b", "c", null, "e", "f"] and filter = [0, 1, 1, 0, null, 1], the output will be = ["b", "c", null, "f"]

Parameters:: ctx - [in] the FunctionContext; values - [in] array to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting array

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       ChunkedArray values,
                                                                       @Const @ByRef
                                                                       Array filter,
                                                                       @SharedPtr
                                                                       ChunkedArray out)

\brief Filter a chunked array with a boolean selection filter The output chunked array will be populated with values from the input at positions where the selection filter is not 0. Nulls in the filter will result in nulls in the output. For example given values = ["a", "b", "c", null, "e", "f"] and filter = [0, 1, 1, 0, null, 1], the output will be = ["b", "c", null, "f"]

Parameters:: ctx - [in] the FunctionContext; values - [in] chunked array to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting chunked array NOTE: Experimental API

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       ChunkedArray values,
                                                                       @Const @ByRef
                                                                       ChunkedArray filter,
                                                                       @SharedPtr
                                                                       ChunkedArray out)

Parameters:: ctx - [in] the FunctionContext; values - [in] chunked array to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting chunked array NOTE: Experimental API

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       RecordBatch batch,
                                                                       @Const @ByRef
                                                                       Array filter,
                                                                       @SharedPtr
                                                                       RecordBatch out)

\brief Filter a record batch with a boolean selection filter The output record batch's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0. Nulls in the filter will result in nulls in the output.

Parameters:: ctx - [in] the FunctionContext; batch - [in] record batch to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting record batch NOTE: Experimental API

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       Table table,
                                                                       @Const @ByRef
                                                                       Array filter,
                                                                       @SharedPtr
                                                                       Table out)

\brief Filter a table with a boolean selection filter The output table's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0. Nulls in the filter will result in nulls in each column of the output.

Parameters:: ctx - [in] the FunctionContext; table - [in] table to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting table NOTE: Experimental API

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       Table table,
                                                                       @Const @ByRef
                                                                       ChunkedArray filter,
                                                                       @SharedPtr
                                                                       Table out)

\brief Filter a table with a boolean selection filter The output record batch's columns will be populated with values from corresponding columns of the input at positions where the selection filter is not 0. Nulls in the filter will result in nulls in the output.

Parameters:: ctx - [in] the FunctionContext; table - [in] record batch to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting record batch NOTE: Experimental API

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static Status Filter(FunctionContext ctx,
                                                                       @Const @ByRef
                                                                       Datum values,
                                                                       @Const @ByRef
                                                                       Datum filter,
                                                                       Datum out)

\brief Filter an array with a boolean selection filter

Parameters:: ctx - [in] the FunctionContext; values - [in] datum to filter; filter - [in] indicates which values should be filtered out; out - [out] resulting datum

Unique

@Namespace(value="arrow::compute")
 @ByVal
public static Status Unique(FunctionContext context,
                                                                       @Const @ByRef
                                                                       Datum datum,
                                                                       @SharedPtr
                                                                       Array out)

\brief Compute unique elements from an array-like object Note if a null occurs in the input it will NOT be included in the output.

Parameters:: context - [in] the FunctionContext; datum - [in] array-like input; out - [out] result as Array
Since:: 0.8.0 \note API not yet finalized

kValuesFieldName

@Namespace(value="arrow::compute")
 @MemberGetter
public static byte kValuesFieldName(int i)

kValuesFieldName

@Namespace(value="arrow::compute")
 @MemberGetter
public static String kValuesFieldName()

kCountsFieldName

@Namespace(value="arrow::compute")
 @MemberGetter
public static byte kCountsFieldName(int i)

kCountsFieldName

@Namespace(value="arrow::compute")
 @MemberGetter
public static String kCountsFieldName()

kValuesFieldIndex

@Namespace(value="arrow::compute")
 @MemberGetter
public static int kValuesFieldIndex()

kCountsFieldIndex

@Namespace(value="arrow::compute")
 @MemberGetter
public static int kCountsFieldIndex()

ValueCounts

@Namespace(value="arrow::compute")
 @ByVal
public static Status ValueCounts(FunctionContext context,
                                                                            @Const @ByRef
                                                                            Datum value,
                                                                            @SharedPtr
                                                                            Array counts)

\brief Return counts of unique elements from an array-like object. Note that the counts do not include counts for nulls in the array. These can be obtained separately from metadata. For floating point arrays there is no attempt to normalize -0.0, 0.0 and NaN values which can lead to unexpected results if the input Array has these values.

Parameters:: context - [in] the FunctionContext; value - [in] array-like input; counts - [out] An array of structs.
Since:: 0.13.0 \note API not yet finalized

DictionaryEncode

@Namespace(value="arrow::compute")
 @ByVal
public static Status DictionaryEncode(FunctionContext context,
                                                                                 @Const @ByRef
                                                                                 Datum data,
                                                                                 Datum out)

\brief Dictionary-encode values in an array-like object

Parameters:: context - [in] the FunctionContext; data - [in] array-like input; out - [out] result with same shape and type as input
Since:: 0.8.0 \note API not yet finalized

IsIn

@Namespace(value="arrow::compute")
 @ByVal
public static Status IsIn(FunctionContext context,
                                                                     @Const @ByRef
                                                                     Datum left,
                                                                     @Const @ByRef
                                                                     Datum right,
                                                                     Datum out)

\brief IsIn returns boolean values if the value is in both left and right arrays. If null occurs in left, if null count in right is not 0, it returns true, else returns null.

Parameters:: context - [in] the FunctionContext; left - [in] array-like input; right - [in] array-like input; out - [out] resulting datum
Since:: 1.0.0 \note API not yet finalized

MakeMeanAggregateFunction

@Namespace(value="arrow::compute")
 @SharedPtr
public static AggregateFunction MakeMeanAggregateFunction(@Const @ByRef
                                                                                                         DataType type,
                                                                                                         FunctionContext context)

Mean

@Namespace(value="arrow::compute")
 @ByVal
public static Status Mean(FunctionContext context,
                                                                     @Const @ByRef
                                                                     Datum value,
                                                                     Datum mean)

\brief Compute the mean of a numeric array.

Parameters:: context - [in] the FunctionContext; value - [in] datum to compute the mean, expecting Array; mean - [out] datum of the computed mean as a DoubleScalar
Since:: 0.13.0 \note API not yet finalized

Mean

@Namespace(value="arrow::compute")
 @ByVal
public static Status Mean(FunctionContext context,
                                                                     @Const @ByRef
                                                                     Array array,
                                                                     Datum mean)

\brief Compute the mean of a numeric array.

Parameters:: context - [in] the FunctionContext; array - [in] to compute the mean; mean - [out] datum of the computed mean as a DoubleScalar
Since:: 0.13.0 \note API not yet finalized

SortToIndices

@Namespace(value="arrow::compute")
 @ByVal
public static Status SortToIndices(FunctionContext ctx,
                                                                              @Const @ByRef
                                                                              Array values,
                                                                              @SharedPtr
                                                                              Array offsets)

\brief Returns the indices that would sort an array. Perform an indirect sort of array. The output array will contain indices that would sort an array, which would be the same length as input. Nulls will be stably partitioned to the end of the output. For example given values = [null, 1, 3.3, null, 2, 5.3], the output will be [1, 4, 2, 5, 0, 3]

Parameters:: ctx - [in] the FunctionContext; values - [in] array to sort; offsets - [out] indices that would sort an array

MakeSumAggregateFunction

@Namespace(value="arrow::compute")
 @SharedPtr
public static AggregateFunction MakeSumAggregateFunction(@Const @ByRef
                                                                                                        DataType type,
                                                                                                        FunctionContext context)

\brief Return a Sum Kernel

Parameters:: type - [in] required to specialize the kernel; context - [in] the FunctionContext
Since:: 0.13.0 \note API not yet finalized

Sum

@Namespace(value="arrow::compute")
 @ByVal
public static Status Sum(FunctionContext context,
                                                                    @Const @ByRef
                                                                    Datum value,
                                                                    Datum out)

\brief Sum values of a numeric array.

Parameters:: context - [in] the FunctionContext; value - [in] datum to sum, expecting Array or ChunkedArray; out - [out] resulting datum
Since:: 0.13.0 \note API not yet finalized

Sum

@Namespace(value="arrow::compute")
 @ByVal
public static Status Sum(FunctionContext context,
                                                                    @Const @ByRef
                                                                    Array array,
                                                                    Datum out)

\brief Sum values of a numeric array.

Parameters:: context - [in] the FunctionContext; array - [in] to sum; out - [out] resulting datum
Since:: 0.13.0 \note API not yet finalized

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     Array values,
                                                                     @Const @ByRef
                                                                     Array indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     Array out)

\brief Take from an array of values at indices in another array The output array will be of the same type as the input values array, with elements taken from the values array at the given indices. If an index is null then the taken element will be null. For example given values = ["a", "b", "c", null, "e", "f"] and indices = [2, 1, null, 3], the output will be = [values[2], values[1], null, values[3]] = ["c", "b", null, null]

Parameters:: ctx - [in] the FunctionContext; values - [in] array from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting array

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     ChunkedArray values,
                                                                     @Const @ByRef
                                                                     Array indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     ChunkedArray out)

\brief Take from a chunked array of values at indices in another array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices. If an index is null then the taken element will be null. For example given values = ["a", "b", "c", null, "e", "f"] and indices = [2, 1, null, 3], the output will be = [values[2], values[1], null, values[3]] = ["c", "b", null, null]

Parameters:: ctx - [in] the FunctionContext; values - [in] chunked array from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting chunked array NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     ChunkedArray values,
                                                                     @Const @ByRef
                                                                     ChunkedArray indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     ChunkedArray out)

\brief Take from a chunked array of values at indices in a chunked array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices. If an index is null then the taken element will be null. The chunks in the output array will align with the chunks in the indices. For example given values = ["a", "b", "c", null, "e", "f"] and indices = [2, 1, null, 3], the output will be = [values[2], values[1], null, values[3]] = ["c", "b", null, null]

Parameters:: ctx - [in] the FunctionContext; values - [in] chunked array from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting chunked array NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     Array values,
                                                                     @Const @ByRef
                                                                     ChunkedArray indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     ChunkedArray out)

\brief Take from an array of values at indices in a chunked array The output chunked array will be of the same type as the input values array, with elements taken from the values array at the given indices. If an index is null then the taken element will be null. The chunks in the output array will align with the chunks in the indices. For example given values = ["a", "b", "c", null, "e", "f"] and indices = [2, 1, null, 3], the output will be = [values[2], values[1], null, values[3]] = ["c", "b", null, null]

Parameters:: ctx - [in] the FunctionContext; values - [in] array from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting chunked array NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     RecordBatch batch,
                                                                     @Const @ByRef
                                                                     Array indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     RecordBatch out)

\brief Take from a record batch at indices in another array The output batch will have the same schema as the input batch, with rows taken from the columns in the batch at the given indices. If an index is null then the taken element will be null.

Parameters:: ctx - [in] the FunctionContext; batch - [in] record batch from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting record batch NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     Table table,
                                                                     @Const @ByRef
                                                                     Array indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     Table out)

\brief Take from a table at indices in an array The output table will have the same schema as the input table, with rows taken from the columns in the table at the given indices. If an index is null then the taken element will be null.

Parameters:: ctx - [in] the FunctionContext; table - [in] table from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting table NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     Table table,
                                                                     @Const @ByRef
                                                                     ChunkedArray indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     @SharedPtr
                                                                     Table out)

\brief Take from a table at indices in a chunked array The output table will have the same schema as the input table, with rows taken from the values array at the given indices. If an index is null then the taken element will be null.

Parameters:: ctx - [in] the FunctionContext; table - [in] table from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting table NOTE: Experimental API

Take

@Namespace(value="arrow::compute")
 @ByVal
public static Status Take(FunctionContext ctx,
                                                                     @Const @ByRef
                                                                     Datum values,
                                                                     @Const @ByRef
                                                                     Datum indices,
                                                                     @Const @ByRef
                                                                     TakeOptions options,
                                                                     Datum out)

\brief Take from an array of values at indices in another array

Parameters:: ctx - [in] the FunctionContext; values - [in] datum from which to take; indices - [in] which values to take; options - [in] options; out - [out] resulting datum

CollectDictionaries

@Namespace(value="arrow::ipc")
 @ByVal
public static Status CollectDictionaries(@Const @ByRef
                                                                                RecordBatch batch,
                                                                                DictionaryMemo memo)

kFeatherVersion

@Namespace(value="arrow::ipc::feather")
 @MemberGetter
public static int kFeatherVersion()

ArrayFromJSON

@Namespace(value="arrow::ipc::internal::json")
 @ByVal
public static Status ArrayFromJSON(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                          DataType arg0,
                                                                                          @StdString
                                                                                          String json,
                                                                                          @SharedPtr
                                                                                          Array out)

\class TableReader \brief An interface for reading columns from Feather files

ArrayFromJSON

@Namespace(value="arrow::ipc::internal::json")
 @ByVal
public static Status ArrayFromJSON(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                          DataType arg0,
                                                                                          @StdString
                                                                                          BytePointer json,
                                                                                          @SharedPtr
                                                                                          Array out)

kMaxNestingDepth

@Namespace(value="arrow::ipc")
 @MemberGetter
public static int kMaxNestingDepth()

FormatMessageType

@Namespace(value="arrow::ipc")
 @StdString
public static String FormatMessageType(Message.Type type)

FormatMessageType

@Namespace(value="arrow::ipc")
 @StdString
public static BytePointer FormatMessageType(@Cast(value="arrow::ipc::Message::Type")
                                                                                       int type)

ReadMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadMessage(@Cast(value="const int64_t")
                                                                        long offset,
                                                                        int metadata_length,
                                                                        RandomAccessFile file,
                                                                        @UniquePtr
                                                                        Message message)

\brief Read encapsulated RPC message from position in file Read a length-prefixed message flatbuffer starting at the indicated file offset. If the message has a body with non-zero length, it will also be read The metadata_length includes at least the length prefix and the flatbuffer

Parameters:: offset - [in] the position in the file where the message starts. The first 4 bytes after the offset are the message length; metadata_length - [in] the total number of bytes to read from file; file - [in] the seekable file interface to read from; message - [out] the message read
Returns:: Status success or failure

AlignStream
```
@Namespace(value="arrow::ipc")
 @ByVal
public static Status AlignStream(InputStream stream,
                                                                        int alignment)
```
\brief Advance stream to an 8-byte offset if its position is not a multiple of 8 already

Parameters:

stream - [in] an input stream

alignment - [in] the byte multiple for the metadata prefix, usually 8 or 64, to ensure the body starts on a multiple of that alignment

Returns:

Status

AlignStream

@Namespace(value="arrow::ipc")
 @ByVal
public static Status AlignStream(InputStream stream)

AlignStream
```
@Namespace(value="arrow::ipc")
 @ByVal
public static Status AlignStream(OutputStream stream,
                                                                        int alignment)
```
\brief Advance stream to an 8-byte offset if its position is not a multiple of 8 already

Parameters:

stream - [in] an output stream

alignment - [in] the byte multiple for the metadata prefix, usually 8 or 64, to ensure the body starts on a multiple of that alignment

Returns:

Status

AlignStream

@Namespace(value="arrow::ipc")
 @ByVal
public static Status AlignStream(OutputStream stream)

CheckAligned

@Namespace(value="arrow::ipc")
 @ByVal
public static Status CheckAligned(FileInterface stream,
                                                                         int alignment)

\brief Return error Status if file position is not a multiple of the indicated alignment

CheckAligned

@Namespace(value="arrow::ipc")
 @ByVal
public static Status CheckAligned(FileInterface stream)

ReadMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadMessage(InputStream stream,
                                                                        @UniquePtr
                                                                        Message message)

\brief Read encapsulated IPC message (metadata and body) from InputStream Returns null if there are not enough bytes available or the message length is 0 (e.g. EOS in a stream)

ReadMessageCopy

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadMessageCopy(InputStream stream,
                                                                            MemoryPool pool,
                                                                            @UniquePtr
                                                                            Message message)

\brief Read encapsulated IPC message (metadata and body) from InputStream Like ReadMessage, except that the metadata is copied in a new buffer. This is necessary if the stream returns non-CPU buffers.

ReadSchema

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadSchema(InputStream stream,
                                                                       DictionaryMemo dictionary_memo,
                                                                       @SharedPtr
                                                                       Schema out)

\brief Read Schema from stream serialized as a single IPC message and populate any dictionary-encoded fields into a DictionaryMemo

Parameters:: stream - [in] an InputStream; dictionary_memo - [in] for recording dictionary-encoded fields; out - [out] the output Schema
Returns:: Status If record batches follow the schema, it is better to use RecordBatchStreamReader

ReadSchema

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadSchema(@Const @ByRef
                                                                       Message message,
                                                                       DictionaryMemo dictionary_memo,
                                                                       @SharedPtr
                                                                       Schema out)

\brief Read Schema from encapsulated Message

Parameters:: message - [in] a message instance containing metadata; dictionary_memo - [in] DictionaryMemo for recording dictionary-encoded fields. Can be nullptr if you are sure there are no dictionary-encoded fields; out - [out] the resulting Schema
Returns:: Status

ReadRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadRecordBatch(@Const @SharedPtr @ByRef
                                                                            Schema schema,
                                                                            @Const
                                                                            DictionaryMemo dictionary_memo,
                                                                            InputStream stream,
                                                                            @SharedPtr
                                                                            RecordBatch out)

Read record batch as encapsulated IPC message with metadata size prefix and header

Parameters:: schema - [in] the record batch schema; dictionary_memo - [in] DictionaryMemo which has any dictionaries. Can be nullptr if you are sure there are no dictionary-encoded fields; stream - [in] the file where the batch is located; out - [out] the read record batch
Returns:: Status

ReadRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadRecordBatch(@Const @ByRef
                                                                            ArrowBuffer metadata,
                                                                            @Const @SharedPtr @ByRef
                                                                            Schema schema,
                                                                            @Const
                                                                            DictionaryMemo dictionary_memo,
                                                                            RandomAccessFile file,
                                                                            @SharedPtr
                                                                            RecordBatch out)

\brief Read record batch from file given metadata and schema

Parameters:: metadata - [in] a Message containing the record batch metadata; schema - [in] the record batch schema; dictionary_memo - [in] DictionaryMemo which has any dictionaries. Can be nullptr if you are sure there are no dictionary-encoded fields; file - [in] a random access file; out - [out] the read record batch
Returns:: Status

ReadRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadRecordBatch(@Const @ByRef
                                                                            Message message,
                                                                            @Const @SharedPtr @ByRef
                                                                            Schema schema,
                                                                            @Const
                                                                            DictionaryMemo dictionary_memo,
                                                                            @SharedPtr
                                                                            RecordBatch out)

\brief Read record batch from encapsulated Message

Parameters:: message - [in] a message instance containing metadata and body; schema - [in] the record batch schema; dictionary_memo - [in] DictionaryMemo which has any dictionaries. Can be nullptr if you are sure there are no dictionary-encoded fields; out - [out] the resulting RecordBatch
Returns:: Status

ReadRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ReadRecordBatch(@Const @ByRef
                                                                            ArrowBuffer metadata,
                                                                            @Const @SharedPtr @ByRef
                                                                            Schema schema,
                                                                            @Const
                                                                            DictionaryMemo dictionary_memo,
                                                                            @Const @ByRef
                                                                            IpcOptions options,
                                                                            RandomAccessFile file,
                                                                            @SharedPtr
                                                                            RecordBatch out)

Read record batch from file given metadata and schema

Parameters:: metadata - [in] a Message containing the record batch metadata; schema - [in] the record batch schema; dictionary_memo - [in] DictionaryMemo which has any dictionaries. Can be nullptr if you are sure there are no dictionary-encoded fields; file - [in] a random access file; options - [in] options for deserialization; out - [out] the read record batch
Returns:: Status

ReadTensor
```
@Namespace(value="arrow::ipc")
 @ByVal
public static TensorResult ReadTensor(InputStream file)
```
\brief Read arrow::Tensor as encapsulated IPC message in file

Parameters:

file - [in] an InputStream pointed at the start of the message

Returns:

the read tensor

ReadTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static TensorResult ReadTensor(@Const @ByRef
                                                                             Message message)

\brief EXPERIMENTAL: Read arrow::Tensor from IPC message

Parameters:: message - [in] a Message containing the tensor metadata and body
Returns:: the read tensor

ReadSparseTensorBodyBufferCount

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static SizeTResult ReadSparseTensorBodyBufferCount(@Const @ByRef
                                                                                                           ArrowBuffer metadata)

\brief EXPERIMENTAL: Read arrow::SparseTensorFormat::type from a metadata

Parameters:: metadata - [in] a Buffer containing the sparse tensor metadata
Returns:: the count of the body buffers

ReadSparseTensorPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static SparseTensorResult ReadSparseTensorPayload(@Const @ByRef
                                                                                                          IpcPayload payload)

\brief EXPERIMENTAL: Read arrow::SparseTensor from an IpcPayload

Parameters:: payload - [in] a IpcPayload contains a serialized SparseTensor
Returns:: the read sparse tensor

FuzzIpcStream

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcStream(@Cast(value="const uint8_t*")
                                                                                    BytePointer data,
                                                                                    @Cast(value="int64_t")
                                                                                    long size)

FuzzIpcStream

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcStream(@Cast(value="const uint8_t*")
                                                                                    ByteBuffer data,
                                                                                    @Cast(value="int64_t")
                                                                                    long size)

FuzzIpcStream

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcStream(@Cast(value="const uint8_t*")
                                                                                    byte[] data,
                                                                                    @Cast(value="int64_t")
                                                                                    long size)

FuzzIpcFile

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcFile(@Cast(value="const uint8_t*")
                                                                                  BytePointer data,
                                                                                  @Cast(value="int64_t")
                                                                                  long size)

FuzzIpcFile

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcFile(@Cast(value="const uint8_t*")
                                                                                  ByteBuffer data,
                                                                                  @Cast(value="int64_t")
                                                                                  long size)

FuzzIpcFile

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcFile(@Cast(value="const uint8_t*")
                                                                                  byte[] data,
                                                                                  @Cast(value="int64_t")
                                                                                  long size)

WriteRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteRecordBatch(@Const @ByRef
                                                                             RecordBatch batch,
                                                                             @Cast(value="int64_t")
                                                                             long buffer_start_offset,
                                                                             OutputStream dst,
                                                                             IntPointer metadata_length,
                                                                             @Cast(value="int64_t*")
                                                                             LongPointer body_length,
                                                                             @Const @ByRef
                                                                             IpcOptions options,
                                                                             MemoryPool pool)

\brief Low-level API for writing a record batch (without schema) to an OutputStream as encapsulated IPC message. See Arrow format documentation for more detail.

Parameters:: batch - [in] the record batch to write; buffer_start_offset - [in] the start offset to use in the buffer metadata, generally should be 0; dst - [in] an OutputStream; metadata_length - [out] the size of the length-prefixed flatbuffer including padding to a 64-byte boundary; body_length - [out] the size of the contiguous buffer block plus; options - [in] options for serialization; pool - [in] the memory pool to allocate memory from
Returns:: Status

WriteRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteRecordBatch(@Const @ByRef
                                                                             RecordBatch batch,
                                                                             @Cast(value="int64_t")
                                                                             long buffer_start_offset,
                                                                             OutputStream dst,
                                                                             IntBuffer metadata_length,
                                                                             @Cast(value="int64_t*")
                                                                             LongBuffer body_length,
                                                                             @Const @ByRef
                                                                             IpcOptions options,
                                                                             MemoryPool pool)

WriteRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteRecordBatch(@Const @ByRef
                                                                             RecordBatch batch,
                                                                             @Cast(value="int64_t")
                                                                             long buffer_start_offset,
                                                                             OutputStream dst,
                                                                             int[] metadata_length,
                                                                             @Cast(value="int64_t*")
                                                                             long[] body_length,
                                                                             @Const @ByRef
                                                                             IpcOptions options,
                                                                             MemoryPool pool)

SerializeRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status SerializeRecordBatch(@Const @ByRef
                                                                                 RecordBatch batch,
                                                                                 MemoryPool pool,
                                                                                 @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                                 ArrowBuffer out)

\brief Serialize record batch as encapsulated IPC message in a new buffer

Parameters:: batch - [in] the record batch; pool - [in] a MemoryPool to allocate memory from; out - [out] the serialized message
Returns:: Status

SerializeRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static Status SerializeRecordBatch(@Const @ByRef
                                                                                 RecordBatch batch,
                                                                                 MemoryPool pool,
                                                                                 OutputStream out)

\brief Write record batch to OutputStream

Parameters:: batch - [in] the record batch to write; pool - [in] a MemoryPool to use for temporary allocations, if needed; out - [in] the OutputStream to write the output to
Returns:: Status If writing to pre-allocated memory, you can use arrow::ipc::GetRecordBatchSize to compute how much space is required

SerializeSchema

@Namespace(value="arrow::ipc")
 @ByVal
public static Status SerializeSchema(@Const @ByRef
                                                                            Schema schema,
                                                                            DictionaryMemo dictionary_memo,
                                                                            MemoryPool pool,
                                                                            @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                                                            ArrowBuffer out)

\brief Serialize schema as encapsulated IPC message

Parameters:: schema - [in] the schema to write; dictionary_memo - [in] a DictionaryMemo for recording dictionary ids; pool - [in] a MemoryPool to allocate memory from; out - [out] the serialized schema
Returns:: Status

WriteRecordBatchStream

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteRecordBatchStream(@Const @ByRef
                                                                                   RecordBatchVector batches,
                                                                                   @Const @ByRef
                                                                                   IpcOptions options,
                                                                                   OutputStream dst)

\brief Write multiple record batches to OutputStream, including schema

Parameters:: batches - [in] a vector of batches. Must all have same schema; options - [in] options for serialization; dst - [out] an OutputStream
Returns:: Status

GetRecordBatchSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetRecordBatchSize(@Const @ByRef
                                                                               RecordBatch batch,
                                                                               @Cast(value="int64_t*")
                                                                               LongPointer size)

\brief Compute the number of bytes needed to write a record batch including metadata

Parameters:: batch - [in] the record batch to write; size - [out] the size of the complete encapsulated message
Returns:: Status

GetRecordBatchSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetRecordBatchSize(@Const @ByRef
                                                                               RecordBatch batch,
                                                                               @Cast(value="int64_t*")
                                                                               LongBuffer size)

GetRecordBatchSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetRecordBatchSize(@Const @ByRef
                                                                               RecordBatch batch,
                                                                               @Cast(value="int64_t*")
                                                                               long[] size)

GetTensorSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetTensorSize(@Const @ByRef
                                                                          Tensor tensor,
                                                                          @Cast(value="int64_t*")
                                                                          LongPointer size)

\brief Compute the number of bytes needed to write a tensor including metadata

Parameters:: tensor - [in] the tensor to write; size - [out] the size of the complete encapsulated message
Returns:: Status

GetTensorSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetTensorSize(@Const @ByRef
                                                                          Tensor tensor,
                                                                          @Cast(value="int64_t*")
                                                                          LongBuffer size)

GetTensorSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetTensorSize(@Const @ByRef
                                                                          Tensor tensor,
                                                                          @Cast(value="int64_t*")
                                                                          long[] size)

GetTensorMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetTensorMessage(@Const @ByRef
                                                                             Tensor tensor,
                                                                             MemoryPool pool,
                                                                             @UniquePtr
                                                                             Message out)

\brief EXPERIMENTAL: Convert arrow::Tensor to a Message with minimal memory allocation

Parameters:: tensor - [in] the Tensor to write; pool - [in] MemoryPool to allocate space for metadata; out - [out] the resulting Message
Returns:: Status

WriteTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteTensor(@Const @ByRef
                                                                        Tensor tensor,
                                                                        OutputStream dst,
                                                                        IntPointer metadata_length,
                                                                        @Cast(value="int64_t*")
                                                                        LongPointer body_length)

\brief Write arrow::Tensor as a contiguous message. The metadata and body are written assuming 64-byte alignment. It is the user's responsibility to ensure that the OutputStream has been aligned to a 64-byte multiple before writing the message. The message is written out as followed:


  <metadata size> <metadata> <tensor data>

Parameters:: tensor - [in] the Tensor to write; dst - [in] the OutputStream to write to; metadata_length - [out] the actual metadata length, including padding; body_length - [out] the actual message body length
Returns:: Status

WriteTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteTensor(@Const @ByRef
                                                                        Tensor tensor,
                                                                        OutputStream dst,
                                                                        IntBuffer metadata_length,
                                                                        @Cast(value="int64_t*")
                                                                        LongBuffer body_length)

WriteTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteTensor(@Const @ByRef
                                                                        Tensor tensor,
                                                                        OutputStream dst,
                                                                        int[] metadata_length,
                                                                        @Cast(value="int64_t*")
                                                                        long[] body_length)

GetSparseTensorMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetSparseTensorMessage(@Const @ByRef
                                                                                   SparseTensor sparse_tensor,
                                                                                   MemoryPool pool,
                                                                                   @UniquePtr
                                                                                   Message out)

\brief EXPERIMENTAL: Convert arrow::SparseTensor to a Message with minimal memory allocation The message is written out as followed:


  <metadata size> <metadata> <sparse index> <sparse tensor body>

Parameters:: sparse_tensor - [in] the SparseTensor to write; pool - [in] MemoryPool to allocate space for metadata; out - [out] the resulting Message
Returns:: Status

WriteSparseTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteSparseTensor(@Const @ByRef
                                                                              SparseTensor sparse_tensor,
                                                                              OutputStream dst,
                                                                              IntPointer metadata_length,
                                                                              @Cast(value="int64_t*")
                                                                              LongPointer body_length)

\brief EXPERIMENTAL: Write arrow::SparseTensor as a contiguous message. The metadata, sparse index, and body are written assuming 64-byte alignment. It is the user's responsibility to ensure that the OutputStream has been aligned to a 64-byte multiple before writing the message.

Parameters:: sparse_tensor - [in] the SparseTensor to write; dst - [in] the OutputStream to write to; metadata_length - [out] the actual metadata length, including padding; body_length - [out] the actual message body length
Returns:: Status

WriteSparseTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteSparseTensor(@Const @ByRef
                                                                              SparseTensor sparse_tensor,
                                                                              OutputStream dst,
                                                                              IntBuffer metadata_length,
                                                                              @Cast(value="int64_t*")
                                                                              LongBuffer body_length)

WriteSparseTensor

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteSparseTensor(@Const @ByRef
                                                                              SparseTensor sparse_tensor,
                                                                              OutputStream dst,
                                                                              int[] metadata_length,
                                                                              @Cast(value="int64_t*")
                                                                              long[] body_length)

OpenRecordBatchWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status OpenRecordBatchWriter(@UniquePtr
                                                                                            IpcPayloadWriter sink,
                                                                                            @Const @SharedPtr @ByRef
                                                                                            Schema schema,
                                                                                            @UniquePtr
                                                                                            RecordBatchWriter out)

Create a new RecordBatchWriter from IpcPayloadWriter and schema.

Parameters:: sink - [in] the IpcPayloadWriter to write to; schema - [in] the schema of the record batches to be written; out - [out] the created RecordBatchWriter
Returns:: Status

OpenRecordBatchWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static RecordBatchWriterUniqueResult OpenRecordBatchWriter(@UniquePtr
                                                                                                                   IpcPayloadWriter sink,
                                                                                                                   @Const @SharedPtr @ByRef
                                                                                                                   Schema schema,
                                                                                                                   @Const @ByRef
                                                                                                                   IpcOptions options)

Create a new RecordBatchWriter from IpcPayloadWriter and schema.

Parameters:: sink - [in] the IpcPayloadWriter to write to; schema - [in] the schema of the record batches to be written; options - [in] options for serialization
Returns:: Result>

GetSchemaPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status GetSchemaPayload(@Const @ByRef
                                                                                       Schema schema,
                                                                                       @Const @ByRef
                                                                                       IpcOptions options,
                                                                                       DictionaryMemo dictionary_memo,
                                                                                       IpcPayload out)

\brief Compute IpcPayload for the given schema

Parameters:: schema - [in] the Schema that is being serialized; options - [in] options for serialization; dictionary_memo - [in,out] class to populate with assigned dictionary ids; out - [out] the returned vector of IpcPayloads
Returns:: Status

GetDictionaryPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status GetDictionaryPayload(@Cast(value="int64_t")
                                                                                           long id,
                                                                                           @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Array>"})
                                                                                           Array dictionary,
                                                                                           @Const @ByRef
                                                                                           IpcOptions options,
                                                                                           MemoryPool pool,
                                                                                           IpcPayload payload)

\brief Compute IpcPayload for a dictionary

Parameters:: id - [in] the dictionary id; dictionary - [in] the dictionary values; options - [in] options for serialization; payload - [out] the output IpcPayload
Returns:: Status

GetRecordBatchPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status GetRecordBatchPayload(@Const @ByRef
                                                                                            RecordBatch batch,
                                                                                            @Const @ByRef
                                                                                            IpcOptions options,
                                                                                            MemoryPool pool,
                                                                                            IpcPayload out)

\brief Compute IpcPayload for the given record batch

Parameters:: batch - [in] the RecordBatch that is being serialized; options - [in] options for serialization; pool - [in,out] for any required temporary memory allocations; out - [out] the returned IpcPayload
Returns:: Status

WriteIpcPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status WriteIpcPayload(@Const @ByRef
                                                                                      IpcPayload payload,
                                                                                      @Const @ByRef
                                                                                      IpcOptions options,
                                                                                      OutputStream dst,
                                                                                      IntPointer metadata_length)

WriteIpcPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status WriteIpcPayload(@Const @ByRef
                                                                                      IpcPayload payload,
                                                                                      @Const @ByRef
                                                                                      IpcOptions options,
                                                                                      OutputStream dst,
                                                                                      IntBuffer metadata_length)

WriteIpcPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status WriteIpcPayload(@Const @ByRef
                                                                                      IpcPayload payload,
                                                                                      @Const @ByRef
                                                                                      IpcOptions options,
                                                                                      OutputStream dst,
                                                                                      int[] metadata_length)

GetSparseTensorPayload

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status GetSparseTensorPayload(@Const @ByRef
                                                                                             SparseTensor sparse_tensor,
                                                                                             MemoryPool pool,
                                                                                             IpcPayload out)

\brief Compute IpcPayload for the given sparse tensor

Parameters:: sparse_tensor - [in] the SparseTensor that is being serialized; pool - [in,out] for any required temporary memory allocations; out - [out] the returned IpcPayload
Returns:: Status

Class arrow

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.arrow.presets.arrow

Methods inherited from class java.lang.Object

Field Detail

ARROW_VERSION_MAJOR

ARROW_VERSION_MINOR

ARROW_VERSION_PATCH

ARROW_VERSION

ARROW_SO_VERSION

ARROW_FULL_SO_VERSION

ARROW_BITNESS

ARROW_LITTLE_ENDIAN

kDefaultAbsoluteTolerance

kNoSize

kFeatherVersion

Constructor Detail

arrow

Method Detail

ARROW_BITNESS

kUseDefaultCompressionLevel

ARROW_LITTLE_ENDIAN

kBytePopcount

kBytePopcount

CeilDiv

BytesForBits

IsPowerOf2

NextPower2

IsMultipleOf64

IsMultipleOf8

RoundUp

RoundDown

RoundUpToPowerOf2

RoundUpToMultipleOf8

RoundUpToMultipleOf64

CoveringBytes

TrailingBits

CountLeadingZeros

CountLeadingZeros

CountTrailingZeros

CountTrailingZeros

NumRequiredBits

Log2

ByteSwap

ByteSwap

ByteSwap

ByteSwap

kBitmask

kBitmask

kFlippedBitmask

kFlippedBitmask

kPrecedingBitmask

kPrecedingBitmask

kPrecedingWrappingBitmask

kPrecedingWrappingBitmask

kTrailingBitmask

kTrailingBitmask

GetBit

GetBit

GetBit

GetBitFromByte

ClearBit

ClearBit

ClearBit

SetBit

SetBit

SetBit

SetBitTo

SetBitTo

SetBitTo

SetBitsTo

SetBitsTo

SetBitsTo

BytesToBits

BytesToBits

BytesToBits

BytesToBits