transaction.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 <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/type_fwd.h"
 
namespace iceberg {
 
enum class TransactionKind : uint8_t { kCreate, kUpdate };
 
enum class TransactionState : uint8_t {
  kReady,
  kUpdatePending,
  kCommitted,
  kFailed,
  kAborted,
  kCommitStateUnknown,
};
 
class ICEBERG_EXPORT Transaction : public std::enable_shared_from_this<Transaction> {
 public:
  ~Transaction();
 
  static Result<std::shared_ptr<Transaction>> Make(std::shared_ptr<Table> table,
                                                   TransactionKind kind);
 
  static Result<std::shared_ptr<Transaction>> Make(
      std::shared_ptr<TransactionContext> ctx);
 
  const std::shared_ptr<Table>& table() const;
 
  const TableMetadata* base() const;
 
  const TableMetadata& current() const;
 
  std::string MetadataFileLocation(std::string_view filename) const;
 
  Result<std::shared_ptr<Table>> Commit();
 
  Status Abort();
 
  TransactionState state() const { return state_; }
 
  Result<std::shared_ptr<UpdatePartitionSpec>> NewUpdatePartitionSpec();
 
  Result<std::shared_ptr<UpdateProperties>> NewUpdateProperties();
 
  Result<std::shared_ptr<UpdateSortOrder>> NewUpdateSortOrder();
 
  Result<std::shared_ptr<UpdateSchema>> NewUpdateSchema();
 
  Result<std::shared_ptr<ExpireSnapshots>> NewExpireSnapshots();
 
  Result<std::shared_ptr<UpdateStatistics>> NewUpdateStatistics();
 
  Result<std::shared_ptr<UpdatePartitionStatistics>> NewUpdatePartitionStatistics();
 
  Result<std::shared_ptr<UpdateLocation>> NewUpdateLocation();
 
  Result<std::shared_ptr<FastAppend>> NewFastAppend();
 
  Result<std::shared_ptr<MergeAppend>> NewMergeAppend();
 
  Result<std::shared_ptr<DeleteFiles>> NewDeleteFiles();
 
  Result<std::shared_ptr<RowDelta>> NewRowDelta();
 
  Result<std::shared_ptr<OverwriteFiles>> NewOverwrite();
 
  Result<std::shared_ptr<RewriteFiles>> NewRewriteFiles();
 
  Result<std::shared_ptr<ReplacePartitions>> NewReplacePartitions();
 
  Result<std::shared_ptr<RewriteManifests>> NewRewriteManifests();
 
  Result<std::shared_ptr<SnapshotManager>> NewSnapshotManager();
 
  Result<std::shared_ptr<CherryPickOperation>> NewCherryPickOperation();
 
  Result<std::shared_ptr<SetSnapshot>> NewSetSnapshot();
 
  Result<std::shared_ptr<UpdateSnapshotReference>> NewUpdateSnapshotReference();
 
 private:
  explicit Transaction(std::shared_ptr<TransactionContext> ctx);
 
  Status CheckReady() const;
  Status AddUpdate(const std::shared_ptr<PendingUpdate>& update);
 
  Status CommitUpdate(PendingUpdate& update);
  Status ApplyUpdate(PendingUpdate& update);
  Status ReplayUpdates();
 
  // Helper methods for applying different types of updates
  Status ApplyExpireSnapshots(ExpireSnapshots& update);
  Status ApplySetSnapshot(SetSnapshot& update);
  Status ApplyUpdateLocation(UpdateLocation& update);
  Status ApplyUpdatePartitionSpec(UpdatePartitionSpec& update);
  Status ApplyUpdatePartitionStatistics(UpdatePartitionStatistics& update);
  Status ApplyUpdateProperties(UpdateProperties& update);
  Status ApplyUpdateSchema(UpdateSchema& update);
  Status ApplyUpdateSnapshot(SnapshotUpdate& update);
  Status ApplyUpdateSnapshotReference(UpdateSnapshotReference& update);
  Status ApplyUpdateSortOrder(UpdateSortOrder& update);
  Status ApplyUpdateStatistics(UpdateStatistics& update);
 
  Result<std::shared_ptr<Table>> CommitOnce(bool is_first_attempt);
 
  bool CanRetry() const;
 
  void CleanupUpdates() noexcept;
  void FinalizeUpdates(const TableMetadata& committed) noexcept;
 
 private:
  friend class PendingUpdate;
 
  // Shared context owning the table, metadata builder, and kind.
  std::shared_ptr<TransactionContext> ctx_;
  // Keep track of all created pending updates.
  std::vector<std::shared_ptr<PendingUpdate>> pending_updates_;
 
  TransactionState state_ = TransactionState::kReady;
};
 
class ICEBERG_EXPORT TransactionContext {
 public:
  TransactionContext();
  ~TransactionContext();
 
  static Result<std::shared_ptr<TransactionContext>> Make(std::shared_ptr<Table> table,
                                                          TransactionKind kind);
 
  const TableMetadata* base() const;
  const TableMetadata& current() const;
  std::string MetadataFileLocation(std::string_view filename) const;
  Result<std::unique_ptr<LocationProvider>> NewLocationProvider() const;
 
  std::shared_ptr<Table> table;
  std::unique_ptr<TableMetadataBuilder> metadata_builder;
  TransactionKind kind;
  // If PendingUpdate is created directly from Table, this is nullopt;
  // otherwise, it holds a weak pointer to the Transaction that created it.
  std::optional<std::weak_ptr<Transaction>> transaction;
};
 
}  // namespace iceberg