feat: implement literal expressions with binary serialization support

Author: HeartLinked

src/iceberg/CMakeLists.txt

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

src/iceberg/expression/literal.cc

@@ -24,7 +24,6 @@
 
 #include "iceberg/exception.h"
 #include "iceberg/util/conversions.h"
-#include "iceberg/util/literal_format.h"
 
 namespace iceberg {
 
@@ -153,7 +152,7 @@ Literal Literal::Binary(std::vector<uint8_t> value) {
 
 Result<Literal> Literal::Deserialize(std::span<const uint8_t> data,
                                      std::shared_ptr<PrimitiveType> type) {
-  return Conversions::FromBytes(type, data);
+  return Conversions::FromBytes(std::move(type), data);
 }
 
 Result<std::vector<uint8_t>> Literal::Serialize() const {

src/iceberg/util/conversions.cc

@@ -19,17 +19,36 @@
 
 #include "iceberg/util/conversions.h"
 
-#include <cctype>
-#include <cstring>
-#include <ranges>
+#include <array>
+#include <span>
+#include <string>
 
-#include "iceberg/exception.h"
-#include "iceberg/type.h"
 #include "iceberg/util/endian.h"
 #include "iceberg/util/macros.h"
 
 namespace iceberg {
 
+/// \brief Write a value in little-endian format to the buffer.
+template <EndianConvertible T>
+void WriteLittleEndian(std::vector<uint8_t>& buffer, T value) {
+  value = ToLittleEndian(value);
+  const auto* bytes = reinterpret_cast<const uint8_t*>(&value);
+  buffer.insert(buffer.end(), bytes, bytes + sizeof(T));
+}
+
+/// \brief Read a value in little-endian format from the data.
+template <EndianConvertible T>
+Result<T> ReadLittleEndian(std::span<const uint8_t> data) {
+  if (data.size() < sizeof(T)) [[unlikely]] {
+    return InvalidArgument("Insufficient data to read {} bytes, got {}", sizeof(T),
+                           data.size());
+  }
+
+  T value;
+  std::memcpy(&value, data.data(), sizeof(T));
+  return FromLittleEndian(value);
+}
+
 Result<std::vector<uint8_t>> Conversions::ToBytes(const PrimitiveType& type,
                                                   const Literal::Value& value) {
   std::vector<uint8_t> result;
@@ -123,13 +142,7 @@ Result<std::vector<uint8_t>> Conversions::ToBytes(const PrimitiveType& type,
       }
       return result;
     }
-
-    case TypeId::kUuid: {
-      // 16-byte big-endian value
-      const auto& uuid_bytes = std::get<std::array<uint8_t, 16>>(value);
-      WriteBigEndian16(result, uuid_bytes);
-      return result;
-    }
+      // TODO(Li Feiyang): Add support for UUID and Decimal
 
     default:
       return NotSupported("Serialization for type {} is not supported", type.ToString());
@@ -255,27 +268,7 @@ Result<Literal::Value> Conversions::FromBytes(const PrimitiveType& type,
         return Literal::Value{std::vector<uint8_t>(data.begin(), data.end())};
       }
     }
-
-    case TypeId::kUuid: {
-      if (data.size() != 16) {
-        return InvalidArgument("UUID requires 16 bytes, got {}", data.size());
-      }
-      ICEBERG_ASSIGN_OR_RAISE(auto uuid_value, ReadBigEndian16(data));
-      return Literal::Value{uuid_value};
-    }
-
-    case TypeId::kDecimal: {
-      if (data.size() > 16) {
-        return InvalidArgument(
-            "Decimal data too large, maximum 16 bytes supported, got {}", data.size());
-      }
-
-      std::array<uint8_t, 16> decimal_bytes{};
-      // Copy data to the end of the array (big-endian format for decimals)
-      // This handles variable-length decimals by right-aligning them
-      std::ranges::copy(data, decimal_bytes.end() - data.size());
-      return Literal::Value{decimal_bytes};
-    }
+      // TODO(Li Feiyang): Add support for UUID and Decimal
 
     default:
       return NotSupported("Deserialization for type {} is not supported",

src/iceberg/util/conversions.h

@@ -19,12 +19,12 @@
 
 #pragma once
 
+#include <span>
 #include <vector>
 
 #include "iceberg/expression/literal.h"
-#include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
-#include "iceberg/type.h"
+#include "iceberg/type_fwd.h"
 
 namespace iceberg {
 class ICEBERG_EXPORT Conversions {

src/iceberg/util/endian.h

@@ -19,26 +19,25 @@
 
 #pragma once
 
-#include <algorithm>
+#include <array>
 #include <bit>
-#include <cstring>
-#include <span>
-#include <vector>
-
-#include "iceberg/result.h"
+#include <concepts>
 
 /// \file iceberg/util/endian.h
 /// \brief Endianness conversion utilities
 
 namespace iceberg {
 
+/// \brief Concept for values that can be written in little-endian format.
+template <typename T>
+concept EndianConvertible = std::is_arithmetic_v<T>;
+
+/// \brief Concept for values that can be written in big-endian format,
 template <typename T>
-concept LittleEndianWritable =
-    std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t> ||
-    std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, uint8_t>;
+concept BigEndianWritable = std::same_as<T, std::array<uint8_t, 16>>;
 
 /// \brief Convert a value to little-endian format.
-template <LittleEndianWritable T>
+template <EndianConvertible T>
 T ToLittleEndian(T value) {
   if constexpr (std::endian::native != std::endian::little && sizeof(T) > 1) {
     return std::byteswap(value);
@@ -47,47 +46,31 @@ T ToLittleEndian(T value) {
 }
 
 /// \brief Convert a value from little-endian format.
-template <LittleEndianWritable T>
+template <EndianConvertible T>
 T FromLittleEndian(T value) {
-  return ToLittleEndian(value);
-}
-
-/// \brief Write a value in little-endian format to the buffer.
-template <LittleEndianWritable T>
-void WriteLittleEndian(std::vector<uint8_t>& buffer, T value) {
-  T le_value = ToLittleEndian(value);
-  const auto* bytes = reinterpret_cast<const uint8_t*>(&le_value);
-  buffer.insert(buffer.end(), bytes, bytes + sizeof(T));
-}
-
-/// \brief Read a value in little-endian format from the data.
-template <LittleEndianWritable T>
-Result<T> ReadLittleEndian(std::span<const uint8_t> data) {
-  if (data.size() < sizeof(T)) [[unlikely]] {
-    return InvalidArgument("Insufficient data to read {} bytes, got {}", sizeof(T),
-                           data.size());
+  if constexpr (std::endian::native != std::endian::little && sizeof(T) > 1) {
+    return std::byteswap(value);
   }
-
-  T value;
-  std::memcpy(&value, data.data(), sizeof(T));
-  return FromLittleEndian(value);
+  return value;
 }
 
-/// \brief Write a 16-byte value in big-endian format (for UUID and Decimal).
-inline void WriteBigEndian16(std::vector<uint8_t>& buffer,
-                             const std::array<uint8_t, 16>& value) {
-  buffer.insert(buffer.end(), value.begin(), value.end());
+template <EndianConvertible T>
+constexpr T ToBigEndian(T value) {
+  if constexpr (std::endian::native == std::endian::big || sizeof(T) <= 1) {
+    return value;
+  } else {
+    return std::byteswap(value);
+  }
 }
 
-/// \brief Read a 16-byte value in big-endian format (for UUID and Decimal).
-inline Result<std::array<uint8_t, 16>> ReadBigEndian16(std::span<const uint8_t> data) {
-  if (data.size() < 16) {
-    return InvalidArgument("Insufficient data to read 16 bytes, got {}", data.size());
+/// \brief Convert a value from big-endian format to native.
+template <EndianConvertible T>
+constexpr T FromBigEndian(T value) {
+  if constexpr (std::endian::native == std::endian::big || sizeof(T) <= 1) {
+    return value;
+  } else {
+    return std::byteswap(value);
   }
-
-  std::array<uint8_t, 16> result;
-  std::copy(data.begin(), data.begin() + 16, result.begin());
-  return result;
 }
 
 }  // namespace iceberg