Class TableAdmin (2.27.0)

namespace cbt = google::cloud::bigtable;
namespace btadmin = google::bigtable::admin::v2;
cbt::TableAdmin admin = ...;
google::cloud::StatusOr<btadmin::Table> metadata = admin.GetTable(...);

if (!metadata) {
  std::cerr << "Error fetching table metadata\n";
  return;
}

// Use "metadata" as a smart pointer here, e.g.:
std::cout << "The full table name is " << table->name() << " the table has "
          << table->column_families_size() << " column families\n";

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string instance_name = cbt::InstanceName(project_id, instance_id);
    // Example garbage collection rule.
    google::bigtable::admin::v2::Table t;
    auto& families = *t.mutable_column_families();
    families["fam"].mutable_gc_rule()->set_max_num_versions(10);

    StatusOr<google::bigtable::admin::v2::Table> schema =
        admin.CreateTable(instance_name, table_id, std::move(t));
    if (!schema) throw std::move(schema).status();
    std::cout << "Table successfully created: " << schema->DebugString()
              << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StreamRange;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id) {
    std::string instance_name = cbt::InstanceName(project_id, instance_id);

    google::bigtable::admin::v2::ListTablesRequest r;
    r.set_parent(instance_name);
    r.set_view(google::bigtable::admin::v2::Table::NAME_ONLY);

    StreamRange<google::bigtable::admin::v2::Table> tables =
        admin.ListTables(std::move(r));
    for (auto& table : tables) {
      if (!table) throw std::move(table).status();
      std::cout << table->name() << "\n";
    }
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);

    google::bigtable::admin::v2::GetTableRequest r;
    r.set_name(table_name);
    r.set_view(google::bigtable::admin::v2::Table::FULL);

    StatusOr<google::bigtable::admin::v2::Table> table =
        admin.GetTable(std::move(r));
    if (!table) throw std::move(table).status();
    std::cout << table->name() << " details=\n" << table->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::Status;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    Status status = admin.DeleteTable(table_name);
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "Table successfully deleted\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::future;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& cluster_id, std::string const& backup_id,
     std::string const& expire_time_string) {
    absl::Time t;
    std::string err;
    if (!absl::ParseTime(absl::RFC3339_full, expire_time_string, &t, &err)) {
      throw std::runtime_error("Unable to parse expire_time:" + err);
    }
    std::string cluster_name =
        cbt::ClusterName(project_id, instance_id, cluster_id);
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);

    google::bigtable::admin::v2::Backup b;
    b.set_source_table(table_name);
    b.mutable_expire_time()->set_seconds(absl::ToUnixSeconds(t));

    future<StatusOr<google::bigtable::admin::v2::Backup>> backup_future =
        admin.CreateBackup(cluster_name, backup_id, std::move(b));
    auto backup = backup_future.get();
    if (!backup) throw std::move(backup).status();
    std::cout << "Backup successfully created: " << backup->DebugString()
              << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id) {
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);
    StatusOr<google::bigtable::admin::v2::Backup> backup =
        admin.GetBackup(backup_name);
    if (!backup) throw std::move(backup).status();
    std::cout << backup->name() << " details=\n"
              << backup->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id, std::string const& expire_time_string) {
    absl::Time t;
    std::string err;
    if (!absl::ParseTime(absl::RFC3339_full, expire_time_string, &t, &err)) {
      throw std::runtime_error("Unable to parse expire_time:" + err);
    }
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);

    google::bigtable::admin::v2::Backup b;
    b.set_name(backup_name);
    b.mutable_expire_time()->set_seconds(absl::ToUnixSeconds(t));

    google::protobuf::FieldMask mask;
    mask.add_paths("expire_time");

    StatusOr<google::bigtable::admin::v2::Backup> backup =
        admin.UpdateBackup(std::move(b), std::move(mask));
    if (!backup) throw std::move(backup).status();
    std::cout << backup->name() << " details=\n"
              << backup->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::Status;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id) {
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);
    Status status = admin.DeleteBackup(backup_name);
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "Backup successfully deleted\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::Status;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id) {
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);
    Status status = admin.DeleteBackup(backup_name);
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "Backup successfully deleted\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StreamRange;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& filter, std::string const& order_by) {
    std::string cluster_name =
        cbt::ClusterName(project_id, instance_id, cluster_id);

    google::bigtable::admin::v2::ListBackupsRequest r;
    r.set_parent(cluster_name);
    r.set_filter(filter);
    r.set_order_by(order_by);

    StreamRange<google::bigtable::admin::v2::Backup> backups =
        admin.ListBackups(std::move(r));
    for (auto& backup : backups) {
      if (!backup) throw std::move(backup).status();
      std::cout << backup->name() << "\n";
    }
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::future;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& cluster_id, std::string const& backup_id) {
    std::string instance_name = cbt::InstanceName(project_id, instance_id);
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);

    google::bigtable::admin::v2::RestoreTableRequest r;
    r.set_parent(instance_name);
    r.set_table_id(table_id);
    r.set_backup(backup_name);

    future<StatusOr<google::bigtable::admin::v2::Table>> table_future =
        admin.RestoreTable(std::move(r));
    auto table = table_future.get();
    if (!table) throw std::move(table).status();
    std::cout << "Table successfully restored: " << table->DebugString()
              << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::future;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& other_instance_id, std::string const& cluster_id,
     std::string const& backup_id) {
    std::string instance_name = cbt::InstanceName(project_id, instance_id);
    std::string backup_name =
        cbt::BackupName(project_id, other_instance_id, cluster_id, backup_id);

    google::bigtable::admin::v2::RestoreTableRequest r;
    r.set_parent(instance_name);
    r.set_table_id(table_id);
    r.set_backup(backup_name);

    future<StatusOr<google::bigtable::admin::v2::Table>> table_future =
        admin.RestoreTable(std::move(r));
    auto table = table_future.get();
    if (!table) throw std::move(table).status();
    std::cout << "Table successfully restored: " << table->DebugString()
              << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::bigtable::admin::v2::ModifyColumnFamiliesRequest;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    auto constexpr kSecondsPerDay =
        std::chrono::seconds(std::chrono::hours(24)).count();

    // Drop
    ModifyColumnFamiliesRequest::Modification m1;
    m1.set_id("foo");
    m1.set_drop(true);

    // Update
    ModifyColumnFamiliesRequest::Modification m2;
    m2.set_id("fam");
    m2.mutable_update()->mutable_gc_rule()->set_max_num_versions(5);

    // Create
    ModifyColumnFamiliesRequest::Modification m3;
    m3.set_id("fam");
    m3.mutable_update()->mutable_gc_rule()->mutable_max_age()->set_seconds(
        7 * kSecondsPerDay);

    StatusOr<google::bigtable::admin::v2::Table> schema =
        admin.ModifyColumnFamilies(
            table_name, {std::move(m1), std::move(m2), std::move(m3)});

    if (!schema) throw std::move(schema).status();
    std::cout << "Schema modified to: " << schema->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::Status;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& prefix) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);

    google::bigtable::admin::v2::DropRowRangeRequest r;
    r.set_name(table_name);
    r.set_row_key_prefix(prefix);

    Status status = admin.DropRowRange(std::move(r));
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "All rows starting with " << prefix
              << " successfully deleted\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    StatusOr<google::bigtable::admin::v2::GenerateConsistencyTokenResponse>
        token = admin.GenerateConsistencyToken(table_name);
    if (!token) throw std::move(token).status();
    std::cout << "generated token is : " << token->consistency_token() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& consistency_token) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    StatusOr<google::bigtable::admin::v2::CheckConsistencyResponse> result =
        admin.CheckConsistency(table_name, consistency_token);
    if (!result) throw std::move(result).status();
    if (result->consistent()) {
      std::cout << "Table is consistent with token " << consistency_token
                << "\n";
    } else {
      std::cout
          << "Table is not yet consistent, Please try again later with the"
          << " same token (" << consistency_token << ")\n";
    }
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::CompletionQueue;
  using ::google::cloud::future;
  using ::google::cloud::Status;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    StatusOr<google::bigtable::admin::v2::GenerateConsistencyTokenResponse>
        consistency_token = admin.GenerateConsistencyToken(table_name);
    if (!consistency_token) {
      throw std::move(consistency_token).status();
    }
    // Start a thread to perform the background work.
    CompletionQueue cq;
    std::thread cq_runner([&cq] { cq.Run(); });

    std::string token = consistency_token->consistency_token();
    future<Status> consistent_future =
        cbta::AsyncWaitForConsistency(cq, admin, table_name, token);

    // Simplify the example by blocking until the operation is done.
    Status status = consistent_future.get();
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "Table is consistent with token " << token << "\n";

    // Shutdown the work queue and join the background thread
    cq.Shutdown();
    cq_runner.join();
  }

  // [START bigtable_truncate_table]
  // [START bigtable_delete_rows]
  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::Status;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);

    google::bigtable::admin::v2::DropRowRangeRequest r;
    r.set_name(table_name);
    r.set_delete_all_data_from_table(true);

    Status status = admin.DropRowRange(std::move(r));
    if (!status.ok()) throw std::runtime_error(status.message());
    std::cout << "All rows successfully deleted\n";
  }
  // [END bigtable_delete_rows]
  // [END bigtable_truncate_table]

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    StatusOr<google::iam::v1::Policy> policy = admin.GetIamPolicy(table_name);
    if (!policy) throw std::move(policy).status();
    std::cout << "The IAM Policy for " << table_id << " is\n"
              << policy->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id) {
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);
    StatusOr<google::iam::v1::Policy> policy = admin.GetIamPolicy(backup_name);
    if (!policy) throw std::move(policy).status();
    std::cout << "The IAM Policy is:\n" << policy->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::string const& role, std::string const& member) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    StatusOr<google::iam::v1::Policy> current = admin.GetIamPolicy(table_name);
    if (!current) throw std::move(current).status();
    // This example adds the member to all existing bindings for that role. If
    // there are no such bindings, it adds a new one. This might not be what the
    // user wants, e.g. in case of conditional bindings.
    size_t num_added = 0;
    for (auto& binding : *current->mutable_bindings()) {
      if (binding.role() == role) {
        binding.add_members(member);
        ++num_added;
      }
    }
    if (num_added == 0) {
      *current->add_bindings() = cbt::IamBinding(role, {member});
    }
    StatusOr<google::iam::v1::Policy> policy =
        admin.SetIamPolicy(table_name, *current);
    if (!policy) throw std::move(policy).status();
    std::cout << "The IAM Policy for " << table_id << " is\n"
              << policy->DebugString() << "\n";
  }

  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;
  using ::google::cloud::StatusOr;
  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& cluster_id,
     std::string const& backup_id, std::string const& role,
     std::string const& member) {
    std::string backup_name =
        cbt::BackupName(project_id, instance_id, cluster_id, backup_id);
    StatusOr<google::iam::v1::Policy> current = admin.GetIamPolicy(backup_name);
    if (!current) throw std::move(current).status();
    // This example adds the member to all existing bindings for that role. If
    // there are no such bindings, it adds a new one. This might not be what the
    // user wants, e.g. in case of conditional bindings.
    size_t num_added = 0;
    for (auto& binding : *current->mutable_bindings()) {
      if (binding.role() == role) {
        binding.add_members(member);
        ++num_added;
      }
    }
    if (num_added == 0) {
      *current->add_bindings() = cbt::IamBinding(role, {member});
    }
    StatusOr<google::iam::v1::Policy> policy =
        admin.SetIamPolicy(backup_name, *current);
    if (!policy) throw std::move(policy).status();
    std::cout << "The IAM Policy is:\n" << policy->DebugString() << "\n";
  }

  using ::google::cloud::StatusOr;
  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;

  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::vector<std::string> const& permissions) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    auto result = admin.TestIamPermissions(table_name, permissions);
    if (!result) throw std::move(result).status();
    std::cout << "The current user has the following permissions [";
    std::cout << absl::StrJoin(result->permissions(), ", ");
    std::cout << "]\n";
  }

  using ::google::cloud::StatusOr;
  namespace cbt = ::google::cloud::bigtable;
  namespace cbta = ::google::cloud::bigtable_admin;

  [](cbta::BigtableTableAdminClient admin, std::string const& project_id,
     std::string const& instance_id, std::string const& table_id,
     std::vector<std::string> const& permissions) {
    std::string table_name = cbt::TableName(project_id, instance_id, table_id);
    auto result = admin.TestIamPermissions(table_name, permissions);
    if (!result) throw std::move(result).status();
    std::cout << "The current user has the following permissions [";
    std::cout << absl::StrJoin(result->permissions(), ", ");
    std::cout << "]\n";
  }