arrow (JavaCPP Presets for Arrow 4.0.1-1.5.6 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`
`static class`	`arrow.DecimalStatus`
`static class`	`arrow.Endianness`
`static class`	`arrow.FileType` \brief FileSystem entry type
`static class`	`arrow.FutureState` A Future's execution or completion status
`static class`	`arrow.MessageType`
`static class`	`arrow.MetadataVersion`
`static class`	`arrow.SortOrder`
`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_CXX_COMPILER_FLAGS`
`static String`	`ARROW_CXX_COMPILER_ID`
`static String`	`ARROW_CXX_COMPILER_VERSION`
`static String`	`ARROW_FULL_SO_VERSION`
`static String`	`ARROW_GIT_DESCRIPTION`
`static String`	`ARROW_GIT_ID`
`static String`	`ARROW_PACKAGE_KIND`
`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 String`	`ARROW_VERSION_STRING`
`static double`	`kDefaultAbsoluteTolerance`
`static long`	`kDefaultExecChunksize`
`static int`	`kFeatherV1Version`
`static int`	`kFeatherV2Version`
`static long`	`kNoSize`

Constructor Summary

Constructors
Constructor and Description

arrow()

Constructors
Constructor and Description
`arrow()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated 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 BasicDecimal256`	`add(BasicDecimal256 left, BasicDecimal256 right)`
`static DatumResult`	`Add(Datum left, Datum right)`
`static DatumResult`	`Add(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \}
`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 DatumResult`	`All(Datum value)`
`static DatumResult`	`All(Datum value, ExecContext ctx)` \brief Test whether all elements in a boolean array evaluate to true.
`static Future`	`AllComplete(Future futures)` \brief Create a Future which completes when all of `futures` complete.
`static BufferUniqueResult`	`AllocateBuffer(long size)`
`static BufferUniqueResult`	`AllocateBuffer(long size, MemoryPool pool)` \defgroup buffer-allocation-functions Functions for allocating buffers \{
`static BufferResult`	`AllocateEmptyBitmap(long length)`
`static BufferResult`	`AllocateEmptyBitmap(long length, MemoryPool pool)` \brief Allocate a zero-initialized bitmap buffer from a memory pool
`static ResizableUniqueResult`	`AllocateResizableBuffer(long size)`
`static ResizableUniqueResult`	`AllocateResizableBuffer(long size, MemoryPool pool)` \brief Allocate a resizeable buffer from a memory pool, zero its padding.
`static DatumResult`	`And(Datum left, Datum right)`
`static DatumResult`	`And(Datum left, Datum right, ExecContext ctx)` \brief Element-wise AND of two boolean datums which always propagates nulls (null and false is null).
`static DatumResult`	`AndNot(Datum left, Datum right)`
`static DatumResult`	`AndNot(Datum left, Datum right, ExecContext ctx)` \brief Element-wise AND NOT of two boolean datums which always propagates nulls (null and not true is null).
`static DatumResult`	`Any(Datum value)`
`static DatumResult`	`Any(Datum value, ExecContext ctx)` \brief Test whether any element in a boolean array evaluates to true.
`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)`
`static boolean`	`ArrayRangeApproxEquals(Array left, Array right, long start_idx, long end_idx, long other_start_idx)`
`static boolean`	`ArrayRangeApproxEquals(Array left, Array right, long start_idx, long end_idx, long other_start_idx, EqualOptions arg5)` Returns true if indicated equal-length segment of arrays are approximately equal
`static boolean`	`ArrayRangeEquals(Array left, Array right, long start_idx, long end_idx, long other_start_idx)`
`static boolean`	`ArrayRangeEquals(Array left, Array right, long start_idx, long end_idx, long other_start_idx, EqualOptions arg5)` Returns true if indicated equal-length segment of arrays are exactly equal
`static int`	`ARROW_BITNESS()`
`static DataType`	`binary()` \brief Return a BinaryType instance
`static TypeMatcher`	`BinaryLike()`
`static int`	`bit_width(int type_id)`
`static long`	`BytesForBits(long bits)`
`static DatumResult`	`CallFunction(BytePointer func_name, DatumVector args)`
`static DatumResult`	`CallFunction(BytePointer func_name, DatumVector args, ExecContext ctx)`
`static DatumResult`	`CallFunction(BytePointer func_name, DatumVector args, FunctionOptions options)`
`static DatumResult`	`CallFunction(BytePointer func_name, DatumVector args, FunctionOptions options, ExecContext ctx)`
`static DatumResult`	`CallFunction(String func_name, DatumVector args)`
`static DatumResult`	`CallFunction(String func_name, DatumVector args, ExecContext ctx)` \brief Variant of CallFunction which uses a function's default options.
`static DatumResult`	`CallFunction(String func_name, DatumVector args, FunctionOptions options)`
`static DatumResult`	`CallFunction(String func_name, DatumVector args, FunctionOptions options, ExecContext ctx)` \defgroup compute-call-function One-shot calls to compute functions \{
`static boolean`	`CanCast(DataType from_type, DataType to_type)` \brief Return true if a cast function is defined
`static ArrayResult`	`Cast(Array value, DataType to_type)`
`static ArrayResult`	`Cast(Array value, DataType to_type, CastOptions options, ExecContext ctx)` \brief Cast from one array type to another
`static DatumResult`	`Cast(Datum value, CastOptions options)`
`static DatumResult`	`Cast(Datum value, CastOptions options, ExecContext ctx)` \brief Cast from one array type to another
`static DatumResult`	`Cast(Datum value, DataType to_type)`
`static DatumResult`	`Cast(Datum value, DataType to_type, CastOptions options, ExecContext ctx)` \brief Cast from one value to another
`static DatumVectorResult`	`Cast(DatumVector values, ValueDescrVector descrs)`
`static DatumVectorResult`	`Cast(DatumVector values, ValueDescrVector descrs, ExecContext ctx)` \brief Cast several values simultaneously.
`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 DictionaryVectorResult`	`CollectDictionaries(RecordBatch batch, DictionaryFieldMapper mapper)`
`static Status`	`CollectDictionaries(RecordBatch batch, DictionaryMemo memo)`
`static DatumResult`	`Compare(Datum left, Datum right, CompareOptions options)`
`static DatumResult`	`Compare(Datum left, Datum right, CompareOptions options, ExecContext ctx)` \brief Compare a numeric array with a scalar.
`static Status`	`ComputeColumnMajorStrides(FixedWidthType type, long[] shape, long[] strides)`
`static Status`	`ComputeColumnMajorStrides(FixedWidthType type, LongBuffer shape, LongBuffer strides)`
`static Status`	`ComputeColumnMajorStrides(FixedWidthType type, LongPointer shape, LongPointer strides)`
`static Status`	`ComputeRowMajorStrides(FixedWidthType type, long[] shape, long[] strides)`
`static Status`	`ComputeRowMajorStrides(FixedWidthType type, LongBuffer shape, LongBuffer strides)`
`static Status`	`ComputeRowMajorStrides(FixedWidthType type, LongPointer shape, LongPointer strides)`
`static ArrayResult`	`Concatenate(ArrayVector arrays)`
`static ArrayResult`	`Concatenate(ArrayVector arrays, MemoryPool pool)` \brief Concatenate arrays
`static Status`	`Concatenate(ArrayVector arrays, MemoryPool pool, Array out)` Deprecated.
`static TableResult`	`ConcatenateTables(TableVector tables)`
`static TableResult`	`ConcatenateTables(TableVector tables, ConcatenateTablesOptions options, MemoryPool memory_pool)` \brief Construct table from multiple input tables.
`static Status`	`CopyFiles(FileLocator sources, FileLocator destinations)`
`static Status`	`CopyFiles(FileLocator sources, FileLocator destinations, IOContext io_context, long chunk_size, boolean use_threads)` \}
`static Status`	`CopyFiles(FileSystem source_fs, FileSelector source_sel, FileSystem destination_fs, BytePointer destination_base_dir)`
`static Status`	`CopyFiles(FileSystem source_fs, FileSelector source_sel, FileSystem destination_fs, BytePointer destination_base_dir, IOContext io_context, long chunk_size, boolean use_threads)`
`static Status`	`CopyFiles(FileSystem source_fs, FileSelector source_sel, FileSystem destination_fs, String destination_base_dir)`
`static Status`	`CopyFiles(FileSystem source_fs, FileSelector source_sel, FileSystem destination_fs, String destination_base_dir, IOContext io_context, long chunk_size, boolean use_threads)` \brief Copy selected files, including from one FileSystem to another Directories will be created under the destination base directory as needed.
`static DatumResult`	`Count(Datum datum)`
`static DatumResult`	`Count(Datum datum, CountOptions options, ExecContext ctx)` \}
`static int`	`CountLeadingZeros(int value)` \brief Count the number of leading zeros in an unsigned integer.
`static int`	`CountLeadingZeros(long value)`
`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 DecimalType instance depending on the precision If the precision is greater than 38, a Decimal128Type is returned, otherwise a Decimal256Type.
`static DataType`	`decimal128(int precision, int scale)` \brief Create a Decimal128Type instance
`static DataType`	`decimal256(int precision, int scale)` \brief Create a Decimal256Type instance
`static Status`	`DecodeMessage(MessageDecoder decoder, InputStream stream)` \brief Feed data from InputStream to MessageDecoder to decode an encapsulated IPC message (metadata and body) This API is EXPERIMENTAL.
`static ExecContext`	`default_exec_context()`
`static IOContext`	`default_io_context()` EXPERIMENTAL: convenience global singleton for default IOContext settings
`static MemoryPool`	`default_memory_pool()` \}
`static DataType`	`dense_union(ArrayVector children)`
`static DataType`	`dense_union(ArrayVector children, StringVector field_names, byte[] type_codes)`
`static DataType`	`dense_union(ArrayVector children, StringVector field_names, ByteBuffer type_codes)`
`static DataType`	`dense_union(ArrayVector children, StringVector field_names, BytePointer type_codes)` \brief Create a DenseUnionType instance
`static DataType`	`dense_union(FieldVector child_fields)`
`static DataType`	`dense_union(FieldVector child_fields, byte[] type_codes)`
`static DataType`	`dense_union(FieldVector child_fields, ByteBuffer type_codes)`
`static DataType`	`dense_union(FieldVector child_fields, BytePointer type_codes)` \brief Create a DenseUnionType instance
`static boolean`	`DetectAbsolutePath(BytePointer s)`
`static boolean`	`DetectAbsolutePath(String s)` HDFS-backed FileSystem implementation.
`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 DatumResult`	`DictionaryEncode(Datum data)`
`static DatumResult`	`DictionaryEncode(Datum data, DictionaryEncodeOptions options, ExecContext ctx)` \brief Dictionary-encode values in an array-like object Any nulls encountered in the dictionary will be handled according to the specified null encoding behavior.
`static void`	`DieWithMessage(BytePointer msg)`
`static void`	`DieWithMessage(String msg)`
`static Kernel`	`DispatchExactImpl(Function func, ValueDescrVector arg1)` \brief Look up a kernel in a function.
`static BasicDecimal128`	`divide(BasicDecimal128 left, BasicDecimal128 right)`
`static BasicDecimal256`	`divide(BasicDecimal256 left, BasicDecimal256 right)`
`static DatumResult`	`Divide(Datum left, Datum right)`
`static DatumResult`	`Divide(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Divide two values.
`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 classes).
`static TypeMatcher`	`DurationTypeUnit(int unit)`
`static TypeMatcher`	`DurationTypeUnit(TimeUnit.type unit)`
`static String`	`EndiannessToString(arrow.Endianness endianness)`
`static BytePointer`	`EndiannessToString(int endianness)`
`static boolean`	`equals(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`equals(BasicDecimal256 left, BasicDecimal256 right)`
`static Field`	`field(BytePointer name, DataType type)`
`static Field`	`field(BytePointer name, DataType type, boolean nullable, KeyValueMetadata metadata)`
`static Field`	`field(BytePointer name, DataType type, KeyValueMetadata metadata)`
`static Field`	`field(String name, DataType type)`
`static Field`	`field(String name, DataType type, boolean nullable, KeyValueMetadata metadata)` \}
`static Field`	`field(String name, DataType type, KeyValueMetadata metadata)` \brief Create a Field instance with metadata The field will be assumed to be nullable.
`static FileSystemResult`	`FileSystemFromUriOrPath(BytePointer uri)`
`static FileSystemResult`	`FileSystemFromUriOrPath(BytePointer uri, BytePointer out_path)`
`static FileSystemResult`	`FileSystemFromUriOrPath(BytePointer uri, IOContext io_context)`
`static FileSystemResult`	`FileSystemFromUriOrPath(BytePointer uri, IOContext io_context, BytePointer out_path)`
`static FileSystemResult`	`FileSystemFromUriOrPath(String uri)`
`static FileSystemResult`	`FileSystemFromUriOrPath(String uri, BytePointer out_path)` \brief Create a new FileSystem by URI Same as FileSystemFromUri, but in addition also recognize non-URIs and treat them as local filesystem paths.
`static FileSystemResult`	`FileSystemFromUriOrPath(String uri, IOContext io_context)`
`static FileSystemResult`	`FileSystemFromUriOrPath(String uri, IOContext io_context, BytePointer out_path)` \brief Create a new FileSystem by URI with a custom IO context Same as FileSystemFromUri, but in addition also recognize non-URIs and treat them as local filesystem paths.
`static DatumResult`	`FillNull(Datum values, Datum fill_value)`
`static DatumResult`	`FillNull(Datum values, Datum fill_value, ExecContext ctx)` \brief FillNull replaces each null element in `values` with `fill_value`
`static DatumResult`	`Filter(Datum values, Datum filter)`
`static DatumResult`	`Filter(Datum values, Datum filter, FilterOptions options, ExecContext ctx)` \}
`static DataType`	`fixed_size_binary(int byte_width)` \brief Create a FixedSizeBinaryType instance.
`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 String`	`FormatMessageType(arrow.MessageType type)`
`static BytePointer`	`FormatMessageType(int 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`	`FuzzIpcTensorStream(byte[] data, long size)`
`static Status`	`FuzzIpcTensorStream(ByteBuffer data, long size)`
`static Status`	`FuzzIpcTensorStream(BytePointer data, long size)`
`static Status`	`GenericToStatus(Status st)` \endcond
`static ArrayDataResult`	`GetArrayView(ArrayData data, DataType type)` Construct a zero-copy view of this ArrayData with the given type.
`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 ValueDescr.Shape`	`GetBroadcastShape(ValueDescrVector args)` \brief For use with scalar functions, returns the broadcasted Value::Shape given a vector of value descriptors.
`static BuildInfo`	`GetBuildInfo()` \brief Get runtime build info.
`static int`	`GetByteWidth(DataType type)`
`static ThreadPool`	`GetCpuThreadPool()`
`static int`	`GetCpuThreadPoolCapacity()` \brief Get the capacity of the global thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various CPU-bound tasks.
`static Status`	`GetDictionaryPayload(long id, Array dictionary, IpcWriteOptions options, IpcPayload payload)` \brief Compute IpcPayload for a dictionary
`static Status`	`GetDictionaryPayload(long id, boolean is_delta, Array dictionary, IpcWriteOptions options, 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 long`	`GetFilterOutputSize(ArrayData filter, FilterOptions.NullSelectionBehavior null_selection)` \brief Return the number of selected indices in the boolean filter
`static long`	`GetFilterOutputSize(ArrayData filter, int null_selection)`
`static FunctionRegistry`	`GetFunctionRegistry()` \brief Return the process-global function registry
`static long`	`GetPayloadSize(IpcPayload payload)`
`static long`	`GetPayloadSize(IpcPayload payload, IpcWriteOptions options)` \brief Compute the number of bytes needed to write an IPC payload including metadata
`static Status`	`GetRecordBatchPayload(RecordBatch batch, IpcWriteOptions options, IpcPayload out)` \brief Compute IpcPayload for the given record batch
`static Status`	`GetRecordBatchSize(RecordBatch batch, IpcWriteOptions options, long[] size)`
`static Status`	`GetRecordBatchSize(RecordBatch batch, IpcWriteOptions options, LongBuffer size)`
`static Status`	`GetRecordBatchSize(RecordBatch batch, IpcWriteOptions options, LongPointer size)` \brief Compute the number of bytes needed to write a record batch including metadata
`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 RuntimeInfo`	`GetRuntimeInfo()` \brief Get runtime info.
`static Status`	`GetSchemaPayload(Schema schema, IpcWriteOptions options, DictionaryFieldMapper mapper, IpcPayload out)` \brief Compute IpcPayload for the given schema
`static MessageUniqueResult`	`GetSparseTensorMessage(SparseTensor sparse_tensor, MemoryPool pool)` \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 ArrayDataResult`	`GetTakeIndices(ArrayData filter, FilterOptions.NullSelectionBehavior null_selection)`
`static ArrayDataResult`	`GetTakeIndices(ArrayData filter, FilterOptions.NullSelectionBehavior null_selection, MemoryPool memory_pool)` \brief Compute uint64 selection indices for use with Take given a boolean filter
`static ArrayDataResult`	`GetTakeIndices(ArrayData filter, int null_selection)`
`static ArrayDataResult`	`GetTakeIndices(ArrayData filter, int null_selection, MemoryPool memory_pool)`
`static MessageUniqueResult`	`GetTensorMessage(Tensor tensor, MemoryPool pool)` \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`	`greaterThan(BasicDecimal256 left, BasicDecimal256 right)`
`static boolean`	`greaterThanEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`greaterThanEquals(BasicDecimal256 left, BasicDecimal256 right)`
`static DatumResult`	`GroupBy(DatumVector arguments, DatumVector keys, Aggregate aggregates)`
`static DatumResult`	`GroupBy(DatumVector arguments, DatumVector keys, Aggregate aggregates, ExecContext ctx)` Internal use only: helper function for testing HashAggregateKernels.
`static boolean`	`HasValidityBitmap(int id)`
`static Status`	`HaveLibHdfs()`
`static DatumResult`	`IndexIn(Datum values, Datum value_set)`
`static DatumResult`	`IndexIn(Datum values, Datum value_set, ExecContext ctx)`
`static DatumResult`	`IndexIn(Datum values, SetLookupOptions options)`
`static DatumResult`	`IndexIn(Datum values, SetLookupOptions options, ExecContext ctx)` \brief IndexIn examines each slot in the values against a value_set array.
`static Status`	`Initialize(FileSystemGlobalOptions options)` Experimental: optional global initialization routine This is for environments (such as manylinux) where the path to TLS CA certificates needs to be configured at runtime.
`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 TypeMatcher`	`Integer()`
`static void`	`InvalidValueOrDie(Status st)`
`static DatumResult`	`Invert(Datum value)`
`static DatumResult`	`Invert(Datum value, ExecContext ctx)` \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_nested(int type_id)`
`static boolean`	`is_primitive(int type_id)`
`static boolean`	`is_signed_integer(int type_id)`
`static boolean`	`is_tensor_supported(int type_id)`
`static boolean`	`is_unsigned_integer(int type_id)`
`static boolean`	`IsFutureFinished(arrow.FutureState state)`
`static boolean`	`IsFutureFinished(byte state)`
`static DatumResult`	`IsIn(Datum values, Datum value_set)`
`static DatumResult`	`IsIn(Datum values, Datum value_set, ExecContext ctx)`
`static DatumResult`	`IsIn(Datum values, SetLookupOptions options)`
`static DatumResult`	`IsIn(Datum values, SetLookupOptions options, ExecContext ctx)` \brief IsIn returns true for each element of `values` that is contained in `value_set` Behaviour of nulls is governed by SetLookupOptions::skip_nulls.
`static boolean`	`IsMultipleOf64(long n)`
`static boolean`	`IsMultipleOf8(long n)`
`static DatumResult`	`IsNan(Datum values)`
`static DatumResult`	`IsNan(Datum values, ExecContext ctx)` \brief IsNan returns true for each element of `values` that is NaN, false otherwise
`static DatumResult`	`IsNull(Datum values)`
`static DatumResult`	`IsNull(Datum values, ExecContext ctx)` \brief IsNull returns true for each element of `values` that is null, false otherwise
`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 DatumResult`	`IsValid(Datum values)`
`static DatumResult`	`IsValid(Datum values, ExecContext ctx)` \brief IsValid returns true for each element of `values` that is not null, false otherwise
`static Status`	`jemalloc_memory_pool(MemoryPool out)`
`static Status`	`jemalloc_memory_pool(PointerPointer out)` \brief 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()` Concrete type class for 64-bit floating-point data (C "double")
`static BytePointer`	`kBitmask()`
`static byte`	`kBitmask(int i)`
`static BytePointer`	`kBytePopcount()`
`static byte`	`kBytePopcount(int i)` \brief Return whether the variant holds a value of the given type
`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 int`	`kDefaultBackgroundMaxQ()`
`static int`	`kDefaultBackgroundQRestart()`
`static byte`	`kDefaultEscapeChar()`
`static long`	`kDefaultExecChunksize()` \brief See VectorKernel::finalize member for usage
`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`	`kFeatherV1Version()`
`static int`	`kFeatherV2Version()`
`static BytePointer`	`kFlippedBitmask()`
`static byte`	`kFlippedBitmask(int i)`
`static DatumResult`	`KleeneAnd(Datum left, Datum right)`
`static DatumResult`	`KleeneAnd(Datum left, Datum right, ExecContext ctx)` \brief Element-wise AND of two boolean datums with a Kleene truth table (null and false is false).
`static DatumResult`	`KleeneAndNot(Datum left, Datum right)`
`static DatumResult`	`KleeneAndNot(Datum left, Datum right, ExecContext ctx)` \brief Element-wise AND NOT of two boolean datums with a Kleene truth table (false and not null is false, null and not true is false).
`static DatumResult`	`KleeneOr(Datum left, Datum right)`
`static DatumResult`	`KleeneOr(Datum left, Datum right, ExecContext ctx)` \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`	`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 TypeMatcher`	`LargeBinaryLike()`
`static long`	`LeastSignificantBitMask(long bit_index)`
`static boolean`	`lessThan(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`lessThan(BasicDecimal256 left, BasicDecimal256 right)`
`static boolean`	`lessThanEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`lessThanEquals(BasicDecimal256 left, BasicDecimal256 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 ArrayResult`	`MakeArrayFromScalar(Scalar scalar, long length)`
`static ArrayResult`	`MakeArrayFromScalar(Scalar scalar, long length, MemoryPool pool)` \brief Create an Array instance whose slots are the given scalar
`static ArrayResult`	`MakeArrayOfNull(DataType type, long length)`
`static ArrayResult`	`MakeArrayOfNull(DataType type, long length, MemoryPool pool)` \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 RecordBatchWriterSharedResult`	`MakeFileWriter(OutputStream sink, Schema schema)`
`static RecordBatchWriterSharedResult`	`MakeFileWriter(OutputStream sink, Schema schema, IpcWriteOptions options, KeyValueMetadata metadata)` Create a new IPC file writer from stream sink and schema
`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 Scalar`	`MakeNullScalar(DataType type)` \defgroup scalar-factories Scalar factory functions \{
`static IpcPayloadWriterResult`	`MakePayloadFileWriter(OutputStream sink, Schema schema)`
`static IpcPayloadWriterResult`	`MakePayloadFileWriter(OutputStream sink, Schema schema, IpcWriteOptions options, KeyValueMetadata metadata)` Create a new IPC payload file writer from stream sink.
`static IpcPayloadWriterResult`	`MakePayloadStreamWriter(OutputStream sink)`
`static IpcPayloadWriterResult`	`MakePayloadStreamWriter(OutputStream sink, IpcWriteOptions options)` Create a new IPC payload stream writer from stream sink.
`static Scalar`	`MakeScalar(BytePointer value)`
`static Scalar`	`MakeScalar(String value)` \brief Type-inferring scalar factory for non-null scalars Construct a Scalar instance with a DataType determined by the input C++ type.
`static RecordBatchWriterSharedResult`	`MakeStreamWriter(OutputStream sink, Schema schema)`
`static RecordBatchWriterSharedResult`	`MakeStreamWriter(OutputStream sink, Schema schema, IpcWriteOptions options)` \defgroup record-batch-writer-factories Functions for creating RecordBatchWriter instances \{
`static DataType`	`map(DataType key_type, DataType item_type)`
`static DataType`	`map(DataType key_type, DataType item_type, boolean keys_sorted)` \brief Create a MapType instance from its key and value DataTypes
`static DataType`	`map(DataType key_type, Field item_field)`
`static DataType`	`map(DataType key_type, Field item_field, boolean keys_sorted)` \brief Create a MapType instance from its key DataType and value field.
`static DatumResult`	`Mean(Datum value)`
`static DatumResult`	`Mean(Datum value, ExecContext ctx)` \brief Compute the mean of a numeric array.
`static Status`	`mimalloc_memory_pool(MemoryPool out)`
`static Status`	`mimalloc_memory_pool(PointerPointer out)` \brief Return a process-wide memory pool based on mimalloc.
`static BasicDecimal128`	`mod(BasicDecimal128 left, BasicDecimal128 right)`
`static DatumResult`	`Mode(Datum value)`
`static DatumResult`	`Mode(Datum value, ModeOptions options, ExecContext ctx)` \brief Calculate the modal (most common) value of a numeric array This function returns top-n most common values and number of times they occur as an array of `struct<mode: T, count: int64>`, where T is the input type.
`static DataType`	`month_interval()` \brief Return a MonthIntervalType instance
`static BasicDecimal128`	`multiply(BasicDecimal128 left, BasicDecimal128 right)`
`static BasicDecimal256`	`multiply(BasicDecimal256 left, BasicDecimal256 right)`
`static DatumResult`	`Multiply(Datum left, Datum right)`
`static DatumResult`	`Multiply(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Multiply two values.
`static RecordBatchWriterSharedResult`	`NewFileWriter(OutputStream sink, Schema schema)` Deprecated.
`static RecordBatchWriterSharedResult`	`NewFileWriter(OutputStream sink, Schema schema, IpcWriteOptions options, KeyValueMetadata metadata)` Deprecated.
`static RecordBatchWriterSharedResult`	`NewStreamWriter(OutputStream sink, Schema schema)` Deprecated.
`static RecordBatchWriterSharedResult`	`NewStreamWriter(OutputStream sink, Schema schema, IpcWriteOptions options)` Deprecated.
`static long`	`NextPower2(long n)`
`static Status`	`NoMatchingKernel(Function func, ValueDescrVector arg1)` \brief Return an error message if no Kernel is found.
`static BasicDecimal128`	`not(BasicDecimal128 operand)`
`static BasicDecimal256`	`not(BasicDecimal256 operand)`
`static boolean`	`notEquals(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`notEquals(BasicDecimal256 left, BasicDecimal256 right)`
`static ArrayResult`	`NthToIndices(Array values, long n)`
`static ArrayResult`	`NthToIndices(Array values, long n, ExecContext ctx)` \brief Returns indices that partition an array around n-th sorted element.
`static int`	`NumRequiredBits(long x)`
`static int`	`offset_bit_width(int type_id)`
`static RecordBatchWriterUniqueResult`	`OpenRecordBatchWriter(IpcPayloadWriter sink, Schema schema)`
`static RecordBatchWriterUniqueResult`	`OpenRecordBatchWriter(IpcPayloadWriter sink, Schema schema, IpcWriteOptions options)` Create a new RecordBatchWriter from IpcPayloadWriter and schema.
`static DatumResult`	`Or(Datum left, Datum right)`
`static DatumResult`	`Or(Datum left, Datum right, ExecContext ctx)` \brief Element-wise OR of two boolean datums which always propagates nulls (null and true is null).
`static RecordBatchResult`	`ParseOne(JsonParseOptions options, ArrowBuffer json)` 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 int`	`PopCount(int bitmap)`
`static long`	`PopCount(long bitmap)`
`static DatumResult`	`Power(Datum left, Datum right)`
`static DatumResult`	`Power(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Raise the values of base array to the power of the exponent array values.
`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 TypeMatcher`	`Primitive()`
`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 DatumResult`	`Quantile(Datum value)`
`static DatumResult`	`Quantile(Datum value, QuantileOptions options, ExecContext ctx)` \brief Calculate the quantiles of a numeric array
`static MessageUniqueResult`	`ReadMessage(InputStream stream)`
`static MessageUniqueResult`	`ReadMessage(InputStream stream, MemoryPool pool)` \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 MessageUniqueResult`	`ReadMessage(long offset, int metadata_length, RandomAccessFile file)` \brief Read encapsulated RPC message from position in file Read a length-prefixed message flatbuffer starting at the indicated file offset.
`static RecordBatchResult`	`ReadRecordBatch(ArrowBuffer metadata, Schema schema, DictionaryMemo dictionary_memo, IpcReadOptions options, RandomAccessFile file)` Read record batch from file given metadata and schema
`static RecordBatchResult`	`ReadRecordBatch(Message message, Schema schema, DictionaryMemo dictionary_memo, IpcReadOptions options)` \brief Read record batch from message
`static RecordBatchResult`	`ReadRecordBatch(Schema schema, DictionaryMemo dictionary_memo, IpcReadOptions options, InputStream stream)` Read record batch as encapsulated IPC message with metadata size prefix and header
`static SchemaResult`	`ReadSchema(InputStream stream, DictionaryMemo dictionary_memo)` \brief Read Schema from stream serialized as a single IPC message and populate any dictionary-encoded fields into a DictionaryMemo
`static SchemaResult`	`ReadSchema(Message message, DictionaryMemo dictionary_memo)` \brief Read Schema from encapsulated Message
`static SparseTensorResult`	`ReadSparseTensor(InputStream file)` \brief EXPERIMENTAL: Read arrow::SparseTensor as encapsulated IPC message in file
`static SparseTensorResult`	`ReadSparseTensor(Message message)` \brief EXPERIMENTAL: Read arrow::SparseTensor from IPC 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`	`RegisterCancellingSignalHandler(int[] signals)`
`static Status`	`RegisterCancellingSignalHandler(IntBuffer signals)`
`static Status`	`RegisterCancellingSignalHandler(IntPointer signals)` EXPERIMENTAL: Register signal handler triggering the signal-receiving StopSource
`static Status`	`RegisterExtensionType(ExtensionType type)` \brief Register an extension type globally.
`static void`	`ResetSignalStopSource()` EXPERIMENTAL: Reset the global signal-receiving StopSource This will invalidate the pointer returned by SetSignalStopSource.
`static Status`	`ResolveDictionaries(ArrayDataVector columns, DictionaryMemo memo, MemoryPool pool)`
`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 TypeMatcher`	`SameTypeId(int type_id)` \brief Match any DataType instance having the same DataType::id.
`static boolean`	`ScalarApproxEquals(Scalar left, Scalar right)`
`static boolean`	`ScalarApproxEquals(Scalar left, Scalar right, EqualOptions options)` Returns true if scalars are approximately equal
`static boolean`	`ScalarEquals(Scalar left, Scalar right)`
`static boolean`	`ScalarEquals(Scalar left, Scalar right, EqualOptions options)` Returns true if scalars are equal
`static Schema`	`schema(FieldVector fields)`
`static Schema`	`schema(FieldVector fields, arrow.Endianness endianness)`
`static Schema`	`schema(FieldVector fields, arrow.Endianness endianness, KeyValueMetadata metadata)` \brief Create a Schema instance
`static Schema`	`schema(FieldVector fields, int endianness)`
`static Schema`	`schema(FieldVector fields, int endianness, KeyValueMetadata metadata)`
`static Schema`	`schema(FieldVector fields, KeyValueMetadata metadata)` \brief Create a Schema instance
`static BufferResult`	`SerializeRecordBatch(RecordBatch batch, IpcWriteOptions options)` \brief Serialize record batch as encapsulated IPC message in a new buffer
`static Status`	`SerializeRecordBatch(RecordBatch batch, IpcWriteOptions options, OutputStream out)` \brief Write record batch to OutputStream
`static BufferResult`	`SerializeRecordBatch(RecordBatch batch, MemoryManager mm)` \brief Serialize record batch as encapsulated IPC message in a new buffer
`static BufferResult`	`SerializeSchema(Schema schema)`
`static BufferResult`	`SerializeSchema(Schema schema, MemoryPool pool)` \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 Status`	`SetCpuThreadPoolCapacity(int threads)` \brief Set the capacity of the global thread pool Set the number of worker threads int the thread pool to which Arrow dispatches various CPU-bound tasks.
`static StopSourceResult`	`SetSignalStopSource()` EXPERIMENTAL: Set a global StopSource that can receive signals The only allowed order of calls is the following: - SetSignalStopSource() - any number of pairs of (RegisterCancellingSignalHandler, UnregisterCancellingSignalHandler) calls - ResetSignalStopSource() Beware that these settings are process-wide.
`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)` \brief Make a generator that always fails with a given error This overload allows inferring the return type from the argument.
`static Pointer`	`shiftLeft(Pointer os, FileInfo arg1)`
`static Pointer`	`shiftLeft(Pointer os, int unit)`
`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 BufferResult`	`SliceBufferSafe(ArrowBuffer buffer, long offset)` \brief Input-checking version of SliceBuffer An Invalid Status is returned if the requested slice falls out of bounds.
`static BufferResult`	`SliceBufferSafe(ArrowBuffer buffer, long offset, long length)` \brief Input-checking version of SliceBuffer An Invalid Status is returned if the requested slice falls out of bounds.
`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 BufferResult`	`SliceMutableBufferSafe(ArrowBuffer buffer, long offset)` \brief Input-checking version of SliceMutableBuffer An Invalid Status is returned if the requested slice falls out of bounds.
`static BufferResult`	`SliceMutableBufferSafe(ArrowBuffer buffer, long offset, long length)` \brief Input-checking version of SliceMutableBuffer An Invalid Status is returned if the requested slice falls out of bounds.
`static ArrayResult`	`SortIndices(Array array)`
`static ArrayResult`	`SortIndices(Array array, arrow.SortOrder order, ExecContext ctx)` \brief Returns the indices that would sort an array in the specified order.
`static ArrayResult`	`SortIndices(Array array, int order, ExecContext ctx)`
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array)`
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array, arrow.SortOrder order, ExecContext ctx)` \brief Returns the indices that would sort a chunked array in the specified order.
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array, int order, ExecContext ctx)`
`static ArrayResult`	`SortIndices(Datum datum, SortOptions options)`
`static ArrayResult`	`SortIndices(Datum datum, SortOptions options, ExecContext ctx)` \brief Returns the indices that would sort an input in the specified order.
`static ArrayResult`	`SortToIndices(Array values)` Deprecated.
`static ArrayResult`	`SortToIndices(Array values, ExecContext ctx)` Deprecated.
`static DataType`	`sparse_union(ArrayVector children)`
`static DataType`	`sparse_union(ArrayVector children, StringVector field_names, byte[] type_codes)`
`static DataType`	`sparse_union(ArrayVector children, StringVector field_names, ByteBuffer type_codes)`
`static DataType`	`sparse_union(ArrayVector children, StringVector field_names, BytePointer type_codes)` \brief Create a SparseUnionType instance
`static DataType`	`sparse_union(FieldVector child_fields)`
`static DataType`	`sparse_union(FieldVector child_fields, byte[] type_codes)`
`static DataType`	`sparse_union(FieldVector child_fields, ByteBuffer type_codes)`
`static DataType`	`sparse_union(FieldVector child_fields, BytePointer type_codes)` \brief Create a SparseUnionType instance
`static boolean`	`SparseTensorEquals(SparseTensor left, SparseTensor right)`
`static boolean`	`SparseTensorEquals(SparseTensor left, SparseTensor right, EqualOptions arg2)` EXPERIMENTAL: Returns true if the given sparse tensors are exactly equal
`static DatumResult`	`Stddev(Datum value)`
`static DatumResult`	`Stddev(Datum value, VarianceOptions options, ExecContext ctx)` \brief Calculate the standard deviation of a numeric array
`static DataType`	`struct_(FieldVector fields)` \brief Create a StructType instance
`static BasicDecimal128`	`subtract(BasicDecimal128 operand)`
`static BasicDecimal128`	`subtract(BasicDecimal128 left, BasicDecimal128 right)`
`static BasicDecimal256`	`subtract(BasicDecimal256 operand)`
`static DatumResult`	`Subtract(Datum left, Datum right)`
`static DatumResult`	`Subtract(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Subtract two values.
`static DatumResult`	`Sum(Datum value)`
`static DatumResult`	`Sum(Datum value, ExecContext ctx)` \brief Sum values of a numeric array.
`static StringVector`	`SupportedMemoryBackendNames()`
`static ArrayDataResult`	`SwapEndianArrayData(ArrayData data)` \brief Swap endian of each element in a generic ArrayData As dictionaries are often shared between different arrays, dictionaries are not swapped by this function and should be handled separately.
`static MemoryPool`	`system_memory_pool()` \brief Return a process-wide memory pool based on the system allocator.
`static ArrayResult`	`Take(Array values, Array indices)`
`static ArrayResult`	`Take(Array values, Array indices, TakeOptions options, ExecContext ctx)` \brief Take with Array inputs and output
`static ChunkedArrayResult`	`Take(Array values, ChunkedArray indices)` Deprecated.
`static ChunkedArrayResult`	`Take(Array values, ChunkedArray indices, TakeOptions options, ExecContext context)` Deprecated.
`static ChunkedArrayResult`	`Take(ChunkedArray values, Array indices)` Deprecated.
`static ChunkedArrayResult`	`Take(ChunkedArray values, Array indices, TakeOptions options, ExecContext context)` Deprecated.
`static ChunkedArrayResult`	`Take(ChunkedArray values, ChunkedArray indices)` Deprecated.
`static ChunkedArrayResult`	`Take(ChunkedArray values, ChunkedArray indices, TakeOptions options, ExecContext context)` Deprecated.
`static DatumResult`	`Take(Datum values, Datum indices)`
`static DatumResult`	`Take(Datum values, Datum indices, TakeOptions options, ExecContext ctx)` \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 RecordBatchResult`	`Take(RecordBatch batch, Array indices)` Deprecated.
`static RecordBatchResult`	`Take(RecordBatch batch, Array indices, TakeOptions options, ExecContext context)` Deprecated.
`static TableResult`	`Take(Table table, Array indices)` Deprecated.
`static TableResult`	`Take(Table table, Array indices, TakeOptions options, ExecContext context)` Deprecated.
`static TableResult`	`Take(Table table, ChunkedArray indices)` Deprecated.
`static TableResult`	`Take(Table table, ChunkedArray indices, TakeOptions options, ExecContext context)` Deprecated.
`static DatumResult`	`TDigest(Datum value)`
`static DatumResult`	`TDigest(Datum value, TDigestOptions options, ExecContext ctx)` \brief Calculate the approximate quantiles of a numeric array with T-Digest algorithm
`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 TypeMatcher`	`Time32TypeUnit(int unit)`
`static TypeMatcher`	`Time32TypeUnit(TimeUnit.type unit)`
`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 TypeMatcher`	`Time64TypeUnit(int unit)`
`static TypeMatcher`	`Time64TypeUnit(TimeUnit.type unit)`
`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 TypeMatcher`	`TimestampTypeUnit(int unit)`
`static TypeMatcher`	`TimestampTypeUnit(TimeUnit.type unit)` \brief Match any TimestampType instance having the same unit, but the time zones can be different.
`static String`	`ToString(arrow.FileType arg0)`
`static BytePointer`	`ToString(byte arg0)`
`static String`	`ToString(int id)`
`static String`	`ToString(TimeUnit.type unit)`
`static String`	`ToTypeName(int id)`
`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_(ArrayVector children)` Deprecated.
`static DataType`	`union_(ArrayVector children, int mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes, int mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, byte[] type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes, int mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, ByteBuffer type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes, int mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, BytePointer type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, int mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, StringVector field_names, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(ArrayVector children, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes, int mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, byte[] type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes, int mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, ByteBuffer type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes, int mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, BytePointer type_codes, UnionMode.type mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, int mode)` Deprecated.
`static DataType`	`union_(FieldVector child_fields, UnionMode.type mode)` Deprecated.
`static ArrayResult`	`Unique(Datum datum)`
`static ArrayResult`	`Unique(Datum datum, ExecContext ctx)` \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 void`	`UnregisterCancellingSignalHandler()` EXPERIMENTAL: Unregister signal handler set up by RegisterCancellingSignalHandler
`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 StructArrayResult`	`ValueCounts(Datum value)`
`static StructArrayResult`	`ValueCounts(Datum value, ExecContext ctx)` \brief Return counts of unique elements from an array-like object.
`static DatumResult`	`Variance(Datum value)`
`static DatumResult`	`Variance(Datum value, VarianceOptions options, ExecContext ctx)` \brief Calculate the variance of a numeric array
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcWriteOptions options, OutputStream dst, int[] metadata_length)`
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcWriteOptions options, OutputStream dst, IntBuffer metadata_length)`
`static Status`	`WriteIpcPayload(IpcPayload payload, IpcWriteOptions options, OutputStream dst, IntPointer metadata_length)` \brief Write an IPC payload to the given stream.
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, int[] metadata_length, long[] body_length, IpcWriteOptions options)`
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, IntBuffer metadata_length, LongBuffer body_length, IpcWriteOptions options)`
`static Status`	`WriteRecordBatch(RecordBatch batch, long buffer_start_offset, OutputStream dst, IntPointer metadata_length, LongPointer body_length, IpcWriteOptions options)` \brief Low-level API for writing a record batch (without schema) to an OutputStream as encapsulated IPC message.
`static Status`	`WriteRecordBatchStream(RecordBatchVector batches, IpcWriteOptions 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`	`WriteTable(Table table, OutputStream dst)`
`static Status`	`WriteTable(Table table, OutputStream dst, WriteProperties properties)`
`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 DatumResult`	`Xor(Datum left, Datum right)`
`static DatumResult`	`Xor(Datum left, Datum right, ExecContext ctx)` \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_VERSION_STRING

