Dataset-Attribute aktualisieren

In diesem Dokument wird beschrieben, wie Sie Dataset-Attribute in BigQuery aktualisieren. Nachdem Sie ein Dataset erstellt haben, können Sie folgende Dataset-Attribute aktualisieren:

Zugriffssteuerung
Abrechnungsmodell
Standardablaufzeit für neue Tabellen
Standardablaufzeit für Partitionen für neu partitionierte Tabellen
Beschreibung
Labels
Zeitreisefenster

Hinweis

Erteilen Sie IAM-Rollen (Identity and Access Management), die Nutzern die erforderlichen Berechtigungen zum Ausführen der einzelnen Aufgaben in diesem Dokument geben.

Erforderliche Berechtigungen

Zum Aktualisieren von Dataset-Attributen benötigen Sie die folgenden IAM-Berechtigungen:

bigquery.datasets.update
bigquery.datasets.get
bigquery.datasets.setIamPolicy (nur erforderlich, wenn Dataset-Zugriffssteuerungen aktualisiert werden)

Die vordefinierte IAM-Rolle roles/bigquery.dataOwner enthält die Berechtigungen, die Sie zum Aktualisieren von Dataset-Attributen benötigen.

Wenn Sie die Berechtigung bigquery.datasets.create haben, können Sie außerdem Attribute der von Ihnen erstellten Datasets aktualisieren.

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

Dataset-Beschreibungen aktualisieren

Sie können die Beschreibung einer Tabelle auf folgenden Wegen aktualisieren:

Google Cloud Console verwenden
Mit dem Befehl bq update des bq-Befehlszeilentools
Durch Aufruf der API-Methode datasets.patch
Mithilfe der Clientbibliotheken

So aktualisieren Sie die Beschreibung eines Datasets:

Console

Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.
Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.
Klicken Sie im Feld Details auf Details bearbeiten, um den Beschreibungstext zu bearbeiten.

Führen Sie im angezeigten Dialogfeld Details bearbeiten die folgenden Schritte aus:
1. Geben Sie eine Beschreibung in das Feld Beschreibung ein oder bearbeiten Sie die vorhandene Beschreibung.
2. Klicken Sie zum Speichern des neuen Beschreibungstexts auf Speichern.

SQL

Zum Aktualisieren der Beschreibung eines Datasets verwenden Sie die Anweisung ALTER SCHEMA SET OPTIONS zum Festlegen der Option description.

Im folgenden Beispiel wird die Beschreibung für ein Dataset mit dem Namen mydataset festgelegt:

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

 ALTER SCHEMA mydataset
 SET OPTIONS (
     description = 'Description of mydataset');

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfragen ausführen.

bq

Führen Sie den Befehl bq update mit dem Flag --description aus. Wenn Sie ein Dataset in einem anderen Projekt als Ihrem Standardprojekt aktualisieren, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

bq update \
--description "string" \
project_id:dataset

Ersetzen Sie Folgendes:

string: der Text zur Beschreibung des Datasets in Anführungszeichen.
project_id: Ihre Projekt-ID
dataset: der Name des Datasets, das Sie aktualisieren.

Beispiele:

Geben Sie den folgenden Befehl ein, um die Beschreibung von mydataset in "Description of mydataset" (Beschreibung von mydataset) zu ändern. mydataset befindet sich in Ihrem Standardprojekt.

bq update --description "Description of mydataset" mydataset

Geben Sie den folgenden Befehl ein, um die Beschreibung von mydataset in "Description of mydataset" (Beschreibung von mydataset) zu ändern. Das Dataset befindet sich nicht in Ihrem Standardprojekt, sondern in myotherproject.

bq update \
--description "Description of mydataset" \
myotherproject:mydataset

API

Rufen Sie datasets.patch auf und aktualisieren Sie in der Dataset-Ressource das Attribut description. Da die Methode datasets.update die gesamte Dataset-Ressource ersetzt, wird die Methode datasets.patch bevorzugt.

