feat: add manifest evaluator

Author: xiao.dong

src/iceberg/CMakeLists.txt

@@ -27,6 +27,7 @@ set(ICEBERG_SOURCES
     expression/expressions.cc
     expression/inclusive_metrics_evaluator.cc
     expression/literal.cc
+    expression/manifest_evaluator.cc
     expression/predicate.cc
     expression/rewrite_not.cc
     expression/strict_metrics_evaluator.cc

src/iceberg/expression/manifest_evaluator.cc

@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+/// \file iceberg/expression/manifest_evaluator.h
+///
+/// Evaluates an Expression on a ManifestFile to test whether the file contains
+/// matching partitions.
+///
+/// For row expressions, evaluation is inclusive: it returns true if a file
+/// may match and false if it cannot match.
+///
+/// Files are passed to #eval(ManifestFile), which returns true if the manifest may
+/// contain data files that match the partition expression. Manifest files may be
+/// skipped if and only if the return value of eval is false.
+///
+
+#include <memory>
+
+#include "iceberg/iceberg_export.h"
+#include "iceberg/result.h"
+#include "iceberg/type_fwd.h"
+
+namespace iceberg {
+
+/// \brief Evaluates an Expression against manifest.
+/// \note: The evaluator is thread-safe.
+class ICEBERG_EXPORT ManifestEvaluator {
+ public:
+  /// \brief Make a manifest evaluator for RowFilter
+  ///
+  /// \param expr The expression to evaluate
+  /// \param spec The partition spec
+  /// \param schema The schema of the table
+  /// \param case_sensitive Whether field name matching is case-sensitive
+  static Result<std::unique_ptr<ManifestEvaluator>> MakeRowFilter(
+      std::shared_ptr<Expression> expr, const std::shared_ptr<PartitionSpec>& spec,
+      const Schema& schema, bool case_sensitive = true);
+
+  /// \brief Make a manifest evaluator for PartitionFilter
+  ///
+  /// \param expr The expression to evaluate
+  /// \param spec The partition spec
+  /// \param schema The schema of the table
+  /// \param case_sensitive Whether field name matching is case-sensitive
+  static Result<std::unique_ptr<ManifestEvaluator>> MakePartitionFilter(
+      std::shared_ptr<Expression> expr, const std::shared_ptr<PartitionSpec>& spec,
+      const Schema& schema, bool case_sensitive = true);
+
+  ~ManifestEvaluator();
+
+  /// \brief Evaluate the expression against a manifest.
+  ///
+  /// \param manifest The manifest to evaluate
+  /// \return true if the row matches the expression, false otherwise, or error
+  Result<bool> Evaluate(const ManifestFile& manifest) const;
+
+ private:
+  explicit ManifestEvaluator(std::shared_ptr<Expression> expr);
+
+ private:
+  std::shared_ptr<Expression> expr_;
+};
+
+}  // namespace iceberg

src/iceberg/expression/manifest_evaluator.h

@@ -25,6 +25,7 @@ install_headers(
         'expressions.h',
         'inclusive_metrics_evaluator.h',
         'literal.h',
+        'manifest_evaluator.h',
         'predicate.h',
         'rewrite_not.h',
         'strict_metrics_evaluator.h',

src/iceberg/expression/meson.build

@@ -157,6 +157,8 @@ class ICEBERG_EXPORT BoundReference
 
   Kind kind() const override { return Kind::kReference; }
 
+  const StructLikeAccessor& accessor() const { return *accessor_; }
+
  private:
   BoundReference(SchemaField field, std::unique_ptr<StructLikeAccessor> accessor);
 

src/iceberg/expression/term.h

@@ -49,6 +49,7 @@ iceberg_sources = files(
     'expression/expressions.cc',
     'expression/inclusive_metrics_evaluator.cc',
     'expression/literal.cc',
+    'expression/manifest_evaluator.cc',
     'expression/predicate.cc',
     'expression/rewrite_not.cc',
     'expression/strict_metrics_evaluator.cc',

src/iceberg/meson.build

@@ -70,7 +70,7 @@ Result<Scalar> LiteralToScalar(const Literal& literal) {
 
 StructLikeAccessor::StructLikeAccessor(std::shared_ptr<Type> type,
                                        std::span<const size_t> position_path)
-    : type_(std::move(type)) {
+    : type_(std::move(type)), position_path_(position_path.begin(), position_path.end()) {
   if (position_path.size() == 1) {
     accessor_ = [pos =
                      position_path[0]](const StructLike& struct_like) -> Result<Scalar> {

src/iceberg/row/struct_like.cc

@@ -121,9 +121,13 @@ class ICEBERG_EXPORT StructLikeAccessor {
   /// \brief Get the type of the value that this accessor is bound to.
   const Type& type() const { return *type_; }
 
+  /// \brief Get the position path of the value that this accessor bounded to.
+  const std::vector<size_t>& position_path() const { return position_path_; }
+
  private:
   std::shared_ptr<Type> type_;
   std::function<Result<Scalar>(const StructLike&)> accessor_;
+  std::vector<size_t> position_path_;
 };
 
 }  // namespace iceberg

src/iceberg/row/struct_like.h

@@ -85,6 +85,7 @@ add_iceberg_test(expression_test
                  expression_test.cc
                  expression_visitor_test.cc
                  literal_test.cc
+                 manifest_evaluator_test.cc
                  inclusive_metrics_evaluator_test.cc
                  inclusive_metrics_evaluator_with_transform_test.cc
                  predicate_test.cc