Abfrageergebnisse schreiben

In diesem Dokument erfahren Sie, wie Abfrageergebnisse geschrieben und gespeichert werden.

Temporäre und permanente Tabellen

In BigQuery werden alle Abfrageergebnisse in einer Tabelle gespeichert. Diese kann permanent oder temporär sein:

  • BigQuery verwendet temporäre Tabellen, um Abfrageergebnisse im Cache zu speichern, die nicht in eine permanente Tabelle geschrieben wurden. Die Tabellen werden in einem speziellen Dataset erstellt und nach dem Zufallsprinzip benannt. Sie können auch temporäre Tabellen zur eigenen Verwendung erstellen. Weitere Informationen finden Sie unter Temporäre Tabellen.

    Nachdem eine Abfrage abgeschlossen ist, besteht die temporäre Tabelle noch bis zu 24 Stunden. Zum Aufrufen der Tabellenstruktur und der Daten öffnen Sie die BigQuery-Konsole, klicken auf Abfrageverlauf und wählen die Abfrage aus, mit der die temporäre Tabelle erstellt wurde. Klicken Sie dann in der Zeile Zieltabelle auf Temporäre Tabelle.

    Sie können temporäre Tabellen nicht abfragen und auch nicht freigeben. Temporäre Tabellen lassen sich auch weder mit einer Standardliste noch mit anderen Methoden der Tabellenbearbeitung sichtbar machen. Für das Speichern temporärer Tabellen fallen keine Kosten an.

  • Eine permanente Tabelle kann eine neue oder eine vorhandene Tabelle in einem beliebigen Dataset sein, auf das Sie Zugriff haben. Wenn Sie Abfrageergebnisse in eine neue Tabelle schreiben, wird Ihnen das Speichern der Daten in Rechnung gestellt. Wenn Sie Abfrageergebnisse in eine permanente Tabelle schreiben, müssen sich die abzufragenden Tabellen am selben Speicherort wie das Dataset befinden, das die Zieltabelle enthält.

Erforderliche Berechtigungen

Damit Sie Abfrageergebnisse in eine Tabelle schreiben können, benötigen Sie mindestens folgende Berechtigungen:

  • bigquery.tables.create-Berechtigungen zum Erstellen einer neuen Tabelle
  • bigquery.tables.updateData, um Daten in eine neue Tabelle zu schreiben, eine Tabelle zu überschreiben oder Daten an eine Tabelle anzuhängen
  • bigquery.jobs.create, um einen Abfragejob auszuführen

Für den Zugriff auf die abgefragten Daten sind möglicherweise zusätzliche Berechtigungen wie z. B. bigquery.tables.getData erforderlich.

Die folgenden vordefinierten IAM-Rollen enthalten die Berechtigungen bigquery.tables.create und bigquery.tables.updateData:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ bigquery.jobs.create:

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

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem Zugriff als bigquery.dataOwner. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, im Dataset Tabellen zu erstellen und zu aktualisieren.

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

Abfrageergebnisse in eine permanente Tabelle schreiben

Wenn Sie Abfrageergebnisse in eine permanente Tabelle schreiben möchten, können Sie eine neue Tabelle erstellen, die Ergebnisse an eine vorhandene Tabelle anfügen oder eine vorhandene Tabelle überschreiben. So schreiben Sie Abfrageergebnisse in eine permanente Tabelle:

  • Cloud Console verwenden
  • Mit dem Befehl bq query des bq-Befehlszeilentools
  • API-Methode jobs.insert aufrufen und einen query-Job konfigurieren.
  • Clientbibliotheken verwenden.

Abfrageergebnisse schreiben

Das im Folgenden aufgeführte Verfahren gibt Ihnen die Möglichkeit, Ihre Abfrageergebnisse in eine permanente Tabelle zu schreiben. Zur besseren Kostenkontrolle können Sie Daten in der Vorschau aufrufen, bevor Sie die Abfrage ausführen.

