Usar resultados de consultas em cache

O BigQuery escreve todos os resultados da consulta numa tabela. A tabela é identificada explicitamente pelo utilizador (uma tabela de destino) ou é uma tabela de resultados temporária em cache. Se executar exatamente a mesma consulta novamente, o BigQuery devolve os resultados da tabela em cache, se existir. As tabelas de resultados temporárias em cache são mantidas por utilizador e por projeto. Consoante a sua edição, pode ter acesso a resultados em cache de outros utilizadores que executam consultas no mesmo projeto. Não existem custos de armazenamento para tabelas de resultados de consultas em cache, mas se escrever resultados de consultas numa tabela permanente, é cobrado pelo armazenamento dos dados.

Todos os resultados das consultas, incluindo consultas interativas e em lote, são colocados em cache em tabelas temporárias durante aproximadamente 24 horas, com algumas exceções.

Limitações

A utilização da cache de consultas está sujeita às seguintes limitações:

  • Quando executa uma consulta duplicada, o BigQuery tenta reutilizar os resultados em cache. Para obter dados da cache, o texto da consulta duplicada tem de ser igual ao da consulta original.
  • Para que os resultados da consulta persistam numa tabela de resultados em cache, o conjunto de resultados tem de ser inferior ao tamanho máximo da resposta. Para mais informações sobre a gestão de grandes conjuntos de resultados, consulte o artigo Devolver grandes resultados de consultas.
  • Não pode segmentar tabelas de resultados em cache com declarações DML.
  • Embora a semântica atual o permita, desaconselhamos a utilização de resultados em cache como entrada para tarefas dependentes. Por exemplo, não deve enviar tarefas de consulta que obtenham resultados da tabela de cache. Em alternativa, escreva os resultados numa tabela de destino com nome. Para simplificar a limpeza, as funcionalidades, como a propriedade defaultTableExpirationMs ao nível do conjunto de dados, podem fazer com que os dados expirem automaticamente após uma determinada duração.

Preços e quotas

Os resultados das consultas em cache são armazenados como tabelas temporárias. O armazenamento dos resultados das consultas em cache em tabelas temporárias não é cobrado. Quando os resultados da consulta são obtidos a partir de uma tabela de resultados em cache, a propriedade de estatísticas da tarefa statistics.query.cacheHit é devolvida como true e não lhe é cobrado nenhum valor pela consulta. Embora não lhe seja cobrado nada pelas consultas que usam resultados em cache, as consultas estão sujeitas às políticas de quotas do BigQuery. Além de reduzir os custos, as consultas que usam resultados em cache são significativamente mais rápidas porque o BigQuery não precisa de calcular o conjunto de resultados.

Exceções à colocação em cache de consultas

Os resultados das consultas não são colocados em cache:

  • Quando é especificada uma tabela de destino na configuração da tarefa, a Google Cloud consola, a ferramenta de linhas de comando bq ou a API.
  • Se alguma das tabelas ou vistas lógicas referenciadas tiver sido alterada desde que os resultados foram colocados em cache anteriormente.
  • Quando qualquer uma das tabelas referenciadas pela consulta recebeu recentemente inserções de streaming (a tabela tem dados no armazenamento otimizado para escrita), mesmo que não tenham chegado novas linhas.
  • Se a consulta usar funções não determinísticas; por exemplo, funções de data e hora, como CURRENT_TIMESTAMP() e CURRENT_DATE, e outras funções, como SESSION_USER(), devolve valores diferentes consoante a altura em que uma consulta é executada.
  • Se estiver a consultar várias tabelas com um caráter universal.
  • Se os resultados em cache tiverem expirado; a duração típica da cache é de 24 horas, mas os resultados em cache representam o melhor esforço e podem ser invalidados mais cedo.
  • Se a consulta for executada em relação a uma origem de dados externa, exceto o Cloud Storage. (As consultas GoogleSQL no Cloud Storage são suportadas por resultados de consultas em cache.)
  • Se a consulta for executada numa tabela protegida pela segurança ao nível das linhas, os resultados não são colocados em cache.
  • Se a consulta for executada numa tabela protegida pela segurança ao nível da coluna, os resultados podem não ser colocados em cache.
  • Se o texto da consulta tiver sido alterado de alguma forma, incluindo espaços em branco ou comentários modificados.

Como são armazenados os resultados em cache

Quando executa uma consulta, é criada uma tabela de resultados temporária em cache num tipo especial de conjunto de dados oculto, conhecido como conjunto de dados anónimo. Ao contrário dos conjuntos de dados normais que herdam autorizações do modelo de hierarquia de recursos do IAM (autorizações de projeto e organização), o acesso aos conjuntos de dados anónimos está restrito ao proprietário. O proprietário de um conjunto de dados anónimo é o utilizador que executou a consulta que gerou o resultado em cache. Além disso, a autorização bigquery.jobs.create é verificada no projeto para confirmar que o utilizador tem acesso ao mesmo.

O BigQuery não suporta a partilha de conjuntos de dados anónimos. Se pretender partilhar os resultados da consulta, não utilize os resultados em cache armazenados num conjunto de dados anónimo. Em alternativa, escreva os resultados numa tabela de destino com nome.

