Compute Functions¶

Datum class¶

class arrow::Datum¶

Variant type for various Arrow C++ data structures.

Public Functions

Datum() = default¶: Empty datum, to be populated elsewhere.

inline bool is_value() const¶: True if Datum contains a scalar or array-like data.

ValueDescr descr() const¶

Return the shape (array or scalar) and type for supported kinds (ARRAY, CHUNKED_ARRAY, and SCALAR).

Debug asserts otherwise

ValueDescr::Shape shape() const¶

Return the shape (array or scalar) for supported kinds (ARRAY, CHUNKED_ARRAY, and SCALAR).

Debug asserts otherwise

std::shared_ptr<DataType> type() const¶

The value type of the variant, if any.

Returns: nullptr if no type

std::shared_ptr<Schema> schema() const¶

The schema of the variant, if any.

Returns: nullptr if no schema

int64_t length() const¶

The value length of the variant, if any.

Returns: kUnknownLength if no type

ArrayVector chunks() const¶

The array chunks of the variant, if any.

Returns: empty if not arraylike

struct Empty¶

Abstract Function classes¶

void PrintTo(const FunctionOptions&, std::ostream*)¶

class FunctionOptionsType¶: #include <arrow/compute/function.h>
Extension point for defining options outside libarrow (but still within this project).

class arrow::compute::FunctionOptions : public arrow::util::EqualityComparable<FunctionOptions>¶

#include <arrow/compute/function.h>

Base class for specifying options configuring a function’s behavior, such as error handling.

Public Functions

Result<std::shared_ptr<Buffer>> Serialize() const¶: Serialize an options struct to a buffer.

Public Static Functions

static Result<std::unique_ptr<FunctionOptions>> Deserialize(const std::string &type_name, const Buffer &buffer)¶

Deserialize an options struct from a buffer.

Note: this will only look for type_name in the default FunctionRegistry; to use a custom FunctionRegistry, look up the FunctionOptionsType, then call FunctionOptionsType::Deserialize().

struct arrow::compute::Arity¶

#include <arrow/compute/function.h>

Contains the number of required arguments for the function.

Naming conventions taken from https://en.wikipedia.org/wiki/Arity.

Public Members

int num_args¶: The number of required arguments (or the minimum number for varargs functions).

bool is_varargs = false¶: If true, then the num_args is the minimum number of required arguments.

Public Static Functions

static inline Arity Nullary()¶: A function taking no arguments.

static inline Arity Unary()¶: A function taking 1 argument.

static inline Arity Binary()¶: A function taking 2 arguments.

static inline Arity Ternary()¶: A function taking 3 arguments.

static inline Arity VarArgs(int min_args = 0)¶

A function taking a variable number of arguments.

Parameters: [in] min_args – the minimum number of arguments required when invoking the function

struct arrow::compute::FunctionDoc¶

#include <arrow/compute/function.h>

Public Members

std::string summary¶

A one-line summary of the function, using a verb.

For example, “Add two numeric arrays or scalars”.

std::string description¶: A detailed description of the function, meant to follow the summary.

std::vector<std::string> arg_names¶

Symbolic names (identifiers) for the function arguments.

Some bindings may use this to generate nicer function signatures.

std::string options_class¶: Name of the options class, if any.

class arrow::compute::Function¶

#include <arrow/compute/function.h>

Base class for compute functions.

Function implementations contain a collection of “kernels” which are implementations of the function for specific argument types. Selecting a viable kernel for executing a function is referred to as “dispatching”.

Subclassed by arrow::compute::detail::FunctionImpl< KernelType >, arrow::compute::MetaFunction, arrow::compute::detail::FunctionImpl< HashAggregateKernel >, arrow::compute::detail::FunctionImpl< ScalarAggregateKernel >, arrow::compute::detail::FunctionImpl< ScalarKernel >, arrow::compute::detail::FunctionImpl< VectorKernel >

Public Types

enum Kind¶

The kind of function, which indicates in what contexts it is valid for use.

Values:

enumerator SCALAR¶

A function that performs scalar data operations on whole arrays of data.

Can generally process Array or Scalar values. The size of the output will be the same as the size (or broadcasted size, in the case of mixing Array and Scalar inputs) of the input.

