Interaktive und Batch-Abfragejobs ausführen

In diesem Dokument wird beschrieben, wie Sie interaktive (On-Demand) und Batch-Abfragejobs ausführen.

Die Abfrageergebnisse werden entweder in einer temporären oder permanenten Tabelle gespeichert. Sie können auswählen, ob Sie Daten in einer vorhandenen Tabelle anhängen oder überschreiben möchten oder ob Sie eine neue Tabelle erstellen, wenn keine mit demselben Namen vorhanden ist.

Erforderliche Berechtigungen

Zum Ausführen eines Abfragejobs müssen Sie mindestens bigquery.jobs.create-Berechtigungen haben. Damit ein Abfragejob erfolgreich abgeschlossen werden kann, benötigen Sie auch Zugriff auf die Tabellen oder Ansichten, auf die sich die Abfrage bezieht. Der Zugriff auf die Tabellen oder Ansichten kann auf folgenden Ebenen gewährt werden, aufgeführt vom größten zulässigen Ressourcenbereich zum kleinsten:

auf übergeordneter Ebene in der Google Cloud-Ressourcenhierarchie, also auf Projekt-, Ordner- oder Organisationsebene
auf Dataset-Ebene
auf Tabellenebene

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

bigquery.user
bigquery.jobUser
bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, wird ihm dafür außerdem bigquery.dataOwner-Zugriff gewährt. Mit bigquery.dataOwner-Zugriff hat der Nutzer die Möglichkeit, Tabellen und Ansichten im Dataset abzufragen.

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

Interaktive Abfragen ausführen

BigQuery führt standardmäßig interaktive Abfragejobs aus. Dies bedeutet, dass die Abfrage so bald wie möglich ausgeführt wird. Interaktive Abfragen werden auf die Limits gleichzeitiger Abfragen und das Tageslimit mit angerechnet.

So führen Sie eine interaktive Abfrage aus, die in eine temporäre Tabelle schreibt:

Console

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

BigQuery aufrufen
Klicken Sie auf Neue Abfrage erstellen.
Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige BigQuery-SQL-Abfrage ein.
Optional: Klicken Sie auf More (Mehr) und dann auf Query settings (Abfrageeinstellungen), um den Ort der Datenverarbeitung zu ändern. Klicken Sie unter Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus. Klicken Sie abschließend auf Save (Speichern), um die Abfrageeinstellungen zu aktualisieren.
Klicken Sie auf Run (Ausführen).

Dies erstellt einen Abfragejob, der die Ausgabe in eine temporäre Tabelle schreibt.

bq

Geben Sie den Befehl bq query ein und fügen Sie den Abfragetext ein.

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

Sie können die folgenden optionalen Flags angeben. Die Liste enthält einige der am häufigsten verwendeten Flags. Eine vollständige Liste der query-Befehls-Flags finden Sie in der Referenz zum bq-Befehlszeilentool unter bq query.

Geben Sie die folgenden Flags an:

Das Flag --destination_table, um eine permanente Tabelle auf Basis der Abfrageergebnisse zu erstellen. 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. Wenn --destination_table nicht angegeben ist, wird ein Abfragejob generiert, der die Ausgabe in eine temporäre (Cache-)Tabelle schreibt.
Das Flag --append_table, um die Abfrageergebnisse an eine Zieltabelle anzufügen.
Das Flag --destination_kms_key, um einen Cloud Key Management Service-Schlüssel zum Verschlüsseln der Zieltabellendaten zu verwenden.
Das Flag --use_legacy_sql=false, um die Standard-SQL-Syntax für die Abfrage zu verwenden. Mithilfe der Datei .bigqueryrc können Sie eine Standardsyntax für das bq-Befehlszeilentool einrichten.
Das Flag --label, um ein Label auf den Abfragejob im Format key:value anzuwenden. Wiederholen Sie dieses Flag, um mehrere Labels anzugeben.
Das Flag --max_rows oder -n, um die Anzahl der in den Abfrageergebnissen zurückzugebenden Zeilen anzugeben.
Das Flag --maximum_bytes_billed, um die für die Abfrage berechneten Byte zu begrenzen. Abfragen, die das Limit überschreiten, schlagen fehl (ohne dass eine Gebühr anfällt). Wenn nicht angegeben, wird die Menge der berechneten Byte auf den Standardwert des Projekts eingestellt.
Das Flag --udf_resource, um eine Codedatei zu laden und auszuwerten, die als benutzerdefinierte Funktionsressource verwendet werden soll. Sie können einen Cloud Storage-URI oder den Pfad zu einer lokalen Codedatei angeben. Wiederholen Sie dieses Flag, um mehrere Dateien anzugeben.

