feat: implement all functions of bound predicates (#280)

- Implemented `Negate`, `ToString` and `Test` functions for bound
predicate subclasses.
- Added hash support to `Literal`.
- Refactored `BoundSetPredicate` to use unordered set for literals.
- Refactored predicate unit test to be better organized.

Author: wgtmac

src/iceberg/expression/literal.cc

@@ -554,4 +554,51 @@ Result<Literal> LiteralCaster::CastTo(const Literal& literal,
                       target_type->ToString());
 }
 
+// LiteralValueHash implementation
+std::size_t LiteralValueHash::operator()(const Literal::Value& value) const noexcept {
+  return std::visit(
+      [](const auto& v) -> std::size_t {
+        using T = std::decay_t<decltype(v)>;
+
+        constexpr size_t kHashPrime = 0x9e3779b9;
+
+        if constexpr (std::is_same_v<T, std::monostate>) {
+          return 0;
+        } else if constexpr (std::is_same_v<T, Literal::BelowMin>) {
+          return std::numeric_limits<std::size_t>::min();
+        } else if constexpr (std::is_same_v<T, Literal::AboveMax>) {
+          return std::numeric_limits<std::size_t>::max();
+        } else if constexpr (std::is_same_v<T, bool> || 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, std::string>) {
+          return std::hash<T>{}(v);
+        } else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
+          std::size_t hash = 0;
+          for (size_t i = 0; i < v.size(); ++i) {
+            hash ^= std::hash<uint8_t>{}(v[i]) + kHashPrime + (hash << 6) + (hash >> 2);
+          }
+          return hash;
+        } else if constexpr (std::is_same_v<T, Decimal>) {
+          const int128_t& val = v.value();
+          std::size_t hash = std::hash<uint64_t>{}(static_cast<uint64_t>(val >> 64));
+          hash ^= std::hash<uint64_t>{}(static_cast<uint64_t>(val)) + kHashPrime +
+                  (hash << 6) + (hash >> 2);
+          return hash;
+        } else if constexpr (std::is_same_v<T, Uuid>) {
+          std::size_t hash = 0;
+          const auto& bytes = v.bytes();
+          for (size_t i = 0; i < bytes.size(); ++i) {
+            hash ^=
+                std::hash<uint8_t>{}(bytes[i]) + kHashPrime + (hash << 6) + (hash >> 2);
+          }
+          return hash;
+        } else {
+          static_assert(sizeof(T) == 0, "Unhandled variant type in LiteralValueHash");
+          return 0;
+        }
+      },
+      value);
+}
+
 }  // namespace iceberg

src/iceberg/expression/literal.h

@@ -166,79 +166,43 @@ class ICEBERG_EXPORT Literal : public util::Formattable {
   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;
+/// \brief Hash function for Literal to facilitate use in unordered containers
+struct ICEBERG_EXPORT LiteralValueHash {
+  std::size_t operator()(const Literal::Value& value) const noexcept;
 };
 
-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::kDecimal> {
-  using ValueType = Decimal;
-};
-
-template <>
-struct LiteralTraits<TypeId::kString> {
-  using ValueType = std::string;
+struct ICEBERG_EXPORT LiteralHash {
+  std::size_t operator()(const Literal& value) const noexcept {
+    return LiteralValueHash{}(value.value());
+  }
 };
 
-template <>
-struct LiteralTraits<TypeId::kUuid> {
-  using ValueType = Uuid;
+template <TypeId type_id>
+struct LiteralTraits {
+  using ValueType = void;
 };
 
-template <>
-struct LiteralTraits<TypeId::kBinary> {
-  using ValueType = std::vector<uint8_t>;
-};
+#define DEFINE_LITERAL_TRAIT(TYPE_ID, VALUE_TYPE) \
+  template <>                                     \
+  struct LiteralTraits<TypeId::TYPE_ID> {         \
+    using ValueType = VALUE_TYPE;                 \
+  };
 
-template <>
-struct LiteralTraits<TypeId::kFixed> {
-  using ValueType = std::vector<uint8_t>;
-};
+DEFINE_LITERAL_TRAIT(kBoolean, bool)
+DEFINE_LITERAL_TRAIT(kInt, int32_t)
+DEFINE_LITERAL_TRAIT(kDate, int32_t)
+DEFINE_LITERAL_TRAIT(kLong, int64_t)
+DEFINE_LITERAL_TRAIT(kTime, int64_t)
+DEFINE_LITERAL_TRAIT(kTimestamp, int64_t)
+DEFINE_LITERAL_TRAIT(kTimestampTz, int64_t)
+DEFINE_LITERAL_TRAIT(kFloat, float)
+DEFINE_LITERAL_TRAIT(kDouble, double)
+DEFINE_LITERAL_TRAIT(kDecimal, Decimal)
+DEFINE_LITERAL_TRAIT(kString, std::string)
+DEFINE_LITERAL_TRAIT(kUuid, Uuid)
+DEFINE_LITERAL_TRAIT(kBinary, std::vector<uint8_t>)
+DEFINE_LITERAL_TRAIT(kFixed, std::vector<uint8_t>)
+
+#undef DEFINE_LITERAL_TRAIT
 
 }  // namespace iceberg