Go

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateDatasetDescription demonstrates how the Description metadata of a dataset can
// be read and modified.
func updateDatasetDescription(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.DatasetMetadataToUpdate{
		Description: "Updated Description.",
	}
	if _, err = ds.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

Erstellen Sie mit der Methode Dataset.toBuilder() eine Dataset.Builder-Instanz aus einer vorhandenen Dataset-Instanz. Konfigurieren Sie das Dataset.Builder-Objekt. Erstellen Sie das aktualisierte Dataset mit der Methode Dataset.Builder.build() und senden Sie die Aktualisierung mit der Methode Dataset.update() an die API.

Auf GitHub ansehen Feedback

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

public class UpdateDatasetDescription {

  public static void runUpdateDatasetDescription() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String newDescription = "this is the new dataset description";
    updateDatasetDescription(datasetName, newDescription);
  }

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

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDescription(newDescription).build());
      System.out.println("Dataset description updated successfully to " + newDescription);
    } catch (BigQueryException e) {
      System.out.println("Dataset description was not updated \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Auf GitHub ansehen Feedback

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function updateDatasetDescription() {
  // Updates a dataset's description.

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Set new dataset description
  const description = 'New dataset description.';
  metadata.description = description;

  const [apiResponse] = await dataset.setMetadata(metadata);
  const newDescription = apiResponse.description;

  console.log(`${datasetId} description: ${newDescription}`);
}

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

Konfigurieren Sie das Attribut Dataset.description und senden Sie die Aktualisierung durch Aufrufen der Methode Client.update_dataset() an die API.

Auf GitHub ansehen Feedback


from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.
dataset.description = "Updated description."
dataset = client.update_dataset(dataset, ["description"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with description '{}'.".format(
        full_dataset_id, dataset.description
    )
)

Standardablaufzeiten von Tabellen aktualisieren

Sie können die Standardablaufzeit für Tabellen eines Datasets so aktualisieren:

Google Cloud Console verwenden
Mit dem Befehl bq update des bq-Befehlszeilentools
Durch Aufruf der API-Methode datasets.patch
Mithilfe der Clientbibliotheken

Sie können Standardablaufzeiten für Tabellen auf Dataset-Ebene festlegen oder die Ablaufzeit bei Erstellung der Tabelle festlegen. Wenn Sie die Ablaufzeit einer Tabelle bei ihrer Erstellung festlegen, wird die für das Dataset gültige Standardablaufzeit für Tabellen ignoriert. Wenn keine Standardablaufzeit auf Dataset-Ebene festgelegt ist und Sie beim Erstellen der Tabelle keine Ablaufzeit festlegen, läuft die Tabelle nie ab und muss manuell gelöscht werden.

Wenn Sie die Einstellung der Standardablaufzeit eines Datasets aktualisieren, gilt:

Wenn Sie den Wert von Never in eine bestimmte Ablaufzeit ändern, laufen bereits im Dataset vorhandene Tabellen nur dann ab, wenn die Ablaufzeit für die Tabelle bei deren Erstellung festgelegt wurde.
Wenn Sie den Wert der Standardablaufzeit für Tabellen ändern, laufen bereits vorhandene Tabellen entsprechend der ursprünglichen Tabellenablaufeinstellung ab. Die neue Ablaufzeiteinstellung wird auf alle neu erstellten Tabellen angewendet, wenn Sie bei der Erstellung der jeweiligen Tabelle keine andere Tabellenablaufzeit angeben.

Der Wert der Standardablaufzeit wird je nachdem, mit welcher Methode der Wert festgelegt wird, unterschiedlich ausgedrückt. Verwenden Sie die Methode, die Ihnen die gewünschte Genauigkeit bietet:

In der Google Cloud Console wird die Ablaufzeit in Tagen angegeben.
Im bq-Befehlszeilentool wird die Ablaufzeit in Sekunden angegeben.
In der API wird die Ablaufzeit in Millisekunden angegeben

So aktualisieren Sie die Standardablaufzeit für ein Dataset:

Console

Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.
Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.
Klicken Sie im Bereich "Details" auf das Stiftsymbol neben Dataset-Informationen, um die Ablaufzeit zu bearbeiten.
Geben Sie im Dialog Dataset info im Bereich Default table expiration (Standard-Tabellenablaufzeit) einen Wert für Number of days after table creation (Anzahl der Tage nach der Tabellenerstellung) ein.
Klicken Sie auf Speichern.

SQL

Zum Aktualisieren der Standardablaufzeit für Tabellen verwenden Sie die Anweisung ALTER SCHEMA SET OPTIONS, um die Option default_table_expiration_days festzulegen.

Im folgenden Beispiel wird die Standardablaufzeit für Tabellen für das Dataset mydataset aktualisiert.

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

 ALTER SCHEMA mydataset
 SET OPTIONS(
     default_table_expiration_days = 3.75);

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfragen ausführen.

bq

Um die Standardablaufzeit neu erstellter Tabellen eines Datasets zu aktualisieren, geben Sie den Befehl bq update mit dem Flag --default_table_expiration ein. Wenn Sie ein Dataset in einem anderen Projekt als Ihrem Standardprojekt aktualisieren, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

bq update \
--default_table_expiration integer \
project_id:dataset

Dabei gilt:

integer: die Standardlebensdauer neu erstellter Tabellen in Sekunden. Der Mindestwert beträgt 3.600 Sekunden (eine Stunde). Die Ablaufzeit entspricht der aktuellen UTC-Zeit plus dem ganzzahligen Wert. Wenn Sie die vorhandene Ablaufzeit entfernen möchten, geben Sie 0 ein. Jede im Dataset erstellte Tabelle wird integer Sekunden nach dem Erstellen gelöscht. Dieser Wert wird angewendet, wenn Sie beim Erstellen der Tabelle keine Ablaufzeit für die Tabelle festlegen.
project_id: Ihre Projekt-ID.
dataset: der Name des Datasets, das Sie aktualisieren.

Beispiele:

Geben Sie den folgenden Befehl ein, um die Standardablaufzeit für neue, in mydataset erstellte Tabellen in zwei Stunden (7.200 Sekunden) ab der aktuellen Uhrzeit zu ändern. Das Dataset ist im Standardprojekt.

bq update --default_table_expiration 7200 mydataset

bq update --default_table_expiration 7200 myotherproject:mydataset

API

Rufen Sie datasets.patch auf und aktualisieren Sie in der Dataset-Ressource das Attribut defaultTableExpirationMs. Die Ablaufzeit wird mit der API in Millisekunden angegeben. Da die Methode datasets.update die gesamte Dataset-Ressource ersetzt, wird die Methode datasets.patch bevorzugt.

Go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// updateDatasetDefaultExpiration demonstrats setting the default expiration of a dataset
// to a specific retention period.
func updateDatasetDefaultExpiration(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.DatasetMetadataToUpdate{
		DefaultTableExpiration: 24 * time.Hour,
	}
	if _, err := client.Dataset(datasetID).Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Konfigurieren Sie die Standardablaufzeit mit der Methode Dataset.setDefaultTableLifetime().

Auf GitHub ansehen Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.concurrent.TimeUnit;

public class UpdateDatasetExpiration {

  public static void runUpdateDatasetExpiration() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    updateDatasetExpiration(datasetName);
  }

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

      // Update dataset expiration to one day
      Long newExpiration = TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDefaultTableLifetime(newExpiration).build());
      System.out.println("Dataset description updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Dataset expiration was not updated \n" + e.toString());
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function updateDatasetExpiration() {
  // Updates the lifetime of all tables in the dataset, in milliseconds.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Set new dataset metadata
  const expirationTime = 24 * 60 * 60 * 1000;
  metadata.defaultTableExpirationMs = expirationTime.toString();

  const [apiResponse] = await dataset.setMetadata(metadata);
  const newExpirationTime = apiResponse.defaultTableExpirationMs;

  console.log(`${datasetId} expiration: ${newExpirationTime}`);
}

Python

Konfigurieren Sie das Attribut Dataset.default_table_expiration_ms und senden Sie die Aktualisierung durch Aufrufen der Methode Client.update_dataset() an die API.

Auf GitHub ansehen Feedback


from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.
dataset.default_table_expiration_ms = 24 * 60 * 60 * 1000  # In milliseconds.

dataset = client.update_dataset(
    dataset, ["default_table_expiration_ms"]
)  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset {} with new expiration {}".format(
        full_dataset_id, dataset.default_table_expiration_ms
    )
)

