Utilizzare i risultati delle query memorizzati nella cache

BigQuery scrive tutti i risultati delle query in una tabella. La tabella è identificato esplicitamente dall'utente (una tabella di destinazione) o si tratta di una tabella temporanea nella tabella dei risultati memorizzati nella cache. Se esegui di nuovo la stessa identica query, BigQuery restituisce i risultati da della tabella memorizzata nella cache, se esistente. Le tabelle dei risultati temporanee memorizzate nella cache vengono gestite per utente, per progetto. A seconda della versione, potresti avere accesso a memorizzare nella cache i risultati di altri utenti che eseguono query nel nello stesso progetto. Non sono previsti costi di archiviazione per le tabelle dei risultati delle query memorizzate nella cache, ma scrivi i risultati della query in una tabella permanente, ti vengono addebitati per l'archiviazione dei dati.

Tutti i risultati delle query, inclusi entrambi query interattive e batch, vengono memorizzate 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 dei risultati memorizzati nella cache. Per recuperare i dati dalla cache, il testo della query duplicato deve uguale alla 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 ulteriori informazioni sulla gestione di grandi dimensioni, consulta la sezione Restituzione di risultati di query di grandi dimensioni.
• Non puoi scegliere come target le tabelle dei risultati memorizzate nella cache con DML istruzioni.
• Sebbene la semantica corrente lo consenta, l'uso dei risultati memorizzati nella cache per i job dipendenti non è consentito. Ad esempio, non dovresti di inviare job di query che recuperano i risultati dalla tabella della cache. Scrivi invece i risultati a una tabella di destinazione denominata. Per semplificare la pulizia, funzionalità come poiché la proprietà defaultTableExpirationMs a livello del set di dati può 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 l'archiviazione dei risultati delle query memorizzati nella cache in tabelle temporanee. Quando i risultati della query vengono recuperate da una tabella dei risultati memorizzati nella cache, la proprietà delle statistiche sulle offerte di lavoro statistics.query.cacheHit restituisce come true e non ti viene addebitato alcun importo per query. Anche se non ti vengono addebitati costi per le query che usano i risultati memorizzati nella cache, sono soggette alle norme BigQuery criteri delle quote. Oltre a ridurre i costi, le query che usano i risultati memorizzati nella cache molto più velocemente perché BigQuery non ha bisogno di l'insieme di risultati.

Eccezioni alla memorizzazione nella cache delle query

I risultati della query non vengono memorizzati nella cache:

• Quando nella configurazione del job viene specificata una tabella di destinazione, il parametro console Google Cloud, lo strumento a riga di comando bq o l'API.
• Se una delle tabelle o visualizzazioni logiche a cui viene fatto riferimento è cambiata dopo erano stati precedentemente memorizzati nella cache.
• Quando una delle tabelle a cui fa riferimento la query ha ricevuto di recente inserimento di flussi di dati (la tabella contiene dati nello spazio di archiviazione ottimizzato per la scrittura) anche se non esistono sono arrivate righe.
• Se la query utilizza funzioni non deterministiche: ad esempio data e ora come CURRENT_TIMESTAMP() e CURRENT_DATE e come SESSION_USER(), restituisce valori diversi a seconda di quando viene eseguita la query.
• Se esegui query su più tabelle utilizzando carattere jolly.
• Se i risultati memorizzati nella cache sono scaduti: in genere è di 24 ore, ma i risultati memorizzati nella cache fanno il possibile e potrebbero essere invalidati prima.
• Se la query viene eseguita su origine dati esterna. diversi da Cloud Storage. (GoogleSQL su 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 riga i risultati non vengono memorizzati nella cache.
• Se la query viene eseguita su una tabella protetta dalla sicurezza a livello di colonna, i risultati non possono essere memorizzati nella cache.

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 di set di dati nascosto chiamato set di dati anonimo. A differenza dei set di dati regolari che eredita le autorizzazioni dal modello di gerarchia delle risorse IAM (progetto e autorizzazioni dell'organizzazione), l'accesso ai set di dati anonimi è limitato proprietario. Il proprietario di un set di dati anonimo è l'utente che ha eseguito la query ha prodotto il risultato memorizzato nella cache. Inoltre, l'autorizzazione bigquery.jobs.create viene controllato nel progetto per verificare che l'utente abbia accesso al progetto.

BigQuery non supporta la condivisione di set di dati anonimi. Se intenzione di 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 dei risultati memorizzati nella cache, si sconsiglia di utilizzarli come input per i job dipendenti.

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

Per ulteriori informazioni su come elencare e ottenere informazioni sui set di dati, inclusi set di dati anonimi, consulta la sezione Elenco dei set di dati.

Memorizzazione nella cache per più utenti

Se utilizzi Enterprise o Enterprise Plus edition e disporre dei necessari le autorizzazioni per eseguire una query memorizzata nella cache nel tuo progetto per un altro utente BigQuery produce il risultato memorizzato nella cache. Il risultato memorizzato nella cache è nel tuo set di dati anonimo personale e che vi rimarrà per 24 ore quando hai eseguito la query. Stessi limiti ed eccezioni per la memorizzazione nella cache di un singolo utente si applicano alla memorizzazione nella cache per più utenti.

Disattivazione del recupero dei risultati memorizzati nella cache

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

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

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

Per disattivare l'opzione Utilizza risultati memorizzati nella cache:

Console

1. Apri la console Google Cloud.
   Vai alla pagina di BigQuery

2. Fai clic su Crea nuova query.

3. Inserisci una query SQL valida nell'area di testo Editor query.

4. Fai clic su Altro e seleziona Impostazioni query.

   

5. In Preferenza cache, deseleziona Utilizza risultati memorizzati nella cache.

bq

Utilizza il flag nouse_cache per sovrascrivere la cache delle query. Le seguenti obbliga BigQuery a elaborare la query senza utilizzare 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 esistenti memorizzati nella cache, imposta il valore useQueryCache in false nella configurazione del job query.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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 esistenti memorizzati nella cache, imposta l'uso della cache delle query a false durante la creazione QueryJobConfiguration.

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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 per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

// 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 per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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 per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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)

Come garantire l'utilizzo della cache

Se utilizzi il metodo jobs.insert per eseguire una query, puoi forzare l'esito negativo di un job di query a meno che non sia possibile utilizzato impostando la proprietà createDisposition del job query configurazione in CREATE_NEVER.

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

bq

Utilizza il flag --require_cache per richiedere risultati dalla cache delle query. La nell'esempio seguente forza BigQuery a elaborare la query se nella cache sono presenti risultati:

 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 memorizzati nella cache esistenti, imposta il valore createDisposition proprietà a CREATE_NEVER nella configurazione del job query.

Verifica dell'utilizzo della cache

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

• Utilizzare la console Google Cloud. Vai a Risultati delle query e fai clic su Informazioni lavoro. 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, eccezioni indicate in precedenza. Query in una tabella protetti dalla sicurezza a livello di colonna potrebbero non essere memorizzati nella cache. Se BigQuery memorizza nella cache il risultato, la durata della cache di 24 ore .

Una modifica, ad esempio la rimozione di un gruppo o di un utente Il ruolo Lettore granulare Data Catalog utilizzato per un tag di criteri non invalidare la cache di 24 ore. Una modifica al Data Catalog Fine Il gruppo di controllo dell'accesso Grained Reader viene propagato immediatamente, ma modifica non invalida la cache.

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

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