esegui una query sui dati Bigtable

Questo documento descrive come eseguire query sui dati archiviati in un Tabella esterna Bigtable.

Bigtable è il database NoSQL sparso scalabile fino a miliardi di righe, migliaia di colonne e e petabyte di dati. Per informazioni sul modello dei dati Bigtable, consulta Modello di archiviazione.

Esegui query su tabelle esterne permanenti

Prima di iniziare, tu o un altro utente dell'organizzazione dovete creare un'istanza esterna che puoi utilizzare. Per dettagli e autorizzazioni richieste, consulta la sezione Creare un Tabella esterna BigQuery.

Ruoli obbligatori

Per eseguire query sulle tabelle esterne permanenti di Bigtable, assicurati disponi dei seguenti ruoli:

  • Visualizzatore dati BigQuery (roles/bigquery.dataViewer)
  • Utente BigQuery (roles/bigquery.user)
  • Lettore Bigtable (roles/bigtable.reader)

In base alle tue autorizzazioni, puoi concediti questi ruoli o chiedi all'amministratore per concederteli. Per ulteriori informazioni sulla concessione dei ruoli, consulta Visualizzazione dei ruoli assegnabili nelle risorse.

Per visualizzare le autorizzazioni BigQuery esatte necessarie per eseguire la query tabelle esterne, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Potresti anche riuscire a ottenere queste autorizzazioni con i ruoli personalizzati. o altri ruoli predefiniti.

esegui una query sulla tabella

Puoi eseguire una query su una tabella Bigtable esterna permanente esattamente come se si trattasse di un tabella BigQuery standard, soggetto alle limitazioni su origini dati esterne. Per ulteriori informazioni, consulta Eseguire query interattive e batch query.

Eseguire query su tabelle esterne temporanee

È utile eseguire query su un'origine dati esterna utilizzando una tabella temporanea per query una tantum ad hoc su dati esterni o per l'estrazione, la trasformazione e il caricamento (ETL) i processi di machine learning.

Per eseguire una query su un'origine dati esterna senza creare una tabella permanente, fornisci una tabella definizione della tabella temporanea e poi utilizzarla in un comando o in una chiamata per eseguire una query sulla tabella temporanea. Puoi fornire la definizione della tabella in uno dei seguenti modi modi:

Il file di definizione della tabella o lo schema fornito vengono utilizzati per creare la tabella esterna temporanea. e la query viene eseguita sulla tabella esterna temporanea.

Quando utilizzi una tabella esterna temporanea, non ne crei una in una delle set di dati BigQuery. Poiché la tabella non è archiviata in modo permanente in un set di dati, non possono essere condivisi con altri.

Utilizzo di una tabella esterna temporanea anziché di una tabella esterna permanente presenta alcune limitazioni, tra cui:

  • Devi avere il ruolo Amministratore Bigtable (roles/bigtable.admin).
  • Questo approccio non consente di utilizzare la console Google Cloud per dedurre dello schema della tabella Bigtable e crea automaticamente la tabella definizione di Kubernetes. Devi creare personalmente la definizione della tabella.

Ruoli obbligatori

Per eseguire query su tabelle esterne temporanee di Bigtable, assicurati disponi dei seguenti ruoli:

  • Visualizzatore dati BigQuery (roles/bigquery.dataViewer)
  • Utente BigQuery (roles/bigquery.user)
  • Amministratore Bigtable (roles/bigtable.admin)

In base alle tue autorizzazioni, puoi concediti questi ruoli o chiedi all'amministratore per concederteli. Per ulteriori informazioni sulla concessione dei ruoli, consulta Visualizzazione dei ruoli assegnabili nelle risorse.

Per visualizzare le autorizzazioni BigQuery esatte necessarie per eseguire la query tabelle esterne, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Potresti anche riuscire a ottenere queste autorizzazioni con i ruoli personalizzati. o altri ruoli predefiniti.

Crea ed esegui query sulla tabella

Per eseguire query sui dati Bigtable utilizzando una tabella esterna temporanea:

La creazione e l'esecuzione di query su una tabella esterna temporanea sono supportate dal a riga di comando bq e l'API.

bq

Per eseguire query su una tabella temporanea utilizzando un file di definizione della tabella, inserisci il metodo Comando bq query con il flag --external_table_definition.

(Facoltativo) Fornisci il flag --location e imposta il valore su località.

bq --location=LOCATION query \
--use_legacy_sql=false \
--external_table_definition=TABLE::DEFINITION_FILE \
'QUERY'

Sostituisci quanto segue:

  • LOCATION: il nome della tua località. Il flag --location è facoltativo.
  • TABLE: il nome della tabella temporanea che stai creando.
  • DEFINITION_FILE: il percorso file di definizione della tabella sul tuo computer locale.
  • QUERY: la query che stai inviando alla tabella temporanea.

Ad esempio, il comando seguente crea ed esegue una query su una tabella temporanea denominato follows mediante un file di definizione della tabella denominato follows_def.

