Exécuter des tâches de requête interactives et par lot

Ce document explique comment exécuter des tâches de requête interactives (à la demande) et par lot.

Autorisations requises

Les tâches sont des actions que BigQuery exécute en votre nom pour charger, exporter, interroger ou copier des données.

Lorsque vous effectuez ces actions à l'aide de la console, de la CLI ou de l'UI Web classique de BigQuery, une ressource de tâche est automatiquement créée, planifiée et exécutée. Vous pouvez également créer une tâche de chargement, d'exportation, de requête ou de copie de manière automatisée. Dans ce cas, BigQuery planifie et exécute la tâche à votre place.

Comme les tâches peuvent durer un certain temps, elles s'exécutent de manière asynchrone, et il est possible d'interroger leur état. Les actions plus courtes (telles que la récupération d'une liste de ressources ou l'obtention de métadonnées) ne sont pas gérées par une ressource de tâche.

L'exécution d'une tâche de requête nécessite des autorisations bigquery.jobs.create. Pour que la tâche de requête aboutisse, l'utilisateur ou le groupe doit aussi avoir accès à l'ensemble de données contenant les tables référencées par la requête.

Vous pouvez définir des autorisations bigquery.jobs.create au niveau du projet en accordant l'un des rôles IAM prédéfinis suivants :

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

Si vous accordez à un utilisateur ou à un groupe le rôle bigquery.user au niveau du projet, il ne disposera, par défaut, d'aucun accès aux ensembles de données, aux tables ou aux vues du projet. Le rôle bigquery.user permet aux utilisateurs de créer leurs propres ensembles de données et d'exécuter des tâches de requête sur des ensembles de données auxquels ils ont accès. Si vous accordez le rôle bigquery.user ou bigquery.jobUser, vous devez également attribuer des contrôles d'accès à chaque ensemble de données auquel l'utilisateur ou le groupe doit accéder, mais qu'il n'a pas créé.

Lorsque vous attribuez l'accès à un ensemble de données, trois options sont disponibles :

  • "Consultation autorisée" correspond au rôle bigquery.dataViewer concernant cet ensemble de données.
  • "Modification autorisée" correspond au rôle bigquery.dataEditor concernant cet ensemble de données.
  • "Propriétaire" correspond au rôle bigquery.dataOwner concernant cet ensemble de données.

Pour pouvoir exécuter une requête, l'utilisateur doit au moins disposer de l'accès "Consultation autorisée".

Pour en savoir plus sur les rôles IAM dans BigQuery, consultez la page Contrôle des accès.

Exécuter des requêtes interactives

Par défaut, BigQuery exécute des tâches de requête interactives (à la demande), ce qui signifie que ces dernières sont exécutées dès que possible. Les requêtes interactives sont comptabilisées dans votre limite de débit simultanée et votre limite quotidienne.

Les résultats de requête sont toujours enregistrés dans une table temporaire ou permanente. Vous pouvez choisir d'ajouter les données à une table existante ou de les utiliser pour écraser cette dernière. Vous avez également la possibilité de créer une table s'il n'en existe aucune du même nom.

Pour exécuter une requête interactive qui écrit dans une table temporaire, procédez comme suit :

Console

  1. Ouvrez l'interface utilisateur Web de BigQuery dans la console GCP.
    Accéder à l'interface utilisateur Web de BigQuery

  2. Cliquez sur Compose new query (Saisir une nouvelle requête).

    Saisir une nouvelle requête

  3. Saisissez une requête SQL BigQuery valide dans la zone de texte de l'éditeur de requête.

  4. (Facultatif) Pour modifier l'emplacement de traitement des données, cliquez sur Plus, puis sur Paramètres de requête. Dans le champ Zone de traitement, cliquez sur Sélection automatique et choisissez l'emplacement de vos données. Cliquez ensuite sur Enregistrer pour mettre à jour les paramètres de la requête.

  5. Cliquez sur Exécuter.

Cette action crée une tâche de requête qui écrit les résultats dans une table temporaire.

UI classique

  1. Accédez à l'UI Web de BigQuery.
    Accéder à l'interface utilisateur Web de BigQuery

  2. Cliquez sur Saisir une requête.

  3. Saisissez une requête SQL BigQuery valide dans la zone de texte Nouvelle requête.

  4. Cliquez sur Afficher les options.

  5. (Facultatif) Dans le champ Zone de traitement, cliquez sur Non spécifiée et sélectionnez l'emplacement de vos données.

  6. Cliquez sur Exécuter la requête.

