Utilizza i risultati delle query memorizzati nella cache

BigQuery scrive automaticamente i risultati delle query in una tabella dei risultati temporanea memorizzata nella cache, a meno che non specifichi una tabella di destinazione permanente. Quando esegui di nuovo una query identica, BigQuery può restituire i risultati direttamente dalla tabella memorizzata nella cache per accelerare l'esecuzione della query ed evitare costi di calcolo aggiuntivi.

Le tabelle dei risultati memorizzati nella cache temporanea vengono gestite per utente e per progetto per circa 24 ore sia per le query interattive che per quelle batch, con alcune eccezioni. A seconda della versione, potresti anche avere accesso ai risultati memorizzati nella cache di altri utenti nello stesso progetto. Non ti vengono addebitati costi per l'archiviazione delle tabelle dei risultati memorizzati nella cache, a differenza delle tabelle permanenti che comportano costi di archiviazione.

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 essere lo stesso della query originale.
• Affinché i risultati della query vengano mantenuti in una tabella dei risultati memorizzati nella cache, il set di risultati deve essere inferiore alla dimensione massima della risposta. Per saperne di più sulla gestione di set di risultati di grandi dimensioni, consulta Restituzione di risultati di query di grandi dimensioni.
• Non puoi scegliere come target le tabelle dei risultati memorizzati nella cache con istruzioni DML.
• Sebbene la semantica attuale lo consenta, l'utilizzo dei risultati memorizzati nella cache come input per i job dipendenti è sconsigliato. 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 semplificare la pulizia, funzionalità come la proprietà defaultTableExpirationMs a livello di set di dati possono far scadere i dati automaticamente dopo un determinato periodo di tempo.

Prezzi e quote

I risultati delle query memorizzati nella cache vengono archiviati come tabelle temporanee. Non ti viene addebitato alcun costo per l'archiviazione dei risultati delle query memorizzati nella cache in tabelle temporanee. Quando i risultati della 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 vengono addebitati costi per la query. Anche se non ti vengono addebitati costi per le query che utilizzano risultati memorizzati nella cache, le query sono soggette alle policy relative alle quote di BigQuery.

Oltre a ridurre i costi, le query che utilizzano i risultati memorizzati nella cache sono notevolmente più veloci perché BigQuery non deve calcolare il set di risultati.

Eccezioni alla memorizzazione delle query nella cache

I risultati delle query non vengono memorizzati nella cache:

• Quando una tabella di destinazione è specificata nella configurazione del job, la consoleGoogle Cloud , lo strumento a riga di comando bq o l'API.
• Se una delle tabelle o delle visualizzazioni logiche di riferimento è cambiata rispetto alla memorizzazione nella cache dei risultati.
• Quando una delle tabelle a cui fa riferimento la query ha ricevuto di recente inserimenti di flussi di dati (la tabella contiene dati nello spazio di archiviazione ottimizzato per la scrittura), anche se non sono arrivate 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 memorizzati nella cache sono best-effort e potrebbero essere invalidati prima.
• Se la query viene eseguita su un'origine dati esterna diversa da Cloud Storage. (Le query GoogleSQL su Cloud Storage sono supportate dai risultati delle query memorizzati nella cache).
• Se la query viene eseguita su una tabella protetta dalla sicurezza a livello di riga, i risultati non vengono memorizzati nella cache.
• Se la query viene eseguita su una tabella protetta dalla sicurezza a livello di colonna, incluso il mascheramento dei dati, i risultati potrebbero non essere memorizzati nella cache.
• Se il testo della query è stato modificato in qualsiasi modo, inclusi spazi vuoti o commenti modificati.

Come vengono memorizzati i risultati memorizzati nella cache

Quando esegui una query, viene creata una tabella dei risultati temporanea memorizzata nella cache in un tipo speciale di set di dati nascosto, denominato set di dati anonimo. A differenza dei set di dati normali 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 delle query, non utilizzare i risultati memorizzati nella cache archiviati 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, l'utilizzo di questi ultimi come input per i job dipendenti è sconsigliato.

I nomi dei set di dati anonimi iniziano con un trattino basso. In questo modo, i set di dati vengono nascosti dall'elenco dei set di dati nella console Google Cloud . Puoi elencare i set di dati anonimi e controllare i controlli di accesso ai set di dati anonimi utilizzando lo strumento a riga di comando bq o l'API.

Per saperne di più su come elencare e ottenere informazioni sui set di dati, inclusi quelli anonimi, consulta Elenca i set di dati.

Memorizzazione nella cache tra utenti

Se disponi delle autorizzazioni necessarie per eseguire una query, i cui risultati sono memorizzati nella cache del tuo progetto per un altro utente, BigQuery restituisce i risultati dalla cache. Il risultato memorizzato nella cache viene copiato nel tuo set di dati anonimo personale e rimane lì per 24 ore dal momento in cui hai eseguito la query.

La memorizzazione nella cache tra utenti è disponibile se utilizzi la versione Enterprise o Enterprise Plus. Alla memorizzazione nella cache tra utenti si applicano gli stessi limiti ed eccezioni della memorizzazione nella cache per un singolo utente.

Disattivazione del recupero dei risultati memorizzati nella cache

L'opzione Utilizza risultati memorizzati nella cache riutilizza i risultati di un'esecuzione precedente della stessa query, a meno che le tabelle su cui viene eseguita la query non siano state modificate. L'utilizzo dei risultati memorizzati nella cache è utile solo per le query ripetute. Per le nuove query, l'opzione Utilizza risultati memorizzati nella cache non ha alcun effetto, anche se è attiva per impostazione predefinita.

Quando ripeti una query con l'opzione Utilizza risultati memorizzati nella cache disattivata, il risultato memorizzato nella cache esistente viene sovrascritto. Ciò richiede a BigQuery di calcolare il risultato della query e ti viene addebitato il costo della query. Questo è particolarmente utile negli scenari di benchmarking.

Se vuoi disattivare 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 Utilizza risultati memorizzati nella cache:

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

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
}

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

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

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);

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)

Garantire l'utilizzo della cache

Se utilizzi il metodo jobs.insert per eseguire una query, puoi forzare l'errore di un job di query, a meno che non sia possibile utilizzare 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 query \
 --require_cache \
 --batch \
 'SELECT
    name,
    count
  FROM
    `my-project`.mydataset.names_2013
  WHERE
    gender = "M"
  ORDER BY
    count DESC
  LIMIT
    6'

Verifica l'utilizzo della cache

Utilizza uno dei seguenti metodi per determinare se BigQuery ha restituito un risultato utilizzando la cache:

• Utilizza la console Google Cloud . Vai a Risultati delle query e fai clic su Informazioni job. Byte elaborati mostra 0 B (risultati memorizzati nella cache).
• Utilizza 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 nella cache i risultati delle query per 24 ore, con le eccezioni indicate in precedenza. Le query su una tabella protetta dalla sicurezza a livello di colonna potrebbero non essere memorizzate nella cache. Se BigQuery memorizza il risultato nella cache, si applica la durata della cache di 24 ore.

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

L'impatto è che se un utente ha eseguito una query, i risultati della query rimangono visibili all'utente. L'utente può anche recuperare i 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 era autorizzato a visualizzare in precedenza. Se vengono aggiunte righe alla tabella, l'utente non può visualizzarle, anche se i risultati sono memorizzati nella cache.