# Utilities¶

## Decimal Numbers¶

class BasicDecimal128 : public arrow::GenericBasicDecimal<BasicDecimal128, 128>

Represents a signed 128-bit integer in two’s complement.

This class is also compiled into LLVM IR - so, it should not have cpp references like streams and boost.

Subclassed by arrow::Decimal128

Public Functions

inline constexpr BasicDecimal128(int64_t high, uint64_t low) noexcept

Create a BasicDecimal128 from the two’s complement representation.

template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && (sizeof(T) <= sizeof(uint64_t)), T>::type>
inline constexpr BasicDecimal128(T value) noexcept

Convert any integer value into a BasicDecimal128.

BasicDecimal128 &Negate()

Negate the current value (in-place)

BasicDecimal128 &Abs()

Absolute value (in-place)

BasicDecimal128 &operator+=(const BasicDecimal128 &right)

Add a number to this one. The result is truncated to 128 bits.

BasicDecimal128 &operator-=(const BasicDecimal128 &right)

Subtract a number from this one. The result is truncated to 128 bits.

BasicDecimal128 &operator*=(const BasicDecimal128 &right)

Multiply this number by another number. The result is truncated to 128 bits.

DecimalStatus Divide(const BasicDecimal128 &divisor, BasicDecimal128 *result, BasicDecimal128 *remainder) const

Divide this number by right and return the result.

This operation is not destructive. The answer rounds to zero. Signs work like: 21 / 5 -> 4, 1 -21 / 5 -> -4, -1 21 / -5 -> -4, 1 -21 / -5 -> 4, -1

Parameters:
• divisor[in] the number to divide by

• result[out] the quotient

• remainder[out] the remainder after the division

BasicDecimal128 &operator/=(const BasicDecimal128 &right)

In-place division.

BasicDecimal128 &operator|=(const BasicDecimal128 &right)

Bitwise “or” between two BasicDecimal128.

BasicDecimal128 &operator&=(const BasicDecimal128 &right)

Bitwise “and” between two BasicDecimal128.

BasicDecimal128 &operator<<=(uint32_t bits)

Shift left by the given number of bits.

BasicDecimal128 &operator>>=(uint32_t bits)

Shift right by the given number of bits. Negative values will.

inline constexpr int64_t high_bits() const

Get the high bits of the two’s complement representation of the number.

inline constexpr uint64_t low_bits() const

Get the low bits of the two’s complement representation of the number.

void GetWholeAndFraction(int32_t scale, BasicDecimal128 *whole, BasicDecimal128 *fraction) const

separate the integer and fractional parts for the given scale.

DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, BasicDecimal128 *out) const

Convert BasicDecimal128 from one scale to another.

BasicDecimal128 IncreaseScaleBy(int32_t increase_by) const

Scale up.

BasicDecimal128 ReduceScaleBy(int32_t reduce_by, bool round = true) const

Scale down.

• If ‘round’ is true, the right-most digits are dropped and the result value is rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits (>= 10^reduce_by / 2).

• If ‘round’ is false, the right-most digits are simply dropped.

bool FitsInPrecision(int32_t precision) const

Whether this number fits in the given precision.

Return true if the number of significant digits is less or equal to `precision`.

count the number of leading binary zeroes.

inline constexpr GenericBasicDecimal() noexcept

Empty constructor creates a decimal with a value of 0.

inline constexpr GenericBasicDecimal(const WordArray &array) noexcept

Create a decimal from the two’s complement representation.

Input array is assumed to be in native endianness.

inline GenericBasicDecimal(LittleEndianArrayTag, const WordArray &array) noexcept

Create a decimal from the two’s complement representation.

Input array is assumed to be in little endianness, with native endian elements.

inline explicit GenericBasicDecimal(const uint8_t *bytes)

Create a decimal from an array of bytes.

Bytes are assumed to be in native-endian byte order.

Public Static Functions

static BasicDecimal128 Abs(const BasicDecimal128 &left)

Absolute value.

static const BasicDecimal128 &GetScaleMultiplier(int32_t scale)

Scale multiplier for given scale value.

static const BasicDecimal128 &GetHalfScaleMultiplier(int32_t scale)

Half-scale multiplier for given scale value.

static const BasicDecimal128 &GetMaxValue()

Get the maximum valid unscaled decimal value.

static BasicDecimal128 GetMaxValue(int32_t precision)

