Compute Functions#


all(array, /, *[, skip_nulls, min_count, ...])

Test whether all elements in a boolean array evaluate to true.

any(array, /, *[, skip_nulls, min_count, ...])

Test whether any element in a boolean array evaluates to true.

approximate_median(array, /, *[, ...])

Approximate median of a numeric array with T-Digest algorithm.

count(array, /[, mode, options, memory_pool])

Count the number of null / non-null values.

count_distinct(array, /[, mode, options, ...])

Count the number of unique values.

index(data, value[, start, end, memory_pool])

Find the index of the first occurrence of a given value.

max(array, /, *[, skip_nulls, min_count, ...])

Compute the minimum or maximum values of a numeric array.

mean(array, /, *[, skip_nulls, min_count, ...])

Compute the mean of a numeric array.

min(array, /, *[, skip_nulls, min_count, ...])

Compute the minimum or maximum values of a numeric array.

min_max(array, /, *[, skip_nulls, ...])

Compute the minimum and maximum values of a numeric array.

mode(array, /[, n, skip_nulls, min_count, ...])

Compute the modal (most common) values of a numeric array.

product(array, /, *[, skip_nulls, ...])

Compute the product of values in a numeric array.

quantile(array, /[, q, interpolation, ...])

Compute an array of quantiles of a numeric array or chunked array.

stddev(array, /, *[, ddof, skip_nulls, ...])

Calculate the standard deviation of a numeric array.

sum(array, /, *[, skip_nulls, min_count, ...])

Compute the sum of a numeric array.

tdigest(array, /[, q, delta, buffer_size, ...])

Approximate quantiles of a numeric array with T-Digest algorithm.

variance(array, /, *[, ddof, skip_nulls, ...])

Calculate the variance of a numeric array.

Cumulative Functions#

Cumulative functions are vector functions that perform a running accumulation on their input using a given binary associative operation with an identity element (a monoid) and output an array containing the corresponding intermediate running values. The input is expected to be of numeric type. By default these functions do not detect overflow. They are also available in an overflow-checking variant, suffixed _checked, which throws an ArrowInvalid exception when overflow is detected.

cumulative_sum(values, /[, start, ...])

Compute the cumulative sum over a numeric input.

cumulative_sum_checked(values, /[, start, ...])

Compute the cumulative sum over a numeric input.

cumulative_prod(values, /[, start, ...])

Compute the cumulative product over a numeric input.

cumulative_prod_checked(values, /[, start, ...])

Compute the cumulative product over a numeric input.

cumulative_max(values, /[, start, ...])

Compute the cumulative max over a numeric input.

cumulative_min(values, /[, start, ...])

Compute the cumulative min over a numeric input.

Arithmetic Functions#

By default these functions do not detect overflow. Most functions are also available in an overflow-checking variant, suffixed _checked, which throws an ArrowInvalid exception when overflow is detected.

abs(x, /, *[, memory_pool])

Calculate the absolute value of the argument element-wise.

abs_checked(x, /, *[, memory_pool])

Calculate the absolute value of the argument element-wise.

add(x, y, /, *[, memory_pool])

Add the arguments element-wise.

add_checked(x, y, /, *[, memory_pool])

Add the arguments element-wise.

divide(dividend, divisor, /, *[, memory_pool])

Divide the arguments element-wise.

divide_checked(dividend, divisor, /, *[, ...])

Divide the arguments element-wise.

multiply(x, y, /, *[, memory_pool])

Multiply the arguments element-wise.

multiply_checked(x, y, /, *[, memory_pool])

Multiply the arguments element-wise.

negate(x, /, *[, memory_pool])

Negate the argument element-wise.

negate_checked(x, /, *[, memory_pool])

Negate the arguments element-wise.

power(base, exponent, /, *[, memory_pool])

Raise arguments to power element-wise.

power_checked(base, exponent, /, *[, ...])

