fix: check type for transform literal to human string

Author: WZhuo

src/iceberg/test/transform_human_string_test.cc

@@ -130,6 +130,36 @@ class TimestampHumanStringTest : public ::testing::TestWithParam<HumanStringTest
       Transform::Year(), Transform::Month(), Transform::Day(), Transform::Hour()};
 };
 
+TEST_F(TimestampHumanStringTest, InvalidType) {
+  ICEBERG_UNWRAP_OR_FAIL(auto above_max,
+                         Literal::Long(std::numeric_limits<int64_t>::max())
+                             .CastTo(std::make_shared<IntType>()));
+  ICEBERG_UNWRAP_OR_FAIL(auto below_min,
+                         Literal::Long(std::numeric_limits<int64_t>::min())
+                             .CastTo(std::make_shared<IntType>()));
+
+  auto unmatch_type_literal = Literal::Long(std::numeric_limits<int64_t>::max());
+
+  for (const auto& transform : transforms_) {
+    auto result = transform->ToHumanString(above_max);
+    EXPECT_THAT(result, IsError(ErrorKind::kNotSupported));
+    EXPECT_THAT(result,
+                HasErrorMessage("Cannot transfrom human string for value: aboveMax"));
+
+    result = transform->ToHumanString(below_min);
+    EXPECT_THAT(result, IsError(ErrorKind::kNotSupported));
+    EXPECT_THAT(result,
+                HasErrorMessage("Cannot transfrom human string for value: belowMin"));
+
+    result = transform->ToHumanString(unmatch_type_literal);
+    EXPECT_THAT(result, IsError(ErrorKind::kNotSupported));
+    EXPECT_THAT(result, HasErrorMessage(std::format(
+                            "Transfrom human {} from type {} is not supported",
+                            TransformTypeToString(transform->transform_type()),
+                            unmatch_type_literal.type()->ToString())));
+  }
+}
+
 TEST_P(TimestampHumanStringTest, ToHumanString) {
   const auto& param = GetParam();
   for (uint32_t i = 0; i < transforms_.size(); i++) {

src/iceberg/transform.cc

@@ -372,16 +372,44 @@ Result<std::string> Transform::ToHumanString(const Literal& value) {
     return "null";
   }
 
+  if (value.IsAboveMax() || value.IsBelowMin()) [[unlikely]] {
+    return NotSupported("Cannot transfrom human string for value: {}", value.ToString());
+  }
+
   switch (transform_type_) {
-    case TransformType::kYear:
+    case TransformType::kYear: {
+      if (!std::holds_alternative<int32_t>(value.value())) [[unlikely]] {
+        return NotSupported("Transfrom human year from type {} is not supported",
+                            value.type()->ToString());
+      }
       return TransformUtil::HumanYear(std::get<int32_t>(value.value()));
-    case TransformType::kMonth:
+    }
+    case TransformType::kMonth: {
+      if (!std::holds_alternative<int32_t>(value.value())) [[unlikely]] {
+        return NotSupported("Transfrom human month from type {} is not supported",
+                            value.type()->ToString());
+      }
       return TransformUtil::HumanMonth(std::get<int32_t>(value.value()));
-    case TransformType::kDay:
+    }
+    case TransformType::kDay: {
+      if (!std::holds_alternative<int32_t>(value.value())) [[unlikely]] {
+        return NotSupported("Transfrom human day from type {} is not supported",
+                            value.type()->ToString());
+      }
       return TransformUtil::HumanDay(std::get<int32_t>(value.value()));
-    case TransformType::kHour:
+    }
+    case TransformType::kHour: {
+      if (!std::holds_alternative<int32_t>(value.value())) [[unlikely]] {
+        return NotSupported("Transfrom human hour from type {} is not supported",
+                            value.type()->ToString());
+      }
       return TransformUtil::HumanHour(std::get<int32_t>(value.value()));
-    default: {
+    }
+    case TransformType::kIdentity:
+    case TransformType::kBucket:
+    case TransformType::kTruncate:
+    case TransformType::kUnknown:
+    case TransformType::kVoid: {
       switch (value.type()->type_id()) {
         case TypeId::kDate:
           return TransformUtil::HumanDay(std::get<int32_t>(value.value()));
@@ -409,6 +437,7 @@ Result<std::string> Transform::ToHumanString(const Literal& value) {
       }
     }
   }
+  std::unreachable();
 }
 
 bool TransformFunction::Equals(const TransformFunction& other) const {

src/iceberg/transform.h

@@ -194,10 +194,10 @@ class ICEBERG_EXPORT Transform : public util::Formattable {
   Result<std::unique_ptr<UnboundPredicate>> ProjectStrict(
       std::string_view name, const std::shared_ptr<BoundPredicate>& predicate);
 
-  /// \brief Returns a human-readable String representation of a transformed value.
+  /// \brief Returns a human-readable string representation of a transformed value.
   ///
   /// \param value The literal value to be transformed.
-  /// \return A human-readable String representation of the value
+  /// \return A human-readable string representation of the value
   Result<std::string> ToHumanString(const Literal& value);
 
   /// \brief Returns a string representation of this transform (e.g., "bucket[16]").