decimal.h

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 under 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.
 */
 
#pragma once
 
 
#include <array>
#include <compare>
#include <cstdint>
#include <iosfwd>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/util/formattable.h"
#include "iceberg/util/int128.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT Decimal : public util::Formattable {
 public:
  static constexpr int32_t kBitWidth = 128;
  static constexpr int32_t kByteWidth = kBitWidth / 8;
  static constexpr int32_t kMaxPrecision = 38;
  static constexpr int32_t kMaxScale = 38;
 
  constexpr Decimal() noexcept = default;
 
  constexpr Decimal(int128_t value) noexcept  // NOLINT implicit conversion
      : data_(value) {}
 
  template <typename T>
    requires(std::is_integral_v<T> && (sizeof(T) <= sizeof(uint64_t)))
  constexpr Decimal(T value) noexcept  // NOLINT implicit conversion
      : data_(static_cast<int128_t>(value)) {}
 
  explicit Decimal(std::string_view str);
 
  constexpr Decimal(int64_t high, uint64_t low) noexcept {
    data_ = (static_cast<int128_t>(high) << 64) | low;
  }
 
  Decimal& Negate();
 
  Decimal& Abs();
 
  static Decimal Abs(const Decimal& value);
 
  Decimal& operator+=(const Decimal& other);
 
  Decimal& operator-=(const Decimal& other);
 
  Decimal& operator*=(const Decimal& other);
 
  Result<std::pair<Decimal, Decimal>> Divide(const Decimal& divisor) const;
 
  Decimal& operator/=(const Decimal& other);
 
  Decimal& operator|=(const Decimal& other);
 
  Decimal& operator&=(const Decimal& other);
 
  Decimal& operator<<=(uint32_t shift);
 
  Decimal operator<<(uint32_t shift) const {
    Decimal result(*this);
    result <<= shift;
    return result;
  }
 
  Decimal& operator>>=(uint32_t shift);
 
  Decimal operator>>(uint32_t shift) const {
    Decimal result(*this);
    result >>= shift;
    return result;
  }
 
  constexpr int128_t value() const { return data_; }
 
  constexpr int64_t high() const { return static_cast<int64_t>(data_ >> 64); }
 
  constexpr uint64_t low() const { return static_cast<uint64_t>(data_); }
 
  Result<std::string> ToString(int32_t scale) const;
 
  std::string ToIntegerString() const;
 
  std::string ToString() const override { return ToIntegerString(); }
 
  static Result<Decimal> FromString(std::string_view str, int32_t* precision = nullptr,
                                    int32_t* scale = nullptr);
 
  static Result<Decimal> FromBigEndian(const uint8_t* data, int32_t length);
 
  std::vector<uint8_t> ToBigEndian() const;
 
  Result<Decimal> Rescale(int32_t orig_scale, int32_t new_scale) const;
 
  bool FitsInPrecision(int32_t precision) const;
 
  std::strong_ordering operator<=>(const Decimal& other) const {
    if (high() != other.high()) {
      return high() <=> other.high();
    }
    return low() <=> other.low();
  }
 
  static std::partial_ordering Compare(const Decimal& lhs, const Decimal& rhs,
                                       int32_t lhs_scale, int32_t rhs_scale);
 
  const uint8_t* native_endian_bytes() const {
    return reinterpret_cast<const uint8_t*>(&data_);
  }
 
  std::array<uint8_t, kByteWidth> ToBytes() const;
 
  int64_t Sign() const { return 1 | (high() >> 63); }
 
  bool IsNegative() const { return (high() >> 63) < 0; }
 
  explicit operator bool() const { return data_ != 0; }
 
  friend bool operator==(const Decimal& lhs, const Decimal& rhs) {
    return lhs.data_ == rhs.data_;
  }
 
  friend bool operator!=(const Decimal& lhs, const Decimal& rhs) {
    return lhs.data_ != rhs.data_;
  }
 
  ICEBERG_EXPORT friend Decimal operator-(const Decimal& operand);
  ICEBERG_EXPORT friend Decimal operator~(const Decimal& operand);
 
  ICEBERG_EXPORT friend Decimal operator+(const Decimal& lhs, const Decimal& rhs);
  ICEBERG_EXPORT friend Decimal operator-(const Decimal& lhs, const Decimal& rhs);
  ICEBERG_EXPORT friend Decimal operator*(const Decimal& lhs, const Decimal& rhs);
  ICEBERG_EXPORT friend Decimal operator/(const Decimal& lhs, const Decimal& rhs);
  ICEBERG_EXPORT friend Decimal operator%(const Decimal& lhs, const Decimal& rhs);
 
 private:
  int128_t data_{0};
};
 
ICEBERG_EXPORT std::ostream& operator<<(std::ostream& os, const Decimal& decimal);
 
}  // namespace iceberg