table_requirements.h

Go to the documentation of this file.

/*
 * 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
 
 
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/table_requirement.h"
#include "iceberg/type_fwd.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT TableUpdateContext {
 public:
  TableUpdateContext(const TableMetadata* base, bool is_replace)
      : base_(base), is_replace_(is_replace) {}
 
  // Delete copy operations (contains unique_ptr members)
  TableUpdateContext(const TableUpdateContext&) = delete;
  TableUpdateContext& operator=(const TableUpdateContext&) = delete;
 
  // Enable move construction only (assignment deleted due to const members)
  TableUpdateContext(TableUpdateContext&&) noexcept = default;
 
  void AddRequirement(std::unique_ptr<TableRequirement> requirement);
 
  const TableMetadata* base() const { return base_; }
 
  bool is_replace() const { return is_replace_; }
 
  Result<std::vector<std::unique_ptr<TableRequirement>>> Build();
 
  // Helper methods to deduplicate requirements to add.
  void RequireLastAssignedFieldIdUnchanged();
  void RequireCurrentSchemaIdUnchanged();
  void RequireLastAssignedPartitionIdUnchanged();
  void RequireDefaultSpecIdUnchanged();
  void RequireDefaultSortOrderIdUnchanged();
  void RequireNoBranchesChanged();
 
  bool AddChangedRef(const std::string& ref_name);
 
 private:
  const TableMetadata* base_;
  const bool is_replace_;
 
  std::vector<std::unique_ptr<TableRequirement>> requirements_;
 
  // flags to avoid adding duplicate requirements
  bool added_last_assigned_field_id_ = false;
  bool added_current_schema_id_ = false;
  bool added_last_assigned_partition_id_ = false;
  bool added_default_spec_id_ = false;
  bool added_default_sort_order_id_ = false;
 
  // Track refs that have been changed to avoid duplicate requirements
  std::unordered_set<std::string> changed_refs_;
};
 
class ICEBERG_EXPORT TableRequirements {
 public:
  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForCreateTable(
      const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 
  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForReplaceTable(
      const TableMetadata& base,
      const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 
  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForUpdateTable(
      const TableMetadata& base,
      const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 
  static Result<bool> IsCreate(
      const std::vector<std::unique_ptr<TableRequirement>>& requirements);
};
 
}  // namespace iceberg