Im Cache gespeicherte Abfrageergebnisse verwenden

BigQuery schreibt alle Abfrageergebnisse in eine Tabelle. Die Tabelle wird entweder vom Nutzer explizit angegeben (Zieltabelle) oder ist eine temporäre, im Cache gespeicherte Ergebnistabelle. Temporäre, im Cache gespeicherte Ergebnistabellen werden nutzer- und projektspezifisch verwaltet. Für temporäre Tabellen fallen keine Speicherkosten an. Wenn Sie jedoch Abfrageergebnisse in eine permanente Tabelle schreiben, wird das Speichern der Daten in Rechnung gestellt.

Alle Abfrageergebnisse, sowohl für interaktive Abfragen als auch für Batchabfragen, werden etwa 24 Stunden lang in temporären Tabellen im Cache gespeichert. Dabei gelten einige Ausnahmen.

Beschränkungen

Bei der Verwendung des Abfrage-Cache gelten folgende Einschränkungen:

  • Wenn Sie eine Abfrage mehrfach ausführen, versucht BigQuery, im Cache gespeicherte Ergebnisse wiederzuverwenden. Der duplizierte Abfragetext muss genau mit der ursprünglichen Abfrage übereinstimmen, um Daten aus dem Cache abzurufen.
  • Damit Abfrageergebnisse in einer im Cache gespeicherten Ergebnistabelle erhalten bleiben, muss der Ergebnissatz kleiner als die maximale Antwortgröße sein. Weitere Informationen zum Verwalten großer Ergebnissätze finden Sie unter Umfangreiche Abfrageergebnisse schreiben.
  • Sie können nicht mithilfe von DML-Anweisungen auf im Cache gespeicherte Ergebnistabellen zugreifen.
  • Obwohl die aktuelle Semantik es zulässt, wird davon abgeraten, im Cache gespeicherte Ergebnisse als Eingabe für abhängige Jobs zu verwenden. Sie sollten z. B. keine Abfragejobs senden, mit denen Ergebnisse aus der Cache-Tabelle abgerufen werden. Schreiben Sie Ihre Ergebnisse stattdessen in eine benannte Zieltabelle. Mit Features wie dem Attribut defaultTableExpirationMs auf Dataset-Ebene kann dafür gesorgt werden, dass Daten nach einem bestimmten Zeitraum automatisch ablaufen, um eine einfache Bereinigung zu ermöglichen.

Preise und Kontingente

Wenn Abfrageergebnisse aus einer im Cache gespeicherten Ergebnistabelle abgerufen werden, wird für das Jobstatistikattribut statistics.query.cacheHit der Wert true zurückgegeben. Diese Abfrage wird Ihnen nicht in Rechnung gestellt. Abfragen, für die im Cache gespeicherte Ergebnisse verwendet werden, sind zwar kostenlos. Sie unterliegen aber den BigQuery-Kontingentrichtlinien. Mit Abfragen, für die im Cache gespeicherte Ergebnisse verwendet werden, können nicht nur die Kosten gesenkt werden. Sie sind auch deutlich schneller, da BigQuery den Ergebnissatz nicht berechnen muss.

Ausnahmen für das Abfrage-Caching

Abfrageergebnisse werden unter den folgenden Bedingungen nicht im Cache gespeichert:

  • Wenn in der Jobkonfiguration, der Cloud Console, dem bq-Befehlszeilentool oder der API eine Zieltabelle angegeben ist.
  • Angegebene Tabellen oder logische Ansichten wurden geändert, seit die Ergebnisse im Cache gespeichert wurden.
  • In der Abfrage angegebene Tabellen haben kürzlich Streaming-Insert-Anweisungen erhalten (ein Streaming-Zwischenspeicher wird mit der Tabelle verknüpft), selbst wenn keine neuen Zeilen empfangen wurden.
  • In der Abfrage werden nicht deterministische Funktionen verwendet, z. B. Funktionen für Datum und Uhrzeit wie CURRENT_TIMESTAMP() und NOW(). Andere Funktionen wie CURRENT_USER() geben je nach Ausführungszeitpunkt einer Abfrage unterschiedliche Werte zurück.
  • Sie fragen mehrere Tabellen mit einem Platzhalter ab.
  • Die im Cache gespeicherten Ergebnisse sind abgelaufen. Die typische Aufbewahrungsdauer im Cache beträgt 24 Stunden. Im Cache gespeicherte Ergebnisse werden aber auf Best-Effort-Basis bereitgestellt und können auch früher ungültig werden.
  • Die Abfrage wird anhand einer externen Datenquelle ausgeführt.