Standardablaufzeiten von Partitionen aktualisieren

Sie können die Standardablaufzeit für Partitionen eines Datasets folgendermaßen aktualisieren:

Mit dem Befehl bq update des bq-Befehlszeilentools
Durch Aufruf der API-Methode datasets.patch
Mithilfe der Clientbibliotheken

Das Festlegen oder Aktualisieren der Standardablaufzeit für Partitionen eines Datasets wird derzeit von der Google Cloud Console nicht unterstützt.

Auf Dataset-Ebene lässt sich eine Standardablaufzeit für Partitionen festlegen, die dann für alle neu erstellten partitionierten Tabellen gilt. Alternativ können Sie beim Erstellen der partitionierten Tabellen einen Partitionsablauf für einzelne Tabellen angeben. Wenn Sie eine Standardablaufzeit für Partitionen und eine Standardablaufzeit für Tabellen jeweils auf Dataset-Ebene festlegen, gilt für neue partitionierte Tabellen nur der Partitionsablauf. Wenn beide Optionen festgelegt sind, hat die Standardablaufzeit für Partitionen Vorrang vor der Standardablaufzeit für Tabellen.

Wenn Sie die Ablaufzeit für Partitionen beim Erstellen der partitionierten Tabelle festlegen, ersetzt dieser Wert die Standardablaufzeit für Partitionen auf Dataset-Ebene, falls vorhanden.