Get the maximum valid unscaled decimal value for the given precision.

static inline constexpr BasicDecimal128 GetMaxSentinel()

Get the maximum decimal value (is not a valid value).

static inline constexpr BasicDecimal128 GetMinSentinel()

Get the minimum decimal value (is not a valid value).

class Decimal128 : public arrow::BasicDecimal128

Represents a signed 128-bit integer in two’s complement.

Calculations wrap around and overflow is ignored. The max decimal precision that can be safely represented is 38 significant digits.

For a discussion of the algorithms, look at Knuth’s volume 2, Semi-numerical Algorithms section 4.3.1.

Adapted from the Apache ORC C++ implementation

The implementation is split into two parts :

1. BasicDecimal128

• can be safely compiled to IR without references to libstdc++.

2. Decimal128

• has additional functionality on top of BasicDecimal128 to deal with strings and streams.

Public Functions

inline constexpr Decimal128(const BasicDecimal128 &value) noexcept

constructor creates a Decimal128 from a BasicDecimal128.

explicit Decimal128(const std::string &value)

Parse the number from a base 10 string representation.

inline constexpr Decimal128() noexcept

Empty constructor creates a Decimal128 with a value of 0.

inline Result<std::pair<Decimal128, Decimal128>> Divide(const Decimal128 &divisor) const

Divide this number by right and return the result.

This operation is not destructive. The answer rounds to zero. Signs work like: 21 / 5 -> 4, 1 -21 / 5 -> -4, -1 21 / -5 -> -4, 1 -21 / -5 -> 4, -1

Parameters:

divisor[in] the number to divide by

Returns:

the pair of the quotient and the remainder

std::string ToString(int32_t scale) const

Convert the Decimal128 value to a base 10 decimal string with the given scale.

std::string ToIntegerString() const

Convert the value to an integer string.

explicit operator int64_t() const

Cast this value to an int64_t.

inline Result<Decimal128> Rescale(int32_t original_scale, int32_t new_scale) const

Convert Decimal128 from one scale to another.

template<typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
inline Result<T> ToInteger() const

Convert to a signed integer.

template<typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
inline Status ToInteger(T *out) const

Convert to a signed integer.

float ToFloat(int32_t scale) const

Convert to a floating-point number (scaled)

double ToDouble(int32_t scale) const

Convert to a floating-point number (scaled)

template<typename T>
inline T ToReal(int32_t scale) const

Convert to a floating-point number (scaled)

Public Static Functions

static Status FromString(std::string_view s, Decimal128 *out, int32_t *precision, int32_t *scale = NULLPTR)

Convert a decimal string to a Decimal128 value, optionally including precision and scale if they’re passed in and not null.

static Result<Decimal128> FromBigEndian(const uint8_t *data, int32_t length)

Convert from a big-endian byte representation.

The length must be between 1 and 16.

Returns:

error status if the length is an invalid value

template<>
struct ToRealConversion<double>
template<>
struct ToRealConversion<float>
class BasicDecimal256 : public arrow::GenericBasicDecimal<BasicDecimal256, 256>

Subclassed by arrow::Decimal256

Public Functions

template<typename T, typename = typename std::enable_if<std::is_integral<T>::value && (sizeof(T) <= sizeof(uint64_t)), T>::type>
inline constexpr BasicDecimal256(T value) noexcept

Convert any integer value into a BasicDecimal256.

BasicDecimal256 &Negate()

Negate the current value (in-place)

BasicDecimal256 &Abs()

Absolute value (in-place)

BasicDecimal256 &operator+=(const BasicDecimal256 &right)

Add a number to this one. The result is truncated to 256 bits.

BasicDecimal256 &operator-=(const BasicDecimal256 &right)

Subtract a number from this one. The result is truncated to 256 bits.

inline uint64_t low_bits() const

Get the lowest bits of the two’s complement representation of the number.

DecimalStatus Rescale(int32_t original_scale, int32_t new_scale, BasicDecimal256 *out) const

Convert BasicDecimal256 from one scale to another.

BasicDecimal256 IncreaseScaleBy(int32_t increase_by) const

Scale up.

BasicDecimal256 ReduceScaleBy(int32_t reduce_by, bool round = true) const

Scale down.

• If ‘round’ is true, the right-most digits are dropped and the result value is rounded up (+1 for positive, -1 for negative) based on the value of the dropped digits (>= 10^reduce_by / 2).

