Tabellen verwalten

In diesem Dokument wird beschrieben, wie in BigQuery Tabellen verwaltet werden. Sie haben folgende Möglichkeiten zum Verwalten Ihrer BigQuery-Tabellen:

  • Tabellenattribute aktualisieren:
    • Ablaufzeit
    • Beschreibung
    • Schemadefinition
    • Labels
  • Tabelle umbenennen (kopieren)
  • Tabelle kopieren
  • Tabelle löschen
  • Gelöschte Tabelle wiederherstellen

Weitere Informationen zum Erstellen und Verwenden von Tabellen, darunter auch zum Abrufen von Tabelleninformationen, Auflisten von Tabellen und Steuern des Zugriffs auf Tabellendaten, finden Sie unter Tabellen erstellen und verwenden.

Hinweis

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

Tabellenattribute aktualisieren

Sie können die folgenden Elemente einer Tabelle aktualisieren:

Erforderliche Berechtigungen

Zum Aktualisieren einer Tabelle benötigen Sie die folgenden IAM-Berechtigungen:

  • bigquery.tables.update
  • bigquery.tables.get

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

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin

Wenn Sie die Berechtigung bigquery.datasets.create haben, können Sie außerdem die Attribute der Tabellen für die Datasets aktualisieren, die Sie erstellen.

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

Die Beschreibung einer Tabelle aktualisieren

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

  • Mit der Console
  • Durch Senden einer ALTER TABLE-DDL-Anweisung (Data Definition Language, Datendefinitionssprache)
  • Mit dem Befehl bq update des bq-Befehlszeilentools
  • Durch Aufruf der API-Methode tables.patch
  • Mithilfe der Clientbibliotheken

So aktualisieren Sie die Beschreibung einer Tabelle:

Console

Sie können keine Beschreibung hinzufügen, wenn Sie eine Tabelle mit der Console erstellen. Nachdem die Tabelle erstellt wurde, können Sie auf der Seite Details eine Beschreibung hinzufügen.

  1. Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.

  2. Klicken Sie im Detailbereich auf Details.

  3. Klicken Sie im Abschnitt Description (Beschreibung) auf das Stiftsymbol, um die Beschreibung zu bearbeiten.

    Beschreibung bearbeiten.

  4. Geben Sie eine Beschreibung in das Feld ein und klicken Sie zum Speichern auf Aktualisieren.

SQL

Verwenden Sie die Anweisung ALTER TABLE SET OPTIONS. Im folgenden Beispiel wird die Beschreibung einer Tabelle mit dem Namen mytable aktualisiert:

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    ALTER TABLE mydataset.mytable
      SET OPTIONS (
        description = 'Description of mytable');
    

  3. 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 eine Tabelle 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 "description" \
project_id:dataset.table

Dabei gilt:

  • description: der Text zur Beschreibung der Tabelle in Anführungszeichen
  • project_id: Ihre Projekt-ID
  • dataset: der Name des Datasets, das die zu aktualisierende Tabelle enthält
  • table: der Name der zu aktualisierenden Tabelle

Beispiele:

Geben Sie den folgenden Befehl ein, um die Beschreibung der Tabelle mytable im Dataset mydataset in „Description of mytable” (Beschreibung von mytable) zu ändern. Das Dataset mydataset befindet sich in Ihrem Standardprojekt.

bq update --description "Description of mytable" mydataset.mytable

Geben Sie den folgenden Befehl ein, um die Beschreibung der Tabelle mytable im Dataset mydataset in „Description of mytable” (Beschreibung von mytable) zu ändern. Das Dataset mydataset befindet sich im Projekt myotherproject, nicht in Ihrem Standardprojekt.

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

API

Rufen Sie die Methode tables.patch auf und verwenden Sie das Attribut description in der Tabellenressource, um die Beschreibung der Tabelle zu aktualisieren. Da die Methode tables.update die gesamte Tabellenressource ersetzt, ist die Methode tables.patch zu bevorzugen.

Go

Bevor Sie dieses Beispiel ausprobieren, 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.

import (
	"context"
	"fmt"

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

// updateTableDescription demonstrates how to fetch a table's metadata and updates the Description metadata.
func updateTableDescription(projectID, datasetID, tableID 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()

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

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

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

public class UpdateTableDescription {

  public static void runUpdateTableDescription() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String newDescription = "this is the new table description";
    updateTableDescription(datasetName, tableName, newDescription);
  }

  public static void updateTableDescription(
      String datasetName, String tableName, 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();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setDescription(newDescription).build());
      System.out.println("Table description updated successfully to " + newDescription);
    } catch (BigQueryException e) {
      System.out.println("Table description was not updated \n" + e.toString());
    }
  }
}

Python

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

Konfigurieren Sie das Attribut Table.description und rufen Sie Client.update_table() auf, um die Aktualisierung an die API zu senden.
# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.description == "Original description."
table.description = "Updated description."

table = client.update_table(table, ["description"])  # API request

assert table.description == "Updated description."

Ablaufzeit einer Tabelle aktualisieren

Sie können Standardablaufzeiten für Tabellen auf Dataset-Ebene festlegen oder die Ablaufzeit bei Erstellung der Tabelle festlegen. Die Ablaufzeit einer Tabelle wird auch als Gültigkeitsdauer oder TTL (Time To Live) bezeichnet.

Wenn eine Tabelle abläuft, wird sie mit allen enthaltenen Daten gelöscht. Bei Bedarf können Sie die abgelaufene Tabelle innerhalb des für das Dataset angegebenen Zeitreisefensters wiederherstellen. Weitere Informationen finden Sie unter Gelöschte Tabellen wiederherstellen.

