add test function

Author: wgtmac

src/iceberg/expression/predicate.cc

@@ -20,9 +20,9 @@
 #include "iceberg/expression/predicate.h"
 
 #include <algorithm>
+#include <cmath>
 #include <format>
 
-#include "iceberg/exception.h"
 #include "iceberg/expression/expressions.h"
 #include "iceberg/expression/literal.h"
 #include "iceberg/result.h"
@@ -143,6 +143,26 @@ bool IsFloatingType(TypeId type) {
   return type == TypeId::kFloat || type == TypeId::kDouble;
 }
 
+bool IsNan(const Literal& literal) {
+  const auto& value = literal.value();
+  if (std::holds_alternative<float>(value)) {
+    return std::isnan(std::get<float>(value));
+  } else if (std::holds_alternative<double>(value)) {
+    return std::isnan(std::get<double>(value));
+  }
+  return false;
+}
+
+bool StartsWith(const Literal& lhs, const Literal& rhs) {
+  const auto& lhs_value = lhs.value();
+  const auto& rhs_value = rhs.value();
+  if (std::holds_alternative<std::string>(lhs_value) &&
+      std::holds_alternative<std::string>(rhs_value)) {
+    return std::get<std::string>(lhs_value).starts_with(std::get<std::string>(rhs_value));
+  }
+  return false;
+}
+
 }  // namespace
 
 template <typename B>