Geben Sie den folgenden Befehl ein, um mit der Standard-SQL-Syntax eine interaktive Abfrage auszuführen:

bq --location=location query \
--use_legacy_sql=false \
'query'

Wobei:

location ist der Name des Standorts, an dem die Abfrage verarbeitet wird. Das Flag --location ist optional. Wenn Sie beispielsweise BigQuery in der Region Tokio verwenden, können Sie den Wert des Flags auf asia-northeast1 setzen. Mit der Datei ".bigqueryrc" können Sie einen Standardwert für den Standort festlegen.
query eine Abfrage in der Standard-SQL-Syntax ist.

Beispiele:

Mit dem folgenden Befehl schreiben Sie interaktive Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in Ihrem Standardprojekt. 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 schreiben Sie interaktive Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in myotherproject und nicht in Ihrem Standardprojekt. Mit der Abfrage werden Daten aus einer nicht partitionierten Tabelle abgerufen, dem öffentlichen Dataset „USA Name Data“.

bq query \
--destination_table myotherproject: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'

API

Sie können die API zum Ausführen einer Abfrage verwenden. Dazu fügen Sie einen neuen Job ein und füllen das Attribut jobs#configuration.query mit Daten. Geben Sie im Abschnitt jobReference der Jobressource Ihren Standort im Attribut location an.

Rufen Sie getQueryResults auf, um die Ergebnisse abzufragen. Führen Sie die Abfrage so lange aus, bis jobComplete gleich true ist. In der Liste errors werden Fehler und Warnungen angezeigt.

C#

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

Auf GitHub ansehen Feedback


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