Wenn Sie die Ablaufzeit einer Tabelle beim Erstellen festlegen, wird die Standardablaufzeit für Tabellen des Datasets ignoriert. Wenn Sie keine Standardablaufzeit für Tabellen auf Dataset-Ebene und keine Ablaufzeit beim Erstellen der Tabelle festlegen, läuft die Tabelle nie ab und Sie müssen die Tabelle manuell löschen.

Nachdem die Tabelle erstellt wurde, können Sie die Ablaufzeit jederzeit auf folgenden Wegen aktualisieren:

  • Mit der Console
  • Durch Senden einer ALTER TABLE-DDL-Anweisung (Data Definition Language, Datendefinitionssprache)
  • Mit dem Befehl bq update des bq-Befehlszeilentools
  • Durch Aufruf der API-Methode tables.patch
  • Mithilfe der Clientbibliotheken

So aktualisieren Sie die Ablaufzeit einer Tabelle:

Console

Sie können keine Ablaufzeit hinzufügen, wenn Sie eine Tabelle mit der Console erstellen. Nachdem eine Tabelle erstellt wurde, können Sie den Ablauf der Tabelle auf der Seite Details hinzufügen oder aktualisieren.

  1. Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.

  2. Klicken Sie im Detailbereich auf Details.

  3. Klicken Sie auf das Stiftsymbol neben Tabelleninformationen.

  4. Wählen Sie bei Tabellenablauf die Option Datum angeben aus. Wählen Sie dann mit dem Kalender-Widget weiter unten das Ablaufdatum aus.

  5. Klicken Sie zum Speichern auf Aktualisieren. Die aktualisierte Ablaufzeit wird im Abschnitt Tabelleninformationen angezeigt.

SQL

Verwenden Sie die Anweisung ALTER TABLE SET OPTIONS. Im folgenden Beispiel wird die Ablaufzeit einer Tabelle mit dem Namen mytable aktualisiert:

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    ALTER TABLE mydataset.mytable
      SET OPTIONS (
        -- Sets table expiration to timestamp 2025-02-03 12:34:56
        expiration_timestamp = TIMESTAMP '2025-02-03 12:34:56');
    

  3. 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 --expiration aus. Wenn Sie eine Tabelle 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 \
--expiration integer \
project_id:dataset.table

Dabei gilt:

  • integer: die Standardlebensdauer der Tabelle in Sekunden. Der Mindestwert beträgt 3.600 Sekunden (eine Stunde). Die Ablaufzeit entspricht der aktuellen Zeit plus dem ganzzahligen Wert. Wenn Sie 0 angeben, wird der Tabellenablauf entfernt und die Tabelle läuft nie ab. Tabellen ohne Ablauf müssen manuell gelöscht werden.
  • project_id: Ihre Projekt-ID.
  • dataset: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
  • table: der Name der zu aktualisierenden Tabelle.

Beispiele:

Geben Sie den folgenden Befehl ein, um die Ablaufzeit der Tabelle mytable im Dataset mydataset auf 5 Tage (432000 Sekunden) zu aktualisieren. Das Dataset mydataset befindet sich in Ihrem Standardprojekt.

bq update --expiration 432000 mydataset.mytable

Geben Sie den folgenden Befehl ein, um die Ablaufzeit der Tabelle mytable im Dataset mydataset auf 5 Tage (432000 Sekunden) zu aktualisieren. Das Dataset mydataset befindet sich im Projekt myotherproject, nicht in Ihrem Standardprojekt.

bq update --expiration 432000 myotherproject:mydataset.mytable

API

Rufen Sie die Methode tables.patch auf und verwenden Sie das Attribut expirationTime in der Tabellenressource, um die Ablaufzeit der Tabelle in Millisekunden zu ändern. Da die Methode tables.update die gesamte Tabellenressource ersetzt, ist die Methode tables.patch zu bevorzugen.

Go

Bevor Sie dieses Beispiel ausprobieren, 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.

import (
	"context"
	"fmt"
	"time"

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

// updateTableExpiration demonstrates setting the table expiration of a table to a specific point in time
// in the future, at which time it will be deleted.
func updateTableExpiration(projectID, datasetID, tableID 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()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		ExpirationTime: time.Now().Add(time.Duration(5*24) * time.Hour), // table expiration in 5 days.
	}
	if _, err = tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

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

public class UpdateTableExpiration {

  public static void runUpdateTableExpiration() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    // Update table expiration to one day.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);
    updateTableExpiration(datasetName, tableName, newExpiration);
  }

  public static void updateTableExpiration(
      String datasetName, String tableName, Long newExpiration) {
    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();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setExpirationTime(newExpiration).build());

      System.out.println("Table expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Table expiration was not updated \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben 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 updateTableExpiration() {
  // Updates a table's expiration.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset', // Existing dataset
  // const tableId = 'my_table', // Existing table
  // const expirationTime = Date.now() + 1000 * 60 * 60 * 24 * 5 // 5 days from current time in ms

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

  // Set new table expiration to 5 days from current time
  metadata.expirationTime = expirationTime.toString();
  const [apiResponse] = await table.setMetadata(metadata);

  const newExpirationTime = apiResponse.expirationTime;
  console.log(`${tableId} expiration: ${newExpirationTime}`);
}

Python

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

Konfigurieren Sie das Attribut Table.expires und rufen Sie Client.update_table() auf, um die Aktualisierung an die API zu senden.
import datetime

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.expires is None

# set table to expire 5 days from now
expiration = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(
    days=5
)
table.expires = expiration
table = client.update_table(table, ["expires"])  # API request

# expiration is stored in milliseconds
margin = datetime.timedelta(microseconds=1000)
assert expiration - margin <= table.expires <= expiration + margin

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

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

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;

// Sample to update partition expiration on a dataset.
public class UpdateDatasetPartitionExpiration {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    // Set the default partition expiration (applies to new tables, only) in
    // milliseconds. This example sets the default expiration to 90 days.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(90, TimeUnit.DAYS);
    updateDatasetPartitionExpiration(datasetName, newExpiration);
  }

  public static void updateDatasetPartitionExpiration(String datasetName, Long newExpiration) {
    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().setDefaultPartitionExpirationMs(newExpiration).build());
      System.out.println(
          "Dataset default partition expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Dataset partition expiration was not updated \n" + e.toString());
    }
  }
}