Speichern von im Cache gespeicherten Ergebnissen

Wenn Sie eine Abfrage ausführen, wird eine temporäre, im Cache gespeicherte Ergebnistabelle in einem besonderen Dataset erstellt, das als "anonymes Dataset" bezeichnet wird. Im Gegensatz zu regulären Datasets, die Berechtigungen vom Modell der IAM-Ressourcenhierarchie (Projekt- und Organisationsberechtigungen) übernehmen, ist der Zugriff auf anonyme Datasets auf die jeweiligen Eigentümer beschränkt. Der Eigentümer eines anonymen Datasets ist der Nutzer, der die Abfrage ausgeführt hat, die das im Cache gespeicherte Ergebnis zurückgegeben hat.

Wenn ein anonymes Dataset erstellt wird, erhält der Nutzer, der den Abfragejob ausführt, explizit bigquery.dataOwner-Zugriff auf das anonyme Dataset. Der bigquery.dataOwner-Zugriff gewährt nur dem Nutzer, der den Abfragejob ausgeführt hat, uneingeschränkte Kontrolle über das Dataset. Dazu gehört die uneingeschränkte Kontrolle über die im Cache gespeicherten Ergebnistabellen des anonymen Datasets. Wenn Sie vorhaben, Abfrageergebnisse mit anderen Nutzern zu teilen, sollten Sie keine im Cache gespeicherten Ergebnisse aus einem anonymen Dataset verwenden. Schreiben Sie die Ergebnisse stattdessen in eine benannte Zieltabelle.

Obwohl der Nutzer, der die Abfrage ausführt, uneingeschränkten Zugriff auf das Dataset und die im Cache gespeicherte Ergebnistabelle hat, wird davon abgeraten, diese als Eingabe für abhängige Jobs zu verwenden.

Die Namen eines anonymen Datasets beginnen mit einem Unterstrich. Dadurch werden sie in der Dataset-Liste der Cloud Console ausgeblendet. Mit dem bq-Befehlszeilentool oder der API können Sie anonyme Datasets auflisten und Zugriffssteuerungen für anonyme Datasets prüfen.

Abruf von im Cache gespeicherten Ergebnissen deaktivieren

Mit der Option Im Cache gespeicherte Ergebnisse verwenden werden Ergebnisse aus einer früheren Ausführung der gleichen Abfrage wiederverwendet, sofern sich die abgefragten Tabellen nicht geändert haben. Die Verwendung von im Cache gespeicherten Ergebnissen ist nur bei wiederholten Abfragen sinnvoll. Bei neuen Abfragen hat die Option Im Cache gespeicherte Ergebnisse verwenden keine Wirkung, auch wenn sie standardmäßig aktiviert ist.

Wenn Sie eine Abfrage bei deaktivierter Option Im Cache gespeicherte Ergebnisse verwenden wiederholen, wird das vorhandene im Cache gespeicherte Ergebnis überschrieben. BigQuery muss dann das Abfrageergebnis neu berechnen und die Abfrage wird Ihnen in Rechnung gestellt. Dies ist insbesondere in Benchmark-Szenarien hilfreich.

Wenn Sie das Abrufen von im Cache gespeicherten Ergebnissen deaktivieren und eine Liveauswertung eines Abfragejobs erzwingen möchten, können Sie das Attribut configuration.query.useQueryCache Ihres Abfragejobs auf false setzen.

So deaktivieren Sie die Option Im Cache gespeicherte Ergebnisse verwenden:

Console

  1. Öffnen Sie die Cloud Console.
    Zur Seite "BigQuery"

  2. Klicken Sie auf Neue Abfrage erstellen.

  3. Geben Sie im Textbereich des Abfrageeditors eine gültige SQL-Abfrage ein.

  4. Klicken Sie auf Mehr und wählen Sie Abfrageeinstellungen.

    Abfrageeinstellungen

  5. Deaktivieren Sie unter Cache-Einstellung die Option Im Cache gespeicherte Ergebnisse verwenden.

    Option für im Cache gespeicherte Ergebnisse

bq

Verwenden Sie das Flag nouse_cache, um den Abfrage-Cache zu überschreiben. Im folgenden Beispiel wird BigQuery gezwungen, die Abfrage zu verarbeiten, ohne die vorhandenen, im Cache gespeicherten Ergebnisse zu verwenden:

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

API

Wenn eine Abfrage ohne Verwendung der im Cache gespeicherten Ergebnisse verarbeitet werden soll, setzen Sie in der query-Jobkonfiguration das Attribut useQueryCache auf false.

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

Soll eine Abfrage ausgeführt werden, ohne die im Cache gespeicherten Ergebnisse zu verwenden, legen Sie für "useQueryCache" beim Erstellen einer QueryJobConfiguration den Wert false fest.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur  Python API.

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)

Verwendung des Cache gewährleisten

Wenn Sie zur Ausführung von Abfragen die Funktion jobs.insert verwenden, können Sie erzwingen, dass Abfragejobs fehlschlagen, wenn keine im Cache gespeicherten Ergebnisse verwendet werden können. Setzen Sie dazu das Attribut createDisposition der copy-Jobkonfiguration auf CREATE_NEVER.

Wenn das Abfrageergebnis im Cache nicht existiert, wird ein NOT_FOUND-Fehler zurückgegeben.

Verwendung des Cache überprüfen

Es gibt zwei Möglichkeiten festzustellen, ob BigQuery ein Ergebnis aus dem Cache zurückgegeben hat:

  • Wenn Sie die Cloud Console verwenden, enthält der Ergebnisstring keine Informationen zur Anzahl der verarbeiteten Byte, aber den Begriff cached.

    Cache-Anzeige in der Cloud Console

  • Wenn Sie die BigQuery API verwenden, ist das Attribut cacheHit im Abfrageergebnis auf true gesetzt.

Auswirkungen der Sicherheit auf Spaltenebene

Standardmäßig speichert BigQuery Abfrageergebnisse 24 Stunden lang im Cache, mit den zuvor genannten Ausnahmen. Der 24-Stunden-Cache gilt auch für Abfragen von Daten, die durch die Sicherheit auf Spaltenebene geschützt sind, die Richtlinien-Tags verwendet. Eine Änderung, z. B. das Entfernen einer Gruppe oder eines Nutzers aus der Rolle detaillierter Lesezugriff für Data Catalog, die für ein Richtlinien-Tag verwendet wird, macht den 24-Stunden-Cache nicht ungültig. Eine Änderung an der Zugriffssteuerungsgruppe detaillierter Lesezugriff für Data Catalog selbst wird sofort übernommen, aber der Cache wird dadurch nicht ungültig.

Dies hat zur Folge, dass durch die Abfrage die Abfrageergebnisse für den Nutzer auf dem Bildschirm sichtbar bleiben. Der Nutzer kann diese Ergebnisse auch dann aus dem Cache abrufen, selbst wenn er innerhalb der letzten 24 Stunden den Zugriff auf die Daten verloren hat.

In den 24 Stunden nach der Entfernung eines Nutzers aus der Rolle detaillierter Lesezugriff für Data Catalog für ein Richtlinien-Tag hat der Nutzer nur Zugriff auf die im Cache gespeicherten Daten, die ihm zuvor angezeigt wurden. Wenn Zeilen zur Tabelle hinzugefügt werden, sieht der Nutzer die hinzugefügten Zeilen nicht, selbst wenn die Ergebnisse im Cache gespeichert werden.