Esta página se ha traducido con Cloud Translation API.

Consultar tablas agrupadas en clústeres

Cuando creas una tabla agrupada en clústeres en BigQuery, los datos de la tabla se organizan automáticamente en función del contenido de una o más columnas del esquema de la tabla. Las columnas que especifiques se usarán para colocar los datos relacionados en el mismo lugar. Cuando agrupa una tabla usando varias columnas, es importante el orden de las columnas que especifique. El orden de las columnas especificadas determina el orden de los datos.

Para optimizar el rendimiento al ejecutar consultas en tablas agrupadas en clústeres, usa una expresión que filtre por una columna agrupada o por varias columnas agrupadas en el orden en que se especifican las columnas agrupadas. Las consultas que filtran por columnas agrupadas en clústeres suelen tener un mejor rendimiento que las que filtran solo por columnas que no están agrupadas en clústeres.

BigQuery ordena los datos de las tablas agrupadas en clústeres según los valores de las columnas de este tipo de agrupamiento y los organiza en bloques.

Cuando envías una consulta que incluye un filtro en una columna agrupada en clústeres, BigQuery emplea la información de dicho agrupamiento para determinar de forma eficiente si algún bloque contiene datos pertinentes para la consulta. De ese modo, BigQuery se limita a analizar solo los bloques que sean relevantes. Ese proceso se denomina recorte de bloques.

Puede consultar tablas agrupadas en clústeres por los siguientes elementos:

Usar la Google Cloud consola
Usar el comando bq query de la herramienta de línea de comandos bq
Llamar al método jobs.insert y configurar una tarea de consulta
Usar las bibliotecas de cliente