public static final String ARROW_VERSION_STRING

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_CXX_COMPILER_ID

public static final String ARROW_CXX_COMPILER_ID

See Also:: Constant Field Values

ARROW_CXX_COMPILER_VERSION

public static final String ARROW_CXX_COMPILER_VERSION

See Also:: Constant Field Values

ARROW_CXX_COMPILER_FLAGS

public static final String ARROW_CXX_COMPILER_FLAGS

See Also:: Constant Field Values

ARROW_GIT_ID

public static final String ARROW_GIT_ID

See Also:: Constant Field Values

ARROW_GIT_DESCRIPTION

public static final String ARROW_GIT_DESCRIPTION

See Also:: Constant Field Values

ARROW_PACKAGE_KIND

public static final String ARROW_PACKAGE_KIND

See Also:: Constant Field Values

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

kDefaultAbsoluteTolerance

public static final double kDefaultAbsoluteTolerance

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

kDefaultExecChunksize

public static final long kDefaultExecChunksize

kFeatherV1Version

public static final int kFeatherV1Version

kFeatherV2Version

public static final int kFeatherV2Version

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

kBytePopcount

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

\brief Return whether the variant holds a value of the given type

kBytePopcount

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

PopCount

@Namespace(value="arrow::BitUtil")
 @Cast(value="uint64_t")
