feat: Add incremental scan API with IncrementalAppendScan and IncrementalChangelogScan

Author: WZhuo

src/iceberg/table.cc

@@ -152,6 +152,16 @@ Result<std::unique_ptr<TableScanBuilder>> Table::NewScan() const {
   return TableScanBuilder::Make(metadata_, io_);
 }
 
+Result<std::unique_ptr<IncrementalAppendScanBuilder>> Table::NewIncrementalAppendScan()
+    const {
+  return IncrementalAppendScanBuilder::Make(metadata_, io_);
+}
+
+Result<std::unique_ptr<IncrementalChangelogScanBuilder>>
+Table::NewIncrementalChangelogScan() const {
+  return IncrementalChangelogScanBuilder::Make(metadata_, io_);
+}
+
 Result<std::shared_ptr<Transaction>> Table::NewTransaction() {
   // Create a brand new transaction object for the table. Users are expected to commit the
   // transaction manually.

src/iceberg/table.h

@@ -129,6 +129,14 @@ class ICEBERG_EXPORT Table : public std::enable_shared_from_this<Table> {
   /// filter data.
   virtual Result<std::unique_ptr<TableScanBuilder>> NewScan() const;
 
+  /// \brief Create a new incremental append scan builder for this table
+  virtual Result<std::unique_ptr<IncrementalAppendScanBuilder>> NewIncrementalAppendScan()
+      const;
+
+  /// \brief Create a new incremental changelog scan builder for this table
+  virtual Result<std::unique_ptr<IncrementalChangelogScanBuilder>>
+  NewIncrementalChangelogScan() const;
+
   /// \brief Create a new Transaction to commit multiple table operations at once.
   virtual Result<std::shared_ptr<Transaction>> NewTransaction();
 

src/iceberg/table_scan.cc

@@ -313,29 +313,6 @@ TableScanBuilder& TableScanBuilder::AsOfTime(int64_t timestamp_millis) {
   return UseSnapshot(snapshot_id);
 }
 
-TableScanBuilder& TableScanBuilder::FromSnapshot(
-    [[maybe_unused]] int64_t from_snapshot_id, [[maybe_unused]] bool inclusive) {
-  return AddError(NotImplemented("Incremental scan is not implemented"));
-}
-
-TableScanBuilder& TableScanBuilder::FromSnapshot([[maybe_unused]] const std::string& ref,
-                                                 [[maybe_unused]] bool inclusive) {
-  return AddError(NotImplemented("Incremental scan is not implemented"));
-}
-
-TableScanBuilder& TableScanBuilder::ToSnapshot([[maybe_unused]] int64_t to_snapshot_id) {
-  return AddError(NotImplemented("Incremental scan is not implemented"));
-}
-
-TableScanBuilder& TableScanBuilder::ToSnapshot([[maybe_unused]] const std::string& ref) {
-  return AddError(NotImplemented("Incremental scan is not implemented"));
-}
-
-TableScanBuilder& TableScanBuilder::UseBranch(const std::string& branch) {
-  context_.branch = branch;
-  return *this;
-}
-
 Result<std::reference_wrapper<const std::shared_ptr<Schema>>>
 TableScanBuilder::ResolveSnapshotSchema() {
   if (snapshot_schema_ == nullptr) {
@@ -352,18 +329,10 @@ TableScanBuilder::ResolveSnapshotSchema() {
   return snapshot_schema_;
 }
 
-bool TableScanBuilder::IsIncrementalScan() const {
-  return context_.from_snapshot_id.has_value() || context_.to_snapshot_id.has_value();
-}
-
-Result<std::unique_ptr<TableScan>> TableScanBuilder::Build() {
+Result<std::unique_ptr<DataTableScan>> TableScanBuilder::Build() {
   ICEBERG_RETURN_UNEXPECTED(CheckErrors());
   ICEBERG_RETURN_UNEXPECTED(context_.Validate());
 
-  if (IsIncrementalScan()) {
-    return NotImplemented("Incremental scan is not yet implemented");
-  }
-
   ICEBERG_ASSIGN_OR_RAISE(auto schema, ResolveSnapshotSchema());
   return DataTableScan::Make(metadata_, schema.get(), io_, std::move(context_));
 }
@@ -445,8 +414,7 @@ Result<std::unique_ptr<DataTableScan>> DataTableScan::Make(
 DataTableScan::DataTableScan(std::shared_ptr<TableMetadata> metadata,
                              std::shared_ptr<Schema> schema, std::shared_ptr<FileIO> io,
                              internal::TableScanContext context)
-    : TableScan(std::move(metadata), std::move(schema), std::move(io),
-                std::move(context)) {}
+    : Scan(std::move(metadata), std::move(schema), std::move(io), std::move(context)) {}
 
 Result<std::vector<std::shared_ptr<FileScanTask>>> DataTableScan::PlanFiles() const {
   ICEBERG_ASSIGN_OR_RAISE(auto snapshot, this->snapshot());
@@ -477,4 +445,111 @@ Result<std::vector<std::shared_ptr<FileScanTask>>> DataTableScan::PlanFiles() co
   return manifest_group->PlanFiles();
 }
 
+BaseIncrementalScanBuilder::BaseIncrementalScanBuilder(
+    std::shared_ptr<TableMetadata> metadata, std::shared_ptr<FileIO> io)
+    : TableScanBuilder(std::move(metadata), std::move(io)) {}
+
+BaseIncrementalScanBuilder& BaseIncrementalScanBuilder::FromSnapshot(
+    [[maybe_unused]] int64_t from_snapshot_id, [[maybe_unused]] bool inclusive) {
+  return AddError(NotImplemented("Incremental scan is not implemented"));
+}
+
+BaseIncrementalScanBuilder& BaseIncrementalScanBuilder::FromSnapshot(
+    [[maybe_unused]] const std::string& ref, [[maybe_unused]] bool inclusive) {
+  return AddError(NotImplemented("Incremental scan is not implemented"));
+}
+
+BaseIncrementalScanBuilder& BaseIncrementalScanBuilder::ToSnapshot(
+    [[maybe_unused]] int64_t to_snapshot_id) {
+  return AddError(NotImplemented("Incremental scan is not implemented"));
+}
+
+BaseIncrementalScanBuilder& BaseIncrementalScanBuilder::ToSnapshot(
+    [[maybe_unused]] const std::string& ref) {
+  return AddError(NotImplemented("Incremental scan is not implemented"));
+}
+
+BaseIncrementalScanBuilder& BaseIncrementalScanBuilder::UseBranch(
+    const std::string& branch) {
+  context_.branch = branch;
+  return *this;
+}
+
+// IncrementalAppendScanBuilder implementation
+Result<std::unique_ptr<IncrementalAppendScanBuilder>> IncrementalAppendScanBuilder::Make(
+    std::shared_ptr<TableMetadata> metadata, std::shared_ptr<FileIO> io) {
+  ICEBERG_PRECHECK(metadata != nullptr, "Table metadata cannot be null");
+  ICEBERG_PRECHECK(io != nullptr, "FileIO cannot be null");
+  return std::unique_ptr<IncrementalAppendScanBuilder>(
+      new IncrementalAppendScanBuilder(std::move(metadata), std::move(io)));
+}
+
+IncrementalAppendScanBuilder::IncrementalAppendScanBuilder(
+    std::shared_ptr<TableMetadata> metadata, std::shared_ptr<FileIO> io)
+    : IncrementalScanBuilder(std::move(metadata), std::move(io)) {}
+
+Result<std::unique_ptr<IncrementalAppendScan>> IncrementalAppendScanBuilder::Build() {
+  return NotImplemented("IncrementalAppendScanBuilder is not implemented");
+}
+
+// IncrementalChangelogScanBuilder implementation
+Result<std::unique_ptr<IncrementalChangelogScanBuilder>>
+IncrementalChangelogScanBuilder::Make(std::shared_ptr<TableMetadata> metadata,
+                                      std::shared_ptr<FileIO> io) {
+  ICEBERG_PRECHECK(metadata != nullptr, "Table metadata cannot be null");
+  ICEBERG_PRECHECK(io != nullptr, "FileIO cannot be null");
+  return std::unique_ptr<IncrementalChangelogScanBuilder>(
+      new IncrementalChangelogScanBuilder(std::move(metadata), std::move(io)));
+}
+
+IncrementalChangelogScanBuilder::IncrementalChangelogScanBuilder(
+    std::shared_ptr<TableMetadata> metadata, std::shared_ptr<FileIO> io)
+    : IncrementalScanBuilder(std::move(metadata), std::move(io)) {}
+
+Result<std::unique_ptr<IncrementalChangelogScan>>
+IncrementalChangelogScanBuilder::Build() {
+  return NotImplemented("IncrementalChangelogScanBuilder is not implemented");
+}
+
+// IncrementalAppendScan implementation
+
+Result<std::unique_ptr<IncrementalAppendScan>> IncrementalAppendScan::Make(
+    [[maybe_unused]] std::shared_ptr<TableMetadata> metadata,
+    [[maybe_unused]] std::shared_ptr<Schema> schema,
+    [[maybe_unused]] std::shared_ptr<FileIO> io,
+    [[maybe_unused]] internal::TableScanContext context) {
+  return NotImplemented("IncrementalAppendScan is not implemented");
+}
+
+IncrementalAppendScan::IncrementalAppendScan(std::shared_ptr<TableMetadata> metadata,
+                                             std::shared_ptr<Schema> schema,
+                                             std::shared_ptr<FileIO> io,
+                                             internal::TableScanContext context)
+    : Scan(std::move(metadata), std::move(schema), std::move(io), std::move(context)) {}
+
+Result<std::vector<std::shared_ptr<FileScanTask>>> IncrementalAppendScan::PlanFiles()
+    const {
+  return NotImplemented("IncrementalAppendScan::PlanFiles is not implemented");
+}
+
+// IncrementalChangelogScan implementation
+
+Result<std::unique_ptr<IncrementalChangelogScan>> IncrementalChangelogScan::Make(
+    [[maybe_unused]] std::shared_ptr<TableMetadata> metadata,
+    [[maybe_unused]] std::shared_ptr<Schema> schema,
+    [[maybe_unused]] std::shared_ptr<FileIO> io,
+    [[maybe_unused]] internal::TableScanContext context) {
+  return NotImplemented("IncrementalChangelogScan is not implemented");
+}
+
+IncrementalChangelogScan::IncrementalChangelogScan(
+    std::shared_ptr<TableMetadata> metadata, std::shared_ptr<Schema> schema,
+    std::shared_ptr<FileIO> io, internal::TableScanContext context)
+    : Scan(std::move(metadata), std::move(schema), std::move(io), std::move(context)) {}
+
+Result<std::vector<std::shared_ptr<ChangelogScanTask>>>
+IncrementalChangelogScan::PlanFiles() const {
+  return NotImplemented("IncrementalChangelogScan::PlanFiles is not implemented");
+}
+
 }  // namespace iceberg