• If ‘round’ is false, the right-most digits are simply dropped.

bool FitsInPrecision(int32_t precision) const

Whether this number fits in the given precision.

Return true if the number of significant digits is less or equal to `precision`.

BasicDecimal256 &operator*=(const BasicDecimal256 &right)

Multiply this number by another number. The result is truncated to 256 bits.

DecimalStatus Divide(const BasicDecimal256 &divisor, BasicDecimal256 *result, BasicDecimal256 *remainder) const

Divide this number by right and return the result.

This operation is not destructive. The answer rounds to zero. Signs work like: 21 / 5 -> 4, 1 -21 / 5 -> -4, -1 21 / -5 -> -4, 1 -21 / -5 -> 4, -1

Parameters:
• divisor[in] the number to divide by

• result[out] the quotient

• remainder[out] the remainder after the division

BasicDecimal256 &operator<<=(uint32_t bits)

Shift left by the given number of bits.

BasicDecimal256 &operator/=(const BasicDecimal256 &right)

In-place division.

inline constexpr GenericBasicDecimal() noexcept

Empty constructor creates a decimal with a value of 0.

inline constexpr GenericBasicDecimal(const WordArray &array) noexcept

Create a decimal from the two’s complement representation.

Input array is assumed to be in native endianness.

inline GenericBasicDecimal(LittleEndianArrayTag, const WordArray &array) noexcept

Create a decimal from the two’s complement representation.

Input array is assumed to be in little endianness, with native endian elements.

inline explicit GenericBasicDecimal(const uint8_t *bytes)

Create a decimal from an array of bytes.

Bytes are assumed to be in native-endian byte order.

Public Static Functions

static BasicDecimal256 Abs(const BasicDecimal256 &left)

Absolute value.

static const BasicDecimal256 &GetScaleMultiplier(int32_t scale)

Scale multiplier for given scale value.

static const BasicDecimal256 &GetHalfScaleMultiplier(int32_t scale)

Half-scale multiplier for given scale value.

static BasicDecimal256 GetMaxValue(int32_t precision)

Get the maximum valid unscaled decimal value for the given precision.

static inline constexpr BasicDecimal256 GetMaxSentinel()

Get the maximum decimal value (is not a valid value).

static inline constexpr BasicDecimal256 GetMinSentinel()

Get the minimum decimal value (is not a valid value).

class Decimal256 : public arrow::BasicDecimal256

Represents a signed 256-bit integer in two’s complement.

The max decimal precision that can be safely represented is 76 significant digits.

The implementation is split into two parts :

1. BasicDecimal256

• can be safely compiled to IR without references to libstdc++.

2. Decimal256

• (TODO) has additional functionality on top of BasicDecimal256 to deal with strings and streams.

Public Functions

inline constexpr Decimal256(const BasicDecimal256 &value) noexcept

constructor creates a Decimal256 from a BasicDecimal256.

explicit Decimal256(const std::string &value)

Parse the number from a base 10 string representation.

inline constexpr Decimal256() noexcept

Empty constructor creates a Decimal256 with a value of 0.

std::string ToString(int32_t scale) const

Convert the Decimal256 value to a base 10 decimal string with the given scale.

std::string ToIntegerString() const

Convert the value to an integer string.

inline Result<Decimal256> Rescale(int32_t original_scale, int32_t new_scale) const

Convert Decimal256 from one scale to another.

inline Result<std::pair<Decimal256, Decimal256>> Divide(const Decimal256 &divisor) const

Divide this number by right and return the result.

This operation is not destructive. The answer rounds to zero. Signs work like: 21 / 5 -> 4, 1 -21 / 5 -> -4, -1 21 / -5 -> -4, 1 -21 / -5 -> 4, -1

Parameters:

divisor[in] the number to divide by

Returns:

the pair of the quotient and the remainder

float ToFloat(int32_t scale) const

Convert to a floating-point number (scaled).

May return infinity in case of overflow.

double ToDouble(int32_t scale) const

Convert to a floating-point number (scaled)

template<typename T>
inline T ToReal(int32_t scale) const

Convert to a floating-point number (scaled)

Public Static Functions

static Status FromString(std::string_view s, Decimal256 *out, int32_t *precision, int32_t *scale = NULLPTR)

Convert a decimal string to a Decimal256 value, optionally including precision and scale if they’re passed in and not null.

