Gestire le viste materializzate

Questo documento descrive come gestire le viste materializzate in BigQuery.

La gestione delle viste materializzate di BigQuery include le seguenti operazioni:

• Modificare le viste materializzate
• Elenca le viste materializzate
• Ottenere informazioni sulle viste materializzate
• Eliminare le viste materializzate
• Aggiornare le viste materializzate

Per ulteriori informazioni sulle viste materializzate, consulta le seguenti risorse:

• Introduzione alle viste materializzate
• Creare viste materializzate
• Utilizzare le viste materializzate
• Monitorare le viste materializzate

Prima di iniziare

Concedi ruoli IAM (Identity and Access Management) che forniscono agli utenti le autorizzazioni necessarie per eseguire ogni attività descritta in questo documento. Le autorizzazioni richieste per eseguire un'attività (se presenti) sono elencate nella sezione "Autorizzazioni richieste" dell'attività.

Modifica le viste materializzate

Puoi modificare una vista materializzata tramite la console Google Cloud o lo strumento a riga di comando bq utilizzando il linguaggio di definizione dei dati (DDL) con ALTER MATERIALIZED VIEW e SET OPTIONS. Per un elenco di opzioni della vista materializzata, consulta materialized_view_set_options_list.

Di seguito è riportato un esempio che imposta enable_refresh su true. Modifica in base alle esigenze del tuo caso d'uso.

Autorizzazioni obbligatorie

Per modificare le viste materializzate, devi disporre delle autorizzazioni IAM bigquery.tables.get e bigquery.tables.update.

Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per modificare una vista materializzata:

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

Per saperne di più su BigQuery Identity and Access Management (IAM), vedi Ruoli e autorizzazioni predefiniti.

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());
    }
  }
}

Elenca le viste materializzate

Puoi elencare le viste materializzate tramite la console Google Cloud , lo strumento a riga di comando bq o l'API BigQuery.

Autorizzazioni obbligatorie

Per elencare le viste materializzate in un set di dati, devi disporre dell'autorizzazione IAM bigquery.tables.list.

Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per elencare le viste materializzate in un set di dati:

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

Per saperne di più sui ruoli e sulle autorizzazioni IAM in IAM, consulta Ruoli e autorizzazioni predefiniti.

La procedura per elencare le viste materializzate è identica a quella per elencare le tabelle. Per elencare le viste materializzate in un set di dati:

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))

Ottenere informazioni sulle viste materializzate

Puoi ottenere informazioni su una vista materializzata utilizzando SQL, lo strumento a riga di comando bq o l'API BigQuery.

Autorizzazioni obbligatorie

Per eseguire query sulle informazioni relative a una vista materializzata, devi disporre delle seguenti autorizzazioni Identity and Access Management (IAM):

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

Ognuno dei seguenti ruoli IAM predefiniti include le autorizzazioni precedenti:

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

Per ulteriori informazioni sulle autorizzazioni BigQuery, consulta Controllo dell'accesso con IAM.

Per ottenere informazioni su una vista materializzata, incluse eventuali repliche della vista materializzata:

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

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

Elimina viste materializzate

Puoi eliminare una vista materializzata tramite la console Google Cloud , lo strumento a riga di comando bq o l'API.

L'eliminazione di una vista materializzata comporta anche l'eliminazione di tutte le autorizzazioni associate a questa vista materializzata. Quando ricrei una vista materializzata eliminata, devi anche riconfigurare manualmente le autorizzazioni di accesso associate in precedenza.

Autorizzazioni obbligatorie

Per eliminare le viste materializzate, devi disporre dell'autorizzazione IAM bigquery.tables.delete.

Ognuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per eliminare una vista materializzata:

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

Per saperne di più su BigQuery Identity and Access Management (IAM), vedi Ruoli e autorizzazioni predefiniti.

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());
    }
  }
}

Aggiorna le viste materializzate

L'aggiornamento di una vista materializzata aggiorna i dati memorizzati nella cache della vista in modo che riflettano lo stato attuale delle tabelle di base.

Quando esegui una query su una vista materializzata, BigQuery restituisce i risultati sia dai dati della vista materializzata memorizzati nella cache sia dai dati recuperati dalla tabella di base. Ove possibile, BigQuery legge solo le modifiche apportate dall'ultimo aggiornamento della vista. Anche se i dati trasmessi in streaming di recente potrebbero non essere inclusi durante l'aggiornamento della vista materializzata, le query leggono sempre i dati trasmessi in streaming indipendentemente dall'utilizzo di una vista materializzata.

