feat: implement literal expressions with binary serialization support

Author: HeartLinked

src/iceberg/CMakeLists.txt

@@ -52,7 +52,9 @@ set(ICEBERG_SOURCES
     util/decimal.cc
     util/murmurhash3_internal.cc
     util/timepoint.cc
-    util/gzip_internal.cc)
+    util/gzip_internal.cc
+    util/conversions.cc
+    util/literal_format.cc)
 
 set(ICEBERG_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_SHARED_BUILD_INTERFACE_LIBS)

src/iceberg/expression/literal.cc

@@ -23,6 +23,8 @@
 #include <concepts>
 
 #include "iceberg/exception.h"
+#include "iceberg/util/conversions.h"
+#include "iceberg/util/literal_format.h"
 
 namespace iceberg {
 
@@ -151,11 +153,11 @@ Literal Literal::Binary(std::vector<uint8_t> value) {
 
 Result<Literal> Literal::Deserialize(std::span<const uint8_t> data,
                                      std::shared_ptr<PrimitiveType> type) {
-  return NotImplemented("Deserialization of Literal is not implemented yet");
+  return Conversions::FromBytes(type, data);
 }
 
 Result<std::vector<uint8_t>> Literal::Serialize() const {
-  return NotImplemented("Serialization of Literal is not implemented yet");
+  return Conversions::ToBytes(*this);
 }
 
 // Getters

src/iceberg/expression/literal.h

@@ -144,8 +144,8 @@ class ICEBERG_EXPORT Literal {
   Literal(Value value, std::shared_ptr<PrimitiveType> type);
 
   friend class LiteralCaster;
+  friend class Conversions;
 
- private:
   Value value_;
   std::shared_ptr<PrimitiveType> type_;
 };

src/iceberg/type.cc

@@ -22,6 +22,7 @@
 #include <format>
 #include <iterator>
 #include <memory>
+#include <utility>
 
 #include "iceberg/exception.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
@@ -390,4 +391,45 @@ std::shared_ptr<StructType> struct_(std::vector<SchemaField> fields) {
   return std::make_shared<StructType>(std::move(fields));
 }
 
+std::string_view ToString(TypeId id) {
+  switch (id) {
+    case TypeId::kStruct:
+      return "struct";
+    case TypeId::kList:
+      return "list";
+    case TypeId::kMap:
+      return "map";
+    case TypeId::kBoolean:
+      return "boolean";
+    case TypeId::kInt:
+      return "int";
+    case TypeId::kLong:
+      return "long";
+    case TypeId::kFloat:
+      return "float";
+    case TypeId::kDouble:
+      return "double";
+    case TypeId::kDecimal:
+      return "decimal";
+    case TypeId::kDate:
+      return "date";
+    case TypeId::kTime:
+      return "time";
+    case TypeId::kTimestamp:
+      return "timestamp";
+    case TypeId::kTimestampTz:
+      return "timestamptz";
+    case TypeId::kString:
+      return "string";
+    case TypeId::kUuid:
+      return "uuid";
+    case TypeId::kFixed:
+      return "fixed";
+    case TypeId::kBinary:
+      return "binary";
+  }
+
+  std::unreachable();
+}
+
 }  // namespace iceberg

src/iceberg/type.h

@@ -520,4 +520,13 @@ ICEBERG_EXPORT std::shared_ptr<MapType> map(SchemaField key, SchemaField value);
 
 /// @}
 
+/// \brief Get the lowercase string representation of a TypeId.
+///
+/// This returns the same lowercase string as used by Type::ToString() methods.
+/// For example: TypeId::kBoolean -> "boolean", TypeId::kInt -> "int", etc.
+///
+/// \param id The TypeId to convert to string
+/// \return A string_view containing the lowercase type name
+ICEBERG_EXPORT std::string_view ToString(TypeId id);
+
 }  // namespace iceberg