#pragma once

#include <optional>

#include <string>

#include <utility>

#include "arrow/compute/function.h"

#include "arrow/compute/type_fwd.h"

#include "arrow/datum.h"

#include "arrow/result.h"

#include "arrow/util/macros.h"

#include "arrow/util/visibility.h"

namespace arrow {

namespace compute {

class ARROW_EXPORT ArithmeticOptions : public FunctionOptions {

public:

explicit ArithmeticOptions(bool check_overflow = false);

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

bool check_overflow;

};

class ARROW_EXPORT ElementWiseAggregateOptions : public FunctionOptions {

public:

explicit ElementWiseAggregateOptions(bool skip_nulls = true);

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

static ElementWiseAggregateOptions Defaults() { return ElementWiseAggregateOptions{}; }

bool skip_nulls;

};

enum class RoundMode : int8_t {

};

class ARROW_EXPORT RoundOptions : public FunctionOptions {

public:

explicit RoundOptions(int64_t ndigits = 0,

RoundMode round_mode = RoundMode::HALF_TO_EVEN);

static constexpr char const kTypeName[] = "RoundOptions";

static RoundOptions Defaults() { return RoundOptions(); }

/// Rounding precision (number of digits to round to)

int64_t ndigits;

/// Rounding and tie-breaking mode

RoundMode round_mode;

};

class ARROW_EXPORT RoundBinaryOptions : public FunctionOptions {

public:

explicit RoundBinaryOptions(RoundMode round_mode = RoundMode::HALF_TO_EVEN);

static constexpr char const kTypeName[] = "RoundBinaryOptions";

static RoundBinaryOptions Defaults() { return RoundBinaryOptions(); }

/// Rounding and tie-breaking mode

RoundMode round_mode;

};

enum class CalendarUnit : int8_t {

};

class ARROW_EXPORT RoundTemporalOptions : public FunctionOptions {

public:

explicit RoundTemporalOptions(int multiple = 1, CalendarUnit unit = CalendarUnit::DAY,

bool week_starts_monday = true,

bool ceil_is_strictly_greater = false,

bool calendar_based_origin = false);

static constexpr char const kTypeName[] = "RoundTemporalOptions";

static RoundTemporalOptions Defaults() { return RoundTemporalOptions(); }

/// Number of units to round to

int multiple;

/// The unit used for rounding of time

CalendarUnit unit;

/// What day does the week start with (Monday=true, Sunday=false)

bool week_starts_monday;

/// Enable this flag to return a rounded value that is strictly greater than the input.

/// For example: ceiling 1970-01-01T00:00:00 to 3 hours would yield 1970-01-01T03:00:00

/// if set to true and 1970-01-01T00:00:00 if set to false.

/// This applies for ceiling only.

bool ceil_is_strictly_greater;

/// By default time is rounded to a multiple of units since 1970-01-01T00:00:00.

/// By setting calendar_based_origin to true, time will be rounded to a number

/// of units since the last greater calendar unit.

/// For example: rounding to a multiple of days since the beginning of the month or

/// to hours since the beginning of the day.

/// Exceptions: week and quarter are not used as greater units, therefore days will

/// will be rounded to the beginning of the month not week. Greater unit of week

/// is year.

/// Note that ceiling and rounding might change sorting order of an array near greater

/// unit change. For example rounding YYYY-mm-dd 23:00:00 to 5 hours will ceil and

/// round to YYYY-mm-dd+1 01:00:00 and floor to YYYY-mm-dd 20:00:00. On the other hand

/// YYYY-mm-dd+1 00:00:00 will ceil, round and floor to YYYY-mm-dd+1 00:00:00. This

/// can break the order of an already ordered array.

bool calendar_based_origin;

};

class ARROW_EXPORT RoundToMultipleOptions : public FunctionOptions {

public:

explicit RoundToMultipleOptions(double multiple = 1.0,

RoundMode round_mode = RoundMode::HALF_TO_EVEN);

explicit RoundToMultipleOptions(std::shared_ptr<Scalar> multiple,

RoundMode round_mode = RoundMode::HALF_TO_EVEN);

static constexpr char const kTypeName[] = "RoundToMultipleOptions";

static RoundToMultipleOptions Defaults() { return RoundToMultipleOptions(); }

/// Rounding scale (multiple to round to).

///

/// Should be a positive numeric scalar of a type compatible with the

/// argument to be rounded. The cast kernel is used to convert the rounding

/// multiple to match the result type.

std::shared_ptr<Scalar> multiple;

/// Rounding and tie-breaking mode

RoundMode round_mode;

};

class ARROW_EXPORT JoinOptions : public FunctionOptions {

public:

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

enum NullHandlingBehavior {

};

explicit JoinOptions(NullHandlingBehavior null_handling = EMIT_NULL,

std::string null_replacement = "");

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

static JoinOptions Defaults() { return JoinOptions(); }

NullHandlingBehavior null_handling;

std::string null_replacement;

};

class ARROW_EXPORT MatchSubstringOptions : public FunctionOptions {

public:

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

MatchSubstringOptions();

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

/// The exact substring (or regex, depending on kernel) to look for inside input values.

std::string pattern;

/// Whether to perform a case-insensitive match.

bool ignore_case;

};

class ARROW_EXPORT SplitOptions : public FunctionOptions {

public:

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

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

/// Maximum number of splits allowed, or unlimited when -1

int64_t max_splits;

/// Start splitting from the end of the string (only relevant when max_splits != -1)

bool reverse;

};

class ARROW_EXPORT SplitPatternOptions : public FunctionOptions {

public:

explicit SplitPatternOptions(std::string pattern, int64_t max_splits = -1,

bool reverse = false);

SplitPatternOptions();

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

/// The exact substring to split on.

std::string pattern;

/// Maximum number of splits allowed, or unlimited when -1

int64_t max_splits;

/// Start splitting from the end of the string (only relevant when max_splits != -1)

bool reverse;

};

class ARROW_EXPORT ReplaceSliceOptions : public FunctionOptions {

public:

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

ReplaceSliceOptions();

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

/// Index to start slicing at

int64_t start;

/// Index to stop slicing at

int64_t stop;

/// String to replace the slice with

std::string replacement;

};

class ARROW_EXPORT ReplaceSubstringOptions : public FunctionOptions {

public:

explicit ReplaceSubstringOptions(std::string pattern, std::string replacement,

int64_t max_replacements = -1);

ReplaceSubstringOptions();

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

/// Pattern to match, literal, or regular expression depending on which kernel is used

std::string pattern;

/// String to replace the pattern with

std::string replacement;

/// Max number of substrings to replace (-1 means unbounded)

int64_t max_replacements;

};

class ARROW_EXPORT ExtractRegexOptions : public FunctionOptions {

public:

explicit ExtractRegexOptions(std::string pattern);

ExtractRegexOptions();

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

/// Regular expression with named capture fields

std::string pattern;

};

class ARROW_EXPORT SetLookupOptions : public FunctionOptions {

public:

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

SetLookupOptions();

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

/// The set of values to look up input values into.

Datum value_set;

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

bool skip_nulls;

};

class ARROW_EXPORT StructFieldOptions : public FunctionOptions {

public:

explicit StructFieldOptions(std::vector<int> indices);

explicit StructFieldOptions(std::initializer_list<int>);

explicit StructFieldOptions(FieldRef field_ref);

StructFieldOptions();

static constexpr char const kTypeName[] = "StructFieldOptions";

/// The FieldRef specifying what to extract from struct or union.

FieldRef field_ref;

};

class ARROW_EXPORT StrptimeOptions : public FunctionOptions {

public:

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

bool error_is_null = false);

StrptimeOptions();

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

/// The desired format string.

std::string format;

/// The desired time resolution

TimeUnit::type unit;

/// Return null on parsing errors if true or raise if false

bool error_is_null;

};

class ARROW_EXPORT StrftimeOptions : public FunctionOptions {

public:

explicit StrftimeOptions(std::string format, std::string locale = "C");

StrftimeOptions();

static constexpr char const kTypeName[] = "StrftimeOptions";

static constexpr const char* kDefaultFormat = "%Y-%m-%dT%H:%M:%S";

/// The desired format string.

std::string format;

/// The desired output locale string.

std::string locale;

};

class ARROW_EXPORT PadOptions : public FunctionOptions {

public:

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

PadOptions();

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

/// The desired string length.

int64_t width;

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

std::string padding;

};

class ARROW_EXPORT TrimOptions : public FunctionOptions {

public:

explicit TrimOptions(std::string characters);

TrimOptions();

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

/// The individual characters to be trimmed from the string.

std::string characters;

};

class ARROW_EXPORT SliceOptions : public FunctionOptions {

public:

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

int64_t step = 1);

SliceOptions();

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

int64_t start, stop, step;

};

