esegui una query sui dati Bigtable

Questo documento descrive come utilizzare BigQuery per eseguire query sui dati archiviati in una tabella esterna Bigtable. Per informazioni su come eseguire query sui dati direttamente da Bigtable, consulta la panoramica di GoogleSQL per Bigtable.

Bigtable è il database NoSQL di Google con popolamento sparso che può essere scalato a miliardi di righe, migliaia di colonne e petabyte di dati. Per informazioni sul modello dei dati Bigtable, consulta Modello di archiviazione.

Eseguire query su tabelle esterne permanenti

Prima di iniziare, tu o un amministratore della tua organizzazione dovete creare una tabella esterna da utilizzare. Per i dettagli e le autorizzazioni richieste, consulta Creare una tabella esterna BigQuery.

Ruoli obbligatori

Per eseguire query sulle tabelle esterne Bigtable, assicurati di disporre dei seguenti ruoli.

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

A seconda delle tue autorizzazioni, puoi concederti questi ruoli o chiedere all'amministratore di concederteli. Per ulteriori informazioni sulla concessione dei ruoli, consulta Visualizzazione dei ruoli assegnabili sulle risorse.

Per vedere quali sono esattamente le autorizzazioni BigQuery richieste per eseguire query sulle tabelle esterne, espandi la sezione Autorizzazioni obbligatorie:

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

esegui una query sulla tabella

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

Eseguire query sulle tabelle esterne temporanee

L'esecuzione di query su un'origine dati esterna utilizzando una tabella temporanea è utile per query ad hoc una tantum sui dati esterni o per processi ETL (Extract, Transform, Load).

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

• Un file di definizione della tabella
• Una definizione dello schema in linea
• Un file di schema JSON

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

Quando utilizzi una tabella esterna temporanea, non crei una tabella in uno dei tuoi set di dati BigQuery. Poiché la tabella non è archiviata in modo permanente in un set di dati, non può essere condivisa con altri.

L'utilizzo di una tabella esterna temporanea anziché di una tabella esterna permanente presenta alcune limitazioni, tra cui le seguenti:

• Devi disporre del ruolo Amministratore Bigtable (roles/bigtable.admin).
• Questo approccio non ti consente di utilizzare la console Google Cloud per dedurre lo schema della tabella Bigtable e creare automaticamente la definizione della tabella. Devi creare tu stesso la definizione della tabella.

Ruoli obbligatori

Per eseguire query sulle tabelle esterne temporanee Bigtable, assicurati di disporre dei seguenti ruoli:

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

A seconda delle tue autorizzazioni, puoi concederti questi ruoli o chiedere all'amministratore di concederteli. Per ulteriori informazioni sulla concessione dei ruoli, consulta Visualizzazione dei ruoli assegnabili sulle risorse.

Per vedere quali sono esattamente le autorizzazioni BigQuery richieste per eseguire query sulle tabelle esterne, espandi la sezione Autorizzazioni obbligatorie:

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

Crea ed esegui query sulla tabella

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

• Crea un file di definizione della tabella
• Invia sia una query che un file di definizione della tabella

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

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

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

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 dipendono da tre fattori:

• Il numero di righe
• La quantità di dati letti
• Il grado di parallelizzazione

BigQuery tenta di leggere il minor numero possibile di dati leggendo solo le famiglie di colonne a cui viene fatto riferimento nella query. Il grado di parallelizzazione dipende dal numero di nodi nel cluster Bigtable e dal numero di suddivisioni della tabella.

Tieni presente che Bigtable unisce automaticamente le suddivisioni in base al carico. Se la tua tabella non viene letta di frequente, nel tempo ci saranno meno suddivisioni e un graduale peggioramento delle prestazioni delle query. Per ulteriori informazioni, consulta la pagina Come BigQuery ottimizza i tuoi dati nel tempo.

Computing

Quando esegui query sui dati Bigtable da BigQuery, hai le seguenti opzioni di calcolo:

• Nodi del cluster, che è l'impostazione predefinita.
• Data Boost (anteprima), un'opzione di serverless computing che consente di isolare il traffico di analisi senza influire sul traffico di pubblicazione delle applicazioni gestito dai nodi dei cluster.

Per utilizzare Data Boost, tu o il tuo amministratore dovete creare un file di definizione che specifica un profilo dell'app Data Boost nell'URI Bigtable. Per saperne di più, consulta Creare una tabella esterna Bigtable.

Se non utilizzi Data Boost, tieni presente che l'esecuzione di query su Bigtable da BigQuery consuma cicli di CPU di Bigtable. Il consumo di CPU da parte di BigQuery quando si utilizzano nodi di cui è stato eseguito il provisioning per il calcolo potrebbe influire sulla latenza e sul throughput di altre richieste simultanee, ad esempio la pubblicazione del traffico degli utenti live. Ad esempio, un utilizzo elevato della CPU su Bigtable influisce sulle query long tail e aumenta la latenza al 99° percentile.

Di conseguenza, devi monitorare l'utilizzo della CPU di Bigtable per verificare di rientrare nei limiti consigliati, come indicato nella dashboard di monitoraggio di Bigtable nella console Google Cloud . Aumentando il numero di nodi per l'istanza, puoi gestire sia il traffico BigQuery sia il traffico di altre richieste simultanee.

Filtri delle query

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

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

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