Utilities¶

Decimal Numbers¶

class arrow::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 :

BasicDecimal128
- can be safely compiled to IR without references to libstdc++.
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: [in] divisor – 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(const util::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>¶

Abstract Sequences¶

template<typename T> class arrow::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¶

enumerator LZ4_HADOOP¶

class arrow::util::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 upper 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 arrow::util::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 arrow::util::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¶

Tensors

Input / output