Utiliser les résultats de requête mis en cache

Ce document décrit comment utiliser les résultats mis en cache dans BigQuery.

Présentation

BigQuery écrit tous les résultats de requête dans une table. Il s'agit soit d'une table explicitement identifiée par l'utilisateur (une table de destination), soit d'une table temporaire de résultats mis en cache. Les tables temporaires de résultats mis en cache sont gérées par utilisateur et par projet. Il n'y a aucun coût de stockage pour les tables temporaires, mais si vous écrivez des résultats de requête dans une table permanente, le stockage des données vous est facturé.

Tous les résultats de requête, y compris ceux des requêtes interactives et par lots, sont mis en cache dans des tables temporaires pendant environ 24 heures, à quelques exceptions près.

Limites

L'utilisation du cache de requêtes est soumise aux limites suivantes :

  • Lorsque vous exécutez une requête en double, BigQuery tente de réutiliser les résultats mis en cache. Pour récupérer des données du cache, le texte de la requête en double doit être identique à celui de la requête d'origine.
  • Pour que les résultats de requête persistent dans une table de résultats mis en cache, l'ensemble de résultats doit être inférieur à la taille de réponse maximale. Pour plus d'informations sur la gestion d'ensembles de résultats volumineux, consultez la section sur le renvoi des résultats de requête volumineux.
  • Vous ne pouvez pas cibler de tables de résultats mis en cache avec des instructions LMD.
  • Bien que la sémantique actuelle le permette, l'utilisation de résultats mis en cache en entrée pour les tâches dépendantes est vivement déconseillée. Par exemple, vous ne devez pas soumettre de tâches de requête qui extraient les résultats de la table de cache. À la place, écrivez vos résultats dans une table de destination nommée. Pour faciliter le nettoyage, des fonctionnalités peuvent faire expirer automatiquement les données après une certaine durée. C'est le cas, par exemple, de la propriété defaultTableExpirationMs au niveau des ensembles de données.

Tarifs et quotas

Lorsque les résultats de requête sont extraits d'une table de résultats mis en cache, la propriété statistics.query.cacheHit des statistiques de tâche renvoie la valeur true, et la requête n'est pas facturée. Bien que les requêtes qui utilisent des résultats mis en cache ne soient pas payantes, elles restent soumises aux règles de quotas de BigQuery. Permettant non seulement de réduire les coûts, ce type de requête est aussi beaucoup plus rapide, car BigQuery n'a pas besoin de calculer l'ensemble de résultats.

Exceptions à la mise en cache des requêtes

