Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzo dei risultati delle query memorizzati nella cache

BigQuery scrive tutti i risultati delle query in una tabella. La tabella è identificata in modo esplicito dall'utente (una tabella di destinazione) o è una tabella temporanea dei risultati memorizzati nella cache. Le tabelle dei risultati temporanee memorizzate nella cache vengono mantenute per utente per progetto. Non sono previsti costi per l'archiviazione delle tabelle temporanee, ma se scrivi i risultati della query in una tabella permanente, ti viene addebitato il costo di archiviazione dei dati.

Tutti i risultati delle query, incluse le query interattive e batch, vengono memorizzati nella cache in tabelle temporanee per circa 24 ore, con alcune eccezioni.

Limitazioni

L'utilizzo della cache delle query è soggetto alle seguenti limitazioni:

Quando esegui una query duplicata, BigQuery tenta di riutilizzare i risultati memorizzati nella cache. Per recuperare i dati dalla cache, il testo della query duplicata deve corrispondere alla query originale.
Affinché i risultati delle query vengano mantenuti in una tabella dei risultati memorizzati nella cache, il set di risultati deve essere inferiore alla dimensione massima della risposta. Per ulteriori informazioni sulla gestione dei set di risultati di grandi dimensioni, consulta la sezione Restituzione di risultati di query di grandi dimensioni.
Non puoi scegliere come target tabelle di risultati memorizzati nella cache con istruzioni DML.
Sebbene la semantica attuale lo consenta, è sconsigliato utilizzare i risultati memorizzati nella cache come input per i job dipendenti. Ad esempio, non devi inviare job di query che recuperano i risultati dalla tabella della cache. Scrivi invece i risultati in una tabella di destinazione denominata. Per consentire una facile pulizia, funzionalità come la proprietà defaultTableExpirationMs a livello di set di dati possono far scadere automaticamente i dati dopo una determinata durata.

Prezzi e quote

I risultati delle query memorizzati nella cache vengono memorizzati come tabelle temporanee. Non ti viene addebitato alcun costo per l'archiviazione di queste tabelle temporanee. Quando i risultati delle query vengono recuperati da una tabella dei risultati memorizzati nella cache, la proprietà delle statistiche del job statistics.query.cacheHit restituisce true e non ti viene addebitato alcun costo per la query. Anche se non ti viene addebitato alcun costo per le query che utilizzano i risultati memorizzati nella cache, le query sono soggette ai criteri per le quote di BigQuery. Oltre a ridurre i costi, le query che utilizzano i risultati memorizzati nella cache sono molto più veloci perché BigQuery non ha bisogno di calcolare il set di risultati.

Eccezioni per la memorizzazione nella cache delle query

I risultati della query non vengono memorizzati nella cache:

Quando si specifica una tabella di destinazione nella configurazione del job, nella console Google Cloud, nello strumento a riga di comando bq o nell'API
Se una delle tabelle o delle viste logiche a cui viene fatto riferimento è cambiata dopo che i risultati sono stati precedentemente memorizzati nella cache
Quando una delle tabelle a cui viene fatto riferimento dalla query ha ricevuto di recente inserimento di flussi di dati (la tabella contiene dati nello spazio di archiviazione ottimizzato in scrittura), anche se non sono state aggiunte nuove righe
Se la query utilizza funzioni non deterministiche, ad esempio funzioni di data e ora come CURRENT_TIMESTAMP() e CURRENT_DATE e altre funzioni come SESSION_USER(), restituisce valori diversi a seconda di quando viene eseguita una query
Se esegui query su più tabelle utilizzando un carattere jolly
Se i risultati memorizzati nella cache sono scaduti; la durata tipica della cache è di 24 ore, ma i risultati sono memorizzati al meglio e potrebbero essere invalidati prima
Se la query viene eseguita su un'origine dati esterna diversa da Cloud Storage. Le query su Google SQL in Cloud Storage sono supportate dai risultati delle query memorizzati nella cache.
Se la query viene eseguita su una tabella protetta da sicurezza a livello di colonna, i risultati potrebbero non essere memorizzati nella cache.
Se la query viene eseguita su una tabella protetta da sicurezza a livello di riga, i risultati non vengono memorizzati nella cache.

