Tabellendaten in Cloud Storage exportieren

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

Nach dem Laden der Daten in BigQuery können Sie die Daten in verschiedenen Formaten exportieren. BigQuery kann in einer Datei bis zu 1 GB Daten exportieren. Wenn Sie mehr als 1 GB Daten exportieren möchten, müssen Sie dafür mehrere Dateien verwenden. Beim Export in mehrere Dateien variiert die Größe der Dateien.

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.

Sie können die Ergebnisse einer Abfrage auch mit der Anweisung EXPORT DATA exportieren. Sie können EXPORT DATA OPTIONS verwenden, um Ansichten in Cloud Storage zu exportieren.

Exportbeschränkungen

Wenn Sie Daten aus BigQuery exportieren, sollten Sie Folgendes beachten:

  • Tabellendaten können nicht in eine lokale Datei, nicht in Google Sheets und nicht in Google 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. Sie können die Daten partitionieren und jede Partition exportieren, um die Größe der exportierten Datei zu begrenzen.
  • Die Größe der generierten Datei bei Verwendung der EXPORT DATA-Anweisung ist nicht gewährleistet.
  • Die Anzahl der von einem Exportjob generierten Dateien kann variieren.
  • Verschachtelte und wiederkehrende Daten können nicht im CSV-Format exportiert werden. Verschachtelte und wiederkehrende Daten werden für Avro-, JSON- und Parquet-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 Google Cloud Console können Sie nur den Komprimierungstyp GZIP auswählen.
  • Wenn Sie Daten in einen Cloud Storage-Bucket exportieren, der mit einer Aufbewahrungsrichtlinie konfiguriert wurde, schreibt BigQuery möglicherweise keine Dateien in den Bucket. Konfigurieren Sie die Aufbewahrungsdauer so, dass sie länger als die Dauer der Exportjobs ist.
  • Wenn Sie eine Tabelle im JSON-Format exportieren, werden die Symbole <, > und & mit der Unicode-Notation \uNNNN konvertiert, wobei N eine Hexadezimalzahl ist. Aus profit&loss wird beispielsweise profit\u0026loss. Diese Unicode-Konvertierung erfolgt, um Sicherheitslücken zu vermeiden.
  • Die Reihenfolge der exportierten Tabellendaten ist nur dann garantiert, wenn Sie die Anweisung EXPORT DATA verwenden und in query_statement eine ORDER BY-Klausel angeben.
  • BigQuery unterstützt keine Cloud Storage-Ressourcenpfade, die nach dem anfänglichen doppelten Schrägstrich weitere, aufeinanderfolgende Schrägstriche enthalten. Cloud Storage-Objektnamen können mehrere aufeinanderfolgende Schrägstriche ("/") enthalten. BigQuery wandelt diese jedoch in einen einzelnen Schrägstrich um. Der folgende Ressourcenpfad ist beispielsweise in Cloud Storage gültig, funktioniert aber nicht in BigQuery: gs://bucket/my//object//name.
  • Neue Daten, die während der Ausführung eines Exportjobs in BigQuery geladen werden, sind in diesem Exportjob nicht enthalten. Sie müssen einen neuen Exportjob erstellen, um die neuen Daten zu exportieren.

Hinweise

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

Erforderliche Berechtigungen

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

Berechtigungen für den Export von Daten aus einer BigQuery-Tabelle

Zum Exportieren von Daten aus einer BigQuery-Tabelle benötigen Sie die IAM-Berechtigung bigquery.tables.export.

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigung bigquery.tables.export:

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

Berechtigungen zum Ausführen eines Exportjobs

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

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie zum Ausführen eines Exportjobs benötigen:

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

Berechtigungen zum Schreiben der Daten in den Cloud Storage-Bucket

Zum Schreiben der Daten in einen vorhandenen Cloud Storage-Bucket benötigen Sie die folgenden IAM-Berechtigungen:

  • storage.objects.create
  • storage.objects.delete

Jede der folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie benötigen, um die Daten in einen vorhandenen Cloud Storage-Bucket zu schreiben:

  • roles/storage.objectAdmin
  • roles/storage.admin

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

Überlegungen zum Standort