Console

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

    Zur Seite "BigQuery"

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

  3. Wenn der Abfrageeditor ausgeblendet ist, klicken Sie oben rechts im Fenster auf Show editor (Editor einblenden).

  4. Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige SQL-Abfrage ein.

  5. Klicken Sie auf Mehr und wählen Sie dann Abfrageoptionen aus.

    Abfrageeinstellungen

  6. Klicken Sie auf das Kästchen Zieltabelle für Abfrageergebnisse festlegen.

    Ziel festlegen

  7. Wählen Sie im Abschnitt Destination (Ziel) den entsprechenden Projektnamen unter Project name (Projektname) bzw. den Namen des Datasets, in dem die Tabelle erstellt werden soll, unter Dataset name (Dataset-Name) aus. Wählen Sie dann einen Tabellennamen unter Table name (Tabellenname) aus.

  8. Wählen Sie im Abschnitt Destination table write preference (Schreibeinstellung für Zieltabelle) eine der folgenden Optionen aus:

    • Write if empty (Schreiben, wenn leer): Die Abfrageergebnisse werden nur in die Tabelle geschrieben, wenn sie leer ist.
    • Append to table (An Tabelle anfügen): Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
    • Overwrite table (Tabelle überschreiben): Eine vorhandene Tabelle mit demselben Namen wird mit den Abfrageergebnissen überschrieben.
  9. Optional: Klicken Sie unter Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus.

  10. Klicken Sie auf Run query (Abfrage ausführen). Dadurch wird ein Abfragejob erstellt, mit dem die Abfrageergebnisse in die angegebene Tabelle geschrieben werden.

Wenn Sie vor dem Ausführen der Abfrage keine Zieltabelle angegeben haben, können Sie die im Cache gespeicherte Ergebnistabelle auch in eine permanente Tabelle kopieren. Klicken Sie hierfür unterhalb des Editors auf die Schaltfläche Save Results (Ergebnisse speichern).

SQL

DDL-Anweisungen (Data Definition Language) ermöglichen Ihnen, Tabellen mit der Standard-SQL-Abfragesyntax zu erstellen und zu ändern.

Weitere Informationen finden Sie auf der Seite zur CREATE TABLE-Anweisung und im Beispiel zu CREATE TABLE: Neue Tabelle aus einer vorhandenen Tabelle erstellen.

bq

Um aus den Abfrageergebnissen eine permanente Tabelle zu erstellen, führen Sie den Befehl bq query mit dem Flag --destination_table aus. Mit dem Flag use_legacy_sql=false legen Sie die Standard-SQL-Syntax fest. Wenn Sie die Abfrageergebnisse in eine Tabelle schreiben möchten, die sich nicht in Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

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

Mit einem der folgenden optionalen Flags steuern Sie die Schreibanordnung für eine vorhandene Zieltabelle:

  • --append_table: Wenn die Zieltabelle vorhanden ist, werden die Abfrageergebnisse an diese angefügt.
  • --replace: Wenn die Zieltabelle vorhanden ist, wird sie mit den Abfrageergebnissen überschrieben.
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

Dabei gilt:

  • location ist der Name des Standorts, an dem die Abfrage bearbeitet wurde. 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 können Sie für den Standort einen Standardwert festlegen.
  • project_id ist die Projekt-ID.
  • dataset ist der Name des Datasets mit der Tabelle, in die Sie die Abfrageergebnisse schreiben.
  • table ist der Name der Tabelle, in die Sie die Abfrageergebnisse schreiben.
  • query eine Abfrage in der Standard-SQL-Syntax ist.

Wenn kein Schreibanordnungs-Flag angegeben ist, werden die Ergebnisse standardmäßig nur dann in die Tabelle geschrieben, wenn sie leer ist. Wenn die Tabelle vorhanden und nicht leer ist, wird der folgende Fehler zurückgegeben: "BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table".

Beispiele:

Mit dem folgenden Befehl schreiben Sie Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in Ihrem Standardprojekt. Da im Befehl kein Schreibanordnungs-Flag angegeben ist, muss die Tabelle neu oder leer sein. Andernfalls wird der Fehler Already exists zurückgegeben. Mit dieser Abfrage werden Daten aus dem öffentlichen Dataset USA Name Data abgerufen.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=false \
'SELECT
  name,
  number
FROM
  `bigquery-public-data`.usa_names.usa_1910_current
WHERE
  gender = "M"
ORDER BY
  number DESC'

Mit dem folgenden Befehl überschreiben Sie eine Zieltabelle mit dem Namen mytable in mydataset mit Abfrageergebnissen. Das Dataset befindet sich in Ihrem Standardprojekt. In dem Befehl wird das Flag --replace verwendet, um die Zieltabelle zu überschreiben.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=false \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

