feat: Implement Type Casting and toString for Literals

Author: HeartLinked

src/iceberg/CMakeLists.txt

@@ -49,9 +49,10 @@ set(ICEBERG_SOURCES
     manifest_reader_internal.cc
     manifest_writer.cc
     arrow_c_data_guard_internal.cc
+    util/date_time_util.cc
+    util/gzip_internal.cc
     util/murmurhash3_internal.cc
-    util/timepoint.cc
-    util/gzip_internal.cc)
+    util/timepoint.cc)
 
 set(ICEBERG_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_SHARED_BUILD_INTERFACE_LIBS)

src/iceberg/expression/literal.cc

@@ -19,10 +19,13 @@
 
 #include "iceberg/expression/literal.h"
 
-#include <cmath>
 #include <concepts>
+#include <cstdint>
+
+#include <iceberg/result.h>
 
 #include "iceberg/exception.h"
+#include "iceberg/util/date_time_util.h"
 
 namespace iceberg {
 
@@ -52,6 +55,30 @@ class LiteralCaster {
   /// Cast from Float type to target type.
   static Result<Literal> CastFromFloat(const Literal& literal,
                                        const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from Double type to target type.
+  static Result<Literal> CastFromDouble(
+      const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from String type to target type.
+  static Result<Literal> CastFromString(
+      const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from Timestamp type to target type.
+  static Result<Literal> CastFromTimestamp(
+      const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from TimestampTz type to target type.
+  static Result<Literal> CastFromTimestampTz(
+      const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from Binary type to target type.
+  static Result<Literal> CastFromBinary(
+      const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type);
+
+  /// Cast from Fixed type to target type.
+  static Result<Literal> CastFromFixed(const Literal& literal,
+                                       const std::shared_ptr<PrimitiveType>& target_type);
 };
 
 Literal LiteralCaster::BelowMinLiteral(std::shared_ptr<PrimitiveType> type) {
@@ -74,6 +101,9 @@ Result<Literal> LiteralCaster::CastFromInt(
       return Literal::Float(static_cast<float>(int_val));
     case TypeId::kDouble:
       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());
@@ -83,15 +113,14 @@ Result<Literal> LiteralCaster::CastFromInt(
 Result<Literal> LiteralCaster::CastFromLong(
     const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
   auto long_val = std::get<int64_t>(literal.value_);
-  auto target_type_id = target_type->type_id();
 
-  switch (target_type_id) {
+  switch (target_type->type_id()) {
     case TypeId::kInt: {
       // Check for overflow
-      if (long_val >= std::numeric_limits<int32_t>::max()) {
+      if (long_val > std::numeric_limits<int32_t>::max()) {
         return AboveMaxLiteral(target_type);
       }
-      if (long_val <= std::numeric_limits<int32_t>::min()) {
+      if (long_val < std::numeric_limits<int32_t>::min()) {
         return BelowMinLiteral(target_type);
       }
       return Literal::Int(static_cast<int32_t>(long_val));
@@ -100,6 +129,22 @@ Result<Literal> LiteralCaster::CastFromLong(
       return Literal::Float(static_cast<float>(long_val));
     case TypeId::kDouble:
       return Literal::Double(static_cast<double>(long_val));
+    case TypeId::kDate: {
+      if (long_val > std::numeric_limits<int32_t>::max()) {
+        return AboveMaxLiteral(target_type);
+      }
+      if (long_val < std::numeric_limits<int32_t>::min()) {
+        return BelowMinLiteral(target_type);
+      }
+      return Literal::Date(static_cast<int32_t>(long_val));
+    }
+    case TypeId::kTime:
+      return Literal::Time(long_val);
+    case TypeId::kTimestamp:
+      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());
@@ -109,17 +154,141 @@ Result<Literal> LiteralCaster::CastFromLong(
 Result<Literal> LiteralCaster::CastFromFloat(
     const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
   auto float_val = std::get<float>(literal.value_);
-  auto target_type_id = target_type->type_id();
 
-  switch (target_type_id) {
+  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());
   }
 }
 
+Result<Literal> LiteralCaster::CastFromDouble(
+    const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  auto double_val = std::get<double>(literal.value_);
+
+  switch (target_type->type_id()) {
+    case TypeId::kFloat: {
+      if (double_val > static_cast<double>(std::numeric_limits<float>::max())) {
+        return AboveMaxLiteral(target_type);
+      }
+      if (double_val < static_cast<double>(std::numeric_limits<float>::lowest())) {
+        return BelowMinLiteral(target_type);
+      }
+      return Literal::Float(static_cast<float>(double_val));
+    }
+    default:
+      return NotSupported("Cast from Double to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
+Result<Literal> LiteralCaster::CastFromString(
+    const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  const auto& str_val = std::get<std::string>(literal.value_);
+
+  switch (target_type->type_id()) {
+    case TypeId::kDate: {
+      auto days_result = ParseDateString(str_val);
+      if (!days_result.has_value()) {
+        return std::unexpected(days_result.error());
+      }
+      return Literal::Date(days_result.value());
+    }
+
+    case TypeId::kTime: {
+      auto micros_result = ParseTimeString(str_val);
+      if (!micros_result.has_value()) {
+        return std::unexpected(micros_result.error());
+      }
+      return Literal::Time(micros_result.value());
+    }
+
+    case TypeId::kTimestamp: {
+      auto micros_result = ParseTimestampString(str_val);
+      if (!micros_result.has_value()) {
+        return std::unexpected(micros_result.error());
+      }
+      return Literal::Timestamp(micros_result.value());
+    }
+
+    case TypeId::kTimestampTz: {
+      auto micros_result = ParseTimestampTzString(str_val);
+      if (!micros_result.has_value()) {
+        return std::unexpected(micros_result.error());
+      }
+      return Literal::TimestampTz(micros_result.value());
+    }
+      // TODO(Li Feiyang): Implement cast from String to uuid and decimal
+
+    default:
+      return NotSupported("Cast from String to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
+Result<Literal> LiteralCaster::CastFromTimestamp(
+    const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  auto timestamp_val = std::get<int64_t>(literal.value_);
+
+  switch (target_type->type_id()) {
+    case TypeId::kDate:
+      return Literal::Date(MicrosToDays(timestamp_val));
+    case TypeId::kTimestampTz:
+      return Literal::TimestampTz(timestamp_val);
+    default:
+      return NotSupported("Cast from Timestamp to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
+Result<Literal> LiteralCaster::CastFromTimestampTz(
+    const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  auto micros = std::get<int64_t>(literal.value_);
+
+  switch (target_type->type_id()) {
+    case TypeId::kDate:
+      return Literal::Date(MicrosToDays(micros));
+    case TypeId::kTimestamp:
+      return Literal::Timestamp(micros);
+    default:
+      return NotSupported("Cast from TimestampTz to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
+Result<Literal> LiteralCaster::CastFromBinary(
+    const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  auto binary_val = std::get<std::vector<uint8_t>>(literal.value_);
+  switch (target_type->type_id()) {
+    case TypeId::kFixed: {
+      auto target_fixed_type = std::static_pointer_cast<FixedType>(target_type);
+      if (binary_val.size() == target_fixed_type->length()) {
+        return Literal::Fixed(std::move(binary_val));
+      }
+      return InvalidArgument("Failed to cast Binary with length {} to Fixed({})",
+                             binary_val.size(), target_fixed_type->length());
+    }
+    default:
+      return NotSupported("Cast from Binary to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
+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
+    default:
+      return NotSupported("Cast from Fixed to {} is not supported",
+                          target_type->ToString());
+  }
+}
+
 // Constructor
 Literal::Literal(Value value, std::shared_ptr<PrimitiveType> type)
     : value_(std::move(value)), type_(std::move(type)) {}
@@ -149,6 +318,11 @@ Literal Literal::Binary(std::vector<uint8_t> value) {
   return {Value{std::move(value)}, binary()};
 }
 
+Literal Literal::Fixed(std::vector<uint8_t> value) {
+  const auto size = value.size();
+  return {Value{std::move(value)}, fixed(size)};
+}
+
 Result<Literal> Literal::Deserialize(std::span<const uint8_t> data,
                                      std::shared_ptr<PrimitiveType> type) {
   return NotImplemented("Deserialization of Literal is not implemented yet");
@@ -216,6 +390,7 @@ std::partial_ordering Literal::operator<=>(const Literal& other) const {
     }
 
     case TypeId::kLong:
+    case TypeId::kTime:
     case TypeId::kTimestamp:
     case TypeId::kTimestampTz: {
       auto this_val = std::get<int64_t>(value_);
@@ -243,7 +418,8 @@ std::partial_ordering Literal::operator<=>(const Literal& other) const {
       return this_val <=> other_val;
     }
 
-    case TypeId::kBinary: {
+    case TypeId::kBinary:
+    case TypeId::kFixed: {
       auto& this_val = std::get<std::vector<uint8_t>>(value_);
       auto& other_val = std::get<std::vector<uint8_t>>(other.value_);
       return this_val <=> other_val;
@@ -285,23 +461,29 @@ std::string Literal::ToString() const {
     case TypeId::kString: {
       return std::get<std::string>(value_);
     }
-    case TypeId::kBinary: {
+    case TypeId::kBinary:
+    case TypeId::kFixed: {
       const auto& binary_data = std::get<std::vector<uint8_t>>(value_);
-      std::string result;
-      result.reserve(binary_data.size() * 2);  // 2 chars per byte
+      std::string result = "X'";
+      result.reserve(2 + binary_data.size() * 2 +
+                     1);  // 2 chars per byte and 2 + 1 for prefix and suffix
       for (const auto& byte : binary_data) {
         std::format_to(std::back_inserter(result), "{:02X}", byte);
       }
+      result.push_back('\'');
       return result;
     }
-    case TypeId::kDecimal:
-    case TypeId::kUuid:
-    case TypeId::kFixed:
-    case TypeId::kDate:
     case TypeId::kTime:
     case TypeId::kTimestamp:
     case TypeId::kTimestampTz: {
-      throw IcebergError("Not implemented: ToString for " + type_->ToString());
+      return std::to_string(std::get<int64_t>(value_));
+    }
+    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());
@@ -343,10 +525,18 @@ Result<Literal> LiteralCaster::CastTo(const Literal& literal,
     case TypeId::kFloat:
       return CastFromFloat(literal, target_type);
     case TypeId::kDouble:
-    case TypeId::kBoolean:
+      return CastFromDouble(literal, target_type);
     case TypeId::kString:
+      return CastFromString(literal, target_type);
     case TypeId::kBinary:
-      break;
+      return CastFromBinary(literal, target_type);
+    case TypeId::kFixed:
+      return CastFromFixed(literal, target_type);
+    case TypeId::kTimestamp:
+      return CastFromTimestamp(literal, target_type);
+    case TypeId::kTimestampTz:
+      return CastFromTimestampTz(literal, target_type);
+    case TypeId::kBoolean:
     default:
       break;
   }

src/iceberg/expression/literal.h

@@ -71,6 +71,7 @@ class ICEBERG_EXPORT Literal {
   static Literal Double(double value);
   static Literal String(std::string value);
   static Literal Binary(std::vector<uint8_t> value);
+  static Literal Fixed(std::vector<uint8_t> value);
 
   /// \brief Create a literal representing a null value.
   static Literal Null(std::shared_ptr<PrimitiveType> type) {