Usa resultados de consultas almacenados en caché

BigQuery escribe todos los resultados de consultas en una tabla. El usuario identifica la tabla de forma explícita (una tabla de destino) o si es una tabla de resultados temporal en caché. Las tablas de resultados temporales en caché se conservan por usuario y por proyecto. No se aplican costos de almacenamiento para las tablas temporales, pero si escribes resultados de consultas en una tabla permanente, se te cobrará por almacenar los datos.

Todos los resultados de consultas, incluidas las consultas interactivas y por lotes, se almacenan en caché en tablas temporales durante unas 24 horas, con algunas excepciones.

Limitaciones

El uso de las consultas en caché está sujeto a las limitaciones siguientes:

  • Cuando ejecutas una consulta duplicada, BigQuery trata de volver a usar los resultados almacenados en caché. Para recuperar datos de la caché, el texto de la consulta duplicada debe ser el mismo que el de la consulta original.
  • Para que los resultados de la consulta se conserven en una tabla de resultados almacenados en caché, el conjunto de resultados debe ser más pequeño que el tamaño máximo de respuesta. Para obtener más información sobre cómo administrar conjuntos de resultados grandes, consulta Muestra resultados de consultas grandes.
  • No se puede orientar tablas de resultados almacenados en caché con declaraciones DML.
  • A pesar de que la semántica actual lo permite, no se recomienda el uso de los resultados almacenados en caché como entrada para trabajos dependientes. Por ejemplo, no debes enviar trabajos de consulta que recuperen resultados desde las tablas en caché. Por el contrario, debes escribir tus resultados en una tabla de destino con nombre. A fin de habilitar una limpieza fácil, las características como la propiedad defaultTableExpirationMs del nivel del conjunto de datos puede hacer vencer los datos de forma automática después de un período determinado.

Precios y cuotas

Cuando los resultados de la consulta se recuperan de una tabla de resultados almacenados en caché, la propiedad de estadísticas del trabajo statistics.query.cacheHit se muestra como true y no se te cobra por la consulta. Aunque no se te cobra por las consultas que usan los resultados almacenados en caché, las consultas están sujetas a las políticas de cuotas de BigQuery. Además de reducir costos, las consultas que usan los resultados en caché son mucho más rápidas porque BigQuery no necesita procesar el conjunto de resultados.

Excepciones a las consultas en caché

Los resultados de consultas no se almacenan en caché en estos casos:

  • Cuando se especifica una tabla de destino en la configuración del trabajo, Cloud Console, la herramienta de línea de comandos de bq o la API.
  • Si alguna de las tablas referenciadas o las vistas lógicas cambiaron desde que los resultados se almacenaron en caché con anterioridad.
  • Cuando cualquiera de las tablas referenciadas por la consulta haya recibido inserción de transmisión reciente (un búfer de transmisión se adjunta a la tabla), incluso si no llegaron filas nuevas.
  • Si la consulta usa funciones no deterministas; por ejemplo, las funciones de fecha y hora como CURRENT_TIMESTAMP() y NOW(), y otras funciones como CURRENT_USER() muestran valores diferentes según cuándo se ejecuta una consulta.
  • Si consultas varias tablas con un comodín.
  • Si los resultados en caché caducaron; la vida útil normal de la caché es de 24 horas, pero los resultados almacenados en caché se basan en función del mejor esfuerzo y se pueden invalidar antes.
  • Si la consulta se ejecuta en una fuente de datos externa

Cómo se almacenan los resultados en caché

Cuando ejecutas una consulta, se crea una tabla de resultados temporal en caché en un conjunto de datos especial denominado “conjunto de datos anónimo”. A diferencia de los conjuntos de datos normales que heredan permisos del modelo de jerarquía de recursos de IAM (permisos de proyecto y organización), el acceso a los conjuntos de datos anónimos está restringido al propietario del conjunto de datos. El propietario de un conjunto de datos anónimo es el usuario que ejecutó la consulta que produjo el resultado almacenado en caché.

Cuando se crea un conjunto de datos anónimo, se le otorga acceso de bigquery.dataOwner al conjunto de datos anónimo de forma explícita al usuario que ejecuta el trabajo de consulta. El acceso bigquery.dataOwner le otorga el control total del conjunto de datos solo al usuario que ejecutó el trabajo de consulta. Esto incluye un control total sobre las tablas de resultados almacenados en caché en el conjunto de datos anónimo. Si deseas compartir los resultados de la consulta, no uses resultados almacenados en caché almacenados en un conjunto de datos anónimo. En su lugar, escribe los resultados en una tabla de destino con nombre.