Solo puedes usar GoogleSQL con tablas agrupadas en clústeres.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones 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 Go 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 (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryClusteredTable demonstrates querying a table that has a clustering specification.
func queryClusteredTable(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(fmt.Sprintf(`
	SELECT
	  COUNT(1) as transactions,
	  SUM(amount) as total_paid,
	  COUNT(DISTINCT destination) as distinct_recipients
    FROM
	  `+"`%s.%s`"+`
	 WHERE
	    timestamp > TIMESTAMP('2015-01-01')
		AND origin = @wallet`, datasetID, tableID))
	q.Parameters = []bigquery.QueryParameter{
		{
			Name:  "wallet",
			Value: "wallet00001866cb7e0f09a890",
		},
	}
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

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.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;

public class QueryClusteredTable {

  public static void runQueryClusteredTable() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    queryClusteredTable(projectId, datasetName, tableName);
  }

  public static void queryClusteredTable(String projectId, String datasetName, String tableName) {
    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();

      String sourceTable = "`" + projectId + "." + datasetName + "." + tableName + "`";
      String query =
          "SELECT word, word_count\n"
              + "FROM "
              + sourceTable
              + "\n"
              // Optimize query performance by filtering the clustered columns in sort order
              + "WHERE corpus = 'romeoandjuliet'\n"
              + "AND word_count >= 1";

      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

      TableResult results = bigquery.query(queryConfig);

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

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

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones 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 Python de BigQuery.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

sql = "SELECT * FROM `bigquery-public-data.samples.shakespeare`"
cluster_fields = ["corpus"]

job_config = bigquery.QueryJobConfig(
    clustering_fields=cluster_fields, destination=table_id
)

# Start the query, passing in the extra configuration.
client.query_and_wait(
    sql, job_config=job_config
)  # Make an API request and wait for job to complete.

table = client.get_table(table_id)  # Make an API request.
if table.clustering_fields == cluster_fields:
    print(
        "The destination table is written using the cluster_fields configuration."
    )

Permisos obligatorios

Para ejecutar un trabajo de consulta, necesitas el permiso de gestión de identidades y accesos (IAM) bigquery.jobs.createen el proyecto que ejecuta el trabajo de consulta.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para ejecutar un trabajo de consulta:

roles/bigquery.admin
roles/bigquery.jobUser
roles/bigquery.user

También necesitas el permiso bigquery.tables.getData en todas las tablas y vistas a las que haga referencia tu consulta. Además, al consultar una vista, necesitas este permiso en todas las tablas y vistas subyacentes. Sin embargo, si usas vistas autorizadas o conjuntos de datos autorizados, no necesitas acceso a los datos de origen subyacentes.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye el permiso que necesitas en todas las tablas y vistas a las que hace referencia la consulta:

roles/bigquery.admin
roles/bigquery.dataOwner
roles/bigquery.dataEditor
roles/bigquery.dataViewer

Para obtener más información sobre los roles de gestión de identidades y accesos en BigQuery, consulta el artículo sobre roles y permisos predefinidos.

Prácticas recomendadas

Para obtener el mejor rendimiento de las consultas en tablas agrupadas en clústeres, siga estas prácticas recomendadas.

Para contextualizar, la tabla de ejemplo que se usa en los ejemplos de prácticas recomendadas es una tabla agrupada que se crea mediante una instrucción DDL. La declaración de DDL crea una tabla llamada ClusteredSalesData. La tabla está agrupada en clústeres por las siguientes columnas: customer_id, product_id y order_id, en ese orden.

CREATE TABLE
  `mydataset.ClusteredSalesData`
PARTITION BY
  DATE(timestamp)
CLUSTER BY
  customer_id,
  product_id,
  order_id AS
SELECT
  *
FROM
  `mydataset.SalesData`

Filtrar columnas agrupadas por orden

Cuando especifique un filtro, utilice expresiones que filtren las columnas agrupadas en clústeres por orden. El orden de clasificación es el orden de las columnas que se indica en la cláusula CLUSTER BY. Para disfrutar de las ventajas de la creación de clústeres, incluye una o varias de las columnas agrupadas en orden de clasificación de izquierda a derecha, empezando por la primera columna. En la mayoría de los casos, la primera columna de agrupación es la más eficaz para la poda de bloques, seguida de la segunda y la tercera. Puedes seguir usando la segunda o la tercera columna por separado en la consulta, pero es probable que la eliminación de bloques no sea tan eficaz. El orden de los nombres de las columnas dentro de la expresión de filtro no afecta al rendimiento.

En el siguiente ejemplo se consulta la tabla agrupada ClusteredSalesData que se ha creado en el ejemplo anterior. La consulta incluye una expresión de filtro que filtra por customer_id y, a continuación, por product_id. Esta consulta optimiza el rendimiento filtrando las columnas agrupadas en orden de clasificación, es decir, el orden de las columnas indicado en la cláusula CLUSTER BY.

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  customer_id = 10000
  AND product_id LIKE 'gcp_analytics%'

La siguiente consulta no filtra las columnas agrupadas por orden de clasificación. Por lo tanto, el rendimiento de la consulta no es óptimo. Esta consulta filtra por product_id y, a continuación, por order_id (se salta customer_id).

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  product_id LIKE 'gcp_analytics%'
  AND order_id = 20000

No uses columnas agrupadas en expresiones de filtro complejas

Si usas una columna agrupada en clústeres en una expresión de filtro compleja, el rendimiento de la consulta no se optimiza porque no se puede aplicar el recorte de bloques.

Por ejemplo, la siguiente consulta no recortará bloques porque se usa una columna agrupada en clústeres (customer_id) en una función de la expresión del filtro.

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  CAST(customer_id AS STRING) = "10000"

Para optimizar el rendimiento de las consultas mediante la eliminación de bloques, use expresiones de filtro sencillas como las siguientes. En este ejemplo, se aplica un filtro sencillo a la columna agrupada customer_id.

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  customer_id = 10000

No compares columnas de clúster con otras columnas

Si una expresión de filtro compara una columna agrupada con otra columna (ya sea agrupada o no), el rendimiento de la consulta no se optimiza porque no se puede aplicar la eliminación de bloques.

La siguiente consulta no recorta bloques porque la expresión de filtro compara una columna agrupada en clústeres (customer_id) con otra columna (order_id).

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  customer_id = order_id

Seguridad de las tablas

Para controlar el acceso a las tablas de BigQuery, consulta el artículo sobre cómo controlar el acceso a los recursos con la gestión de identidades y accesos.

Siguientes pasos

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar consultas interactivas y por lotes.
Para saber cómo crear y usar tablas agrupadas en clústeres, consulta el artículo Crear y usar tablas agrupadas en clústeres.
Para obtener una descripción general de la compatibilidad con tablas particionadas en BigQuery, consulta Introducción a las tablas particionadas.
Para saber cómo crear tablas con particiones, consulta Crear tablas con particiones.