static Result<Decimal256> FromBigEndian(const uint8_t *data, int32_t length)

Convert from a big-endian byte representation.

The length must be between 1 and 32.

Returns:

error status if the length is an invalid value

template<>
struct ToRealConversion<double>
template<>
struct ToRealConversion<float>

## Iterators¶

template<typename T>
class Iterator

A generic Iterator that can return errors.

Public Functions

template<typename Wrapped>
inline explicit Iterator(Wrapped has_next)

Iterator may be constructed from any type which has a member function with signature Result<T> Next(); End of iterator is signalled by returning IteratorTraits<T>::End();.

The argument is moved or copied to the heap and kept in a unique_ptr<void>. Only its destructor and its Next method (which are stored in function pointers) are referenced after construction.

This approach is used to dodge MSVC linkage hell (ARROW-6244, ARROW-6558) when using an abstract template base class: instead of being inlined as usual for a template function the base’s virtual destructor will be exported, leading to multiple definition errors when linking to any other TU where the base is instantiated.

inline Result<T> Next()

Return the next element of the sequence, IterationTraits<T>::End() when the iteration is completed.

Calling this on a default constructed Iterator will result in undefined behavior.

template<typename Visitor>
inline Status Visit(Visitor &&visitor)

Pass each element of the sequence to a visitor.

Will return any error status returned by the visitor, terminating iteration.

inline bool Equals(const Iterator &other) const

Iterators will only compare equal if they are both null.

Equality comparability is required to make an Iterator of Iterators (to check for the end condition).

inline Result<std::vector<T>> ToVector()

Move every element of this iterator into a vector.

class RangeIterator
template<typename T>
class VectorIterator

Simple iterator which yields the elements of a std::vector.

## Compression¶

enum arrow::Compression::type

Compression algorithm.

Values:

enumerator UNCOMPRESSED
enumerator SNAPPY
enumerator GZIP
enumerator BROTLI
enumerator ZSTD
enumerator LZ4
enumerator LZ4_FRAME
enumerator LZO
enumerator BZ2
class Codec

Compression codec.

Public Functions

virtual int minimum_compression_level() const = 0

Return the smallest supported compression level.

virtual int maximum_compression_level() const = 0

Return the largest supported compression level.

virtual int default_compression_level() const = 0

Return the default compression level.

virtual Result<int64_t> Decompress(int64_t input_len, const uint8_t *input, int64_t output_buffer_len, uint8_t *output_buffer) = 0

One-shot decompression function.

output_buffer_len must be correct and therefore be obtained in advance. The actual decompressed length is returned.

Note

One-shot decompression is not always compatible with streaming compression. Depending on the codec (e.g. LZ4), different formats may be used.

virtual Result<int64_t> Compress(int64_t input_len, const uint8_t *input, int64_t output_buffer_len, uint8_t *output_buffer) = 0

One-shot compression function.

output_buffer_len must first have been computed using MaxCompressedLen(). The actual compressed length is returned.

Note

One-shot compression is not always compatible with streaming decompression. Depending on the codec (e.g. LZ4), different formats may be used.

virtual Result<std::shared_ptr<Compressor>> MakeCompressor() = 0

Create a streaming compressor instance.

virtual Result<std::shared_ptr<Decompressor>> MakeDecompressor() = 0

Create a streaming compressor instance.

virtual Compression::type compression_type() const = 0

This Codec’s compression type.

inline const std::string &name() const

The name of this Codec’s compression type.

inline virtual int compression_level() const

This Codec’s compression level, if applicable.

Public Static Functions

static int UseDefaultCompressionLevel()

Return special value to indicate that a codec implementation should use its default compression level.

static const std::string &GetCodecAsString(Compression::type t)

Return a string name for compression type.

static Result<Compression::type> GetCompressionType(const std::string &name)

Return compression type for name (all lower case)

static Result<std::unique_ptr<Codec>> Create(Compression::type codec, int compression_level = kUseDefaultCompressionLevel)

Create a codec for the given compression algorithm.

static bool IsAvailable(Compression::type codec)

Return true if support for indicated codec has been enabled.

static bool SupportsCompressionLevel(Compression::type codec)

Return true if indicated codec supports setting a compression level.

static Result<int> MinimumCompressionLevel(Compression::type codec)

Return the smallest supported compression level for the codec Note: This function creates a temporary Codec instance.