Embora o utilizador que executa a consulta tenha acesso total ao conjunto de dados e à tabela de resultados em cache, não é recomendável usá-los como entradas para tarefas dependentes.

Os nomes dos conjuntos de dados anónimos começam com um caráter de sublinhado. Esta ação oculta-os da lista de conjuntos de dados na consola Google Cloud . Pode listar conjuntos de dados anónimos e auditar os controlos de acesso a conjuntos de dados anónimos através da ferramenta de linhas de comando bq ou da API.

Para mais informações sobre como listar e obter informações sobre conjuntos de dados, incluindo conjuntos de dados anónimos, consulte o artigo Listar conjuntos de dados.

Colocação em cache entre utilizadores

Se estiver a usar a edição Enterprise ou Enterprise Plus e tiver as autorizações necessárias para executar uma consulta em cache no seu projeto para outro utilizador, o BigQuery produz o resultado em cache. O resultado em cache é copiado para o seu conjunto de dados anónimo pessoal e permanece aí durante 24 horas a partir do momento em que executou a consulta. Os mesmos limites e exceções para o armazenamento em cache de utilizador único aplicam-se ao armazenamento em cache de vários utilizadores.

Desativar a obtenção de resultados em cache

A opção Usar resultados em cache reutiliza os resultados de uma execução anterior da mesma consulta, a menos que as tabelas consultadas tenham sido alteradas. A utilização de resultados em cache só é vantajosa para consultas repetidas. Para novas consultas, a opção Usar resultados em cache não tem efeito, embora esteja ativada por predefinição.

Quando repete uma consulta com a opção Usar resultados em cache desativada, o resultado em cache existente é substituído. Isto requer que o BigQuery calcule o resultado da consulta, e a consulta é-lhe cobrada. Isto é particularmente útil em cenários de testes de referência.

Se quiser desativar a obtenção de resultados em cache e forçar a avaliação em direto de uma tarefa de consulta, pode definir a propriedade configuration.query.useQueryCache da tarefa de consulta como false.

Para desativar a opção Usar resultados em cache:

Consola

  1. Abra a Google Cloud consola.
    Aceda à página do BigQuery

  2. Clique em Redigir nova consulta.

  3. Introduza uma consulta SQL válida na área de texto do editor de consultas.

  4. Clique em Mais e selecione Definições de consulta.

    Definições da consulta

  5. Para Preferência de cache, desmarque a opção Usar resultados em cache.

bq

Use a flag nouse_cache para substituir a cache de consultas. O exemplo seguinte força o BigQuery a processar a consulta sem usar os resultados em cache existentes:

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

API

Para processar uma consulta sem usar os resultados em cache existentes, defina a propriedade useQueryCache como false na configuração da tarefa query.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

Para processar uma consulta sem usar os resultados em cache existentes, defina use query cache como false quando criar uma QueryJobConfiguration.

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

Antes de experimentar este exemplo, siga as PHPinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API PHP BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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)

Garantir a utilização da cache

Se usar o método jobs.insert para executar uma consulta, pode forçar a falha de uma tarefa de consulta, a menos que seja possível usar resultados em cache, definindo a propriedade createDisposition da configuração da tarefa query como CREATE_NEVER.

Se o resultado da consulta não existir na cache, é devolvido um erro NOT_FOUND.

bq

Use a flag --require_cache para exigir resultados da cache de consultas. O exemplo seguinte força o BigQuery a processar a consulta se os respetivos resultados existirem na 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

Para processar uma consulta com resultados em cache existentes, defina a propriedade createDisposition como CREATE_NEVER na configuração da tarefa query.

Validar a utilização da cache

Use um dos seguintes métodos para determinar se o BigQuery devolveu um resultado através da cache:

  • Use a Google Cloud consola. Aceda a Resultados da consulta e clique em Informações do trabalho. Bytes processados mostra 0 B (resultados em cache).
  • Use a API BigQuery. A propriedade cacheHit no resultado da consulta está definida como true.

Impacto da segurança ao nível da coluna

Por predefinição, o BigQuery armazena em cache os resultados das consultas durante 24 horas, com as exceções indicadas anteriormente. As consultas a uma tabela protegida pela segurança ao nível da coluna podem não ser colocadas em cache. Se o BigQuery colocar o resultado em cache, aplica-se a duração total da cache de 24 horas.

Uma alteração, como remover um grupo ou um utilizador da função Leitor detalhado do catálogo de dados usada para uma etiqueta de política, não invalida a cache de 24 horas. Uma alteração ao próprio grupo de controlo de acesso Data Catalog Fine Grained Reader é propagada imediatamente, mas a alteração não invalida a cache.

O impacto é que, se um utilizador executar uma consulta, os resultados da consulta permanecem visíveis no ecrã. O utilizador também pode obter esses resultados da cache, mesmo que tenha perdido o acesso aos dados nas últimas 24 horas.

Durante as 24 horas após a remoção de um utilizador da função Leitor detalhado do catálogo de dados para uma etiqueta de política, o utilizador pode aceder aos dados em cache apenas para os dados que o utilizador tinha autorização para ver anteriormente. Se forem adicionadas linhas à tabela, o utilizador não consegue ver as linhas adicionadas, mesmo que os resultados estejam em cache.