public static long PopCount(@Cast(value="uint64_t")
                                                                                        long bitmap)

PopCount

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

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)

LeastSignificantBitMask

@Namespace(value="arrow::BitUtil")
 @Cast(value="const uint64_t")
public static long LeastSignificantBitMask(@Cast(value="int64_t")
                                                                                                             long bit_index)

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)

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)

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(@ByVal
                                                                                        StringVector keys,
                                                                                        @ByVal
                                                                                        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()
```
\brief 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)

\brief 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)

\brief 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)

SupportedMemoryBackendNames

@Namespace(value="arrow")
 @ByVal
public static StringVector SupportedMemoryBackendNames()

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)

SliceBufferSafe

@Namespace(value="arrow")
 @ByVal
public static BufferResult SliceBufferSafe(@SharedPtr
                                                                             ArrowBuffer buffer,
                                                                             @Cast(value="int64_t")
                                                                             long offset)

\brief Input-checking version of SliceBuffer An Invalid Status is returned if the requested slice falls out of bounds.

SliceBufferSafe

@Namespace(value="arrow")
 @ByVal
public static BufferResult SliceBufferSafe(@SharedPtr
                                                                             ArrowBuffer buffer,
                                                                             @Cast(value="int64_t")
                                                                             long offset,
                                                                             @Cast(value="int64_t")
                                                                             long length)

\brief Input-checking version of SliceBuffer An Invalid Status is returned if the requested slice falls out of bounds. Note that unlike SliceBuffer, length isn't clamped to the available buffer size.

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).

SliceMutableBufferSafe

@Namespace(value="arrow")
 @ByVal
public static BufferResult SliceMutableBufferSafe(@SharedPtr
                                                                                    ArrowBuffer buffer,
                                                                                    @Cast(value="int64_t")
                                                                                    long offset)

\brief Input-checking version of SliceMutableBuffer An Invalid Status is returned if the requested slice falls out of bounds.

SliceMutableBufferSafe

@Namespace(value="arrow")
 @ByVal
public static BufferResult SliceMutableBufferSafe(@SharedPtr
                                                                                    ArrowBuffer buffer,
                                                                                    @Cast(value="int64_t")
                                                                                    long offset,
                                                                                    @Cast(value="int64_t")
                                                                                    long length)

\brief Input-checking version of SliceMutableBuffer An Invalid Status is returned if the requested slice falls out of bounds. Note that unlike SliceBuffer, length isn't clamped to the available buffer size.

AllocateBuffer

@Namespace(value="arrow")
 @ByVal
public static BufferUniqueResult AllocateBuffer(@Cast(value="const int64_t")
                                                                                  long size,
                                                                                  MemoryPool pool)

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

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

Parameters:: size - [in] size of buffer to allocate; pool - [in] a memory pool

AllocateBuffer

@Namespace(value="arrow")
 @ByVal
public static BufferUniqueResult AllocateBuffer(@Cast(value="const int64_t")
                                                                                  long size)

AllocateResizableBuffer

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

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

Parameters:: size - [in] size of buffer to allocate; pool - [in] a memory pool

AllocateResizableBuffer

@Namespace(value="arrow")
 @ByVal
public static ResizableUniqueResult AllocateResizableBuffer(@Cast(value="const int64_t")
                                                                                              long size)

AllocateEmptyBitmap

@Namespace(value="arrow")
 @ByVal
public static BufferResult AllocateEmptyBitmap(@Cast(value="int64_t")
                                                                                 long length,
                                                                                 MemoryPool pool)

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

Parameters:: length - [in] size in bits of bitmap to allocate; pool - [in] memory pool to allocate memory from

AllocateEmptyBitmap

@Namespace(value="arrow")
 @ByVal
public static BufferResult AllocateEmptyBitmap(@Cast(value="int64_t")
                                                                                 long length)

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)

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,
                                                                                      @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                      EqualOptions arg5)

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

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)

ArrayRangeApproxEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayRangeApproxEquals(@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,
                                                                                            @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                            EqualOptions arg5)

Returns true if indicated equal-length segment of arrays are approximately equal

ArrayRangeApproxEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ArrayRangeApproxEquals(@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)

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,
                                                                                        @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                        EqualOptions arg2)

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

SparseTensorEquals

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

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,
                                                                                  @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                  EqualOptions options)

Returns true if scalars are equal

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

ScalarEquals

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

ScalarApproxEquals

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean ScalarApproxEquals(@Const @ByRef
                                                                                        Scalar left,
                                                                                        @Const @ByRef
                                                                                        Scalar right,
                                                                                        @Const @ByRef(nullValue="arrow::EqualOptions::Defaults()")
                                                                                        EqualOptions options)

Returns true if scalars are approximately equal

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

ScalarApproxEquals

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

DieWithMessage

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

DieWithMessage

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

InvalidValueOrDie

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

_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

fixed_size_binary

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

\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 DecimalType instance depending on the precision If the precision is greater than 38, a Decimal128Type is returned, otherwise a Decimal256Type.

decimal128

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

\brief Create a Decimal128Type instance

decimal256

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

\brief Create a Decimal256Type instance

list

@Namespace(value="arrow")
 @SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::DataType>"})
public static DataType list(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                                                                                                        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(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                                                                                                              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 item_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 item_type)

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::Field>"})
                                                                                                                       Field item_field,
                                                                                                                       @Cast(value="bool")
                                                                                                                       boolean keys_sorted)

\brief Create a MapType instance from its key DataType and value field. The field override is provided to communicate nullability of the value.

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::Field>"})
                                                                                                                       Field item_field)

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::Field>"})
                                                                                                                                   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 classes).

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

sparse_union

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

\brief Create a SparseUnionType instance

sparse_union

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

sparse_union

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

sparse_union

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

dense_union

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

\brief Create a DenseUnionType instance

dense_union

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

dense_union

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

dense_union

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

sparse_union

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

\brief Create a SparseUnionType instance

sparse_union

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

sparse_union

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

sparse_union

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

dense_union

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

\brief Create a DenseUnionType instance

dense_union

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

dense_union

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

dense_union

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

union_

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

Deprecated.

\brief Create a UnionType instance

union_

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

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

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

Deprecated.

union_

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

Deprecated.

union_

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

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

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

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

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

Deprecated.

\brief Create a UnionType instance

union_

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

Deprecated.

union_

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

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

\brief Create a UnionType instance

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

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

Deprecated.

\brief Create a UnionType instance

union_

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

Deprecated.

union_

@Namespace(value="arrow")
 @Deprecated
 @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)

Deprecated.

union_

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

Deprecated.

\brief Create a UnionType instance

union_

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

Deprecated.

union_

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

Deprecated.

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
 @Cast(value={"","std::shared_ptr<arrow::Field>"})
public static Field field(@StdString
                                                                                                                   String name,
                                                                                                                   @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                   DataType type,
                                                                                                                   @Cast(value="bool")
                                                                                                                   boolean nullable,
                                                                                                                   @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                                                                   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
 @Cast(value={"","std::shared_ptr<arrow::Field>"})
public static Field field(@StdString
                                                                                                                   String name,
                                                                                                                   @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                                                   DataType type)

field

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

field

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

field

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

\brief Create a Field instance with metadata The field will be assumed to be nullable.

Parameters:: name - the field name; type - the field value type; metadata - any custom key-value metadata

field

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

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@ByVal
                                                                          FieldVector fields,
                                                                          @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                          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(@ByVal
                                                                          FieldVector fields)

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@ByVal
                                                                          FieldVector fields,
                                                                          arrow.Endianness endianness,
                                                                          @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                          KeyValueMetadata metadata)

\brief Create a Schema instance

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

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@ByVal
                                                                          FieldVector fields,
                                                                          arrow.Endianness endianness)

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@ByVal
                                                                          FieldVector fields,
                                                                          @Cast(value="arrow::Endianness")
                                                                          int endianness,
                                                                          @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                          KeyValueMetadata metadata)

schema

@Namespace(value="arrow")
 @SharedPtr
 @ByVal
public static Schema schema(@ByVal
                                                                          FieldVector fields,
                                                                          @Cast(value="arrow::Endianness")
                                                                          int endianness)

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_signed_integer

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

is_unsigned_integer

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean is_unsigned_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)

bit_width

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

is_nested

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

offset_bit_width

@Namespace(value="arrow")
public static int offset_bit_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)

equals

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

notEquals

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

lessThan

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

lessThanEquals

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

greaterThan

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

greaterThanEquals

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

subtract

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

not

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

add

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

multiply

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

divide

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

IsFutureFinished

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean IsFutureFinished(arrow.FutureState state)

IsFutureFinished

@Namespace(value="arrow")
 @Cast(value="bool")
public static boolean IsFutureFinished(@Cast(value="arrow::FutureState")
                                                                                      byte state)

AllComplete

@Namespace(value="arrow")
 @ByVal
public static Future AllComplete(@StdVector
                                                                   Future futures)

\brief Create a Future which completes when all of futures complete. The future will be marked complete if all futures complete successfully. Otherwise, it will be marked failed with the status of the first failing future.

SetSignalStopSource
```
@Namespace(value="arrow")
 @ByVal
public static StopSourceResult SetSignalStopSource()
```
EXPERIMENTAL: Set a global StopSource that can receive signals The only allowed order of calls is the following: - SetSignalStopSource() - any number of pairs of (RegisterCancellingSignalHandler, UnregisterCancellingSignalHandler) calls - ResetSignalStopSource() Beware that these settings are process-wide. Typically, only one thread should call these APIs, even in a multithreaded setting.

ResetSignalStopSource
```
@Namespace(value="arrow")
public static void ResetSignalStopSource()
```
EXPERIMENTAL: Reset the global signal-receiving StopSource This will invalidate the pointer returned by SetSignalStopSource.

RegisterCancellingSignalHandler

@Namespace(value="arrow")
 @ByVal
public static Status RegisterCancellingSignalHandler(@StdVector
                                                                                       IntPointer signals)

EXPERIMENTAL: Register signal handler triggering the signal-receiving StopSource

RegisterCancellingSignalHandler

@Namespace(value="arrow")
 @ByVal
public static Status RegisterCancellingSignalHandler(@StdVector
                                                                                       IntBuffer signals)

RegisterCancellingSignalHandler

@Namespace(value="arrow")
 @ByVal
public static Status RegisterCancellingSignalHandler(@StdVector
                                                                                       int[] signals)

UnregisterCancellingSignalHandler
```
@Namespace(value="arrow")
public static void UnregisterCancellingSignalHandler()
```
EXPERIMENTAL: Unregister signal handler set up by RegisterCancellingSignalHandler

GetCpuThreadPoolCapacity
```
@Namespace(value="arrow")
public static int GetCpuThreadPoolCapacity()
```
\brief Get the capacity of the global thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various CPU-bound tasks. This is an ideal number, not necessarily the exact number of threads at a given point in time. You can change this number using SetCpuThreadPoolCapacity().

SetCpuThreadPoolCapacity
```
@Namespace(value="arrow")
 @ByVal
public static Status SetCpuThreadPoolCapacity(int threads)
```
\brief Set the capacity of the global thread pool Set the number of worker threads int the thread pool to which Arrow dispatches various CPU-bound tasks. The current number is returned by GetCpuThreadPoolCapacity().

GetCpuThreadPool

@Namespace(value="arrow::internal")
public static ThreadPool GetCpuThreadPool()

kDefaultBackgroundMaxQ

@Namespace(value="arrow")
 @MemberGetter
public static int kDefaultBackgroundMaxQ()

See Also:: MakeBackgroundGenerator

kDefaultBackgroundQRestart

@Namespace(value="arrow")
 @MemberGetter
public static int kDefaultBackgroundQRestart()

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)

\brief Make a generator that always fails with a given error This overload allows inferring the return type from the argument.

kBinaryMemoryLimit

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

Concrete type class for 64-bit floating-point data (C "double")

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)

EndiannessToString

@Namespace(value="arrow")
 @StdString
public static String EndiannessToString(arrow.Endianness endianness)

EndiannessToString

@Namespace(value="arrow")
 @StdString
public static BytePointer EndiannessToString(@Cast(value="arrow::Endianness")
                                                                                   int endianness)

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)

HasValidityBitmap

@Namespace(value="arrow::internal")
 @Cast(value="bool")
public static boolean HasValidityBitmap(@Cast(value="arrow::Type::type")
                                                                                                 int id)

ToString

@Namespace(value="arrow::internal")
 @StdString
public static String ToString(@Cast(value="arrow::Type::type")
                                                                              int id)

ToTypeName

@Namespace(value="arrow::internal")
 @StdString
public static String ToTypeName(@Cast(value="arrow::Type::type")
                                                                                int id)

ToString

@Namespace(value="arrow::internal")
 @StdString
public static String ToString(TimeUnit.type unit)

GetByteWidth

@Namespace(value="arrow::internal")
public static int GetByteWidth(@Const @ByRef
                                                                   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)

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)

\defgroup scalar-factories Scalar factory functions \{

\brief Scalar factory for null scalars

MakeScalar

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

\brief Type-inferring scalar factory for non-null scalars Construct a Scalar instance with a DataType determined by the input C++ type. (for example Int8Scalar for a int8_t input). Only non-parametric primitive types and String are supported.

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()

GetArrayView

@Namespace(value="arrow::internal")
 @ByVal
public static ArrayDataResult GetArrayView(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::ArrayData>"})
                                                                                       ArrayData data,
                                                                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                                       DataType type)

Construct a zero-copy view of this ArrayData with the given type. This method checks if the types are layout-compatible. Nested types are traversed in depth-first order. Data buffers must have the same item sizes, even though the logical types may be different. An error is returned if the types are not layout-compatible.

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 ArrayResult MakeArrayOfNull(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                            DataType type,
                                                                            @Cast(value="int64_t")
                                                                            long length,
                                                                            MemoryPool pool)

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

Parameters:: type - [in] the array type; length - [in] the array length; pool - [in] the memory pool to allocate memory from

MakeArrayOfNull

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

MakeArrayFromScalar

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

\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; pool - [in] the memory pool to allocate memory from

MakeArrayFromScalar

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

SwapEndianArrayData

@Namespace(value="arrow::internal")
 @ByVal
public static ArrayDataResult SwapEndianArrayData(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::ArrayData>"})
                                                                                              ArrayData data)

\brief Swap endian of each element in a generic ArrayData As dictionaries are often shared between different arrays, dictionaries are not swapped by this function and should be handled separately.

Parameters:: data - [in] the array contents
Returns:: the resulting ArrayData whose elements were swapped

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 ArrayResult Concatenate(@Const @ByRef
                                                                        ArrayVector arrays,
                                                                        MemoryPool pool)

\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
Returns:: the concatenated array

Concatenate

@Namespace(value="arrow")
 @ByVal
public static ArrayResult Concatenate(@Const @ByRef
                                                                        ArrayVector arrays)

Concatenate

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

Deprecated.

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()

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] the data type to create the builder for; 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] the dictionary type to create the builder for; dictionary - [in] the initial dictionary, if any. May be nullptr; out - [out] the created ArrayBuilder

GetBuildInfo
```
@Namespace(value="arrow")
 @Const
 @ByRef
public static BuildInfo GetBuildInfo()
```
\brief Get runtime build info. The returned values correspond to exact loaded version of the Arrow library, rather than the values frozen at application compile-time through the ARROW_* preprocessor definitions.

GetRuntimeInfo

@Namespace(value="arrow")
 @ByVal
public static RuntimeInfo GetRuntimeInfo()

\brief Get runtime info.

GetBroadcastShape

@Namespace(value="arrow")
public static ValueDescr.Shape GetBroadcastShape(@Const @ByRef
                                                                           ValueDescrVector args)

\brief For use with scalar functions, returns the broadcasted Value::Shape given a vector of value descriptors. Return SCALAR unless any value is ARRAY

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)

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)

ComputeRowMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeRowMajorStrides(@Const @ByRef
                                                                                        FixedWidthType type,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        LongPointer shape,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        LongPointer strides)

ComputeRowMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeRowMajorStrides(@Const @ByRef
                                                                                        FixedWidthType type,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        LongBuffer shape,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        LongBuffer strides)

ComputeRowMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeRowMajorStrides(@Const @ByRef
                                                                                        FixedWidthType type,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        long[] shape,
                                                                                        @Cast(value="int64_t*") @StdVector
                                                                                        long[] strides)

ComputeColumnMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeColumnMajorStrides(@Const @ByRef
                                                                                           FixedWidthType type,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           LongPointer shape,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           LongPointer strides)

ComputeColumnMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeColumnMajorStrides(@Const @ByRef
                                                                                           FixedWidthType type,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           LongBuffer shape,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           LongBuffer strides)

ComputeColumnMajorStrides

@Namespace(value="arrow::internal")
 @ByVal
public static Status ComputeColumnMajorStrides(@Const @ByRef
                                                                                           FixedWidthType type,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           long[] shape,
                                                                                           @Cast(value="int64_t*") @StdVector
                                                                                           long[] 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
                                                                                                         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)

default_io_context

@Namespace(value="arrow::io")
 @Const
 @ByRef
public static IOContext default_io_context()

EXPERIMENTAL: convenience global singleton for default IOContext settings

MakeInputStreamIterator

@Namespace(value="arrow::io")
 @ByVal
public static BufferIteratorResult MakeInputStreamIterator(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::io::InputStream>"})
                                                                                                 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()

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
                                                                                                                                FileInfo arg1)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             String uri,
                                                                                             @StdString @Cast(value={"char*","std::string*"})
                                                                                             BytePointer out_path)

\brief Create a new FileSystem by URI Same as FileSystemFromUri, but in addition also recognize non-URIs and treat them as local filesystem paths. Only absolute local filesystem paths are allowed.

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             String uri)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             BytePointer uri,
                                                                                             @StdString @Cast(value={"char*","std::string*"})
                                                                                             BytePointer out_path)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             BytePointer uri)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             String uri,
                                                                                             @Const @ByRef
                                                                                             IOContext io_context,
                                                                                             @StdString @Cast(value={"char*","std::string*"})
                                                                                             BytePointer out_path)

\brief Create a new FileSystem by URI with a custom IO context Same as FileSystemFromUri, but in addition also recognize non-URIs and treat them as local filesystem paths. Only absolute local filesystem paths are allowed.

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             String uri,
                                                                                             @Const @ByRef
                                                                                             IOContext io_context)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             BytePointer uri,
                                                                                             @Const @ByRef
                                                                                             IOContext io_context,
                                                                                             @StdString @Cast(value={"char*","std::string*"})
                                                                                             BytePointer out_path)

FileSystemFromUriOrPath

@Namespace(value="arrow::fs")
 @ByVal
public static FileSystemResult FileSystemFromUriOrPath(@StdString
                                                                                             BytePointer uri,
                                                                                             @Const @ByRef
                                                                                             IOContext io_context)

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@StdVector
                                                                     FileLocator sources,
                                                                     @StdVector
                                                                     FileLocator destinations,
                                                                     @Const @ByRef(nullValue="arrow::io::IOContext(arrow::io::default_io_context())")
                                                                     IOContext io_context,
                                                                     @Cast(value="int64_t")
                                                                     long chunk_size,
                                                                     @Cast(value="bool")
                                                                     boolean use_threads)

\brief Copy files, including from one FileSystem to another If a source and destination are resident in the same FileSystem FileSystem::CopyFile will be used, otherwise the file will be opened as a stream in both FileSystems and chunks copied from the source to the destination. No directories will be created.

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@StdVector
                                                                     FileLocator sources,
                                                                     @StdVector
                                                                     FileLocator destinations)

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@SharedPtr
                                                                     FileSystem source_fs,
                                                                     @Const @ByRef
                                                                     FileSelector source_sel,
                                                                     @SharedPtr
                                                                     FileSystem destination_fs,
                                                                     @StdString
                                                                     String destination_base_dir,
                                                                     @Const @ByRef(nullValue="arrow::io::IOContext(arrow::io::default_io_context())")
                                                                     IOContext io_context,
                                                                     @Cast(value="int64_t")
                                                                     long chunk_size,
                                                                     @Cast(value="bool")
                                                                     boolean use_threads)

\brief Copy selected files, including from one FileSystem to another Directories will be created under the destination base directory as needed.

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@SharedPtr
                                                                     FileSystem source_fs,
                                                                     @Const @ByRef
                                                                     FileSelector source_sel,
                                                                     @SharedPtr
                                                                     FileSystem destination_fs,
                                                                     @StdString
                                                                     String destination_base_dir)

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@SharedPtr
                                                                     FileSystem source_fs,
                                                                     @Const @ByRef
                                                                     FileSelector source_sel,
                                                                     @SharedPtr
                                                                     FileSystem destination_fs,
                                                                     @StdString
                                                                     BytePointer destination_base_dir,
                                                                     @Const @ByRef(nullValue="arrow::io::IOContext(arrow::io::default_io_context())")
                                                                     IOContext io_context,
                                                                     @Cast(value="int64_t")
                                                                     long chunk_size,
                                                                     @Cast(value="bool")
                                                                     boolean use_threads)

CopyFiles

@Namespace(value="arrow::fs")
 @ByVal
public static Status CopyFiles(@SharedPtr
                                                                     FileSystem source_fs,
                                                                     @Const @ByRef
                                                                     FileSelector source_sel,
                                                                     @SharedPtr
                                                                     FileSystem destination_fs,
                                                                     @StdString
                                                                     BytePointer destination_base_dir)

Initialize

@Namespace(value="arrow::fs")
 @ByVal
public static Status Initialize(@Const @ByRef
                                                                      FileSystemGlobalOptions options)

Experimental: optional global initialization routine This is for environments (such as manylinux) where the path to TLS CA certificates needs to be configured at runtime.

DetectAbsolutePath

@Namespace(value="arrow::fs::internal")
 @Cast(value="bool")
public static boolean DetectAbsolutePath(@StdString
                                                                                                      String s)

HDFS-backed FileSystem implementation. implementation notes: - This is a wrapper of arrow/io/hdfs, so we can use FileSystem API to handle hdfs.

DetectAbsolutePath

@Namespace(value="arrow::fs::internal")
 @Cast(value="bool")
public static boolean DetectAbsolutePath(@StdString
                                                                                                      BytePointer s)

kDefaultEscapeChar

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

ParseOne

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

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

Count

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Count(@Const @ByRef
                                                                           Datum datum,
                                                                           @ByVal(nullValue="arrow::compute::CountOptions::Defaults()")
                                                                           CountOptions options,
                                                                           ExecContext ctx)

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

Parameters:: options - [in] counting options, see CountOptions for more information; datum - [in] to count; ctx - [in] the function execution context, optional
Returns:: out resulting datum
Since:: 1.0.0 \note API not yet finalized

Count

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Count(@Const @ByRef
                                                                           Datum datum)

Mean

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Mean(@Const @ByRef
                                                                          Datum value,
                                                                          ExecContext ctx)

\brief Compute the mean of a numeric array.

Parameters:: value - [in] datum to compute the mean, expecting Array; ctx - [in] the function execution context, optional
Returns:: datum of the computed mean as a DoubleScalar
Since:: 1.0.0 \note API not yet finalized

Mean

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Mean(@Const @ByRef
                                                                          Datum value)

Sum

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Sum(@Const @ByRef
                                                                         Datum value,
                                                                         ExecContext ctx)

\brief Sum values of a numeric array.

Parameters:: value - [in] datum to sum, expecting Array or ChunkedArray; ctx - [in] the function execution context, optional
Returns:: datum of the computed sum as a Scalar
Since:: 1.0.0 \note API not yet finalized

Sum

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Sum(@Const @ByRef
                                                                         Datum value)

Any

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Any(@Const @ByRef
                                                                         Datum value,
                                                                         ExecContext ctx)

\brief Test whether any element in a boolean array evaluates to true. This function returns true if any of the elements in the array evaluates to true and false otherwise. Null values are skipped.

Parameters:: value - [in] input datum, expecting a boolean array; ctx - [in] the function execution context, optional
Returns:: resulting datum as a BooleanScalar
Since:: 3.0.0 \note API not yet finalized

Any

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Any(@Const @ByRef
                                                                         Datum value)

All

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult All(@Const @ByRef
                                                                         Datum value,
                                                                         ExecContext ctx)

\brief Test whether all elements in a boolean array evaluate to true. This function returns true if all of the elements in the array evaluate to true and false otherwise. Null values are skipped.

Parameters:: value - [in] input datum, expecting a boolean array; ctx - [in] the function execution context, optional
Returns:: resulting datum as a BooleanScalar
Since:: 3.0.0 \note API not yet finalized

All

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult All(@Const @ByRef
                                                                         Datum value)

Mode

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Mode(@Const @ByRef
                                                                          Datum value,
                                                                          @Const @ByRef(nullValue="arrow::compute::ModeOptions::Defaults()")
                                                                          ModeOptions options,
                                                                          ExecContext ctx)

\brief Calculate the modal (most common) value of a numeric array This function returns top-n most common values and number of times they occur as an array of struct<mode: T, count: int64>, where T is the input type. Values with larger counts are returned before smaller ones. If there are more than one values with same count, smaller value is returned first.

Parameters:: value - [in] input datum, expecting Array or ChunkedArray; options - [in] see ModeOptions for more information; ctx - [in] the function execution context, optional
Returns:: resulting datum as an array of struct
Since:: 2.0.0 \note API not yet finalized

Mode

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Mode(@Const @ByRef
                                                                          Datum value)

Stddev

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Stddev(@Const @ByRef
                                                                            Datum value,
                                                                            @Const @ByRef(nullValue="arrow::compute::VarianceOptions::Defaults()")
                                                                            VarianceOptions options,
                                                                            ExecContext ctx)

\brief Calculate the standard deviation of a numeric array

Parameters:: value - [in] input datum, expecting Array or ChunkedArray; options - [in] see VarianceOptions for more information; ctx - [in] the function execution context, optional
Returns:: datum of the computed standard deviation as a DoubleScalar
Since:: 2.0.0 \note API not yet finalized

Stddev

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Stddev(@Const @ByRef
                                                                            Datum value)

Variance

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Variance(@Const @ByRef
                                                                              Datum value,
                                                                              @Const @ByRef(nullValue="arrow::compute::VarianceOptions::Defaults()")
                                                                              VarianceOptions options,
                                                                              ExecContext ctx)

\brief Calculate the variance of a numeric array

Parameters:: value - [in] input datum, expecting Array or ChunkedArray; options - [in] see VarianceOptions for more information; ctx - [in] the function execution context, optional
Returns:: datum of the computed variance as a DoubleScalar
Since:: 2.0.0 \note API not yet finalized

Variance

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Variance(@Const @ByRef
                                                                              Datum value)

Quantile

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Quantile(@Const @ByRef
                                                                              Datum value,
                                                                              @Const @ByRef(nullValue="arrow::compute::QuantileOptions::Defaults()")
                                                                              QuantileOptions options,
                                                                              ExecContext ctx)

\brief Calculate the quantiles of a numeric array

Parameters:: value - [in] input datum, expecting Array or ChunkedArray; options - [in] see QuantileOptions for more information; ctx - [in] the function execution context, optional
Returns:: resulting datum as an array
Since:: 4.0.0 \note API not yet finalized

Quantile

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Quantile(@Const @ByRef
                                                                              Datum value)

TDigest

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult TDigest(@Const @ByRef
                                                                             Datum value,
                                                                             @Const @ByRef(nullValue="arrow::compute::TDigestOptions::Defaults()")
                                                                             TDigestOptions options,
                                                                             ExecContext ctx)

\brief Calculate the approximate quantiles of a numeric array with T-Digest algorithm

Parameters:: value - [in] input datum, expecting Array or ChunkedArray; options - [in] see TDigestOptions for more information; ctx - [in] the function execution context, optional
Returns:: resulting datum as an array
Since:: 4.0.0 \note API not yet finalized

TDigest

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult TDigest(@Const @ByRef
                                                                             Datum value)

GroupBy

@Namespace(value="arrow::compute::internal")
 @ByVal
public static DatumResult GroupBy(@Const @ByRef
                                                                                       DatumVector arguments,
                                                                                       @Const @ByRef
                                                                                       DatumVector keys,
                                                                                       @StdVector
                                                                                       Aggregate aggregates,
                                                                                       ExecContext ctx)

Internal use only: helper function for testing HashAggregateKernels. This will be replaced by streaming execution operators.

GroupBy

@Namespace(value="arrow::compute::internal")
 @ByVal
public static DatumResult GroupBy(@Const @ByRef
                                                                                       DatumVector arguments,
                                                                                       @Const @ByRef
                                                                                       DatumVector keys,
                                                                                       @StdVector
                                                                                       Aggregate aggregates)

Add

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Add(@Const @ByRef
                                                                         Datum left,
                                                                         @Const @ByRef
                                                                         Datum right,
                                                                         @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                         ArithmeticOptions options,
                                                                         ExecContext ctx)

\brief Add two values together. Array values must be the same length. If either addend is null the result will be null.

Parameters:: left - [in] the first addend; right - [in] the second addend; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise sum

Add

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Add(@Const @ByRef
                                                                         Datum left,
                                                                         @Const @ByRef
                                                                         Datum right)

Subtract

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Subtract(@Const @ByRef
                                                                              Datum left,
                                                                              @Const @ByRef
                                                                              Datum right,
                                                                              @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                              ArithmeticOptions options,
                                                                              ExecContext ctx)

\brief Subtract two values. Array values must be the same length. If the minuend or subtrahend is null the result will be null.

Parameters:: left - [in] the value subtracted from (minuend); right - [in] the value by which the minuend is reduced (subtrahend); options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise difference

Subtract

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Subtract(@Const @ByRef
                                                                              Datum left,
                                                                              @Const @ByRef
                                                                              Datum right)

Multiply

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Multiply(@Const @ByRef
                                                                              Datum left,
                                                                              @Const @ByRef
                                                                              Datum right,
                                                                              @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                              ArithmeticOptions options,
                                                                              ExecContext ctx)

\brief Multiply two values. Array values must be the same length. If either factor is null the result will be null.

Parameters:: left - [in] the first factor; right - [in] the second factor; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise product

Multiply

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Multiply(@Const @ByRef
                                                                              Datum left,
                                                                              @Const @ByRef
                                                                              Datum right)

Divide

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Divide(@Const @ByRef
                                                                            Datum left,
                                                                            @Const @ByRef
                                                                            Datum right,
                                                                            @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                            ArithmeticOptions options,
                                                                            ExecContext ctx)

\brief Divide two values. Array values must be the same length. If either argument is null the result will be null. For integer types, if there is a zero divisor, an error will be raised.

Parameters:: left - [in] the dividend; right - [in] the divisor; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise quotient

Divide

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Divide(@Const @ByRef
                                                                            Datum left,
                                                                            @Const @ByRef
                                                                            Datum right)

Power

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Power(@Const @ByRef
                                                                           Datum left,
                                                                           @Const @ByRef
                                                                           Datum right,
                                                                           @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                           ArithmeticOptions options,
                                                                           ExecContext ctx)

\brief Raise the values of base array to the power of the exponent array values. Array values must be the same length. If either base or exponent is null the result will be null.

Parameters:: left - [in] the base; right - [in] the exponent; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise base value raised to the power of exponent

Power

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Power(@Const @ByRef
                                                                           Datum left,
                                                                           @Const @ByRef
                                                                           Datum right)

Compare

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Compare(@Const @ByRef
                                                                             Datum left,
                                                                             @Const @ByRef
                                                                             Datum right,
                                                                             @ByVal
                                                                             CompareOptions options,
                                                                             ExecContext ctx)

\brief Compare a numeric array with a scalar.

Parameters:: 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; ctx - [in] the function execution context, optional
Returns:: resulting datum Note on floating point arrays, this uses ieee-754 compare semantics.
Since:: 1.0.0 \note API not yet finalized

Compare

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

Invert

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Invert(@Const @ByRef
                                                                            Datum value,
                                                                            ExecContext ctx)

\brief Invert the values of a boolean datum

Parameters:: value - [in] datum to invert; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

Invert

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Invert(@Const @ByRef
                                                                            Datum value)

And

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult And(@Const @ByRef
                                                                         Datum left,
                                                                         @Const @ByRef
                                                                         Datum right,
                                                                         ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

And

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

KleeneAnd

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult KleeneAnd(@Const @ByRef
                                                                               Datum left,
                                                                               @Const @ByRef
                                                                               Datum right,
                                                                               ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

KleeneAnd

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

Or

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Or(@Const @ByRef
                                                                        Datum left,
                                                                        @Const @ByRef
                                                                        Datum right,
                                                                        ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

Or

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

KleeneOr

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult KleeneOr(@Const @ByRef
                                                                              Datum left,
                                                                              @Const @ByRef
                                                                              Datum right,
                                                                              ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

KleeneOr

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

Xor

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Xor(@Const @ByRef
                                                                         Datum left,
                                                                         @Const @ByRef
                                                                         Datum right,
                                                                         ExecContext ctx)

\brief Element-wise XOR of two boolean datums

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

Xor

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

AndNot

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult AndNot(@Const @ByRef
                                                                            Datum left,
                                                                            @Const @ByRef
                                                                            Datum right,
                                                                            ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 3.0.0 \note API not yet finalized

AndNot

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult AndNot(@Const @ByRef
                                                                            Datum left,
                                                                            @Const @ByRef
                                                                            Datum right)

KleeneAndNot

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult KleeneAndNot(@Const @ByRef
                                                                                  Datum left,
                                                                                  @Const @ByRef
                                                                                  Datum right,
                                                                                  ExecContext ctx)

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

Parameters:: left - [in] left operand; right - [in] right operand; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 3.0.0 \note API not yet finalized

KleeneAndNot

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult KleeneAndNot(@Const @ByRef
                                                                                  Datum left,
                                                                                  @Const @ByRef
                                                                                  Datum right)

IsIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsIn(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          SetLookupOptions options,
                                                                          ExecContext ctx)

\brief IsIn returns true for each element of values that is contained in value_set Behaviour of nulls is governed by SetLookupOptions::skip_nulls.

Parameters:: values - [in] array-like input to look up in value_set; options - [in] SetLookupOptions; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

IsIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsIn(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          SetLookupOptions options)

IsIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsIn(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          Datum value_set,
                                                                          ExecContext ctx)

IsIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsIn(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          Datum value_set)

IndexIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IndexIn(@Const @ByRef
                                                                             Datum values,
                                                                             @Const @ByRef
                                                                             SetLookupOptions options,
                                                                             ExecContext ctx)

\brief IndexIn examines each slot in the values against a value_set array. If the value is not found in value_set, null will be output. If found, the index of occurrence within value_set (ignoring duplicates) will be output. For example given values = [99, 42, 3, null] and value_set = [3, 3, 99], the output will be = [1, null, 0, null] Behaviour of nulls is governed by SetLookupOptions::skip_nulls.

Parameters:: values - [in] array-like input; options - [in] SetLookupOptions; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

IndexIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IndexIn(@Const @ByRef
                                                                             Datum values,
                                                                             @Const @ByRef
                                                                             SetLookupOptions options)

IndexIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IndexIn(@Const @ByRef
                                                                             Datum values,
                                                                             @Const @ByRef
                                                                             Datum value_set,
                                                                             ExecContext ctx)

IndexIn

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IndexIn(@Const @ByRef
                                                                             Datum values,
                                                                             @Const @ByRef
                                                                             Datum value_set)

IsValid

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsValid(@Const @ByRef
                                                                             Datum values,
                                                                             ExecContext ctx)

\brief IsValid returns true for each element of values that is not null, false otherwise

Parameters:: values - [in] input to examine for validity; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

IsValid

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsValid(@Const @ByRef
                                                                             Datum values)

IsNull

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsNull(@Const @ByRef
                                                                            Datum values,
                                                                            ExecContext ctx)

\brief IsNull returns true for each element of values that is null, false otherwise

Parameters:: values - [in] input to examine for nullity; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

IsNull

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsNull(@Const @ByRef
                                                                            Datum values)

IsNan

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsNan(@Const @ByRef
                                                                           Datum values,
                                                                           ExecContext ctx)

\brief IsNan returns true for each element of values that is NaN, false otherwise

Parameters:: values - [in] input to look for NaN; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 3.0.0 \note API not yet finalized

IsNan

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult IsNan(@Const @ByRef
                                                                           Datum values)

FillNull

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult FillNull(@Const @ByRef
                                                                              Datum values,
                                                                              @Const @ByRef
                                                                              Datum fill_value,
                                                                              ExecContext ctx)

\brief FillNull replaces each null element in values with fill_value

Parameters:: values - [in] input to examine for nullity; fill_value - [in] scalar; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

FillNull

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult FillNull(@Const @ByRef
                                                                              Datum values,
                                                                              @Const @ByRef
                                                                              Datum fill_value)

Filter

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Filter(@Const @ByRef
                                                                            Datum values,
                                                                            @Const @ByRef
                                                                            Datum filter,
                                                                            @Const @ByRef(nullValue="arrow::compute::FilterOptions::Defaults()")
                                                                            FilterOptions options,
                                                                            ExecContext ctx)

\brief Filter with a boolean selection filter The output will be populated with values from the input at positions where the selection filter is not 0. Nulls in the filter will be handled based on options.null_selection_behavior. For example given values = ["a", "b", "c", null, "e", "f"] and filter = [0, 1, 1, 0, null, 1], the output will be (null_selection_behavior == DROP) = ["b", "c", "f"] (null_selection_behavior == EMIT_NULL) = ["b", "c", null, "f"]

Parameters:: values - [in] array to filter; filter - [in] indicates which values should be filtered out; options - [in] configures null_selection_behavior; ctx - [in] the function execution context, optional
Returns:: the resulting datum

Filter

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

GetFilterOutputSize

@Namespace(value="arrow::compute::internal")
 @Cast(value="int64_t")
public static long GetFilterOutputSize(@Const @ByRef
                                                                                                            ArrayData filter,
                                                                                                            FilterOptions.NullSelectionBehavior null_selection)

\brief Return the number of selected indices in the boolean filter

GetFilterOutputSize

@Namespace(value="arrow::compute::internal")
 @Cast(value="int64_t")
public static long GetFilterOutputSize(@Const @ByRef
                                                                                                            ArrayData filter,
                                                                                                            @Cast(value="arrow::compute::FilterOptions::NullSelectionBehavior")
                                                                                                            int null_selection)

GetTakeIndices

@Namespace(value="arrow::compute::internal")
 @ByVal
public static ArrayDataResult GetTakeIndices(@Const @ByRef
                                                                                                  ArrayData filter,
                                                                                                  FilterOptions.NullSelectionBehavior null_selection,
                                                                                                  MemoryPool memory_pool)

\brief Compute uint64 selection indices for use with Take given a boolean filter

GetTakeIndices

@Namespace(value="arrow::compute::internal")
 @ByVal
public static ArrayDataResult GetTakeIndices(@Const @ByRef
                                                                                                  ArrayData filter,
                                                                                                  FilterOptions.NullSelectionBehavior null_selection)

GetTakeIndices

@Namespace(value="arrow::compute::internal")
 @ByVal
public static ArrayDataResult GetTakeIndices(@Const @ByRef
                                                                                                  ArrayData filter,
                                                                                                  @Cast(value="arrow::compute::FilterOptions::NullSelectionBehavior")
                                                                                                  int null_selection,
                                                                                                  MemoryPool memory_pool)

GetTakeIndices

@Namespace(value="arrow::compute::internal")
 @ByVal
public static ArrayDataResult GetTakeIndices(@Const @ByRef
                                                                                                  ArrayData filter,
                                                                                                  @Cast(value="arrow::compute::FilterOptions::NullSelectionBehavior")
                                                                                                  int null_selection)

Take

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Take(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          Datum indices,
                                                                          @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                          TakeOptions options,
                                                                          ExecContext ctx)

\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:: values - [in] datum from which to take; indices - [in] which values to take; options - [in] options; ctx - [in] the function execution context, optional
Returns:: the resulting datum

Take

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Take(@Const @ByRef
                                                                          Datum values,
                                                                          @Const @ByRef
                                                                          Datum indices)

Take

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Take(@Const @ByRef
                                                                          Array values,
                                                                          @Const @ByRef
                                                                          Array indices,
                                                                          @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                          TakeOptions options,
                                                                          ExecContext ctx)

\brief Take with Array inputs and output

Take

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Take(@Const @ByRef
                                                                          Array values,
                                                                          @Const @ByRef
                                                                          Array indices)

NthToIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult NthToIndices(@Const @ByRef
                                                                                  Array values,
                                                                                  @Cast(value="int64_t")
                                                                                  long n,
                                                                                  ExecContext ctx)

\brief Returns indices that partition an array around n-th sorted element. Find index of n-th(0 based) smallest value and perform indirect partition of an array around that element. Output indices[0 ~ n-1] holds values no greater than n-th element, and indices[n+1 ~ end] holds values no less than n-th element. Elements in each partition is not sorted. Nulls will be partitioned to the end of the output. Output is not guaranteed to be stable.

Parameters:: values - [in] array to be partitioned; n - [in] pivot array around sorted n-th element; ctx - [in] the function execution context, optional
Returns:: offsets indices that would partition an array

NthToIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult NthToIndices(@Const @ByRef
                                                                                  Array values,
                                                                                  @Cast(value="int64_t")
                                                                                  long n)

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 Array array,
                                                                                 arrow.SortOrder order,
                                                                                 ExecContext ctx)

\brief Returns the indices that would sort an array in the specified order. 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 regardless of order. For example given array = [null, 1, 3.3, null, 2, 5.3] and order = SortOrder::DESCENDING, the output will be [5, 2, 4, 1, 0, 3].

Parameters:: array - [in] array to sort; order - [in] ascending or descending; ctx - [in] the function execution context, optional
Returns:: offsets indices that would sort an array

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 Array array)

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 Array array,
                                                                                 @Cast(value="arrow::compute::SortOrder")
                                                                                 int order,
                                                                                 ExecContext ctx)

SortIndices
```
@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 ChunkedArray chunked_array,
                                                                                 arrow.SortOrder order,
                                                                                 ExecContext ctx)