static Result<int> MaximumCompressionLevel(Compression::type codec)

Return the largest supported compression level for the codec Note: This function creates a temporary Codec instance.

static Result<int> DefaultCompressionLevel(Compression::type codec)

Return the default compression level Note: This function creates a temporary Codec instance.

class Compressor

Streaming compressor interface.

Public Functions

virtual Result<CompressResult> Compress(int64_t input_len, const uint8_t *input, int64_t output_len, uint8_t *output) = 0

Compress some input.

If bytes_read is 0 on return, then a larger output buffer should be supplied.

virtual Result<FlushResult> Flush(int64_t output_len, uint8_t *output) = 0

Flush part of the compressed output.

If should_retry is true on return, Flush() should be called again with a larger buffer.

virtual Result<EndResult> End(int64_t output_len, uint8_t *output) = 0

End compressing, doing whatever is necessary to end the stream.

If should_retry is true on return, End() should be called again with a larger buffer. Otherwise, the Compressor should not be used anymore.

End() implies Flush().

struct CompressResult
struct EndResult
struct FlushResult
class Decompressor

Streaming decompressor interface.

Public Functions

virtual Result<DecompressResult> Decompress(int64_t input_len, const uint8_t *input, int64_t output_len, uint8_t *output) = 0

Decompress some input.

If need_more_output is true on return, a larger output buffer needs to be supplied.

virtual bool IsFinished() = 0

Return whether the compressed stream is finished.

This is a heuristic. If true is returned, then it is guaranteed that the stream is finished. If false is returned, however, it may simply be that the underlying library isn’t able to provide the information.

virtual Status Reset() = 0

Reinitialize decompressor, making it ready for a new compressed stream.

struct DecompressResult

## Visitors¶

template<typename VISITOR, typename ...ARGS>
inline Status arrow::VisitTypeInline(const DataType &type, VISITOR *visitor, ARGS&&... args)

Calls `visitor` with the corresponding concrete type class.

A visitor is a type that implements specialized logic for each Arrow type. Example usage:

```class ExampleVisitor {
arrow::Status Visit(const arrow::Int32Type& type) { ... }
arrow::Status Visit(const arrow::Int64Type& type) { ... }
...
}
ExampleVisitor visitor;
VisitTypeInline(some_type, &visitor);
```
Template Parameters:
• VISITOR – Visitor type that implements Visit() for all Arrow types.

• ARGS – Additional arguments, if any, will be passed to the Visit function after the `type` argument

Returns:

Status

template<typename VISITOR, typename ...ARGS>
inline Status arrow::VisitTypeIdInline(Type::type id, VISITOR *visitor, ARGS&&... args)

Calls `visitor` with a nullptr of the corresponding concrete type class.

Template Parameters:
• VISITOR – Visitor type that implements Visit() for all Arrow types.

• ARGS – Additional arguments, if any, will be passed to the Visit function after the `type` argument

Returns:

Status

template<typename VISITOR, typename ...ARGS>
inline Status arrow::VisitScalarInline(const Scalar &scalar, VISITOR *visitor, ARGS&&... args)

Apply the visitors Visit() method specialized to the scalar type.

A visitor is a type that implements specialized logic for each Arrow type. Example usage:

```class ExampleVisitor {
arrow::Status Visit(arrow::Int32Scalar scalar) { ... }
arrow::Status Visit(arrow::Int64Scalar scalar) { ... }
...
}
ExampleVisitor visitor;
VisitScalarInline(some_scalar, &visitor);
```
Template Parameters:
• VISITOR – Visitor type that implements Visit() for all scalar types.

• ARGS – Additional arguments, if any, will be passed to the Visit function after the `scalar` argument

Returns:

Status

template<typename VISITOR, typename ...ARGS>
inline Status arrow::VisitArrayInline(const Array &array, VISITOR *visitor, ARGS&&... args)

Apply the visitors Visit() method specialized to the array type.

A visitor is a type that implements specialized logic for each Arrow type. Example usage:

```class ExampleVisitor {
arrow::Status Visit(arrow::NumericArray<Int32Type> arr) { ... }
arrow::Status Visit(arrow::NumericArray<Int64Type> arr) { ... }
...
}
ExampleVisitor visitor;
VisitArrayInline(some_array, &visitor);
```
Template Parameters:
• VISITOR – Visitor type that implements Visit() for all array types.