Mit dem folgenden Befehl fügen Sie Abfrageergebnisse an eine Zieltabelle mit dem Namen mytable in mydataset an. Das Dataset befindet sich in my-other-project und nicht in Ihrem Standardprojekt. In dem Befehl wird das Flag --append_table verwendet, um die Abfrageergebnisse an die Zieltabelle anzufügen.

bq query \
--append_table \
--use_legacy_sql=false \
--destination_table my-other-project:mydataset.mytable \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

Die Ausgabe für jedes dieser Beispiele sieht folgendermaßen aus. Aus Gründen der Lesbarkeit ist ein Teil der Ausgabe abgeschnitten.

Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

Wenn Sie Abfrageergebnisse in einer permanenten Tabelle speichern möchten, rufen Sie die Methode jobs.insert auf. Anschließend konfigurieren Sie einen query-Job und geben einen Wert für das Attribut destinationTable an. Sie konfigurieren das Attribut writeDisposition, um die Schreibanordnung für eine vorhandene Zieltabelle zu steuern.

Geben Sie im Abschnitt jobReference der Jobressource das Attribut location an, um den Verarbeitungsstandort für den Abfragejob zu steuern.

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

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID 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()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.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
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	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.

Wenn Sie die Abfrageergebnisse in einer permanenten Tabelle speichern möchten, geben Sie für die Zieltabelle die gewünschte TableId in einer QueryJobConfiguration an.

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

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    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();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \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 queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

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.

Wenn Sie die Abfrageergebnisse in einer permanenten Tabelle speichern möchten, erstellen Sie eine QueryJobConfig und legen als Ziel die gewünschte TableReference fest. Übergeben Sie die Jobkonfiguration an die Abfragemethode.
from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Große Abfrageergebnisse schreiben

Normalerweise haben Abfragen eine maximale Antwortgröße. Wenn Sie beabsichtigen, eine Abfrage auszuführen, bei der größere Ergebnisse zurückgegeben werden könnten, haben Sie folgende Möglichkeiten:

  • Geben Sie in Standard-SQL eine Zieltabelle für die Abfrageergebnisse an.
  • Geben Sie in Legacy-SQL eine Zieltabelle an und legen Sie die Option allowLargeResults fest.

Wenn Sie eine Zieltabelle für umfassende Abfrageergebnisse angeben, wird Ihnen das Speichern der Daten in Rechnung gestellt.

Beschränkungen

Beim Schreiben großer Ergebnismengen im Legacy-SQL-Dialekt bestehen die folgenden Einschränkungen:

  • Sie müssen eine Zieltabelle angeben.
  • Sie können keine Klausel der obersten Ebene ORDER BY, TOP oder LIMIT angeben. Dies würde die Vorteile von allowLargeResults zunichtemachen, weil die Abfrageausgabe nicht mehr parallel berechnet werden kann.
  • Fensterfunktionen können große Abfrageergebnisse nur zurückgeben, wenn sie in Verbindung mit einer PARTITION BY-Klausel verwendet werden.

Große Ergebnismengen mit Legacy-SQL schreiben

So schreiben Sie große Ergebnismengen mit Legacy-SQL:

Console

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

    BigQuery aufrufen

  2. Klicken Sie auf Neue Abfrage erstellen.

  3. Geben Sie im Textbereich des Abfrageeditors eine gültige SQL-Abfrage ein. Verwenden Sie das Präfix #legacySQL oder prüfen Sie, ob in den Abfrageeinstellungen Use Legacy SQL (Legacy-SQL verwenden) ausgewählt ist.

  4. Klicken Sie auf More (Mehr) und wählen Sie dann Query settings (Abfrageeinstellungen) aus.

    Abfrageeinstellungen

  5. Aktivieren Sie unter Destination (Ziel) die Option Set a destination table for query results (Zieltabelle für Abfrageergebnisse festlegen).

    Ziel festlegen

  6. Für Project name (Projektname) wählen Sie das Projekt, in dem die Zieltabelle erstellt wird.

  7. Für Dataset name (Dataset-Name) wählen Sie das Dataset, in dem die Tabelle gespeichert wird.

  8. Geben Sie im Feld Table name (Tabellenname) einen Tabellennamen ein.

  9. Wenn Sie eine große Ergebnismenge in eine vorhandene Tabelle schreiben, können Sie mit der Option Destination table write preference (Schreibeinstellung für die Zieltabelle) die Schreibposition der Zieltabelle steuern:

    • Schreiben, wenn leer: Die Abfrageergebnisse werden nur in die Tabelle geschrieben, wenn sie leer ist.
    • An Tabelle anfügen: Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
    • Tabelle überschreiben: Eine vorhandene Tabelle mit dem gleichen Namen wird mit den Abfrageergebnissen überschrieben.

    Optionsfeld "Tabelle überschreiben"

  10. Aktivieren Sie für die Results size (Ergebnisgröße) die Option Allow large results (no size limit) (Große Ergebnisse zulassen (kein Größenlimit)).

    Größe der Abfrageergebnisse

  11. Optional: Klicken Sie unter Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus.

    Verarbeitungsstandort der Abfrage

  12. Klicken Sie auf Speichern, um die Abfrageeinstellungen zu aktualisieren.

  13. Klicken Sie auf Run (Ausführen). Dadurch wird ein Abfragejob erstellt, mit dem die große Ergebnismenge in die angegebene Tabelle geschrieben wird.