enumerator VECTOR¶: A function with array input and output whose behavior depends on the values of the entire arrays passed, rather than the value of each scalar value.

enumerator SCALAR_AGGREGATE¶: A function that computes scalar summary statistics from array input.

enumerator HASH_AGGREGATE¶: A function that computes grouped summary statistics from array input and an array of group identifiers.

enumerator META¶: A function that dispatches to other functions and does not contain its own kernels.

Public Functions

inline const std::string &name() const¶: The name of the kernel. The registry enforces uniqueness of names.

inline Function::Kind kind() const¶: The kind of kernel, which indicates in what contexts it is valid for use.

inline const Arity &arity() const¶: Contains the number of arguments the function requires, or if the function accepts variable numbers of arguments.

inline const FunctionDoc &doc() const¶: Return the function documentation.

virtual int num_kernels() const = 0¶: Returns the number of registered kernels for this function.

virtual Result<const Kernel*> DispatchExact(const std::vector<ValueDescr> &values) const¶

Return a kernel that can execute the function given the exact argument types (without implicit type casts or scalar->array promotions).

NB: This function is overridden in CastFunction.

virtual Result<const Kernel*> DispatchBest(std::vector<ValueDescr> *values) const¶

Return a best-match kernel that can execute the function given the argument types, after implicit casts are applied.

Parameters: [inout] values – Argument types. An element may be modified to indicate that the returned kernel only approximately matches the input value descriptors; callers are responsible for casting inputs to the type and shape required by the kernel.

virtual Result<Datum> Execute(const std::vector<Datum> &args, const FunctionOptions *options, ExecContext *ctx) const¶

Execute the function eagerly with the passed input arguments with kernel dispatch, batch iteration, and memory allocation details taken care of.

If the options pointer is null, then default_options() will be used.

This function can be overridden in subclasses.

inline const FunctionOptions *default_options() const¶

Returns a the default options for this function.

Whatever option semantics a Function has, implementations must guarantee that default_options() is valid to pass to Execute as options.

class arrow::compute::ScalarFunction : public arrow::compute::detail::FunctionImpl<ScalarKernel>¶

#include <arrow/compute/function.h>

A function that executes elementwise operations on arrays or scalars, and therefore whose results generally do not depend on the order of the values in the arguments.

Accepts and returns arrays that are all of the same size. These functions roughly correspond to the functions used in SQL expressions.

Subclassed by arrow::compute::CastFunction

Public Functions

Status AddKernel(std::vector<InputType> in_types, OutputType out_type, ArrayKernelExec exec, KernelInit init = NULLPTR)¶: Add a kernel with given input/output types, no required state initialization, preallocation for fixed-width types, and default null handling (intersect validity bitmaps of inputs).

Status AddKernel(ScalarKernel kernel)¶

Add a kernel (function implementation).

Returns error if the kernel’s signature does not match the function’s arity.

class arrow::compute::VectorFunction : public arrow::compute::detail::FunctionImpl<VectorKernel>¶

#include <arrow/compute/function.h>

A function that executes general array operations that may yield outputs of different sizes or have results that depend on the whole array contents.

These functions roughly correspond to the functions found in non-SQL array languages like APL and its derivatives.

Public Functions

Status AddKernel(std::vector<InputType> in_types, OutputType out_type, ArrayKernelExec exec, KernelInit init = NULLPTR)¶: Add a simple kernel with given input/output types, no required state initialization, no data preallocation, and no preallocation of the validity bitmap.

Status AddKernel(VectorKernel kernel)¶

Add a kernel (function implementation).

Returns error if the kernel’s signature does not match the function’s arity.

class arrow::compute::ScalarAggregateFunction : public arrow::compute::detail::FunctionImpl<ScalarAggregateKernel>¶

#include <arrow/compute/function.h>

Public Functions

Status AddKernel(ScalarAggregateKernel kernel)¶

Add a kernel (function implementation).

Returns error if the kernel’s signature does not match the function’s arity.

class arrow::compute::HashAggregateFunction : public arrow::compute::detail::FunctionImpl<HashAggregateKernel>¶

#include <arrow/compute/function.h>

