Gestionar vistas materializadas

En este documento se describe cómo gestionar las vistas materializadas en BigQuery.

La gestión de vistas materializadas de BigQuery incluye las siguientes operaciones:

• Modificar vistas materializadas
• Listar vistas materializadas
• Obtener información sobre las vistas materializadas
• Eliminar vistas materializadas
• Actualizar vistas materializadas

Para obtener más información sobre las vistas materializadas, consulta lo siguiente:

• Introducción a las vistas materializadas
• Crear vistas materializadas
• Usar vistas materializadas
• Monitorizar vistas materializadas

Antes de empezar

Concede roles de gestión de identidades y accesos (IAM) que proporcionen a los usuarios los permisos necesarios para realizar cada tarea de este documento. Los permisos necesarios para realizar una tarea (si los hay) se indican en la sección "Permisos necesarios" de la tarea.

Modificar vistas materializadas

Puedes modificar una vista materializada mediante la consola de Google Cloud o la herramienta de línea de comandos bq. Para ello, usa el lenguaje de definición de datos (DDL) con ALTER MATERIALIZED VIEW y SET OPTIONS. Para ver una lista de opciones de vistas materializadas, consulta materialized_view_set_options_list.

A continuación, se muestra un ejemplo en el que se asigna true a enable_refresh. Ajusta los valores según sea necesario para tu caso práctico.

Permisos obligatorios

Para modificar vistas materializadas, necesitas los permisos de gestión de identidades y accesos bigquery.tables.get y bigquery.tables.update.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para modificar una vista materializada:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

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

bq update \
--enable_refresh=true \
--refresh_interval_ms= \
PROJECT.DATASET.MATERIALIZED_VIEW

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.MaterializedViewDefinition;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

// Sample to update materialized view
public class UpdateMaterializedView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String materializedViewName = "MY_MATERIALIZED_VIEW_NAME";
    updateMaterializedView(datasetName, materializedViewName);
  }

  public static void updateMaterializedView(String datasetName, String materializedViewName) {
    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();

      TableId tableId = TableId.of(datasetName, materializedViewName);

      // Get existing materialized view
      Table table = bigquery.getTable(tableId);
      MaterializedViewDefinition materializedViewDefinition = table.getDefinition();
      // Update materialized view
      materializedViewDefinition
          .toBuilder()
          .setEnableRefresh(true)
          .setRefreshIntervalMs(1000L)
          .build();
      table.toBuilder().setDefinition(materializedViewDefinition).build().update();
      System.out.println("Materialized view updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Materialized view was not updated. \n" + e.toString());
    }
  }
}

Mostrar vistas materializadas

Puedes consultar las vistas materializadas mediante la consola de Google Cloud , la herramienta de línea de comandos bq o la API de BigQuery.

Permisos obligatorios

Para enumerar las vistas materializadas de un conjunto de datos, necesitas el permiso bigquery.tables.list de gestión de identidades y accesos.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para enumerar las vistas materializadas de un conjunto de datos:

• roles/bigquery.user
• roles/bigquery.metadataViewer
• roles/bigquery.dataViewer
• roles/bigquery.dataOwner
• roles/bigquery.dataEditor
• roles/bigquery.admin

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

El proceso para enumerar vistas materializadas es idéntico al de las tablas. Para enumerar las vistas materializadas de un conjunto de datos, sigue estos pasos:

bq ls --format=pretty project_id:dataset

+-------------------------+--------------------+----------------------+-------------------+
|         tableId         | Type               |        Labels        | Time Partitioning |
+-------------------------+--------------------+----------------------+-------------------+
| mytable                 | TABLE              | department:shipping  |                   |
| mymatview               | MATERIALIZED_VIEW  |                      |                   |
+-------------------------+--------------------+----------------------+-------------------+

bq ls --format=pretty mydataset

bq ls --format=pretty myotherproject:mydataset

import (
	"context"
	"fmt"
	"io"

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

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID 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()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Obtener información sobre las vistas materializadas

Puede obtener información sobre una vista materializada mediante SQL, la herramienta de línea de comandos bq o la API de BigQuery.

Permisos obligatorios

Para consultar información sobre una vista materializada, necesitas los siguientes permisos de gestión de identidades y accesos (IAM):

• bigquery.tables.get
• bigquery.tables.list
• bigquery.routines.get
• bigquery.routines.list

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos anteriores:

• roles/bigquery.metadataViewer
• roles/bigquery.dataViewer
• roles/bigquery.admin

Para obtener más información sobre los permisos de BigQuery, consulta Control de acceso con gestión de identidades y accesos.

Para obtener información sobre una vista materializada, incluidas las réplicas de vistas materializadas dependientes, sigue estos pasos:

bq show --project=project_id --format=prettyjson dataset.materialized_view

bq show --project=myproject --format=prettyjson report_views.my_mv

Eliminar vistas materializadas

Puedes eliminar una vista materializada a través de la Google Cloud consola, la herramienta de línea de comandos bq o la API.

Si eliminas una vista materializada, también se eliminarán los permisos asociados a ella. Cuando vuelvas a crear una vista materializada eliminada, también debes volver a configurar manualmente los permisos de acceso que tenía asociados.

Permisos obligatorios

Para eliminar vistas materializadas, necesita el bigquery.tables.deletepermiso de gestión de identidades y accesos.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para eliminar una vista materializada:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

// Sample to delete materialized view
public class DeleteMaterializedView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String materializedViewName = "MY_MATERIALIZED_VIEW_NAME";
    deleteMaterializedView(datasetName, materializedViewName);
  }

  public static void deleteMaterializedView(String datasetName, String materializedViewName) {
    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();

      TableId tableId = TableId.of(datasetName, materializedViewName);

      boolean success = bigquery.delete(tableId);
      if (success) {
        System.out.println("Materialized view deleted successfully");
      } else {
        System.out.println("Materialized view was not found");
      }
    } catch (BigQueryException e) {
      System.out.println("Materialized view was not found. \n" + e.toString());
    }
  }
}

