refactor: use templatem member method for incremental plan files

Author: WZhuo

src/iceberg/table_scan.cc

@@ -644,23 +644,21 @@ Result<std::vector<std::shared_ptr<FileScanTask>>> DataTableScan::PlanFiles() co
 // to the two-arg virtual PlanFiles() override in the concrete subclass.
 // Defined as a friend to access the protected two-arg PlanFiles().
 template <typename ScanTaskType>
-Result<std::vector<std::shared_ptr<ScanTaskType>>> ResolvePlanFiles(
-    const IncrementalScan<ScanTaskType>& scan) {
-  if (IsScanCurrentLineage(scan.context())) {
-    if (scan.metadata()->current_snapshot_id == kInvalidSnapshotId) {
+Result<std::vector<std::shared_ptr<ScanTaskType>>>
+IncrementalScan<ScanTaskType>::PlanFiles() const {
+  if (IsScanCurrentLineage(context_)) {
+    if (metadata_->current_snapshot_id == kInvalidSnapshotId) {
       return std::vector<std::shared_ptr<ScanTaskType>>{};
     }
   }
 
-  ICEBERG_ASSIGN_OR_RAISE(
-      int64_t to_snapshot_id_inclusive,
-      internal::ToSnapshotIdInclusive(scan.context(), *scan.metadata()));
+  ICEBERG_ASSIGN_OR_RAISE(int64_t to_snapshot_id_inclusive,
+                          internal::ToSnapshotIdInclusive(context_, *metadata_));
   ICEBERG_ASSIGN_OR_RAISE(
       std::optional<int64_t> from_snapshot_id_exclusive,
-      internal::FromSnapshotIdExclusive(scan.context(), *scan.metadata(),
-                                        to_snapshot_id_inclusive));
+      internal::FromSnapshotIdExclusive(context_, *metadata_, to_snapshot_id_inclusive));
 
-  return scan.PlanFiles(from_snapshot_id_exclusive, to_snapshot_id_inclusive);
+  return PlanFiles(from_snapshot_id_exclusive, to_snapshot_id_inclusive);
 }
 
 // IncrementalAppendScan implementation
@@ -675,11 +673,6 @@ Result<std::unique_ptr<IncrementalAppendScan>> IncrementalAppendScan::Make(
       std::move(metadata), std::move(schema), std::move(io), std::move(context)));
 }
 
-Result<std::vector<std::shared_ptr<FileScanTask>>> IncrementalAppendScan::PlanFiles()
-    const {
-  return ResolvePlanFiles<FileScanTask>(*this);
-}
-
 Result<std::vector<std::shared_ptr<FileScanTask>>> IncrementalAppendScan::PlanFiles(
     std::optional<int64_t> from_snapshot_id_exclusive,
     int64_t to_snapshot_id_inclusive) const {
@@ -754,15 +747,13 @@ Result<std::unique_ptr<IncrementalChangelogScan>> IncrementalChangelogScan::Make
   return NotImplemented("IncrementalChangelogScan is not implemented");
 }
 
-Result<std::vector<std::shared_ptr<ChangelogScanTask>>>
-IncrementalChangelogScan::PlanFiles() const {
-  return ResolvePlanFiles<ChangelogScanTask>(*this);
-}
-
 Result<std::vector<std::shared_ptr<ChangelogScanTask>>>
 IncrementalChangelogScan::PlanFiles(std::optional<int64_t> from_snapshot_id_exclusive,
                                     int64_t to_snapshot_id_inclusive) const {
   return NotImplemented("IncrementalChangelogScan::PlanFiles is not implemented");
 }
 
+template class ICEBERG_TEMPLATE_EXPORT IncrementalScan<FileScanTask>;
+template class ICEBERG_TEMPLATE_EXPORT IncrementalScan<ChangelogScanTask>;
+
 }  // namespace iceberg

src/iceberg/table_scan.h

@@ -356,25 +356,23 @@ class ICEBERG_EXPORT DataTableScan : public TableScan {
 /// \brief A base template class for incremental scans that read changes between
 /// snapshots, and return scan tasks of the specified type.
 template <typename ScanTaskType>
-class IncrementalScan : public TableScan {
+class ICEBERG_TEMPLATE_CLASS_EXPORT IncrementalScan : public TableScan {
  public:
   ~IncrementalScan() override = default;
 
-  virtual Result<std::vector<std::shared_ptr<ScanTaskType>>> PlanFiles() const = 0;
+  Result<std::vector<std::shared_ptr<ScanTaskType>>> PlanFiles() const;
 
  protected:
   virtual Result<std::vector<std::shared_ptr<ScanTaskType>>> PlanFiles(
       std::optional<int64_t> from_snapshot_id_exclusive,
       int64_t to_snapshot_id_inclusive) const = 0;
 
   using TableScan::TableScan;
-
-  // Allow the free function ResolvePlanFiles to access protected members.
-  template <typename T>
-  friend Result<std::vector<std::shared_ptr<T>>> ResolvePlanFiles(
-      const IncrementalScan<T>& scan);
 };
 
+extern template class ICEBERG_TEMPLATE_CLASS_EXPORT IncrementalScan<FileScanTask>;
+extern template class ICEBERG_TEMPLATE_CLASS_EXPORT IncrementalScan<ChangelogScanTask>;
+
 /// \brief A scan that reads data files added between snapshots (incremental appends).
 class ICEBERG_EXPORT IncrementalAppendScan : public IncrementalScan<FileScanTask> {
  public:
@@ -385,7 +383,7 @@ class ICEBERG_EXPORT IncrementalAppendScan : public IncrementalScan<FileScanTask
 
   ~IncrementalAppendScan() override = default;
 
-  Result<std::vector<std::shared_ptr<FileScanTask>>> PlanFiles() const override;
+  using IncrementalScan::PlanFiles;
 
  protected:
   Result<std::vector<std::shared_ptr<FileScanTask>>> PlanFiles(
@@ -406,7 +404,7 @@ class ICEBERG_EXPORT IncrementalChangelogScan
 
   ~IncrementalChangelogScan() override = default;
 
-  Result<std::vector<std::shared_ptr<ChangelogScanTask>>> PlanFiles() const override;
+  using IncrementalScan::PlanFiles;
 
  protected:
   Result<std::vector<std::shared_ptr<ChangelogScanTask>>> PlanFiles(