Public Functions

Status AddKernel(HashAggregateKernel kernel)¶

Add a kernel (function implementation).

Returns error if the kernel’s signature does not match the function’s arity.

class arrow::compute::MetaFunction : public arrow::compute::Function ¶

#include <arrow/compute/function.h>

A function that dispatches to other functions.

Must implement MetaFunction::ExecuteImpl.

For Array, ChunkedArray, and Scalar Datum kinds, may rely on the execution of concrete Function types, but must handle other Datum kinds on its own.

Public Functions

inline virtual int num_kernels() const override¶: Returns the number of registered kernels for this function.

virtual Result<Datum> Execute(const std::vector<Datum> &args, const FunctionOptions *options, ExecContext *ctx) const override¶

Execute the function eagerly with the passed input arguments with kernel dispatch, batch iteration, and memory allocation details taken care of.

If the options pointer is null, then default_options() will be used.

This function can be overridden in subclasses.

Function registry¶

class arrow::compute::FunctionRegistry¶

A mutable central function registry for built-in functions as well as user-defined functions.

Functions are implementations of arrow::compute::Function.

Generally, each function contains kernels which are implementations of a function for a specific argument signature. After looking up a function in the registry, one can either execute it eagerly with Function::Execute or use one of the function’s dispatch methods to pick a suitable kernel for lower-level function execution.

Public Functions

Status AddFunction(std::shared_ptr<Function> function, bool allow_overwrite = false)¶

Add a new function to the registry.

Returns Status::KeyError if a function with the same name is already registered

Status AddAlias(const std::string &target_name, const std::string &source_name)¶

Add aliases for the given function name.

Returns Status::KeyError if the function with the given name is not registered

Status AddFunctionOptionsType(const FunctionOptionsType *options_type, bool allow_overwrite = false)¶

Add a new function options type to the registry.

Returns Status::KeyError if a function options type with the same name is already registered

Result<std::shared_ptr<Function>> GetFunction(const std::string &name) const¶: Retrieve a function by name from the registry.

std::vector<std::string> GetFunctionNames() const¶

Return vector of all entry names in the registry.

Helpful for displaying a manifest of available functions

Result<const FunctionOptionsType*> GetFunctionOptionsType(const std::string &name) const¶: Retrieve a function options type by name from the registry.

int num_functions() const¶: The number of currently registered functions.

Public Static Functions

static std::unique_ptr<FunctionRegistry> Make()¶

Construct a new registry.

Most users only need to use the global registry

FunctionRegistry *arrow::compute::GetFunctionRegistry()¶: Return the process-global function registry.

Convenience functions¶

Result<Datum> CallFunction(const std::string &func_name, const std::vector<Datum> &args, const FunctionOptions *options, ExecContext *ctx = NULLPTR)¶

One-shot invoker for all types of functions.

Does kernel dispatch, argument checking, iteration of ChunkedArray inputs, and wrapping of outputs.

Result<Datum> CallFunction(const std::string &func_name, const std::vector<Datum> &args, ExecContext *ctx = NULLPTR)¶

Variant of CallFunction which uses a function’s default options.

NB: Some functions require FunctionOptions be provided.

Concrete options classes¶

enum CompareOperator¶

Values:

enumerator EQUAL¶

enumerator NOT_EQUAL¶

enumerator GREATER¶

enumerator GREATER_EQUAL¶

enumerator LESS¶

enumerator LESS_EQUAL¶

enum SortOrder¶

Values:

enumerator Ascending¶

enumerator Descending¶

class arrow::compute::ScalarAggregateOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control general scalar aggregate kernel behavior.

By default, null values are ignored

Public Functions

explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 1)¶

Public Members

bool skip_nulls¶

uint32_t min_count¶

Public Static Functions

static inline ScalarAggregateOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "ScalarAggregateOptions"

class arrow::compute::ModeOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control Mode kernel behavior.

Returns top-n common values and counts. By default, returns the most common value and count.

Public Functions

explicit ModeOptions(int64_t n = 1)¶

Public Members

int64_t n = 1¶

Public Static Functions

static inline ModeOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "ModeOptions"

class arrow::compute::VarianceOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel.