Raise arguments to power element-wise.

sign(x, /, *[, memory_pool])

Get the signedness of the arguments element-wise.

sqrt(x, /, *[, memory_pool])

Takes the square root of arguments element-wise.

sqrt_checked(x, /, *[, memory_pool])

Takes the square root of arguments element-wise.

subtract(x, y, /, *[, memory_pool])

Subtract the arguments element-wise.

subtract_checked(x, y, /, *[, memory_pool])

Subtract the arguments element-wise.

Bit-wise Functions#

bit_wise_and(x, y, /, *[, memory_pool])

Bit-wise AND the arguments element-wise.

bit_wise_not(x, /, *[, memory_pool])

Bit-wise negate the arguments element-wise.

bit_wise_or(x, y, /, *[, memory_pool])

Bit-wise OR the arguments element-wise.

bit_wise_xor(x, y, /, *[, memory_pool])

Bit-wise XOR the arguments element-wise.

shift_left(x, y, /, *[, memory_pool])

Left shift x by y.

shift_left_checked(x, y, /, *[, memory_pool])

Left shift x by y.

shift_right(x, y, /, *[, memory_pool])

Right shift x by y.

shift_right_checked(x, y, /, *[, memory_pool])

Right shift x by y.

Rounding Functions#

Rounding functions displace numeric inputs to an approximate value with a simpler representation based on the rounding criterion.

ceil(x, /, *[, memory_pool])

Round up to the nearest integer.

floor(x, /, *[, memory_pool])

Round down to the nearest integer.

round(x, /[, ndigits, round_mode, options, ...])

Round to a given precision.

round_to_multiple(x, /[, multiple, ...])

Round to a given multiple.

trunc(x, /, *[, memory_pool])

Compute the integral part.

Logarithmic Functions#

Logarithmic functions are also supported, and also offer _checked variants which detect domain errors.

ln(x, /, *[, memory_pool])

Compute natural logarithm.

ln_checked(x, /, *[, memory_pool])

Compute natural logarithm.

log10(x, /, *[, memory_pool])

Compute base 10 logarithm.

log10_checked(x, /, *[, memory_pool])

Compute base 10 logarithm.

log1p(x, /, *[, memory_pool])

Compute natural log of (1+x).

log1p_checked(x, /, *[, memory_pool])

Compute natural log of (1+x).

log2(x, /, *[, memory_pool])

Compute base 2 logarithm.

log2_checked(x, /, *[, memory_pool])

Compute base 2 logarithm.

logb(x, b, /, *[, memory_pool])

Compute base b logarithm.

logb_checked(x, b, /, *[, memory_pool])

Compute base b logarithm.

Trigonometric Functions#

Trigonometric functions are also supported, and also offer _checked variants which detect domain errors where appropriate.

acos(x, /, *[, memory_pool])

Compute the inverse cosine.

acos_checked(x, /, *[, memory_pool])

Compute the inverse cosine.

asin(x, /, *[, memory_pool])

Compute the inverse sine.

asin_checked(x, /, *[, memory_pool])

Compute the inverse sine.

atan(x, /, *[, memory_pool])

Compute the inverse tangent of x.

atan2(y, x, /, *[, memory_pool])

Compute the inverse tangent of y/x.

cos(x, /, *[, memory_pool])

Compute the cosine.

cos_checked(x, /, *[, memory_pool])

Compute the cosine.

sin(x, /, *[, memory_pool])

Compute the sine.

sin_checked(x, /, *[, memory_pool])

Compute the sine.

tan(x, /, *[, memory_pool])

Compute the tangent.

tan_checked(x, /, *[, memory_pool])

Compute the tangent.


These functions expect two inputs of the same type. If one of the inputs is null they return null.

equal(x, y, /, *[, memory_pool])

Compare values for equality (x == y).

greater(x, y, /, *[, memory_pool])

Compare values for ordered inequality (x > y).

