Tabellendaten exportieren

Auf dieser Seite wird gezeigt, wie Sie Daten aus BigQuery-Tabellen exportieren oder extrahieren.

Nach dem Laden der Daten in BigQuery können Sie die Daten in verschiedene Formate exportieren. BigQuery kann bis zu 1 GB Daten in eine einzige Datei exportieren. Wenn Sie mehr als 1 GB Daten exportieren möchten, müssen Sie dafür mehrere Dateien verwenden. Wenn Sie Daten in mehrere Dateien exportieren, kann die Größe der Dateien variieren.

Anstatt Daten manuell zu exportieren, können Sie auch einen Dienst wie Dataflow verwenden, um Daten aus BigQuery zu lesen. Weitere Informationen dazu, wie Sie Dataflow zum Lesen und Schreiben in BigQuery verwenden, finden Sie in der Apache Beam-Dokumentation unter BigQuery-E/A.

Erforderliche Berechtigungen

Zum Exportieren von Daten in Cloud Storage benötigen Sie Berechtigungen für den Zugriff auf die BigQuery-Tabelle mit den Daten, für das Ausführen eines Exportjobs und für das Schreiben der Daten in den Cloud Storage-Bucket.

BigQuery-Berechtigungen

  • Zum Exportieren von Daten müssen Sie mindestens Berechtigungen vom Typ bigquery.tables.export haben. Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ bigquery.tables.export:

    • bigquery.dataViewer
    • bigquery.dataOwner
    • bigquery.dataEditor
    • bigquery.admin
  • Zum Ausführen eines Exportjobs benötigen Sie Berechtigungen vom Typ bigquery.jobs.create. Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ bigquery.jobs.create:

    • bigquery.user
    • bigquery.jobUser
    • bigquery.admin

Cloud Storage-Berechtigungen

  • Zum Schreiben von Daten in einen vorhandenen Cloud Storage-Bucket benötigen Sie die Berechtigungen storage.objects.create und storage.objects.delete. Die folgenden vordefinierten IAM-Rollen gewähren beide Berechtigungen:

    • storage.objectAdmin
    • storage.admin

Exportbeschränkungen

Beim Export von Daten aus BigQuery sollten Sie Folgendes beachten:

  • Tabellendaten können nicht in eine lokale Datei, nicht in Tabellen und nicht in Drive exportiert werden. Der einzige unterstützte Exportspeicherort ist Cloud Storage. Informationen zum Speichern von Abfrageergebnissen finden Sie unter Abfrageergebnisse herunterladen und speichern.
  • Sie können bis zu 1 GB Tabellendaten in eine einzige Datei exportieren. Wenn Sie mehr als 1 GB Daten exportieren, verwenden Sie einen Platzhalter, um die Daten in mehrere Dateien zu exportieren. Wenn Sie Daten in mehrere Dateien exportieren, variiert die Größe der Dateien.
  • Verschachtelte und wiederkehrende Daten können nicht im CSV-Format exportiert werden. Verschachtelte und wiederkehrende Daten werden für Avro- und JSON-Exporte unterstützt.
  • Beim Exportieren von Daten in das JSON-Format werden INT64-Datentypen (Ganzzahl) als JSON-Strings codiert, um die 64-Bit-Genauigkeit beizubehalten, wenn die Daten von anderen Systemen gelesen werden.
  • Daten aus mehreren Tabellen können nicht mit einem einzelnen Exportjob exportiert werden.
  • Beim Exportieren von Daten mit der Cloud Console oder der klassischen BigQuery-Web-UI kann nur der Komprimierungstyp GZIP ausgewählt werden.

Überlegungen zum Standort

