1

Author: HeartLinked

src/iceberg/expression/literal.cc

@@ -22,6 +22,8 @@
 #include <chrono>
 #include <cmath>
 #include <concepts>
+#include <cstdint>
+#include <iomanip>
 
 #include "iceberg/exception.h"
 
@@ -35,6 +37,14 @@ int32_t MicrosToDays(int64_t micros_since_epoch) {
   return static_cast<int32_t>(days_duration.count());
 }
 
+time_t timegm_custom(std::tm* tm) {
+#if defined(_WIN32)
+  return _mkgmtime(tm);
+#else
+  return timegm(tm);
+#endif
+}
+
 }  // namespace
 
 /// \brief LiteralCaster handles type casting operations for Literal.
@@ -111,6 +121,7 @@ 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());
@@ -137,10 +148,10 @@ Result<Literal> LiteralCaster::CastFromLong(
     case TypeId::kDouble:
       return Literal::Double(static_cast<double>(long_val));
     case TypeId::kDate: {
-      if (long_val > static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
+      if (long_val > std::numeric_limits<int32_t>::max()) {
         return AboveMaxLiteral(target_type);
       }
-      if (long_val < static_cast<int64_t>(std::numeric_limits<int32_t>::min())) {
+      if (long_val < std::numeric_limits<int32_t>::min()) {
         return BelowMinLiteral(target_type);
       }
       return Literal::Date(static_cast<int32_t>(long_val));
@@ -151,6 +162,7 @@ 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());
@@ -164,6 +176,7 @@ 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());
@@ -192,30 +205,129 @@ Result<Literal> LiteralCaster::CastFromDouble(
 
 Result<Literal> LiteralCaster::CastFromString(
     const Literal& literal, const std::shared_ptr<PrimitiveType>& target_type) {
+  const auto& str_val = std::get<std::string>(literal.value_);
+  std::istringstream in{str_val};
+  std::tm tm = {};
+
   switch (target_type->type_id()) {
     case TypeId::kDate: {
-      // TODO(Li Feiyang): Implement parsing for "YYYY-MM-DD" using std::chrono::parse
-      // once it becomes available in the target libc++.
-      return NotImplemented("Cast from String to Date is not yet implemented.");
+      // Parse "YYYY-MM-DD" into days since 1970-01-01 epoch.
+      in >> std::get_time(&tm, "%Y-%m-%d");
+
+      if (in.fail() || in.peek() != EOF) {
+        return NotSupported("Failed to parse '{}' as a valid Date (expected YYYY-MM-DD)",
+                            str_val);
+      }
+
+      auto time_point = std::chrono::system_clock::from_time_t(timegm_custom(&tm));
+      auto days_since_epoch = std::chrono::floor<std::chrono::days>(time_point);
+      return Literal::Date(
+          static_cast<int32_t>(days_since_epoch.time_since_epoch().count()));
     }
 
     case TypeId::kTime: {
-      // TODO(Li Feiyang): Implement parsing for "HH:MM:SS.ffffff" using
-      // std::chrono::parse once it becomes available in the target libc++.
-      return NotImplemented("Cast from String to Time is not yet implemented.");
-    }
+      // Parse "HH:MM:SS.ffffff" into microseconds since midnight.
+      in >> std::get_time(&tm, "%H:%M:%S");
 
-    case TypeId::kTimestamp: {
-      // TODO(Li Feiyang): Implement parsing for "YYYY-MM-DDTHH:MM:SS.ffffff" using
-      // std::chrono::parse once it becomes available in the target libc++.
-      return NotImplemented("Cast from String to Timestamp is not yet implemented.");
+      if (in.fail()) {
+        return NotSupported(
+            "Failed to parse '{}' as a valid Time (expected HH:MM:SS.ffffff)", str_val);
+      }
+
+      int64_t total_micros =
+          (tm.tm_hour * 3600LL + tm.tm_min * 60LL + tm.tm_sec) * 1000000LL;
+
+      if (in.peek() == '.') {
+        in.ignore();
+        std::string fractional_str;
+        char c;
+        while (in.get(c) && isdigit(c)) {
+          fractional_str += c;
+        }
+        if (in) {
+          in.unget();
+        }
+
+        if (fractional_str.length() > 6) {
+          fractional_str.resize(6);
+        }
+        try {
+          if (!fractional_str.empty()) {
+            fractional_str.append(6 - fractional_str.length(), '0');
+            total_micros += std::stoll(fractional_str);
+          }
+        } catch (const std::exception&) {
+          return NotSupported("Failed to parse fractional part of Time '{}'", str_val);
+        }
+      }
+
+      if (in.peek() != EOF) {
+        return NotSupported("Unconsumed characters found after parsing Time '{}'",
+                            str_val);
+      }
+
+      return Literal::Time(total_micros);
     }
 
+    case TypeId::kTimestamp:
     case TypeId::kTimestampTz: {
-      // TODO(Li Feiyang): Implement parsing for "YYYY-MM-DDTHH:MM:SS.ffffffZ" using
-      // std::chrono::parse once it becomes available in the target libc++.
-      return NotImplemented("Cast from String to TimestampTz is not yet implemented.");
+      // Parse "YYYY-MM-DDTHH:MM:SS.ffffff" and optional 'Z'
+      in >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+
+      if (in.fail()) {
+        return NotSupported(
+            "Failed to parse '{}' as a valid Timestamp (expected YYYY-MM-DDTHH:MM:SS...)",
+            str_val);
+      }
+
+      auto seconds_since_epoch = timegm_custom(&tm);
+      int64_t total_micros = seconds_since_epoch * 1000000LL;
+
+      if (in.peek() == '.') {
+        in.ignore();
+        std::string fractional_str;
+        char c;
+        while (in.get(c) && isdigit(c)) {
+          fractional_str += c;
+        }
+        if (in) {
+          in.unget();
+        }
+
+        if (fractional_str.length() > 6) {
+          fractional_str.resize(6);
+        }
+        try {
+          if (!fractional_str.empty()) {
+            fractional_str.append(6 - fractional_str.length(), '0');
+            total_micros += std::stoll(fractional_str);
+          }
+        } catch (const std::exception&) {
+          return NotSupported("Failed to parse fractional part of Timestamp '{}'",
+                              str_val);
+        }
+      }
+
+      if (target_type->type_id() == TypeId::kTimestampTz) {
+        // NOTE: This implementation DOES NOT support timezone offsets like
+        // '+08:00' or '-07:00'. It only supports the UTC designator 'Z'.
+        if (in.peek() == 'Z') {
+          in.ignore();  // Consume 'Z'
+        }
+      }
+
+      if (in.peek() != EOF) {
+        return NotSupported("Unconsumed characters found after parsing Timestamp '{}'",
+                            str_val);
+      }
+
+      if (target_type->type_id() == TypeId::kTimestamp) {
+        return Literal::Timestamp(total_micros);
+      } else {
+        return Literal::TimestampTz(total_micros);
+      }
     }
+      // TODO(Li Feiyang): Implement cast from String to uuid and decimal
 
     default:
       return NotSupported("Cast from String to {} is not supported",
@@ -281,14 +393,6 @@ Result<Literal> LiteralCaster::CastFromFixed(
     case TypeId::kBinary: {
       return Literal::Binary(fixed_val);
     }
-    case TypeId::kFixed: {
-      auto target_fixed_type = std::dynamic_pointer_cast<FixedType>(target_type);
-      if (fixed_val.size() == target_fixed_type->length()) {
-        return literal;
-      }
-      return NotSupported("Cannot cast Fixed({}) to Fixed({}) due to mismatched lengths",
-                          fixed_val.size(), target_fixed_type->length());
-    }
     default:
       return NotSupported("Cast from Fixed to {} is not supported",
                           target_type->ToString());

test/literal_test.cc

@@ -534,14 +534,6 @@ TEST(LiteralTest, CrossTypeComparison) {
   EXPECT_EQ(int_literal <=> string_literal, std::partial_ordering::unordered);
 }
 
-// Special value tests
-TEST(LiteralTest, SpecialValues) {
-  auto int_literal = Literal::Int(42);
-
-  EXPECT_FALSE(int_literal.IsAboveMax());
-  EXPECT_FALSE(int_literal.IsBelowMin());
-}
-
 // Same type cast test
 TEST(LiteralTest, SameTypeCast) {
   auto int_literal = Literal::Int(42);