```
\brief Returns the indices that would sort a chunked array in the specified order. Perform an indirect sort of chunked array. The output array will contain indices that would sort a chunked array, which would be the same length as input. Nulls will be stably partitioned to the end of the output regardless of order. For example given chunked_array = [[null, 1], [3.3], [null, 2, 5.3]] and order = SortOrder::DESCENDING, the output will be [5, 2, 4, 1, 0, 3].

Parameters:

chunked_array - [in] chunked array to sort

order - [in] ascending or descending

ctx - [in] the function execution context, optional

Returns:

offsets indices that would sort an array

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 ChunkedArray chunked_array)

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 ChunkedArray chunked_array,
                                                                                 @Cast(value="arrow::compute::SortOrder")
                                                                                 int order,
                                                                                 ExecContext ctx)

SortIndices
```
@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 Datum datum,
                                                                                 @Const @ByRef
                                                                                 SortOptions options,
                                                                                 ExecContext ctx)
```
\brief Returns the indices that would sort an input in the specified order. Input is one of array, chunked array record batch or table. Perform an indirect sort of input. The output array will contain indices that would sort an input, which would be the same length as input. Nulls will be stably partitioned to the end of the output regardless of order. For example given input (table) = { "column1": [[null, 1], [ 3, null, 2, 1]], "column2": [[ 5], [3, null, null, 5, 5]], } and options = { {"column1", SortOrder::Ascending}, {"column2", SortOrder::Descending}, }, the output will be [5, 1, 4, 2, 0, 3].

Parameters:

datum - [in] array, chunked array, record batch or table to sort

options - [in] options

ctx - [in] the function execution context, optional

Returns:

offsets indices that would sort a table

SortIndices

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                 Datum datum,
                                                                                 @Const @ByRef
                                                                                 SortOptions options)

Unique

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Unique(@Const @ByRef
                                                                            Datum datum,
                                                                            ExecContext ctx)

\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:: datum - [in] array-like input; ctx - [in] the function execution context, optional
Returns:: result as Array
Since:: 1.0.0 \note API not yet finalized

Unique

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Unique(@Const @ByRef
                                                                            Datum datum)

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 StructArrayResult ValueCounts(@Const @ByRef
                                                                                       Datum value,
                                                                                       ExecContext ctx)
```
\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:

value - [in] array-like input

ctx - [in] the function execution context, optional

Returns:

counts An array of structs.

Since:

1.0.0 \note API not yet finalized

ValueCounts

@Namespace(value="arrow::compute")
 @ByVal
public static StructArrayResult ValueCounts(@Const @ByRef
                                                                                       Datum value)

DictionaryEncode

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult DictionaryEncode(@Const @ByRef
                                                                                      Datum data,
                                                                                      @Const @ByRef(nullValue="arrow::compute::DictionaryEncodeOptions::Defaults()")
                                                                                      DictionaryEncodeOptions options,
                                                                                      ExecContext ctx)

\brief Dictionary-encode values in an array-like object Any nulls encountered in the dictionary will be handled according to the specified null encoding behavior. For example, given values ["a", "b", null, "a", null] the output will be (null_encoding == ENCODE) Indices: [0, 1, 2, 0, 2] / Dict: ["a", "b", null] (null_encoding == MASK) Indices: [0, 1, null, 0, null] / Dict: ["a", "b"] If the input is already dictionary encoded this function is a no-op unless it needs to modify the null_encoding (TODO)

Parameters:: data - [in] array-like input; ctx - [in] the function execution context, optional; options - [in] configures null encoding behavior
Returns:: result with same shape and type as input
Since:: 1.0.0 \note API not yet finalized