Python

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

# Set the default partition expiration (applies to new tables, only) in
# milliseconds. This example sets the default expiration to 90 days.
dataset.default_partition_expiration_ms = 90 * 24 * 60 * 60 * 1000

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

print(
    "Updated dataset {}.{} with new default partition expiration {}".format(
        dataset.project, dataset.dataset_id, dataset.default_partition_expiration_ms
    )
)

Schemadefinition einer Tabelle aktualisieren

Weitere Informationen zum Aktualisieren der Schemadefinition einer Tabelle finden Sie unter Tabellenschemas ändern.

Tabelle umbenennen

Sie können eine Tabelle mit der Anweisung ALTER TABLE RENAME TO umbenennen, nachdem sie erstellt wurde. Im folgenden Beispiel wird mytable in mynewtable umbenannt:

ALTER TABLE mydataset.mytable
RENAME TO mynewtable;

Einschränkungen beim Umbenennen von Tabellen

  • Derzeit können Sie eine Tabelle bis zu 72 Stunden nach dem letzten Streamingvorgang nicht umbenennen.

Tabelle kopieren

In diesem Abschnitt wird beschrieben, wie Sie eine vollständige Kopie einer Tabelle erstellen. Informationen zu anderen Arten von Tabellenkopien finden Sie unter Tabellenklone und Tabellen-Snapshots.

Sie können eine Tabelle auf folgenden Wegen kopieren:

  • Verwenden Sie die Konsole.
  • Führen Sie den Befehl bq cp aus.
  • Eine CREATE TABLE COPY-DDL-Anweisung (Data Definition Language, Datendefinitionssprache) verwenden
  • Rufen Sie die API-Methode jobs.insert auf und konfigurieren Sie einen copy-Job.
  • Verwenden Sie die Client-Bibliotheken.

Einschränkungen beim Kopieren von Tabellen

Tabellenkopierjobs unterliegen den folgenden Einschränkungen:

  • Für die Zieltabelle gelten beim Kopieren dieselben Namenskonventionen wie beim Erstellen.
  • Tabellenkopien unterliegen den BigQuery-Limits für Kopierjobs.
  • Wenn Sie die Console zum Kopieren einer Tabelle verwenden, können Sie keine vorhandene Tabelle im Ziel-Dataset überschreiben. Die Tabelle muss im Ziel-Dataset einen eindeutigen Namen haben.
  • Das Ziel-Dataset muss sich am gleichen Standort befinden wie das Dataset mit der kopierten Tabelle. Beispielsweise ist es nicht möglich, eine Tabelle aus einem europäischen Dataset in ein US-amerikanisches Dataset zu kopieren.
  • Das Kopieren mehrerer Quelltabellen in eine Zieltabelle wird von der Console nicht unterstützt.
  • Wenn Sie mehrere Quelltabellen mit der API oder dem bq-Befehlszeilentool in eine Zieltabelle kopieren, müssen alle Quelltabellen identische Schemas haben.
  • Die Zeit, die BigQuery zum Kopieren von Tabellen benötigt, kann in verschiedenen Ausführungen erheblich variieren, da der zugrunde liegende Speicher dynamisch verwaltet wird.

Erforderliche Berechtigungen

Zum Ausführen der Aufgaben in diesem Dokument benötigen Sie die folgenden Berechtigungen.

Berechtigungen zum Kopieren von Tabellen und Partitionen

Zum Kopieren von Tabellen und Partitionen benötigen Sie IAM-Berechtigungen für die Quell- und Ziel-Datasets.

  • Für das Quell-Dataset benötigen Sie Folgendes:

    • bigquery.tables.get
    • bigquery.tables.getData
  • Für das Ziel-Dataset benötigen Sie Folgendes:

    • bigquery.tables.create: Mit dieser Berechtigung können Sie eine Kopie der Tabelle oder Partition im Ziel-Dataset erstellen.

Jede der folgenden vordefinierten IAM-Rollen umfasst die Berechtigungen, die Sie zum Kopieren von Tabellen und Partitionen benötigen:

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin

Berechtigung zum Ausführen eines Kopierjobs

Zum Ausführen eines Kopierjobs benötigen Sie die IAM-Berechtigung bigquery.jobs.create.

Jede der folgenden vordefinierten IAM-Rollen umfasst die Berechtigungen, die Sie zum Ausführen eines Kopierjobs benötigen:

  • roles/bigquery.user
  • roles/bigquery.jobUser
  • roles/bigquery.admin

Wenn Sie die Berechtigung bigquery.datasets.create haben, können Sie außerdem Tabellen und Partitionen in den von Ihnen erstellten Datasets kopieren. Sie benötigen außerdem Zugriff auf das Ziel-Dataset.

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

Tabelle mit einer einzelnen Quelle kopieren

