Exemplo: aplicativo "Hello World" em C++

Este exemplo é um aplicativo "Hello World" simples, escrito em C++, que ilustra como:

  • conectar-se a uma instância do Cloud Bigtable;
  • criar uma nova tabela;
  • gravar dados na tabela;
  • ler os dados de volta;
  • excluir a tabela.

Executar o exemplo

Este exemplo usa o pacote do Cloud Bigtable da biblioteca de cliente do Google Cloud para C++ (links em inglês) para se comunicar com o Cloud Bigtable.

Para executar este programa de amostra, siga as instruções no GitHub.

Como usar a biblioteca de cliente do Cloud com o Cloud Bigtable

O aplicativo de amostra conecta-se ao Cloud Bigtable e demonstra algumas operações simples.

Como instalar e importar a biblioteca de cliente

Faça o download ou clone a biblioteca de cliente do Cloud Bigtable para C ++ do GitHub e compile-a. Siga as instruções do compilador no README (em inglês).

Inclua os cabeçalhos obrigatórios.

#include "google/cloud/bigtable/table.h"
#include "google/cloud/bigtable/table_admin.h"

Conexão ao Cloud Bigtable

Use TableAdmin.CreateDefaultAdminClient() para criar um cliente administrador que será usado para criar uma tabela.

cbt::TableAdmin table_admin(
    cbt::CreateDefaultAdminClient(project_id, cbt::ClientOptions()),
    instance_id);

Como criar uma tabela

Defina um esquema para a tabela que tenha um grupo de colunas. Defina uma regra de coleta de lixo para o grupo de colunas para manter no máximo uma versão de cada valor. Use esse esquema para instanciar um objeto de tabela usando TableAdmin.CreateTable(). Em seguida, crie um cliente de dados que você possa usar para obter dados dentro e fora da sua tabela.

// Define the desired schema for the Table.
cbt::GcRule gc_rule = cbt::GcRule::MaxNumVersions(1);
cbt::TableConfig schema({{"family", gc_rule}}, {});

// Create a table.
StatusOr<google::bigtable::admin::v2::Table> returned_schema =
    table_admin.CreateTable(table_id, schema);

// Create an object to access the Cloud Bigtable Data API.
cbt::Table table(cbt::CreateDefaultDataClient(project_id, instance_id,
                                              cbt::ClientOptions()),
                 table_id);

Como gravar linhas em uma tabela

Execute um loop em uma lista de strings de saudação para criar algumas linhas novas para a tabela. Em cada iteração, use SingleRowMutation() para definir uma linha e atribuir a ela um valor e uma chave de linha. Em seguida, chame Table.Apply() para aplicar a mutação à linha.

std::vector<std::string> greetings{"Hello World!", "Hello Cloud Bigtable!",
                                   "Hello C++!"};
int i = 0;
for (auto const& greeting : greetings) {
  // Each row has a unique row key.
  //
  // Note: This example uses sequential numeric IDs for simplicity, but
  // this can result in poor performance in a production application.
  // Since rows are stored in sorted order by key, sequential keys can
  // result in poor distribution of operations across nodes.
  //
  // For more information about how to design a Bigtable schema for the
  // best performance, see the documentation:
  //
  //     https://cloud.google.com/bigtable/docs/schema-design
  std::string row_key = "key-" + std::to_string(i);
  google::cloud::Status status = table.Apply(cbt::SingleRowMutation(
      std::move(row_key), cbt::SetCell("family", "c0", greeting)));

  if (!status.ok()) {
    throw std::runtime_error(status.message());
  }
  ++i;
}

Como criar um filtro

Antes de ler os dados gravados, crie um filtro usando Filter.ColumnRangeClosed() para limitar os dados retornados pelo Cloud Bigtable. Com esse filtro, o Cloud Bigtable retorna apenas a versão mais recente de cada valor, mesmo que a tabela contenha versões mais antigas que não tenham passado pela coleta de lixo.

cbt::Filter filter = cbt::Filter::ColumnRangeClosed("family", "c0", "c0");

Como ler uma linha pela chave dela

Chame a função Table.ReadRow(), transmitindo a chave de linha e o filtro, para obter uma versão de cada valor nessa linha.