Platzieren Sie die Cloud Storage-Buckets zum Exportieren von Daten am selben Standort.
  • Wenn sich Ihr BigQuery-Dataset in der Multi-Region EU befindet, muss sich der Cloud Storage-Bucket mit den zu exportierenden Daten am selben Standort oder an einem Standort in derselben Multi-Region Region befinden. Wenn sich Ihr BigQuery-Dataset zum Beispiel in der Multi-Region EU befindet, kann sich der Cloud Storage-Bucket in der Region europe-west1 innerhalb der EU befinden.

    Wenn sich Ihr Dataset in der Multi-Region US befindet, können Sie Daten in einen Cloud Storage-Bucket an einem beliebigen Standort exportieren.

  • Wenn sich Ihr Dataset in einer Region befindet, muss sich der Cloud Storage-Bucket in derselben Region befinden. Wenn sich Ihr Dataset zum Beispiel in der Region asia-northeast1 Tokio befindet, darf sich der Cloud Storage-Bucket nicht am multiregionalen Standort ASIA befinden.
Entwickeln Sie einen Plan zur Datenverwaltung:
  • Wenn Sie eine regionale Speicherressource wie ein BigQuery-Dataset oder einen Cloud Storage-Bucket auswählen, sollten Sie einen Plan für die geografische Verwaltung Ihrer Daten entwickeln.

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

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.

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 mithilfe des --field_delimiter-bq-Befehlszeilentool-Flags oder des configuration.extract.fieldDelimiter-Extrahierungsjob-Attributs festlegen.

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. Siehe Avro-Exportdetails.
Parquet SNAPPY, GZIP, ZSTD

Verschachtelte und wiederkehrende Daten werden unterstützt. Weitere Informationen finden Sie unter Parquet-Exportdetails.

Daten exportieren

Sie können Tabellendaten mit den folgenden Methoden exportieren:

  • Google Cloud Console verwenden
  • 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. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

    Zur Seite "BigQuery"

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

  3. Klicken Sie im Detailbereich auf Exportieren und wählen Sie Nach Cloud Storage exportieren aus.

  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 unter Exportformat das Format für die exportierten Daten aus: CSV, JSON (durch Zeilenumbruch getrennt), Avro oder Parquet.
    • Wählen Sie unter Komprimierung ein Komprimierungsformat aus oder wählen Sie None für keine Komprimierung aus.
    • Klicken Sie auf Exportieren, um die Tabelle zu exportieren.

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

Verwenden Sie die Anweisung EXPORT DATA OPTIONS, um Ansichten nach Cloud Storage zu exportieren.

SQL

Verwenden Sie die Anweisung EXPORT DATA. Im folgenden Beispiel werden ausgewählte Felder aus einer Tabelle mit dem Namen mydataset.table1 exportiert:

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

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    EXPORT DATA
  OPTIONS (
    uri = 'gs://bucket/folder/*.csv',
    format = 'CSV',
    overwrite = true,
    header = true,
    field_delimiter = ';')
AS (
  SELECT field1, field2
  FROM mydataset.table1
  ORDER BY field1
);

  3. Klicken Sie auf Ausführen.

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

bq

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

Optional: Geben Sie das Flag --location an und legen Sie 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 extract --location=location \
--destination_format format \
--compression compression_type \
--field_delimiter delimiter \
--print_header=boolean \
project_id:dataset.table \
gs://bucket/filename.ext

Wobei:

  • 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, AVRO oder PARQUET.
  • compression_type ist ein unterstützter Komprimierungstyp für das Datenformat. Weitere Informationen finden Sie unter Exportformate und Komprimierungstypen.
  • 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. Wenn Sie einen Partitions-Decorator verwenden, müssen Sie den Tabellenpfad in einfache Anführungszeichen setzen oder das Zeichen $ mit Escapezeichen versehen.
  • 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

Mit dem folgenden Befehl wird eine einzelne Partition von mydataset.my_partitioned_table in eine CSV-Datei in Cloud Storage exportiert:

bq extract \
--destination_format CSV \
'mydataset.my_partitioned_table$0' \
gs://example-bucket/single_partition.csv

API

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

Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource 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 ausprobieren, folgen Sie der C#-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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}.");
    }
}

Einfach loslegen (Go)

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// 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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery PHP API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\BigQuery\BigQueryClient;