greater_equal(x, y, /, *[, memory_pool])

Compare values for ordered inequality (x >= y).

less(x, y, /, *[, memory_pool])

Compare values for ordered inequality (x < y).

less_equal(x, y, /, *[, memory_pool])

Compare values for ordered inequality (x <= y).

not_equal(x, y, /, *[, memory_pool])

Compare values for inequality (x != y).

These functions take any number of arguments of a numeric or temporal type.

max_element_wise(*args[, skip_nulls, ...])

Find the element-wise maximum value.

min_element_wise(*args[, skip_nulls, ...])

Find the element-wise minimum value.

Logical Functions#

These functions normally emit a null when one of the inputs is null. However, Kleene logic variants are provided (suffixed _kleene). See User Guide for details.

and_(x, y, /, *[, memory_pool])

Logical 'and' boolean values.

and_kleene(x, y, /, *[, memory_pool])

Logical 'and' boolean values (Kleene logic).

and_not(x, y, /, *[, memory_pool])

Logical 'and not' boolean values.

and_not_kleene(x, y, /, *[, memory_pool])

Logical 'and not' boolean values (Kleene logic).

invert(values, /, *[, memory_pool])

Invert boolean values.

or_(x, y, /, *[, memory_pool])

Logical 'or' boolean values.

or_kleene(x, y, /, *[, memory_pool])

Logical 'or' boolean values (Kleene logic).

xor(x, y, /, *[, memory_pool])

Logical 'xor' boolean values.

String Predicates#

In these functions an empty string emits false in the output. For ASCII variants (prefixed ascii_) a string element with non-ASCII characters emits false in the output.

The first set of functions emit true if the input contains only characters of a given class.

ascii_is_alnum(strings, /, *[, memory_pool])

Classify strings as ASCII alphanumeric.

ascii_is_alpha(strings, /, *[, memory_pool])

Classify strings as ASCII alphabetic.

ascii_is_decimal(strings, /, *[, memory_pool])

Classify strings as ASCII decimal.

ascii_is_lower(strings, /, *[, memory_pool])

Classify strings as ASCII lowercase.

ascii_is_printable(strings, /, *[, memory_pool])

Classify strings as ASCII printable.

ascii_is_space(strings, /, *[, memory_pool])

Classify strings as ASCII whitespace.

ascii_is_upper(strings, /, *[, memory_pool])

Classify strings as ASCII uppercase.

utf8_is_alnum(strings, /, *[, memory_pool])

Classify strings as alphanumeric.

utf8_is_alpha(strings, /, *[, memory_pool])

Classify strings as alphabetic.

utf8_is_decimal(strings, /, *[, memory_pool])

Classify strings as decimal.

utf8_is_digit(strings, /, *[, memory_pool])

Classify strings as digits.

utf8_is_lower(strings, /, *[, memory_pool])

Classify strings as lowercase.

utf8_is_numeric(strings, /, *[, memory_pool])

Classify strings as numeric.

utf8_is_printable(strings, /, *[, memory_pool])

Classify strings as printable.

utf8_is_space(strings, /, *[, memory_pool])

Classify strings as whitespace.

utf8_is_upper(strings, /, *[, memory_pool])

Classify strings as uppercase.

The second set of functions also consider the order of characters in the string element.

ascii_is_title(strings, /, *[, memory_pool])

Classify strings as ASCII titlecase.

utf8_is_title(strings, /, *[, memory_pool])

Classify strings as titlecase.

The third set of functions examines string elements on a byte-by-byte basis.

string_is_ascii(strings, /, *[, memory_pool])

Classify strings as ASCII.

String Transforms#

ascii_capitalize(strings, /, *[, memory_pool])

Capitalize the first character of ASCII input.

ascii_lower(strings, /, *[, memory_pool])

Transform ASCII input to lowercase.

ascii_reverse(strings, /, *[, memory_pool])

Reverse ASCII input.

