Usa resultados de consultas 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é. Si vuelves a ejecutar la misma consulta, BigQuery muestra los resultados de la tabla almacenada en caché, si existe. Las tablas de resultados temporales en caché se conservan por usuario y por proyecto. Según la edición que uses, es posible que tengas acceso a resultados almacenados en caché de otros usuarios que ejecutan consultas en el mismo proyecto. No se aplican costos de almacenamiento para las tablas de resultados de consultas en caché, 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 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 recupere resultados desde las tablas en caché. Por el contrario, debes escribir tus resultados en una tabla de destino con nombre. A fin de simplificar la limpieza, 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

Los resultados de consultas en caché se almacenan como tablas temporales. No se te cobrará por el almacenamiento de los resultados de consultas en caché en tablas temporales. 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 almacenadas 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, la consola de Google Cloud, 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 una inserción de transmisión reciente (la tabla tiene datos en el almacenamiento optimizado para escritura), 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 CURRENT_DATE, y otras funciones como SESSION_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 son el mejor esfuerzo y se pueden invalidar antes.
• Si la consulta se ejecuta en una fuente de datos externa que no sea Cloud Storage. (Las consultas de GoogleSQL en Cloud Storage son compatibles con los resultados de consultas en caché).
• Si la consulta se ejecuta en una tabla protegida por la seguridad a nivel de la fila, los resultados no se almacenan en caché.
• Si la consulta se ejecuta en una tabla protegida por la seguridad a nivel de la columna, es posible que los resultados no se almacenen en caché.

Cómo se almacenan los resultados en caché

Cuando ejecutas una consulta, se crea una tabla temporal de resultados en caché en un tipo especial de conjunto de datos oculto 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. El propietario de un conjunto de datos anónimo es el usuario que ejecutó la consulta que produjo el resultado en caché. Además, el permiso bigquery.jobs.create se verifica en el proyecto para verificar que el usuario tenga acceso al proyecto.

BigQuery no admite el uso compartido de conjuntos de datos anónimos. 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 guión bajo. De esa forma, se ocultan de la lista de conjuntos de datos en la consola de Google Cloud. Puedes enumerar los conjuntos de datos anónimos y auditar los controles de acceso de los conjuntos de datos anónimos con la herramienta de línea de comandos de bq o la API.

Para obtener más información sobre cómo enumerar y obtener información sobre conjuntos de datos, incluidos los conjuntos de datos anónimos, consulta Haz una lista de los conjuntos de datos.

Almacenamiento en caché entre usuarios

Si usas la edición Enterprise o Enterprise Plus y tienes los permisos necesarios para ejecutar una consulta almacenada en caché en tu proyecto para otro usuario, BigQuery producirá el resultado almacenado en caché. El resultado almacenado en caché se copia en tu conjunto de datos anónimo personal y permanece allí durante 24 horas desde que ejecutas la consulta. Se aplican los mismos límites y excepciones para el almacenamiento en caché de un solo usuario al almacenamiento en caché entre usuarios.

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:

 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)

Asegura el uso del almacenamiento en caché

Si usas el método jobs.insert para ejecutar una consulta, puedes forzar a un trabajo de consulta para 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 query en CREATE_NEVER.

Si el resultado de la consulta no existe en la caché, se muestra un error 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 el uso del almacenamiento en caché

Usa uno de los siguientes métodos para determinar si BigQuery mostró un resultado con el uso de la caché:

• Usa la consola de Google Cloud. Ve a Resultados de la consulta y haz clic en Información del trabajo. Bytes procesados muestra 0 B (resultados almacenados en caché).
• Usa 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. Es posible que las consultas en una tabla protegida por la seguridad a nivel de la columna no se almacenen en caché. Si BigQuery almacena en caché el resultado, se aplica la vida útil de la caché de 24 horas.

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 un usuario del rol 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 puede ver las filas agregadas, incluso si los resultados se almacenan en caché.