Aunque el usuario que ejecuta la consulta tiene acceso total al conjunto de datos y a la tabla de resultados almacenados en caché, no se recomienda usarlos como entradas para trabajos dependientes.

Los nombres de los conjuntos de datos anónimos comienzan con un guion bajo. De esa forma, se ocultan de la lista de conjuntos de datos en Cloud Console. Puedes enumerar los conjuntos de datos anónimos y auditar los controles de acceso de los conjuntos de datos anónimos mediante la herramienta de línea de comandos de bq o la API.

Inhabilita la recuperación de resultados almacenados en caché

La opción Use cached results (Usa resultados almacenados en caché) vuelve a usar los resultados desde una ejecución previa de la misma consulta, a menos que las tablas a las que se les consulta hayan cambiado. Usar los resultados almacenados en caché solo es beneficioso para consultas repetidas. Para consultas nuevas, la opción Usar resultados almacenados en caché no tiene efecto, a pesar de que está habilitada de forma predeterminada.

Cuando repites una consulta con la opción Usar resultados almacenados en caché inhabilitada, el resultado en caché existente se reemplaza. Esto requiere que BigQuery procese el resultado de la consulta y se te cobrará por la consulta. Esto es útil, en particular, en casos de comparativas.

Si deseas inhabilitar la recuperación de resultados almacenados en caché y forzar la evaluación en vivo de un trabajo de consulta, puede establecer la propiedad configuration.query.useQueryCache de tu trabajo de consulta en false.

Si quieres inhabilitar la opción Usar resultados almacenados en caché, sigue estos pasos:

Console

  1. Abre Cloud Console.
    Ir a la página de BigQuery

  2. Haz clic en Redactar consulta nueva.

  3. Ingresa una consulta de SQL válida en el área de texto del Editor de consultas.

  4. Haz clic en Más y selecciona Configuración de consulta.

    Configuración de consulta

  5. En Cache preference (Preferencia de caché), desmarca Use cached results (Usar resultados almacenados en caché).

    Opción de resultados almacenados en caché

bq

Usa la marca nouse_cache para reemplazar la caché de la consulta. En el siguiente ejemplo, se obliga a BigQuery a procesar la consulta sin usar los resultados almacenados en caché 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 procesar una consulta sin usar los resultados almacenados en caché existentes, establece la propiedad useQueryCache en false en la configuración del trabajo query.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

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 procesar una consulta sin usar los resultados almacenados en caché existentes, configura el uso de la caché de consulta en false cuando crees una QueryJobConfiguration.

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 probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para 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 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));
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

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)

Asegura el uso del almacenamiento en caché

Si usas la función jobs.insert con el fin de ejecutar una consulta, puedes forzar a un trabajo de consulta a que falle, a menos que los resultados almacenados en caché se puedan usar mediante la configuración de la propiedad createDisposition de la configuración del trabajo copy en CREATE_NEVER.

Si el resultado de la consulta no existe en la caché, se muestra un error NOT_FOUND.

Verifica el uso del almacenamiento en caché

Existen dos formas de determinar si BigQuery usó la caché para mostrar un resultado:

  • Si usas Cloud Console, la string de resultado no contiene información sobre la cantidad de bytes procesados y muestra la palabra cached.

    Indicador de caché en Cloud Console

  • Si usas la API de BigQuery , la propiedad cacheHit en el resultado de la consulta se establece en true.

Impacto de la seguridad a nivel de la columna

De forma predeterminada, BigQuery almacena en caché los resultados de las consultas durante 24 horas, con las excepciones indicadas antes. El almacenamiento en caché de 24 horas también se aplica a las consultas con datos protegidos por la seguridad a nivel de la columna, que usa etiquetas de política. Un cambio como quitar un grupo o un usuario de la función Lector detallado de Data Catalog, que se usa para una etiqueta de política, no invalida el almacenamiento en caché de 24 horas. Si hay un cambio en el grupo de control de acceso del Lector detallado de Data Catalog, este se propaga de inmediato, pero no invalida la caché.

El efecto es que si un usuario ejecuta una búsqueda, los resultados de la consulta seguirán siendo visibles para el usuario en la pantalla. El usuario también puede recuperar esos resultados del almacenamiento en caché, incluso si perdió el acceso a los datos en las últimas 24 horas.

Durante las 24 horas posteriores a que se quita de un usuario de la función de Lector detallado de Data Catalog de una etiqueta de política, el usuario tiene acceso a los datos almacenados en caché solo para los datos que antes se le permitían ver. Si se agregan filas a la tabla, el usuario no verá las filas que se agregaron, incluso si los resultados se almacenan en caché.