Les résultats de requête ne sont pas mis en cache :

  • lorsqu'une table de destination est spécifiée dans la configuration de la tâche, la console GCP, l'interface utilisateur Web classique, la ligne de commande ou l'API ;
  • si l'une des tables référencées ou des vues logiques a changé depuis la dernière mise en cache des résultats ;
  • lorsque des tables référencées par la requête ont récemment reçu des insertions en flux continu (un tampon de diffusion en continu est associé à la table), même si aucune nouvelle ligne n'est arrivée ;
  • si la requête utilise des fonctions non déterministes (par exemple, les fonctions de date et heure, telles que CURRENT_TIMESTAMP() et NOW(), ainsi que d'autres fonctions comme CURRENT_USER(), renvoient des valeurs différentes selon le moment où une requête est exécutée) ;
  • si vous interrogez plusieurs tables à l'aide d'un caractère générique ;
  • si les résultats mis en cache ont expiré (la durée de vie du cache est de 24 heures en général, mais les résultats mis en cache sont les meilleurs possible et peuvent être annulés plus tôt) ;
  • si la requête s'exécute sur une source de données externe.

Stocker les résultats mis en cache

Lorsque vous exécutez une requête, une table temporaire de résultats mis en cache est créée dans un ensemble de données spécial appelé "ensemble de données anonyme". Contrairement aux ensembles de données standards qui héritent des autorisations du modèle de hiérarchie des ressources IAM (autorisations de projet et d'organisation), les ensembles de données anonymes ne sont accessibles que par leur propriétaire. Le propriétaire d'un ensemble de données anonyme correspond à l'utilisateur qui a exécuté la requête ayant généré le résultat mis en cache.

Lorsqu'un ensemble de données anonyme est créé, un accès OWNER (propriétaire) à ce dernier est accordé de façon explicite à l'utilisateur qui exécute la tâche de requête. L'accès OWNER n'attribue un contrôle total sur l'ensemble de données qu'à l'utilisateur ayant exécuté la tâche de requête. Il permet entre autres de contrôler entièrement les tables de résultats mises en cache dans l'ensemble de données anonyme. Si vous avez l'intention de partager les résultats de requête, n'utilisez pas les résultats mis en cache qui sont stockés dans un ensemble de données anonyme. Il est préférable d'écrire les résultats dans une table de destination nommée.

Bien que l'utilisateur qui exécute la requête ait un accès complet à l'ensemble de données et à la table de résultats mis en cache, s'en servir comme entrées pour les tâches dépendantes est vivement déconseillé.

Les noms des ensembles de données anonymes commencent par un trait de soulignement. Cela permet de les masquer dans la liste des ensembles de données de la console GCP et dans l'interface utilisateur Web classique de BigQuery. Vous pouvez répertorier les ensembles de données anonymes et auditer les contrôles des accès aux ensembles de données anonymes à l'aide de la CLI ou de l'API.

Désactiver la récupération des résultats mis en cache

L'option Utiliser les résultats mis en cache permet de réutiliser les résultats d'une exécution précédente de la même requête, sauf si les tables interrogées ont été modifiées. L'utilisation des résultats mis en cache n'est utile que pour les requêtes répétées. Bien qu'elle soit activée par défaut, l'option Utiliser les résultats mis en cache n'a aucun effet sur les nouvelles requêtes.

Lorsque vous répétez une requête avec l'option Utiliser les résultats mis en cache désactivée, le résultat mis en cache existant est écrasé. Pour cela, BigQuery doit calculer le résultat de la requête, et le coût de la requête vous est facturé. Ceci est particulièrement utile dans les cas d'analyse comparative.

Si vous souhaitez désactiver la récupération des résultats mis en cache et forcer l'évaluation en direct d'une tâche de requête, vous pouvez définir la propriété configuration.query.useQueryCache de votre tâche de requête sur false.

Pour désactiver l'option Utiliser les résultats mis en cache, procédez comme suit :

Console

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

  2. Cliquez sur 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 More (Plus) et sélectionnez Query settings (Paramètres de requête).

    Paramètres de requête

  5. Sous Cache preference (Préférence en matière de cache), décochez l'option Use cached results (Utiliser les résultats mis en cache).

    Résultats mis en cache

UI classique

  1. Accédez à l'UI Web classique de BigQuery.
    Accéder à l'UI 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 Afficher les options.

  5. Décochez la case Use Cached Results (Utiliser les résultats mis en cache).

Ligne de commande

Remplacez le cache de la requête à l'aide du paramètre nouse_cache. Dans l'exemple suivant, BigQuery est obligé de traiter la requête sans utiliser les résultats mis en cache existants :

 bq --location=US query --nouse_cache --batch "SELECT name,count FROM mydataset.names_2013 WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

API

Pour traiter une requête sans utiliser les résultats mis en cache, définissez la propriété useQueryCache sur false.

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 sur 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 corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;")
q.DisableQueryCache = 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
}
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)
}

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 queryDisableCache() {
  // Queries the Shakespeare dataset with the cache disabled.

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

  const query = `SELECT corpus
    FROM \`bigquery-public-data.samples.shakespeare\`
    GROUP BY corpus`;
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    useQueryCache: false,
  };

  // 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));
}
queryDisableCache();

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 traiter une requête sans utiliser les résultats mis en cache, définissez setUseQueryCache sur false lorsque vous créez 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)
        // Disable the query cache to force live query evaluation.
        .setUseQueryCache(false)
        .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");
}

Python

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 sur l'API BigQuery Python.

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

job_config = bigquery.QueryJobConfig()
job_config.use_query_cache = False
sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""
query_job = client.query(
    sql,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
    job_config=job_config,
)  # API request

# Print the results.
for row in query_job:  # API request - fetches results
    print(row)

Assurer l'utilisation du cache

Lorsque vous exécutez une requête à l'aide de la fonction jobs.insert(), vous pouvez forcer l'échec d'une tâche de requête si les résultats mis en cache ne peuvent pas être utilisés. Pour ce faire, définissez la propriété createDisposition de la configuration de la tâche sur CREATE_NEVER.

Si le résultat de la requête n'existe pas dans le cache, une erreur NOT_FOUND est renvoyée.

Vérifier l'utilisation du cache

Il existe deux façons de déterminer si BigQuery a renvoyé un résultat à l'aide du cache :

  • Si vous utilisez la console GCP ou l'interface utilisateur Web classique de BigQuery, la chaîne de résultat ne contient pas d'informations sur le nombre d'octets traités et affiche le mot "cached" (mis en cache).

    Indicateur de cache dans l'interface utilisateur

  • Si vous utilisez l'API BigQuery, la propriété cacheHit figurant dans le résultat de la requête est définie sur true.

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

Envoyer des commentaires concernant…

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