Cette action crée une tâche de requête qui écrit les résultats dans une table temporaire.

Ligne de commande

Exécutez la commande bq query, puis incluez le texte de votre requête. Spécifiez le paramètre --location et définissez la valeur correspondant à votre emplacement.

Vous pouvez spécifier les paramètres facultatifs suivants. Cette liste comprend certains des paramètres les plus courants. Pour obtenir la liste complète des paramètres de la commande query, consultez la section bq query dans la documentation de référence de l'outil de ligne de commande bq.

Spécifiez les paramètres suivants :

  • Le paramètre --destination_table pour créer une table permanente basée sur les résultats de la requête. Pour écrire les résultats des requêtes dans une table qui n'est pas dans votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données au format suivant : [PROJECT_ID]:[DATASET]. Si le paramètre --destination_table n'est pas spécifié, une tâche de requête est générée. Elle écrit les résultats dans une table (en cache) temporaire.
  • Le paramètre --append_table pour ajouter les résultats de la requête à une table de destination.
  • Le paramètre --destination_kms_key pour utiliser une clé Cloud KMS permettant de chiffrer les données de la table de destination.
  • Le paramètre --use_legacy_sql=false pour utiliser la syntaxe SQL standard. Vous pouvez définir une syntaxe par défaut pour l'outil de ligne de commande à l'aide du fichier .bigqueryrc.
  • Le paramètre --label pour appliquer une étiquette à la tâche de requête sous la forme [KEY]:[VALUE]. Répétez ce paramètre pour spécifier plusieurs étiquettes.
  • Le paramètre --max_rows ou -n pour spécifier le nombre de lignes à renvoyer dans les résultats de la requête.
  • Le paramètre --maximum_bytes_billed pour limiter le nombre d'octets facturé pour la requête. Si la requête dépasse la limite, elle échoue (sans frais). Si le paramètre n'est pas spécifié, le nombre d'octets facturés est défini sur la valeur par défaut du projet.
  • Le paramètre --udf_resource pour charger et évaluer un fichier de code à utiliser comme ressource de fonction définie par l'utilisateur. Vous pouvez spécifier un URI Cloud Storage ou le chemin d'accès à un fichier de code local. Répétez ce paramètre pour spécifier plusieurs fichiers.

Saisissez la commande suivante pour exécuter une requête interactive à l'aide de la syntaxe SQL standard :

bq --location=[LOCATION] query --use_legacy_sql=false '[QUERY]'

Où :

  • [LOCATION] est le nom de la zone dans laquelle la requête est traitée. Le paramètre --location est facultatif. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, définissez la valeur du paramètre sur asia-northeast1. Vous pouvez spécifier une valeur par défaut pour l'emplacement à l'aide du fichier .bigqueryrc.
  • [QUERY] est une requête en syntaxe SQL standard.

Exemples :

Saisissez la commande suivante pour écrire les résultats d'une requête interactive dans une table de destination nommée mytable dans mydataset. L'ensemble de données se trouve dans votre projet par défaut. La requête extrait les données de l'ensemble de données public USA Name Data.

bq --location=US 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'

Saisissez la commande suivante pour écrire les résultats d'une requête interactive dans une table de destination nommée mytable dans mydataset. L'ensemble de données se trouve dans myotherproject, et non dans votre projet par défaut. La requête extrait les données d'une table non partitionnée, l'ensemble de données public USA Name Data.

bq --location=US 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'

Pour en savoir plus, consultez la section Utiliser l'outil de ligne de commande bq.

API

Pour exécuter une requête à l'aide de l'API, insérez une nouvelle tâche, puis définissez la propriété jobs#configuration.query. Spécifiez l'emplacement dans la propriété location de la section jobReference de la ressource de tâche.

Interrogez les résultats en appelant getQueryResults jusqu'à ce que jobComplete ait la valeur true. Recherchez les erreurs et les avertissements dans la liste des erreurs.

C#

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour C# dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery C#.

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

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")

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"
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.Println(row)
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Java.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Node.js dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Node.js.

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

async function query() {
  // Queries the Shakespeare dataset with the cache disabled.

  // Create a client
  const bigqueryClient = new BigQuery();

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;
  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 bigqueryClient.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));
}
query();

