Materialisierte Ansichten verwalten

In diesem Dokument wird beschrieben, wie Sie materialisierte Ansichten in BigQuery verwalten können.

Die BigQuery-Verwaltung von materialisierten Ansichten umfasst die folgenden Vorgänge:

• Materialisierte Ansichten ändern
• Materialisierte Ansichten auflisten
• Informationen zu materialisierten Ansichten abrufen
• Materialisierte Ansichten löschen
• Materialisierte Ansichten aktualisieren

Weitere Informationen zu materialisierten Ansichten finden Sie hier:

• Einführung in materialisierte Ansichten
• Materialisierte Ansichten erstellen
• Materialisierte Ansichten verwenden
• Materialisierte Ansichten überwachen

Hinweis

Weisen Sie IAM-Rollen (Identity and Access Management) zu, die Nutzern die erforderlichen Berechtigungen zum Ausführen der einzelnen Aufgaben in diesem Dokument gewähren. Die Berechtigungen, die zum Ausführen einer Aufgabe erforderlich sind (sofern zutreffend), werden im Abschnitt „Erforderliche Berechtigungen“ der Aufgabe aufgelistet.

Materialisierte Ansichten ändern

Sie können eine materialisierte Ansicht über die Google Cloud Console oder das bq-Befehlszeilentool ändern. Verwenden Sie dafür die Datendefinitionssprache (DDL, Data Definition Language) mit ALTER MATERIALIZED VIEW und SET OPTIONS. Eine Liste der Optionen für die materialisierte Ansicht finden Sie unter materialized_view_set_options_list.

Im folgenden Beispiel wird enable_refresh auf true gesetzt. Passen Sie dies nach Bedarf an Ihren Fall an.

Erforderliche Berechtigungen

Zum Ändern von materialisierten Ansichten benötigen Sie die IAM-Berechtigungen bigquery.tables.get und bigquery.tables.update.

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie zum Ändern einer materialisierten Ansicht benötigen:

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

Weitere Informationen zu BigQuery Identity and Access Management (IAM) finden Sie unter Vordefinierte Rollen und Berechtigungen.

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

Materialisierte Ansichten auflisten

Sie können materialisierte Ansichten über die Google Cloud Console, das bq-Befehlszeilentool oder die BigQuery API auflisten.

Erforderliche Berechtigungen

Zum Auflisten von materialisierten Ansichten in einem Dataset benötigen Sie die IAM-Berechtigung bigquery.tables.list.

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie zum Auflisten von materialisierten Ansichten in einem Dataset benötigen:

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

Weitere Informationen zu IAM-Rollen und Berechtigungen in IAM finden Sie unter Vordefinierte Rollen und Berechtigungen.

Der Vorgang zum Auflisten von materialisierten Ansichten ist mit dem Vorgang zum Auflisten von Tabellen identisch. So listen Sie die Ansichten in einem Dataset auf:

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

Informationen zu materialisierten Ansichten abrufen

Sie können Informationen zu einer materialisierten Ansicht mit SQL, dem bq-Befehlszeilentool oder der BigQuery API abrufen.

Erforderliche Berechtigungen

Zum Abfragen von Informationen zu einer materialisierten Ansicht benötigen Sie die folgenden IAM-Berechtigungen (Identity and Access Management):

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

Die folgenden vordefinierten IAM-Rollen enthalten jeweils die vorherigen Berechtigungen:

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

Weitere Informationen zu BigQuery-Berechtigungen finden Sie unter Zugriffssteuerung mit IAM.

So rufen Sie Informationen zu einer materialisierten Ansicht ab, einschließlich aller abhängigen Replikate von materialisierten Ansichten:

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

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

Materialisierte Ansichten löschen

Sie können eine materialisierte Ansicht über die Google Cloud Console, das bq-Befehlszeilentool oder die API löschen.

Beim Löschen einer materialisierten Ansicht werden auch alle mit dieser materialisierten Ansicht verknüpften Berechtigungen gelöscht. Wenn Sie eine gelöschte materialisierte Ansicht neu erstellen, müssen Sie auch zuvor alle Zugriffsberechtigungen neu konfigurieren.

Erforderliche Berechtigungen

Zum Erstellen von materialisierten Ansichten benötigen Sie die IAM-Berechtigung bigquery.tables.delete.

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie für das Löschen einer Tabelle benötigen:

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

Weitere Informationen zu BigQuery Identity and Access Management (IAM) finden Sie unter Vordefinierte Rollen und Berechtigungen.

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

Materialisierte Ansichten aktualisieren

Durch Aktualisieren einer materialisierten Ansicht werden die im Cache gespeicherten Ergebnisse der Ansicht aktualisiert, um den aktuellen Status ihrer Basistabellen widerzuspiegeln. Nach Möglichkeit liest BigQuery nur die Änderungen seit der letzten Aktualisierung der Ansicht. Obwohl kürzlich gestreamte Daten während der Aktualisierung der materialisierten Ansicht möglicherweise nicht enthalten sind, lesen Abfragen immer gestreamte Daten, unabhängig davon, ob eine materialisierte Ansicht verwendet wird. In diesem Abschnitt wird Folgendes beschrieben:

• Automatische Aktualisierung konfigurieren
• Materialisierte Ansicht manuell aktualisieren

Automatische Aktualisierung

Standardmäßig werden materialisierte Ansichten automatisch innerhalb von fünf Minuten nach einer Änderung an den Basistabellen aktualisiert, jedoch nicht häufiger als alle 30 Minuten. Beispiele für Änderungen sind das Einfügen oder Löschen von Zeilen.

Mit der Aktualisierungshäufigkeit können Sie die Kosten und die Abfrageleistung von materialisierten Ansichten verwalten. Unabhängig von der Aktualisierungsbegrenzung geben materialisierte Ansichten immer aktuelle Daten zurück.

Die automatische Aktualisierung kann jederzeit aktiviert oder deaktiviert werden. Der automatische Aktualisierungsjob wird vom Dienstkonto [email protected] ausgeführt und im Jobverlauf des Projekts mit der materialisierten Ansicht angezeigt.

Automatische Aktualisierung aktivieren und deaktivieren

Wenn Sie die automatische Aktualisierung beim Erstellen einer Tabelle deaktivieren möchten, setzen Sie enable_refresh auf false.

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

Bei einer vorhandenen materialisierten Ansicht können Sie den Wert enable_refresh mit ALTER MATERIALIZED VIEW ändern.

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

Frequency Capping festlegen

Sie können festlegen, wie häufig die automatische Aktualisierung durchgeführt wird. Standardmäßig werden materialisierte Ansichten nicht häufiger als alle 30 Minuten aktualisiert.

Die Aktualisierungshäufigkeit kann jederzeit geändert werden.

Wenn Sie beim Erstellen einer materialisierten Ansicht eine Häufigkeitsbegrenzung festlegen möchten, setzen Sie refresh_interval_minutes in DDL (oder refresh_interval_ms in der API und im bq-Befehlszeilentool) auf den von Ihnen erstellten Wert.

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

Ebenso können Sie die Häufigkeitsbegrenzung beim Ändern einer Tabelle festlegen. In diesem Beispiel wird davon ausgegangen, dass Sie die automatische Aktualisierung bereits aktiviert haben und nur die Häufigkeitsbegrenzung ändern möchten:

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

Die Mindesthäufigkeit der Aktualisierungen beträgt 1 Minute. Die maximale Häufigkeit für Aktualisierungen beträgt sieben Tage.

Sie können eine materialisierte Ansicht jederzeit manuell aktualisieren. Dies unterliegt nicht der Häufigkeitsbegrenzung.

Best-Effort-Ansatz

Die automatische Aktualisierung erfolgt auf Best-Effort-Basis. BigQuery versucht, innerhalb von fünf Minuten nach einer Änderung an der Basistabelle eine Aktualisierung zu starten (vorausgesetzt, die vorherige Aktualisierung wurde vor über 30 Minuten durchgeführt). Es wird jedoch nicht garantiert, dass die Aktualisierung zu diesem Zeitpunkt gestartet wird oder dass der Vorgang abgeschlossen wird.

Die automatische Aktualisierung wird ähnlich behandelt wie eine Abfrage mit der Batch-Priorität. Wenn das Projekt der materialisierten Ansicht derzeit nicht über die Kapazität verfügt, erfolgt die Aktualisierung verzögert. Wenn das Projekt viele Ansichten enthält, deren Aktualisierung teuer ist, kann jede einzelne Ansicht im Verhältnis zu den Basistabellen erheblich verzögert sein.

Manuelle Aktualisierung

Sie können eine materialisierte Ansicht jederzeit manuell aktualisieren.

Erforderliche Berechtigungen

Zum manuellen Aktualisieren materialisierter Ansichten benötigen Sie die IAM-Berechtigungen bigquery.tables.getData, bigquery.tables.update und bigquery.tables.updateData.

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie zum manuellen Aktualisieren einer materialisierten Ansicht benötigen:

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

Weitere Informationen zu BigQuery Identity and Access Management (IAM) finden Sie unter Vordefinierte Rollen und Berechtigungen.

Rufen Sie das Systemverfahren BQ.REFRESH_MATERIALIZED_VIEW auf, um die Daten in der materialisierten Ansicht zu aktualisieren. Beim Aufruf dieses Systemvorgangs identifiziert BigQuery die Änderungen, die in den Basistabellen stattgefunden haben, und wendet diese Änderungen auf die materialisierte Ansicht an. Die Abfrage zum Ausführen von BQ.REFRESH_MATERIALIZED_VIEW ist beendet, wenn die Aktualisierung abgeschlossen ist.

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

Materialisierte Ansichten überwachen

Mit der BigQuery API können Sie Informationen zu materialisierten Ansichten und Aktualisierungsjobs zu materialisierten Ansichten abrufen. Weitere Informationen finden Sie unter Materialisierte Ansichten überwachen.