/**
 * Extracts the given table as json to given GCS bucket.
 *
 * @param string $projectId The project Id of your Google Cloud Project.
 * @param string $datasetId The BigQuery dataset ID.
 * @param string $tableId The BigQuery table ID.
 * @param string $bucketName Bucket name in Google Cloud Storage
 */
function extract_table(
    string $projectId,
    string $datasetId,
    string $tableId,
    string $bucketName
): void {
    $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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

# 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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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.
  • Die Felder REPEATED werden als Avro-Arrays dargestellt.
  • TIMESTAMP-Datentypen werden standardmäßig im logischen Typ timestamp-micros dargestellt (annotiert den Avro-Typ LONG) sowohl beim Extrahieren von Jobs als auch beim Exportieren von Daten-SQL. (Achtung: Sie können use_avro_logical_types=False zu Export Data Options hinzufügen, um den logischen Typ zu deaktivieren, sodass stattdessen der Typ string für die Zeitstempelspalte verwendet wird, aber in Extract Jobs wird immer der logische Avro-Typ verwendet.)
  • DATE-Datentypen werden in Export Data SQL standardmäßig als logischer date-Typ (annotiert Avro-INT-Typen) dargestellt, aber in Extract-Jobs standardmäßig als string-Typ dargestellt. (Hinweis: Sie können use_avro_logical_types=False zu Export Data Options hinzufügen, um den logischen Typ zu deaktivieren, oder das Flag --use_avro_logical_types=True verwenden, um den logischen Typ in Extract-Jobs zu aktivieren.)
  • TIME-Datentypen werden in Export Data SQL standardmäßig als logischer timestamp-micro-Typ dargestellt (annotiert Avro-LONG-Typen), aber in Extract-Jobs standardmäßig als string-Typ dargestellt. Hinweis: Sie können use_avro_logical_types=False zu Export Data Options hinzufügen, um den logischen Typ zu deaktivieren, oder das Flag --use_avro_logical_types=True verwenden, um den logischen Typ in Extract-Jobs zu aktivieren.
  • DATETIME-Datentypen werden in Export Data SQL standardmäßig als Avro-STRING-Typen (ein Stringtyp mit einem benutzerdefinierten logischen Typ datetime) dargestellt, aber in Extract-Jobs standardmäßig als string dargestellt. Hinweis: Sie können use_avro_logical_types=False zu Export Data Options hinzufügen, um den logischen Typ zu deaktivieren, oder das Flag --use_avro_logical_types=True verwenden, um den logischen Typ in Extract-Jobs zu aktivieren.
Internet Engineering Task Force.

Die parametrisierten Datentypen NUMERIC(P[, S]) und BIGNUMERIC(P[, S]) übertragen ihre Genauigkeits- und Skalierungstypparameter an den logischen Avro-Dezimaltyp.

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

Parquet-Exportdetails

BigQuery konvertiert GoogleSQL-Datentypen in folgende Parquet-Datentypen:

BigQuery-Datentyp Einfacher Parquet-Typ Logischer Parquet-Typ
Integer INT64 NONE
Numerisch FIXED_LEN_BYTE_ARRAY DECIMAL (precision = 38, scale = 9)
Numeric(P[, S]) FIXED_LEN_BYTE_ARRAY DECIMAL (precision = P, scale = S)
BigNumeric FIXED_LEN_BYTE_ARRAY DECIMAL (precision = 76, scale = 38)
BigNumeric(P[, S]) FIXED_LEN_BYTE_ARRAY DECIMAL (precision = P, scale = S)
Gleitkomma FLOAT NONE
Boolesch BOOLEAN NONE
String BYTE_ARRAY STRING (UTF8)
Byte BYTE_ARRAY NONE
Datum INT32 DATE
Datum/Uhrzeit INT64 TIMESTAMP (isAdjustedToUTC = false, unit = MICROS)
Zeit INT64 TIME (isAdjustedToUTC = true, unit = MICROS)
Zeitstempel INT64 TIMESTAMP (isAdjustedToUTC = false, unit = MICROS)

Das Parquet-Schema stellt verschachtelte Daten als Gruppe und wiederkehrende Datensätze als wiederkehrende Gruppen dar. Weitere Informationen zur Verwendung verschachtelter und wiederkehrender Daten in BigQuery finden Sie unter Verschachtelte und wiederkehrende Spalten angeben.

Sie können die folgenden Problemumgehungen für DATETIME-Typen verwenden:

  • Laden Sie die Datei in eine Staging-Tabelle. Verwenden Sie dann eine SQL-Abfrage, um das Feld in DATETIME umzuwandeln und das Ergebnis in einer neuen Tabelle zu speichern. Weitere Informationen finden Sie unter Datentyp einer Spalte ändern.
  • Geben Sie im Ladejob das Flag --schema für die Tabelle an. Definieren Sie die Datum/Uhrzeit-Spalte als col:DATETIME.

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. Diese Option wird für die Anweisung EXPORT DATA nicht unterstützt. Sie müssen einen einzelnen Platzhalter-URI verwenden.

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

Größe der exportierten Datei beschränken

Wenn Sie mehr als 1 GB Daten in einem einzelnen Export exportieren, müssen Sie einen Platzhalter verwenden, um die Daten in mehrere Dateien zu exportieren, und die Größe der Dateien variiert. Wenn Sie die maximale Größe jeder exportierten Datei begrenzen müssen, können Sie Ihre Daten nach dem Zufallsprinzip partitionieren und dann jede Partition in eine Datei exportieren:

  1. Ermitteln Sie die Anzahl der benötigten Partitionen. Diese entspricht der Gesamtgröße Ihrer Daten geteilt durch die gewünschte exportierte Dateigröße. Beispiel: Wenn Sie 8.000 MB Daten haben und jede exportierte Datei ca. 20 MB haben soll, benötigen Sie 400 Partitionen.

  2. Erstellen Sie eine neue Tabelle, die nach einer neuen, zufällig generierten Spalte namens export_id partitioniert und geclustert ist. Das folgende Beispiel zeigt, wie Sie eine neue processed_table aus einer vorhandenen Tabelle namens source_table erstellen, bei der n-Partitionen erforderlich sind, um die gewünschte Dateigröße zu erreichen:

    CREATE TABLE my_dataset.processed_table
PARTITION BY RANGE_BUCKET(export_id, GENERATE_ARRAY(0, n, 1))
CLUSTER BY export_id
AS (
  SELECT *, CAST(FLOOR(n*RAND()) AS INT64) AS export_id
  FROM my_dataset.source_table
);

  3. Führen Sie für jede Ganzzahl i zwischen 0 und n-1 eine EXPORT DATA-Anweisung in der folgenden Abfrage aus:

    SELECT * EXCEPT(export_id)
FROM my_dataset.processed_table
WHERE export_id = i;

Komprimierte Tabelle extrahieren

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Go-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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: %w", 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 ausprobieren, folgen Sie der Java-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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 ausprobieren, folgen Sie der Node.js-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// 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 ausprobieren, folgen Sie der Python-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Anwendungsbeispiel

In diesem Beispiel wird gezeigt, wie Sie Daten nach Cloud Storage exportieren können.

Angenommen, Sie streamen kontinuierlich Daten aus Endpunktlogs an Cloud Storage. Ein täglicher Snapshot soll zu Sicherungs- und Archivierungszwecken in Cloud Storage exportiert werden. Die beste Wahl ist ein Extraktionsjob, der bestimmten Kontingenten und Einschränkungen unterliegt.

Senden Sie einen Extraktionsjob mit der API oder den Clientbibliotheken und übergeben Sie eine eindeutige ID als jobReference.jobId. Extraktionsjobs sind asynchron. Prüfen Sie den Jobstatus anhand der eindeutigen Job-ID, die zum Erstellen des Jobs verwendet wird. Der Job wurde erfolgreich abgeschlossen, wenn status.status den Wert DONE hat. Wenn status.errorResult vorhanden ist, ist der Job fehlgeschlagen und muss wiederholt werden.

Batchdatenverarbeitung

Angenommen, ein nächtlicher Batchjob wird verwendet, um Daten nach einer festen Frist zu laden. Nachdem dieser Ladejob abgeschlossen ist, wird eine Tabelle mit Statistiken aus einer Abfrage materialisiert, wie im vorherigen Abschnitt beschrieben. Die Daten aus dieser Tabelle werden abgerufen, in einem PDF-Bericht kompiliert und an eine Regulierungsbehörde gesendet.

Da die zu lesende Datenmenge klein ist, verwenden Sie die API tabledata.list, um alle Zeilen der Tabelle im JSON-Wörterbuchformat abzurufen. Wenn mehr als eine Seite Daten vorhanden ist, ist in den Ergebnissen das Attribut pageToken festgelegt. Mit einem weiteren tabledata.list-Aufruf fügen Sie den Tokenwert als Parameter pageToken hinzu, um die nächste Ergebnisseite abzurufen. Wenn der API-Aufruf mit einem 5xx-Fehler fehlschlägt, versuchen Sie es mit exponentiellem Backoff. Die meisten 4xx-Fehler sind nicht wiederholbar. Zur besseren Entkopplung von BigQuery-Export und Berichtsgenerierung sollten die Ergebnisse auf dem Laufwerk gespeichert werden.

Kontingentrichtlinie

Weitere Informationen zum Exportieren von Jobkontingenten finden Sie auf der Seite "Kontingente und Beschränkungen" unter Jobs exportieren.

Die Verwendung für Exportjobs ist in INFORMATION_SCHEMA verfügbar. Der Jobeintrag in den Systemtabellen JOBS_BY_* für den Exportjob enthält einen total_processed_bytes-Wert, mit dem die aggregierte Nutzung überwacht werden kann, um sicherzustellen, dass er unter 50 TB pro Tag bleibt. Informationen zum Abfragen der Ansicht INFORMATION_SCHEMA.JOBS zum Abrufen des Werts total_processed_bytes finden Sie unter Von Exportjobs verarbeitete Byte abrufen.

Aktuelle Kontingentnutzung ansehen

Sie können Ihre aktuelle Nutzung von Abfrage-, Lade-, Extrahierungs- oder Kopierjobs aufrufen, indem Sie eine INFORMATION_SCHEMA-Abfrage ausführen, um Metadaten zu den Jobs aufzurufen, die in einem bestimmten Zeitraum ausgeführt wurden. Sie können Ihre aktuelle Nutzung mit dem Kontingentlimit vergleichen, um die Kontingentnutzung für eine bestimmte Art von Job zu ermitteln. Die folgende Beispielabfrage verwendet die Ansicht INFORMATION_SCHEMA.JOBS, um die Anzahl der Abfrage-, Lade-, Extrahierungs- und Kopierjobs nach Projekt aufzulisten:

SELECT
  sum(case  when job_type="QUERY" then 1 else 0 end) as QRY_CNT,
  sum(case  when job_type="LOAD" then 1 else 0 end) as LOAD_CNT,
  sum(case  when job_type="EXTRACT" then 1 else 0 end) as EXT_CNT,
  sum(case  when job_type="COPY" then 1 else 0 end) as CPY_CNT
FROM `region-eu`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

Sie können eine Cloud Monitoring-Benachrichtigungsrichtlinie einrichten, die Benachrichtigungen über die Anzahl der exportierten Byte liefert.

  1. Rufen Sie in der Google Cloud Console die Seite Monitoring auf.

    Zu Monitoring

  2. Wählen Sie im Navigationsbereich Metrics Explorer aus.

  3. Richten Sie im MQL-Abfrageeditor eine Benachrichtigung ein, um die exportierten Byte pro Tag zu überwachen, wie im folgenden Beispiel gezeigt:

    fetch consumer_quota
  | filter resource.service == 'bigquery.googleapis.com'
  | { metric serviceruntime.googleapis.com/quota/rate/net_usage
      | align delta_gauge(1m)
      | group_by [resource.project_id, metric.quota_metric, resource.location],
          sum(value.net_usage)
    ; metric serviceruntime.googleapis.com/quota/limit
      | filter metric.limit_name == 'ExtractBytesPerDay'
      | group_by [resource.project_id, metric.quota_metric, resource.location],
          sliding(1m), max(val()) }
  | ratio
  | every 1m
  | condition gt(val(), 0.01 '1')

  4. Klicken Sie zum Einrichten der Benachrichtigung auf Abfrage ausführen.

Weitere Informationen finden Sie unter Benachrichtigungsrichtlinien mit MQL.

Preise

Die Preise für den Datenexport 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 finden Sie unter Cloud Storage – Preise.

Tabellensicherheit

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

Nächste Schritte