update_partition_spec.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 <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/type_fwd.h"
#include "iceberg/update/pending_update.h"
#include "iceberg/util/string_util.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT UpdatePartitionSpec : public PendingUpdate {
 public:
  static Result<std::shared_ptr<UpdatePartitionSpec>> Make(
      std::shared_ptr<TransactionContext> ctx);
 
  ~UpdatePartitionSpec() override;
 
  UpdatePartitionSpec& CaseSensitive(bool is_case_sensitive);
 
  UpdatePartitionSpec& AddField(std::string_view source_name);
 
  UpdatePartitionSpec& AddField(const std::shared_ptr<Term>& term,
                                std::string_view part_name = "");
 
  UpdatePartitionSpec& RemoveField(std::string_view name);
 
  UpdatePartitionSpec& RemoveField(const std::shared_ptr<Term>& term);
 
  UpdatePartitionSpec& RenameField(std::string_view name, std::string new_name);
 
  UpdatePartitionSpec& AddNonDefaultSpec();
 
  Kind kind() const final { return Kind::kUpdatePartitionSpec; }
 
  bool IsRetryable() const override { return false; }
 
  struct ApplyResult {
    std::shared_ptr<PartitionSpec> spec;
    bool set_as_default;
  };
  Result<ApplyResult> Apply();
 
 private:
  explicit UpdatePartitionSpec(std::shared_ptr<TransactionContext> ctx);
 
  using TransformKey = std::pair<int32_t, std::string>;
 
  struct TransformKeyHash {
    size_t operator()(const TransformKey& key) const {
      return 31 * std::hash<int32_t>{}(key.first) + std::hash<std::string>{}(key.second);
    }
  };
 
  int32_t AssignFieldId();
 
  PartitionField RecycleOrCreatePartitionField(int32_t source_id,
                                               std::shared_ptr<Transform> transform,
                                               std::string_view name);
 
  UpdatePartitionSpec& AddFieldInternal(std::string_view name, int32_t source_id,
                                        const std::shared_ptr<Transform>& transform);
 
  Result<std::string> GeneratePartitionName(
      int32_t source_id, const std::shared_ptr<Transform>& transform) const;
 
  static bool IsTimeTransform(const std::shared_ptr<Transform>& transform);
 
  static bool IsVoidTransform(const PartitionField& field);
 
  void CheckForRedundantAddedPartitions(const PartitionField& field);
 
  UpdatePartitionSpec& RewriteDeleteAndAddField(const PartitionField& existing,
                                                std::string_view name);
 
  UpdatePartitionSpec& RemoveFieldByTransform(const TransformKey& key,
                                              std::string_view term_str);
 
  static std::unordered_map<std::string, const PartitionField*, StringHash, StringEqual>
  IndexSpecByName(const PartitionSpec& spec);
 
  static std::unordered_map<TransformKey, const PartitionField*, TransformKeyHash>
  IndexSpecByTransform(const PartitionSpec& spec);
 
  void BuildHistoricalFieldsIndex();
 
  // Configuration
  int32_t format_version_;
  std::shared_ptr<PartitionSpec> spec_;
  std::shared_ptr<Schema> schema_;
  bool case_sensitive_{true};
  bool set_as_default_{true};
  int32_t last_assigned_partition_id_;
 
  // Indexes for existing fields
  std::unordered_map<std::string, const PartitionField*, StringHash, StringEqual>
      name_to_field_;
  std::unordered_map<TransformKey, const PartitionField*, TransformKeyHash>
      transform_to_field_;
 
  // Index for historical partition fields (V2+ only) for efficient recycling.
  // Maps (source_id, transform_string) -> PartitionField from all historical specs.
  std::unordered_map<TransformKey, PartitionField, TransformKeyHash> historical_fields_;
 
  // Pending changes
  std::vector<PartitionField> adds_;
  std::unordered_set<std::string, StringHash, StringEqual> added_field_names_;
  std::unordered_map<int32_t, std::string> added_time_fields_;
  std::unordered_map<TransformKey, std::string, TransformKeyHash>
      transform_to_added_field_;
  std::unordered_set<int32_t> deletes_;
  std::unordered_map<std::string, std::string, StringHash, StringEqual> renames_;
};
 
}  // namespace iceberg