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

constexpr Decimal128(const BasicDecimal128 &value) noexcept¶: constructor creates a Decimal128 from a BasicDecimal128.

Decimal128(const std::string &value)¶: Parse the number from a base 10 string representation.

constexpr Decimal128() noexcept¶: Empty constructor creates a Decimal128 with a value of 0.

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

Return

the pair of the quotient and the remainder

Parameters

[in] divisor: the number to divide by

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.

operator int64_t() const¶: Cast this value to an int64_t.

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>> Result<T> ToInteger() const¶: Convert to a signed integer.

template<typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>> 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> T ToReal(int32_t scale) const¶: Convert to a floating-point number (scaled)

Public Static Functions

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.

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.

Return: 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 : public arrow::util::EqualityComparable<Iterator<T>>¶

A generic Iterator that can return errors.

Public Functions

template<typename Wrapped> Iterator(Wrapped has_next)¶

Iterator may be constructed from any type which has a member function with signature Status Next(T*);.

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.

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> Status Visit(Visitor &&visitor)¶

Pass each element of the sequence to a visitor.

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

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

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

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.

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.

Result<std::shared_ptr<Compressor>> MakeCompressor() = 0¶: Create a streaming compressor instance.

Result<std::shared_ptr<Decompressor>> MakeDecompressor() = 0¶: Create a streaming compressor instance.

Compression::type compression_type() const = 0¶: This Codec’s compression type.

const std::string &name() const¶: The name of this Codec’s compression type.

int compression_level() const¶: This Codec’s compression level, if applicable.

Public Static Functions

int UseDefaultCompressionLevel()¶: Return special value to indicate that a codec implementation should use its default compression level.

const std::string &GetCodecAsString(Compression::type t)¶: Return a string name for compression type.

Result<Compression::type> GetCompressionType(const std::string &name)¶: Return compression type for name (all upper case)

Result<std::unique_ptr<Codec>> Create(Compression::type codec, int compression_level = kUseDefaultCompressionLevel)¶: Create a codec for the given compression algorithm.

bool IsAvailable(Compression::type codec)¶: Return true if support for indicated codec has been enabled.

bool SupportsCompressionLevel(Compression::type codec)¶: Return true if indicated codec supports setting a compression level.

class arrow::util::Compressor¶

Streaming compressor interface.

Public Functions

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.

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.

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

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.

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.

Status Reset() = 0¶: Reinitialize decompressor, making it ready for a new compressed stream.

struct DecompressResult¶