feat: Implement Type Casting and toString for Literals

Author: HeartLinked

src/iceberg/expression/literal.cc

@@ -19,10 +19,13 @@
 
 #include "iceberg/expression/literal.h"
 
+#include <cmath>
 #include <concepts>
 #include <cstdint>
+#include <string>
 
-#include "iceberg/exception.h"
+#include "iceberg/type_fwd.h"
+#include "iceberg/util/macros.h"
 
 namespace iceberg {
 
@@ -100,7 +103,6 @@ Result<Literal> LiteralCaster::CastFromInt(
       return Literal::Double(static_cast<double>(int_val));
     case TypeId::kDate:
       return Literal::Date(int_val);
-    // TODO(Li Feiyang): Implement cast from Int to decimal
     default:
       return NotSupported("Cast from Int to {} is not implemented",
                           target_type->ToString());
@@ -141,7 +143,6 @@ Result<Literal> LiteralCaster::CastFromLong(
       return Literal::Timestamp(long_val);
     case TypeId::kTimestampTz:
       return Literal::TimestampTz(long_val);
-    // TODO(Li Feiyang): Implement cast from Long to decimal, TimestampNs and
     default:
       return NotSupported("Cast from Long to {} is not supported",
                           target_type->ToString());
@@ -155,7 +156,6 @@ Result<Literal> LiteralCaster::CastFromFloat(
   switch (target_type->type_id()) {
     case TypeId::kDouble:
       return Literal::Double(static_cast<double>(float_val));
-    // TODO(Li Feiyang): Implement cast from Float to decimal
     default:
       return NotSupported("Cast from Float to {} is not supported",
                           target_type->ToString());
@@ -191,10 +191,9 @@ Result<Literal> LiteralCaster::CastFromString(
     case TypeId::kTime:
     case TypeId::kTimestamp:
     case TypeId::kTimestampTz:
+    case TypeId::kUuid:
       return NotImplemented("Cast from String to {} is not implemented yet",
                             target_type->ToString());
-      // TODO(Li Feiyang): Implement cast from String to uuid and decimal
-
     default:
       return NotSupported("Cast from String to {} is not supported",
                           target_type->ToString());
@@ -253,8 +252,7 @@ Result<Literal> LiteralCaster::CastFromFixed(
     const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
   switch (target_type->type_id()) {
     case TypeId::kBinary:
-      return Literal::Binary(
-          std::get<std::vector<uint8_t>>(literal.value_));  // 直接拷贝+move
+      return Literal::Binary(std::get<std::vector<uint8_t>>(literal.value_));
     default:
       return NotSupported("Cast from Fixed to {} is not supported",
                           target_type->ToString());
@@ -404,6 +402,13 @@ std::partial_ordering Literal::operator<=>(const Literal& other) const {
 }
 
 std::string Literal::ToString() const {
+  auto unsupported_error = [this]() {
+    return std::format("ToString not supported for type: {}", type_->ToString());
+  };
+  auto invalid_argument = [this]() {
+    return std::format("Invalid argument for type: {}", type_->ToString());
+  };
+
   if (std::holds_alternative<BelowMin>(value_)) {
     return "belowMin";
   }
@@ -431,14 +436,13 @@ std::string Literal::ToString() const {
       return std::to_string(std::get<double>(value_));
     }
     case TypeId::kString: {
-      return std::get<std::string>(value_);
+      return "\"" + std::get<std::string>(value_) + "\"";
     }
     case TypeId::kBinary:
     case TypeId::kFixed: {
       const auto& binary_data = std::get<std::vector<uint8_t>>(value_);
       std::string result = "X'";
-      result.reserve(2 + binary_data.size() * 2 +
-                     1);  // 2 chars per byte and 2 + 1 for prefix and suffix
+      result.reserve(/*prefix*/ 2 + /*suffix*/ 1 + /*data*/ binary_data.size() * 2);
       for (const auto& byte : binary_data) {
         std::format_to(std::back_inserter(result), "{:02X}", byte);
       }
@@ -453,12 +457,8 @@ std::string Literal::ToString() const {
     case TypeId::kDate: {
       return std::to_string(std::get<int32_t>(value_));
     }
-    case TypeId::kDecimal:
-    case TypeId::kUuid: {
-      throw NotImplemented("kDecimal and kUuid are not implemented yet");
-    }
     default: {
-      throw IcebergError("Unknown type: " + type_->ToString());
+      return unsupported_error();
     }
   }
 }
@@ -490,6 +490,9 @@ Result<Literal> LiteralCaster::CastTo(const Literal& literal,
 
   // Delegate to specific cast functions based on source type
   switch (source_type_id) {
+    case TypeId::kBoolean:
+      // No casts defined for Boolean, other than to itself.
+      break;
     case TypeId::kInt:
       return CastFromInt(literal, target_type);
     case TypeId::kLong:
@@ -508,12 +511,11 @@ Result<Literal> LiteralCaster::CastTo(const Literal& literal,
       return CastFromTimestamp(literal, target_type);
     case TypeId::kTimestampTz:
       return CastFromTimestampTz(literal, target_type);
-    case TypeId::kBoolean:
     default:
       break;
   }
 
-  return NotSupported("Cast from {} to {} is not implemented", literal.type_->ToString(),
+  return NotSupported("Cast from {} to {} is not supported", literal.type_->ToString(),
                       target_type->ToString());
 }
 

src/iceberg/expression/literal.h

@@ -57,7 +57,7 @@ class ICEBERG_EXPORT Literal : public util::Formattable {
                              double,          // for double
                              std::string,     // for string
                              std::vector<uint8_t>,     // for binary, fixed
-                             std::array<uint8_t, 16>,  // for uuid and decimal
+                             std::array<uint8_t, 16>,  // for uuid
                              BelowMin, AboveMax>;
 
   /// \brief Factory methods for primitive types

src/iceberg/test/literal_test.cc

@@ -40,7 +40,7 @@ void AssertCastSucceeds(const Result<Literal>& result, TypeId expected_type_id,
   ASSERT_THAT(result, IsOk());
   EXPECT_EQ(result->type()->type_id(), expected_type_id);
   ASSERT_NO_THROW(EXPECT_EQ(std::get<T>(result->value()), expected_value))
-      << "Value type mismatch in std::get. Expected type for TypeId "
+      << "Type mismatch in std::get. Expected type for TypeId "
       << static_cast<int>(expected_type_id);
 }
 
@@ -146,15 +146,15 @@ TEST(LiteralTest, LongCastTo) {
 
   // Cast to Time
   AssertCastSucceeds(long_literal.CastTo(iceberg::time()), TypeId::kTime,
-                     static_cast<int64_t>(42L));
+                     static_cast<int64_t>(42));
 
   // Cast to Timestamp
   AssertCastSucceeds(long_literal.CastTo(iceberg::timestamp()), TypeId::kTimestamp,
-                     static_cast<int64_t>(42L));
+                     static_cast<int64_t>(42));
 
   // Cast to TimestampTz
   AssertCastSucceeds(long_literal.CastTo(iceberg::timestamp_tz()), TypeId::kTimestampTz,
-                     static_cast<int64_t>(42L));
+                     static_cast<int64_t>(42));
 }
 
 TEST(LiteralTest, LongCastToOverflow) {
@@ -204,11 +204,11 @@ TEST(LiteralTest, FloatComparison) {
 }
 
 TEST(LiteralTest, FloatCastTo) {
-  auto float_literal = Literal::Float(3.14f);
+  auto float_literal = Literal::Float(2.0f);
 
   // Cast to Double
   AssertCastSucceeds(float_literal.CastTo(iceberg::float64()), TypeId::kDouble,
-                     static_cast<double>(3.14f));
+                     static_cast<double>(2.0f));
 }
 
 // Double type tests
@@ -234,10 +234,10 @@ TEST(LiteralTest, DoubleComparison) {
 }
 
 TEST(LiteralTest, DoubleCastTo) {
-  auto double_literal = Literal::Double(3.14);
+  auto double_literal = Literal::Double(2.0);
 
   // Cast to Float
-  AssertCastSucceeds(double_literal.CastTo(iceberg::float32()), TypeId::kFloat, 3.14f);
+  AssertCastSucceeds(double_literal.CastTo(iceberg::float32()), TypeId::kFloat, 2.0f);
 }
 
 TEST(LiteralTest, DoubleCastToOverflow) {
@@ -264,8 +264,8 @@ TEST(LiteralTest, StringBasics) {
   EXPECT_EQ(string_literal.type()->type_id(), TypeId::kString);
   EXPECT_EQ(empty_string.type()->type_id(), TypeId::kString);
 
-  EXPECT_EQ(string_literal.ToString(), "hello world");
-  EXPECT_EQ(empty_string.ToString(), "");
+  EXPECT_EQ(string_literal.ToString(), "\"hello world\"");
+  EXPECT_EQ(empty_string.ToString(), "\"\"");
 }
 
 TEST(LiteralTest, StringComparison) {
@@ -305,6 +305,18 @@ TEST(LiteralTest, BinaryComparison) {
   EXPECT_EQ(binary2 <=> binary1, std::partial_ordering::greater);
 }
 
+TEST(LiteralTest, BinaryCastTo) {
+  std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
+  auto binary_literal = Literal::Binary(data4);
+
+  // Cast to Fixed with matching length
+  AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
+
+  // Cast to Fixed with different length should fail
+  EXPECT_THAT(binary_literal.CastTo(iceberg::fixed(5)),
+              IsError(ErrorKind::kInvalidArgument));
+}
+
 // Fixed type tests
 TEST(LiteralTest, FixedBasics) {
   std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0xFF};
@@ -332,6 +344,20 @@ TEST(LiteralTest, FixedComparison) {
   EXPECT_EQ(fixed2 <=> fixed1, std::partial_ordering::greater);
 }
 
+TEST(LiteralTest, FixedCastTo) {
+  std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
+  auto fixed_literal = Literal::Fixed(data4);
+
+  // Cast to Binary
+  AssertCastSucceeds(fixed_literal.CastTo(iceberg::binary()), TypeId::kBinary, data4);
+
+  // Cast to Fixed with same length
+  AssertCastSucceeds(fixed_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
+
+  // Cast to Fixed with different length should fail
+  EXPECT_THAT(fixed_literal.CastTo(iceberg::fixed(5)), IsError(ErrorKind::kNotSupported));
+}
+
 // Date type tests
 TEST(LiteralTest, DateBasics) {
   auto date_literal = Literal::Date(19489);  // May 15, 2023
@@ -422,32 +448,6 @@ TEST(LiteralTest, TimestampTzComparison) {
   EXPECT_EQ(timestamptz2 <=> timestamptz1, std::partial_ordering::greater);
 }
 
-TEST(LiteralTest, BinaryCastTo) {
-  std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
-  auto binary_literal = Literal::Binary(data4);
-
-  // Cast to Fixed with matching length
-  AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
-
-  // Cast to Fixed with different length should fail
-  EXPECT_THAT(binary_literal.CastTo(iceberg::fixed(5)),
-              IsError(ErrorKind::kInvalidArgument));
-}
-
-TEST(LiteralTest, FixedCastTo) {
-  std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
-  auto fixed_literal = Literal::Fixed(data4);
-
-  // Cast to Binary
-  AssertCastSucceeds(fixed_literal.CastTo(iceberg::binary()), TypeId::kBinary, data4);
-
-  // Cast to Fixed with same length
-  AssertCastSucceeds(fixed_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
-
-  // Cast to Fixed with different length should fail
-  EXPECT_THAT(fixed_literal.CastTo(iceberg::fixed(5)), IsError(ErrorKind::kNotSupported));
-}
-
 // Cross-type comparison tests
 TEST(LiteralTest, CrossTypeComparison) {
   auto int_literal = Literal::Int(42);
@@ -457,22 +457,18 @@ TEST(LiteralTest, CrossTypeComparison) {
   EXPECT_EQ(int_literal <=> string_literal, std::partial_ordering::unordered);
 }
 
-// Special value tests
-TEST(LiteralTest, SpecialValues) {
+// Same type cast tests
+TEST(LiteralTest, SameTypeCast) {
   auto int_literal = Literal::Int(42);
 
-  EXPECT_FALSE(int_literal.IsAboveMax());
-  EXPECT_FALSE(int_literal.IsBelowMin());
+  AssertCastSucceeds(int_literal.CastTo(iceberg::int32()), TypeId::kInt, 42);
 }
 
-// Same type cast test
-TEST(LiteralTest, SameTypeCast) {
+// Special value tests
+TEST(LiteralTest, SpecialValues) {
   auto int_literal = Literal::Int(42);
-
-  auto same_type_result = int_literal.CastTo(iceberg::int32());
-  ASSERT_THAT(same_type_result, IsOk());
-  EXPECT_EQ(same_type_result->type()->type_id(), TypeId::kInt);
-  EXPECT_EQ(same_type_result->ToString(), "42");
+  EXPECT_FALSE(int_literal.IsAboveMax());
+  EXPECT_FALSE(int_literal.IsBelowMin());
 }
 
 // Float special values tests

src/iceberg/transform_function.cc

@@ -27,6 +27,7 @@
 
 #include "iceberg/expression/literal.h"
 #include "iceberg/type.h"
+#include "iceberg/util/int128.h"
 #include "iceberg/util/murmurhash3_internal.h"
 #include "iceberg/util/truncate_util.h"