Actualizar vistas materializadas

Al actualizar una vista materializada, se actualizan los datos almacenados en caché de la vista para reflejar el estado actual de sus tablas base.

Cuando consultas una vista materializada, BigQuery devuelve resultados de los datos de la vista materializada almacenados en caché y de los datos obtenidos de la tabla base. Cuando es posible, BigQuery solo lee los cambios que se han producido desde la última vez que se actualizó la vista. Aunque es posible que los datos transmitidos recientemente no se incluyan durante una actualización de la vista materializada, las consultas siempre leen los datos transmitidos, independientemente de si se usa una vista materializada.

Devolver los resultados de las consultas directamente desde la tabla base conlleva un coste de computación más alto que devolver los resultados de los datos de la vista materializada almacenados en caché. Si actualizas periódicamente los datos almacenados en caché de las vistas materializadas, se reduce la cantidad de datos que se devuelven directamente de la tabla base, lo que disminuye el coste de computación.

En esta sección se describe cómo hacer lo siguiente:

• Configurar la actualización automática
• Actualizar manualmente una vista materializada

Actualización automática

Puedes habilitar o inhabilitar la actualización automática en cualquier momento. El servicio bigquery-adminbot@system.gserviceaccount.com realiza el trabajo de actualización automática y aparece en el historial de trabajos del proyecto de la vista materializada.

De forma predeterminada, los datos almacenados en caché de una vista materializada se actualizan automáticamente desde la tabla base en un plazo de entre 5 y 30 minutos después de que se produzca un cambio en la tabla base (por ejemplo, la inserción o la eliminación de filas).

Puede definir el límite de frecuencia de actualización para gestionar la frecuencia de las actualizaciones automáticas de los datos almacenados en caché y, de este modo, gestionar los costes y el rendimiento de las consultas de las vistas materializadas.

Habilitar e inhabilitar la actualización automática

Para desactivar la actualización automática al crear una vista materializada, defina enable_refresh en false.

CREATE MATERIALIZED VIEW PROJECT.DATASET.MATERIALIZED_VIEW
PARTITION BY RANGE_BUCKET(column_name, buckets)
OPTIONS (enable_refresh = false)
AS SELECT ...

En el caso de una vista materializada, puede modificar el valor de enable_refresh con ALTER MATERIALIZED VIEW.

ALTER MATERIALIZED VIEW PROJECT.DATASET.MATERIALIZED_VIEW
SET OPTIONS (enable_refresh = true);

Definir el límite de frecuencia

Puede configurar la frecuencia con la que se ejecuta la actualización automática. De forma predeterminada, las vistas materializadas se actualizan como máximo cada 30 minutos.

El límite de frecuencia de actualización se puede cambiar en cualquier momento.

Para definir un límite de frecuencia de actualización al crear una vista materializada, asigne a refresh_interval_minutes en DDL (o refresh_interval_ms en la API y la herramienta de línea de comandos bq) el valor que quiera.

CREATE MATERIALIZED VIEW PROJECT.DATASET.MATERIALIZED_VIEW
OPTIONS (enable_refresh = true, refresh_interval_minutes = 60)
AS SELECT ...

Del mismo modo, puede definir el límite de frecuencia al modificar una vista materializada. En este ejemplo, se presupone que ya has habilitado la actualización automática y solo quieres cambiar el límite de frecuencia:

ALTER MATERIALIZED VIEW PROJECT.DATASET.MATERIALIZED_VIEW
SET OPTIONS (refresh_interval_minutes = 60);

El límite de frecuencia de actualización mínimo es de 1 minuto. La frecuencia máxima de actualización es de 7 días.

Puedes actualizar manualmente una vista materializada en cualquier momento, y su tiempo no está sujeto al límite de frecuencia.

Mejor resultado posible

La actualización automática se realiza en la medida de lo posible. BigQuery intenta iniciar una actualización en un plazo de 5 minutos después de que se produzca un cambio en la tabla base (si la actualización anterior se realizó hace más de 30 minutos), pero no garantiza que la actualización se inicie en ese momento ni cuándo se completará.

La actualización automática se trata de forma similar a una consulta con prioridad por lotes. Si el proyecto de la vista materializada no tiene capacidad en ese momento, la actualización se retrasa. Si el proyecto contiene muchas vistas cuya actualización resulta costosa, cada vista puede retrasarse significativamente en relación con sus tablas base.

Actualización manual

Puedes actualizar manualmente una vista materializada en cualquier momento.

Permisos obligatorios

Para actualizar manualmente las vistas materializadas, necesitas los permisos de gestión de identidades y accesos bigquery.tables.getData, bigquery.tables.update y bigquery.tables.updateData.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para actualizar manualmente una vista materializada:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

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

Para actualizar los datos de la vista materializada, llama al procedimiento del sistema BQ.REFRESH_MATERIALIZED_VIEW. Cuando se llama a este procedimiento, BigQuery identifica los cambios que se han producido en las tablas base y los aplica a la vista materializada. La consulta que se va a ejecutar BQ.REFRESH_MATERIALIZED_VIEW finaliza cuando se completa la actualización.

CALL BQ.REFRESH_MATERIALIZED_VIEW('PROJECT.DATASET.MATERIALIZED_VIEW');

Monitorizar vistas materializadas

Puedes obtener información sobre las vistas materializadas y las tareas de actualización de vistas materializadas mediante la API de BigQuery. Para obtener más información, consulta el artículo Monitorizar vistas materializadas.