Bei der Auswahl eines Speicherorts für Ihre Daten sollten Sie Folgendes beachten:

  • Platzieren Sie die Cloud Storage-Buckets zum Exportieren von Daten am selben Standort wie das Dataset:
    • Wenn Sie Daten exportieren, muss sich der regionale oder multiregionale Cloud Storage-Bucket am selben Standort wie das BigQuery-Dataset befinden. Wenn sich Ihr BigQuery-Dataset zum Beispiel am multiregionalen Standort "EU" befindet, muss sich der Cloud Storage-Bucket mit den Daten, die Sie exportieren, an einem regionalen oder multiregionalen Standort in der EU befinden.
    • Wenn sich Ihr Dataset an einem regionalen Standort befindet, muss der Cloud Storage-Bucket ein regionaler Bucket am selben Standort sein. Wenn sich Ihr Dataset zum Beispiel in der Region "Tokio" befindet, muss der Cloud Storage-Bucket ein regionaler Bucket in Tokio sein.
    • Ausnahme: Wenn sich Ihr Dataset am multiregionalen Standort "US" befindet, können Sie Daten in einen Cloud Storage-Bucket exportieren, der sich an einem beliebigen regionalen oder multiregionalen Standort befindet.
  • Entwickeln Sie einen Plan zur Datenverwaltung:
    • Wenn Sie eine regionale Speicherressource wie ein BigQuery-Dataset oder einen Cloud Storage-Bucket auswählen, müssen Sie einen Plan für die geografische Verwaltung Ihrer Daten erstellen.

Weitere Informationen zu Cloud Storage-Standorten finden Sie unter Bucket-Standorte in der Cloud Storage-Dokumentation.

BigQuery-Daten zwischen Standorten verschieben

Der Standort eines Datasets lässt sich nach seiner Erstellung nicht mehr ändern. Sie können aber eine Kopie des Datasets anlegen. Ein Dataset lässt sich auch nicht von einem Standort an einen anderen verschieben. Sie haben jedoch die Möglichkeit, ein Dataset manuell zu verschieben, d. h. neu zu erstellen.

Datasets kopieren

Unter Datasets kopieren erfahren Sie, wie Sie ein Dataset kopieren, auch regionenübergreifend.

Dataset verschieben

Wenn Sie ein Dataset manuell von einem Standort an einen anderen verschieben möchten, gehen Sie so vor:

  1. Sie exportieren die Daten aus Ihren BigQuery-Tabellen in einen regionalen oder multiregionalen Cloud Storage-Bucket, der sich am selben Standort wie das Dataset befindet. Wenn sich Ihr Dataset zum Beispiel am multiregionalen Standort "EU" befindet, exportieren Sie Ihre Daten in einen regionalen oder multiregionalen Bucket in der EU.

    Beim Exportieren von Daten aus BigQuery fallen keine Gebühren an. Dagegen wird das Speichern der exportierten Daten in Cloud Storage in Rechnung gestellt. BigQuery-Exporte unterliegen den Limits für Exportjobs.

  2. Sie kopieren oder verschieben die Daten aus Ihrem Cloud Storage-Bucket in einen regionalen oder multiregionalen Bucket am neuen Standort. Wenn Sie zum Beispiel Ihre Daten vom multiregionalen Standort "US" an den regionalen Standort "Tokio" verschieben, werden die Daten in einen regionalen Bucket in Tokio übertragen. Weitere Informationen zum Übertragen von Cloud Storage-Objekten finden Sie in der Cloud Storage-Dokumentation unter Objekte umbenennen, kopieren und verschieben.

    Beachten Sie, dass beim Übertragen von Daten zwischen Regionen Gebühren für ausgehenden Netzwerktraffic in Cloud Storage anfallen.

  3. Nachdem Sie die Daten in einen Cloud Storage-Bucket am neuen Standort übertragen haben, erstellen Sie dort ein neues BigQuery-Dataset. Laden Sie Ihre Daten dann aus dem Cloud Storage-Bucket in BigQuery.

    Beim Laden der Daten in BigQuery fallen keine Kosten an. Das gilt jedoch nicht für das Speichern von Daten in Cloud Storage. Hier werden Gebühren berechnet, bis Sie die Daten oder den Bucket löschen. Es fallen außerdem Kosten an, wenn Sie die Daten in BigQuery speichern, nachdem sie geladen wurden. Das Laden von Daten in BigQuery unterliegt den Limits für Ladejobs.

Sie können auch Cloud Composer verwenden, um große Datasets programmatisch zu verschieben und zu kopieren.

Weitere Informationen zur Verwendung von Cloud Storage für das Speichern und Verschieben großer Datasets finden Sie unter Cloud Storage mit Big Data verwenden.

Exportformate und Komprimierungstypen

BigQuery unterstützt die folgenden Datenformate und Komprimierungstypen für exportierte Daten.

Datenformat Unterstützte Komprimierungstypen Details
CSV GZIP