La restituzione dei risultati della query direttamente dalla tabella di base comporta un costo di calcolo superiore rispetto alla restituzione dei risultati dai dati della vista materializzata memorizzati nella cache. L'aggiornamento regolare dei dati memorizzati nella cache della vista materializzata riduce la quantità di dati restituiti direttamente dalla tabella di base, il che riduce il costo di calcolo.

Questa sezione descrive come:

• Configurare l'aggiornamento automatico
• Aggiornare manualmente una vista materializzata

Aggiornamento automatico

Puoi attivare o disattivare l'aggiornamento automatico in qualsiasi momento. Il job di aggiornamento automatico viene eseguito dall'account di servizio bigquery-adminbot@system.gserviceaccount.com e viene visualizzato nella cronologia dei job del progetto di vista materializzata.

Per impostazione predefinita, i dati memorizzati nella cache di una vista materializzata vengono aggiornati automaticamente dalla tabella di base entro 5-30 minuti da una modifica alla tabella di base, ad esempio inserimenti o eliminazioni di righe.

Puoi impostare il limite di frequenza di aggiornamento per gestire la frequenza degli aggiornamenti automatici dei dati memorizzati nella cache e quindi gestire i costi e le prestazioni delle query delle viste materializzate.

Attivare e disattivare l'aggiornamento automatico

Per disattivare l'aggiornamento automatico quando crei una vista materializzata, imposta enable_refresh su false.

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

Per una vista materializzata esistente, puoi modificare il valore enable_refresh utilizzando ALTER MATERIALIZED VIEW.

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

Impostare la quota limite

Puoi configurare una quota limite per la frequenza di esecuzione dell'aggiornamento automatico. Per impostazione predefinita, le viste materializzate vengono aggiornate non più spesso di ogni 30 minuti.

Il limite della frequenza di aggiornamento può essere modificato in qualsiasi momento.

Per impostare un limite alla frequenza di aggiornamento quando crei una vista materializzata, imposta refresh_interval_minutes in DDL (o refresh_interval_ms nell'API e nello strumento a riga di comando bq) sul valore che preferisci.

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

Allo stesso modo, puoi impostare la quota limite quando modifichi una vista materializzata. Questo esempio presuppone che tu abbia già attivato l'aggiornamento automatico e che tu voglia solo modificare la quota limite:

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

La quota limite minima per la frequenza di aggiornamento è di 1 minuto. La quota limite di aggiornamento massima è di 7 giorni.

Puoi eseguire un aggiornamento manuale di una vista materializzata in qualsiasi momento e la sua tempistica non è soggetta al limite di frequenza.

Best effort

L'aggiornamento automatico viene eseguito al meglio delle possibilità. BigQuery tenta di avviare un aggiornamento entro 5 minuti da una modifica alla tabella di base (se l'aggiornamento precedente è stato eseguito più di 30 minuti prima), ma non garantisce che l'aggiornamento verrà avviato in quel momento né quando verrà completato.

L'aggiornamento automatico viene trattato in modo simile a una query con priorità batch. Se il progetto della vista materializzata non ha la capacità al momento, l'aggiornamento viene ritardato. Se il progetto contiene molte viste il cui aggiornamento risulta costoso, ogni singola vista potrebbe essere in ritardo in modo significativo rispetto alle tabelle di base.

Aggiornamento manuale

Puoi aggiornare manualmente una vista materializzata in qualsiasi momento.

Autorizzazioni obbligatorie

Per aggiornare manualmente le viste materializzate, devi disporre delle autorizzazioni IAM bigquery.tables.getData, bigquery.tables.update e bigquery.tables.updateData.

Ognuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per aggiornare manualmente una vista materializzata:

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

Per saperne di più su BigQuery Identity and Access Management (IAM), vedi Ruoli e autorizzazioni predefiniti.

Per aggiornare i dati nella vista materializzata, chiama la procedura di sistema BQ.REFRESH_MATERIALIZED_VIEW. Quando viene chiamata questa procedura, BigQuery identifica le modifiche apportate alle tabelle di base e le applica alla vista materializzata. La query da eseguire BQ.REFRESH_MATERIALIZED_VIEW termina al termine dell'aggiornamento.

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

Monitorare le viste materializzate

Puoi ottenere informazioni sulle viste materializzate e sui job di aggiornamento delle viste materializzate utilizzando l'API BigQuery. Per ulteriori informazioni, vedi Monitorare le viste materializzate.