public class BigQueryQuery
{
    public void Query(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        string query = @"
            SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013`
            WHERE state = 'TX'
            LIMIT 100";
        BigQueryJob job = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: new QueryOptions { UseQueryCache = false });
        // Wait for the job to complete.
        job.PollUntilCompleted();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

Go

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

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// queryBasic demonstrates issuing a query and reading results.
func queryBasic(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	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 name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
			"WHERE state = \"TX\" " +
			"LIMIT 100")
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"
	// 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: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

Auf GitHub ansehen Feedback

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

public class SimpleQuery {

  public static void runSimpleQuery() {
    // TODO(developer): Replace this query before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    simpleQuery(query);
  }

  public static void simpleQuery(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();

      // Create the query job.
      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

      // Execute the query.
      TableResult result = bigquery.query(queryConfig);

      // Print the results.
      result.iterateAll().forEach(rows -> rows.forEach(row -> System.out.println(row.getValue())));

      System.out.println("Query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("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: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Auf GitHub ansehen Feedback

// Import the Google Cloud client library using default credentials
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();
async function query() {
  // Queries the U.S. given names dataset for the state of Texas.

  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/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
  };

  // Run the query as a job
  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));
}

PHP

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

Auf GitHub ansehen Feedback

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

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$jobConfig = $bigQuery->query($query);
$job = $bigQuery->startQuery($jobConfig);

$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
$queryResults = $job->queryResults();

$i = 0;
foreach ($queryResults as $row) {
    printf('--- Row %s ---' . PHP_EOL, ++$i);
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, json_encode($value));
    }
}
printf('Found %s row(s)' . PHP_EOL, $i);

Python

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

Auf GitHub ansehen Feedback


from google.cloud import bigquery

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

query = """
    SELECT name, SUM(number) as total_people
    FROM `bigquery-public-data.usa_names.usa_1910_2013`
    WHERE state = 'TX'
    GROUP BY name, state
    ORDER BY total_people DESC
    LIMIT 20
"""
query_job = client.query(query)  # Make an API request.

print("The query data:")
for row in query_job:
    # Row values can be accessed by field name or index.
    print("name={}, count={}".format(row[0], row["total_people"]))

Ruby

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

Auf GitHub ansehen Feedback

require "google/cloud/bigquery"

def query
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " \
        "WHERE state = 'TX' " \
        "LIMIT 100"

  # Location must match that of the dataset(s) referenced in the query.
  results = bigquery.query sql do |config|
    config.location = "US"
  end

  results.each do |row|
    puts row.inspect
  end
end

Batch-Abfragen ausführen

Außerdem sind in BigQuery Batch-Abfragen möglich. BigQuery stellt jede Batch-Abfrage in Ihrem Namen in die Warteschlange und startet sie, sobald im gemeinsamen Ressourcenpool von BigQuery Ressourcen frei sind, meist innerhalb von ein paar Minuten. Wenn BigQuery die Abfrage nicht innerhalb von 24 Stunden gestartet hat, wird die Jobpriorität in interaktiv geändert.

Batch-Abfragen werden hinsichtlich der Grenze gleichzeitiger Abfragen nicht berücksichtigt. Dadurch ist es unter Umständen einfacher, viele Abfragen auf einmal zu starten. Batch-Abfragen verwenden dieselben Ressourcen wie interaktive Abfragen (On-Demand). Bei Pauschalpreisen teilen sich interaktive und Batch-Abfragen die zugewiesenen Slots.

So führen Sie eine Batch-Abfrage aus:

Console

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

BigQuery aufrufen
Klicken Sie auf die Schaltfläche Neue Abfrage erstellen.
Geben Sie im Textbereich des Abfrageeditors eine gültige SQL-Abfrage ein.
Klicken Sie auf More (Mehr) und dann auf Query settings (Abfrageeinstellungen).
Wählen Sie im Abschnitt Job priority (Jobpriorität) die Option Batchaus.
Optional: Klicken Sie bei Processing location (Verarbeitungsstandort) auf Unspecified (Nicht angegeben) und wählen Sie den Standort Ihrer Daten aus.
Klicken Sie auf Save (Speichern), um die Abfrageeinstellungen zu aktualisieren.
Klicken Sie auf Run (Ausführen).

bq

Geben Sie den Befehl bq query ein und fügen Sie den Abfragetext ein. Verwenden Sie das Flag --batch, um eine Batch-Abfrage auszuführen.

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

Geben Sie die folgenden Flags an:

Das Flag --destination_table, um eine permanente Tabelle auf Basis der Abfrageergebnisse zu erstellen. 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. Wenn --destination_table nicht angegeben ist, wird ein Abfragejob generiert, der die Ausgabe in eine temporäre (Cache-)Tabelle schreibt.
Das Flag --append_table, um die Abfrageergebnisse an eine Zieltabelle anzufügen.
Das Flag --destination_kms_key, um einen Cloud Key Management Service-Schlüssel zum Verschlüsseln der Zieltabellendaten zu verwenden.
Das Flag --use_legacy_sql=false, um die Standard-SQL-Syntax für die Abfrage zu verwenden. Mithilfe der Datei .bigqueryrc können Sie eine Standardsyntax für das bq-Befehlszeilentool einrichten.
Das Flag --label, um ein Label auf den Abfragejob im Format key:value anzuwenden. Wiederholen Sie dieses Flag, um mehrere Labels anzugeben.
Das Flag --max_rows oder -n, um die Anzahl der in den Abfrageergebnissen zurückzugebenden Zeilen anzugeben.
Das Flag --maximum_bytes_billed, um die für die Abfrage berechneten Byte zu begrenzen. Abfragen, die das Limit überschreiten, schlagen fehl (ohne dass eine Gebühr anfällt). Wenn nicht angegeben, wird die Menge der berechneten Byte auf den Standardwert des Projekts eingestellt.
Das Flag --udf_resource, um eine Codedatei zu laden und auszuwerten, die als benutzerdefinierte Funktionsressource verwendet werden soll. Sie können einen Cloud Storage-URI oder den Pfad zu einer lokalen Codedatei angeben. Wiederholen Sie dieses Flag, um mehrere Dateien anzugeben.

Geben Sie den folgenden Befehl ein, um mit der Standard-SQL-Syntax eine interaktive Abfrage auszuführen:

bq --location=location query \
--batch \
--use_legacy_sql=false \
'query'

Wobei:

location ist der Name des Standorts, an dem die Abfrage verarbeitet wird. Das Flag --location ist optional. Wenn Sie beispielsweise BigQuery in der Region Tokio verwenden, können Sie den Wert des Flags auf asia-northeast1 setzen. Mit der Datei ".bigqueryrc" können Sie einen Standardwert für den Standort festlegen.
query eine Abfrage in der Standard-SQL-Syntax ist.

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. Mit der Abfrage werden Daten aus dem öffentlichen Dataset „USA Name Data“ abgerufen.

bq query \
--batch \
--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 schreiben Sie große Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in myotherproject und nicht in Ihrem Standardprojekt. Mit der Abfrage werden Daten aus einer nicht partitionierten Tabelle abgerufen, dem öffentlichen Dataset USA Name Data.

bq query \
--batch \
--destination_table myotherproject: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'

API

Sie können die API zum Ausführen einer Abfrage verwenden. Dazu fügen Sie einen neuen Job ein und füllen das Jobkonfigurationsattribut query mit Daten. Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.

Wenn Sie die Attribute des Abfragejobs angeben, nehmen Sie das Attribut configuration.query.priority mit dem Wert BATCH auf.

Go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"time"

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

// queryBatch demonstrates issuing a query job using batch priority.
func queryBatch(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// dstDatasetID := "mydataset"
	// dstTableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	// Build an aggregate table.
	q := client.Query(`
		SELECT
  			corpus,
  			SUM(word_count) as total_words,
  			COUNT(1) as unique_words
		FROM ` + "`bigquery-public-data.samples.shakespeare`" + `
		GROUP BY corpus;`)
	q.Priority = bigquery.BatchPriority
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)

	// Start the job.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Job is started and will progress without interaction.
	// To simulate other work being done, sleep a few seconds.
	time.Sleep(5 * time.Second)
	status, err := job.Status(ctx)
	if err != nil {
		return err
	}

	state := "Unknown"
	switch status.State {
	case bigquery.Pending:
		state = "Pending"
	case bigquery.Running:
		state = "Running"
	case bigquery.Done:
		state = "Done"
	}
	// You can continue to monitor job progress until it reaches
	// the Done state by polling periodically.  In this example,
	// we print the latest status.
	fmt.Fprintf(w, "Job %s in Location %s currently in state: %s\n", job.ID(), job.Location(), state)

	return nil

}

Java

Zum Ausführen einer Batch-Abfrage legen Sie die Abfragepriorität fest, und zwar auf QueryJobConfiguration.Priority.BATCH, wenn Sie eine QueryJobConfiguration erstellen.

Auf GitHub ansehen Feedback

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

// Sample to query batch in a table
public class QueryBatch {

  public static void runQueryBatch() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String query =
        "SELECT corpus"
            + " FROM `"
            + projectId
            + "."
            + datasetName
            + "."
            + tableName
            + " GROUP BY corpus;";
    queryBatch(query);
  }

