feat: Literal adapt Uuid representation

Author: zhjwpku

src/iceberg/expression/literal.cc

@@ -145,6 +145,8 @@ Literal Literal::Double(double value) { return {Value{value}, float64()}; }
 
 Literal Literal::String(std::string value) { return {Value{std::move(value)}, string()}; }
 
+Literal Literal::UUID(Uuid value) { return {Value{std::move(value)}, uuid()}; }
+
 Literal Literal::Binary(std::vector<uint8_t> value) {
   return {Value{std::move(value)}, binary()};
 }
@@ -285,6 +287,9 @@ std::string Literal::ToString() const {
     case TypeId::kString: {
       return std::get<std::string>(value_);
     }
+    case TypeId::kUuid: {
+      return std::get<Uuid>(value_).ToString();
+    }
     case TypeId::kBinary: {
       const auto& binary_data = std::get<std::vector<uint8_t>>(value_);
       std::string result;
@@ -295,7 +300,6 @@ std::string Literal::ToString() const {
       return result;
     }
     case TypeId::kDecimal:
-    case TypeId::kUuid:
     case TypeId::kFixed:
     case TypeId::kDate:
     case TypeId::kTime:

src/iceberg/expression/literal.h

@@ -27,6 +27,7 @@
 
 #include "iceberg/result.h"
 #include "iceberg/type.h"
+#include "iceberg/util/uuid.h"
 
 namespace iceberg {
 
@@ -55,8 +56,9 @@ class ICEBERG_EXPORT Literal {
                              float,           // for float
                              double,          // for double
                              std::string,     // for string
+                             Uuid,            // for uuid
                              std::vector<uint8_t>,     // for binary, fixed
-                             std::array<uint8_t, 16>,  // for uuid and decimal
+                             std::array<uint8_t, 16>,  // for decimal
                              BelowMin, AboveMax>;
 
   /// \brief Factory methods for primitive types
@@ -70,6 +72,7 @@ class ICEBERG_EXPORT Literal {
   static Literal Float(float value);
   static Literal Double(double value);
   static Literal String(std::string value);
+  static Literal UUID(Uuid value);
   static Literal Binary(std::vector<uint8_t> value);
 
   /// \brief Create a literal representing a null value.

src/iceberg/test/literal_test.cc

@@ -217,6 +217,15 @@ TEST(LiteralTest, StringBasics) {
   EXPECT_EQ(empty_string.ToString(), "");
 }
 
+// Uuid type tests
+TEST(LiteralTest, UuidBasics) {
+  auto uuid = Uuid::FromString("123e4567-e89b-12d3-a456-426614174000").value();
+  auto uuid_literal = Literal::UUID(uuid);
+
+  EXPECT_EQ(uuid_literal.type()->type_id(), TypeId::kUuid);
+  EXPECT_EQ(uuid_literal.ToString(), "123e4567-e89b-12d3-a456-426614174000");
+}
+
 TEST(LiteralTest, StringComparison) {
   auto string1 = Literal::String("apple");
   auto string2 = Literal::String("banana");

src/iceberg/transform_function.cc

@@ -29,6 +29,7 @@
 #include "iceberg/type.h"
 #include "iceberg/util/murmurhash3_internal.h"
 #include "iceberg/util/truncate_util.h"
+#include "iceberg/util/uuid.h"
 
 namespace iceberg {
 
@@ -75,6 +76,9 @@ Result<Literal> BucketTransform::Transform(const Literal& literal) {
           MurmurHash3_x86_32(value.data(), sizeof(uint8_t) * 16, 0, &hash_value);
         } else if constexpr (std::is_same_v<T, std::string>) {
           MurmurHash3_x86_32(value.data(), value.size(), 0, &hash_value);
+        } else if constexpr (std::is_same_v<T, Uuid>) {
+          MurmurHash3_x86_32(std::get<Uuid>(literal.value()).bytes().data(),
+                             Uuid::kLength, 0, &hash_value);
         } else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
           MurmurHash3_x86_32(value.data(), value.size(), 0, &hash_value);
         } else if constexpr (std::is_same_v<T, std::monostate> ||