The divisor used in calculations is N - ddof, where N is the number of elements. By default, ddof is zero, and population variance or stddev is returned.

Public Functions

explicit VarianceOptions(int ddof = 0)¶

Public Members

int ddof = 0¶

Public Static Functions

static inline VarianceOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "VarianceOptions"

class arrow::compute::QuantileOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control Quantile kernel behavior.

By default, returns the median value.

Public Types

enum Interpolation¶

Interpolation method to use when quantile lies between two data points.

Values:

enumerator LINEAR¶

enumerator LOWER¶

enumerator HIGHER¶

enumerator NEAREST¶

enumerator MIDPOINT¶

Public Functions

explicit QuantileOptions(double q = 0.5, enum Interpolation interpolation = LINEAR)¶

explicit QuantileOptions(std::vector<double> q, enum Interpolation interpolation = LINEAR)¶

Public Members

std::vector<double> q¶: quantile must be between 0 and 1 inclusive

enum Interpolation interpolation¶

Public Static Functions

static inline QuantileOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "QuantileOptions"

class arrow::compute::TDigestOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control TDigest approximate quantile kernel behavior.

By default, returns the median value.

Public Functions

explicit TDigestOptions(double q = 0.5, uint32_t delta = 100, uint32_t buffer_size = 500)¶

explicit TDigestOptions(std::vector<double> q, uint32_t delta = 100, uint32_t buffer_size = 500)¶

Public Members

std::vector<double> q¶: quantile must be between 0 and 1 inclusive

uint32_t delta¶: compression parameter, default 100

uint32_t buffer_size¶: input buffer size, default 500

Public Static Functions

static inline TDigestOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "TDigestOptions"

class arrow::compute::IndexOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_aggregate.h>

Control Index kernel behavior.

Public Functions

explicit IndexOptions(std::shared_ptr<Scalar> value)¶

IndexOptions()¶

Public Members

std::shared_ptr<Scalar> value¶

Public Static Attributes

static constexpr static char const kTypeName [] = "IndexOptions"

class arrow::compute::ArithmeticOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit ArithmeticOptions(bool check_overflow = false)¶

Public Members

bool check_overflow¶

Public Static Attributes

static constexpr static char const kTypeName [] = "ArithmeticOptions"

class arrow::compute::ElementWiseAggregateOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit ElementWiseAggregateOptions(bool skip_nulls = true)¶

Public Members

bool skip_nulls¶

Public Static Functions

static inline ElementWiseAggregateOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "ElementWiseAggregateOptions"

class arrow::compute::JoinOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Options for var_args_join.

Public Types

enum NullHandlingBehavior¶

How to handle null values. (A null separator always results in a null output.)

Values:

enumerator EMIT_NULL¶: A null in any input results in a null in the output.

enumerator SKIP¶: Nulls in inputs are skipped.

enumerator REPLACE¶: Nulls in inputs are replaced with the replacement string.

Public Functions

explicit JoinOptions(NullHandlingBehavior null_handling = EMIT_NULL, std::string null_replacement = "")¶

Public Members

NullHandlingBehavior null_handling¶

std::string null_replacement¶

Public Static Functions

static inline JoinOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "JoinOptions"

class arrow::compute::MatchSubstringOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit MatchSubstringOptions(std::string pattern, bool ignore_case = false)¶

MatchSubstringOptions()¶

Public Members

std::string pattern¶: The exact substring (or regex, depending on kernel) to look for inside input values.

bool ignore_case = false¶: Whether to perform a case-insensitive match.

Public Static Attributes

static constexpr static char const kTypeName [] = "MatchSubstringOptions"

class arrow::compute::SplitOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit SplitOptions(int64_t max_splits = -1, bool reverse = false)¶

Public Members

int64_t max_splits¶: Maximum number of splits allowed, or unlimited when -1.

bool reverse¶: Start splitting from the end of the string (only relevant when max_splits != -1)

Public Static Attributes

static constexpr static char const kTypeName [] = "SplitOptions"

class arrow::compute::SplitPatternOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit SplitPatternOptions(std::string pattern, int64_t max_splits = -1, bool reverse = false)¶

SplitPatternOptions()¶

Public Members