DictionaryEncode

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult DictionaryEncode(@Const @ByRef
                                                                                      Datum data)

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              ChunkedArray values,
                                                                                              @Const @ByRef
                                                                                              Array indices,
                                                                                              @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                              TakeOptions options,
                                                                                              ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              ChunkedArray values,
                                                                                              @Const @ByRef
                                                                                              Array indices)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              ChunkedArray values,
                                                                                              @Const @ByRef
                                                                                              ChunkedArray indices,
                                                                                              @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                              TakeOptions options,
                                                                                              ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              ChunkedArray values,
                                                                                              @Const @ByRef
                                                                                              ChunkedArray indices)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              Array values,
                                                                                              @Const @ByRef
                                                                                              ChunkedArray indices,
                                                                                              @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                              TakeOptions options,
                                                                                              ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ChunkedArrayResult Take(@Const @ByRef
                                                                                              Array values,
                                                                                              @Const @ByRef
                                                                                              ChunkedArray indices)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static RecordBatchResult Take(@Const @ByRef
                                                                                             RecordBatch batch,
                                                                                             @Const @ByRef
                                                                                             Array indices,
                                                                                             @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                             TakeOptions options,
                                                                                             ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static RecordBatchResult Take(@Const @ByRef
                                                                                             RecordBatch batch,
                                                                                             @Const @ByRef
                                                                                             Array indices)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static TableResult Take(@Const @ByRef
                                                                                       Table table,
                                                                                       @Const @ByRef
                                                                                       Array indices,
                                                                                       @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                       TakeOptions options,
                                                                                       ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static TableResult Take(@Const @ByRef
                                                                                       Table table,
                                                                                       @Const @ByRef
                                                                                       Array indices)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static TableResult Take(@Const @ByRef
                                                                                       Table table,
                                                                                       @Const @ByRef
                                                                                       ChunkedArray indices,
                                                                                       @Const @ByRef(nullValue="arrow::compute::TakeOptions::Defaults()")
                                                                                       TakeOptions options,
                                                                                       ExecContext context)

Deprecated.

Take

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static TableResult Take(@Const @ByRef
                                                                                       Table table,
                                                                                       @Const @ByRef
                                                                                       ChunkedArray indices)

Deprecated.

SortToIndices

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ArrayResult SortToIndices(@Const @ByRef
                                                                                                Array values,
                                                                                                ExecContext ctx)

Deprecated.

SortToIndices

@Namespace(value="arrow::compute")
 @Deprecated
 @ByVal
public static ArrayResult SortToIndices(@Const @ByRef
                                                                                                Array values)

Deprecated.

SameTypeId

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher SameTypeId(@Cast(value="arrow::Type::type")
                                                                                           int type_id)

\brief Match any DataType instance having the same DataType::id.

TimestampTypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher TimestampTypeUnit(TimeUnit.type unit)

\brief Match any TimestampType instance having the same unit, but the time zones can be different.

TimestampTypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher TimestampTypeUnit(@Cast(value="arrow::TimeUnit::type")
                                                                                                  int unit)

Time32TypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Time32TypeUnit(TimeUnit.type unit)

Time32TypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Time32TypeUnit(@Cast(value="arrow::TimeUnit::type")
                                                                                               int unit)

Time64TypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Time64TypeUnit(TimeUnit.type unit)

Time64TypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Time64TypeUnit(@Cast(value="arrow::TimeUnit::type")
                                                                                               int unit)

DurationTypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher DurationTypeUnit(TimeUnit.type unit)

DurationTypeUnit

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher DurationTypeUnit(@Cast(value="arrow::TimeUnit::type")
                                                                                                 int unit)

Integer

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Integer()

BinaryLike

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher BinaryLike()

LargeBinaryLike

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher LargeBinaryLike()

Primitive

@Namespace(value="arrow::compute::match")
 @SharedPtr
public static TypeMatcher Primitive()

kDefaultExecChunksize

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

\brief See VectorKernel::finalize member for usage

default_exec_context

@Namespace(value="arrow::compute")
public static ExecContext default_exec_context()

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  String func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  @Const
                                                                                  FunctionOptions options,
                                                                                  ExecContext ctx)

\defgroup compute-call-function One-shot calls to compute functions \{

\brief One-shot invoker for all types of functions. Does kernel dispatch, argument checking, iteration of ChunkedArray inputs, and wrapping of outputs.

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  String func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  @Const
                                                                                  FunctionOptions options)

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  BytePointer func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  @Const
                                                                                  FunctionOptions options,
                                                                                  ExecContext ctx)

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  BytePointer func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  @Const
                                                                                  FunctionOptions options)

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  String func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  ExecContext ctx)