bq

Verwenden Sie das Flag --allow_large_results mit dem Flag --destination_table, um eine Zieltabelle für die großen Ergebnismengen zu erstellen. Da die Option -- allow_large_results nur für Legacy-SQL gilt, müssen Sie auch das Flag --use_legacy_sql=true angeben. Wenn Sie die Abfrageergebnisse in eine Tabelle schreiben möchten, die sich nicht in Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

Mit einem der folgenden optionalen Flags steuern Sie die Schreibanordnung für eine vorhandene Zieltabelle:

  • --append_table: Wenn die Zieltabelle vorhanden ist, werden die Abfrageergebnisse an diese angefügt.
  • --replace: Wenn die Zieltabelle vorhanden ist, wird sie mit den Abfrageergebnissen überschrieben.
bq --location=location query \
--destination_table PROJECT_ID:DATASET.TABLE \
--use_legacy_sql=true \
--allow_large_results "QUERY"

Dabei gilt:

  • LOCATION ist der Name des Standorts, an dem die Abfrage bearbeitet wurde. 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 können Sie einen Standardwert für den Standort festlegen.
  • PROJECT_ID ist die Projekt-ID.
  • DATASET ist der Name des Datasets mit der Tabelle, in die Sie die Abfrageergebnisse schreiben.
  • TABLE ist der Name der Tabelle, in die Sie die Abfrageergebnisse schreiben.
  • QUERY ist eine Abfrage in Legacy SQL-Syntax.

Beispiele:

Mit dem folgenden Befehl schreiben Sie große Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in Ihrem Standardprojekt. Da im Befehl kein Schreibanordnungs-Flag angegeben ist, muss die Tabelle neu oder leer sein. Andernfalls wird der Fehler Already exists zurückgegeben. Mit dieser Abfrage werden Daten aus dem öffentlichen Dataset USA Name Data abgerufen. Diese Abfrage dient lediglich als Beispiel. Der zurückgegebene Ergebnissatz überschreitet nicht die maximale Antwortgröße.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Mit dem folgenden Befehl überschreiben Sie eine Zieltabelle mit dem Namen mytable in mydataset mit Abfrageergebnissen. Das Dataset befindet sich in myotherproject, und nicht in Ihrem Standardprojekt. In dem Befehl wird das Flag --replace verwendet, um die Zieltabelle zu überschreiben.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Mit dem folgenden Befehl schreiben Sie große Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in myotherprojectund nicht in Ihrem Standardprojekt. In dem Befehl wird das Flag --append_table verwendet, um die Abfrageergebnisse an die Zieltabelle anzufügen.

bq query \
--destination_table myotherproject:mydataset.mytable \
--append_table \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

API

Wenn Sie große Abfrageergebnisse in einer Zieltabelle speichern möchten, rufen Sie die Methode jobs.insert auf. Konfigurieren Sie anschließend einen query-Job und geben Sie für das Attribut allowLargeResults den Wert true an. Geben Sie die Zieltabelle mit dem Attribut destinationTable an. Konfigurieren Sie das Attribut writeDisposition, um die Schreibanordnung für eine vorhandene Zieltabelle zu steuern.

