Effectuer une simulation de requête

Lorsque vous exécutez une requête dans l'outil de ligne de commande bq, vous pouvez utiliser l'option --dry_run pour estimer le nombre d'octets lus par la requête. Vous pouvez également utiliser le paramètre dryRun lorsque vous envoyez une tâche de requête à l'aide de l'API ou des bibliothèques clientes.

L'estimation renvoyée par la simulation vous permettra de calculer les coûts de requête dans le simulateur de coût. L'exécution d'une simulation ne vous est pas facturée.

Autorisations requises

Pour exécuter une tâche de requête, vous devez disposer au minimum des autorisations bigquery.jobs.create. Ensuite, pour que cette tâche de requête aboutisse, vous devez également disposer d'un accès aux tables ou aux vues référencées par la requête. L'accès aux tables ou aux vues peut être accordé aux niveaux suivants, classés par ordre de ressources autorisées (de la plus grande à la plus petite) :

• à un niveau élevé dans la hiérarchie des ressources Google Cloud (par exemple, au niveau du projet, du dossier ou de l'organisation)
• au niveau d'un ensemble de données
• au niveau de la table

Les rôles Cloud IAM prédéfinis suivants incluent les autorisations bigquery.jobs.create :

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

Remarque : La plupart des utilisateurs, tels que les analystes de données et les data scientists, doivent disposer du rôle bigquery.user ou bigquery.jobUser pour exécuter des tâches de requête. Le rôle bigquery.admin dispose de toutes les autorisations BigQuery. Vous pouvez également créer un rôle personnalisé doté de toutes les autorisations requises.

En outre, si un utilisateur possède des autorisations bigquery.datasets.create, lorsqu'il crée un ensemble de données, il obtient également le rôle bigquery.dataOwner qui lui permet d'y accéder. L'accès bigquery.dataOwner permet à l'utilisateur d'interroger des tables et des vues dans l'ensemble de données.

Pour en savoir plus sur les rôles IAM dans BigQuery, consultez la page Rôles et autorisations prédéfinis.

Effectuer des simulations

Vous pouvez effectuer une simulation de tâche de requête de plusieurs façons :

• L'option --dry_run avec la commande query dans l'outil de ligne de commande bq
• En définissant le paramètre dryRun dans la configuration de la tâche lorsque vous utilisez l'API ou les bibliothèques clientes

Effectuer une simulation

Pour effectuer une simulation, procédez comme suit :

Console

Actuellement, vous ne pouvez pas effectuer de simulation à l'aide de Cloud Console.

UI classique

Actuellement, vous ne pouvez pas effectuer de simulation à l'aide de l'interface utilisateur Web.

bq

Saisissez une requête semblable à celle-ci à l'aide de l'option --dry_run.

bq query \
--use_legacy_sql=false \
--dry_run \
'SELECT
   COUNTRY,
   AIRPORT,
   IATA
 FROM
   `project_id`.dataset.airports
 LIMIT
   1000'
 

La commande produit la réponse suivante :

Query successfully validated. Assuming the tables are not modified,
running this query will process 10918 bytes of data.

Remarque : Si votre requête traite une petite quantité de données, vous devrez peut-être convertir les Ko en Mo. Le Mo est la plus petite unité de mesure utilisée par le simulateur de coût.

API

Pour effectuer une simulation avec l'API, envoyez une tâche de requête avec la valeur dryRun définie sur true dans le type JobConfiguration.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go décrite 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 en langage Go.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"

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

// queryDryRun demonstrates issuing a dry run query to validate query structure and
// provide an estimate of the bytes scanned.
func queryDryRun(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,
		COUNT(*) as name_count
	FROM ` + "`bigquery-public-data.usa_names.usa_1910_2013`" + `
	WHERE state = 'WA'
	GROUP BY name`)
	q.DryRun = true
	// 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
	}
	// Dry run is not asynchronous, so get the latest status and statistics.
	status := job.LastStatus()
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "This query will process %d bytes\n", status.Statistics.TotalBytesProcessed)
	return nil
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java décrite 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.

Afficher sur GitHub Commentaires

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobStatistics;
import com.google.cloud.bigquery.QueryJobConfiguration;

// Sample to run dry query on the table
public class QueryDryRun {

  public static void runQueryDryRun() {
    String query =
        "SELECT name, COUNT(*) as name_count "
            + "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
            + "WHERE state = 'WA' "
            + "GROUP BY name";
    queryDryRun(query);
  }

  public static void queryDryRun(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).setDryRun(true).setUseQueryCache(false).build();

      Job job = bigquery.create(JobInfo.of(queryConfig));
      JobStatistics.QueryStatistics statistics = job.getStatistics();

      System.out.println(
          "Query dry run performed successfully." + statistics.getTotalBytesProcessed());
    } catch (BigQueryException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Python

Pour effectuer une simulation avec la bibliothèque cliente Python, définissez la propriété QueryJobConfig.dry_run sur True. La méthode Client.query() renvoie toujours une tâche QueryJob terminée lorsque vous lui transmettez une configuration de requête simulée.

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Python décrite 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 en langage Python.

Afficher sur GitHub Commentaires

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)

# Start the query, passing in the extra configuration.
query_job = client.query(
    (
        "SELECT name, COUNT(*) as name_count "
        "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
        "WHERE state = 'WA' "
        "GROUP BY name"
    ),
    job_config=job_config,
)  # Make an API request.

# A dry run query completes immediately.
print("This query will process {} bytes.".format(query_job.total_bytes_processed))