\brief Variant of CallFunction which uses a function's default options. NB: Some functions require FunctionOptions be provided.

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  String func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args)

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  BytePointer func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args,
                                                                                  ExecContext ctx)

CallFunction

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CallFunction(@StdString
                                                                                  BytePointer func_name,
                                                                                  @Const @ByRef
                                                                                  DatumVector args)

DispatchExactImpl

@Namespace(value="arrow::compute::detail")
 @Const
public static Kernel DispatchExactImpl(@Const
                                                                                          Function func,
                                                                                          @Const @ByRef
                                                                                          ValueDescrVector arg1)

\brief Look up a kernel in a function. If no Kernel is found, nullptr is returned.

NoMatchingKernel

@Namespace(value="arrow::compute::detail")
 @ByVal
public static Status NoMatchingKernel(@Const
                                                                                         Function func,
                                                                                         @Const @ByRef
                                                                                         ValueDescrVector arg1)

\brief Return an error message if no Kernel is found.

CanCast

@Namespace(value="arrow::compute")
 @Cast(value="bool")
public static boolean CanCast(@Const @ByRef
                                                                                      DataType from_type,
                                                                                      @Const @ByRef
                                                                                      DataType to_type)

\brief Return true if a cast function is defined

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Cast(@Const @ByRef
                                                                          Array value,
                                                                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                          DataType to_type,
                                                                          @Const @ByRef(nullValue="arrow::compute::CastOptions::Safe()")
                                                                          CastOptions options,
                                                                          ExecContext ctx)

\brief Cast from one array type to another

Parameters:: value - [in] array to cast; to_type - [in] type to cast to; options - [in] casting options; ctx - [in] the function execution context, optional
Returns:: the resulting array
Since:: 1.0.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult Cast(@Const @ByRef
                                                                          Array value,
                                                                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                          DataType to_type)

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Cast(@Const @ByRef
                                                                          Datum value,
                                                                          @Const @ByRef
                                                                          CastOptions options,
                                                                          ExecContext ctx)

\brief Cast from one array type to another

Parameters:: value - [in] array to cast; options - [in] casting options. The "to_type" field must be populated; ctx - [in] the function execution context, optional
Returns:: the resulting array
Since:: 1.0.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Cast(@Const @ByRef
                                                                          Datum value,
                                                                          @Const @ByRef
                                                                          CastOptions options)

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Cast(@Const @ByRef
                                                                          Datum value,
                                                                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                          DataType to_type,
                                                                          @Const @ByRef(nullValue="arrow::compute::CastOptions::Safe()")
                                                                          CastOptions options,
                                                                          ExecContext ctx)

\brief Cast from one value to another

Parameters:: value - [in] datum to cast; to_type - [in] type to cast to; options - [in] casting options; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 1.0.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Cast(@Const @ByRef
                                                                          Datum value,
                                                                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                                                          DataType to_type)

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumVectorResult Cast(@ByVal
                                                                                DatumVector values,
                                                                                @ByVal
                                                                                ValueDescrVector descrs,
                                                                                ExecContext ctx)

\brief Cast several values simultaneously. Safe cast options are used.

Parameters:: values - [in] datums to cast; descrs - [in] ValueDescrs to cast to; ctx - [in] the function execution context, optional
Returns:: the resulting datums
Since:: 4.0.0 \note API not yet finalized

Cast

@Namespace(value="arrow::compute")
 @ByVal
public static DatumVectorResult Cast(@ByVal
                                                                                DatumVector values,
                                                                                @ByVal
                                                                                ValueDescrVector descrs)

GetFunctionRegistry

@Namespace(value="arrow::compute")
public static FunctionRegistry GetFunctionRegistry()

\brief Return the process-global function registry

CollectDictionaries

@Namespace(value="arrow::ipc")
 @ByVal
public static DictionaryVectorResult CollectDictionaries(@Const @ByRef
                                                                                                RecordBatch batch,
                                                                                                @Const @ByRef
                                                                                                DictionaryFieldMapper mapper)

ResolveDictionaries

@Namespace(value="arrow::ipc")
 @ByVal
public static Status ResolveDictionaries(@Const @ByRef
                                                                                ArrayDataVector columns,
                                                                                @Const @ByRef
                                                                                DictionaryMemo memo,
                                                                                MemoryPool pool)

CollectDictionaries

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

kFeatherV1Version

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

kFeatherV2Version

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

WriteTable

@Namespace(value="arrow::ipc::feather")
 @ByVal