Geben Sie Ihren Standort 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"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryLegacyLargeResults demonstrates issuing a legacy SQL query and writing a large result set
// into a destination table.
func queryLegacyLargeResults(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "destinationdataset"
	// tableID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(
		"SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;")
	q.UseLegacySQL = true
	q.AllowLargeResults = true
	q.QueryConfig.Dst = client.Dataset(datasetID).Table(tableID)
	// Run the query and print results when the query job is completed.
	job, err := q.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
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

Um umfangreiche Ergebnisse zu ermöglichen, legen Sie für Große Ergebnisse zulassen den Wert true und unter Zieltabelle die gewünschte TableId in einer QueryJobConfiguration fest.

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

// Sample to run query with large results and save the results to a table.
public class QueryLargeResults {

  public static void runQueryLargeResults() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDataset = "MY_DESTINATION_DATASET_NAME";
    String destinationTable = "MY_DESTINATION_TABLE_NAME";
    String query = "SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;";
    queryLargeResults(destinationDataset, destinationTable, query);
  }

  public static void queryLargeResults(
      String destinationDataset, String destinationTable, String query) {
    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();

      QueryJobConfiguration queryConfig =
          // To use legacy SQL syntax, set useLegacySql to true.
          QueryJobConfiguration.newBuilder(query)
              .setUseLegacySql(true)
              // Save the results of the query to a permanent table.
              .setDestinationTable(TableId.of(destinationDataset, destinationTable))
              // Allow results larger than the maximum response size.
              // If true, a destination table must be set.
              .setAllowLargeResults(true)
              .build();

      TableResult results = bigquery.query(queryConfig);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));

      System.out.println("Query large results performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \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 queryLegacyLargeResults() {
  // Query enables large result sets.

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

  const query = `SELECT word FROM [bigquery-public-data:samples.shakespeare] LIMIT 10;`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced
    // in the query and of the destination table.
    useLegacySql: true,
    allowLargeResult: true,
    destinationTable: {
      projectId: projectId,
      datasetId: datasetId,
      tableId: tableId,
    },
  };

  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

  // Wait for the query to finish
  const [rows] = await job.getQueryResults();

  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

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 destination table.
# table_id = "your-project.your_dataset.your_table_name"

# Set the destination table and use_legacy_sql to True to use
# legacy SQL syntax.
job_config = bigquery.QueryJobConfig(
    allow_large_results=True, destination=table_id, use_legacy_sql=True
)