Sie können eine Tabelle auf folgenden Wegen kopieren:

  • Mit der Console
  • Mit dem Befehl bq cp des bq-Befehlszeilentools
  • Durch Senden einer CREATE TABLE COPY-DDL-Anweisung (Data Definition Language, Datendefinitionssprache)
  • Durch Aufrufen der API-Methode jobs.insert, Konfigurieren eines copy-Jobs und Angeben des Attributs sourceTable
  • Mithilfe der Clientbibliotheken

Die Console und die CREATE TABLE COPY-Anweisung unterstützen pro Kopierjob nur eine Quelltabelle und eine Zieltabelle. Sie müssen das bq-Befehlszeilentool oder die API verwenden, um mehrere Quelldateien in eine Zieltabelle zu kopieren.

So kopieren Sie eine einzelne Quelltabelle:

Console

  1. Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.

  2. Klicken Sie im Detailfeld auf Tabelle kopieren.

  3. Im Dialogfeld Copy table (Tabelle kopieren) unter Destination (Ziel):

    • Wählen Sie bei Projektname das Projekt aus, in dem die kopierte Tabelle gespeichert wird.
    • Wählen Sie bei Dataset-Name das Dataset aus, in dem die kopierte Tabelle gespeichert werden soll. Die Quell- und Ziel-Datasets müssen sich am selben Standort befinden.
    • Geben Sie bei Tabellenname einen Namen für die neue Tabelle ein. Der Name darf im Ziel-Dataset nur einmal vorkommen. Sie können eine vorhandene Tabelle im Ziel-Dataset nicht mit der Console überschreiben. Weitere Informationen zu den Anforderungen für Tabellennamen finden Sie unter Tabellennamen.
  4. Klicken Sie auf Kopieren, um den Kopierjob zu starten.

SQL

Verwenden Sie die Anweisung CREATE TABLE COPY, um eine Tabelle mit dem Namen table1 in eine neue Tabelle mit dem Namen table1copy zu kopieren:

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE myproject.mydataset.table1copy
    COPY myproject.mydataset.table1;
    

  3. 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 cp aus. Sie können optionale Flags verwenden, um die Schreibanordnung für die Zieltabelle zu steuern:

  • Mit -a oder --append_table werden die Daten aus der Quelltabelle an eine vorhandene Tabelle im Ziel-Dataset angefügt.
  • -f oder --force überschreibt eine vorhandene Tabelle im Ziel-Dataset, ohne eine Bestätigung von Ihnen anzufordern.
  • Wenn sich die Tabelle im Ziel-Dataset befindet, gibt -n oder --no_clobber die folgende Fehlermeldung aus: Table 'project_id:dataset.table' already exists, skipping.. Wenn -n nicht angegeben ist, werden Sie standardmäßig gefragt, ob die Zieltabelle ersetzt werden soll.
  • --destination_kms_key ist der vom Kunden verwaltete Cloud KMS-Schlüssel, der zum Verschlüsseln der Zieltabelle verwendet wird.

--destination_kms_key wird hier nicht angewendet. Weitere Informationen finden Sie unter Daten mit Cloud KMS-Schlüsseln schützen.

Wenn sich das Quell- oder Ziel-Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie die Projekt-ID im folgenden Format dem Dataset-Namen hinzu: project_id:dataset.

Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

bq --location=location cp \
-a -f -n \
project_id:dataset.source_table \
project_id:dataset.destination_table

Dabei gilt:

  • location: Name Ihres Standorts. Das Flag --location ist optional. Wenn Sie BigQuery z. B. in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei .bigqueryrc können Sie einen Standardwert für den Standort festlegen.
  • project_id: Ihre Projekt-ID.
  • dataset: der Name des Quell- oder Ziel-Datasets.
  • source_table: die Tabelle, die Sie kopieren.
  • destination_table: der Name der Tabelle im Ziel-Dataset.

Beispiele:

Geben Sie den folgenden Befehl ein, um die Tabelle mydataset.mytable in die Tabelle mydataset2.mytable2 zu kopieren. Beide Datasets befinden sich in Ihrem Standardprojekt.

bq cp mydataset.mytable mydataset2.mytable2

Geben Sie den folgenden Befehl ein, um die Tabelle mydataset.mytable zu kopieren und eine Zieltabelle mit demselben Namen zu überschreiben. Das Quell-Dataset befindet sich in Ihrem Standardprojekt. Das Ziel-Dataset befindet sich im Projekt myotherproject. Das Kürzel -f wird verwendet, um die Zieltabelle ohne Eingabeaufforderung zu überschreiben.

bq cp -f \
mydataset.mytable \
myotherproject:myotherdataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabelle mydataset.mytable zu kopieren und einen Fehler zurückzugeben, wenn das Ziel-Dataset eine Tabelle mit demselben Namen enthält. Das Quell-Dataset befindet sich in Ihrem Standardprojekt. Das Ziel-Dataset befindet sich im Projekt myotherproject. Mit dem Kürzel -n wird das Überschreiben einer Tabelle mit demselben Namen verhindert.

bq cp -n \
mydataset.mytable \
myotherproject:myotherdataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabelle mydataset.mytable zu kopieren und die Daten an eine Zieltabelle mit demselben Namen anzufügen. Das Quell-Dataset befindet sich in Ihrem Standardprojekt. Das Ziel-Dataset befindet sich im Projekt myotherproject. Das Kürzel - a wird zum Anfügen an die Zieltabelle verwendet.

bq cp -a mydataset.mytable myotherproject:myotherdataset.mytable

API

Sie können eine vorhandene Tabelle über die API kopieren, indem Sie die Methode bigquery.jobs.insert aufrufen und einen copy-Job konfigurieren. Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.

