tmp

Author: HeartLinked

src/iceberg/CMakeLists.txt

@@ -50,6 +50,7 @@ set(ICEBERG_SOURCES
     manifest_writer.cc
     arrow_c_data_guard_internal.cc
     util/decimal.cc
+    util/gzip_internal.cc
     util/murmurhash3_internal.cc
     util/timepoint.cc)
 

src/iceberg/expression/literal.cc

@@ -21,8 +21,10 @@
 
 #include <concepts>
 #include <cstdint>
+#include <string>
 
 #include "iceberg/exception.h"
+#include "iceberg/type_fwd.h"
 
 namespace iceberg {
 
@@ -294,6 +296,15 @@ Literal Literal::Fixed(std::vector<uint8_t> value) {
   return {Value{std::move(value)}, fixed(size)};
 }
 
+Literal Literal::Decimal(const iceberg::Decimal& value, int32_t precision,
+                         int32_t scale) {
+  return {Value{value.value()}, decimal(precision, scale)};
+}
+
+Literal Literal::Decimal(int128_t value, int32_t precision, int32_t scale) {
+  return {Value{value}, decimal(precision, scale)};
+}
+
 Result<Literal> Literal::Deserialize(std::span<const uint8_t> data,
                                      std::shared_ptr<PrimitiveType> type) {
   return NotImplemented("Deserialization of Literal is not implemented yet");
@@ -403,6 +414,8 @@ std::partial_ordering Literal::operator<=>(const Literal& other) const {
 }
 
 std::string Literal::ToString() const {
+  auto invalid_ = [this]() { return std::format(" = {}", type_->ToString()); };
+
   if (std::holds_alternative<BelowMin>(value_)) {
     return "belowMin";
   }
@@ -452,9 +465,20 @@ std::string Literal::ToString() const {
     case TypeId::kDate: {
       return std::to_string(std::get<int32_t>(value_));
     }
-    case TypeId::kDecimal:
+    case TypeId::kDecimal: {
+      const auto unscaled_value = std::get<int128_t>(value_);
+      auto decimal_type = std::static_pointer_cast<DecimalType>(type_);
+      int32_t scale = decimal_type->scale();
+
+      iceberg::Decimal decimal_val(unscaled_value);
+      Result<std::string> str_res = decimal_val.ToString(scale);
+      if (str_res.has_value()) {
+        return str_res.value();
+      }
+      return
+    }
     case TypeId::kUuid: {
-      throw NotImplemented("kDecimal and kUuid are not implemented yet");
+      return {"kDecimal and kUuid are not implemented yet"};
     }
     default: {
       throw IcebergError("Unknown type: " + type_->ToString());

src/iceberg/expression/literal.h

@@ -27,6 +27,8 @@
 
 #include "iceberg/result.h"
 #include "iceberg/type.h"
+#include "iceberg/util/decimal.h"
+#include "iceberg/util/int128.h"
 
 namespace iceberg {
 
@@ -56,7 +58,8 @@ class ICEBERG_EXPORT Literal {
                              double,          // for double
                              std::string,     // for string
                              std::vector<uint8_t>,     // for binary, fixed
-                             std::array<uint8_t, 16>,  // for uuid and decimal
+                             std::array<uint8_t, 16>,  // for uuid
+                             int128_t,                 // for decimal
                              BelowMin, AboveMax>;
 
   /// \brief Factory methods for primitive types
@@ -73,6 +76,10 @@ class ICEBERG_EXPORT Literal {
   static Literal Binary(std::vector<uint8_t> value);
   static Literal Fixed(std::vector<uint8_t> value);
 
+  /// \brief Factory methods for decimal type
+  static Literal Decimal(const Decimal& value, int32_t precision, int32_t scale);
+  static Literal Decimal(int128_t value, int32_t precision, int32_t scale);
+
   /// \brief Create a literal representing a null value.
   static Literal Null(std::shared_ptr<PrimitiveType> type) {
     return {Value{std::monostate{}}, std::move(type)};
@@ -139,7 +146,7 @@ class ICEBERG_EXPORT Literal {
   /// \return true if this literal is null, false otherwise
   bool IsNull() const;
 
-  std::string ToString() const;
+  Result<std::string> ToString() const;
 
  private:
   Literal(Value value, std::shared_ptr<PrimitiveType> type);