Sie können das CSV-Trennzeichen in Ihren exportierten Daten mit dem Flag --field_delimiter des bq-Befehlszeilentools oder mit dem Attribut configuration.extract.fieldDelimiter für den Extrahierungsjob steuern.

Verschachtelte und wiederkehrende Daten werden nicht unterstützt.

JSON GZIP Verschachtelte und wiederkehrende Daten werden unterstützt.
Avro DEFLATE, SNAPPY

GZIP wird für Avro-Exporte nicht unterstützt.

Verschachtelte und wiederkehrende Daten werden unterstützt.

In BigQuery gespeicherte Daten exportieren

Sie können Tabellendaten mit den folgenden Methoden exportieren:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq extract im bq-Befehlszeilentool
  • Durch Senden eines extract-Jobs über die API oder die Clientbibliotheken

Tabellendaten exportieren

So exportieren Sie Daten aus einer BigQuery-Tabelle:

Console

  1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
    Zur Cloud Console

  2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und klicken Sie dann zum Maximieren auf Ihr Dataset. Klicken Sie auf die Tabelle mit den Daten, die Sie exportieren möchten.

  3. Klicken Sie auf der rechten Seite des Fensters auf Exportieren und wählen Sie Nach Google Cloud Storage exportieren aus

    Daten exportieren

  4. Gehen Sie im Dialogfeld Nach Google Cloud Storage exportieren folgendermaßen vor:

    • Wählen Sie für Google Cloud Storage-Speicherort auswählen den Bucket, Ordner oder die Datei aus, in den bzw. die Sie die Daten exportieren möchten.
    • Wählen Sie als Exportformat das Format für die exportierten Daten aus: CSV, JSON (durch Zeilenumbruch getrennt) oder Avro.
    • Übernehmen Sie unter Komprimierung den Standardwert None oder wählen Sie GZIP aus. Das Avro-Format kann nicht in Verbindung mit der GZIP-Komprimierung verwendet werden. Komprimieren Sie Avro-Daten mit dem bq-Befehlszeilentool oder mit der API und geben Sie dafür einen der unterstützten Komprimierungstypen für Avro-Daten an: DEFLATE oder SNAPPY.
    • Klicken Sie auf Exportieren, um die Tabelle zu exportieren.

Für einen Exportjob können Sie unter Jobverlauf oben in der Navigation den Status des Jobs überprüfen.

Klassische UI

  1. Rufen Sie die BigQuery-Web-UI auf.
    Zur BigQuery-Web-UI

  2. Klicken Sie im Navigationsbereich auf Ihr Dataset, um es zu maximieren.

  3. Klicken Sie auf den Abwärtspfeil Abwärtspfeilsymbol neben der Tabelle mit den Daten, die exportiert werden sollen.

  4. Wählen Sie Tabelle exportieren aus, um das Dialogfeld Nach Google Cloud Storage exportieren anzuzeigen.

  5. Gehen Sie im Dialogfeld Nach Google Cloud Storage exportieren folgendermaßen vor:

    • Wählen Sie als Exportformat das Format für die exportierten Daten aus: CSV, JSON (durch Zeilenumbruch getrennt) oder Avro.
    • Übernehmen Sie unter Komprimierung den Standardwert None oder wählen Sie GZIP aus. Das Avro-Format kann nicht in Verbindung mit der GZIP-Komprimierung verwendet werden. Komprimieren Sie Avro-Daten mit dem bq-Befehlszeilentool oder mit der API und geben Sie dafür einen der unterstützten Komprimierungstypen für Avro-Daten an: DEFLATE oder SNAPPY.
    • Geben Sie im Textfeld Google Cloud Storage-URI einen gültigen URI im Format gs://bucket_name/filename.ext ein, wobei bucket_name der Name des Cloud Storage-Buckets ist und filename.ext für den Namen und die Erweiterung der Zieldatei steht. Das BigQuery-Dataset und der Cloud Storage-Bucket müssen sich am selben Standort befinden.
    • Klicken Sie auf OK, um die Tabelle zu exportieren.

Während der Job ausgeführt wird, wird neben dem Namen der Tabelle im Navigationsbereich (Extrahieren läuft) angezeigt. Suchen Sie weiter oben im Navigationsbereich unter Jobverlauf nach einem Extrahierungsjob, um den Fortschritt des Jobs zu prüfen.

bq