  public static void queryBatch(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 =
          QueryJobConfiguration.newBuilder(query)
              // Run at batch priority, which won't count toward concurrent rate limit.
              .setPriority(QueryJobConfiguration.Priority.BATCH)
              .build();

      TableResult results = bigquery.query(queryConfig);

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

      System.out.println("Query batch performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query batch not performed \n" + e.toString());
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

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

async function queryBatch() {
  // Runs a query at batch priority.

  // Create query job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfigurationquery
  const queryJobConfig = {
    query: `SELECT corpus
            FROM \`bigquery-public-data.samples.shakespeare\`
            LIMIT 10`,
    useLegacySql: false,
    priority: 'BATCH',
  };

  // Create job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfiguration
  const jobConfig = {
    // Specify a job configuration to set optional job resource properties.
    configuration: {
      query: queryJobConfig,
    },
  };

  // Make API request.
  const [job] = await bigquery.createJob(jobConfig);

  const jobId = job.metadata.id;
  const state = job.metadata.status.state;
  console.log(`Job ${jobId} is currently in state ${state}`);
}

Python

Auf GitHub ansehen Feedback

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(
    # Run at batch priority, which won't count toward concurrent rate limit.
    priority=bigquery.QueryPriority.BATCH
)

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.

# Check on the progress by getting the job's updated state. Once the state
# is `DONE`, the results are ready.
query_job = client.get_job(
    query_job.job_id, location=query_job.location
)  # Make an API request.

print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))