StatusOr<std::pair<bool, cbt::Row>> result = table.ReadRow("key-0", filter);
if (!result) {
  throw std::runtime_error(result.status().message());
}
if (!result->first) {
  std::cout << "Cannot find row 'key-0' in the table: " << table.table_name()
            << "\n";
  return 0;
}
cbt::Cell const& cell = result->second.cells().front();
std::cout << cell.family_name() << ":" << cell.column_qualifier() << "    @ "
          << cell.timestamp().count() << "us\n"
          << '"' << cell.value() << '"' << "\n";

Verificação de todas as linhas da tabela

Use Table.ReadRows() para ler um intervalo de linhas da tabela.

for (StatusOr<cbt::Row> const& row : table.ReadRows(
         cbt::RowRange::InfiniteRange(), cbt::Filter::PassAllFilter())) {
  if (!row) {
    throw std::runtime_error(row.status().message());
  }
  std::cout << row->row_key() << ":\n";
  for (cbt::Cell const& cell : row->cells()) {
    std::cout << "\t" << cell.family_name() << ":" << cell.column_qualifier()
              << "    @ " << cell.timestamp().count() << "us\n"
              << "\t\"" << cell.value() << '"' << "\n";
  }
}

Como excluir tabelas

Exclua a tabela com DeleteTable().

google::cloud::Status status = table_admin.DeleteTable(table_id);
if (!status.ok()) {
  throw std::runtime_error(status.message());
}

Funcionamento em conjunto

Aqui está o exemplo completo sem comentários.



#include "google/cloud/bigtable/table.h"
#include "google/cloud/bigtable/table_admin.h"
#include <iostream>

int main(int argc, char* argv[]) try {
  if (argc != 4) {
    std::string const cmd = argv[0];
    auto last_slash = std::string(cmd).find_last_of('/');
    std::cerr << "Usage: " << cmd.substr(last_slash + 1)
              << " <project_id> <instance_id> <table_id>\n";
    return 1;
  }

  std::string const project_id = argv[1];
  std::string const instance_id = argv[2];
  std::string const table_id = argv[3];

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

  cbt::TableAdmin table_admin(
      cbt::CreateDefaultAdminClient(project_id, cbt::ClientOptions()),
      instance_id);

  cbt::GcRule gc_rule = cbt::GcRule::MaxNumVersions(1);
  cbt::TableConfig schema({{"family", gc_rule}}, {});

  StatusOr<google::bigtable::admin::v2::Table> returned_schema =
      table_admin.CreateTable(table_id, schema);

  cbt::Table table(cbt::CreateDefaultDataClient(project_id, instance_id,
                                                cbt::ClientOptions()),
                   table_id);

  std::vector<std::string> greetings{"Hello World!", "Hello Cloud Bigtable!",
                                     "Hello C++!"};
  int i = 0;
  for (auto const& greeting : greetings) {
    std::string row_key = "key-" + std::to_string(i);
    google::cloud::Status status = table.Apply(cbt::SingleRowMutation(
        std::move(row_key), cbt::SetCell("family", "c0", greeting)));

    if (!status.ok()) {
      throw std::runtime_error(status.message());
    }
    ++i;
  }

  cbt::Filter filter = cbt::Filter::ColumnRangeClosed("family", "c0", "c0");

  StatusOr<std::pair<bool, cbt::Row>> result = table.ReadRow("key-0", filter);
  if (!result) {
    throw std::runtime_error(result.status().message());
  }
  if (!result->first) {
    std::cout << "Cannot find row 'key-0' in the table: " << table.table_name()
              << "\n";
    return 0;
  }
  cbt::Cell const& cell = result->second.cells().front();
  std::cout << cell.family_name() << ":" << cell.column_qualifier() << "    @ "
            << cell.timestamp().count() << "us\n"
            << '"' << cell.value() << '"' << "\n";

  for (StatusOr<cbt::Row> const& row : table.ReadRows(
           cbt::RowRange::InfiniteRange(), cbt::Filter::PassAllFilter())) {
    if (!row) {
      throw std::runtime_error(row.status().message());
    }
    std::cout << row->row_key() << ":\n";
    for (cbt::Cell const& cell : row->cells()) {
      std::cout << "\t" << cell.family_name() << ":" << cell.column_qualifier()
                << "    @ " << cell.timestamp().count() << "us\n"
                << "\t\"" << cell.value() << '"' << "\n";
    }
  }

  google::cloud::Status status = table_admin.DeleteTable(table_id);
  if (!status.ok()) {
    throw std::runtime_error(status.message());
  }

  return 0;
} catch (std::exception const& ex) {
  std::cerr << "Standard C++ exception raised: " << ex.what() << "\n";
  return 1;
}
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Cloud Bigtable