@@ -287,10 +307,10 @@ BoundPredicate::BoundPredicate(Expression::Operation op, std::shared_ptr<BoundTe
 
 BoundPredicate::~BoundPredicate() = default;
 
-Result<Literal::Value> BoundPredicate::Evaluate(const StructLike& data) const {
+Result<Literal> BoundPredicate::Evaluate(const StructLike& data) const {
   ICEBERG_ASSIGN_OR_RAISE(auto eval_result, term_->Evaluate(data));
   ICEBERG_ASSIGN_OR_RAISE(auto test_result, Test(eval_result));
-  return Literal::Value{test_result};
+  return Literal::Boolean(test_result);
 }
 
 // BoundUnaryPredicate implementation
@@ -300,8 +320,19 @@ BoundUnaryPredicate::BoundUnaryPredicate(Expression::Operation op,
 
 BoundUnaryPredicate::~BoundUnaryPredicate() = default;
 
-Result<bool> BoundUnaryPredicate::Test(const Literal::Value& value) const {
-  return NotImplemented("BoundUnaryPredicate::Test not implemented");
+Result<bool> BoundUnaryPredicate::Test(const Literal& literal) const {
+  switch (op()) {
+    case Expression::Operation::kIsNull:
+      return literal.IsNull();
+    case Expression::Operation::kNotNull:
+      return !literal.IsNull();
+    case Expression::Operation::kIsNan:
+      return IsNan(literal);
+    case Expression::Operation::kNotNan:
+      return !IsNan(literal);
+    default:
+      return InvalidExpression("Invalid operation for BoundUnaryPredicate: {}", op());
+  }
 }
 
 Result<std::shared_ptr<Expression>> BoundUnaryPredicate::Negate() const {
@@ -345,8 +376,27 @@ BoundLiteralPredicate::BoundLiteralPredicate(Expression::Operation op,
 
 BoundLiteralPredicate::~BoundLiteralPredicate() = default;
 
-Result<bool> BoundLiteralPredicate::Test(const Literal::Value& value) const {
-  return NotImplemented("BoundLiteralPredicate::Test not implemented");
+Result<bool> BoundLiteralPredicate::Test(const Literal& value) const {
+  switch (op()) {
+    case Expression::Operation::kLt:
+      return value < literal_;
+    case Expression::Operation::kLtEq:
+      return value <= literal_;
+    case Expression::Operation::kGt:
+      return value > literal_;
+    case Expression::Operation::kGtEq:
+      return value >= literal_;
+    case Expression::Operation::kEq:
+      return value == literal_;
+    case Expression::Operation::kNotEq:
+      return value != literal_;
+    case Expression::Operation::kStartsWith:
+      return StartsWith(value, literal_);
+    case Expression::Operation::kNotStartsWith:
+      return !StartsWith(value, literal_);
+    default:
+      return InvalidExpression("Invalid operation for BoundLiteralPredicate: {}", op());
+  }
 }
 
 Result<std::shared_ptr<Expression>> BoundLiteralPredicate::Negate() const {
@@ -453,8 +503,15 @@ BoundSetPredicate::BoundSetPredicate(Expression::Operation op,
 
 BoundSetPredicate::~BoundSetPredicate() = default;
 
-Result<bool> BoundSetPredicate::Test(const Literal::Value& value) const {
-  return NotImplemented("BoundSetPredicate::Test not implemented");
+Result<bool> BoundSetPredicate::Test(const Literal& value) const {
+  switch (op()) {
+    case Expression::Operation::kIn:
+      return value_set_.contains(value);
+    case Expression::Operation::kNotIn:
+      return !value_set_.contains(value);
+    default:
+      return InvalidExpression("Invalid operation for BoundSetPredicate: {}", op());
+  }
 }
 
 Result<std::shared_ptr<Expression>> BoundSetPredicate::Negate() const {

src/iceberg/expression/predicate.h

@@ -113,13 +113,13 @@ class ICEBERG_EXPORT BoundPredicate : public Predicate<BoundTerm>, public Bound
 
   std::shared_ptr<BoundReference> reference() override { return term_->reference(); }
 
-  Result<Literal::Value> Evaluate(const StructLike& data) const override;
+  Result<Literal> Evaluate(const StructLike& data) const override;
 
   /// \brief Test a value against this predicate.
   ///
-  /// \param value The value to test
+  /// \param value The literal value to test
   /// \return true if the predicate passes, false otherwise
-  virtual Result<bool> Test(const Literal::Value& value) const = 0;
+  virtual Result<bool> Test(const Literal& value) const = 0;
 
   enum class Kind : int8_t {
     // A unary predicate (tests for null, not-null, etc.).
@@ -145,7 +145,7 @@ class ICEBERG_EXPORT BoundUnaryPredicate : public BoundPredicate {
 
   ~BoundUnaryPredicate() override;
 
-  Result<bool> Test(const Literal::Value& value) const override;
+  Result<bool> Test(const Literal& value) const override;
 
   Kind kind() const override { return Kind::kUnary; }
 
@@ -172,7 +172,7 @@ class ICEBERG_EXPORT BoundLiteralPredicate : public BoundPredicate {
   /// \brief Returns the literal being compared against.
   const Literal& literal() const { return literal_; }
 
-  Result<bool> Test(const Literal::Value& value) const override;
+  Result<bool> Test(const Literal& value) const override;
 
   Kind kind() const override { return Kind::kLiteral; }
 
@@ -208,7 +208,7 @@ class ICEBERG_EXPORT BoundSetPredicate : public BoundPredicate {
   /// \brief Returns the set of literals to test against.
   const LiteralSet& literal_set() const { return value_set_; }
 
-  Result<bool> Test(const Literal::Value& value) const override;
+  Result<bool> Test(const Literal& value) const override;
 
   Kind kind() const override { return Kind::kSet; }
 

src/iceberg/expression/term.cc

@@ -71,7 +71,7 @@ std::string BoundReference::ToString() const {
   return std::format("ref(id={}, type={})", field_.field_id(), field_.type()->ToString());
 }
 
-Result<Literal::Value> BoundReference::Evaluate(const StructLike& data) const {
+Result<Literal> BoundReference::Evaluate(const StructLike& data) const {
   return NotImplemented("BoundReference::Evaluate(StructLike) not implemented");
 }
 
@@ -119,7 +119,7 @@ std::string BoundTransform::ToString() const {
   return std::format("{}({})", transform_->ToString(), ref_->ToString());
 }
 
-Result<Literal::Value> BoundTransform::Evaluate(const StructLike& data) const {
+Result<Literal> BoundTransform::Evaluate(const StructLike& data) const {
   throw IcebergError("BoundTransform::Evaluate(StructLike) not implemented");
 }
 

src/iceberg/expression/term.h

@@ -79,7 +79,7 @@ class ICEBERG_EXPORT Bound {
   virtual ~Bound();
 
   /// \brief Evaluate this expression against a row-based data.
-  virtual Result<Literal::Value> Evaluate(const StructLike& data) const = 0;
+  virtual Result<Literal> Evaluate(const StructLike& data) const = 0;
 
   /// \brief Returns the underlying bound reference for this term.
   virtual std::shared_ptr<class BoundReference> reference() = 0;
@@ -176,7 +176,7 @@ class ICEBERG_EXPORT BoundReference
 
   std::string ToString() const override;
 
-  Result<Literal::Value> Evaluate(const StructLike& data) const override;
+  Result<Literal> Evaluate(const StructLike& data) const override;
 
   std::shared_ptr<BoundReference> reference() override { return shared_from_this(); }
 
@@ -236,7 +236,7 @@ class ICEBERG_EXPORT BoundTransform : public BoundTerm {
 
   std::string ToString() const override;
 
-  Result<Literal::Value> Evaluate(const StructLike& data) const override;
+  Result<Literal> Evaluate(const StructLike& data) const override;
 
   std::shared_ptr<BoundReference> reference() override { return ref_; }