ascii_swapcase(strings, /, *[, memory_pool])

Transform ASCII input by inverting casing.

ascii_title(strings, /, *[, memory_pool])

Titlecase each word of ASCII input.

ascii_upper(strings, /, *[, memory_pool])

Transform ASCII input to uppercase.

binary_length(strings, /, *[, memory_pool])

Compute string lengths.

binary_repeat(strings, num_repeats, /, *[, ...])

Repeat a binary string.

binary_replace_slice(strings, /, start, ...)

Replace a slice of a binary string.

binary_reverse(strings, /, *[, memory_pool])

Reverse binary input.

replace_substring(strings, /, pattern, ...)

Replace matching non-overlapping substrings with replacement.

replace_substring_regex(strings, /, pattern, ...)

Replace matching non-overlapping substrings with replacement.

utf8_capitalize(strings, /, *[, memory_pool])

Capitalize the first character of input.

utf8_length(strings, /, *[, memory_pool])

Compute UTF8 string lengths.

utf8_lower(strings, /, *[, memory_pool])

Transform input to lowercase.

utf8_replace_slice(strings, /, start, stop, ...)

Replace a slice of a string.

utf8_reverse(strings, /, *[, memory_pool])

Reverse input.

utf8_swapcase(strings, /, *[, memory_pool])

Transform input lowercase characters to uppercase and uppercase characters to lowercase.

utf8_title(strings, /, *[, memory_pool])

Titlecase each word of input.

utf8_upper(strings, /, *[, memory_pool])

Transform input to uppercase.

String Padding#

ascii_center(strings, /, width[, padding, ...])

Center strings by padding with a given character.

ascii_lpad(strings, /, width[, padding, ...])

Right-align strings by padding with a given character.

ascii_rpad(strings, /, width[, padding, ...])

Left-align strings by padding with a given character.

utf8_center(strings, /, width[, padding, ...])

Center strings by padding with a given character.

utf8_lpad(strings, /, width[, padding, ...])

Right-align strings by padding with a given character.

utf8_rpad(strings, /, width[, padding, ...])

Left-align strings by padding with a given character.

String Trimming#

ascii_ltrim(strings, /, characters, *[, ...])

Trim leading characters.

ascii_ltrim_whitespace(strings, /, *[, ...])

Trim leading ASCII whitespace characters.

ascii_rtrim(strings, /, characters, *[, ...])

Trim trailing characters.

ascii_rtrim_whitespace(strings, /, *[, ...])

Trim trailing ASCII whitespace characters.

ascii_trim(strings, /, characters, *[, ...])

Trim leading and trailing characters.

ascii_trim_whitespace(strings, /, *[, ...])

Trim leading and trailing ASCII whitespace characters.

utf8_ltrim(strings, /, characters, *[, ...])

Trim leading characters.

utf8_ltrim_whitespace(strings, /, *[, ...])

Trim leading whitespace characters.

utf8_rtrim(strings, /, characters, *[, ...])

Trim trailing characters.

utf8_rtrim_whitespace(strings, /, *[, ...])

Trim trailing whitespace characters.

utf8_trim(strings, /, characters, *[, ...])

Trim leading and trailing characters.

utf8_trim_whitespace(strings, /, *[, ...])

Trim leading and trailing whitespace characters.

String Splitting#

ascii_split_whitespace(strings, /, *[, ...])

Split string according to any ASCII whitespace.

split_pattern(strings, /, pattern, *[, ...])

Split string according to separator.

split_pattern_regex(strings, /, pattern, *)

Split string according to regex pattern.

utf8_split_whitespace(strings, /, *[, ...])

Split string according to any Unicode whitespace.

String Component Extraction#

extract_regex(strings, /, pattern, *[, ...])

Extract substrings captured by a regex pattern.

String Joining#

binary_join(strings, separator, /, *[, ...])

Join a list of strings together with a separator.

