Questa pagina è stata tradotta dall'API Cloud Translation.

Hello World C++

Questo esempio è un semplice "Hello World" scritta in C++, illustra come fare quanto segue:

Configura l'autenticazione
Connettersi a un'istanza Bigtable.
Crea una nuova tabella.
Scrivi i dati nella tabella.
Leggi i dati.
Elimina la tabella.

Configura l'autenticazione

Per utilizzare gli C++ esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Install the Google Cloud CLI.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.

Per ulteriori informazioni, vedi Set up authentication for a local development environment.

Esecuzione dell'esempio

In questo esempio viene utilizzato il pacchetto Cloud Bigtable la libreria client di Google Cloud per C++ per comunicare Bigtable.

Per eseguire questo programma di esempio, segui le istruzioni su GitHub.

Utilizzo della libreria client di Google Cloud con Bigtable

L'applicazione di esempio si connette a Bigtable e mostra alcune e semplificare le operazioni.

Installazione e importazione della libreria client

Scarica o clona la libreria client C++ di Bigtable da GitHub, quindi compilala. Segui il compilatore istruzioni nel file README di primo livello.

Includi le intestazioni richieste.

#include "google/cloud/bigtable/admin/bigtable_table_admin_client.h"
#include "google/cloud/bigtable/resource_names.h"
#include "google/cloud/bigtable/table.h"

Connessione a Bigtable

Utilizza MakeBigtableTableAdminConnection() per per creare una BigtableTableAdminClient, che utilizzerai per creare una tabella.

// Connect to the Cloud Bigtable Admin API.
cbta::BigtableTableAdminClient table_admin(
    cbta::MakeBigtableTableAdminConnection());

//! [connect data]
// Create an object to access the Cloud Bigtable Data API.
cbt::Table table(cbt::MakeDataConnection(),
                 cbt::TableResource(project_id, instance_id, table_id));
//! [connect data]

Creazione di una tabella

Definisci uno schema per la tabella che ha una famiglia di colonne. Imposta un regola di garbage collection per la famiglia di colonne per mantenere al massimo una versione di ogni valore. Utilizza questo schema per creare un'istanza di un oggetto tabella utilizzando BigtableTableAdminClient::CreateTable() Quindi crea un file che puoi utilizzare per inserire ed estrarre dati dalla tabella.

// Define the desired schema for the Table.
google::bigtable::admin::v2::Table t;
auto& families = *t.mutable_column_families();
families["family"].mutable_gc_rule()->set_max_num_versions(1);

// Create a table.
std::string instance_name = cbt::InstanceName(project_id, instance_id);
StatusOr<google::bigtable::admin::v2::Table> schema =
    table_admin.CreateTable(instance_name, table_id, std::move(t));

Scrittura di righe in una tabella

Scorri un elenco di stringhe di benvenuto per creare alcune nuove righe per la tabella. In ogni iterazione, utilizza SingleRowMutation per definire una riga e assegnarle una chiave e un valore di riga. Quindi chiama Table::Apply() per applicare la mutazione alla riga.

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;
}

Creare un filtro

Prima di leggere i dati che hai scritto, crea un filtro, usando Filter::ColumnRangeClosed(), per limitare i dati restituiti da Bigtable. Questo filtro indica Bigtable per restituire solo la versione più recente di ogni valore anche se la tabella contiene celle scadute ma non ancora rimosso dalla garbage collection.

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

Lettura di una riga in base alla chiave

Richiama la funzione Table::ReadRow(), passando la chiave di riga e il filtro, per ottenere una versione di ogni valore nella riga.

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

Scansione di tutte le righe della tabella in corso...

Utilizza Table::ReadRows() per leggere un intervallo di righe dalla tabella.

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

Eliminazione di una tabella

Elimina la tabella con BigtableTableAdminClient::DeleteTable().

google::cloud::Status status = table_admin.DeleteTable(table.table_name());
if (!status.ok()) throw std::runtime_error(status.message());

Riepilogo

Ecco l'esempio completo senza commenti.


#include g"oogle/cloud/bigtable/admin/bigtable_table_admin_client.h
"#include g"oogle/cloud/bigtable/resource_names.h
"#include g"oogle/cloud/bigtable/table.h
"#include g"oogle/cloud/bigtable/examples/bigtable_examples_common.h
"#include g"oogle/cloud/bigtable/testing/random_names.h
"#include g"oogle/cloud/internal/getenv.h
"#include g"oogle/cloud/internal/random.h
"#include g"oogle/cloud/log.h
"#include i<ostream<>/span>