Geben Sie die folgenden Werte in der Jobkonfiguration an:

"copy": {
      "sourceTable": {       // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "destinationTable": {  // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "createDisposition": string,  // Optional
      "writeDisposition": string,   // Optional
    },

Dabei gilt: Mit sourceTable werden Informationen über die zu kopierende Tabelle und mit destinationTable Informationen über die neue Tabelle bereitgestellt. Mit createDisposition wird angegeben, ob die Tabelle erstellt werden soll, falls sie noch nicht vorhanden ist. Mit writeDisposition wird angegeben, ob eine vorhandene Tabelle überschrieben werden soll oder die Daten an eine vorhandene Tabelle angefügt werden sollen.

C#

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


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCopyTable
{
    public void CopyTable(
        string projectId = "your-project-id",
        string destinationDatasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference sourceTableRef = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        TableReference destinationTableRef = client.GetTableReference(
            destinationDatasetId, "destination_table");
        BigQueryJob job = client.CreateCopyJob(
            sourceTableRef, destinationTableRef)
            .PollUntilCompleted();  // Wait for the job to complete.
        // Retrieve destination table
        BigQueryTable destinationTable = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Copied {destinationTable.Resource.NumRows} rows from table "
            + $"{sourceTableRef.DatasetId}.{sourceTableRef.TableId} "
            + $"to {destinationTable.FullyQualifiedId}."
        );
    }
}

Go

Bevor Sie dieses Beispiel ausprobieren, 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.