public static Status WriteTable(@Const @ByRef
                                                                                Table table,
                                                                                OutputStream dst,
                                                                                @Const @ByRef(nullValue="arrow::ipc::feather::WriteProperties::Defaults()")
                                                                                WriteProperties properties)

WriteTable

@Namespace(value="arrow::ipc::feather")
 @ByVal
public static Status WriteTable(@Const @ByRef
                                                                                Table table,
                                                                                OutputStream dst)

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)

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(arrow.MessageType type)

FormatMessageType

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

ReadMessage
```
@Namespace(value="arrow::ipc")
 @ByVal
public static MessageUniqueResult ReadMessage(@Cast(value="const int64_t")
                                                                                     long offset,
                                                                                     int metadata_length,
                                                                                     RandomAccessFile file)
```
\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

Returns:

the message read

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 MessageUniqueResult ReadMessage(InputStream stream,
                                                                                     MemoryPool pool)
```
\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)

Parameters:

stream - [in] an input stream

pool - [in] an optional MemoryPool to copy metadata on the CPU, if required

Returns:

Message

ReadMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static MessageUniqueResult ReadMessage(InputStream stream)

DecodeMessage

@Namespace(value="arrow::ipc")
 @ByVal
public static Status DecodeMessage(MessageDecoder decoder,
                                                                          InputStream stream)

\brief Feed data from InputStream to MessageDecoder to decode an encapsulated IPC message (metadata and body) This API is EXPERIMENTAL.

Parameters:: decoder - [in] a decoder; stream - [in] an input stream
Returns:: Status
Since:: 0.17.0

ReadSchema
```
@Namespace(value="arrow::ipc")
 @ByVal
public static SchemaResult ReadSchema(InputStream stream,
                                                                             DictionaryMemo dictionary_memo)
```
\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

Returns:

the output Schema If record batches follow the schema, it is better to use RecordBatchStreamReader

ReadSchema

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

\brief Read Schema from encapsulated Message

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

ReadRecordBatch

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

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; options - [in] IPC options for reading; stream - [in] the file where the batch is located
Returns:: the read record batch

ReadRecordBatch

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

\brief Read record batch from message

Parameters:: message - [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; options - [in] IPC options for reading
Returns:: the read record batch

ReadRecordBatch

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

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
Returns:: the read record batch

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

ReadSparseTensor
```
@Namespace(value="arrow::ipc")
 @ByVal
public static SparseTensorResult ReadSparseTensor(InputStream file)
```
\brief EXPERIMENTAL: Read arrow::SparseTensor as encapsulated IPC message in file

Parameters:

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

Returns:

the read sparse tensor

ReadSparseTensor

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

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

Parameters:: message - [in] a Message containing the tensor metadata and body
Returns:: the read sparse 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)

FuzzIpcTensorStream

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

FuzzIpcTensorStream

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

FuzzIpcTensorStream

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static Status FuzzIpcTensorStream(@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)

MakeStreamWriter

@Namespace(value="arrow::ipc")
 @ByVal
public static RecordBatchWriterSharedResult MakeStreamWriter(OutputStream sink,
                                                                                                    @Const @SharedPtr @ByRef
                                                                                                    Schema schema,
                                                                                                    @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                    IpcWriteOptions options)

\defgroup record-batch-writer-factories Functions for creating RecordBatchWriter instances \{

Create a new IPC stream writer from stream sink and schema. User is responsible for closing the actual OutputStream.

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

MakeStreamWriter

@Namespace(value="arrow::ipc")
 @ByVal
public static RecordBatchWriterSharedResult MakeStreamWriter(OutputStream sink,
                                                                                                    @Const @SharedPtr @ByRef
                                                                                                    Schema schema)

MakeFileWriter

@Namespace(value="arrow::ipc")
 @ByVal
public static RecordBatchWriterSharedResult MakeFileWriter(OutputStream sink,
                                                                                                  @Const @SharedPtr @ByRef
                                                                                                  Schema schema,
                                                                                                  @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                  IpcWriteOptions options,
                                                                                                  @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                                                  KeyValueMetadata metadata)

Create a new IPC file writer from stream sink and schema

Parameters:: sink - [in] output stream to write to; schema - [in] the schema of the record batches to be written; options - [in] options for serialization, optional; metadata - [in] custom metadata for File Footer, optional
Returns:: Result>

MakeFileWriter

@Namespace(value="arrow::ipc")
 @ByVal
public static RecordBatchWriterSharedResult MakeFileWriter(OutputStream sink,
                                                                                                  @Const @SharedPtr @ByRef
                                                                                                  Schema schema)

NewStreamWriter

@Namespace(value="arrow::ipc")
 @Deprecated
 @ByVal
public static RecordBatchWriterSharedResult NewStreamWriter(OutputStream sink,
                                                                                                                @Const @SharedPtr @ByRef
                                                                                                                Schema schema,
                                                                                                                @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                                IpcWriteOptions options)

Deprecated.

NewStreamWriter

@Namespace(value="arrow::ipc")
 @Deprecated
 @ByVal
public static RecordBatchWriterSharedResult NewStreamWriter(OutputStream sink,
                                                                                                                @Const @SharedPtr @ByRef
                                                                                                                Schema schema)

Deprecated.

NewFileWriter

@Namespace(value="arrow::ipc")
 @Deprecated
 @ByVal
public static RecordBatchWriterSharedResult NewFileWriter(OutputStream sink,
                                                                                                              @Const @SharedPtr @ByRef
                                                                                                              Schema schema,
                                                                                                              @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                              IpcWriteOptions options,
                                                                                                              @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                                                              KeyValueMetadata metadata)

Deprecated.

NewFileWriter

@Namespace(value="arrow::ipc")
 @Deprecated
 @ByVal
public static RecordBatchWriterSharedResult NewFileWriter(OutputStream sink,
                                                                                                              @Const @SharedPtr @ByRef
                                                                                                              Schema schema)

Deprecated.

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
                                                                             IpcWriteOptions options)

\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
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
                                                                             IpcWriteOptions options)

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
                                                                             IpcWriteOptions options)

SerializeRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static BufferResult SerializeRecordBatch(@Const @ByRef
                                                                                       RecordBatch batch,
                                                                                       @Const @ByRef
                                                                                       IpcWriteOptions options)

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

Parameters:: batch - [in] the record batch; options - [in] the IpcWriteOptions to use for serialization
Returns:: the serialized message

SerializeRecordBatch

@Namespace(value="arrow::ipc")
 @ByVal
public static BufferResult SerializeRecordBatch(@Const @ByRef
                                                                                       RecordBatch batch,
                                                                                       @SharedPtr
                                                                                       MemoryManager mm)

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

Parameters:: batch - [in] the record batch; mm - [in] a MemoryManager to allocate memory from
Returns:: the serialized message

SerializeRecordBatch

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

\brief Write record batch to OutputStream

Parameters:: batch - [in] the record batch to write; options - [in] the IpcWriteOptions to use for serialization; 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 BufferResult SerializeSchema(@Const @ByRef
                                                                                  Schema schema,
                                                                                  MemoryPool pool)

\brief Serialize schema as encapsulated IPC message

Parameters:: schema - [in] the schema to write; pool - [in] a MemoryPool to allocate memory from
Returns:: the serialized schema

SerializeSchema

@Namespace(value="arrow::ipc")
 @ByVal
public static BufferResult SerializeSchema(@Const @ByRef
                                                                                  Schema schema)

WriteRecordBatchStream

@Namespace(value="arrow::ipc")
 @ByVal
public static Status WriteRecordBatchStream(@Const @ByRef
                                                                                   RecordBatchVector batches,
                                                                                   @Const @ByRef
                                                                                   IpcWriteOptions 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

GetPayloadSize

@Namespace(value="arrow::ipc")
 @Cast(value="int64_t")
public static long GetPayloadSize(@Const @ByRef
                                                                                         IpcPayload payload,
                                                                                         @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                         IpcWriteOptions options)

\brief Compute the number of bytes needed to write an IPC payload including metadata

Parameters:: payload - [in] the IPC payload to write; options - [in] write options
Returns:: the size of the complete encapsulated message

GetPayloadSize

@Namespace(value="arrow::ipc")
 @Cast(value="int64_t")
public static long GetPayloadSize(@Const @ByRef
                                                                                         IpcPayload payload)

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)

GetRecordBatchSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetRecordBatchSize(@Const @ByRef
                                                                               RecordBatch batch,
                                                                               @Const @ByRef
                                                                               IpcWriteOptions options,
                                                                               @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; options - [in] options for serialization; 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,
                                                                               @Const @ByRef
                                                                               IpcWriteOptions options,
                                                                               @Cast(value="int64_t*")
                                                                               LongBuffer size)

GetRecordBatchSize

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetRecordBatchSize(@Const @ByRef
                                                                               RecordBatch batch,
                                                                               @Const @ByRef
                                                                               IpcWriteOptions options,
                                                                               @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 MessageUniqueResult GetTensorMessage(@Const @ByRef
                                                                                          Tensor tensor,
                                                                                          MemoryPool pool)

\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
Returns:: the resulting Message

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 MessageUniqueResult GetSparseTensorMessage(@Const @ByRef
                                                                                                SparseTensor sparse_tensor,
                                                                                                MemoryPool pool)

\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
Returns:: the resulting Message

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)

GetSchemaPayload

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetSchemaPayload(@Const @ByRef
                                                                             Schema schema,
                                                                             @Const @ByRef
                                                                             IpcWriteOptions options,
                                                                             @Const @ByRef
                                                                             DictionaryFieldMapper mapper,
                                                                             IpcPayload out)

\brief Compute IpcPayload for the given schema

Parameters:: schema - [in] the Schema that is being serialized; options - [in] options for serialization; mapper - [in] object mapping dictionary fields to dictionary ids; out - [out] the returned vector of IpcPayloads
Returns:: Status

GetDictionaryPayload

@Namespace(value="arrow::ipc")
 @ByVal
public static Status GetDictionaryPayload(@Cast(value="int64_t")
                                                                                 long id,
                                                                                 @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Array>"})
                                                                                 Array dictionary,
                                                                                 @Const @ByRef
                                                                                 IpcWriteOptions options,
                                                                                 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

GetDictionaryPayload

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

\brief Compute IpcPayload for a dictionary

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

GetRecordBatchPayload

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

\brief Compute IpcPayload for the given record batch

Parameters:: batch - [in] the RecordBatch that is being serialized; options - [in] options for serialization; out - [out] the returned IpcPayload
Returns:: Status

WriteIpcPayload

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

\brief Write an IPC payload to the given stream.

Parameters:: payload - [in] the payload to write; options - [in] options for serialization; dst - [in] The stream to write the payload to.; metadata_length - [out] the length of the serialized metadata
Returns:: Status

WriteIpcPayload

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

WriteIpcPayload

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

GetSparseTensorPayload

@Namespace(value="arrow::ipc")
 @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

MakePayloadStreamWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static IpcPayloadWriterResult MakePayloadStreamWriter(OutputStream sink,
                                                                                                              @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                              IpcWriteOptions options)

Create a new IPC payload stream writer from stream sink. User is responsible for closing the actual OutputStream.

Parameters:: sink - [in] output stream to write to; options - [in] options for serialization
Returns:: Result>

MakePayloadStreamWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static IpcPayloadWriterResult MakePayloadStreamWriter(OutputStream sink)

MakePayloadFileWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static IpcPayloadWriterResult MakePayloadFileWriter(OutputStream sink,
                                                                                                            @Const @SharedPtr @ByRef
                                                                                                            Schema schema,
                                                                                                            @Const @ByRef(nullValue="arrow::ipc::IpcWriteOptions::Defaults()")
                                                                                                            IpcWriteOptions options,
                                                                                                            @SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                                                            KeyValueMetadata metadata)

Create a new IPC payload file writer from stream sink.

Parameters:: sink - [in] output stream to write to; schema - [in] the schema of the record batches to be written; options - [in] options for serialization, optional; metadata - [in] custom metadata for File Footer, optional
Returns:: Status

MakePayloadFileWriter

@Namespace(value="arrow::ipc::internal")
 @ByVal
public static IpcPayloadWriterResult MakePayloadFileWriter(OutputStream sink,
                                                                                                            @Const @SharedPtr @ByRef
                                                                                                            Schema schema)

OpenRecordBatchWriter

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

Create a new RecordBatchWriter from IpcPayloadWriter and schema. The format is implicitly the IPC stream format (allowing dictionary replacement and deltas).

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>

OpenRecordBatchWriter

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

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_VERSION_STRING

ARROW_SO_VERSION

ARROW_FULL_SO_VERSION

ARROW_CXX_COMPILER_ID

ARROW_CXX_COMPILER_VERSION

ARROW_CXX_COMPILER_FLAGS

ARROW_GIT_ID

ARROW_GIT_DESCRIPTION

ARROW_PACKAGE_KIND

ARROW_BITNESS

kDefaultAbsoluteTolerance

kNoSize

kDefaultExecChunksize

kFeatherV1Version

kFeatherV2Version

Constructor Detail

arrow

Method Detail

ARROW_BITNESS

kUseDefaultCompressionLevel

kBytePopcount

kBytePopcount

PopCount

PopCount

CeilDiv

BytesForBits

IsPowerOf2

NextPower2

IsMultipleOf64

IsMultipleOf8

LeastSignificantBitMask

RoundUp

RoundDown

RoundUpToPowerOf2

RoundUpToMultipleOf8

RoundUpToMultipleOf64

CoveringBytes

TrailingBits

CountLeadingZeros

CountLeadingZeros

CountTrailingZeros

CountTrailingZeros

NumRequiredBits

Log2

kBitmask

kBitmask

kFlippedBitmask

kFlippedBitmask

kPrecedingBitmask

kPrecedingBitmask

kPrecedingWrappingBitmask

kPrecedingWrappingBitmask

kTrailingBitmask

kTrailingBitmask

GetBit

GetBit

GetBit

GetBitFromByte

ClearBit

ClearBit

ClearBit

SetBit

SetBit

SetBit

SetBitTo

SetBitTo

SetBitTo

SetBitsTo