std::string pattern¶: The exact substring to split on.

int64_t max_splits¶: Maximum number of splits allowed, or unlimited when -1.

bool reverse¶: Start splitting from the end of the string (only relevant when max_splits != -1)

Public Static Attributes

static constexpr static char const kTypeName [] = "SplitPatternOptions"

class arrow::compute::ReplaceSliceOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit ReplaceSliceOptions(int64_t start, int64_t stop, std::string replacement)¶

ReplaceSliceOptions()¶

Public Members

int64_t start¶: Index to start slicing at.

int64_t stop¶: Index to stop slicing at.

std::string replacement¶: String to replace the slice with.

Public Static Attributes

static constexpr static char const kTypeName [] = "ReplaceSliceOptions"

class arrow::compute::ReplaceSubstringOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit ReplaceSubstringOptions(std::string pattern, std::string replacement, int64_t max_replacements = -1)¶

ReplaceSubstringOptions()¶

Public Members

std::string pattern¶: Pattern to match, literal, or regular expression depending on which kernel is used.

std::string replacement¶: String to replace the pattern with.

int64_t max_replacements¶: Max number of substrings to replace (-1 means unbounded)

Public Static Attributes

static constexpr static char const kTypeName [] = "ReplaceSubstringOptions"

class arrow::compute::ExtractRegexOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit ExtractRegexOptions(std::string pattern)¶

ExtractRegexOptions()¶

Public Members

std::string pattern¶: Regular expression with named capture fields.

Public Static Attributes

static constexpr static char const kTypeName [] = "ExtractRegexOptions"

class arrow::compute::SetLookupOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Options for IsIn and IndexIn functions.

Public Functions

explicit SetLookupOptions(Datum value_set, bool skip_nulls = false)¶

SetLookupOptions()¶

Public Members

Datum value_set¶: The set of values to look up input values into.

bool skip_nulls¶

Whether nulls in value_set count for lookup.

If true, any null in value_set is ignored and nulls in the input produce null (IndexIn) or false (IsIn) values in the output. If false, any null in value_set is successfully matched in the input.

Public Static Attributes

static constexpr static char const kTypeName [] = "SetLookupOptions"

class arrow::compute::StrptimeOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit StrptimeOptions(std::string format, TimeUnit::type unit)¶

StrptimeOptions()¶

Public Members

std::string format¶

TimeUnit::type unit¶

Public Static Attributes

static constexpr static char const kTypeName [] = "StrptimeOptions"

class arrow::compute::PadOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit PadOptions(int64_t width, std::string padding = " ")¶

PadOptions()¶

Public Members

int64_t width¶: The desired string length.

std::string padding¶: What to pad the string with. Should be one codepoint (Unicode)/byte (ASCII).

Public Static Attributes

static constexpr static char const kTypeName [] = "PadOptions"

class arrow::compute::TrimOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit TrimOptions(std::string characters)¶

TrimOptions()¶

Public Members

std::string characters¶: The individual characters that can be trimmed from the string.

Public Static Attributes

static constexpr static char const kTypeName [] = "TrimOptions"

class arrow::compute::SliceOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit SliceOptions(int64_t start, int64_t stop = std::numeric_limits<int64_t>::max(), int64_t step = 1)¶

SliceOptions()¶

Public Members

int64_t start¶

int64_t stop¶

int64_t step¶

Public Static Attributes

static constexpr static char const kTypeName [] = "SliceOptions"

struct arrow::compute::CompareOptions¶

#include <arrow/compute/api_scalar.h>

Public Functions

inline explicit CompareOptions(CompareOperator op)¶

inline CompareOptions()¶

Public Members

enum CompareOperator op¶

class arrow::compute::MakeStructOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

MakeStructOptions(std::vector<std::string> n, std::vector<bool> r, std::vector<std::shared_ptr<const KeyValueMetadata>> m)¶

explicit MakeStructOptions(std::vector<std::string> n)¶

MakeStructOptions()¶

Public Members

std::vector<std::string> field_names¶: Names for wrapped columns.

std::vector<bool> field_nullability¶: Nullability bits for wrapped columns.

std::vector<std::shared_ptr<const KeyValueMetadata>> field_metadata¶: Metadata attached to wrapped columns.