bq query \
--use_legacy_sql=false \
--external_table_definition=follows::/tmp/follows_def \
'SELECT
  COUNT(rowkey)
 FROM
   follows'

API

  • Crea una query. Consulta Esecuzione di query sui dati per informazioni sulla creazione di un job di query.

  • (Facoltativo) Specifica la tua località nella proprietà location del Sezione jobReference della risorsa job.

  • Specifica le proprietà delle origini dati esterne impostando il parametro ExternalDataConfiguration per la risorsa tabella.

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.BigtableColumn;
import com.google.cloud.bigquery.BigtableColumnFamily;
import com.google.cloud.bigquery.BigtableOptions;
import com.google.cloud.bigquery.ExternalTableDefinition;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;
import com.google.common.collect.ImmutableList;
import org.apache.commons.codec.binary.Base64;

// Sample to queries an external bigtable data source using a temporary table
public class QueryExternalBigtableTemp {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String bigtableInstanceId = "MY_INSTANCE_ID";
    String bigtableTableName = "MY_BIGTABLE_NAME";
    String bigqueryTableName = "MY_TABLE_NAME";
    String sourceUri =
        String.format(
            "https://googleapis.com/bigtable/projects/%s/instances/%s/tables/%s",
            projectId, bigtableInstanceId, bigtableTableName);
    String query = String.format("SELECT * FROM %s ", bigqueryTableName);
    queryExternalBigtableTemp(bigqueryTableName, sourceUri, query);
  }

  public static void queryExternalBigtableTemp(String tableName, String sourceUri, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      BigtableColumnFamily.Builder statsSummary = BigtableColumnFamily.newBuilder();

      // Configuring Columns
      BigtableColumn connectedCell =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("connected_cell".getBytes()))
              .setFieldName("connected_cell")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();
      BigtableColumn connectedWifi =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("connected_wifi".getBytes()))
              .setFieldName("connected_wifi")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();
      BigtableColumn osBuild =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("os_build".getBytes()))
              .setFieldName("os_build")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();

      // Configuring column family and columns
      statsSummary
          .setColumns(ImmutableList.of(connectedCell, connectedWifi, osBuild))
          .setFamilyID("stats_summary")
          .setOnlyReadLatest(true)
          .setEncoding("TEXT")
          .setType("STRING")
          .build();

      // Configuring BigtableOptions is optional.
      BigtableOptions options =
          BigtableOptions.newBuilder()
              .setIgnoreUnspecifiedColumnFamilies(true)
              .setReadRowkeyAsString(true)
              .setColumnFamilies(ImmutableList.of(statsSummary.build()))
              .build();

      // Configure the external data source and query job.
      ExternalTableDefinition externalTable =
          ExternalTableDefinition.newBuilder(sourceUri, options).build();
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query)
              .addTableDefinition(tableName, externalTable)
              .build();

      // Example query
      TableResult results = bigquery.query(queryConfig);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));

      System.out.println("Query on external temporary table performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Considerazioni sulle prestazioni

Le prestazioni delle query sulle origini dati esterne di Bigtable dipende da tre fattori:

  • Il numero di righe
  • La quantità di dati letti
  • L'estensione del caricamento in contemporanea

BigQuery prova a leggere la minor quantità di dati possibile leggendo solo le famiglie di colonne a cui viene fatto riferimento nella query. L'estensione il caricamento in contemporanea dipende da quanti nodi Cluster Bigtable e quante suddivisioni hai per la tua tabella.

Tieni presente che Bigtable unisce automaticamente le suddivisioni in base al carico. Se le tue una tabella non viene letta di frequente, ci saranno meno suddivisioni nel tempo un peggioramento graduale delle prestazioni delle query. Per ulteriori informazioni sulla suddivisione una tabella per chiave di riga, consulta Gestione delle tabelle.

L'esecuzione di query su Bigtable da BigQuery Cicli di CPU di Bigtable. Consumo di CPU da parte di BigQuery potrebbero influire sulla latenza e sulla velocità effettiva per altre richieste in parallelo, come quelle gestione del traffico degli utenti. Ad esempio, utilizzo elevato della CPU su Bigtable influisce sulle query long-tail e aumenta la latenza al 99° percentile.

Devi monitorare l'utilizzo della CPU di Bigtable per verificare entro i limiti consigliati, come indicato nella nella console Google Cloud. Aumentando il numero di i nodi per l'istanza consentono di gestire Traffico BigQuery e traffico da altri richieste in parallelo.

Filtri di query

Le query con un filtro di uguaglianza delle righe leggono solo quella riga specifica. Ad esempio, nel Sintassi GoogleSQL:

SELECT
  COUNT(follows.column.name)
FROM
  `dataset.table`
WHERE
  rowkey = "alice";

Sono supportati anche i filtri per intervallo, come rowkey > '1' e rowkey < '8', ma solo quando rowkey viene letta come stringa con l'opzione readRowkeyAsString.