fix: remove unrelated codes

Author: zhjwpku

src/iceberg/CMakeLists.txt

@@ -20,7 +20,6 @@ set(ICEBERG_INCLUDES "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/src>"
 set(ICEBERG_SOURCES
     arrow_c_data_internal.cc
     catalog/in_memory_catalog.cc
-    util/decimal.cc
     expression/expression.cc
     expression/literal.cc
     file_reader.cc

src/iceberg/util/decimal.cc

@@ -24,21 +24,17 @@
 
 #include "iceberg/util/decimal.h"
 
-#include <algorithm>
 #include <array>
 #include <bit>
 #include <cassert>
 #include <charconv>
 #include <climits>
 #include <cmath>
-#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <format>
 #include <iomanip>
-#include <iostream>
 #include <limits>
-#include <ostream>
 #include <sstream>
 #include <string>
 #include <string_view>
@@ -427,11 +423,11 @@ std::string Decimal::ToIntegerString() const {
 Result<Decimal> Decimal::FromString(std::string_view str, int32_t* precision,
                                     int32_t* scale) {
   if (str.empty()) {
-    return InvalidArgument("Decimal::FromString: empty string is not a valid Decimal");
+    return InvalidArgument("Empty string is not a valid Decimal");
   }
   DecimalComponents dec;
   if (!ParseDecimalComponents(str, &dec)) {
-    return InvalidArgument("Decimal::FromString: invalid decimal string '{}'", str);
+    return InvalidArgument("Invalid decimal string '{}'", str);
   }
 
   // Count number of significant digits (without leading zeros)
@@ -451,8 +447,6 @@ Result<Decimal> Decimal::FromString(std::string_view str, int32_t* precision,
     parsed_scale = static_cast<int32_t>(dec.fractional_digits.size());
   }
 
-  // Index 1 is the high part, index 0 is the low part
-  std::array<uint64_t, 2> result_array = {0, 0};
   uint128_t value = 0;
   ShiftAndAdd(dec.while_digits, value);
   ShiftAndAdd(dec.fractional_digits, value);
@@ -466,9 +460,8 @@ Result<Decimal> Decimal::FromString(std::string_view str, int32_t* precision,
     // For the scale to 0, to avoid negative scales (due to compatibility issues with
     // external systems such as databases)
     if (parsed_scale < -kMaxScale) {
-      return InvalidArgument(
-          "Decimal::FromString: scale must be in the range [-{}, {}], was {}", kMaxScale,
-          kMaxScale, parsed_scale);
+      return InvalidArgument("scale must be in the range [-{}, {}], was {}", kMaxScale,
+                             kMaxScale, parsed_scale);
     }
 
     result *= kDecimal128PowersOfTen[-parsed_scale];
@@ -552,8 +545,6 @@ struct RealTraits<float> {
   static constexpr const float* powers_of_ten() { return kFloatPowersOfTen.data(); }
 
   static constexpr float two_to_64(float x) { return x * 1.8446744e+19f; }
-  static constexpr float two_to_128(float x) { return x == 0 ? 0 : kFloatInf; }
-  static constexpr float two_to_192(float x) { return x == 0 ? 0 : kFloatInf; }
 
   static constexpr int32_t kMantissaBits = 24;
   // ceil(log10(2 ^ kMantissaBits))
@@ -567,8 +558,6 @@ struct RealTraits<double> {
   static constexpr const double* powers_of_ten() { return kDoublePowersOfTen.data(); }
 
   static constexpr double two_to_64(double x) { return x * 1.8446744073709552e+19; }
-  static constexpr double two_to_128(double x) { return x * 3.402823669209385e+38; }
-  static constexpr double two_to_192(double x) { return x * 6.277101735386681e+57; }
 
   static constexpr int32_t kMantissaBits = 53;
   // ceil(log10(2 ^ kMantissaBits))
@@ -791,7 +780,7 @@ struct DecimalRealConversion {
     return x;
   }
 
-  /// An approximate conversion from Decimal128 to Real that guarantees:
+  /// An approximate conversion from Decimal to Real that guarantees:
   /// 1. If the decimal is an integer, the conversion is exact.
   /// 2. If the number of fractional digits is <= RealTraits<Real>::kMantissaDigits (e.g.
   ///    8 for float and 16 for double), the conversion is within 1 ULP of the exact
@@ -864,7 +853,7 @@ static inline uint64_t UInt64FromBigEndian(const uint8_t* bytes, int32_t length)
   // Using memcpy instead of special casing for length
   // and doing the conversion in 16, 32 parts, which could
   // possibly create unaligned memory access on certain platforms
-  memcpy(reinterpret_cast<uint8_t*>(&result) + 8 - length, bytes, length);
+  std::memcpy(reinterpret_cast<uint8_t*>(&result) + 8 - length, bytes, length);
 
   if constexpr (std::endian::native == std::endian::little) {
     return std::byteswap(result);
@@ -1008,7 +997,7 @@ double Decimal::ToDouble(int32_t scale) const {
 
 std::array<uint8_t, Decimal::kByteWidth> Decimal::ToBytes() const {
   std::array<uint8_t, kByteWidth> out{{0}};
-  memcpy(out.data(), &data_, kByteWidth);
+  std::memcpy(out.data(), &data_, kByteWidth);
   return out;
 }
 

src/iceberg/util/decimal.h

@@ -257,27 +257,9 @@ class ICEBERG_EXPORT Decimal {
   friend Decimal operator%(const Decimal& lhs, const Decimal& rhs);
 
  private:
-  static constexpr int32_t highIndex() {
-    if constexpr (std::endian::native == std::endian::little) {
-      return 1;
-    } else {
-      return 0;
-    }
-  }
-
-  static constexpr int32_t lowIndex() {
-    if constexpr (std::endian::native == std::endian::little) {
-      return 0;
-    } else {
-      return 1;
-    }
-  }
-
   int128_t data_{0};
 };
 
 ICEBERG_EXPORT std::ostream& operator<<(std::ostream& os, const Decimal& decimal);
 
-// Unary operators
-
 }  // namespace iceberg

test/decimal_test.cc

@@ -23,11 +23,9 @@
 #include <bit>
 #include <cmath>
 #include <cstdint>
-#include <vector>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <sys/types.h>
 
 #include "iceberg/util/int128.h"
 #include "matchers.h"
@@ -48,11 +46,6 @@ void AssertDecimalFromString(const std::string& s, const Decimal& expected,
   EXPECT_EQ(expected_scale, scale);
 }
 
-Decimal DecimalFromInt128(int128_t value) {
-  return {static_cast<int64_t>(value >> 64),
-          static_cast<uint64_t>(value & 0xFFFFFFFFFFFFFFFFULL)};
-}
-
 }  // namespace
 
 TEST(DecimalTest, Basics) {
@@ -279,23 +272,21 @@ TEST(DecimalTest, FromStringInvalid) {
   // Empty string
   auto result = Decimal::FromString("");
   ASSERT_THAT(result, IsError(ErrorKind::kInvalidArgument));
-  ASSERT_THAT(result, HasErrorMessage(
-                          "Decimal::FromString: empty string is not a valid Decimal"));
+  ASSERT_THAT(result, HasErrorMessage("Empty string is not a valid Decimal"));
   for (const auto& invalid_string :
        std::vector<std::string>{"-", "0.0.0", "0-13-32", "a", "-23092.235-",
                                 "-+23092.235", "+-23092.235", "00a", "1e1a", "0.00123D/3",
                                 "1.23eA8", "1.23E+3A", "-1.23E--5", "1.2345E+++07"}) {
     auto result = Decimal::FromString(invalid_string);
     ASSERT_THAT(result, IsError(ErrorKind::kInvalidArgument));
-    ASSERT_THAT(result, HasErrorMessage("Decimal::FromString: invalid decimal string"));
+    ASSERT_THAT(result, HasErrorMessage("Invalid decimal string"));
   }
 
   for (const auto& invalid_string :
        std::vector<std::string>{"1e39", "-1e39", "9e39", "-9e39", "9.9e40", "-9.9e40"}) {
     auto result = Decimal::FromString(invalid_string);
     ASSERT_THAT(result, IsError(ErrorKind::kInvalidArgument));
-    ASSERT_THAT(result,
-                HasErrorMessage("Decimal::FromString: scale must be in the range"));
+    ASSERT_THAT(result, HasErrorMessage("scale must be in the range"));
   }
 }
 
@@ -1094,11 +1085,10 @@ TEST(DecimalTestFunctionality, Multiply) {
   for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
     for (auto y :
          std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 0, 1, 2, 32, INT32_MAX}) {
-      Decimal decimal_x = DecimalFromInt128(x);
-      Decimal decimal_y = DecimalFromInt128(y);
+      Decimal decimal_x(x);
+      Decimal decimal_y(y);
       Decimal result = decimal_x * decimal_y;
-      EXPECT_EQ(DecimalFromInt128(x * y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+      EXPECT_EQ(Decimal(x * y), result) << " x: " << decimal_x << " y: " << decimal_y;
     }
   }
 }
@@ -1111,11 +1101,10 @@ TEST(DecimalTestFunctionality, Divide) {
 
   for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
     for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
-      Decimal decimal_x = DecimalFromInt128(x);
-      Decimal decimal_y = DecimalFromInt128(y);
+      Decimal decimal_x(x);
+      Decimal decimal_y(y);
       Decimal result = decimal_x / decimal_y;
-      EXPECT_EQ(DecimalFromInt128(x / y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+      EXPECT_EQ(Decimal(x / y), result) << " x: " << decimal_x << " y: " << decimal_y;
     }
   }
 }
@@ -1129,11 +1118,10 @@ TEST(DecimalTestFunctionality, Modulo) {
   // Test some edge cases
   for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
     for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
-      Decimal decimal_x = DecimalFromInt128(x);
-      Decimal decimal_y = DecimalFromInt128(y);
+      Decimal decimal_x(x);
+      Decimal decimal_y(y);
       Decimal result = decimal_x % decimal_y;
-      EXPECT_EQ(DecimalFromInt128(x % y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+      EXPECT_EQ(Decimal(x % y), result) << " x: " << decimal_x << " y: " << decimal_y;
     }
   }
 }
@@ -1206,8 +1194,8 @@ TEST(DecimalTestFunctionality, FitsInPrecision) {
 
 TEST(DecimalTest, LeftShift) {
   auto check = [](int128_t x, uint32_t bits) {
-    auto expected = DecimalFromInt128(x << bits);
-    auto actual = DecimalFromInt128(x) << bits;
+    auto expected = Decimal(x << bits);
+    auto actual = Decimal(x) << bits;
     ASSERT_EQ(actual.low(), expected.low());
     ASSERT_EQ(actual.high(), expected.high());
   };