Public Static Attributes

static constexpr static char const kTypeName [] = "MakeStructOptions"

struct arrow::compute::DayOfWeekOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_scalar.h>

Public Functions

explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)¶

Public Members

bool one_based_numbering¶: Number days from 1 if true and from 0 if false.

uint32_t week_start¶: What day does the week start with (Monday=1, Sunday=7)

Public Static Functions

static inline DayOfWeekOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "DayOfWeekOptions"

class arrow::compute::FilterOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Public Types

enum NullSelectionBehavior¶

Configure the action taken when a slot of the selection mask is null.

Values:

enumerator DROP¶: the corresponding filtered value will be removed in the output

enumerator EMIT_NULL¶: the corresponding filtered value will be null in the output

Public Functions

explicit FilterOptions(NullSelectionBehavior null_selection = DROP)¶

Public Members

NullSelectionBehavior null_selection_behavior = DROP ¶

Public Static Functions

static inline FilterOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "FilterOptions"

class arrow::compute::TakeOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Public Functions

explicit TakeOptions(bool boundscheck = true)¶

Public Members

bool boundscheck = true¶

Public Static Functions

static inline TakeOptions BoundsCheck()¶

static inline TakeOptions NoBoundsCheck()¶

static inline TakeOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "TakeOptions"

class arrow::compute::DictionaryEncodeOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Options for the dictionary encode function.

Public Types

enum NullEncodingBehavior¶

Configure how null values will be encoded.

Values:

enumerator ENCODE¶: the null value will be added to the dictionary with a proper index

enumerator MASK¶: the null value will be masked in the indices array

Public Functions

explicit DictionaryEncodeOptions(NullEncodingBehavior null_encoding = MASK)¶

Public Members

NullEncodingBehavior null_encoding_behavior = MASK ¶

Public Static Functions

static inline DictionaryEncodeOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "DictionaryEncodeOptions"

class arrow::compute::SortKey : public arrow::util::EqualityComparable<SortKey>¶

#include <arrow/compute/api_vector.h>

One sort key for PartitionNthIndices (TODO) and SortIndices.

Public Functions

inline explicit SortKey(std::string name, SortOrder order = SortOrder::Ascending)¶

bool Equals(const SortKey &other) const¶

std::string ToString() const¶

Public Members

std::string name¶: The name of the sort column.

SortOrder order¶: How to order by this sort key.

class arrow::compute::ArraySortOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Public Functions

explicit ArraySortOptions(SortOrder order = SortOrder::Ascending)¶

Public Members

SortOrder order¶

Public Static Functions

static inline ArraySortOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "ArraySortOptions"

class arrow::compute::SortOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Public Functions

explicit SortOptions(std::vector<SortKey> sort_keys = {})¶

Public Members

std::vector<SortKey> sort_keys¶

Public Static Functions

static inline SortOptions Defaults()¶

Public Static Attributes

static constexpr static char const kTypeName [] = "SortOptions"

class arrow::compute::PartitionNthOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/api_vector.h>

Partitioning options for NthToIndices.

Public Functions

explicit PartitionNthOptions(int64_t pivot)¶

inline PartitionNthOptions()¶

Public Members

int64_t pivot¶: The index into the equivalent sorted array of the partition pivot element.

Public Static Attributes

static constexpr static char const kTypeName [] = "PartitionNthOptions"

class arrow::compute::CastOptions : public arrow::compute::FunctionOptions ¶

#include <arrow/compute/cast.h>

Public Functions

explicit CastOptions(bool safe = true)¶

Public Members

std::shared_ptr<DataType> to_type¶

bool allow_int_overflow¶

bool allow_time_truncate¶

bool allow_time_overflow¶

bool allow_decimal_truncate¶

bool allow_float_truncate¶

bool allow_invalid_utf8¶

Public Static Functions

static inline CastOptions Safe(std::shared_ptr<DataType> to_type = NULLPTR)¶

static inline CastOptions Unsafe(std::shared_ptr<DataType> to_type = NULLPTR)¶

Public Static Attributes

static constexpr static char const kTypeName [] = "CastOptions"

C Interfaces Tensors