Come vengono memorizzati i risultati memorizzati nella cache

Quando esegui una query, viene creata una tabella temporanea dei risultati memorizzati nella cache in un set di dati speciale denominato "set di dati anonimo". A differenza dei normali set di dati che ereditano le autorizzazioni dal modello di gerarchia delle risorse IAM (autorizzazioni di progetto e organizzazione), l'accesso ai set di dati anonimi è limitato al proprietario. Il proprietario di un set di dati anonimo è l'utente che ha eseguito la query che ha prodotto il risultato memorizzato nella cache. Inoltre, viene controllata l'autorizzazione bigquery.jobs.create sul progetto per verificare che l'utente abbia accesso al progetto.

BigQuery non supporta la condivisione di set di dati anonimi. Se intendi condividere i risultati della query, non utilizzare i risultati memorizzati nella cache in un set di dati anonimo. Scrivi invece i risultati in una tabella di destinazione denominata.

Sebbene l'utente che esegue la query abbia accesso completo al set di dati e alla tabella dei risultati memorizzati nella cache, non è consigliato utilizzarli come input per i job dipendenti.

I nomi dei set di dati anonimi iniziano con un trattino basso. Ciò li nasconde dall'elenco dei set di dati nella console Google Cloud. Puoi elencare set di dati anonimi e controllare i controlli dell'accesso ai set di dati anonimi utilizzando lo strumento a riga di comando bq o l'API.

Per informazioni sull'elenco dei set di dati (inclusi i set di dati anonimi), consulta Elenco dei set di dati in un progetto.
Per informazioni sui controlli di accesso ai set di dati anonimi, consulta la pagina Ottenere informazioni sui set di dati.

Disattivazione del recupero dei risultati memorizzati nella cache

L'opzione Utilizza i risultati memorizzati nella cache riutilizza i risultati di una precedente esecuzione della stessa query, a meno che le tabelle oggetto di query non siano cambiate. L'utilizzo dei risultati memorizzati nella cache è vantaggioso solo per le query ripetute. Per le nuove query, l'opzione Utilizza i risultati memorizzati nella cache non ha effetto, anche se è abilitata per impostazione predefinita.

Quando ripeti una query con l'opzione Usa risultati memorizzati nella cache disattivata, il risultato memorizzato nella cache esistente viene sovrascritto. In questo modo, BigQuery deve calcolare il risultato della query e ti viene addebitato il costo per la query. Ciò è particolarmente utile negli scenari di benchmarking.

Se vuoi disabilitare il recupero dei risultati memorizzati nella cache e forzare la valutazione in tempo reale di un job di query, puoi impostare la proprietà configuration.query.useQueryCache del job di query su false.

Per disattivare l'opzione Usa risultati memorizzati nella cache:

Console

Apri la console Google Cloud.
Vai alla pagina BigQuery
Fai clic su Crea nuova query.
Inserisci una query SQL valida nell'area di testo Editor query.
Fai clic su Altro e seleziona Impostazioni query.
In Preferenza cache, deseleziona Utilizza risultati memorizzati nella cache.

bq

Utilizza il flag nouse_cache per sovrascrivere la cache delle query. L'esempio seguente obbliga BigQuery a elaborare la query senza utilizzare i risultati memorizzati nella cache esistenti:

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

API