Führen Sie den Befehl bq extract mit dem Flag --destination_format aus.

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

Andere optionale Flags sind:

  • --compression: Der Komprimierungstyp, der für exportierte Dateien verwendet werden soll.
  • --field_delimiter: Das Zeichen, das die Begrenzung zwischen den Spalten in der Ausgabedatei für CSV-Exporte angibt. Es kann sowohl \t als auch tab als Tabulatortrennzeichen verwendet werden.
  • --print_header: Wenn dieses Flag angegeben ist, werden bei Formaten mit Headern wie CSV entsprechende Kopfzeilen ausgegeben.
bq --location=location extract \
--destination_format format \
--compression compression_type \
--field_delimiter delimiter \
--print_header=boolean \
project_id:dataset.table \
gs://bucket/filename.ext

Dabei gilt:

  • location ist der Name Ihres Standorts. Das Flag --location ist optional. Wenn Sie BigQuery beispielsweise in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei ".bigqueryrc" lässt sich für den Standort ein Standardwert angeben.
  • format ist das Format für die exportierten Daten: CSV, NEWLINE_DELIMITED_JSON oder AVRO.
  • compression_type ist ein unterstützter Komprimierungstyp für das Datenformat. CSV und NEWLINE_DELIMITED_JSON unterstützen GZIP. AVRO unterstützt DEFLATE und SNAPPY.
  • delimiter ist das Trennzeichen für Spalten in CSV-Exporten. \t und tab sind akzeptierte Namen für das Tabulatorzeichen.
  • boolean ist true oder false. Wenn true festgelegt ist, werden Header an die exportierten Daten ausgegeben, sofern das Datenformat Header unterstützt. Der Standardwert ist true.
  • project_id ist die Projekt-ID.
  • dataset ist der Name des Quell-Datasets.
  • table ist die Tabelle, die Sie exportieren.
  • bucket ist der Name des Cloud Storage-Buckets, in den Sie Daten exportieren. Das BigQuery-Dataset und der Cloud Storage-Bucket müssen sich am selben Standort befinden.
  • filename.ext ist der Name und die Erweiterung der exportierten Datendatei. Mit einem Platzhalter können Sie in mehrere Dateien exportieren.

Beispiele:

Mit dem folgenden Befehl wird beispielsweise mydataset.mytable in eine komprimierte GZIP-Datei mit dem Namen myfile.csv exportiert. Die Datei myfile.csv wird in einem Cloud Storage-Bucket namens example-bucket gespeichert.

bq extract \
--compression GZIP \
'mydataset.mytable' \
gs://example-bucket/myfile.csv

Das Standardzielformat ist CSV. Für Exporte in eine JSON- oder Avro-Datei verwenden Sie das Flag destination_format und legen dafür NEWLINE_DELIMITED_JSON oder AVRO fest.

bq extract \
--destination_format NEWLINE_DELIMITED_JSON \
'mydataset.mytable' \
gs://example-bucket/myfile.json

Mit dem folgenden Befehl wird mydataset.mytable in eine mit Snappy komprimierte Avro-Datei exportiert. Der Name der Datei lautet myfile.avro. myfile.avro wird in einen Cloud Storage-Bucket namens example-bucket exportiert.

bq extract \
--destination_format AVRO \
--compression SNAPPY \
'mydataset.mytable' \
gs://example-bucket/myfile.avro

API

Zum Exportieren von Daten erstellen Sie einen extract-Job und legen dafür die Jobkonfiguration fest.

