update_schema.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 <optional>
#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
 
#include "iceberg/expression/literal.h"
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/type_fwd.h"
#include "iceberg/update/pending_update.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT UpdateSchema : public PendingUpdate {
 public:
  static Result<std::shared_ptr<UpdateSchema>> Make(
      std::shared_ptr<TransactionContext> ctx);
 
  ~UpdateSchema() override;
 
  UpdateSchema& AllowIncompatibleChanges();
 
  UpdateSchema& AddColumn(std::string_view name, std::shared_ptr<Type> type,
                          std::string_view doc = "",
                          std::optional<Literal> default_value = std::nullopt);
 
  UpdateSchema& AddColumn(std::optional<std::string_view> parent, std::string_view name,
                          std::shared_ptr<Type> type, std::string_view doc = "",
                          std::optional<Literal> default_value = std::nullopt);
 
  UpdateSchema& AddRequiredColumn(std::string_view name, std::shared_ptr<Type> type,
                                  std::string_view doc = "",
                                  std::optional<Literal> default_value = std::nullopt);
 
  UpdateSchema& AddRequiredColumn(std::optional<std::string_view> parent,
                                  std::string_view name, std::shared_ptr<Type> type,
                                  std::string_view doc = "",
                                  std::optional<Literal> default_value = std::nullopt);
 
  UpdateSchema& RenameColumn(std::string_view name, std::string_view new_name);
 
  UpdateSchema& UpdateColumn(std::string_view name,
                             std::shared_ptr<PrimitiveType> new_type);
 
  UpdateSchema& UpdateColumnDoc(std::string_view name, std::string_view new_doc);
 
  UpdateSchema& UpdateColumnDefault(std::string_view name,
                                    std::optional<Literal> new_default);
 
  UpdateSchema& MakeColumnOptional(std::string_view name);
 
  UpdateSchema& RequireColumn(std::string_view name);
 
  UpdateSchema& DeleteColumn(std::string_view name);
 
  UpdateSchema& MoveFirst(std::string_view name);
 
  UpdateSchema& MoveBefore(std::string_view name, std::string_view before_name);
 
  UpdateSchema& MoveAfter(std::string_view name, std::string_view after_name);
 
  UpdateSchema& UnionByNameWith(std::shared_ptr<Schema> new_schema);
 
  UpdateSchema& SetIdentifierFields(const std::span<std::string_view>& names);
 
  UpdateSchema& CaseSensitive(bool case_sensitive);
 
  struct Move {
    enum class MoveType { kFirst, kBefore, kAfter };
 
    int32_t field_id;
    int32_t reference_field_id;  // Only used for kBefore and kAfter
    MoveType type;
 
    static Move First(int32_t field_id);
 
    static Move Before(int32_t field_id, int32_t reference_field_id);
 
    static Move After(int32_t field_id, int32_t reference_field_id);
  };
 
  Kind kind() const final { return Kind::kUpdateSchema; }
 
  bool IsRetryable() const override { return false; }
 
  struct ApplyResult {
    std::shared_ptr<Schema> schema;
    int32_t new_last_column_id;
    std::unordered_map<std::string, std::string> updated_props;
  };
 
  Result<ApplyResult> Apply();
 
 private:
  explicit UpdateSchema(std::shared_ptr<TransactionContext> ctx);
 
  UpdateSchema& AddColumnInternal(std::optional<std::string_view> parent,
                                  std::string_view name, bool is_optional,
                                  std::shared_ptr<Type> type, std::string_view doc,
                                  std::optional<Literal> default_value);
 
  UpdateSchema& UpdateColumnRequirementInternal(std::string_view name, bool is_optional);
 
  int32_t AssignNewColumnId();
 
  Result<std::optional<std::reference_wrapper<const SchemaField>>> FindField(
      std::string_view name) const;
 
  Result<std::optional<std::reference_wrapper<const SchemaField>>> FindFieldForUpdate(
      std::string_view name) const;
 
  std::string CaseSensitivityAwareName(std::string_view name) const;
 
  Result<int32_t> FindFieldIdForMove(std::string_view name) const;
 
  UpdateSchema& MoveInternal(std::string_view name, const Move& move);
 
  // Internal state
  std::shared_ptr<Schema> schema_;
  int32_t last_column_id_;
  bool allow_incompatible_changes_{false};
  bool case_sensitive_{true};
  std::vector<std::string> identifier_field_names_;
 
  // Tracking changes
  // field ID -> parent field ID
  std::unordered_map<int32_t, int32_t> id_to_parent_;
  // field IDs to delete
  std::unordered_set<int32_t> deletes_;
  // field ID -> updated field
  std::unordered_map<int32_t, std::shared_ptr<SchemaField>> updates_;
  // parent ID -> added child IDs
  std::unordered_map<int32_t, std::vector<int32_t>> parent_to_added_ids_;
  // full name -> field ID for added fields
  std::unordered_map<std::string, int32_t> added_name_to_id_;
  // parent ID -> move operations
  std::unordered_map<int32_t, std::vector<Move>> moves_;
};
 
}  // namespace iceberg