class ARROW_EXPORT ListSliceOptions : public FunctionOptions {

public:

explicit ListSliceOptions(int64_t start, std::optional<int64_t> stop = std::nullopt,

int64_t step = 1,

std::optional<bool> return_fixed_size_list = std::nullopt);

ListSliceOptions();

static constexpr char const kTypeName[] = "ListSliceOptions";

/// The start of list slicing.

int64_t start;

/// Optional stop of list slicing. If not set, then slice to end. (NotImplemented)

std::optional<int64_t> stop;

/// Slicing step

int64_t step;

// Whether to return a FixedSizeListArray. If true _and_ stop is after

// a list element's length, nulls will be appended to create the requested slice size.

// Default of `nullopt` will return whatever type it got in.

std::optional<bool> return_fixed_size_list;

};

class ARROW_EXPORT NullOptions : public FunctionOptions {

public:

explicit NullOptions(bool nan_is_null = false);

static constexpr char const kTypeName[] = "NullOptions";

static NullOptions Defaults() { return NullOptions{}; }

bool nan_is_null;

};

enum CompareOperator : int8_t {

};

struct ARROW_EXPORT CompareOptions {

explicit CompareOptions(CompareOperator op) : op(op) {}

CompareOptions() : CompareOptions(CompareOperator::EQUAL) {}

enum CompareOperator op;

};

