table.h

/*
 * 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 <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/snapshot.h"
#include "iceberg/table_identifier.h"
#include "iceberg/type_fwd.h"
#include "iceberg/update/update_location.h"
#include "iceberg/util/timepoint.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT Table : public std::enable_shared_from_this<Table> {
 public:
  static Result<std::shared_ptr<Table>> Make(TableIdentifier identifier,
                                             std::shared_ptr<TableMetadata> metadata,
                                             std::string metadata_location,
                                             std::shared_ptr<FileIO> io,
                                             std::shared_ptr<Catalog> catalog);
 
  virtual ~Table();
 
  const TableIdentifier& name() const { return identifier_; }
 
  const std::string& uuid() const;
 
  Result<std::shared_ptr<Schema>> schema() const;
 
  Result<
      std::reference_wrapper<const std::unordered_map<int32_t, std::shared_ptr<Schema>>>>
  schemas() const;
 
  Result<std::shared_ptr<PartitionSpec>> spec() const;
 
  Result<std::reference_wrapper<
      const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>>>
  specs() const;
 
  Result<std::shared_ptr<SortOrder>> sort_order() const;
 
  Result<std::reference_wrapper<
      const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>>>
  sort_orders() const;
 
  const TableProperties& properties() const;
 
  std::string_view metadata_file_location() const;
 
  std::string_view location() const;
 
  TimePointMs last_updated_ms() const;
 
  Result<std::shared_ptr<Snapshot>> current_snapshot() const;
 
  Result<std::shared_ptr<Snapshot>> SnapshotById(int64_t snapshot_id) const;
 
  const std::vector<std::shared_ptr<Snapshot>>& snapshots() const;
 
  const std::vector<SnapshotLogEntry>& history() const;
 
  const std::shared_ptr<FileIO>& io() const;
 
  const std::shared_ptr<TableMetadata>& metadata() const;
 
  const std::shared_ptr<Catalog>& catalog() const;
 
  Result<std::unique_ptr<LocationProvider>> location_provider() const;
 
  virtual Status Refresh();
 
  virtual Result<std::unique_ptr<DataTableScanBuilder>> NewScan() const;
 
  virtual Result<std::unique_ptr<IncrementalAppendScanBuilder>> NewIncrementalAppendScan()
      const;
 
  virtual Result<std::unique_ptr<IncrementalChangelogScanBuilder>>
  NewIncrementalChangelogScan() const;
 
  virtual Result<std::shared_ptr<Transaction>> NewTransaction();
 
  virtual Result<std::shared_ptr<UpdatePartitionSpec>> NewUpdatePartitionSpec();
 
  virtual Result<std::shared_ptr<UpdateProperties>> NewUpdateProperties();
 
  virtual Result<std::shared_ptr<UpdateSortOrder>> NewUpdateSortOrder();
 
  virtual Result<std::shared_ptr<UpdateSchema>> NewUpdateSchema();
 
  virtual Result<std::shared_ptr<ExpireSnapshots>> NewExpireSnapshots();
 
  virtual Result<std::shared_ptr<UpdateStatistics>> NewUpdateStatistics();
 
  virtual Result<std::shared_ptr<UpdatePartitionStatistics>>
  NewUpdatePartitionStatistics();
 
  virtual Result<std::shared_ptr<UpdateLocation>> NewUpdateLocation();
 
  virtual Result<std::shared_ptr<FastAppend>> NewFastAppend();
 
  virtual Result<std::shared_ptr<SnapshotManager>> NewSnapshotManager();
 
 protected:
  Table(TableIdentifier identifier, std::shared_ptr<TableMetadata> metadata,
        std::string metadata_location, std::shared_ptr<FileIO> io,
        std::shared_ptr<Catalog> catalog);
 
  const TableIdentifier identifier_;
  std::shared_ptr<TableMetadata> metadata_;
  std::string metadata_location_;
  std::shared_ptr<FileIO> io_;
  std::shared_ptr<Catalog> catalog_;
  std::unique_ptr<class TableMetadataCache> metadata_cache_;
};
 
class ICEBERG_EXPORT StagedTable final : public Table {
 public:
  static Result<std::shared_ptr<StagedTable>> Make(
      TableIdentifier identifier, std::shared_ptr<TableMetadata> metadata,
      std::string metadata_location, std::shared_ptr<FileIO> io,
      std::shared_ptr<Catalog> catalog);
 
  ~StagedTable() override;
 
  Status Refresh() override { return {}; }
 
  Result<std::unique_ptr<DataTableScanBuilder>> NewScan() const override;
 
 private:
  using Table::Table;
};
 
 
class ICEBERG_EXPORT StaticTable final : public Table {
 public:
  static Result<std::shared_ptr<StaticTable>> Make(
      TableIdentifier identifier, std::shared_ptr<TableMetadata> metadata,
      std::string metadata_location, std::shared_ptr<FileIO> io);
 
  ~StaticTable() override;
 
  Status Refresh() override;
 
  Result<std::shared_ptr<Transaction>> NewTransaction() override;
 
  Result<std::shared_ptr<UpdateProperties>> NewUpdateProperties() override;
 
  Result<std::shared_ptr<UpdateSchema>> NewUpdateSchema() override;
 
 private:
  using Table::Table;
};
 
}  // namespace iceberg