binary_join_element_wise(*strings[, ...])

Join string arguments together, with the last argument as separator.

String Slicing#

binary_slice(strings, /, start[, stop, ...])

Slice binary string.

utf8_slice_codeunits(strings, /, start[, ...])

Slice string.

Containment Tests#

count_substring(strings, /, pattern, *[, ...])

Count occurrences of substring.

count_substring_regex(strings, /, pattern, *)

Count occurrences of substring.

ends_with(strings, /, pattern, *[, ...])

Check if strings end with a literal pattern.

find_substring(strings, /, pattern, *[, ...])

Find first occurrence of substring.

find_substring_regex(strings, /, pattern, *)

Find location of first match of regex pattern.

index_in(values, /, value_set, *[, ...])

Return index of each element in a set of values.

is_in(values, /, value_set, *[, skip_nulls, ...])

Find each element in a set of values.

match_like(strings, /, pattern, *[, ...])

Match strings against SQL-style LIKE pattern.

match_substring(strings, /, pattern, *[, ...])

Match strings against literal pattern.

match_substring_regex(strings, /, pattern, *)

Match strings against regex pattern.

starts_with(strings, /, pattern, *[, ...])

Check if strings start with a literal pattern.

indices_nonzero(values, /, *[, memory_pool])

Return the indices of the values in the array that are non-zero.


is_finite(values, /, *[, memory_pool])

Return true if value is finite.

is_inf(values, /, *[, memory_pool])

Return true if infinity.

is_nan(values, /, *[, memory_pool])

Return true if NaN.

is_null(values, /, *[, nan_is_null, ...])

Return true if null (and optionally NaN).

is_valid(values, /, *[, memory_pool])

Return true if non-null.

true_unless_null(values, /, *[, memory_pool])

Return true if non-null, else return null.

Selecting / Multiplexing#

case_when(cond, /, *cases[, memory_pool])

Choose values based on multiple conditions.

choose(indices, /, *values[, memory_pool])

Choose values from several arrays.

coalesce(*values[, memory_pool])

Select the first non-null value.

if_else(cond, left, right, /, *[, memory_pool])

Choose values based on a condition.


cast(arr[, target_type, safe, options, ...])

Cast array values to another data type.

ceil_temporal(timestamps, /[, multiple, ...])

Round temporal values up to nearest multiple of specified time unit.

floor_temporal(timestamps, /[, multiple, ...])

Round temporal values down to nearest multiple of specified time unit.

round_temporal(timestamps, /[, multiple, ...])

Round temporal values to the nearest multiple of specified time unit.

run_end_decode(array, /, *[, memory_pool])

Decode run-end encoded array.

run_end_encode(array, /[, run_end_type, ...])

Run-end encode array.

strftime(timestamps, /[, format, locale, ...])

Format temporal values according to a format string.

strptime(strings, /, format, unit[, ...])

Parse timestamps.

Temporal Component Extraction#

day(values, /, *[, memory_pool])

Extract day number.

day_of_week(values, /, *[, count_from_zero, ...])

Extract day of the week number.

day_of_year(values, /, *[, memory_pool])

Extract day of year number.

hour(values, /, *[, memory_pool])

Extract hour value.

iso_week(values, /, *[, memory_pool])

Extract ISO week of year number.

iso_year(values, /, *[, memory_pool])

Extract ISO year number.

iso_calendar(values, /, *[, memory_pool])

Extract (ISO year, ISO week, ISO day of week) struct.

is_leap_year(values, /, *[, memory_pool])

Extract if year is a leap year.

microsecond(values, /, *[, memory_pool])

Extract microsecond values.

millisecond(values, /, *[, memory_pool])

Extract millisecond values.

minute(values, /, *[, memory_pool])

Extract minute values.

month(values, /, *[, memory_pool])

Extract month number.

nanosecond(values, /, *[, memory_pool])

Extract nanosecond values.

