use concepts and remove ArrowArray

Author: wgtmac

src/iceberg/expression/expressions.cc

@@ -307,6 +307,11 @@ std::shared_ptr<UnboundPredicate<BoundReference>> Expressions::Predicate(
                                                             std::move(values));
 }
 
+std::shared_ptr<UnboundPredicate<BoundReference>> Expressions::Predicate(
+    Expression::Operation op, std::string name, std::initializer_list<Literal> values) {
+  return Predicate(op, name, std::vector<Literal>(values));
+}
+
 std::shared_ptr<UnboundPredicate<BoundReference>> Expressions::Predicate(
     Expression::Operation op, std::string name) {
   return std::make_shared<UnboundPredicate<BoundReference>>(op, Ref(std::move(name)));
@@ -319,6 +324,13 @@ std::shared_ptr<UnboundPredicate<B>> Expressions::Predicate(
   return std::make_shared<UnboundPredicate<B>>(op, std::move(expr), std::move(values));
 }
 
+template <typename B>
+std::shared_ptr<UnboundPredicate<B>> Expressions::Predicate(
+    Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
+    std::initializer_list<Literal> values) {
+  return Predicate<B>(op, std::move(expr), std::vector<Literal>(values));
+}
+
 template <typename B>
 std::shared_ptr<UnboundPredicate<B>> Expressions::Predicate(
     Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr) {

src/iceberg/expression/expressions.h

@@ -228,6 +228,10 @@ class ICEBERG_EXPORT Expressions {
   static std::shared_ptr<UnboundPredicate<BoundReference>> Predicate(
       Expression::Operation op, std::string name, std::vector<Literal> values);
 
+  /// \brief Create a predicate with operation and multiple values.
+  static std::shared_ptr<UnboundPredicate<BoundReference>> Predicate(
+      Expression::Operation op, std::string name, std::initializer_list<Literal> values);
+
   /// \brief Create a unary predicate (no values).
   static std::shared_ptr<UnboundPredicate<BoundReference>> Predicate(
       Expression::Operation op, std::string name);
@@ -238,6 +242,12 @@ class ICEBERG_EXPORT Expressions {
       Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
       std::vector<Literal> values);
 
+  /// \brief Create a predicate with operation and multiple values.
+  template <typename B>
+  static std::shared_ptr<UnboundPredicate<B>> Predicate(
+      Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
+      std::initializer_list<Literal> values);
+
   /// \brief Create a unary predicate for unbound term.
   template <typename B>
   static std::shared_ptr<UnboundPredicate<B>> Predicate(

src/iceberg/expression/predicate.cc

@@ -33,12 +33,12 @@
 namespace iceberg {
 
 // Predicate template implementations
-template <typename TermType>
-Predicate<TermType>::Predicate(Expression::Operation op, std::shared_ptr<TermType> term)
+template <TermType T>
+Predicate<T>::Predicate(Expression::Operation op, std::shared_ptr<T> term)
     : operation_(op), term_(std::move(term)) {}
 
-template <typename TermType>
-Predicate<TermType>::~Predicate() = default;
+template <TermType T>
+Predicate<T>::~Predicate() = default;
 
 // UnboundPredicate template implementations
 template <typename B>
@@ -289,18 +289,6 @@ Result<Literal::Value> BoundPredicate::Evaluate(const StructLike& data) const {
   return Literal::Value{test_result};
 }
 
-Result<std::vector<Literal::Value>> BoundPredicate::Evaluate(
-    const ArrowArray& data) const {
-  ICEBERG_ASSIGN_OR_RAISE(auto eval_result, term_->Evaluate(data));
-  std::vector<Literal::Value> result;
-  result.reserve(eval_result.size());
-  for (const auto& value : eval_result) {
-    ICEBERG_ASSIGN_OR_RAISE(auto test_result, Test(value));
-    result.emplace_back(test_result);
-  }
-  return result;
-}
-
 // BoundUnaryPredicate implementation
 BoundUnaryPredicate::BoundUnaryPredicate(Expression::Operation op,
                                          std::shared_ptr<BoundTerm> term)

src/iceberg/expression/predicate.h

@@ -22,33 +22,38 @@
 /// \file iceberg/expression/predicate.h
 /// Predicate interface for boolean expressions that test terms.
 
+#include <concepts>
+
 #include "iceberg/expression/expression.h"
 #include "iceberg/expression/term.h"
 
 namespace iceberg {
 
+template <typename T>
+concept TermType = std::derived_from<T, Term>;
+
 /// \brief A predicate is a boolean expression that tests a term against some criteria.
 ///
 /// \tparam TermType The type of the term being tested
-template <typename TermType>
+template <TermType T>
 class ICEBERG_EXPORT Predicate : public Expression {
  public:
   /// \brief Create a predicate with an operation and term.
   ///
   /// \param op The operation this predicate performs
   /// \param term The term this predicate tests
-  Predicate(Expression::Operation op, std::shared_ptr<TermType> term);
+  Predicate(Expression::Operation op, std::shared_ptr<T> term);
 
   ~Predicate() override;
 
   Expression::Operation op() const override { return operation_; }
 
   /// \brief Returns the term this predicate tests.
-  const std::shared_ptr<TermType>& term() const { return term_; }
+  const std::shared_ptr<T>& term() const { return term_; }
 
  protected:
   Expression::Operation operation_;
-  std::shared_ptr<TermType> term_;
+  std::shared_ptr<T> term_;
 };
 
 /// \brief Unbound predicates contain unbound terms and must be bound to a concrete schema
@@ -108,8 +113,6 @@ class ICEBERG_EXPORT BoundPredicate : public Predicate<BoundTerm>, public Bound
 
   Result<Literal::Value> Evaluate(const StructLike& data) const override;
 
-  Result<std::vector<Literal::Value>> Evaluate(const ArrowArray& data) const override;
-
   /// \brief Test a value against this predicate.
   ///
   /// \param value The value to test
@@ -122,7 +125,7 @@ class ICEBERG_EXPORT BoundPredicate : public Predicate<BoundTerm>, public Bound
     // A literal predicate (compares against a literal).
     kLiteral,
     // A set predicate (tests membership in a set).
-    kIn,
+    kSet,
   };
 
   /// \brief Returns the kind of this bound predicate.
@@ -195,7 +198,7 @@ class ICEBERG_EXPORT BoundSetPredicate : public BoundPredicate {
 
   Result<bool> Test(const Literal::Value& value) const override;
 
-  Kind kind() const override { return Kind::kIn; }
+  Kind kind() const override { return Kind::kSet; }
 
   std::string ToString() const override;
 

src/iceberg/expression/term.cc

@@ -79,11 +79,6 @@ Result<Literal::Value> BoundReference::Evaluate(const StructLike& data) const {
   return NotImplemented("BoundReference::Evaluate(StructLike) not implemented");
 }
 
-Result<std::vector<Literal::Value>> BoundReference::Evaluate(
-    const ArrowArray& data) const {
-  return NotImplemented("BoundReference::Evaluate(ArrowArray) not implemented");
-}
-
 bool BoundReference::Equals(const BoundTerm& other) const {
   if (other.kind() != Term::Kind::kReference) {
     return false;
@@ -132,11 +127,6 @@ Result<Literal::Value> BoundTransform::Evaluate(const StructLike& data) const {
   throw IcebergError("BoundTransform::Evaluate(StructLike) not implemented");
 }
 
-Result<std::vector<Literal::Value>> BoundTransform::Evaluate(
-    const ArrowArray& data) const {
-  throw IcebergError("BoundTransform::Evaluate(ArrowArray) not implemented");
-}
-
 bool BoundTransform::MayProduceNull() const {
   // transforms must produce null for null input values
   // transforms may produce null for non-null inputs when not order-preserving

src/iceberg/expression/term.h

@@ -26,7 +26,6 @@
 #include <string>
 #include <string_view>
 
-#include "iceberg/arrow_c_data.h"
 #include "iceberg/expression/literal.h"
 #include "iceberg/type_fwd.h"
 #include "iceberg/util/formattable.h"
@@ -82,9 +81,6 @@ class ICEBERG_EXPORT Bound {
   /// \brief Evaluate this expression against a row-based data.
   virtual Result<Literal::Value> Evaluate(const StructLike& data) const = 0;
 
-  /// \brief Evaluate this expression against an Arrow array.
-  virtual Result<std::vector<Literal::Value>> Evaluate(const ArrowArray& data) const = 0;
-
   /// \brief Returns the underlying bound reference for this term.
   virtual std::shared_ptr<class BoundReference> reference() = 0;
 };
@@ -182,8 +178,6 @@ class ICEBERG_EXPORT BoundReference
 
   Result<Literal::Value> Evaluate(const StructLike& data) const override;
 
-  Result<std::vector<Literal::Value>> Evaluate(const ArrowArray& data) const override;
-
   std::shared_ptr<BoundReference> reference() override { return shared_from_this(); }
 
   std::shared_ptr<Type> type() const override { return field_.type(); }
@@ -244,8 +238,6 @@ class ICEBERG_EXPORT BoundTransform : public BoundTerm {
 
   Result<Literal::Value> Evaluate(const StructLike& data) const override;
 
-  Result<std::vector<Literal::Value>> Evaluate(const ArrowArray& data) const override;
-
   std::shared_ptr<BoundReference> reference() override { return ref_; }
 
   std::shared_ptr<Type> type() const override;