fix

Author: HeartLinked

src/iceberg/expression/literal.cc

@@ -27,6 +27,7 @@
 #include "iceberg/util/conversions.h"
 #include "iceberg/exception.h"
 #include "iceberg/type_fwd.h"
+#include "iceberg/util/checked_cast.h"
 #include "iceberg/util/macros.h"
 
 namespace iceberg {
@@ -237,7 +238,7 @@ Result<Literal> LiteralCaster::CastFromBinary(
   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);
+      auto target_fixed_type = internal::checked_pointer_cast<FixedType>(target_type);
       if (binary_val.size() == target_fixed_type->length()) {
         return Literal::Fixed(std::move(binary_val));
       }
@@ -404,13 +405,6 @@ 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";
   }
@@ -460,7 +454,7 @@ std::string Literal::ToString() const {
       return std::to_string(std::get<int32_t>(value_));
     }
     default: {
-      return unsupported_error();
+      return std::format("invalid literal of type {}", 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
+                             std::array<uint8_t, 16>,  // for uuid and decimal
                              BelowMin, AboveMax>;
 
   /// \brief Factory methods for primitive types

src/iceberg/expression/predicate.cc

@@ -100,12 +100,11 @@ std::string UnboundPredicate<B>::ToString() const {
       return values_.size() == 1 ? std::format("{} != {}", term, values_[0])
                                  : invalid_predicate_string(op);
     case Expression::Operation::kStartsWith:
-      return values_.size() == 1 ? std::format("{} startsWith \"{}\"", term, values_[0])
+      return values_.size() == 1 ? std::format("{} startsWith {}", term, values_[0])
                                  : invalid_predicate_string(op);
     case Expression::Operation::kNotStartsWith:
-      return values_.size() == 1
-                 ? std::format("{} notStartsWith \"{}\"", term, values_[0])
-                 : invalid_predicate_string(op);
+      return values_.size() == 1 ? std::format("{} notStartsWith {}", term, values_[0])
+                                 : invalid_predicate_string(op);
     case Expression::Operation::kIn:
       return std::format("{} in {}", term, values_);
     case Expression::Operation::kNotIn:

src/iceberg/test/literal_test.cc

@@ -38,8 +38,8 @@ template <typename T>
 void AssertCastSucceeds(const Result<Literal>& result, TypeId expected_type_id,
                         const T& expected_value) {
   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))
+  ASSERT_EQ(result->type()->type_id(), expected_type_id);
+  EXPECT_EQ(std::get<T>(result->value()), expected_value)
       << "Type mismatch in std::get. Expected type for TypeId "
       << static_cast<int>(expected_type_id);
 }
@@ -145,16 +145,14 @@ TEST(LiteralTest, LongCastTo) {
   AssertCastSucceeds(long_literal.CastTo(date()), TypeId::kDate, 42);
 
   // Cast to Time
-  AssertCastSucceeds(long_literal.CastTo(time()), TypeId::kTime,
-                     static_cast<int64_t>(42L));
+  AssertCastSucceeds(long_literal.CastTo(time()), TypeId::kTime, int64_t{42});
 
   // Cast to Timestamp
-  AssertCastSucceeds(long_literal.CastTo(timestamp()), TypeId::kTimestamp,
-                     static_cast<int64_t>(42L));
+  AssertCastSucceeds(long_literal.CastTo(timestamp()), TypeId::kTimestamp, int64_t{42});
 
   // Cast to TimestampTz
   AssertCastSucceeds(long_literal.CastTo(timestamp_tz()), TypeId::kTimestampTz,
-                     static_cast<int64_t>(42L));
+                     int64_t{42});
 }
 
 TEST(LiteralTest, LongCastToOverflow) {
@@ -207,8 +205,7 @@ TEST(LiteralTest, FloatCastTo) {
   auto float_literal = Literal::Float(2.0f);
 
   // Cast to Double
-  AssertCastSucceeds(float_literal.CastTo(float64()), TypeId::kDouble,
-                     static_cast<double>(2.0f));
+  AssertCastSucceeds(float_literal.CastTo(float64()), TypeId::kDouble, double{2.0f});
 }
 
 // Double type tests
@@ -242,10 +239,8 @@ TEST(LiteralTest, DoubleCastTo) {
 
 TEST(LiteralTest, DoubleCastToOverflow) {
   // Test overflow cases for Double to Float
-  auto max_double =
-      Literal::Double(static_cast<double>(std::numeric_limits<float>::max()) * 2);
-  auto min_double =
-      Literal::Double(-static_cast<double>(std::numeric_limits<float>::max()) * 2);
+  auto max_double = Literal::Double(double{std::numeric_limits<float>::max()} * 2);
+  auto min_double = Literal::Double(-double{std::numeric_limits<float>::max()} * 2);
 
   auto max_result = max_double.CastTo(float32());
   ASSERT_THAT(max_result, IsOk());
@@ -313,8 +308,7 @@ TEST(LiteralTest, BinaryCastTo) {
   AssertCastSucceeds(binary_literal.CastTo(fixed(4)), TypeId::kFixed, data4);
 
   // Cast to Fixed with different length should fail
-  EXPECT_THAT(binary_literal.CastTo(fixed(5)),
-              IsError(ErrorKind::kInvalidArgument));
+  EXPECT_THAT(binary_literal.CastTo(fixed(5)), IsError(ErrorKind::kInvalidArgument));
 }
 
 // Fixed type tests

src/iceberg/transform_function.cc

@@ -27,7 +27,6 @@
 
 #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"