Wenn Sie keine Standardablaufzeit für Partitionen auf Dataset-Ebene und keine Ablaufzeit für Partitionen beim Erstellen der Tabelle festlegen, sind Partitionen unbegrenzt gültig. Sie müssen die Partitionen dann manuell löschen.

Wenn Sie eine Standardablaufzeit für Partitionen für ein Dataset festlegen, gilt die Ablaufzeit für alle Partitionen in allen partitionierten Tabellen des Datasets. Wenn Sie die Ablaufzeit für Partitionen für eine Tabelle festlegen, gilt diese für alle Partitionen, die in der angegebenen Tabelle erstellt wurden. Derzeit können Sie keine unterschiedlichen Ablaufzeiten auf verschiedene Partitionen in derselben Tabelle anwenden.

Wenn Sie die Einstellung der Standardablaufzeit für Partitionen eines Datasets aktualisieren, gilt Folgendes:

Wenn Sie den Wert von never in eine bestimmte Ablaufzeit ändern, laufen Partitionen, die in partitionierten Tabellen im Dataset bereits vorhanden sind, nur dann ab, wenn eine Ablaufzeit für Partitionen bei der Erstellung der Tabelle festgelegt wurde.
Wenn Sie den Wert für die Standardablaufzeit für Partitionen ändern, laufen alle Partitionen in vorhandenen partitionierten Tabellen gemäß der ursprünglichen Standardablaufzeit für Partitionen ab. Für alle neuen partitionierten Tabellen, die im Dataset erstellt werden, gilt die neue Einstellung für die Standardablaufzeit für Partitionen, solange Sie bei der Erstellung der Tabelle keine andere Partitionsablaufzeit festlegen.

Der Wert für die Standardablaufzeit für Partitionen wird, je nachdem mit welcher Methode er festgelegt wird, in unterschiedlichen Formaten angegeben. Verwenden Sie die Methode, die Ihnen die gewünschte Genauigkeit bietet:

Im bq-Befehlszeilentool wird die Ablaufzeit in Sekunden angegeben.
In der API wird die Ablaufzeit in Millisekunden angegeben

So aktualisieren Sie die Standardablaufzeit für Partitionen für ein Dataset:

Console

Das Aktualisieren der Standardablaufzeit für Partitionen in einem Dataset wird von der Google Cloud Console derzeit nicht unterstützt.

SQL

Zum Aktualisieren der Standardablaufzeit für Partitionen verwenden Sie die Anweisung ALTER SCHEMA SET OPTIONS, um die Option default_partition_expiration_days festzulegen.

Im folgenden Beispiel wird die Standardablaufzeit für Partitionen für ein Dataset mit dem Namen mydataset aktualisiert:

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

 ALTER SCHEMA mydataset
 SET OPTIONS(
     default_partition_expiration_days = 3.75);

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfragen ausführen.

bq

Zum Aktualisieren der Standardablaufzeit für ein Dataset geben Sie den Befehl bq update mit dem Flag --default_partition_expiration ein. Wenn Sie ein Dataset in einem anderen Projekt als dem Standardprojekt aktualisieren, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

bq update \
--default_partition_expiration integer \
project_id:dataset

Dabei gilt:

integer: die Standardlebensdauer von Partitionen in neu erstellten partitionierten Tabellen in Sekunden. Für dieses Flag gilt kein Mindestwert. Wenn Sie die vorhandene Ablaufzeit entfernen möchten, geben Sie 0 ein. Alle Partitionen in neu erstellten partitionierten Tabellen werden integer Sekunden nach dem UTC-Datum der Partition gelöscht. Dieser Wert wird angewendet, wenn Sie beim Erstellen der Tabelle keine Ablaufzeit für Partitionen festlegen.
project_id: Ihre Projekt-ID.
dataset: der Name des Datasets, das Sie aktualisieren.

Beispiele:

Mit dem folgenden Befehl legen Sie die Standardablaufzeit für Partitionen für neue partitionierte Tabellen in mydataset auf 26 Stunden (93.600 Sekunden) fest. Das Dataset ist im Standardprojekt.

bq update --default_partition_expiration 93600 mydataset

Mit dem folgenden Befehl legen Sie die Standardablaufzeit für Partitionen für neue partitionierte Tabellen in mydataset auf 26 Stunden (93.600 Sekunden) fest. Das Dataset ist in myotherproject und nicht im Standardprojekt.

bq update --default_partition_expiration 93600 myotherproject:mydataset

API

Rufen Sie datasets.patch auf und aktualisieren Sie in der Dataset-Ressource das Attribut defaultPartitionExpirationMs. Die Ablaufzeit wird in Millisekunden angegeben. Da die Methode datasets.update die gesamte Dataset-Ressource ersetzt, wird die Methode datasets.patch bevorzugt.

Dataset-Zugriffssteuerungen aktualisieren

Das Verfahren zum Aktualisieren der Zugriffssteuerungen eines Datasets ähnelt sehr dem zum Zuweisen von Zugriffssteuerungen zu einem Dataset. Zugriffssteuerungen können nicht während der Dataset-Erstellung mit der Google Cloud Console oder dem bq-Befehlszeilentool angewendet werden. Sie müssen zuerst das Dataset erstellen und dann die Zugriffssteuerungen des Datasets aktualisieren. Mit der API können Dataset-Zugriffssteuerungen durch Aufrufen der Methode datasets.patch aktualisiert werden.

Wenn Sie die Zugriffssteuerungen für ein Dataset aktualisieren, können Sie den Zugriff für die folgenden Entitäten ändern:

IAM-Hauptkonten:
- Google Konto e-mail: Gewährt einem einzelnen Google-Konto Zugriff auf das Dataset
- Google Group: Gewährt allen Mitgliedern einer Google-Gruppe Zugriff auf das Dataset
- Google Apps-Domain: Gewährt allen Nutzern und Gruppen in einer Google-Domain Zugriff auf das Dataset.
- Dienstkonto: Gewährt einem Dienstkonto Zugriff auf das Dataset.
- Alle Nutzer: Geben Sie allUsers ein, um den Zugriff der Allgemeinheit zu gewähren.
- Alle Google-Konten: Geben Sie allAuthenticatedUsers ein, wenn Sie allen bei einem Google-Konto angemeldeten Nutzern den Zugriff gewähren möchten
Ressourcentypen:
- Autorisierte Datasets: Gewährt einem autorisierten Dataset Zugriff auf das Dataset.
- Autorisierte Ansichten: Gewährt einer autorisierten Ansicht Zugriff auf das Dataset.
- Autorisierte Funktionen: Gewährt einer autorisierten UDF oder Tabellenfunktion Zugriff auf das Dataset.

So aktualisieren Sie Zugriffssteuerungen für ein Dataset:

Console

Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.
Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.
Klicken Sie auf Share Dataset (Dataset freigeben).
Wenn Sie im Dialogfeld Dataset freigeben vorhandene Einträge löschen möchten, maximieren Sie den jeweiligen Eintrag und klicken Sie auf das Symbol zum Löschen (Papierkorbsymbol).
So fügen Sie im Dialogfeld Dataset freigeben neue Einträge hinzu:
1. Geben Sie die Entität in das Feld Hauptkonten hinzufügen ein.
2. Wählen Sie unter Rolle auswählen die entsprechende IAM-Rolle aus der Liste aus. Weitere Informationen zu den Berechtigungen, die jeder vordefinierten BigQuery-Rolle zugewiesen sind, finden Sie auf der Seite Vordefinierte Rollen und Berechtigungen.
3. Klicken Sie auf Hinzufügen.
Zum Hinzufügen einer autorisierten Ansicht klicken Sie auf den Tab Autorisierte Ansicht und geben das Projekt, das Dataset und die Ansicht ein. Klicken Sie anschließend auf Hinzufügen.
Nachdem Sie Zugriffssteuerungen hinzugefügt oder gelöscht haben, klicken Sie auf Fertig.