Optional: Geben Sie im Attribut location im Abschnitt jobReference der Jobressource Ihren Standort an.

  1. Erstellen Sie einen Extrahierungsjob, der auf die BigQuery-Quelldaten und auf das Cloud Storage-Ziel verweist.

  2. Geben Sie die Quelltabelle mithilfe des Konfigurationsobjekts sourceTable an, das die Projekt-ID, die Dataset-ID und die Tabellen-ID enthält.

  3. Das Attribut destination URI(s) muss vollständig qualifiziert sein und das Format gs://bucket/filename.ext haben. Jeder URI kann genau ein Platzhalterzeichen (*) enthalten, das nach dem Bucket-Namen stehen muss.

  4. Geben Sie das Datenformat an. Legen Sie dazu das Attribut configuration.extract.destinationFormat fest. Geben Sie beispielsweise für dieses Attribut für den Export einer JSON-Datei den Wert NEWLINE_DELIMITED_JSON an.

  5. Rufen Sie zur Prüfung des Jobstatus jobs.get(job_id) mit der ID des Jobs auf, die von der ursprünglichen Anfrage zurückgegeben wurde.

    • Wenn status.state = DONE zurückgegeben wird, wurde der Job erfolgreich abgeschlossen.
    • Wenn das Attribut status.errorResult zurückgegeben wird, ist die Anfrage fehlgeschlagen. Das Objekt enthält in diesem Fall Angaben zur Fehlerursache.
    • Wenn status.errorResult nicht zurückgegeben wird, wurde der Job erfolgreich abgeschlossen. Es können aber nichtsdestotrotz einige nicht schwerwiegende Fehler aufgetreten sein. Nicht schwerwiegende Fehler werden im Attribut status.errors des Objekts des zurückgegebenen Jobs aufgeführt.

API-Hinweise:

  • Als Best Practice generieren Sie eine nur einmal vorkommende ID und übergeben sie als jobReference.jobId, wenn Sie jobs.insert zum Erstellen eines Ladejobs aufrufen. Diese Vorgehensweise ist weniger anfällig für Netzwerkfehler, da der Client anhand der bekannten Job-ID einen Abruf oder einen neuen Versuch ausführen kann.

  • Das Aufrufen von jobs.insert für eine bestimmte Job-ID ist idempotent. Das bedeutet, dass Sie den Aufruf für eine bestimmte Job-ID beliebig oft wiederholen können. Maximal einer dieser Vorgänge wird erfolgreich sein.

C#

Bevor Sie dieses Beispiel anwenden, 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 BigQueryExtractTable
{
    public void ExtractTable(
        string projectId = "your-project-id",
        string bucketName = "your-bucket-name")
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Define a destination URI. Use a single wildcard URI if you think
        // your exported data will be larger than the 1 GB maximum value.
        string destinationUri = $"gs://{bucketName}/shakespeare-*.csv";
        BigQueryJob job = client.CreateExtractJob(
            projectId: "bigquery-public-data",
            datasetId: "samples",
            tableId: "shakespeare",
            destinationUri: destinationUri
        );
        job = job.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        Console.Write($"Exported table to {destinationUri}.");
    }
}

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

