-Go to the documentation of this file.

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed u
 nder the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_DECIMAL_H
 #define ARROW_DECIMAL_H
 
 #include <array>
 #include <cstdint>
 #include <string>
 #include <type_traits>
 
 #include "arrow/status.h"<
 /span>
 #include "arrow/util/visibility.h"
 
 namespace arrow {
 
 class ARROW_EXPORT Decimal128 {
  public:
   constexpr Decimal128(int64_t high, uint64_t low) : high_bits_(high), low_bits_(low) {}
 
   constexpr Decimal128() : Decimal128(0, 0) {}
 
   template <typename T,
   48             typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
   constexpr Decimal128(T value)
       : Decimal128(static_cast<int64_t>(value) >= 0 ? 0 : -1,
                    static_cast<uint64_t>(value)) {}
 
   explicit Decimal128(const std::string& value);
 
   explicit Decimal128(const uint8_t* bytes);
 
   Decimal128& Negate();
 
   Decimal128& operator+=(const 
 Decimal128& right);
 
   Decimal128& operator-=(const Decimal128& right);
 
   Decimal128& operator*=(const Decimal128& right);
 
   Status Divide(const Decimal128& divisor, Decimal128* result,
                 Decimal128* remainder) const;
 
   Decimal128& operator/=(const Decimal128& right);
 
   explicit operator char() const;
 
   Decimal128& operator|=(const Decimal128& right);
 
   Decimal128& operator&=(const Decimal128& right);
 
   Decimal128& operator<<=(uint32_t bits);
 
   Decimal128& operator>>=(uint32_t bits);
 
   int64_t high_bits() const { return high_bits_; }
 
   uint64_t low_bits() const { return low_bits_; }

106

108 std::array<uint8_t, 16> ToBytes() const;

109

112 std::string ToString(int precision, int scale) const;

113

116 static Status FromString(const std::string& s, Decimal128* out,

117 int* precision = nullptr, int* scale = nullptr);

118

119 private:

120 int64_t high_bits_;

121 uint64_t low_bits_;

122 };

123

124 ARROW_EXPORT bool operator==(const Decimal128& left, const Decimal128& right);

125 ARROW_EXPORT bool operator!=(const Decimal1 28& left, const Decimal128& right);

126 ARROW_EXPORT bool operator<(const Decimal128& left, const Decimal128& right);

127 ARROW_EXPORT bool operator<=(const Decimal128& left, const Decimal128& right);

128 ARROW_EXPORT bool operator>(const Decimal128& left, const Decimal128& right);

129 ARROW_EXPORT bool operator>=(const Decimal128& left, const Decimal128& right);

130

131 ARROW_EXPORT Decimal128 operator-(const Decimal128& operand);

132 ARROW_EXPORT Decimal128 operator+(const Decimal128& left, const Decimal128& right);

133 ARROW_EXPORT Decimal128 operator-(const Decimal128& left, const Decimal128& right);

134 ARROW_EXPORT Decimal128 operator*(const Decimal128& left, const Decimal128& right);

135 ARROW _EXPORT Decimal128 operator/(const Decimal128& left, const Decimal128& right);

136 ARROW_EXPORT Decimal128 operator%(const Decimal128& left, const Decimal128& right);

137

138 } // namespace arrow

139

140 #endif // ARROW_DECIMAL_H

arrow::operator*

Decimal128 operator*(const Decimal128 &left, const Decimal128 &right)

arrow::Decimal128::Decimal128

constexpr Decimal128(T value)

Convert any integer value into an Decimal128.

Definition: decimal.h:49

arrow::Decimal128::high_bits

int64_t high_bits() const

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

Definition: decimal.h:102

arrow::Decimal128::Decimal128

constexpr Decimal128(int64_t high, uint64_t low)

Create an Decimal128 from the two's complement representation.

Definition: decimal.h:41

+Go to the documentation of this file.

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed u
 nder the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_DECIMAL_H
 #define ARROW_DECIMAL_H
 
 #include <array>
 #include <cstdint>
 #include <string>
 #include <type_traits>
 
 #include "arrow/status.h"<
 /span>
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
 
 class ARROW_EXPORT Decimal128 {
  public:
   constexpr Decimal128(int64_t high, uint64_t low) : high_bits_(high), low_bits_(low) {}
 
   constexpr Decimal128() : Decimal128(0, 0) {}
 
   template <typename T,
             typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
   constexpr Decimal128(T value)
       : Decimal128(static_cast<int64_t>(value) >= 0 ? 0 : -1,
                    static_cast<uint64_t>(value)) {}
 
   explicit Decimal128(const std::string& value);
 
   explicit Decimal128(const uint8_t* bytes);
 
   Decimal128& Negate();
 
   Decimal128& operator+=(const Decimal128& right);
 
   Decimal128& operator-=(const Decimal128& right);
 
   Decimal128& operator*=(const D
 ecimal128& right);
 
   Status Divide(const Decimal128& divisor, Decimal128* result,
                 Decimal128* remainder) const;
 
   Decimal128& operator/=(const Decimal128& right);
 
   explicit operator char() const;
 
   Decimal128& operator|=(const Decimal128& right);
 
   Decimal128& operator&=(const Decimal128& right);
 
   Decimal128& operator<<=(uint32_t bits);
 
   Decimal128& operator>>=(uint32_t bits);
 
   int64_t high_bits() const { return high_bits_; }
 
   uint64_t low_bits() const { return low_bits_; }
 
   std::array<uint8_t, 16> ToBytes() const;
 
   std::string 
 ToString(int precision, int scale) const;
 
   static Status FromString(const std::string& s, Decimal128* out,
                            int* precision = NULLPTR, int* scale = NULLPTR);
 
  private:
   int64_t high_bits_;
   uint64_t low_bits_;
 };
 
 ARROW_EXPORT bool operator==(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT bool operator!=(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT bool operator<(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT bool operator<=(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT bool operator>(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT bool operator>=(const Decimal128& left, const Decimal128& right);
 
 ARROW_EXPORT Decimal128 operator-(const Decimal128& operand);
 ARROW_EXPORT Decimal128 operator+(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT Decimal128 operator-(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT Decimal128 operator*(cons
 t Decimal128& left, const Decimal128& right);
 ARROW_EXPORT Decimal128 operator/(const Decimal128& left, const Decimal128& right);
 ARROW_EXPORT Decimal128 operator%(const Decimal128& left, const Decimal128& right);
 
 }  // namespace arrow
 
 #endif  //  ARROW_DECIMAL_H

+
+
+
+
+
-
+
-
+
-
-
+
+
-
-
+
+

Classes