feat: add inclusive metrics evaluator (#357)

Author: dongxiao1198

src/iceberg/CMakeLists.txt

@@ -25,6 +25,7 @@ set(ICEBERG_SOURCES
     expression/evaluator.cc
     expression/expression.cc
     expression/expressions.cc
+    expression/inclusive_metrics_evaluator.cc
     expression/literal.cc
     expression/predicate.cc
     expression/rewrite_not.cc

src/iceberg/expression/expressions.cc

@@ -156,226 +156,87 @@ std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::IsNull(
   return IsNull<BoundReference>(Ref(std::move(name)));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::IsNull(
-    std::shared_ptr<UnboundTerm<B>> expr) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred,
-      UnboundPredicateImpl<B>::Make(Expression::Operation::kIsNull, std::move(expr)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotNull(
     std::string name) {
   return NotNull<BoundReference>(Ref(std::move(name)));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotNull(
-    std::shared_ptr<UnboundTerm<B>> expr) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred,
-      UnboundPredicateImpl<B>::Make(Expression::Operation::kNotNull, std::move(expr)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::IsNaN(
     std::string name) {
   return IsNaN<BoundReference>(Ref(std::move(name)));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::IsNaN(
-    std::shared_ptr<UnboundTerm<B>> expr) {
-  ICEBERG_ASSIGN_OR_THROW(auto pred, UnboundPredicateImpl<B>::Make(
-                                         Expression::Operation::kIsNan, std::move(expr)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotNaN(
     std::string name) {
   return NotNaN<BoundReference>(Ref(std::move(name)));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotNaN(
-    std::shared_ptr<UnboundTerm<B>> expr) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred,
-      UnboundPredicateImpl<B>::Make(Expression::Operation::kNotNan, std::move(expr)));
-  return pred;
-}
-
 // Template implementations for comparison predicates
 
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::LessThan(
     std::string name, Literal value) {
   return LessThan<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::LessThan(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kLt,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::LessThanOrEqual(
     std::string name, Literal value) {
   return LessThanOrEqual<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::LessThanOrEqual(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kLtEq,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::GreaterThan(
     std::string name, Literal value) {
   return GreaterThan<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::GreaterThan(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kGt,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::GreaterThanOrEqual(
     std::string name, Literal value) {
   return GreaterThanOrEqual<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::GreaterThanOrEqual(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kGtEq,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Equal(std::string name,
                                                                          Literal value) {
   return Equal<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Equal(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kEq,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotEqual(
     std::string name, Literal value) {
   return NotEqual<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotEqual(
-    std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kNotEq,
-                                               std::move(expr), std::move(value)));
-  return pred;
-}
-
 // String predicates
 
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::StartsWith(
     std::string name, std::string value) {
   return StartsWith<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::StartsWith(
-    std::shared_ptr<UnboundTerm<B>> expr, std::string value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred,
-      UnboundPredicateImpl<B>::Make(Expression::Operation::kStartsWith, std::move(expr),
-                                    Literal::String(std::move(value))));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotStartsWith(
     std::string name, std::string value) {
   return NotStartsWith<BoundReference>(Ref(std::move(name)), std::move(value));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotStartsWith(
-    std::shared_ptr<UnboundTerm<B>> expr, std::string value) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred,
-      UnboundPredicateImpl<B>::Make(Expression::Operation::kNotStartsWith,
-                                    std::move(expr), Literal::String(std::move(value))));
-  return pred;
-}
-
 // Template implementations for set predicates
 
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::In(
     std::string name, std::vector<Literal> values) {
   return In<BoundReference>(Ref(std::move(name)), std::move(values));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::In(
-    std::shared_ptr<UnboundTerm<B>> expr, std::vector<Literal> values) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kIn,
-                                               std::move(expr), std::move(values)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::In(
     std::string name, std::initializer_list<Literal> values) {
   return In<BoundReference>(Ref(std::move(name)), std::vector<Literal>(values));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::In(
-    std::shared_ptr<UnboundTerm<B>> expr, std::initializer_list<Literal> values) {
-  return In<B>(std::move(expr), std::vector<Literal>(values));
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotIn(
     std::string name, std::vector<Literal> values) {
   return NotIn<BoundReference>(Ref(std::move(name)), std::move(values));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotIn(
-    std::shared_ptr<UnboundTerm<B>> expr, std::vector<Literal> values) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kNotIn,
-                                               std::move(expr), std::move(values)));
-  return pred;
-}
-
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotIn(
     std::string name, std::initializer_list<Literal> values) {
   return NotIn<BoundReference>(Ref(std::move(name)), std::vector<Literal>(values));
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotIn(
-    std::shared_ptr<UnboundTerm<B>> expr, std::initializer_list<Literal> values) {
-  return NotIn<B>(expr, std::vector<Literal>(values));
-}
-
 // Template implementations for generic predicate factory
 
 std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Predicate(
@@ -404,29 +265,6 @@ std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Predicate(
   return pred;
 }
 
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Predicate(
-    Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
-    std::vector<Literal> values) {
-  ICEBERG_ASSIGN_OR_THROW(
-      auto pred, UnboundPredicateImpl<B>::Make(op, std::move(expr), std::move(values)));
-  return pred;
-}
-
-template <typename B>
-std::shared_ptr<UnboundPredicateImpl<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<UnboundPredicateImpl<B>> Expressions::Predicate(
-    Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr) {
-  ICEBERG_ASSIGN_OR_THROW(auto pred, UnboundPredicateImpl<B>::Make(op, std::move(expr)));
-  return pred;
-}
-
 // Constants
 
 std::shared_ptr<True> Expressions::AlwaysTrue() { return True::Instance(); }