• ARGS – Additional arguments, if any, will be passed to the Visit function after the `arr` argument

Returns:

Status

## Type Traits¶

These types provide relationships between Arrow types at compile time. `TypeTraits` maps Arrow DataTypes to other types, and `CTypeTraits` maps C types to Arrow types.

### TypeTraits¶

Each specialized type defines the following associated types:

type TypeTraits::ArrayType

Corresponding Arrow array type

type TypeTraits::BuilderType

Corresponding array builder type

type TypeTraits::ScalarType

Corresponding Arrow scalar type

bool TypeTraits::is_parameter_free

Whether the type has any type parameters, such as field types in nested types or scale and precision in decimal types.

In addition, the following are defined for many but not all of the types:

type TypeTraits::CType

Corresponding C type. For example, `int64_t` for `Int64Array`.

type TypeTraits::TensorType

Corresponding Arrow tensor type

static inline constexpr int64_t bytes_required(int64_t elements)

Return the number of bytes required for given number of elements. Defined for types with a fixed size.

static inline std::shared_ptr<DataType> TypeTraits::type_singleton()

For types where is_parameter_free is true, returns an instance of the data type.

template<>
struct TypeTraits<NullType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = NullArray
using BuilderType = NullBuilder
using ScalarType = NullScalar

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<BooleanType>
#include <arrow/type_traits.h>

Subclassed by arrow::CTypeTraits< bool >

Public Types

using ArrayType = BooleanArray
using BuilderType = BooleanBuilder
using ScalarType = BooleanScalar
using CType = bool

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<Date64Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Date64Array
using BuilderType = Date64Builder
using ScalarType = Date64Scalar
using CType = Date64Type::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<Date32Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Date32Array
using BuilderType = Date32Builder
using ScalarType = Date32Scalar
using CType = Date32Type::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<TimestampType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = TimestampArray
using BuilderType = TimestampBuilder
using ScalarType = TimestampScalar
using CType = TimestampType::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<DurationType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = DurationArray
using BuilderType = DurationBuilder
using ScalarType = DurationScalar
using CType = DurationType::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<DayTimeIntervalType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = DayTimeIntervalArray
using BuilderType = DayTimeIntervalBuilder
using ScalarType = DayTimeIntervalScalar
using CType = DayTimeIntervalType::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<MonthDayNanoIntervalType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = MonthDayNanoIntervalArray
using BuilderType = MonthDayNanoIntervalBuilder
using ScalarType = MonthDayNanoIntervalScalar
using CType = MonthDayNanoIntervalType::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<MonthIntervalType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = MonthIntervalArray
using BuilderType = MonthIntervalBuilder
using ScalarType = MonthIntervalScalar
using CType = MonthIntervalType::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<Time32Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Time32Array
using BuilderType = Time32Builder
using ScalarType = Time32Scalar
using CType = Time32Type::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<Time64Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Time64Array
using BuilderType = Time64Builder
using ScalarType = Time64Scalar
using CType = Time64Type::c_type

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<HalfFloatType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = HalfFloatArray
using BuilderType = HalfFloatBuilder
using ScalarType = HalfFloatScalar
using TensorType = HalfFloatTensor

Public Static Functions

static inline constexpr int64_t bytes_required(int64_t elements)
static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<Decimal128Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Decimal128Array
using BuilderType = Decimal128Builder
using ScalarType = Decimal128Scalar
using CType = Decimal128

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<Decimal256Type>
#include <arrow/type_traits.h>

Public Types

using ArrayType = Decimal256Array
using BuilderType = Decimal256Builder
using ScalarType = Decimal256Scalar
using CType = Decimal256

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<BinaryType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = BinaryArray
using BuilderType = BinaryBuilder
using ScalarType = BinaryScalar
using OffsetType = Int32Type

Public Static Functions

static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<LargeBinaryType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = LargeBinaryArray
using BuilderType = LargeBinaryBuilder
using ScalarType = LargeBinaryScalar
using OffsetType = Int64Type

Public Static Functions

static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<FixedSizeBinaryType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = FixedSizeBinaryArray
using BuilderType = FixedSizeBinaryBuilder
using ScalarType = FixedSizeBinaryScalar
using OffsetType = Int32Type

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<StringType>
#include <arrow/type_traits.h>

Subclassed by arrow::CTypeTraits< std::string >

Public Types

