Dataset-Attribute aktualisieren

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

Erforderliche Berechtigungen

Sie benötigen mindestens die Berechtigungen bigquery.datasets.update und bigquery.datasets.get, um Dataset-Attribute zu aktualisieren. Diese vordefinierten IAM-Rollen enthalten die Berechtigungen bigquery.datasets.update und bigquery.datasets.get:

  • bigquery.dataOwner
  • bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, Attribute für die von ihnen erstellten Datasets zu erstellen.

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

Dataset-Beschreibungen aktualisieren

So können Sie die Beschreibung eines Datasets aktualisieren:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq update des bq-Befehlszeilentools
  • Durch Aufrufen der API-Methode datasets.patch
  • Mit den Clientbibliotheken

So aktualisieren Sie die Beschreibung eines Datasets:

Console

  1. Wählen Sie im Bereich Resources (Ressourcen) das Dataset aus.

  2. Klicken Sie auf der Seite Details auf das Stiftsymbol neben Beschreibung, um den Beschreibungstext zu bearbeiten.

    Abfrageeinstellungen

  3. Geben Sie im Dialogfeld eine Beschreibung in das Feld ein oder bearbeiten Sie die vorhandene Beschreibung. Klicken Sie auf Update (Aktualisieren), um den neuen Beschreibungstext zu speichern.

Klassische UI

  1. Wählen Sie das Dataset im Navigationsbereich aus.

  2. Klicken Sie auf der Seite Dataset Details im Bereich Description auf Describe this dataset, um das Beschreibungsfeld zu öffnen, wenn das Dataset keine Beschreibung hat. Klicken Sie andernfalls auf den vorhandenen Beschreibungstext.

  3. Geben Sie eine Beschreibung in das Feld ein oder bearbeiten Sie die vorhandene Beschreibung. Wenn Sie außerhalb des Felds klicken, wird der Text gespeichert.

    Dataset-Beschreibung

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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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: Clientbibliotheken verwenden. 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.
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: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// 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: Clientbibliotheken verwenden. 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.

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 von Tabellen eines Datasets folgendermaßen aktualisieren:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq update des bq-Befehlszeilentools
  • Durch Aufrufen der API-Methode datasets.patch
  • Mit den Clientbibliotheken

Sie können Standardablaufzeiten für Tabellen auf Dataset-Ebene festlegen oder beim Erstellen einer Tabelle ihre Ablaufzeit angeben. 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 Cloud Console und der klassischen BigQuery-Web-UI 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

  1. Wählen Sie im Bereich Resources (Ressourcen) das Dataset aus.

  2. Klicken Sie auf der Seite Details auf das Stiftsymbol neben Dataset info, um die Ablaufzeit zu bearbeiten.

  3. 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.

  4. Klicken Sie auf Save (Speichern).

Klassische UI

  1. Wählen Sie das Dataset im Navigationsbereich aus.

  2. Klicken Sie auf der Seite Dataset Details im Abschnitt Details rechts neben Default Table Expiration auf Edit.

    Tabellenablauf

  3. Klicken Sie im Dialogfeld Update Expiration unter Data expiration auf In und geben Sie die Ablaufzeit in Tagen ein. Der Standardwert ist Never.

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

Ersetzen Sie Folgendes:

  • 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 nach integer Sekunden ab dem Zeitpunkt der Erstellung 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

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 in myotherproject und nicht im Standardprojekt.

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

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. 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.

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

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

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

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

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

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

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 die Partitionen eines Datasets so aktualisieren:

  • Mit dem Befehl bq update des bq-Befehlszeilentools
  • Durch Aufrufen der API-Methode datasets.patch
  • Mit den Clientbibliotheken

Das Festlegen oder Aktualisieren der Standardablaufzeit für Partitionen eines Datasets wird derzeit von der Cloud Console oder der klassischen BigQuery-Web-UI 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 "Nie" 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 Cloud Console derzeit nicht unterstützt.

Klassische UI

Das Aktualisieren der Standardablaufzeit für Partitionen eines Datasets wird derzeit von der klassischen BigQuery-Web-UI nicht unterstützt.

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

