arrow (JavaCPP Presets for Arrow 6.0.1-1.5.7 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.NullPlacement`
`static class`	`arrow.RoundMode` Rounding and tie-breaking modes for round compute functions.
`static class`	`arrow.ShouldSchedule` \brief Describe whether the callback should be scheduled or run synchronously
`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 DatumResult`	`AbsoluteValue(Datum arg)`
`static DatumResult`	`AbsoluteValue(Datum arg, ArithmeticOptions options, ExecContext ctx)` \}
`static DatumResult`	`Acos(Datum arg)`
`static DatumResult`	`Acos(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Compute the inverse cosine (arccosine) of the array values.
`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)` \brief Add two values together.
`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, ScalarAggregateOptions options, 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 Future`	`AllFinished(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 Expression`	`and_(Expression arg0)`
`static Expression`	`and_(Expression lhs, Expression rhs)`
`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, ScalarAggregateOptions options, 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 DatumResult`	`Asin(Datum arg)`
`static DatumResult`	`Asin(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Compute the inverse sine (arcsine) of the array values.
`static DatumResult`	`AssumeTimezone(Datum values, AssumeTimezoneOptions options)`
`static DatumResult`	`AssumeTimezone(Datum values, AssumeTimezoneOptions options, ExecContext ctx)` \brief Converts timestamps from local timestamp without a timezone to a timestamp with timezone, interpreting the local timestamp as being in the specified timezone for each element of `values`
`static DatumResult`	`Atan(Datum arg)`
`static DatumResult`	`Atan(Datum arg, ExecContext ctx)` \brief Compute the inverse tangent (arctangent) of the array values.
`static DatumResult`	`Atan2(Datum y, Datum x)`
`static DatumResult`	`Atan2(Datum y, Datum x, ExecContext ctx)` \brief Compute the inverse tangent (arctangent) of y/x, using the argument signs to determine the correct quadrant.
`static DataTypeVector`	`BaseBinaryTypes()`
`static DataType`	`binary()` \brief Return a BinaryType instance
`static TypeMatcher`	`BinaryLike()`
`static int`	`bit_width(int type_id)`
`static long`	`BytesForBits(long bits)`
`static Expression`	`call(BytePointer function, Expression arguments)`
`static Expression`	`call(BytePointer function, Expression arguments, FunctionOptions options)`
`static Expression`	`call(String function, Expression arguments)`
`static Expression`	`call(String function, Expression arguments, FunctionOptions options)`
`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 ExpressionResult`	`Canonicalize(Expression arg0)`
`static ExpressionResult`	`Canonicalize(Expression arg0, ExecContext arg1)` \defgroup expression-passes Functions for modification of Expressions \{ These transform bound expressions.
`static DatumResult`	`CaseWhen(Datum cond, DatumVector cases)`
`static DatumResult`	`CaseWhen(Datum cond, DatumVector cases, ExecContext ctx)` \brief CaseWhen behaves like a switch/case or if-else if-else statement: for each row, select the first value for which the corresponding condition is true, or (if given) select the 'else' value, else emit null.
`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 DatumResult`	`Ceil(Datum arg)`
`static DatumResult`	`Ceil(Datum arg, ExecContext ctx)` \brief Round to the nearest integer greater than or equal in magnitude to the argument.
`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 void`	`ClearBitmap(byte[] data, long offset, long length)`
`static void`	`ClearBitmap(ByteBuffer data, long offset, long length)`
`static void`	`ClearBitmap(BytePointer data, long offset, long length)` \brief Clears all bits in the bitmap (set to false)
`static DictionaryVectorResult`	`CollectDictionaries(RecordBatch batch, DictionaryFieldMapper mapper)`
`static Status`	`CollectDictionaries(RecordBatch batch, DictionaryMemo memo)`
`static DatumResult`	`Compare(Datum left, Datum right, CompareOptions options)` Deprecated.
`static DatumResult`	`Compare(Datum left, Datum right, CompareOptions options, ExecContext ctx)` Deprecated.
`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 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`	`Cos(Datum arg)`
`static DatumResult`	`Cos(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Compute the cosine of the array values.
`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 LongFuture`	`CountRowsAsync(IOContext io_context, InputStream input, Executor cpu_executor, ReadOptions arg3, CsvParseOptions arg4)` \brief Count the logical rows of data in a CSV file (i.e.
`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 DatumResult`	`Day(Datum values)`
`static DatumResult`	`Day(Datum values, ExecContext ctx)` \brief Day returns day number for each element of `values`
`static DatumResult`	`DayOfWeek(Datum values)`
`static DatumResult`	`DayOfWeek(Datum values, DayOfWeekOptions options, ExecContext ctx)` \brief DayOfWeek returns number of the day of the week value for each element of `values`.
`static DatumResult`	`DayOfYear(Datum values)`
`static DatumResult`	`DayOfYear(Datum values, ExecContext ctx)` \brief DayOfYear returns number of day of the year for each element of `values`.
`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 Decimal256Type is returned, otherwise a Decimal128Type.
`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 ExpressionResult`	`Deserialize(ArrowBuffer arg0)`
`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 ArrayResult`	`DropNull(Array values)`
`static ArrayResult`	`DropNull(Array values, ExecContext ctx)` \brief DropNull with Array inputs and output
`static DatumResult`	`DropNull(Datum values)`
`static DatumResult`	`DropNull(Datum values, ExecContext ctx)` \brief Drop Null from an array of values The output array will be of the same type as the input values array, with elements taken from the values array without nulls.
`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 Expression`	`equal(Expression lhs, Expression rhs)`
`static boolean`	`equals(BasicDecimal128 left, BasicDecimal128 right)`
`static boolean`	`equals(BasicDecimal256 left, BasicDecimal256 right)`
`static boolean`	`equals(ExecBatch l, ExecBatch r)`
`static boolean`	`equals(Expression l, Expression r)` \brief See VectorKernel::finalize member for usage
`static DatumResult`	`ExecuteScalarExpression(Expression arg0, ExecBatch input)`
`static DatumResult`	`ExecuteScalarExpression(Expression arg0, ExecBatch input, ExecContext arg2)` Execute a scalar expression against the provided state and input ExecBatch.
`static DatumResult`	`ExecuteScalarExpression(Expression arg0, Schema full_schema, Datum partial_input)`
`static DatumResult`	`ExecuteScalarExpression(Expression arg0, Schema full_schema, Datum partial_input, ExecContext arg3)` Convenience function for invoking against a RecordBatch
`static boolean`	`ExpressionHasFieldRefs(Expression arg0)` Check if the expression references any fields.
`static Expression`	`field_ref(FieldRef ref)`
`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 FieldRef`	`FieldsInExpression(Expression arg0)` Assemble a list of all fields referenced by an Expression at any depth.
`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`	`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 TypeMatcher`	`FixedSizeBinaryLike()`
`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 DataTypeVector`	`FloatingPointTypes()`
`static DatumResult`	`Floor(Datum arg)`
`static DatumResult`	`Floor(Datum arg, ExecContext ctx)` \brief Round to the nearest integer less than or equal in magnitude to the argument.
`static ExpressionResult`	`FoldConstants(Expression arg0)` Simplify Expressions based on literal arguments (for example, add(null, x) will always be null so replace the call with a null literal).
`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 int`	`GetIOThreadPoolCapacity()` \brief Get the capacity of the global I/O thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various I/O-bound tasks.
`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 Expression`	`greater_equal(Expression lhs, Expression rhs)`
`static Expression`	`greater(Expression lhs, Expression rhs)`
`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, boolean use_threads, ExecContext ctx)` Internal use only: helper function for testing HashAggregateKernels.
`static boolean`	`HasValidityBitmap(int id)`
`static Status`	`HaveLibHdfs()`
`static DatumResult`	`Hour(Datum values)`
`static DatumResult`	`Hour(Datum values, ExecContext ctx)` \brief Hour returns hour value for each element of `values`
`static DatumResult`	`IfElse(Datum cond, Datum left, Datum right)`
`static DatumResult`	`IfElse(Datum cond, Datum left, Datum right, ExecContext ctx)` \brief IfElse returns elements chosen from `left` or `right` depending on `cond`.
`static DatumResult`	`Index(Datum value, IndexOptions options)`
`static DatumResult`	`Index(Datum value, IndexOptions options, ExecContext ctx)` \brief Find the first index of a value in an array.
`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 DataTypeVector`	`IntervalTypes()`
`static DataTypeVector`	`IntTypes()`
`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_decimal(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 Expression`	`is_null(Expression lhs)`
`static Expression`	`is_null(Expression lhs, boolean nan_is_null)`
`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_union(int type_id)`
`static boolean`	`is_unsigned_integer(int type_id)`
`static Expression`	`is_valid(Expression lhs)`
`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, NullOptions options, ExecContext ctx)` \brief IsNull returns true for each element of `values` that is null, false otherwise
`static DatumResult`	`ISOCalendar(Datum values)`
`static DatumResult`	`ISOCalendar(Datum values, ExecContext ctx)` \brief ISOCalendar returns a (ISO year, ISO week, ISO day of week) struct for each element of `values`.
`static DatumResult`	`ISOWeek(Datum values)`
`static DatumResult`	`ISOWeek(Datum values, ExecContext ctx)` \brief ISOWeek returns ISO week of year number for each element of `values`.
`static DatumResult`	`ISOYear(Datum values)`
`static DatumResult`	`ISOYear(Datum values, ExecContext ctx)` \brief ISOYear returns ISO year number for each element of `values`.
`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()`
`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 byte`	`kNonNullFiller()` \brief Create a word with low `n` bits from `low` and high `sizeof(Word)-n` bits from `high`.
`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()` \defgroup numeric-arrays Concrete classes for numeric arrays \{ \}
`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 Expression`	`less_equal(Expression lhs, Expression rhs)`
`static Expression`	`less(Expression lhs, Expression rhs)`
`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 Expression`	`literal(Datum lit)`
`static DatumResult`	`Ln(Datum arg)`
`static DatumResult`	`Ln(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Get the natural log of a value.
`static DatumResult`	`Log10(Datum arg)`
`static DatumResult`	`Log10(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Get the log base 10 of a value.
`static DatumResult`	`Log1p(Datum arg)`
`static DatumResult`	`Log1p(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Get the natural log of (1 + value).
`static DatumResult`	`Log2(Datum arg)`
`static DatumResult`	`Log2(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Get the log base 2 of a value.
`static int`	`Log2(long x)`
`static DatumResult`	`Logb(Datum arg, Datum base)`
`static DatumResult`	`Logb(Datum arg, Datum base, ArithmeticOptions options, ExecContext ctx)` \brief Get the log of a value to the given base.
`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`	`MakeBuilderExactIndex(MemoryPool pool, DataType type, ArrayBuilder out)` \brief Construct an empty ArrayBuilder corresponding to the data type, where any top-level or nested dictionary builders return the exact index type specified by the 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 ExecBatchResult`	`MakeExecBatch(Schema full_schema, Datum partial)` Create an ExecBatch suitable for passing to ExecuteScalarExpression() from a /** RecordBatch which may have missing or incorrectly ordered columns.
`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 IntResult`	`MaxDecimalDigitsForInteger(int type_id)` For an integer type, return the max number of decimal digits (=minimal decimal precision) it can represent.
`static DatumResult`	`MaxElementWise(DatumVector args)`
`static DatumResult`	`MaxElementWise(DatumVector args, ElementWiseAggregateOptions options, ExecContext ctx)` \brief Find the element-wise maximum of any number of arrays or scalars.
`static DatumResult`	`Mean(Datum value)`
`static DatumResult`	`Mean(Datum value, ScalarAggregateOptions options, ExecContext ctx)` \brief Compute the mean of a numeric array.
`static DatumResult`	`Microsecond(Datum values)`
`static DatumResult`	`Microsecond(Datum values, ExecContext ctx)` \brief Microsecond returns number of microseconds since the last full millisecond for each element of `values`
`static DatumResult`	`Millisecond(Datum values)`
`static DatumResult`	`Millisecond(Datum values, ExecContext ctx)` \brief Millisecond returns number of milliseconds since the last full second for each element of `values`
`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 DatumResult`	`MinElementWise(DatumVector args)`
`static DatumResult`	`MinElementWise(DatumVector args, ElementWiseAggregateOptions options, ExecContext ctx)` \brief Find the element-wise minimum of any number of arrays or scalars.
`static DatumResult`	`Minute(Datum values)`
`static DatumResult`	`Minute(Datum values, ExecContext ctx)` \brief Minute returns minutes value for each element of `values`
`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_day_nano_interval()` \brief Return a MonthDayNanoIntervalType instance
`static DataType`	`month_interval()` \brief Return a MonthIntervalType instance
`static DatumResult`	`Month(Datum values)`
`static DatumResult`	`Month(Datum values, ExecContext ctx)` \brief Month returns month for each element of `values`.
`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 DatumResult`	`Nanosecond(Datum values)`
`static DatumResult`	`Nanosecond(Datum values, ExecContext ctx)` \brief Nanosecond returns number of nanoseconds since the last full millisecond for each element of `values`
`static DatumResult`	`Negate(Datum arg)`
`static DatumResult`	`Negate(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Negate 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 Expression`	`not_(Expression operand)`
`static Expression`	`not_equal(Expression lhs, Expression rhs)`
`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 boolean`	`notEquals(ExecBatch l, ExecBatch r)`
`static boolean`	`notEquals(Expression l, Expression r)`
`static ArrayResult`	`NthToIndices(Array values, long n)`
`static ArrayResult`	`NthToIndices(Array values, long n, ExecContext ctx)` \brief Return indices that partition an array around n-th sorted element.
`static ArrayResult`	`NthToIndices(Array values, PartitionNthOptions options)`
`static ArrayResult`	`NthToIndices(Array values, PartitionNthOptions options, ExecContext ctx)` \brief Return indices that partition an array around n-th sorted element.
`static DataTypeVector`	`NumericTypes()`
`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 Expression`	`or_(Expression arg0)`
`static Expression`	`or_(Expression lhs, Expression rhs)`
`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 DataTypeVector`	`PrimitiveTypes()`
`static void`	`PrintTo(FunctionOptions arg0, Pointer arg1)` \}
`static DatumResult`	`Product(Datum value)`
`static DatumResult`	`Product(Datum value, ScalarAggregateOptions options, ExecContext ctx)` \brief Compute the product of values of a numeric array.
`static Expression`	`project(Expression values, StringVector names)`
`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 DatumResult`	`Quarter(Datum values)`
`static DatumResult`	`Quarter(Datum values, ExecContext ctx)` \brief Quarter returns the quarter of year number for each element of `values` First quarter maps to 1 and fourth quarter maps to 4.
`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 MessageFuture`	`ReadMessageAsync(long offset, int metadata_length, long body_length, RandomAccessFile file)`
`static MessageFuture`	`ReadMessageAsync(long offset, int metadata_length, long body_length, RandomAccessFile file, IOContext context)`
`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 DatumResult`	`ReplaceWithMask(Datum values, Datum mask, Datum replacements)`
`static DatumResult`	`ReplaceWithMask(Datum values, Datum mask, Datum replacements, ExecContext ctx)` \brief ReplaceWithMask replaces each value in the array corresponding to a true value in the mask with the next element from `replacements`.
`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 DatumResult`	`Round(Datum arg)`
`static DatumResult`	`Round(Datum arg, RoundOptions options, ExecContext ctx)` \brief Round a value to a given precision.
`static long`	`RoundDown(long value, long factor)`
`static DatumResult`	`RoundToMultiple(Datum arg)`
`static DatumResult`	`RoundToMultiple(Datum arg, RoundToMultipleOptions options, ExecContext ctx)` \brief Round a value to a given multiple.
`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 DatumResult`	`Second(Datum values)`
`static DatumResult`	`Second(Datum values, ExecContext ctx)` \brief Second returns seconds value for each element of `values`
`static ArrayResult`	`SelectKUnstable(Datum datum, SelectKOptions options)`
`static ArrayResult`	`SelectKUnstable(Datum datum, SelectKOptions options, ExecContext ctx)` \brief Return indices that would select the first `k` elements.
`static BufferResult`	`Serialize(Expression arg0)`
`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`	`SetBitmap(byte[] data, long offset, long length)`
`static void`	`SetBitmap(ByteBuffer data, long offset, long length)`
`static void`	`SetBitmap(BytePointer data, long offset, long length)` \brief Sets all bits in the bitmap to true
`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 Status`	`SetIOThreadPoolCapacity(int threads)` \brief Set the capacity of the global I/O thread pool Set the number of worker threads in the thread pool to which Arrow dispatches various I/O-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 DatumResult`	`ShiftLeft(Datum left, Datum right)`
`static DatumResult`	`ShiftLeft(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Left shift the left array by the right array.
`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 If the generator is empty, return the given value, else forward the values from the generator.
`static Pointer`	`shiftLeft(Pointer os, DayTimeIntervalType.DayMilliseconds interval)`
`static Pointer`	`shiftLeft(Pointer os, FileInfo arg1)`
`static Pointer`	`shiftLeft(Pointer os, int unit)`
`static Pointer`	`shiftLeft(Pointer os, MonthDayNanoIntervalType.MonthDayNanos interval)`
`static Pointer`	`shiftLeft(Pointer os, TimeUnit.type unit)`
`static DatumResult`	`ShiftRight(Datum left, Datum right)`
`static DatumResult`	`ShiftRight(Datum left, Datum right, ArithmeticOptions options, ExecContext ctx)` \brief Right shift the left array by the right array.
`static DatumResult`	`Sign(Datum arg)`
`static DatumResult`	`Sign(Datum arg, ExecContext ctx)` \brief Get the sign of a value.
`static DataTypeVector`	`SignedIntTypes()`
`static ExpressionResult`	`SimplifyWithGuarantee(Expression arg0, Expression guaranteed_true_predicate)` Simplify an expression by replacing subexpressions based on a guarantee: a boolean expression which is guaranteed to evaluate to `true`.
`static DatumResult`	`Sin(Datum arg)`
`static DatumResult`	`Sin(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Compute the sine of the array values.
`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, ArraySortOptions options)`
`static ArrayResult`	`SortIndices(Array array, ArraySortOptions options, ExecContext ctx)` \brief Return the indices that would sort an array.
`static ArrayResult`	`SortIndices(Array array, arrow.SortOrder order, ExecContext ctx)` \brief Return the indices that would sort an array.
`static ArrayResult`	`SortIndices(Array array, int order, ExecContext ctx)`
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array)`
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array, ArraySortOptions options)`
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array, ArraySortOptions options, ExecContext ctx)` \brief Return the indices that would sort a chunked array.
`static ArrayResult`	`SortIndices(ChunkedArray chunked_array, arrow.SortOrder order, ExecContext ctx)` \brief Return the indices that would sort a chunked array.
`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 Return 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 DatumResult`	`Strftime(Datum values, StrftimeOptions options)`
`static DatumResult`	`Strftime(Datum values, StrftimeOptions options, ExecContext ctx)` \brief Format timestamps according to a format string Return formatted time strings according to the format string `StrftimeOptions::format` and to the locale specifier `Strftime::locale`.
`static DataTypeVector`	`StringTypes()`
`static DataType`	`struct_(FieldVector fields)` \brief Create a StructType instance
`static DatumResult`	`Subsecond(Datum values)`
`static DatumResult`	`Subsecond(Datum values, ExecContext ctx)` \brief Subsecond returns the fraction of second elapsed since last full second as a float for each element of `values`
`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, ScalarAggregateOptions options, 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 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 DatumResult`	`Tan(Datum arg)`
`static DatumResult`	`Tan(Datum arg, ArithmeticOptions options, ExecContext ctx)` \brief Compute the tangent of the array values.
`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 DataTypeVector`	`TemporalTypes()`
`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 Future`	`ToFuture(Status status)` \brief Loop through an asynchronous sequence
`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 DatumResult`	`Trunc(Datum arg)`
`static DatumResult`	`Trunc(Datum arg, ExecContext ctx)` \brief Get the integral part without fractional digits.
`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 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 DataTypeVector`	`UnsignedIntTypes()`
`static DatumResult`	`USWeek(Datum values)`
`static DatumResult`	`USWeek(Datum values, ExecContext ctx)` \brief USWeek returns US week of year number for each element of `values`.
`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 DatumResult`	`Week(Datum values)`
`static DatumResult`	`Week(Datum values, WeekOptions options, ExecContext ctx)` \brief Week returns week of year number for each element of `values`.
`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
`static DatumResult`	`Year(Datum values)`
`static DatumResult`	`Year(Datum values, ExecContext ctx)` \brief Year returns year for each element of `values`

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="const 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="const 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="const 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="const 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)

SetBitmap

@Namespace(value="arrow::BitUtil")
public static void SetBitmap(@Cast(value="uint8_t*")
                                                                 BytePointer data,
                                                                 @Cast(value="int64_t")
                                                                 long offset,
                                                                 @Cast(value="int64_t")
                                                                 long length)

\brief Sets all bits in the bitmap to true

SetBitmap

@Namespace(value="arrow::BitUtil")
public static void SetBitmap(@Cast(value="uint8_t*")
                                                                 ByteBuffer data,
                                                                 @Cast(value="int64_t")
                                                                 long offset,
                                                                 @Cast(value="int64_t")
                                                                 long length)

SetBitmap

@Namespace(value="arrow::BitUtil")
public static void SetBitmap(@Cast(value="uint8_t*")
                                                                 byte[] data,
                                                                 @Cast(value="int64_t")
                                                                 long offset,
                                                                 @Cast(value="int64_t")
                                                                 long length)

ClearBitmap

@Namespace(value="arrow::BitUtil")
public static void ClearBitmap(@Cast(value="uint8_t*")
                                                                   BytePointer data,
                                                                   @Cast(value="int64_t")
                                                                   long offset,
                                                                   @Cast(value="int64_t")
                                                                   long length)

\brief Clears all bits in the bitmap (set to false)

ClearBitmap

@Namespace(value="arrow::BitUtil")
public static void ClearBitmap(@Cast(value="uint8_t*")
                                                                   ByteBuffer data,
                                                                   @Cast(value="int64_t")
                                                                   long offset,
                                                                   @Cast(value="int64_t")
                                                                   long length)

ClearBitmap

@Namespace(value="arrow::BitUtil")
public static void ClearBitmap(@Cast(value="uint8_t*")
                                                                   byte[] data,
                                                                   @Cast(value="int64_t")
                                                                   long offset,
                                                                   @Cast(value="int64_t")
                                                                   long length)

kNonNullFiller
```
@Namespace(value="arrow::util::internal")
 @MemberGetter
 @Cast(value="const uint8_t")
public static byte kNonNullFiller()
```
\brief Create a word with low n bits from low and high sizeof(Word)-n bits from high. Word ret for (i = 0; i < sizeof(Word)*8; i++){ ret[i]= i < n ? low[i]: high[i]; }

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")
 @Const
 @ByRef
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 Decimal256Type is returned, otherwise a Decimal128Type.

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

month_day_nano_interval

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

\brief Return a MonthDayNanoIntervalType 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)

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

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)

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_decimal

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

is_union

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

MaxDecimalDigitsForInteger

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

For an integer type, return the max number of decimal digits (=minimal decimal precision) it can represent.

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.

AllFinished
```
@Namespace(value="arrow")
 @ByVal
public static Future AllFinished(@StdVector
                                                                     Future futures)
```
\brief Create a Future which completes when all of futures complete. The future will finish with an ok status if all futures finish with an ok status. Otherwise, it will be marked failed with the status of one of the failing futures. Unlike AllComplete this Future will not complete immediately when a failure occurs. It will wait until all futures have finished.

ToFuture
```
@Namespace(value="arrow")
 @ByVal
public static Future ToFuture(@ByVal
                                                                  Status status)
```
\brief Loop through an asynchronous sequence

Parameters:

iterate - [in] A generator of Future>. On completion of each yielded future the resulting ControlFlow will be examined. A Break will terminate the loop, while a Continue will re-invoke iterate.

Returns:

A future which will complete when a Future returned by iterate completes with a Break

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 If the generator is empty, return the given value, else forward the values from the generator. This generator is async-reentrant.

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)

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @ByVal
                                                                                                                                DayTimeIntervalType.DayMilliseconds interval)

shiftLeft

@Namespace(value="arrow")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @ByVal
                                                                                                                                MonthDayNanoIntervalType.MonthDayNanos interval)

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)

SignedIntTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector SignedIntTypes()

UnsignedIntTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector UnsignedIntTypes()

IntTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector IntTypes()

FloatingPointTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector FloatingPointTypes()

NumericTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector NumericTypes()

BaseBinaryTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector BaseBinaryTypes()

StringTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector StringTypes()

TemporalTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector TemporalTypes()

IntervalTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector IntervalTypes()

PrimitiveTypes

@Namespace(value="arrow")
 @Const
 @ByRef
public static DataTypeVector PrimitiveTypes()

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()
```
\defgroup numeric-arrays Concrete classes for numeric arrays \{ \}
\defgroup binary-arrays Concrete classes for binary/string arrays \{ \}
\defgroup nested-arrays Concrete classes for nested arrays \{ \}

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)

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

MakeBuilderExactIndex

@Namespace(value="arrow")
 @ByVal
public static Status MakeBuilderExactIndex(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, where any top-level or nested dictionary builders return the exact index type specified by the type.

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

GetIOThreadPoolCapacity
```
@Namespace(value="arrow::io")
public static int GetIOThreadPoolCapacity()
```
\brief Get the capacity of the global I/O thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various I/O-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 SetIOThreadPoolCapacity().

SetIOThreadPoolCapacity
```
@Namespace(value="arrow::io")
 @ByVal
public static Status SetIOThreadPoolCapacity(int threads)
```
\brief Set the capacity of the global I/O thread pool Set the number of worker threads in the thread pool to which Arrow dispatches various I/O-bound tasks. The current number is returned by GetIOThreadPoolCapacity().

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

CountRowsAsync

@Namespace(value="arrow::csv")
 @ByVal
public static LongFuture CountRowsAsync(@ByVal
                                                                                 IOContext io_context,
                                                                                 @SharedPtr @Cast(value={"","std::shared_ptr<arrow::io::InputStream>"})
                                                                                 InputStream input,
                                                                                 Executor cpu_executor,
                                                                                 @Const @ByRef
                                                                                 ReadOptions arg3,
                                                                                 @Const @ByRef
                                                                                 CsvParseOptions arg4)

\brief Count the logical rows of data in a CSV file (i.e. the number of rows you would get if you read the file into a table).

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

\brief Count 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,
                                                                            @Const @ByRef(nullValue="arrow::compute::ScalarAggregateOptions::Defaults()")
                                                                            ScalarAggregateOptions options,
                                                                            ExecContext ctx)

\brief Compute the mean of a numeric array.

Parameters:: value - [in] datum to compute the mean, expecting Array; options - [in] see ScalarAggregateOptions for more information; 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)

Product

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

\brief Compute the product of values of a numeric array.

Parameters:: value - [in] datum to compute product of, expecting Array or ChunkedArray; options - [in] see ScalarAggregateOptions for more information; ctx - [in] the function execution context, optional
Returns:: datum of the computed sum as a Scalar
Since:: 6.0.0 \note API not yet finalized

Product

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

Sum

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

\brief Sum values of a numeric array.

Parameters:: value - [in] datum to sum, expecting Array or ChunkedArray; options - [in] see ScalarAggregateOptions for more information; 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,
                                                                           @Const @ByRef(nullValue="arrow::compute::ScalarAggregateOptions::Defaults()")
                                                                           ScalarAggregateOptions options,
                                                                           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 ignored by default. If null values are taken into account by setting ScalarAggregateOptions parameter skip_nulls = false then Kleene logic is used. See KleeneOr for more details on Kleene logic.

Parameters:: value - [in] input datum, expecting a boolean array; options - [in] see ScalarAggregateOptions for more information; 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,
                                                                           @Const @ByRef(nullValue="arrow::compute::ScalarAggregateOptions::Defaults()")
                                                                           ScalarAggregateOptions options,
                                                                           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 ignored by default. If null values are taken into account by setting ScalarAggregateOptions parameter skip_nulls = false then Kleene logic is used. See KleeneAnd for more details on Kleene logic.

Parameters:: value - [in] input datum, expecting a boolean array; options - [in] see ScalarAggregateOptions for more information; 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)

Index

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

\brief Find the first index of a value in an array.

Parameters:: value - [in] The array to search.; options - [in] The array to search for. See IndexOoptions.; ctx - [in] the function execution context, optional
Returns:: out a Scalar containing the index (or -1 if not found).
Since:: 5.0.0 \note API not yet finalized

Index

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

GroupBy

@Namespace(value="arrow::compute::internal")
 @ByVal
public static DatumResult GroupBy(@Const @ByRef
                                                                                         DatumVector arguments,
                                                                                         @Const @ByRef
                                                                                         DatumVector keys,
                                                                                         @StdVector
                                                                                         Aggregate aggregates,
                                                                                         @Cast(value="bool")
                                                                                         boolean use_threads,
                                                                                         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)

AbsoluteValue

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

\brief Get the absolute value of a value. If argument is null the result will be null.

Parameters:: arg - [in] the value transformed; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise absolute value

AbsoluteValue

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

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)

Negate

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

\brief Negate values. If argument is null the result will be null.

Parameters:: arg - [in] the value negated; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise negation

Negate

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

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)

ShiftLeft

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

\brief Left shift the left array by the right array. Array values must be the same length. If either operand is null, the result will be null.

Parameters:: left - [in] the value to shift; right - [in] the value to shift by; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise left value shifted left by the right value

ShiftLeft

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

ShiftRight

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

\brief Right shift the left array by the right array. Array values must be the same length. If either operand is null, the result will be null. Performs a logical shift for unsigned values, and an arithmetic shift for signed values.

Parameters:: left - [in] the value to shift; right - [in] the value to shift by; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise left value shifted right by the right value

ShiftRight

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

Sin

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

\brief Compute the sine of the array values.

Parameters:: arg - [in] The values to compute the sine for.; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise sine of the values

Sin

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

Cos

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

\brief Compute the cosine of the array values.

Parameters:: arg - [in] The values to compute the cosine for.; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise cosine of the values

Cos

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

Asin

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

\brief Compute the inverse sine (arcsine) of the array values.

Parameters:: arg - [in] The values to compute the inverse sine for.; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise inverse sine of the values

Asin

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

Acos

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

\brief Compute the inverse cosine (arccosine) of the array values.

Parameters:: arg - [in] The values to compute the inverse cosine for.; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise inverse cosine of the values

Acos

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

Tan

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

\brief Compute the tangent of the array values.

Parameters:: arg - [in] The values to compute the tangent for.; options - [in] arithmetic options (enable/disable overflow checking), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise tangent of the values

Tan

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

Atan

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

\brief Compute the inverse tangent (arctangent) of the array values.

Parameters:: arg - [in] The values to compute the inverse tangent for.; ctx - [in] the function execution context, optional
Returns:: the elementwise inverse tangent of the values

Atan

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

Atan2

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

\brief Compute the inverse tangent (arctangent) of y/x, using the argument signs to determine the correct quadrant.

Parameters:: y - [in] The y-values to compute the inverse tangent for.; x - [in] The x-values to compute the inverse tangent for.; ctx - [in] the function execution context, optional
Returns:: the elementwise inverse tangent of the values

Atan2

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Atan2(@Const @ByRef
                                                                             Datum y,
                                                                             @Const @ByRef
                                                                             Datum x)

Ln

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

\brief Get the natural log of a value. If argument is null the result will be null.

Parameters:: arg - [in] The values to compute the logarithm for.; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise natural log

Ln

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

Log10

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

\brief Get the log base 10 of a value. If argument is null the result will be null.

Parameters:: arg - [in] The values to compute the logarithm for.; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise log base 10

Log10

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

Log2

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

\brief Get the log base 2 of a value. If argument is null the result will be null.

Parameters:: arg - [in] The values to compute the logarithm for.; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise log base 2

Log2

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

Log1p

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

\brief Get the natural log of (1 + value). If argument is null the result will be null. This function may be more accurate than Log(1 + value) for values close to zero.

Parameters:: arg - [in] The values to compute the logarithm for.; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise natural log

Log1p

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

Logb

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Logb(@Const @ByRef
                                                                            Datum arg,
                                                                            @Const @ByRef
                                                                            Datum base,
                                                                            @ByVal(nullValue="arrow::compute::ArithmeticOptions()")
                                                                            ArithmeticOptions options,
                                                                            ExecContext ctx)

\brief Get the log of a value to the given base. If argument is null the result will be null.

Parameters:: arg - [in] The values to compute the logarithm for.; base - [in] The given base.; options - [in] arithmetic options (overflow handling), optional; ctx - [in] the function execution context, optional
Returns:: the elementwise log to the given base

Logb

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult Logb(@Const @ByRef
                                                                            Datum arg,
                                                                            @Const @ByRef
                                                                            Datum base)

Floor

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

\brief Round to the nearest integer less than or equal in magnitude to the argument. If argument is null the result will be null.

Parameters:: arg - [in] the value to round; ctx - [in] the function execution context, optional
Returns:: the rounded value

Floor

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

Ceil

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

\brief Round to the nearest integer greater than or equal in magnitude to the argument. If argument is null the result will be null.

Parameters:: arg - [in] the value to round; ctx - [in] the function execution context, optional
Returns:: the rounded value

Ceil

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

Trunc

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

\brief Get the integral part without fractional digits. If argument is null the result will be null.

Parameters:: arg - [in] the value to truncate; ctx - [in] the function execution context, optional
Returns:: the truncated value

Trunc

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

MaxElementWise

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult MaxElementWise(@Const @ByRef
                                                                                      DatumVector args,
                                                                                      @ByVal(nullValue="arrow::compute::ElementWiseAggregateOptions::Defaults()")
                                                                                      ElementWiseAggregateOptions options,
                                                                                      ExecContext ctx)

\brief Find the element-wise maximum of any number of arrays or scalars. Array values must be the same length.

Parameters:: args - [in] arrays or scalars to operate on.; options - [in] options for handling nulls, optional; ctx - [in] the function execution context, optional
Returns:: the element-wise maximum

MaxElementWise

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult MaxElementWise(@Const @ByRef
                                                                                      DatumVector args)

MinElementWise

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult MinElementWise(@Const @ByRef
                                                                                      DatumVector args,
                                                                                      @ByVal(nullValue="arrow::compute::ElementWiseAggregateOptions::Defaults()")
                                                                                      ElementWiseAggregateOptions options,
                                                                                      ExecContext ctx)

\brief Find the element-wise minimum of any number of arrays or scalars. Array values must be the same length.

Parameters:: args - [in] arrays or scalars to operate on.; options - [in] options for handling nulls, optional; ctx - [in] the function execution context, optional
Returns:: the element-wise minimum

MinElementWise

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult MinElementWise(@Const @ByRef
                                                                                      DatumVector args)

Sign

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

\brief Get the sign of a value. Array values can be of arbitrary length. If argument is null the result will be null.

Parameters:: arg - [in] the value to extract sign from; ctx - [in] the function execution context, optional
Returns:: the element-wise sign function

Sign

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

Round

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

\brief Round a value to a given precision. If argument is null the result will be null.

Parameters:: arg - [in] the value rounded; options - [in] rounding options (rounding mode and number of digits), optional; ctx - [in] the function execution context, optional
Returns:: the element-wise rounded value

Round

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

RoundToMultiple

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

\brief Round a value to a given multiple. If argument is null the result will be null.

Parameters:: arg - [in] the value to round; options - [in] rounding options (rounding mode and multiple), optional; ctx - [in] the function execution context, optional
Returns:: the element-wise rounded value

RoundToMultiple

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

Compare

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

Deprecated.

\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")
 @Deprecated
 @ByVal
public static DatumResult Compare(@Const @ByRef
                                                                                             Datum left,
                                                                                             @Const @ByRef
                                                                                             Datum right,
                                                                                             @ByVal
                                                                                             CompareOptions options)

Deprecated.

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 = [2, 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,
                                                                              @ByVal(nullValue="arrow::compute::NullOptions::Defaults()")
                                                                              NullOptions options,
                                                                              ExecContext ctx)

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

Parameters:: values - [in] input to examine for nullity; options - [in] NullOptions; 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)

IfElse

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

\brief IfElse returns elements chosen from left or right depending on cond. null values in cond will be promoted to the result

Parameters:: cond - [in] Boolean condition Scalar/ Array; left - [in] Scalar/ Array; right - [in] Scalar/ Array; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

IfElse

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

CaseWhen

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

\brief CaseWhen behaves like a switch/case or if-else if-else statement: for each row, select the first value for which the corresponding condition is true, or (if given) select the 'else' value, else emit null. Note that a null condition is the same as false.

Parameters:: cond - [in] Conditions (Boolean); cases - [in] Values (any type), along with an optional 'else' value.; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

CaseWhen

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult CaseWhen(@Const @ByRef
                                                                                Datum cond,
                                                                                @Const @ByRef
                                                                                DatumVector cases)

Year

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

\brief Year returns year for each element of values

Parameters:: values - [in] input to extract year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Year

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

Month

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

\brief Month returns month for each element of values. Month is encoded as January=1, December=12

Parameters:: values - [in] input to extract month from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Month

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

Day

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

\brief Day returns day number for each element of values

Parameters:: values - [in] input to extract day from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Day

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

DayOfWeek

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

\brief DayOfWeek returns number of the day of the week value for each element of values. By default week starts on Monday denoted by 0 and ends on Sunday denoted by 6. Start day of the week (Monday=1, Sunday=7) and numbering base (0 or 1) can be set using DayOfWeekOptions

Parameters:: values - [in] input to extract number of the day of the week from; options - [in] for setting start of the week and day numbering; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

DayOfWeek

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

DayOfYear

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

\brief DayOfYear returns number of day of the year for each element of values. January 1st maps to day number 1, February 1st to 32, etc.

Parameters:: values - [in] input to extract number of day of the year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

DayOfYear

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

ISOYear

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

\brief ISOYear returns ISO year number for each element of values. First week of an ISO year has the majority (4 or more) of its days in January.

Parameters:: values - [in] input to extract ISO year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

ISOYear

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

ISOWeek

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

\brief ISOWeek returns ISO week of year number for each element of values. First ISO week has the majority (4 or more) of its days in January. ISO week starts on Monday. Year can have 52 or 53 weeks. Week numbering can start with 1.

Parameters:: values - [in] input to extract ISO week of year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

ISOWeek

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

USWeek

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

\brief USWeek returns US week of year number for each element of values. First US week has the majority (4 or more) of its days in January. US week starts on Sunday. Year can have 52 or 53 weeks. Week numbering starts with 1.

Parameters:: values - [in] input to extract US week of year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 6.0.0 \note API not yet finalized

USWeek

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

Week

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

\brief Week returns week of year number for each element of values. First ISO week has the majority (4 or more) of its days in January. Year can have 52 or 53 weeks. Week numbering can start with 0 or 1 depending on DayOfWeekOptions.count_from_zero.

Parameters:: values - [in] input to extract week of year from; options - [in] for setting numbering start; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 6.0.0 \note API not yet finalized

Week

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

ISOCalendar

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

\brief ISOCalendar returns a (ISO year, ISO week, ISO day of week) struct for each element of values. ISO week starts on Monday denoted by 1 and ends on Sunday denoted by 7.

Parameters:: values - [in] input to ISO calendar struct from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

ISOCalendar

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

Quarter

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

\brief Quarter returns the quarter of year number for each element of values First quarter maps to 1 and fourth quarter maps to 4.

Parameters:: values - [in] input to extract quarter of year from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Quarter

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

Hour

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

\brief Hour returns hour value for each element of values

Parameters:: values - [in] input to extract hour from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Hour

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

Minute

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

\brief Minute returns minutes value for each element of values

Parameters:: values - [in] input to extract minutes from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Minute

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

Second

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

\brief Second returns seconds value for each element of values

Parameters:: values - [in] input to extract seconds from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Second

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

Millisecond

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

\brief Millisecond returns number of milliseconds since the last full second for each element of values

Parameters:: values - [in] input to extract milliseconds from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Millisecond

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

Microsecond

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

\brief Microsecond returns number of microseconds since the last full millisecond for each element of values

Parameters:: values - [in] input to extract microseconds from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Microsecond

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

Nanosecond

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

\brief Nanosecond returns number of nanoseconds since the last full millisecond for each element of values

Parameters:: values - [in] input to extract nanoseconds from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Nanosecond

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

Subsecond

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

\brief Subsecond returns the fraction of second elapsed since last full second as a float for each element of values

Parameters:: values - [in] input to extract subsecond from; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

Subsecond

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

Strftime

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

\brief Format timestamps according to a format string Return formatted time strings according to the format string StrftimeOptions::format and to the locale specifier Strftime::locale.

Parameters:: values - [in] input timestamps; options - [in] for setting format string and locale; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 6.0.0 \note API not yet finalized

Strftime

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

AssumeTimezone

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

\brief Converts timestamps from local timestamp without a timezone to a timestamp with timezone, interpreting the local timestamp as being in the specified timezone for each element of values

Parameters:: values - [in] input to convert; options - [in] for setting source timezone, exception and ambiguous timestamp handling.; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 6.0.0 \note API not yet finalized

AssumeTimezone

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

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)

ReplaceWithMask

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

\brief ReplaceWithMask replaces each value in the array corresponding to a true value in the mask with the next element from replacements.

Parameters:: values - [in] Array input to replace; mask - [in] Array or Scalar of Boolean mask values; replacements - [in] The replacement values to draw from. There must be as many replacement values as true values in the mask.; ctx - [in] the function execution context, optional
Returns:: the resulting datum
Since:: 5.0.0 \note API not yet finalized

ReplaceWithMask

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult ReplaceWithMask(@Const @ByRef
                                                                                       Datum values,
                                                                                       @Const @ByRef
                                                                                       Datum mask,
                                                                                       @Const @ByRef
                                                                                       Datum replacements)

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)

DropNull

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

\brief Drop Null from an array of values The output array will be of the same type as the input values array, with elements taken from the values array without nulls. For example given values = ["a", "b", "c", null, "e", "f"], the output will be = ["a", "b", "c", "e", "f"]

Parameters:: values - [in] datum from which to take; ctx - [in] the function execution context, optional
Returns:: the resulting datum

DropNull

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

DropNull

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

\brief DropNull with Array inputs and output

DropNull

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

NthToIndices

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

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

NthToIndices

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

\brief Return indices that partition an array around n-th sorted element. This overload takes a PartitionNthOptions specifiying the pivot index and the null handling.

Parameters:: values - [in] array to be partitioned; options - [in] options including pivot index and null handling; 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,
                                                                                    @Const @ByRef
                                                                                    PartitionNthOptions options)

SelectKUnstable

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

\brief Return indices that would select the first k elements. Perform an indirect sort of the datum, keeping only the first k elements. The output array will contain indices such that the item indicated by the k-th index will be in the position it would be if the datum were sorted by options.sort_keys. However, indices of null values will not be part of the output. The sort is not guaranteed to be stable.

Parameters:: datum - [in] datum to be partitioned; options - [in] options; ctx - [in] the function execution context, optional
Returns:: a datum with the same schema as the input

SelectKUnstable

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

SortIndices

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

\brief Return the indices that would sort an array. Perform an indirect sort of array. The output array will contain indices that would sort an array, which would be the same length as input. Nulls will be stably partitioned to the end of the output 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
                                                                                   Array array,
                                                                                   @Const @ByRef
                                                                                   ArraySortOptions options,
                                                                                   ExecContext ctx)

\brief Return the indices that would sort an array. This overload takes a ArraySortOptions specifiying the sort order and the null handling.

Parameters:: array - [in] array to sort; options - [in] options including sort order and null handling; 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,
                                                                                   @Const @ByRef
                                                                                   ArraySortOptions options)

SortIndices

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

\brief Return the indices that would sort a chunked array. 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
                                                                                   ChunkedArray chunked_array,
                                                                                   @Const @ByRef
                                                                                   ArraySortOptions options,
                                                                                   ExecContext ctx)

\brief Return the indices that would sort a chunked array. This overload takes a ArraySortOptions specifiying the sort order and the null handling.

Parameters:: chunked_array - [in] chunked array to sort; options - [in] options including sort order and null handling; 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,
                                                                                   @Const @ByRef
                                                                                   ArraySortOptions options)

SortIndices
```
@Namespace(value="arrow::compute")
 @ByVal
public static ArrayResult SortIndices(@Const @ByRef
                                                                                   Datum datum,
                                                                                   @Const @ByRef
                                                                                   SortOptions options,
                                                                                   ExecContext ctx)
```
\brief Return 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 start or to the end of the output depending on SortOrder::null_placement. 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)

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

FixedSizeBinaryLike

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

Primitive

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

equals

@Namespace(value="arrow::compute")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                                    Expression l,
                                                                                                                    @Const @ByRef
                                                                                                                    Expression r)

\brief See VectorKernel::finalize member for usage

notEquals

@Namespace(value="arrow::compute")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                                       Expression l,
                                                                                                                       @Const @ByRef
                                                                                                                       Expression r)

literal

@Namespace(value="arrow::compute")
 @ByVal
public static Expression literal(@ByVal
                                                                              Datum lit)

field_ref

@Namespace(value="arrow::compute")
 @ByVal
public static Expression field_ref(@ByVal
                                                                                FieldRef ref)

call

@Namespace(value="arrow::compute")
 @ByVal
public static Expression call(@StdString
                                                                           String function,
                                                                           @StdVector
                                                                           Expression arguments,
                                                                           @SharedPtr
                                                                           FunctionOptions options)

call

@Namespace(value="arrow::compute")
 @ByVal
public static Expression call(@StdString
                                                                           String function,
                                                                           @StdVector
                                                                           Expression arguments)

call

@Namespace(value="arrow::compute")
 @ByVal
public static Expression call(@StdString
                                                                           BytePointer function,
                                                                           @StdVector
                                                                           Expression arguments,
                                                                           @SharedPtr
                                                                           FunctionOptions options)

call

@Namespace(value="arrow::compute")
 @ByVal
public static Expression call(@StdString
                                                                           BytePointer function,
                                                                           @StdVector
                                                                           Expression arguments)

FieldsInExpression

@Namespace(value="arrow::compute")
 @StdVector
public static FieldRef FieldsInExpression(@Const @ByRef
                                                                                           Expression arg0)

Assemble a list of all fields referenced by an Expression at any depth.

ExpressionHasFieldRefs

@Namespace(value="arrow::compute")
 @Cast(value="bool")
public static boolean ExpressionHasFieldRefs(@Const @ByRef
                                                                                                       Expression arg0)

Check if the expression references any fields.

Canonicalize
```
@Namespace(value="arrow::compute")
 @ByVal
public static ExpressionResult Canonicalize(@ByVal
                                                                                         Expression arg0,
                                                                                         ExecContext arg1)
```
\defgroup expression-passes Functions for modification of Expressions \{ These transform bound expressions. Some transforms utilize a guarantee, which is provided as an Expression which is guaranteed to evaluate to true. The guaranteed_true_predicate need not be bound, but canonicalization is currently deferred to producers of guarantees. For example in order to be recognized as a guarantee on a field value, an Expression must be a call to "equal" with field_ref LHS and literal RHS. Flipping the arguments, "is_in" with a one-long value_set, ... or other semantically identical Expressions will not be recognized.
Weak canonicalization which establishes guarantees for subsequent passes. Even equivalent Expressions may result in different canonicalized expressions. TODO this could be a strong canonicalization

Canonicalize

@Namespace(value="arrow::compute")
 @ByVal
public static ExpressionResult Canonicalize(@ByVal
                                                                                         Expression arg0)

FoldConstants

@Namespace(value="arrow::compute")
 @ByVal
public static ExpressionResult FoldConstants(@ByVal
                                                                                          Expression arg0)

Simplify Expressions based on literal arguments (for example, add(null, x) will always be null so replace the call with a null literal). Includes early evaluation of all calls whose arguments are entirely literal.

SimplifyWithGuarantee

@Namespace(value="arrow::compute")
 @ByVal
public static ExpressionResult SimplifyWithGuarantee(@ByVal
                                                                                                  Expression arg0,
                                                                                                  @Const @ByRef
                                                                                                  Expression guaranteed_true_predicate)

Simplify an expression by replacing subexpressions based on a guarantee: a boolean expression which is guaranteed to evaluate to true. For example, this is used to remove redundant function calls from a filter expression or to replace a reference to a constant-value field with a literal.

MakeExecBatch

@Namespace(value="arrow::compute")
 @ByVal
public static ExecBatchResult MakeExecBatch(@Const @ByRef
                                                                                         Schema full_schema,
                                                                                         @Const @ByRef
                                                                                         Datum partial)

Create an ExecBatch suitable for passing to ExecuteScalarExpression() from a /** RecordBatch which may have missing or incorrectly ordered columns. /** Missing fields will be replaced with null scalars.

ExecuteScalarExpression

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult ExecuteScalarExpression(@Const @ByRef
                                                                                               Expression arg0,
                                                                                               @Const @ByRef
                                                                                               ExecBatch input,
                                                                                               ExecContext arg2)

Execute a scalar expression against the provided state and input ExecBatch. This expression must be bound.

ExecuteScalarExpression

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult ExecuteScalarExpression(@Const @ByRef
                                                                                               Expression arg0,
                                                                                               @Const @ByRef
                                                                                               ExecBatch input)

ExecuteScalarExpression

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult ExecuteScalarExpression(@Const @ByRef
                                                                                               Expression arg0,
                                                                                               @Const @ByRef
                                                                                               Schema full_schema,
                                                                                               @Const @ByRef
                                                                                               Datum partial_input,
                                                                                               ExecContext arg3)

Convenience function for invoking against a RecordBatch

ExecuteScalarExpression

@Namespace(value="arrow::compute")
 @ByVal
public static DatumResult ExecuteScalarExpression(@Const @ByRef
                                                                                               Expression arg0,
                                                                                               @Const @ByRef
                                                                                               Schema full_schema,
                                                                                               @Const @ByRef
                                                                                               Datum partial_input)

Serialize

@Namespace(value="arrow::compute")
 @ByVal
public static BufferResult Serialize(@Const @ByRef
                                                                                  Expression arg0)

Deserialize

@Namespace(value="arrow::compute")
 @ByVal
public static ExpressionResult Deserialize(@SharedPtr
                                                                                        ArrowBuffer arg0)

project

@Namespace(value="arrow::compute")
 @ByVal
public static Expression project(@StdVector
                                                                              Expression values,
                                                                              @ByVal
                                                                              StringVector names)

equal

@Namespace(value="arrow::compute")
 @ByVal
public static Expression equal(@ByVal
                                                                            Expression lhs,
                                                                            @ByVal
                                                                            Expression rhs)

not_equal

@Namespace(value="arrow::compute")
 @ByVal
public static Expression not_equal(@ByVal
                                                                                Expression lhs,
                                                                                @ByVal
                                                                                Expression rhs)

less

@Namespace(value="arrow::compute")
 @ByVal
public static Expression less(@ByVal
                                                                           Expression lhs,
                                                                           @ByVal
                                                                           Expression rhs)

less_equal

@Namespace(value="arrow::compute")
 @ByVal
public static Expression less_equal(@ByVal
                                                                                 Expression lhs,
                                                                                 @ByVal
                                                                                 Expression rhs)

greater

@Namespace(value="arrow::compute")
 @ByVal
public static Expression greater(@ByVal
                                                                              Expression lhs,
                                                                              @ByVal
                                                                              Expression rhs)

greater_equal

@Namespace(value="arrow::compute")
 @ByVal
public static Expression greater_equal(@ByVal
                                                                                    Expression lhs,
                                                                                    @ByVal
                                                                                    Expression rhs)

is_null

@Namespace(value="arrow::compute")
 @ByVal
public static Expression is_null(@ByVal
                                                                              Expression lhs,
                                                                              @Cast(value="bool")
                                                                              boolean nan_is_null)

is_null

@Namespace(value="arrow::compute")
 @ByVal
public static Expression is_null(@ByVal
                                                                              Expression lhs)

is_valid

@Namespace(value="arrow::compute")
 @ByVal
public static Expression is_valid(@ByVal
                                                                               Expression lhs)

and_

@Namespace(value="arrow::compute")
 @ByVal
public static Expression and_(@ByVal
                                                                           Expression lhs,
                                                                           @ByVal
                                                                           Expression rhs)

and_

@Namespace(value="arrow::compute")
 @ByVal
public static Expression and_(@StdVector
                                                                           Expression arg0)

or_

@Namespace(value="arrow::compute")
 @ByVal
public static Expression or_(@ByVal
                                                                          Expression lhs,
                                                                          @ByVal
                                                                          Expression rhs)

or_

@Namespace(value="arrow::compute")
 @ByVal
public static Expression or_(@StdVector
                                                                          Expression arg0)

not_

@Namespace(value="arrow::compute")
 @ByVal
public static Expression not_(@ByVal
                                                                           Expression operand)

kDefaultExecChunksize

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

default_exec_context

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

equals

@Namespace(value="arrow::compute")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                                    ExecBatch l,
                                                                                                                    @Const @ByRef
                                                                                                                    ExecBatch r)

notEquals

@Namespace(value="arrow::compute")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                                       ExecBatch l,
                                                                                                                       @Const @ByRef
                                                                                                                       ExecBatch r)

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)

PrintTo

@Namespace(value="arrow::compute")
public static void PrintTo(@Const @ByRef
                                                               FunctionOptions arg0,
                                                               @Cast(value="std::ostream*")
                                                               Pointer arg1)

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

ReadMessageAsync

@Namespace(value="arrow::ipc")
 @ByVal
public static MessageFuture ReadMessageAsync(@Cast(value="const int64_t")
                                                                                      long offset,
                                                                                      int metadata_length,
                                                                                      @Cast(value="const int64_t")
                                                                                      long body_length,
                                                                                      RandomAccessFile file,
                                                                                      @Const @ByRef(nullValue="arrow::io::IOContext(arrow::io::default_io_context())")
                                                                                      IOContext context)

ReadMessageAsync

@Namespace(value="arrow::ipc")
 @ByVal
public static MessageFuture ReadMessageAsync(@Cast(value="const int64_t")
                                                                                      long offset,
                                                                                      int metadata_length,
                                                                                      @Cast(value="const int64_t")
                                                                                      long body_length,
                                                                                      RandomAccessFile file)

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