class ARROW_EXPORT MakeStructOptions : public FunctionOptions {

public:

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

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

/// Names for wrapped columns

std::vector<std::string> field_names;

/// Nullability bits for wrapped columns

std::vector<bool> field_nullability;

/// Metadata attached to wrapped columns

std::vector<std::shared_ptr<const KeyValueMetadata>> field_metadata;

};

struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {

public:

explicit DayOfWeekOptions(bool count_from_zero = true, uint32_t week_start = 1);

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

static DayOfWeekOptions Defaults() { return DayOfWeekOptions(); }

/// Number days from 0 if true and from 1 if false

bool count_from_zero;

/// What day does the week start with (Monday=1, Sunday=7).

/// The numbering is unaffected by the count_from_zero parameter.

uint32_t week_start;

};

struct ARROW_EXPORT AssumeTimezoneOptions : public FunctionOptions {

public:

/// \brief How to interpret ambiguous local times that can be interpreted as

/// multiple instants (normally two) due to DST shifts.

///

/// AMBIGUOUS_EARLIEST emits the earliest instant amongst possible interpretations.

/// AMBIGUOUS_LATEST emits the latest instant amongst possible interpretations.

enum Ambiguous { AMBIGUOUS_RAISE, AMBIGUOUS_EARLIEST, AMBIGUOUS_LATEST };

/// \brief How to handle local times that do not exist due to DST shifts.

///

/// NONEXISTENT_EARLIEST emits the instant "just before" the DST shift instant

/// in the given timestamp precision (for example, for a nanoseconds precision

/// timestamp, this is one nanosecond before the DST shift instant).

/// NONEXISTENT_LATEST emits the DST shift instant.

enum Nonexistent { NONEXISTENT_RAISE, NONEXISTENT_EARLIEST, NONEXISTENT_LATEST };

explicit AssumeTimezoneOptions(std::string timezone,

Ambiguous ambiguous = AMBIGUOUS_RAISE,

Nonexistent nonexistent = NONEXISTENT_RAISE);

AssumeTimezoneOptions();

static constexpr char const kTypeName[] = "AssumeTimezoneOptions";

/// Timezone to convert timestamps from

std::string timezone;

/// How to interpret ambiguous local times (due to DST shifts)

Ambiguous ambiguous;

/// How to interpret non-existent local times (due to DST shifts)

Nonexistent nonexistent;

};