Ersetzen Sie Folgendes:

  • 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 Erstellung von Datasets in der Cloud Console, der klassischen BigQuery-Web-UI oder dem bq-Befehlszeilentool festgelegt 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:

  • Google-Konto-E-Mail-Adresse: Gewährt einem einzelnen Google-Konto Zugriff auf das Dataset.
  • Google-Gruppe: 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.
  • Beliebig: Geben Sie "allUsers" an, wenn das Dataset öffentlich verfügbar sein soll.
  • Alle Google-Konten: Geben Sie "allAuthenticatedUsers" an, wenn Sie allen an einem Google-Konto angemeldeten Nutzern den Zugriff gewähren möchten.
  • Autorisierte Ansichten: Gewährt einer autorisierten Ansicht Zugriff auf das Dataset.

So aktualisieren Sie Zugriffssteuerungen für ein Dataset:

Console

  1. Klicken Sie im Navigationsbereich im Abschnitt Ressourcen auf Ihr Dataset.

  2. Klicken Sie auf Dataset freigeben.

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

  4. So fügen Sie im Dialogfeld Dataset freigeben neue Einträge hinzu:

    1. Geben Sie die Entität in das Feld Mitglieder 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.

  5. 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.

  6. Nachdem Sie Zugriffssteuerungen hinzugefügt oder gelöscht haben, klicken Sie auf Fertig.

Klassische UI

  1. Klicken Sie rechts neben dem Dataset auf den Drop-down-Pfeil und wählen Sie Dataset freigeben aus.

  2. So ändern Sie vorhandene Einträge im Dialogfeld Share Dataset (Dataset freigeben):

    • Klicken Sie rechts neben der Entität auf das Symbol X, um vorhandene Einträge zu löschen.
    • Zum Ändern der Berechtigungen für eine Entität, können Sie auf die Schaltfläche "Berechtigungen" klicken und eine geeignete Zugriffsebene auswählen: Is owner (OWNER), Can edit (WRITER) oder Can view. (READER). Weitere Informationen zu Rollen auf Dataset-Ebene finden Sie unter Einfache Rollen und Berechtigungen.
  3. So fügen Sie im Dialogfeld Dataset freigeben neue Einträge hinzu:

    1. Klicken Sie auf das Drop-down-Menü links neben dem Feld Add People (Personen hinzufügen) und wählen Sie die entsprechende Option aus.

    2. Geben Sie einen Wert in das Textfeld ein. Wenn Sie beispielsweise User by e-mail (Nutzer per E-Mail) auswählen, geben Sie die E-Mail-Adresse des Nutzers ein.

    3. Klicken Sie rechts neben dem Feld Add People auf Can view und wählen Sie in der Liste die passende Rolle aus.

      Personen zu Dataset hinzufügen

      • "Darf ansehen" (READER) gewährt für das Dataset die Zugriffsberechtigung bigquery.dataViewer.
      • "Darf bearbeiten" (WRITER) gewährt für das Dataset die Zugriffsberechtigung bigquery.dataEditor.
      • "Ist Inhaber" (OWNER) gewährt für das Dataset die Zugriffsberechtigung bigquery.dataOwner.
    4. Klicken Sie auf Hinzufügen.

  4. Nachdem Sie die gewünschten Zugriffssteuerungen hinzugefügt, gelöscht bzw. geändert haben, klicken Sie auf Änderungen speichern.

  5. Prüfen Sie die Zugriffssteuerungen. Klicken Sie dazu auf den Drop-down-Pfeil rechts neben dem Dataset und wählen Sie Share Dataset (Dataset freigeben) aus. Sie können die Einstellungen im Dialogfeld Share Dataset bestätigen.

bq

  1. 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
    
  2. 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]"
      }
     ],
    }
    

  3. 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.

    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
    
  4. 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

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. 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.

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

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

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

// 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: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

Legen Sie im Attribut dataset.access_entries die Zugriffssteuerungen für ein Dataset fest. Rufen Sie dann die Funktion client.update_dataset() auf, um das Attribut zu aktualisieren.
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.

entry = bigquery.AccessEntry(
    role="READER",
    entity_type="userByEmail",
    entity_id="sample.bigquery.dev@gmail.com",
)

entries = list(dataset.access_entries)
entries.append(entry)
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)
)

Weitere Informationen