bq

Schreiben Sie die vorhandenen Dataset-Informationen (einschließlich Zugriffssteuerungen) mit dem Befehl show in eine JSON-Datei. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.
```
bq show \
--format=prettyjson \
project_id:dataset > path_to_file
```
Ersetzen Sie Folgendes:
- project_id: Ihre Projekt-ID.
- dataset: der Name Ihres Datasets.
- path_to_file: der Pfad zur JSON-Datei auf dem lokalen Computer.
Beispiele:

Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset in eine JSON-Datei zu schreiben. mydataset befindet sich in Ihrem Standardprojekt.
```
bq show --format=prettyjson mydataset > /tmp/mydataset.json
```
Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset in eine JSON-Datei zu schreiben. mydataset befindet sich in myotherproject.
```
bq show --format=prettyjson \
myotherproject:mydataset > /tmp/mydataset.json
```

Nehmen Sie die Änderungen im Abschnitt "access" der JSON-Datei vor. Sie können specialGroup-Einträge beliebig einfügen oder entfernen: projectOwners, projectWriters, projectReaders und allAuthenticatedUsers. Außerdem können Sie folgende Einträge angeben, entfernen oder ändern: userByEmail, groupByEmail und domain.

Der Abschnitt "access" der JSON-Datei eines Datasets sieht zum Beispiel so aus:

{
 "access": [
  {
   "role": "READER",
   "specialGroup": "projectReaders"
  },
  {
   "role": "WRITER",
   "specialGroup": "projectWriters"
  },
  {
   "role": "OWNER",
   "specialGroup": "projectOwners"
  }
  {
   "role": "READER",
   "specialGroup": "allAuthenticatedUsers"
  }
  {
   "role": "READER",
   "domain": "[DOMAIN_NAME]"
  }
  {
   "role": "WRITER",
   "userByEmail": "[USER_EMAIL]"
  }
  {
   "role": "READER",
   "groupByEmail": "[GROUP_EMAIL]"
  }
 ],
}

Wenn die Änderungen abgeschlossen sind, führen Sie den Befehl update aus und fügen mit dem Flag --source die JSON-Datei hinzu. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.
Achtung: Durch Anwendung der JSON-Datei mit den Zugriffssteuerungen werden die vorhandenen Zugriffssteuerungen überschrieben.
```
bq update --source path_to_file project_id:dataset
```
Ersetzen Sie Folgendes:
- path_to_file: der Pfad zur JSON-Datei auf dem lokalen Computer.
- project_id: Ihre Projekt-ID.
- dataset: der Name Ihres Datasets.
Beispiele:

Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset zu aktualisieren. mydataset befindet sich in Ihrem Standardprojekt.
```
bq update --source /tmp/mydataset.json mydataset
```
Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset zu aktualisieren. mydataset befindet sich in myotherproject.
```
bq update --source /tmp/mydataset.json myotherproject:mydataset
```
Geben Sie den Befehl show noch einmal ein, ohne die Informationen in eine Datei zu schreiben, um die Änderungen der Zugriffssteuerung zu prüfen.
```
bq show --format=prettyjson dataset
```
oder
```
bq show --format=prettyjson project_id:dataset
```

API

Rufen Sie datasets.patch auf und aktualisieren Sie das Attribut access in der Dataset-Ressource.

Da die Methode datasets.update die gesamte Dataset-Ressource ersetzt, ist datasets.patch die bevorzugte Methode zum Aktualisieren von Zugriffssteuerungen.

Go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateDatasetAccessControl demonstrates how the access control policy of a dataset
// can be amended by adding an additional entry corresponding to a specific user identity.
func updateDatasetAccessControl(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       bigquery.ReaderRole,
			EntityType: bigquery.UserEmailEntity,
			Entity:     "sample.bigquery.dev@gmail.com"},
		),
	}

	// Leverage the ETag for the update to assert there's been no modifications to the
	// dataset since the metadata was originally read.
	if _, err := ds.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Konfigurieren Sie die Zugriffssteuerungen mit der Methode Dataset.Builder.setAcl().