using ArrayType = StringArray
using BuilderType = StringBuilder
using ScalarType = StringScalar
using OffsetType = Int32Type

Public Static Functions

static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<LargeStringType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = LargeStringArray
using BuilderType = LargeStringBuilder
using ScalarType = LargeStringScalar
using OffsetType = Int64Type

Public Static Functions

static inline std::shared_ptr<DataType> type_singleton()

Public Static Attributes

static constexpr bool is_parameter_free = true
template<>
struct TypeTraits<RunEndEncodedType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = RunEndEncodedArray
using BuilderType = RunEndEncodedBuilder
using ScalarType = RunEndEncodedScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<ListType>
#include <arrow/type_traits.h>

Subclassed by arrow::CTypeTraits< std::vector< CType > >

Public Types

using ArrayType = ListArray
using BuilderType = ListBuilder
using ScalarType = ListScalar
using OffsetType = Int32Type
using OffsetArrayType = Int32Array
using OffsetBuilderType = Int32Builder
using OffsetScalarType = Int32Scalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<LargeListType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = LargeListArray
using BuilderType = LargeListBuilder
using ScalarType = LargeListScalar
using OffsetType = Int64Type
using OffsetArrayType = Int64Array
using OffsetBuilderType = Int64Builder
using OffsetScalarType = Int64Scalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<MapType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = MapArray
using BuilderType = MapBuilder
using ScalarType = MapScalar
using OffsetType = Int32Type
using OffsetArrayType = Int32Array
using OffsetBuilderType = Int32Builder

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<FixedSizeListType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = FixedSizeListArray
using BuilderType = FixedSizeListBuilder
using ScalarType = FixedSizeListScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<StructType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = StructArray
using BuilderType = StructBuilder
using ScalarType = StructScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<SparseUnionType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = SparseUnionArray
using BuilderType = SparseUnionBuilder
using ScalarType = SparseUnionScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<DenseUnionType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = DenseUnionArray
using BuilderType = DenseUnionBuilder
using ScalarType = DenseUnionScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<DictionaryType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = DictionaryArray
using ScalarType = DictionaryScalar

Public Static Attributes

static constexpr bool is_parameter_free = false
template<>
struct TypeTraits<ExtensionType>
#include <arrow/type_traits.h>

Public Types

using ArrayType = ExtensionArray
using ScalarType = ExtensionScalar

Public Static Attributes

static constexpr bool is_parameter_free = false

### CTypeTraits¶

Each specialized type defines the following associated types:

type CTypeTraits::ArrowType

Corresponding Arrow type

template<>
struct CTypeTraits<std::string> : public arrow::TypeTraits<StringType>
#include <arrow/type_traits.h>

Subclassed by arrow::CTypeTraits< const char * >, arrow::CTypeTraits< const char(&)[N]>, arrow::stl::ConversionTraits< std::string >

Public Types

using ArrowType = StringType
template<>
struct CTypeTraits<const char*> : public arrow::CTypeTraits<std::string>
#include <arrow/type_traits.h>
template<size_t N>
struct CTypeTraits<const char (&)[N]> : public arrow::CTypeTraits<std::string>
#include <arrow/type_traits.h>
template<>
struct CTypeTraits<DayTimeIntervalType::DayMilliseconds> : public arrow::TypeTraits<DayTimeIntervalType>
#include <arrow/type_traits.h>

Public Types

using ArrowType = DayTimeIntervalType

### Type Predicates¶

Type predicates that can be used with templates. Predicates of the form `is_XXX` resolve to constant boolean values, while predicates of the form `enable_if_XXX` resolve to the second type parameter `R` if the first parameter `T` passes the test.

Example usage:

```template<typename TypeClass>
arrow::enable_if_number<TypeClass, RETURN_TYPE> MyFunction(const TypeClass& type) {
..
}

template<typename ArrayType, typename TypeClass=ArrayType::TypeClass>
arrow::enable_if_number<TypeClass, RETURN_TYPE> MyFunction(const ArrayType& array) {
..
}
```

Warning

doxygengroup: Cannot find group “type-predicates” in doxygen xml output for project “arrow_cpp” from directory: ../../cpp/apidoc/xml

### Runtime Type Predicates¶

Type predicates that can be applied at runtime.

Warning

doxygengroup: Cannot find group “runtime-type-predicates” in doxygen xml output for project “arrow_cpp” from directory: ../../cpp/apidoc/xml