Per elaborare una query senza utilizzare i risultati memorizzati nella cache esistenti, imposta la proprietà useQueryCache su false nella configurazione del job query.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento per le API GoBigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// queryDisableCache demonstrates issuing a query and requesting that the query cache is bypassed.
func queryDisableCache(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 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"

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

Per elaborare una query senza utilizzare i risultati memorizzati nella cache esistenti, imposta la cache delle query su false durante la creazione di QueryJobConfiguration.

samples/snippets/src/main/java/com/example/bigquery/QueryDisabledCache.java

Visualizza su GitHub 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 running a query with the cache disabled.
public class QueryDisableCache {

  public static void runQueryDisableCache() {
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    queryDisableCache(query);
  }

  public static void queryDisableCache(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)
              // Disable the query cache to force live query evaluation.
              .setUseQueryCache(false)
              .build();

      TableResult results = bigquery.query(queryConfig);

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

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

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento per le API Node.jsBigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

// 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 bigquery = 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 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

Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida di BigQuery che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento per le API PHPBigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

use Google\Cloud\BigQuery\BigQueryClient;

/** 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`';

// Construct a BigQuery client object.
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);

// Set job configs
$jobConfig = $bigQuery->query($query);
$jobConfig->useQueryCache(false);

// Extract query results
$queryResults = $bigQuery->runQuery($jobConfig);

$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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento per le API PythonBigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(use_query_cache=False)
sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""
query_job = client.query(sql, job_config=job_config)  # Make an API request.

for row in query_job:
    print(row)

Assicurarsi che la cache venga utilizzata

Se utilizzi il metodo jobs.insert per eseguire una query, puoi forzare l'esecuzione del job di una query a meno che non vengano utilizzati i risultati memorizzati nella cache impostando la proprietà createDisposition della configurazione del job query su CREATE_NEVER.

Se il risultato della query non esiste nella cache, viene restituito un errore NOT_FOUND.

bq

Utilizza il flag --require_cache per richiedere risultati dalla cache delle query. L'esempio seguente obbliga BigQuery a elaborare la query se i suoi risultati sono presenti nella cache:

 bq query \
 --require_cache \
 --batch \
 'SELECT
    name,
    count
  FROM
    `my-project`.mydataset.names_2013
  WHERE
    gender = "M"
  ORDER BY
    count DESC
  LIMIT
    6'

API

Per elaborare una query con risultati esistenti memorizzati nella cache, imposta la proprietà createDisposition su CREATE_NEVER nella configurazione del job query.

Verifica dell'utilizzo della cache

Esistono due modi per determinare se BigQuery ha restituito un risultato utilizzando la cache:

Utilizzo della console Google Cloud. Vai a Risultati delle query e fai clic su Informazioni job. Byte elaborati mostra 0 B (risultati memorizzati nella cache).
Utilizzando l'API BigQuery. La proprietà cacheHit nel risultato della query è impostata su true.

Impatto della sicurezza a livello di colonna

Per impostazione predefinita, BigQuery memorizza i risultati delle query per 24 ore, con le eccezioni indicate in precedenza. Le query relative a una tabella protetta dalla sicurezza a livello di colonna potrebbero non essere memorizzate nella cache. Se BigQuery memorizza nella cache il risultato, la durata della cache di 24 ore viene applicata.

Una modifica, come la rimozione di un gruppo o di un utente dal ruolo Lettore granulare Data Catalog utilizzato per un tag di criteri, non invalida la cache di 24 ore. Una modifica al gruppo di controllo dell'accesso dell'accesso Lettore granulare Data Catalog viene propagata immediatamente, ma la modifica non invalida la cache.

L'impatto è dovuto al fatto che un utente ha eseguito una query, i risultati della query rimangono visibili all'utente sullo schermo. L'utente può recuperare questi risultati dalla cache anche se ha perso l'accesso ai dati nelle ultime 24 ore.

Nelle 24 ore successive alla rimozione di un utente dal ruolo Lettore granulare di Data Catalog per un tag di criteri, l'utente può accedere ai dati memorizzati nella cache solo per i dati che in precedenza l'utente era autorizzato a visualizzare. Se vengono aggiunte righe alla tabella, l'utente non può vedere le righe aggiunte, anche se i risultati vengono memorizzati nella cache.