Consultar datos de Bigtable

En este documento se describe cómo usar BigQuery para consultar datos almacenados en una tabla externa de Bigtable. Para obtener información sobre cómo consultar datos directamente desde Bigtable, consulta la descripción general de GoogleSQL para Bigtable.

Bigtable es la base de datos NoSQL de Google con datos dispersos que puede escalarse a miles de millones de filas, miles de columnas y petabytes de datos. Para obtener información sobre el modelo de datos de Bigtable, consulta Modelo de almacenamiento.

Consultar tablas externas permanentes

Antes de empezar, tú o un administrador de tu organización debéis crear una tabla externa para que puedas usarla. Para obtener más información y consultar los permisos necesarios, consulta Crear una tabla externa de BigQuery.

Roles obligatorios

Para consultar tablas externas de Bigtable, asegúrate de que tienes los siguientes roles.

  • Lector de datos de BigQuery (roles/bigquery.dataViewer)
  • Usuario de BigQuery (roles/bigquery.user)
  • Lector de Bigtable (roles/bigtable.reader)

En función de tus permisos, puedes concederte estos roles a ti mismo o pedirle a tu administrador que te los conceda. Para obtener más información sobre cómo conceder roles, consulta el artículo Ver los roles que se pueden conceder en los recursos.

Para ver los permisos exactos de BigQuery que se necesitan para consultar tablas externas, despliega la sección Permisos necesarios:

Permisos obligatorios

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Consultar la tabla

Puedes ejecutar una consulta en una tabla externa permanente de Bigtable exactamente igual que si fuera una tabla estándar de BigQuery, sujeta a las limitaciones de las fuentes de datos externas. Para obtener más información, consulta Ejecutar consultas interactivas y por lotes.

Consultar tablas externas temporales

Consultar una fuente de datos externa mediante una tabla temporal es útil para realizar consultas puntuales y ad hoc sobre datos externos, o para procesos de extracción, transformación y carga (ETL).

Para consultar una fuente de datos externa sin crear una tabla permanente, debes proporcionar una definición de tabla para la tabla temporal y, a continuación, usar esa definición de tabla en un comando o una llamada para consultar la tabla temporal. Puedes proporcionar la definición de la tabla de cualquiera de las siguientes formas:

El archivo de definición de tabla o el esquema proporcionado se utilizan para crear la tabla externa temporal y la consulta se ejecuta en la tabla externa temporal.

Cuando usas una tabla externa temporal, no creas una tabla en uno de tus conjuntos de datos de BigQuery. Como la tabla no se almacena de forma permanente en un conjunto de datos, no se puede compartir con otros usuarios.

Usar una tabla externa temporal en lugar de una permanente tiene algunas limitaciones, como las siguientes:

  • Debes tener el rol Administrador de Bigtable (roles/bigtable.admin).
  • Con este método, no puedes usar la Google Cloud consola para inferir el esquema de la tabla de Bigtable y crear automáticamente la definición de la tabla. Debes crear la definición de tabla tú mismo.

Roles obligatorios

Para consultar tablas externas temporales de Bigtable, asegúrate de tener los siguientes roles:

  • Lector de datos de BigQuery (roles/bigquery.dataViewer)
  • Usuario de BigQuery (roles/bigquery.user)
  • Administración de Bigtable (roles/bigtable.admin)

En función de tus permisos, puedes concederte estos roles a ti mismo o pedirle a tu administrador que te los conceda. Para obtener más información sobre cómo conceder roles, consulta el artículo Ver los roles que se pueden conceder en los recursos.

Para ver los permisos exactos de BigQuery que se necesitan para consultar tablas externas, despliega la sección Permisos necesarios:

Permisos obligatorios

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Crear y consultar la tabla

Para consultar datos de Bigtable con una tabla externa temporal, debes hacer lo siguiente:

La herramienta de línea de comandos bq y la API permiten crear y consultar tablas externas temporales.

bq

Para consultar una tabla temporal con un archivo de definición de tabla, introduce el comando bq query con la marca --external_table_definition.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

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

Haz los cambios siguientes:

  • LOCATION: el nombre de tu ubicación. La marca --location es opcional.
  • TABLE: el nombre de la tabla temporal que vas a crear.
  • DEFINITION_FILE: la ruta al archivo de definición de tabla en tu máquina local.
  • QUERY: la consulta que envías a la tabla temporal.

Por ejemplo, el siguiente comando crea y consulta una tabla temporal llamada follows mediante un archivo de definición de tabla llamado follows_def.

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

API

  • Crea una consulta. Consulta Consultar datos para obtener información sobre cómo crear un trabajo de consulta.

  • (Opcional) Especifica tu ubicación en la propiedad location de la sección jobReference del recurso Job.

  • Especifica las propiedades de la fuente de datos externa configurando el ExternalDataConfiguration del recurso de tabla.

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente. 

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(