quarter(values, /, *[, memory_pool])

Extract quarter of year number.

second(values, /, *[, memory_pool])

Extract second values.

subsecond(values, /, *[, memory_pool])

Extract subsecond values.

us_week(values, /, *[, memory_pool])

Extract US week of year number.

us_year(values, /, *[, memory_pool])

Extract US epidemiological year number.

week(values, /, *[, week_starts_monday, ...])

Extract week of year number.

year(values, /, *[, memory_pool])

Extract year number.

year_month_day(values, /, *[, memory_pool])

Extract (year, month, day) struct.

Temporal Difference#

day_time_interval_between(start, end, /, *)

Compute the number of days and milliseconds between two timestamps.

days_between(start, end, /, *[, memory_pool])

Compute the number of days between two timestamps.

hours_between(start, end, /, *[, memory_pool])

Compute the number of hours between two timestamps.

microseconds_between(start, end, /, *[, ...])

Compute the number of microseconds between two timestamps.

milliseconds_between(start, end, /, *[, ...])

Compute the number of millisecond boundaries between two timestamps.

minutes_between(start, end, /, *[, memory_pool])

Compute the number of minute boundaries between two timestamps.

month_day_nano_interval_between(start, end, /, *)

Compute the number of months, days and nanoseconds between two timestamps.

month_interval_between(start, end, /, *[, ...])

Compute the number of months between two timestamps.

nanoseconds_between(start, end, /, *[, ...])

Compute the number of nanoseconds between two timestamps.

quarters_between(start, end, /, *[, memory_pool])

Compute the number of quarters between two timestamps.

seconds_between(start, end, /, *[, memory_pool])

Compute the number of seconds between two timestamps.

weeks_between(start, end, /, *[, ...])

Compute the number of weeks between two timestamps.

years_between(start, end, /, *[, memory_pool])

Compute the number of years between two timestamps.

Timezone Handling#

assume_timezone(timestamps, /, timezone, *)

Convert naive timestamp to timezone-aware timestamp.

local_timestamp(values, /, *[, memory_pool])

Convert timestamp to a timezone-naive local time timestamp.

Associative Transforms#

dictionary_encode(array, /[, null_encoding, ...])

Dictionary-encode array.

unique(array, /, *[, memory_pool])

Compute unique elements.

value_counts(array, /, *[, memory_pool])

Compute counts of unique elements.


array_filter(array, selection_filter, /[, ...])

Filter with a boolean selection filter.

array_take(array, indices, /, *[, ...])

Select values from an array based on indices from another array.

drop_null(input, /, *[, memory_pool])

Drop nulls from the input.

filter(input, selection_filter, /[, ...])

Filter with a boolean selection filter.

take(data, indices, *[, boundscheck, ...])

Select values (or records) from array- or table-like data given integer selection indices.

Sorts and Partitions#

array_sort_indices(array, /[, order, ...])

Return the indices that would sort an array.

partition_nth_indices(array, /, pivot, *[, ...])

Return the indices that would partition an array around a pivot.

select_k_unstable(input, /, k, sort_keys, *)

Select the indices of the first k ordered elements from the input.

sort_indices(input, /[, sort_keys, ...])

Return the indices that would sort an array, record batch or table.

Structural Transforms#

fill_null(values, fill_value)

Replace each null element in values with a corresponding element from fill_value.

fill_null_backward(values, /, *[, memory_pool])

Carry non-null values backward to fill null slots.

fill_null_forward(values, /, *[, memory_pool])

Carry non-null values forward to fill null slots.

list_element(lists, index, /, *[, memory_pool])

Compute elements using of nested list values using an index.

list_flatten(lists, /, *[, memory_pool])

Flatten list values.

list_parent_indices(lists, /, *[, memory_pool])

Compute parent indices of nested list values.

list_slice(lists, /, start[, stop, step, ...])

Compute slice of list-like array.

list_value_length(lists, /, *[, memory_pool])

