Abfrageergebnisse schreiben

In diesem Dokument wird beschrieben, wie Abfrageergebnisse in temporäre oder permanente Tabellen geschrieben 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 in Abfragen mit mehreren Anweisungen und Sitzungen erstellen.

• 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 Persönlichen verlauf 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.

• Der Zugriff auf die temporären Tabellendaten ist auf das Nutzer- oder Dienstkonto beschränkt, das den Abfragejob erstellt hat.

• Temporäre Tabellen können nicht freigegeben werden. Sie können auch nicht mit der standardmäßigen Auflistungsmethode oder anderen Methoden zur Tabellenbearbeitung sichtbar gemacht werden. Temporäre Tabellen werden in derselben Region wie die abgefragten Tabellen erstellt.

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

Hinweis: Wenn Sie Daten aus einem Projekt nach Daten abfragen, die in einem anderen Projekt gespeichert sind, wird das Abfrageprojekt dem Abfragejob in Rechnung gestellt. Dem Projekt, das die Daten speichert, wird die in BigQuery gespeicherte Datenmenge in Rechnung gestellt.

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.

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 Google Cloud Console die Seite "BigQuery".

   Zur Seite "BigQuery"

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

3. Geben Sie eine gültige SQL-Abfrage ein.

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

   

5. Wählen Sie die Option Zieltabelle für Abfrageergebnisse festlegen aus.

   

6. Wählen Sie unter Ziel das Dataset aus, in dem Sie die Tabelle erstellen möchten, und wählen Sie dann eine Tabellen-ID aus.

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

8. Optional: Wählen Sie als Speicherort der Daten Ihren Standort aus.

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

10. Klicken Sie auf 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 über dem Editor auf die Schaltfläche Ergebnisse speichern.

SQL

Im folgenden Beispiel wird mit der Anweisung CREATE TABLE aus Daten in der öffentlichen Tabelle bikeshare_trips die Tabelle trips erstellt:

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

   BigQuery aufrufen

2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

   CREATE TABLE mydataset.trips AS (
     SELECT
       bike_id,
       start_time,
       duration_minutes
     FROM
       bigquery-public-data.austin_bikeshare.bikeshare_trips
   );
   

3. Klicken Sie auf Ausführen.

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

Weitere Informationen finden Sie unter Neue Tabelle aus einer vorhandenen Tabelle erstellen.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

   Geben Sie eines der folgenden optionalen Flags an, um die Schreibanordnung für eine vorhandene Zieltabelle zu steuern:

   • --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 ist eine Abfrage in der GoogleSQL-Syntax.

     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:

     Hinweis: Diese Beispiele beziehen sich auf die Abfrage eines öffentlichen Datasets in den USA. Da das öffentliche Dataset am multiregionalen Standort "US" gespeichert ist, muss sich das Dataset, das Ihre Zieltabelle enthält, ebenfalls in den USA befinden. Sie können ein Dataset nicht an einem Standort abfragen und die Ergebnisse in eine Zieltabelle an einem anderen Standort schreiben.

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

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

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 GoogleSQL 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 Google 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. 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).

   

5. Aktivieren Sie unter Zie die Option Zieltabelle für Abfrageergebnisse festlegen.

   

6. Wählen Sie unter Dataset das Dataset aus, in dem die Tabelle gespeichert wird.

7. Geben Sie im Feld Tabellen-ID einen Tabellennamen ein.

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

9. Aktivieren Sie für die Ergebnisgröße die Option Große Ergebnisse zulassen (kein Größenlimit).

10. Optional: Wählen Sie unter Speicherort der Daten den Standort Ihrer Daten aus.

11. Klicken Sie auf Save (Speichern), um die Abfrageeinstellungen zu aktualisieren.

12. Klicken Sie auf 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:

Hinweis: Diese Beispiele beziehen sich auf die Abfrage eines öffentlichen Datasets. Da das Dataset am multiregionalen Standort US gespeichert wird, muss sich das Ziel-Dataset auch in den USA befinden. Sie können die Abfrageergebnisse für öffentliche Datasets nicht in eine Tabelle in einer anderen Region schreiben.

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

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

# 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 Google Cloud Console herunterladen und speichern

Nach dem Ausführen einer SQL-Abfrage mithilfe der Google Cloud Console können Sie die Ergebnisse an einem anderen Ort speichern. Sie können mit der Google Cloud Console Abfrageergebnisse in eine lokale Datei, Google Tabellen oder Google Drive herunterladen. Wenn Sie die Abfrageergebnisse zuerst nach Spalte (Vorschau) sortieren, wird die Reihenfolge in den heruntergeladenen Daten beibehalten. Das Speichern von Ergebnissen in einer lokalen Datei, Google Tabellen oder Google Drive wird vom bq-Befehlszeilentool und von 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 in Google Tabellen gespeichert werden.
• Die Ergebnismenge darf maximal 1 GB groß sein, wenn Abfrageergebnisse mit der Google Cloud Console in Google Drive gespeichert werden sollen. Wenn Ihre Ergebnisse größer sind, können Sie diese stattdessen in einer Tabelle speichern.
• Beim Speichern einer Abfrageergebnisse in einer lokalen CSV-Datei beträgt die maximale Downloadgröße 10 MB. Die maximale Downloadgröße basiert auf der Größe jeder Zeile, die in der Antwort der Methode tabledata.list zurückgegeben wird. Sie kann je nach Schema der Abfrageergebnisse variieren. Daher kann die Größe der heruntergeladenen CSV-Datei variieren und unterhalb der Grenze des maximalen Downloads liegen.
• Abfrageergebnisse können nur im CSV- oder im durch Zeilenumbruch getrennten JSON-Format in Google Drive gespeichert werden.

Nächste Schritte

• Tabelle programmatisch in eine JSON-Datei exportieren
• Weitere Informationen zu Kontingenten für Abfragejobs
• Informationen zu BigQuery-Speicherpreisen