// exportTableAsCompressedCSV demonstrates using an export job to
// write the contents of a table into Cloud Storage as CSV.
func exportTableAsCSV(projectID, gcsURI string) error {
	// projectID := "my-project-id"
	// gcsUri := "gs://mybucket/shakespeare.csv"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcProject := "bigquery-public-data"
	srcDataset := "samples"
	srcTable := "shakespeare"

	gcsRef := bigquery.NewGCSReference(gcsURI)
	gcsRef.FieldDelimiter = ","

	extractor := client.DatasetInProject(srcProject, srcDataset).Table(srcTable).ExtractorTo(gcsRef)
	extractor.DisableHeader = true
	// You can choose to run the job in a specific location for more complex data locality scenarios.
	// Ex: In this example, source dataset and GCS bucket are in the US.
	extractor.Location = "US"

	job, err := extractor.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 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.

import com.google.cloud.RetryOption;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;
import org.threeten.bp.Duration;

public class ExtractTableToCsv {

  public static void runExtractTableToCsv() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    String bucketName = "my-bucket";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    // For more information on export formats available see:
    // https://cloud.google.com/bigquery/docs/exporting-data#export_formats_and_compression_types
    // For more information on Job see:
    // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html

    String dataFormat = "CSV";
    extractTableToCsv(projectId, datasetName, tableName, destinationUri, dataFormat);
  }

  // Exports datasetName:tableName to destinationUri as raw CSV
  public static void extractTableToCsv(
      String projectId,
      String datasetName,
      String tableName,
      String destinationUri,
      String dataFormat) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);

      Job job = table.extract(dataFormat, destinationUri);

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob =
          job.waitFor(
              RetryOption.initialRetryDelay(Duration.ofSeconds(1)),
              RetryOption.totalTimeout(Duration.ofMinutes(3)));
      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 extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println(
          "Table export successful. Check in GCS bucket for the " + dataFormat + " file.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \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 libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

const bigquery = new BigQuery();
const storage = new Storage();

async function extractTableToGCS() {
  // Exports my_dataset:my_table to gcs://my-bucket/my-file as raw CSV.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const bucketName = "my-bucket";
  // const filename = "file.csv";

  // Location must match that of the source table.
  const options = {
    location: 'US',
  };

  // Export data from the table into a Google Cloud Storage file
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .extract(storage.bucket(bucketName).file(filename), options);

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

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

PHP

Bevor Sie dieses Beispiel anwenden, 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';
// $bucketName = 'The Cloud Storage bucket Name';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$destinationUri = "gs://{$bucketName}/{$tableId}.json";
// Define the format to use. If the format is not specified, 'CSV' will be used.
$format = 'NEWLINE_DELIMITED_JSON';
// Create the extract job
$extractConfig = $table->extract($destinationUri)->destinationFormat($format);
// Run the job
$job = $table->runJob($extractConfig);  // Waits for the job to complete
printf('Exported %s to %s' . PHP_EOL, $table->id(), $destinationUri);

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.

# from google.cloud import bigquery
# client = bigquery.Client()
# bucket_name = 'my-bucket'
project = "bigquery-public-data"
dataset_id = "samples"
table_id = "shakespeare"

destination_uri = "gs://{}/{}".format(bucket_name, "shakespeare.csv")
dataset_ref = bigquery.DatasetReference(project, dataset_id)
table_ref = dataset_ref.table(table_id)

extract_job = client.extract_table(
    table_ref,
    destination_uri,
    # Location must match that of the source table.
    location="US",
)  # API request
extract_job.result()  # Waits for job to complete.

print(
    "Exported {}:{}.{} to {}".format(project, dataset_id, table_id, destination_uri)
)

Ruby

Bevor Sie dieses Beispiel anwenden, 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 extract_table bucket_name = "my-bucket",
                  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

  # Define a destination URI. Use a single wildcard URI if you think
  # your exported data will be larger than the 1 GB maximum value.
  destination_uri = "gs://#{bucket_name}/output-*.csv"

  extract_job = table.extract_job destination_uri do |config|
    # Location must match that of the source table.
    config.location = "US"
  end
  extract_job.wait_until_done! # Waits for the job to complete

  puts "Exported #{table.id} to #{destination_uri}"
end

Avro-Exportdetails

BigQuery drückt Avro-formatierte Daten folgendermaßen aus:

  • Bei den resultierenden Exportdateien handelt es sich um Avro-Containerdateien.
  • Jede BigQuery-Zeile wird als Avro-Datensatz dargestellt. Verschachtelte Daten werden durch verschachtelte Datensatzobjekte dargestellt.
  • REQUIRED-Felder werden als äquivalente Avro-Typen dargestellt. Der Typ INTEGER in BigQuery wird beispielsweise dem Typ LONG in Avro zugeordnet.
  • NULLABLE-Felder werden als Avro-Union des entsprechenden Typs und als "null" dargestellt.
  • REPEATED-Felder werden als Avro-Arrays dargestellt.
  • TIMESTAMP-Datentypen werden als logische Avro-timestamp-micros-Typen dargestellt.
  • DATE-Datentypen werden standardmäßig als Avro-INT-Typen oder logische Avro-date-Typen dargestellt, wenn das Flag --use_avro_logical_types angegeben ist.
  • TIME-Datentypen werden standardmäßig als Avro-LONG-Typen oder logische Avro-time-micros-Typen dargestellt, wenn das Flag --use_avro_logical_types angegeben ist.
  • DATETIME-Datentypen werden als Avro-STRING-Typen dargestellt. Die Codierung folgt der Spezifikation RFC 3339 der Internet Engineering Task Force.

Das Avro-Format kann nicht in Verbindung mit der GZIP-Komprimierung verwendet werden. Komprimieren Sie Avro-Daten mit dem bq-Befehlszeilentool oder der API und geben Sie dabei einen der unterstützten Komprimierungstypen für Avro-Daten an: DEFLATE oder SNAPPY.

Daten in eine oder mehrere Dateien exportieren

Das Attribut destinationUris gibt die Speicherorte der Dateinamen an, in die BigQuery die Dateien exportieren soll.

BigQuery unterstützt einen einzelnen Platzhalteroperator (*) in jedem URI. Der Platzhalter kann an jeder beliebigen Stelle im URI eingefügt werden, darf jedoch nicht Teil des Bucket-Namens sein. Durch Verwendung des Platzhalteroperators wird BigQuery angewiesen, mehrere fragmentierte Dateien gemäß dem bereitgestellten Musters zu erstellen. Der Platzhalteroperator wird durch eine Zahl (beginnend mit 0) ersetzt und nach links auf 12 Stellen aufgefüllt. Ein URI mit einem Platzhalter am Ende des Dateinamens würde Dateien erstellen, bei denen 000000000000 an den Namen der ersten Datei, 000000000001 an den Namen der zweiten Datei usw. angefügt wird.

In der folgenden Tabelle sind mehrere mögliche Optionen für das Attribut destinationUris beschrieben:

Optionen für "destinationUris"
Einzelner URI

Verwenden Sie einen einzelnen URI, wenn Sie Tabellendaten mit einer Größe von maximal 1 GB exportieren. Diese Option ist am gebräuchlichsten, da exportierte Daten im Allgemeinen unter dem Höchstwert von 1 GB liegen.

Attributdefinition:

['gs://my-bucket/file-name.json']

Erstellt:


gs://my-bucket/file-name.json
Einzelner Platzhalter-URI

Verwenden Sie einen einzelnen Platzhalter-URI, wenn Sie davon ausgehen, dass die exportierten Daten den Höchstwert von 1 GB überschreiten. BigQuery fragmentiert die Daten dann anhand des bereitgestellten Musters in mehrere Dateien. Die Größe der exportierten Dateien variiert.

Wenn Sie einen Platzhalter in einer anderen URI-Komponente als dem Dateinamen verwenden, achten Sie vor dem Export der Daten darauf, dass die Pfadkomponente nicht vorhanden ist.

Attributdefinition:

['gs://my-bucket/file-name-*.json']

Erstellt:


gs://my-bucket/file-name-000000000000.json
gs://my-bucket/file-name-000000000001.json
gs://my-bucket/file-name-000000000002.json
...
Mehrere Platzhalter-URIs

Verwenden Sie mehrere Platzhalter-URIs, wenn die Ausgabe des Exports partitioniert werden soll. Dies ist z. B. notwendig, wenn Sie einen parallelen Verarbeitungsjob mit einem Dienst wie Dataproc ausführen. Legen Sie fest, wie viele Worker für die Verarbeitung des Jobs verfügbar sein sollen, und erstellen Sie einen URI pro Worker. BigQuery behandelt jeden URI-Speicherort als eine Partition und nutzt die Parallelverarbeitung, um die Daten in mehrere Dateien pro Speicherort zu fragmentieren. Sie können jedes beliebige Muster im Dateinamen verwenden, solange nur ein Platzhalteroperator pro URI verwendet wird, alle URIs nur einmal vorkommen und die Anzahl der URIs die Kontingentrichtlinie nicht überschreitet.

Wenn Sie mehrere Platzhalter-URIs übergeben, erstellt BigQuery am Ende jeder Partition eine spezielle Datei, die die letzte Datei in der Gruppe darstellt. Dieser Dateiname gibt an, wie viele Shards von BigQuery erstellt wurden.

Wenn beispielsweise der Platzhalter-URI gs://my-bucket/file- name-<worker number>-*.json ist und BigQuery 80 fragmentierte Dateien erstellt, hat die Datei mit null Datensätzen den Namen gs://my-bucket/file-name-<worker number>-000000000080.json. An diesem Dateinamen können Sie ablesen, dass BigQuery 80 fragmentierte Dateien erstellt hat (namens 000000000000 bis 000000000079).

Beachten Sie, dass die Größe einer Datei mit null Datensätzen je nach Datenformat mehr als 0 Byte betragen kann, wie z. B. beim Export von Daten in das CSV-Format mit einer Spaltenüberschrift.

Stringmuster:

gs://my-bucket/file-name-<worker number>-*.json

Attributdefinition:


['gs://my-bucket/file-name-1-*.json',
'gs://my-bucket/file-name-2-*.json',
'gs://my-bucket/file-name-3-*.json']

Erstellt:

Bei diesem Beispiel wird davon ausgegangen, dass BigQuery 80 fragmentierte Dateien in jeder Partition erstellt.


gs://my-bucket/file-name-1-000000000000.json
gs://my-bucket/file-name-1-000000000001.json
...
gs://my-bucket/file-name-1-000000000080.json
gs://my-bucket/file-name-2-000000000000.json
gs://my-bucket/file-name-2-000000000001.json
...
gs://my-bucket/file-name-2-000000000080.json
gs://my-bucket/file-name-3-000000000000.json
gs://my-bucket/file-name-3-000000000001.json
...
gs://my-bucket/file-name-3-000000000080.json

Komprimierte Tabelle extrahieren

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

// exportTableAsCompressedCSV demonstrates using an export job to
// write the contents of a table into Cloud Storage as compressed CSV.
func exportTableAsCompressedCSV(projectID, gcsURI string) error {
	// projectID := "my-project-id"
	// gcsUri := "gs://mybucket/shakespeare.csv"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcProject := "bigquery-public-data"
	srcDataset := "samples"
	srcTable := "shakespeare"

	gcsRef := bigquery.NewGCSReference(gcsURI)
	gcsRef.Compression = bigquery.Gzip

	extractor := client.DatasetInProject(srcProject, srcDataset).Table(srcTable).ExtractorTo(gcsRef)
	extractor.DisableHeader = true
	// You can choose to run the job in a specific location for more complex data locality scenarios.
	// Ex: In this example, source dataset and GCS bucket are in the US.
	extractor.Location = "US"

	job, err := extractor.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 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.

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

// Sample to extract a compressed table
public class ExtractTableCompressed {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectName = "MY_PROJECT_NAME";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String bucketName = "MY-BUCKET-NAME";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    // For more information on export formats available see:
    // https://cloud.google.com/bigquery/docs/exporting-data#export_formats_and_compression_types
    String compressed = "gzip";
    // For more information on Job see:
    // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
    String dataFormat = "CSV";

    extractTableCompressed(
        projectName, datasetName, tableName, destinationUri, dataFormat, compressed);
  }

  public static void extractTableCompressed(
      String projectName,
      String datasetName,
      String tableName,
      String destinationUri,
      String dataFormat,
      String compressed) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectName, datasetName, tableName);

      ExtractJobConfiguration extractConfig =
          ExtractJobConfiguration.newBuilder(tableId, destinationUri)
              .setCompression(compressed)
              .setFormat(dataFormat)
              .build();

      Job job = bigquery.create(JobInfo.of(extractConfig));

      // 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 extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table extract compressed successful");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \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 libraries
const {BigQuery} = require('@google-cloud/bigquery');
const {Storage} = require('@google-cloud/storage');

const bigquery = new BigQuery();
const storage = new Storage();

async function extractTableCompressed() {
  // Exports my_dataset:my_table to gcs://my-bucket/my-file as a compressed file.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const bucketName = "my-bucket";
  // const filename = "file.csv";

  // Location must match that of the source table.
  const options = {
    location: 'US',
    gzip: true,
  };

  // Export data from the table into a Google Cloud Storage file
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .extract(storage.bucket(bucketName).file(filename), options);

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

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

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.

# from google.cloud import bigquery
# client = bigquery.Client()
# bucket_name = 'my-bucket'

destination_uri = "gs://{}/{}".format(bucket_name, "shakespeare.csv.gz")
dataset_ref = bigquery.DatasetReference(project, dataset_id)
table_ref = dataset_ref.table("shakespeare")
job_config = bigquery.job.ExtractJobConfig()
job_config.compression = bigquery.Compression.GZIP

extract_job = client.extract_table(
    table_ref,
    destination_uri,
    # Location must match that of the source table.
    location="US",
    job_config=job_config,
)  # API request
extract_job.result()  # Waits for job to complete.

Kontingentrichtlinie

Weitere Informationen zum Exportieren von Jobkontingenten finden Sie auf der Seite "Kontingente und Limits" unter Exportjobs.

Preise

Derzeit ist das Exportieren von BigQuery-Daten kostenlos. Die Exporte unterliegen jedoch den Kontingenten und Limits von BigQuery. Weitere Informationen zu den Preisen von BigQuery finden Sie auf der Seite BigQuery-Preise.

Nachdem die Daten exportiert wurden, wird das Speichern der Daten in Cloud Storage in Rechnung gestellt. Weitere Informationen zu den Preisen von Cloud Storage finden Sie auf der Seite Cloud Storage – Preise.

Weitere Informationen