PHP

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour PHP dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery PHP.

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

Avant d'essayer cet exemple, suivez la procédure de configuration de Python dans le guide de démarrage rapide de BigQuery à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()

query = (
    "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` "
    'WHERE state = "TX" '
    "LIMIT 100"
)
query_job = client.query(
    query,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
)  # API request - starts the query

for row in query_job:  # API request - fetches results
    # Row values can be accessed by field name or index
    assert row[0] == row.name == row["name"]
    print(row)

Ruby

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Ruby dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Ruby.

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

Exécuter des requêtes par lot

BigQuery propose également des requêtes par lot. Il met en file d'attente chaque requête par lot en votre nom et en lance une dès que des ressources inactives sont disponibles, généralement en quelques minutes. Si BigQuery n'a pas lancé la requête dans les 24 heures, il modifie la priorité de la tâche en interactive.

Les requêtes par lot ne sont pas comptabilisées dans votre limite de débit simultané, ce qui peut faciliter le lancement de plusieurs requêtes à la fois. Elles utilisent les mêmes ressources que les requêtes interactives (à la demande). Si vous avez opté pour un tarif forfaitaire, les requêtes par lot et les requêtes interactives partagent les emplacements attribués.

Pour exécuter une requête par lot, procédez comme suit :

Console

  1. Ouvrez l'interface utilisateur Web de BigQuery dans la console GCP.
    Accéder à l'interface utilisateur Web de BigQuery

  2. Cliquez sur le bouton Compose new query (Saisir une nouvelle requête).

    Saisir une nouvelle requête

  3. Saisissez une requête SQL BigQuery valide dans la zone de texte de l'éditeur de requête.

  4. Cliquez sur le bouton More (Plus), puis sur Query settings (Paramètres de la requête).

    Paramètres de requête

  5. Sélectionnez l'option Batch (Lot) dans la section Job priority (Priorité de la tâche).

    Exécution par lots

  6. (Facultatif) Dans le champ Zone de traitement, cliquez sur Non spécifiée et sélectionnez l'emplacement de vos données.

  7. Cliquez sur Enregistrer pour mettre à jour les paramètres de la requête.

  8. Cliquez sur le bouton Exécuter.

UI classique

  1. Accédez à l'UI Web de BigQuery.
    Accéder à l'interface utilisateur Web de BigQuery

  2. Cliquez sur le bouton Saisir une requête.

  3. Saisissez une requête SQL BigQuery valide dans la zone de texte Nouvelle requête.

  4. Cliquez sur le bouton Afficher les options.

  5. Sélectionnez l'option Par lot dans la section Priorité de la requête.

  6. (Facultatif) Dans le champ Zone de traitement, cliquez sur Non spécifiée et sélectionnez l'emplacement de vos données.

  7. Cliquez sur le bouton Exécuter la requête.

Ligne de commande

Exécutez la commande bq query, puis incluez le texte de votre requête. Spécifiez le paramètre --batch pour exécuter une requête par lot. Définissez le paramètre --location sur la valeur correspondant à votre emplacement.

Vous pouvez spécifier les paramètres facultatifs suivants. Cette liste comprend certains des paramètres les plus courants. Pour obtenir la liste complète des paramètres de la commande query, consultez la section bq query dans la documentation de référence de l'outil de ligne de commande bq.

Spécifiez les paramètres suivants :

  • Le paramètre --destination_table pour créer une table permanente basée sur les résultats de la requête. Pour écrire les résultats des requêtes dans une table qui n'est pas dans votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données au format suivant : [PROJECT_ID]:[DATASET]. Si le paramètre --destination_table n'est pas spécifié, une tâche de requête est générée. Elle écrit les résultats dans une table (en cache) temporaire.
  • Le paramètre --append_table pour ajouter les résultats de la requête à une table de destination.
  • Le paramètre --destination_kms_key pour utiliser une clé Cloud KMS permettant de chiffrer les données de la table de destination.
  • Le paramètre --use_legacy_sql=false pour utiliser la syntaxe SQL standard. Vous pouvez définir une syntaxe par défaut pour l'outil de ligne de commande à l'aide du fichier .bigqueryrc.
  • Le paramètre --label pour appliquer une étiquette à la tâche de requête sous la forme [KEY]:[VALUE]. Répétez ce paramètre pour spécifier plusieurs étiquettes.
  • Le paramètre --max_rows ou -n pour spécifier le nombre de lignes à renvoyer dans les résultats de la requête.
  • Le paramètre --maximum_bytes_billed pour limiter le nombre d'octets facturé pour la requête. Si la requête dépasse la limite, elle échoue (sans frais). Si le paramètre n'est pas spécifié, le nombre d'octets facturés est défini sur la valeur par défaut du projet.
  • Le paramètre --udf_resource pour charger et évaluer un fichier de code à utiliser comme ressource de fonction définie par l'utilisateur. Vous pouvez spécifier un URI Cloud Storage ou le chemin d'accès à un fichier de code local. Répétez ce paramètre pour spécifier plusieurs fichiers.