struct ARROW_EXPORT WeekOptions : public FunctionOptions {

public:

explicit WeekOptions(bool week_starts_monday = true, bool count_from_zero = false,

bool first_week_is_fully_in_year = false);

static constexpr char const kTypeName[] = "WeekOptions";

static WeekOptions Defaults() { return WeekOptions{}; }

static WeekOptions ISODefaults() {

}

static WeekOptions USDefaults() {

}

/// What day does the week start with (Monday=true, Sunday=false)

bool week_starts_monday;

/// Dates from current year that fall into last ISO week of the previous year return

/// 0 if true and 52 or 53 if false.

bool count_from_zero;

/// Must the first week be fully in January (true), or is a week that begins on

/// December 29, 30, or 31 considered to be the first week of the new year (false)?

bool first_week_is_fully_in_year;

};

struct ARROW_EXPORT Utf8NormalizeOptions : public FunctionOptions {

public:

enum Form { NFC, NFKC, NFD, NFKD };

explicit Utf8NormalizeOptions(Form form = NFC);

static Utf8NormalizeOptions Defaults() { return Utf8NormalizeOptions(); }

static constexpr char const kTypeName[] = "Utf8NormalizeOptions";

/// The Unicode normalization form to apply

Form form;

};

class ARROW_EXPORT RandomOptions : public FunctionOptions {

public:

enum Initializer { SystemRandom, Seed };

static RandomOptions FromSystemRandom() { return RandomOptions{SystemRandom, 0}; }

static RandomOptions FromSeed(uint64_t seed) { return RandomOptions{Seed, seed}; }

RandomOptions(Initializer initializer, uint64_t seed);

RandomOptions();

static constexpr char const kTypeName[] = "RandomOptions";

static RandomOptions Defaults() { return RandomOptions(); }

/// The type of initialization for random number generation - system or provided seed.

Initializer initializer;

/// The seed value used to initialize the random number generation.

uint64_t seed;

};

class ARROW_EXPORT MapLookupOptions : public FunctionOptions {

public:

enum Occurrence {

};

explicit MapLookupOptions(std::shared_ptr<Scalar> query_key, Occurrence occurrence);

MapLookupOptions();

constexpr static char const kTypeName[] = "MapLookupOptions";

/// The key to lookup in the map

std::shared_ptr<Scalar> query_key;

/// Whether to return the first, last, or all matching values

Occurrence occurrence;

};

Result<Datum> AbsoluteValue(const Datum& arg,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Add(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Subtract(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Multiply(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Divide(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Negate(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Power(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Exp(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> ShiftLeft(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> ShiftRight(const Datum& left, const Datum& right,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Sin(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Cos(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Asin(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Acos(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Tan(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Atan(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> Atan2(const Datum& y, const Datum& x, ExecContext* ctx = NULLPTR);

Result<Datum> Ln(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Log10(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Log2(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Log1p(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Logb(const Datum& arg, const Datum& base,

ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Sqrt(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),

ExecContext* ctx = NULLPTR);

Result<Datum> Floor(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> Ceil(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> Trunc(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> MaxElementWise(

const std::vector<Datum>& args,

ElementWiseAggregateOptions options = ElementWiseAggregateOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> MinElementWise(

const std::vector<Datum>& args,

ElementWiseAggregateOptions options = ElementWiseAggregateOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> Sign(const Datum& arg, ExecContext* ctx = NULLPTR);

Result<Datum> Round(const Datum& arg, RoundOptions options = RoundOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> RoundBinary(const Datum& arg1, const Datum& arg2,

RoundBinaryOptions options = RoundBinaryOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> RoundToMultiple(

const Datum& arg, RoundToMultipleOptions options = RoundToMultipleOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> CeilTemporal(

const Datum& arg, RoundTemporalOptions options = RoundTemporalOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> FloorTemporal(

const Datum& arg, RoundTemporalOptions options = RoundTemporalOptions::Defaults(),

ExecContext* ctx = NULLPTR);

Result<Datum> RoundTemporal(

const Datum& arg, RoundTemporalOptions options = RoundTemporalOptions::Defaults(),

ExecContext* ctx = NULLPTR);

ARROW_DEPRECATED("Deprecated in 5.0.0. Use each compare function directly")

Result<Datum> Compare(const Datum& left, const Datum& right, CompareOptions options,

ExecContext* ctx = NULLPTR);

Result<Datum> Invert(const Datum& value, ExecContext* ctx = NULLPTR);