Auf GitHub ansehen Feedback

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Role;
import com.google.cloud.bigquery.Acl.User;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.ArrayList;

public class UpdateDatasetAccess {

  public static void runUpdateDatasetAccess() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    updateDatasetAccess(datasetName);
  }

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

      Dataset dataset = bigquery.getDataset(datasetName);

      // Create a new ACL granting the READER role to "sample.bigquery.dev@gmail.com"
      // For more information on the types of ACLs available see:
      // https://cloud.google.com/storage/docs/access-control/lists
      Acl newEntry = Acl.of(new User("sample.bigquery.dev@gmail.com"), Role.READER);

      // Get a copy of the ACLs list from the dataset and append the new entry
      ArrayList<Acl> acls = new ArrayList<>(dataset.getAcl());
      acls.add(newEntry);

      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("Dataset Access Control updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Dataset Access control was not updated \n" + e.toString());
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function updateDatasetAccess() {
  // Updates a datasets's access controls.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";

  // Create new role metadata
  const newRole = {
    role: 'READER',
    entity_type: 'userByEmail',
    userByEmail: 'sample.bigquery.dev@gmail.com',
  };

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Add new role to role acess array
  metadata.access.push(newRole);
  const [apiResponse] = await dataset.setMetadata(metadata);
  const newAccessRoles = apiResponse.access;
  newAccessRoles.forEach(role => console.log(role));
}

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Das Attribut dataset.access_entries legen Sie mit den Zugriffssteuerungen für ein Dataset fest. Rufen Sie dann die Funktion client.update_dataset() auf, um das Attribut zu aktualisieren.

Auf GitHub ansehen Feedback


# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
dataset_id = "your-project.your_dataset"

# TODO(developer): Set entity_id to the ID of the email or group from whom
# you are adding access. Alternatively, to the JSON REST API representation
# of the entity, such as a view's table reference.
entity_id = "user-or-group-to-add@example.com"

from google.cloud.bigquery.enums import EntityTypes

# TODO(developer): Set entity_type to the type of entity you are granting access to.
# Common types include:
#
# * "userByEmail" -- A single user or service account. For example "fred@example.com"
# * "groupByEmail" -- A group of users. For example "example@googlegroups.com"
# * "view" -- An authorized view. For example
#       {"projectId": "p", "datasetId": "d", "tableId": "v"}
#
# For a complete reference, see the REST API reference documentation:
# https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#Dataset.FIELDS.access
entity_type = EntityTypes.GROUP_BY_EMAIL

# TODO(developer): Set role to a one of the "Basic roles for datasets"
# described here:
# https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
role = "READER"

from google.cloud import bigquery

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

dataset = client.get_dataset(dataset_id)  # Make an API request.

entries = list(dataset.access_entries)
entries.append(
    bigquery.AccessEntry(
        role=role,
        entity_type=entity_type,
        entity_id=entity_id,
    )
)
dataset.access_entries = entries

