feat: add more tests

Author: zhjwpku

src/iceberg/expression/decimal.cc

@@ -33,6 +33,7 @@
 #include <iomanip>
 #include <iostream>
 #include <limits>
+#include <ostream>
 #include <sstream>
 #include <string>
 #include <string_view>
@@ -183,7 +184,7 @@ static Status BuildFromArray(Decimal* result, const uint32_t* array, int64_t len
   std::array<uint64_t, 2> result_array = {0, 0};
   for (int64_t i = length - 2 * 2 - 1; i >= 0; i--) {
     if (array[i] != 0) {
-      return Overflow("Decimal division overflow");
+      return Invalid("Decimal division overflow");
     }
   }
 
@@ -250,7 +251,7 @@ static inline Status DecimalDivide(const Decimal& dividend, const Decimal& divis
   }
 
   if (divisor_length == 0) {
-    return DivideByZero("Cannot divide by zero in DecimalDivide");
+    return Invalid("Cannot divide by zero in DecimalDivide");
   }
 
   if (divisor_length == 1) {
@@ -1013,9 +1014,8 @@ struct DecimalRealConversion {
     const auto x = std::nearbyint(real * PowerOfTen<double>(scale));
     const auto max_abs = PowerOfTen<double>(precision);
     if (x <= -max_abs || x >= max_abs) {
-      return Overflow(
-          "Cannot convert {} to Decimal(precision = {}, scale = {}): overflow", real,
-          precision, scale);
+      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
+                     real, precision, scale);
     }
 
     // Extract high and low bits
@@ -1048,9 +1048,8 @@ struct DecimalRealConversion {
       // overflow.
       // NOTE: `limit` is allowed here as rounding can make it smaller than
       // the theoretical limit (for example, 1.0e23 < 10^23).
-      return Overflow(
-          "Cannot convert {} to Decimal(precision = {}, scale = {}): overflow", real,
-          precision, scale);
+      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
+                     real, precision, scale);
     }
 
     // 2. Losslessly convert `real` to `mant * 2**k`
@@ -1140,9 +1139,8 @@ struct DecimalRealConversion {
 
     // Rounding might have pushed `x` just above the max precision, check again
     if (!x.FitsInPrecision(precision)) {
-      return Overflow(
-          "Cannot convert {} to Decimal(precision = {}, scale = {}): overflow", real,
-          precision, scale);
+      return Invalid("Cannot convert {} to Decimal(precision = {}, scale = {}): overflow",
+                     real, precision, scale);
     }
     return x;
   }
@@ -1346,6 +1344,11 @@ std::array<uint8_t, Decimal::kByteWidth> Decimal::ToBytes() const {
   return out;
 }
 
+ICEBERG_EXPORT std::ostream& operator<<(std::ostream& os, const Decimal& decimal) {
+  os << decimal.ToIntegerString();
+  return os;
+}
+
 // Unary operators
 ICEBERG_EXPORT Decimal operator-(const Decimal& operand) {
   Decimal result(operand.high(), operand.low());

src/iceberg/expression/decimal.h

@@ -27,6 +27,7 @@
 
 #include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
+#include "iceberg/util/macros.h"
 #include "iceberg/util/port.h"
 
 namespace iceberg {
@@ -171,6 +172,28 @@ class ICEBERG_EXPORT Decimal {
   /// Returns true if the number of significant digits is less or equal to `precision`.
   bool FitsInPrecision(int32_t precision) const;
 
+  /// \brief Convert to a signed integer
+  template <typename T>
+    requires std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t>
+  Result<T> ToInteger() const {
+    constexpr auto min_value = std::numeric_limits<T>::min();
+    constexpr auto max_value = std::numeric_limits<T>::max();
+    const auto& self = *this;
+    if (self < min_value || self > max_value) {
+      return Invalid("Invalid cast from Decimal to {} byte integer", sizeof(T));
+    }
+    return static_cast<T>(low());
+  }
+
+  /// \brief Convert to a signed integer
+  template <typename T>
+    requires std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t>
+  Status ToInteger(T* out) const {
+    ICEBERG_ASSIGN_OR_RAISE(auto result, ToInteger<T>());
+    *out = result;
+    return {};
+  }
+
   /// \brief Convert to a floating-point number (scaled)
   float ToFloat(int32_t scale) const;
   /// \brief Convert to a floating-point number (scaled)
@@ -212,6 +235,8 @@ class ICEBERG_EXPORT Decimal {
     return lhs.data_ != rhs.data_;
   }
 
+  friend std::ostream& operator<<(std::ostream& os, const Decimal& decimal);
+
  private:
 #if ICEBERG_LITTLE_ENDIAN
   static constexpr int32_t kHighIndex = 1;

src/iceberg/result.h

@@ -32,7 +32,7 @@ enum class ErrorKind {
   kAlreadyExists,
   kCommitStateUnknown,
   kDecompressError,
-  kDivideByZero,
+  kInvalid,  // For general invalid errors
   kInvalidArgument,
   kInvalidArrowData,
   kInvalidExpression,
@@ -47,8 +47,6 @@ enum class ErrorKind {
   kNotFound,
   kNotImplemented,
   kNotSupported,
-  kOverflow,
-  kRescaleDataLoss,
   kUnknownError,
 };
 
@@ -82,7 +80,7 @@ using Status = Result<void>;
 DEFINE_ERROR_FUNCTION(AlreadyExists)
 DEFINE_ERROR_FUNCTION(CommitStateUnknown)
 DEFINE_ERROR_FUNCTION(DecompressError)
-DEFINE_ERROR_FUNCTION(DivideByZero)
+DEFINE_ERROR_FUNCTION(Invalid)
 DEFINE_ERROR_FUNCTION(InvalidArgument)
 DEFINE_ERROR_FUNCTION(InvalidArrowData)
 DEFINE_ERROR_FUNCTION(InvalidExpression)
@@ -97,8 +95,6 @@ DEFINE_ERROR_FUNCTION(NotAllowed)
 DEFINE_ERROR_FUNCTION(NotFound)
 DEFINE_ERROR_FUNCTION(NotImplemented)
 DEFINE_ERROR_FUNCTION(NotSupported)
-DEFINE_ERROR_FUNCTION(Overflow)
-DEFINE_ERROR_FUNCTION(RescaleDataLoss)
 DEFINE_ERROR_FUNCTION(UnknownError)
 
 #undef DEFINE_ERROR_FUNCTION