sql = """
    SELECT corpus
    FROM [bigquery-public-data:samples.shakespeare]
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Abfrageergebnisse aus der Cloud Console herunterladen und speichern

Nach dem Ausführen einer SQL-Abfrage mithilfe der Cloud Console können Sie die Ergebnisse an einem anderen Ort speichern. Sie können mit der Cloud Console Abfrageergebnisse in eine lokale Datei, Google Tabellen oder Google Drive herunterladen. Das Speichern von Ergebnissen in einer lokalen Datei, in Google Tabellen oder in Google Drive wird vom bq-Befehlszeilentool und der API nicht unterstützt.

Beschränkungen

Das Herunterladen und Speichern von Abfrageergebnissen unterliegt den folgenden Einschränkungen:

  • Abfrageergebnisse lassen sich lokal nur im CSV-Format oder im JSON-Format (mit Zeilenumbruch) herunterladen.
  • Abfrageergebnisse mit verschachtelten und wiederkehrenden Daten können nicht im CSV-Format heruntergeladen werden.
  • Abfrageergebnisse mit verschachtelten und wiederkehrenden Daten können nicht in Google Tabellen gespeichert werden.
  • Damit Abfrageergebnisse mit der Cloud Console in Drive gespeichert werden, darf die Ergebnismenge maximal 1 GB und 16.000 Zeilen umfassen. Wenn Ihre Ergebnisse diese Grenzwerte überschreiten, können Sie sie stattdessen in einer Tabelle speichern.
  • Abfrageergebnisse können nur im CSV- oder im durch Zeilenumbruch getrennten JSON-Format in Google Drive gespeichert werden.

Abfrageergebnisse in eine lokale Datei herunterladen

Das Herunterladen von Abfrageergebnissen in eine lokale Datei wird vom bq-Befehlszeilentool und der API nicht unterstützt.

Verwenden Sie die Cloud Console, um Abfrageergebnisse als CSV- oder durch Zeilenumbruch getrennte JSON-Datei herunterzuladen:

Console

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

    BigQuery aufrufen

  2. Klicken Sie auf Neue Abfrage erstellen.

  3. Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige SQL-Abfrage ein.

  4. Optional: Klicken Sie auf More (Mehr) und wählen Sie Query settings (Abfrageeinstellungen) aus, um den Verarbeitungsstandort zu ändern. Klicken Sie bei Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus.

  5. Klicken Sie auf Run (Ausführen).

  6. Wenn die Ergebnisse zurückgegeben werden, klicken Sie auf Save results (Ergebnisse speichern) und wählen Sie das Format/den Standort zum Speichern der Ergebnisse aus.

    Die Datei wird in das Standard-Downloadverzeichnis Ihres Browsers heruntergeladen.

Abfrageergebnisse in Google Drive speichern

Das Speichern von Abfrageergebnissen in Google Drive wird vom bq-Befehlszeilentool und der API nicht unterstützt.

Verwenden Sie die Cloud Console, um Abfrageergebnisse in Google Drive zu speichern:

Console

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

    BigQuery aufrufen

  2. Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige SQL-Abfrage ein.

  3. Klicken Sie auf Ausführen.

  4. Wenn die Ergebnisse zurückgegeben werden, klicken Sie auf Ergebnisse speichern.

    Schaltfläche zum Speichern der Ergebnisse

  5. Wählen Sie CSV (Google Drive) oder JSON (Google Drive) aus. Wenn Sie Ergebnisse in Google Drive speichern, können Sie den Standort nicht auswählen. Die Ergebnisse werden immer im Stammverzeichnis "Meine Ablage" gespeichert.

  6. Es kann einige Minuten dauern, bis die Ergebnisse in Google Drive gespeichert sind. Wenn die Ergebnisse dort gespeichert sind, erhalten Sie eine Pop-up-Meldung mit dem Dateinamen im Format bq-results-[TIMESTAMP]-[RANDOM_CHARACTERS].[CSV or JSON].

    Schaltfläche zum Speichern der Ergebnisse

  7. Klicken Sie in der Pop-up-Meldung auf Öffnen, um die Datei zu öffnen, oder wechseln Sie zu Google Drive und klicken Sie auf Meine Ablage.

Abfrageergebnisse in Google Tabellen speichern

Das Speichern von Abfrageergebnissen in Google Tabellen wird vom bq-Befehlszeilentool und der API nicht unterstützt.

Verwenden Sie die Cloud Console, um Abfrageergebnisse in Google Tabellen zu speichern:

Console

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

    BigQuery aufrufen

  2. Klicken Sie auf Neue Abfrage erstellen.

  3. Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige SQL-Abfrage ein.

  4. Optional: Klicken Sie auf More (Mehr) und wählen Sie Query settings (Abfrageeinstellungen) aus, um den Verarbeitungsstandort zu ändern. Klicken Sie bei Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus.

  5. Klicken Sie auf Run (Ausführen).

  6. Wenn die Ergebnisse zurückgegeben werden, klicken Sie auf Save results (Ergebnisse speichern) und wählen Sie Google Sheets (Google Tabellen) aus.

  7. Wenn Sie dazu aufgefordert werden, melden Sie sich bei Ihrem Google-Konto an und klicken Sie auf Zulassen, um BigQuery die Berechtigung zu erteilen, die Daten in den Ordner MY Drive in Google Drive zu schreiben.

    Nachdem Sie den Aufforderungen gefolgt sind, erhalten Sie eine E-Mail etwa mit folgendem Betreff: "Mit Ihrem Google-Konto verbundene BigQuery-Clienttools". Die E-Mail enthält Informationen zu den von Ihnen erteilten Berechtigungen sowie eine Anleitung zum Entziehen der Berechtigungen.

  8. Wenn die Ergebnisse gespeichert wurden, wird unter den Abfrageergebnissen in der Cloud Console eine Meldung angezeigt, die in etwa so aussieht: Saved to Sheets as "results-20190225-103531. Open. Klicken Sie in der Meldung auf den Link, um die Ergebnisse in Google Tabellen aufzurufen, oder wechseln Sie zum Ordner My Drive und öffnen Sie die Datei manuell.

    Wenn Sie Abfrageergebnisse in Google Tabellen speichern, beginnt der Dateiname mit results-[DATE], wobei [DATE] das aktuelle Datum im Format YYYYMMDD ist.