dataset = client.update_dataset(dataset, ["access_entries"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with modified user permissions.".format(full_dataset_id)
)

Zeitreisefenster aktualisieren

Sie können das Zeitreisefenster eines Datasets auf folgende Arten aktualisieren:

Anweisung ALTER SCHEMA SET OPTIONS verwenden
Den Befehl bq update des Befehlszeilentools bq anwenden
Durch Aufrufen der API-Methode datasets.patch oder datasets.update Die Methode update ersetzt die gesamte Dataset-Ressource, während die Methode patch nur Felder ersetzt, die in der gesendeten Dataset-Ressource bereitgestellt werden.

Weitere Informationen zum Zeitreisefenster finden Sie unter Zeitreisefenster konfigurieren.

So aktualisieren Sie das Zeitreisefenster für ein Dataset:

SQL

Verwenden Sie die Anweisung ALTER SCHEMA SET OPTIONS mit der Option max_time_travel_hours, um das Zeitreisefenster beim Ändern eines Datasets anzugeben. Der Wert max_time_travel_hours muss eine Ganzzahl sein, die als Vielfaches von 24 (48, 72, 96, 120, 144, 168) zwischen 48 (2 Tagen) und 168 (7 Tage) ausgedrückt wird.

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

    ALTER SCHEMA DATASET_NAME
    SET OPTIONS(
      max_time_travel_hours = HOURS);

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfragen ausführen.

bq

Verwenden Sie den Befehl bq update mit dem Flag --max_time_travel_hours, um das Zeitreisefenster beim Ändern eines Datasets anzugeben. Der Wert --max_time_travel_hours muss eine Ganzzahl sein, die als Vielfaches von 24 (48, 72, 96, 120, 144, 168) zwischen 48 (2 Tagen) und 168 (7 Tage) ausgedrückt wird.

bq update \
--dataset=true --max_time_travel_hours=HOURS \
PROJECT_ID:DATASET_NAME

API

Rufen Sie die Methode datasets.patch oder datasets.update mit einer definierten Dataset-Ressource auf, in der Sie einen Wert für das Feld maxTimeTravelHours angegeben haben. Der Wert maxTimeTravelHours muss eine Ganzzahl sein, die als Vielfaches von 24 (48, 72, 96, 120, 144, 168) zwischen 48 (2 Tagen) und 168 (7 Tage) ausgedrückt wird.

Speicherabrechnungsmodelle aktualisieren

Sie können das Speichermodell eines Datasets so aktualisieren, dass bei der Berechnung der Speichergebühren physische Byte anstelle von logischen Standard-Byte verwendet werden. Wenn Sie das Abrechnungsmodell eines Datasets ändern, dauert es 24 Stunden, bis die Änderung wirksam wird. Wenn Sie das Speicherabrechnungsmodell eines Datasets auf physische Byte geändert haben, können Sie es nicht mehr zurück in logische Logwerte ändern.

Weitere Informationen finden Sie unter Abrechnungsmodelle für Datasets.

SQL

Verwenden Sie zum Aktualisieren des Abrechnungsmodells für ein Dataset die Anweisung ALTER SCHEMA SET OPTIONS und legen Sie die Option storage_billing_model auf physical fest:

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen
Geben Sie im Abfrageeditor die folgende Anweisung ein:
```
ALTER SCHEMA DATASET_NAME
SET OPTIONS(
 storage_billing_model = 'physical');
```
Ersetzen Sie DATASET_NAME durch den Namen des Datasets, das Sie ändern.
Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfragen ausführen.

Verwenden Sie die folgende SQL-Abfrage, um das Speicherabrechnungsmodell für alle Datasets in einem Projekt zu aktualisieren:

FOR record IN
 (SELECT CONCAT(catalog_name, ':', schema_name) AS dataset_path
 FROM PROJECT_ID.INFORMATION_SCHEMA.SCHEMATA)
DO
 ALTER SCHEMA record.dataset_path
 SET OPTIONS(
   storage_billing_model = 'physical');
END FOR;

Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

bq

Verwenden Sie zum Aktualisieren des Abrechnungsmodells für ein Dataset den Befehl bq update und legen Sie das Flag --storage_billing_model auf PHYSICAL fest:

bq update -d --storage_billing_model=PHYSICAL PROJECT_ID:DATASET_ID

Dabei gilt:

PROJECT_ID: Ihre Projekt-ID
DATASET_ID: die ID des zu aktualisierenden Datasets

API

Rufen Sie die Methode datasets.update mit einer definierten Dataset-Ressource auf, wobei das Feld storageBillingModel auf PHYSICAL gesetzt ist.

Das folgende Beispiel zeigt, wie datasets.update mit curl aufgerufen wird:

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" -L -X PUT https://bigquery.googleapis.com/bigquery/v2/projects/PROJECT_ID/datasets/DATASET_ID -d '{"datasetReference": {"projectId": "PROJECT_ID", "datasetId": "DATASET_ID"}, "storageBillingModel": "PHYSICAL"}'

Dabei gilt:

PROJECT_ID: Ihre Projekt-ID
DATASET_ID: die ID des zu aktualisierenden Datasets

Dataset-Sicherheit

Informationen zum Steuern des Zugriffs auf Datasets in BigQuery finden Sie unter Zugriff auf Datasets steuern. Informationen zur Datenverschlüsselung finden Sie unter Verschlüsselung inaktiver Daten.

Weitere Informationen

Weitere Informationen zum Erstellen von Datasets finden Sie unter Datasets erstellen.
Weitere Informationen zum Verwalten von Datasets finden Sie unter Datasets verwalten