Saisissez la commande suivante pour exécuter une requête par lot à l'aide de la syntaxe SQL standard :

bq --location=[LOCATION] query --batch --use_legacy_sql=false '[QUERY]'

Où :

  • [LOCATION] est le nom de la zone dans laquelle la requête est traitée. Ce paramètre --location est facultatif. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, définissez la valeur du paramètre sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • [QUERY] est une requête en syntaxe SQL standard.

Exemples :

Saisissez la commande suivante pour écrire les résultats de la requête par lot dans une table de destination nommée mytable dans mydataset. L'ensemble de données se trouve dans votre projet par défaut. La requête extrait les données de l'ensemble de données public USA Name Data.

bq --location=US 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'

Saisissez la commande suivante pour écrire les résultats de la requête par lot dans une table de destination nommée mytable dans mydataset. L'ensemble de données se trouve dans myotherproject, et non dans votre projet par défaut. La requête extrait les données d'une table non partitionnée, l'ensemble de données public USA Name Data.

bq --location=US 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'

Pour en savoir plus, consultez la section Utiliser l'outil de ligne de commande bq.

API

Pour exécuter une requête à l'aide de l'API, insérez une nouvelle tâche, puis définissez la propriété jobs#configuration.query. Spécifiez l'emplacement dans la propriété location de la section jobReference de la ressource de tâche.

Lorsque vous spécifiez les propriétés de la tâche de requête, incluez la propriété configuration.query.priority en définissant sa valeur sur BATCH.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Go.

	// To run this sample, you will need to create (or reuse) a context and
	// an instance of the bigquery client.  For example:
	// import "cloud.google.com/go/bigquery"
	// ctx := context.Background()
	// client, err := bigquery.NewClient(ctx, "your-project-id")
	// 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.Printf("Job %s in Location %s currently in state: %s\n", job.ID(), job.Location(), state)

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Java.

Pour exécuter une requête par lot, définissez la priorité de la requête sur QueryJobConfiguration.Priority.BATCH lors de la création d'une classe QueryJobConfiguration.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    QueryJobConfiguration.newBuilder(query)
        // Run at batch priority, which won't count toward concurrent rate
        // limit.
        .setPriority(QueryJobConfiguration.Priority.BATCH)
        .build();

// Location must match that of the dataset(s) referenced in the query.
JobId jobId = JobId.newBuilder().setRandomJob().setLocation("US").build();
String jobIdString = jobId.getJob();

// API request - starts the query.
bigquery.create(JobInfo.newBuilder(queryConfig).setJobId(jobId).build());

// Check on the progress by getting the job's updated state. Once the state
// is `DONE`, the results are ready.
Job queryJob = bigquery.getJob(
    JobId.newBuilder().setJob(jobIdString).setLocation("US").build());
System.out.printf(
    "Job %s in location %s currently in state: %s%n",
    queryJob.getJobId().getJob(),
    queryJob.getJobId().getLocation(),
    queryJob.getStatus().getState().toString());

Python

Avant d'essayer cet exemple, suivez la procédure de configuration de Python dans le guide de démarrage rapide de BigQuery à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()

job_config = bigquery.QueryJobConfig()
# Run at batch priority, which won't count toward concurrent rate limit.
job_config.priority = bigquery.QueryPriority.BATCH
sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""
# Location must match that of the dataset(s) referenced in the query.
location = "US"

# API request - starts the query
query_job = client.query(sql, location=location, job_config=job_config)

# 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=location
)  # API request - fetches job
print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.