feat: implement literal expressions with binary serialization support

Author: HeartLinked

src/iceberg/CMakeLists.txt

@@ -49,10 +49,11 @@ set(ICEBERG_SOURCES
     manifest_reader_internal.cc
     manifest_writer.cc
     arrow_c_data_guard_internal.cc
+    util/conversions.cc
     util/decimal.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

@@ -23,6 +23,7 @@
 #include <concepts>
 
 #include "iceberg/exception.h"
+#include "iceberg/util/conversions.h"
 
 namespace iceberg {
 
@@ -151,11 +152,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

@@ -143,11 +143,76 @@ class ICEBERG_EXPORT Literal {
  private:
   Literal(Value value, std::shared_ptr<PrimitiveType> type);
 
+  friend class Conversions;
   friend class LiteralCaster;
 
- private:
   Value value_;
   std::shared_ptr<PrimitiveType> type_;
 };
 
+template <TypeId type_id>
+struct LiteralTraits {
+  using ValueType = void;
+};
+
+template <>
+struct LiteralTraits<TypeId::kBoolean> {
+  using ValueType = bool;
+};
+
+template <>
+struct LiteralTraits<TypeId::kInt> {
+  using ValueType = int32_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kDate> {
+  using ValueType = int32_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kLong> {
+  using ValueType = int64_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kTime> {
+  using ValueType = int64_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kTimestamp> {
+  using ValueType = int64_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kTimestampTz> {
+  using ValueType = int64_t;
+};
+
+template <>
+struct LiteralTraits<TypeId::kFloat> {
+  using ValueType = float;
+};
+
+template <>
+struct LiteralTraits<TypeId::kDouble> {
+  using ValueType = double;
+};
+
+template <>
+struct LiteralTraits<TypeId::kString> {
+  using ValueType = std::string;
+};
+
+template <>
+struct LiteralTraits<TypeId::kBinary> {
+  using ValueType = std::vector<uint8_t>;
+};
+
+template <>
+struct LiteralTraits<TypeId::kFixed> {
+  using ValueType = std::vector<uint8_t>;
+};
+
 }  // namespace iceberg

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
@@ -386,4 +387,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

@@ -531,4 +531,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