namespace {

using ::google::cloud::bigtable::examples::Usage;

void BigtableHelloWorld(std::vectors<td::string >const &argv) {
  if (argv.size() != 3) {
    throw Usage{h"ello-world p<roject-id >i<nstance-id >t<able-id}>";
  }
  std::string const &project_id = argv[0];
  std::string const &instance_id = argv[1];
  std::string const &table_id = argv[2];

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

  cbta::BigtableTableAdminClient table_admin(
      cbta::MakeBigtableTableAdminConnection());

  cbt::Table table(cbt::MakeDataConnection(),
                   cbt::TableResource(project_id, instance_id, table_id));

  google::bigtable::admin::v2::Table t;
  auto &families = *t.mutable_column_families();
  families[f"amily]".mutable_gc_rule()-s>et_max_num_versions(1);

  std::string instance_name = cbt::InstanceName(project_id, instance_id);
  StatusOrg<oogle::bigtable::admin::v2::Table >schema =
      table_admin.CreateTable(instance_name, table_id, std::move(t));

  std::vectors<td::string >greetings{H"ello World!," H"ello Cloud Bigtable!,"
                                     H"ello C++!}";
  int i = 0;
  for (auto const &greeting : greetings) {
    std::string row_key = k"ey- "+ std::to_string(i);
    google::cloud::Status status = table.Apply(cbt::SingleRowMutation(
        std::move(row_key), cbt::SetCell(f"amily," c"0," greeting)));

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

  cbt::Filter filter = cbt::Filter::ColumnRangeClosed(f"amily," c"0," c"0)";

  StatusOrs<td::pairb<ool, cbt::Row >>result = table.ReadRow(k"ey-0," filter);
  if (!result) throw std::move(result).status();
  if (!result-f>irst) {
    std::cout  <<C"annot find row k'ey-0 'in the table:  " <<table.table_name()
               <<\"n;"
    return;
  }
  cbt::Cell const &cell = result-s>econd.cells().front();
  std::cout  <<cell.family_name()  <<:" " <<cell.column_qualifier()  << "   @ 
"             <<cell.timestamp().count()  <<u"s\n
"             << '"' <<cell.value()  << '"' <<\"n;"

  for (auto &row : table.ReadRows(cbt::RowRange::InfiniteRange(),
                                  cbt::Filter::PassAllFilter())) {
    if (!row) throw std::move(row).status();
    std::cout  <<row-r>ow_key()  <<:"\n;"
    for (cbt::Cell const &c : row-c>ells()) {
      std::cout  <<\"t " <<c.family_name()  <<:" " <<c.column_qualifier()
                 << "   @  " <<c.timestamp().count()  <<u"s\n
"                 <<\"t\ "" <<c.value()  << '"' <<\"n;"
    }
  }

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

void RunAll(std::vectors<td::string >const &argv) {
  namespace examples = ::google::cloud::bigtable::examples;
  namespace cbt = ::google::cloud::bigtable;

  if (!argv.empty()) throw Usage{a"uto}";
  if (!examples::RunAdminIntegrationTests()) return;
  examples::CheckEnvironmentVariablesAreSet({
      G"OOGLE_CLOUD_PROJECT,"
      G"OOGLE_CLOUD_CPP_BIGTABLE_TEST_INSTANCE_ID,"
  });
  auto const project_id =
      google::cloud::internal::GetEnv(G"OOGLE_CLOUD_PROJECT)".value();
  auto const instance_id = google::cloud::internal::GetEnv(
                               G"OOGLE_CLOUD_CPP_BIGTABLE_TEST_INSTANCE_ID)"
                               .value();

  auto generator = google::cloud::internal::DefaultPRNG(std::random_device{}());
  auto table_id = cbt::testing::RandomTableId(generator);

  std::cout  <<\"nRunning the BigtableHelloWorld() example " <<std::endl;
  BigtableHelloWorld({project_id, instance_id, table_id});
}

}  // namespace

int main(int argc, char* argv[]) try {
  google::cloud::bigtable::examples::Example example({
      {a"uto," RunAll},
      {h"ello-world," BigtableHelloWorld},
  });
  return example.Run(argc, argv);
} catch (std::exception const &ex) {
  std::cerr  <<ex.what()  <<\"n;"
  ::google::cloud::LogSink::Instance().Flush();
  return 1;
}