import (
	"context"
	"fmt"

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

// copyTable demonstrates copying a table from a source to a destination, and
// allowing the copy to overwrite existing data by using truncation.
func copyTable(projectID, datasetID, srcID, dstID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// srcID := "sourcetable"
	// dstID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	dataset := client.Dataset(datasetID)
	copier := dataset.Table(dstID).CopierFrom(dataset.Table(srcID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

public class CopyTable {

  public static void runCopyTable() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";

    copyTable(sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId);
  }

  public static void copyTable(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId) {
    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 sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable).build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

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

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

async function copyTable() {
  // Copies src_dataset:src_table to dest_dataset:dest_table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const srcDatasetId = "my_src_dataset";
  // const srcTableId = "my_src_table";
  // const destDatasetId = "my_dest_dataset";
  // const destTableId = "my_dest_table";

  // Copy the table contents into another table
  const [job] = await bigquery
    .dataset(srcDatasetId)
    .table(srcTableId)
    .copy(bigquery.dataset(destDatasetId).table(destTableId));

  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $sourceTableId   = 'The BigQuery table ID to copy from';
// $destinationTableId = 'The BigQuery table ID to copy to';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$sourceTable = $dataset->table($sourceTableId);
$destinationTable = $dataset->table($destinationTableId);
$copyConfig = $sourceTable->copy($destinationTable);
$job = $sourceTable->runJob($copyConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Table copied successfully' . PHP_EOL);
}

Python

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


from google.cloud import bigquery

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

# TODO(developer): Set source_table_id to the ID of the original table.
# source_table_id = "your-project.source_dataset.source_table"

# TODO(developer): Set destination_table_id to the ID of the destination table.
# destination_table_id = "your-project.destination_dataset.destination_table"

job = client.copy_table(source_table_id, destination_table_id)
job.result()  # Wait for the job to complete.

print("A copy of the table created.")

Mehrere Quelltabellen kopieren

Sie können auf folgenden Wegen mehrere Quelltabellen in eine Zieltabelle kopieren:

  • Mit dem Befehl bq cp des bq-Befehlszeilentools
  • Durch Aufrufen der Methode jobs.insert, Konfigurieren eines copy-Jobs und Angeben des Attributs sourceTables
  • Mithilfe der Clientbibliotheken

Alle Quelltabellen müssen identische Schemas haben und es ist nur eine Zieltabelle zulässig.

Quelltabellen müssen als eine durch Kommas getrennte Liste angegeben werden. Sie können keine Platzhalter verwenden, wenn Sie mehrere Quelltabellen kopieren.

Wählen Sie eine der folgenden Optionen aus, um mehrere Quelltabellen zu kopieren:

bq

Führen Sie den Befehl bq cp aus und geben Sie in einer durch Kommas getrennten Liste mehrere Quelltabellen an. Sie können optionale Flags verwenden, um die Schreibanordnung für die Zieltabelle zu steuern:

  • Mit -a oder --append_table werden die Daten aus den Quelltabellen an eine vorhandene Tabelle im Ziel-Dataset angefügt.
  • Mit -f oder --force wird eine vorhandene Zieltabelle im Ziel-Dataset überschrieben. Sie werden dabei nicht zur Bestätigung des Vorgangs aufgefordert.
  • Wenn sich die Tabelle im Ziel-Dataset befindet, gibt -n oder --no_clobber die folgende Fehlermeldung aus: Table 'project_id:dataset.table' already exists, skipping.. Wenn -n nicht angegeben ist, werden Sie standardmäßig gefragt, ob die Zieltabelle ersetzt werden soll.
  • --destination_kms_key ist der vom Kunden verwaltete Cloud KMS-Schlüssel, der zum Verschlüsseln der Zieltabelle verwendet wird.

--destination_kms_key wird hier nicht angewendet. Weitere Informationen finden Sie unter Daten mit Cloud KMS-Schlüsseln schützen.

Wenn sich das Quell- oder Ziel-Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie die Projekt-ID im folgenden Format dem Dataset-Namen hinzu: project_id:dataset.

Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

bq --location=location cp \
-a -f -n \
project_id:dataset.source_table,project_id:dataset.source_table \
project_id:dataset.destination_table

Dabei gilt:

  • location: Name Ihres Standorts. Das Flag --location ist optional. Wenn Sie BigQuery z. B. in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei .bigqueryrc können Sie einen Standardwert für den Standort festlegen.
  • project_id: Ihre Projekt-ID.
  • dataset: der Name des Quell- oder Ziel-Datasets.
  • source_table: die Tabelle, die Sie kopieren.
  • destination_table: der Name der Tabelle im Ziel-Dataset.

Beispiele:

Geben Sie den folgenden Befehl ein, um die Tabellen mydataset.mytable und mydataset.mytable2 in die Tabelle mydataset2.tablecopy zu kopieren. Alle Datasets befinden sich in Ihrem Standardprojekt.

bq cp \
mydataset.mytable,mydataset.mytable2 \
mydataset2.tablecopy

Geben Sie den folgenden Befehl ein, um die Tabellen mydataset.mytable und mydataset.mytable2 in die Tabelle myotherdataset.mytable zu kopieren und eine Zieltabelle mit demselben Namen zu überschreiben. Das Ziel-Dataset befindet sich im Projekt myotherproject, nicht im Standardprojekt. Mit dem Kürzel -f wird die Zieltabelle ohne Eingabeaufforderung überschrieben.

bq cp -f \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabellen myproject:mydataset.mytable und myproject:mydataset.mytable2 zu kopieren. Wenn das Ziel-Dataset eine Tabelle mit demselben Namen enthält, wird eine Fehlermeldung zurückgegeben: Das Ziel-Dataset befindet sich im Projekt myotherproject. Mit dem Kürzel -n wird das Überschreiben einer Tabelle mit demselben Namen verhindert.

bq cp -n \
myproject:mydataset.mytable,myproject:mydataset.mytable2 \
myotherproject:myotherdataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabellen mydataset.mytable und mydataset.mytable2 zu kopieren und die Daten an eine Zieltabelle mit demselben Namen anzufügen. Das Quell-Dataset befindet sich in Ihrem Standardprojekt. Das Ziel-Dataset befindet sich im Projekt myotherproject. Das Kürzel -a wird zum Anfügen an die Zieltabelle verwendet.

bq cp -a \
mydataset.mytable,mydataset.mytable2 \
myotherproject:myotherdataset.mytable

API

Wenn Sie mehrere Tabellen mit der API kopieren möchten, rufen Sie die Methode jobs.insert auf, konfigurieren Sie einen copy-Tabellenjob und geben Sie das Attribut sourceTables an.

Geben Sie Ihre Region im Abschnitt jobReference der Jobressource im Attribut location an.

Go

Bevor Sie dieses Beispiel ausprobieren, 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.

import (
	"context"
	"fmt"

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

// copyMultiTable demonstrates using a copy job to copy multiple source tables into a single destination table.
func copyMultiTable(projectID, srcDatasetID string, srcTableIDs []string, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// srcDatasetID := "sourcedataset"
	// srcTableIDs := []string{"table1","table2"}
	// dstDatasetID = "destinationdataset"
	// dstTableID = "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcDataset := client.Dataset(srcDatasetID)
	dstDataset := client.Dataset(dstDatasetID)
	var tableRefs []*bigquery.Table
	for _, v := range srcTableIDs {
		tableRefs = append(tableRefs, srcDataset.Table(v))
	}
	copier := dstDataset.Table(dstTableID).CopierFrom(tableRefs...)
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;
import java.util.Arrays;

public class CopyMultipleTables {

  public static void runCopyMultipleTables() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DATASET_NAME";
    String destinationTableId = "MY_TABLE_NAME";
    copyMultipleTables(destinationDatasetName, destinationTableId);
  }

  public static void copyMultipleTables(String destinationDatasetName, String destinationTableId) {
    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 destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  destinationTable,
                  Arrays.asList(
                      TableId.of(destinationDatasetName, "table1"),
                      TableId.of(destinationDatasetName, "table2")))
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy tables due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben 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 copyTableMultipleSource() {
  // Copy multiple source tables to a given destination.

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

  // Create a client
  const dataset = bigquery.dataset(datasetId);

  const metadata = {
    createDisposition: 'CREATE_NEVER',
    writeDisposition: 'WRITE_TRUNCATE',
  };

  // Create table references
  const table = dataset.table(sourceTable);
  const yourTable = dataset.table(destinationTable);

  // Copy table
  const [apiResponse] = await table.copy(yourTable, metadata);
  console.log(apiResponse.configuration.copy);
}

Python

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


from google.cloud import bigquery

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

# TODO(developer): Set dest_table_id to the ID of the destination table.
# dest_table_id = "your-project.your_dataset.your_table_name"

# TODO(developer): Set table_ids to the list of the IDs of the original tables.
# table_ids = ["your-project.your_dataset.your_table_name", ...]

job = client.copy_table(table_ids, dest_table_id)  # Make an API request.
job.result()  # Wait for the job to complete.

print("The tables {} have been appended to {}".format(table_ids, dest_table_id))

Tabellen löschen

Sie können eine Tabelle auf folgenden Wegen löschen:

  • Mit der Console
  • Durch Senden einer DROP TABLE-DDL-Anweisung (Data Definition Language, Datendefinitionssprache)
  • Mit dem Befehl bq rm des bq-Befehlszeilentools
  • Durch Aufruf der API-Methode tables.delete
  • Mithilfe der Clientbibliotheken

Derzeit können Sie nur eine Tabelle auf einmal löschen.

Wenn Sie eine Tabelle löschen, werden die Daten in der Tabelle ebenfalls gelöscht. Sie können festlegen, dass Tabellen nach einem bestimmten Zeitraum automatisch gelöscht werden. Legen Sie dazu den Standard-Tabellenablauf für das Dataset fest oder geben Sie beim Erstellen der Tabelle die Ablaufzeit ein.

Erforderliche Berechtigungen

Zum Löschen einer Tabelle benötigen Sie die folgenden IAM-Berechtigungen:

  • bigquery.tables.delete
  • bigquery.tables.get

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

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin

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

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

Tabelle löschen

So löschen Sie eine Tabelle:

Console

  1. Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.

  2. Klicken Sie im Detailbereich auf Tabelle löschen.

  3. Geben Sie "delete" in das Dialogfeld ein und klicken Sie zur Bestätigung auf Löschen.

SQL

Verwenden Sie die Anweisung DROP TABLE. Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable gelöscht:

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    DROP TABLE mydataset.mytable;
    

  3. Klicken Sie auf Ausführen.

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

bq

Verwenden Sie den Befehl bq rm mit dem Flag --table (oder dem Kürzel -t), um eine Tabelle zu löschen. Wenn Sie eine Tabelle mit dem bq-Befehlszeilentool entfernen, müssen Sie die Aktion bestätigen. Sie können das Flag --force (oder das Kürzel -f) zum Überspringen der Bestätigung verwenden.

Wenn sich die Tabelle in einem Dataset eines anderen Projekts als dem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

bq rm \
-f \
-t \
project_id:dataset.table

Dabei gilt:

  • project_id: Ihre Projekt-ID
  • dataset: der Name des Datasets, das die Tabelle enthält
  • table: der Name der Tabelle, die Sie löschen

Beispiele:

Geben Sie den folgenden Befehl ein, um die Tabelle mytable aus dem Dataset mydataset zu löschen. Das Dataset mydataset befindet sich in Ihrem Standardprojekt.

bq rm -t mydataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabelle mytable aus dem Dataset mydataset zu löschen. Das Dataset mydataset befindet sich im Projekt myotherproject, nicht in Ihrem Standardprojekt.

bq rm -t myotherproject:mydataset.mytable

Geben Sie den folgenden Befehl ein, um die Tabelle mytable aus dem Dataset mydataset zu löschen. Das Dataset mydataset befindet sich in Ihrem Standardprojekt. Durch das Kürzel -f in diesem Befehl wird die Bestätigung übersprungen.

bq rm -f -t mydataset.mytable

API

Rufen Sie die API-Methode tables.delete auf und legen Sie mit dem Parameter tableId die zu löschende Tabelle fest.

C#

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


using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryDeleteTable
{
    public void DeleteTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        client.DeleteTable(datasetId, tableId);
        Console.WriteLine($"Table {tableId} deleted.");
    }
}

Go

Bevor Sie dieses Beispiel ausprobieren, 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.

import (
	"context"
	"fmt"

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

// deleteTable demonstrates deletion of a BigQuery table.
func deleteTable(projectID, datasetID, tableID 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()

	table := client.Dataset(datasetID).Table(tableID)
	if err := table.Delete(ctx); err != nil {
		return err
	}
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

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

public class DeleteTable {

  public static void runDeleteTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    deleteTable(datasetName, tableName);
  }

  public static void deleteTable(String datasetName, String tableName) {
    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();
      boolean success = bigquery.delete(TableId.of(datasetName, tableName));
      if (success) {
        System.out.println("Table deleted successfully");
      } else {
        System.out.println("Table was not found");
      }
    } catch (BigQueryException e) {
      System.out.println("Table was not deleted. \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben 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 deleteTable() {
  // Deletes "my_table" from "my_dataset".

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

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$table->delete();
printf('Deleted table %s.%s' . PHP_EOL, $datasetId, $tableId);

Python

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


from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the table to fetch.
# table_id = 'your-project.your_dataset.your_table'

# If the table does not exist, delete_table raises
# google.api_core.exceptions.NotFound unless not_found_ok is True.
client.delete_table(table_id, not_found_ok=True)  # Make an API request.
print("Deleted table '{}'.".format(table_id))

Ruby

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

require "google/cloud/bigquery"

def delete_table dataset_id = "my_dataset_id", table_id = "my_table_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table    = dataset.table table_id

  table.delete

  puts "Table #{table_id} deleted."
end

Gelöschte Tabellen wiederherstellen

Sie können eine Tabelle innerhalb des für das Dataset angegebenen Zeitreisefensters wiederherstellen, einschließlich expliziter und impliziter Löschungen aufgrund des Ablaufs einer Tabelle. Die Möglichkeit, das Zeitreisefenster zu konfigurieren, befindet sich in der Vorschau.

Das Zeitreisefenster kann zwischen zwei und sieben Tagen liegen. Nach Ablauf des Zeitreisefensters ist es nicht mehr möglich, eine Tabelle wiederherzustellen, weder durch das Öffnen eines Support-Tickets noch durch andere Methoden.

Wenn Sie eine partitionierte Tabelle wiederherstellen, die gelöscht wurde, weil sie abgelaufen ist, müssen Sie die Partitionen manuell neu erstellen.

Sie können eine Tabelle wiederherstellen, die gelöscht wurde, aber sich noch innerhalb des Zeitreisefensters befindet. Kopieren Sie dazu die Tabelle mit dem Zeit-Decorator @<time> in eine neue Tabelle. Zum Kopieren der Tabelle können Sie das bq-Befehlszeilentool oder die Clientbibliotheken verwenden:

Console

In der Console können gelöschte Tabellen nicht wiederhergestellt werden.

bq

Verwenden Sie einen Tabellen-Kopiervorgang mit dem Snapshot-Decorator @<time>, um eine Tabelle wiederherzustellen. Ermitteln Sie zuerst einen UNIX-Zeitstempel in Millisekunden für die Zeit, in der die Tabelle existiert hat. Verwenden Sie dann den Befehl bq copy mit dem Snapshot-Decorator.

Geben Sie beispielsweise den folgenden Befehl ein, um die Tabelle mydataset.mytable zum Zeitpunkt 1418864998000 in die neue Tabelle mydataset.newtable zu kopieren.

bq cp mydataset.mytable@1418864998000 mydataset.newtable

Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

Sie können auch ein relatives Offset angeben. Im folgenden Beispiel wird die Version einer Tabelle von vor einer Stunde kopiert:

bq cp mydataset.mytable@-3600000 mydataset.newtable

Weitere Informationen finden Sie unter Tabelle auf dem Stand eines bestimmten Zeitpunkts wiederherstellen.

Go

import (
	"context"
	"fmt"
	"time"

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

// deleteAndUndeleteTable demonstrates how to recover a deleted table by copying it from a point in time
// that predates the deletion event.
func deleteAndUndeleteTable(projectID, datasetID, tableID 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()

	ds := client.Dataset(datasetID)
	if _, err := ds.Table(tableID).Metadata(ctx); err != nil {
		return err
	}
	// Record the current time.  We'll use this as the snapshot time
	// for recovering the table.
	snapTime := time.Now()

	// "Accidentally" delete the table.
	if err := client.Dataset(datasetID).Table(tableID).Delete(ctx); err != nil {
		return err
	}

	// Construct the restore-from tableID using a snapshot decorator.
	snapshotTableID := fmt.Sprintf("%s@%d", tableID, snapTime.UnixNano()/1e6)
	// Choose a new table ID for the recovered table data.
	recoverTableID := fmt.Sprintf("%s_recovered", tableID)

	// Construct and run a copy job.
	copier := ds.Table(recoverTableID).CopierFrom(ds.Table(snapshotTableID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}

	ds.Table(recoverTableID).Delete(ctx)
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, 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.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to undeleting a table
public class UndeleteTable {

  public static void runUndeleteTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_TABLE";
    String recoverTableName = "MY_RECOVER_TABLE_TABLE";
    undeleteTable(datasetName, tableName, recoverTableName);
  }

  public static void undeleteTable(String datasetName, String tableName, String recoverTableName) {
    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();

      // "Accidentally" delete the table.
      bigquery.delete(TableId.of(datasetName, tableName));

      // Record the current time.  We'll use this as the snapshot time
      // for recovering the table.
      long snapTime = System.currentTimeMillis();

      // Construct the restore-from tableID using a snapshot decorator.
      String snapshotTableId = String.format("%s@%d", tableName, snapTime);

      // Construct and run a copy job.
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  // Choose a new table ID for the recovered table data.
                  TableId.of(datasetName, recoverTableName),
                  TableId.of(datasetName, snapshotTableId))
              .build();

      Job job = bigquery.create(JobInfo.of(configuration));
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("Undelete table recovered successfully.");
      } else {
        System.out.println(
            "BigQuery was unable to copy the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table not found. \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben 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 undeleteTable() {
  // Undeletes "my_table_to_undelete" from "my_dataset".

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

  /**
   * TODO(developer): Choose an appropriate snapshot point as epoch milliseconds.
   * For this example, we choose the current time as we're about to delete the
   * table immediately afterwards.
   */
  const snapshotEpoch = Date.now();

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);

  // Construct the restore-from table ID using a snapshot decorator.
  const snapshotTableId = `${tableId}@${snapshotEpoch}`;

  // Construct and run a copy job.
  await bigquery
    .dataset(datasetId)
    .table(snapshotTableId)
    .copy(bigquery.dataset(datasetId).table(recoveredTableId));

  console.log(
    `Copied data from deleted table ${tableId} to ${recoveredTableId}`
  );
}

Python

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

import time

from google.cloud import bigquery

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

# TODO(developer): Choose a table to recover.
# table_id = "your-project.your_dataset.your_table"

# TODO(developer): Choose a new table ID for the recovered table data.
# recovered_table_id = "your-project.your_dataset.your_table_recovered"

# TODO(developer): Choose an appropriate snapshot point as epoch
# milliseconds. For this example, we choose the current time as we're about
# to delete the table immediately afterwards.
snapshot_epoch = int(time.time() * 1000)

# ...

# "Accidentally" delete the table.
client.delete_table(table_id)  # Make an API request.

# Construct the restore-from table ID using a snapshot decorator.
snapshot_table_id = "{}@{}".format(table_id, snapshot_epoch)

# Construct and run a copy job.
job = client.copy_table(
    snapshot_table_id,
    recovered_table_id,
    # Must match the source and destination tables location.
    location="US",
)  # Make an API request.

job.result()  # Wait for the job to complete.

print(
    "Copied data from deleted table {} to {}".format(table_id, recovered_table_id)
)

Wenn Sie davon ausgehen, dass Sie eine Tabelle später wiederherstellen möchten, als dies durch das Zeitreisefenster zulässig ist, erstellen Sie einen Tabellen-Snapshot der Tabelle. Weitere Informationen finden Sie unter Tabellen-Snapshots.

Tabellensicherheit

Informationen zum Steuern des Zugriffs auf Tabellen in BigQuery finden Sie unter Einführung in die Tabellenzugriffssteuerung.

Nächste Schritte