Compute list lengths.

make_struct(*args[, field_names, ...])

Wrap Arrays into a StructArray.

map_lookup(container, /, query_key, ...[, ...])

Find the items corresponding to a given key in a Map.

replace_with_mask(values, mask, ...[, ...])

Replace items selected with a mask.

struct_field(values, /, indices, *[, ...])

Extract children of a struct or union by index.

Pairwise Functions#

pairwise_diff(input, /[, period, options, ...])

Compute first order difference of an array.

Compute Options#

ArraySortOptions([order, null_placement])

Options for the array_sort_indices function.

AssumeTimezoneOptions(timezone, *[, ...])

Options for the assume_timezone function.

CastOptions([target_type, ...])

Options for the cast function.


Options for the count function.


Options for the count function.

CumulativeSumOptions([start, skip_nulls])

Options for cumulative_sum function.

DayOfWeekOptions(*[, count_from_zero, ...])

Options for the day_of_week function.


Options for dictionary encoding.

ElementWiseAggregateOptions(*[, skip_nulls])

Options for element-wise aggregate functions.


Options for the extract_regex function.


Options for selecting with a boolean filter.


Options for the index function.

JoinOptions([null_handling, null_replacement])

Options for the binary_join_element_wise function.

ListSliceOptions(start[, stop, step, ...])

Options for list array slicing.

MakeStructOptions([field_names, ...])

Options for the make_struct function.

MapLookupOptions(query_key, occurrence)

Options for the map_lookup function.

MatchSubstringOptions(pattern, *[, ignore_case])

Options for looking for a substring.

ModeOptions([n, skip_nulls, min_count])

Options for the mode function.

NullOptions(*[, nan_is_null])

Options for the is_null function.

PadOptions(width[, padding])

Options for padding strings.


Options for pairwise functions.

PartitionNthOptions(pivot, *[, null_placement])

Options for the partition_nth_indices function.

QuantileOptions([q, interpolation, ...])

Options for the quantile function.

ReplaceSliceOptions(start, stop, replacement)

Options for replacing slices.

ReplaceSubstringOptions(pattern, replacement, *)

Options for replacing matched substrings.

RoundOptions([ndigits, round_mode])

Options for rounding numbers.

RoundTemporalOptions([multiple, unit, ...])

Options for rounding temporal values.

RoundToMultipleOptions([multiple, round_mode])

Options for rounding numbers to a multiple.


Options for run-end encoding.

ScalarAggregateOptions(*[, skip_nulls, ...])

Options for scalar aggregations.

ScalarAggregateOptions(*[, skip_nulls, ...])

Options for scalar aggregations.

SelectKOptions(k, sort_keys)

Options for top/bottom k-selection.

SetLookupOptions(value_set, *[, skip_nulls])

Options for the is_in and index_in functions.

SliceOptions(start[, stop, step])

Options for slicing.

SortOptions([sort_keys, null_placement])

Options for the sort_indices function.

SplitOptions(*[, max_splits, reverse])

Options for splitting on whitespace.

SplitPatternOptions(pattern, *[, ...])

Options for splitting on a string pattern.

StrftimeOptions([format, locale])

Options for the strftime function.

StrptimeOptions(format, unit[, error_is_null])

Options for the strptime function.


Options for the struct_field function.

TakeOptions(*[, boundscheck])

Options for the take and array_take functions.

TDigestOptions([q, delta, buffer_size, ...])

Options for the tdigest function.

TDigestOptions([q, delta, buffer_size, ...])

Options for the tdigest function.


Options for trimming characters from strings.

VarianceOptions(*[, ddof, skip_nulls, min_count])

Options for the variance and stddev functions.

WeekOptions(*[, week_starts_monday, ...])

Options for the week function.

User-Defined Functions#

register_scalar_function(func, ...[, ...])

Register a user-defined scalar function.


Per-invocation function context/state.