Tabellen erstellen und verwenden

In diesem Dokument wird beschrieben, wie Standardtabellen (integriert) in BigQuery erstellt und verwendet werden. Informationen zum Erstellen anderer Tabellentypen finden Sie in folgenden Artikeln:

Nach dem Erstellen einer Tabelle können Sie:

  • Den Zugriff auf Ihre Tabellendaten steuern
  • Informationen über Ihre Tabellen abrufen
  • Die Tabellen in einem Dataset auflisten
  • Tabellenmetadaten abrufen

Weitere Informationen zur Verwaltung von Tabellen, einschließlich dem Aktualisieren von Tabellenattributen, Kopieren von Tabellen und Löschen von Tabellen, finden Sie unter Tabellen verwalten.

Hinweis

Bevor Sie eine Tabelle in BigQuery erstellen, erledigen Sie zuerst Folgendes:

Tabellennamen

Wenn Sie eine Tabelle in BigQuery erstellen, muss der Tabellenname pro Dataset eindeutig sein. Der Tabellenname kann:

  • Enthält Zeichen mit insgesamt bis zu 1.024 UTF-8-Byte.
  • Unicode-Zeichen in Kategorie L (Buchstabe), M (Zeichen), N (Zahl), Pc (Verbindungselement, einschließlich Unterstrich), Pd (Strich), Zs (Leerzeichen) enthalten Weitere Informationen finden Sie unter Allgemeine Kategorie.

Beispiele für gültige Tabellennamen: table 01, ग्राहक, 00_お客様, étudiant-01.

Vorsichtsmaßnahmen:

  • Bei Tabellennamen wird standardmäßig zwischen Groß- und Kleinschreibung unterschieden. mytable und MyTable können im selben Dataset gleichzeitig vorhanden sein, es sei denn, sie sind Teil eines Datasets mit deaktivierter Berücksichtigung der Groß-/Kleinschreibung.
  • Einige Tabellennamen und Präfixe für Tabellennamen sind reserviert. Wenn Ihnen eine Fehlermeldung angezeigt wird, dass der Tabellenname oder das Präfix reserviert ist, wählen Sie einen anderen Namen aus und versuchen Sie es noch einmal.

  • Wenn Sie mehrere Punktoperatoren (.) in eine Sequenz aufnehmen, werden die doppelten Operatoren implizit entfernt.

    Beispiel: project_name....dataset_name..table_name

    Dieses Tag wird folgendermaßen geändert: project_name.dataset_name.table_name

Tabellen erstellen

So können Sie eine Tabelle in BigQuery erstellen:

  • Manuell mit der Google Cloud Console oder dem Befehl bq mk des bq-Befehlszeilentools.
  • Programmatisch durch Aufrufen der API-Methode tables.insert
  • Mit den Clientbibliotheken
  • Aus Abfrageergebnissen
  • Durch Definieren einer Tabelle, die auf eine externe Datenquelle verweist
  • Beim Laden von Daten
  • Mit der DDL-Anweisung (Data Definition Language) CREATE TABLE

Erforderliche Berechtigungen

Zum Erstellen einer Tabelle benötigen Sie die folgenden IAM-Berechtigungen:

  • bigquery.tables.create
  • bigquery.tables.updateData
  • bigquery.jobs.create

Außerdem ist möglicherweise die Berechtigung bigquery.tables.getData erforderlich, um auf die Daten zuzugreifen, die Sie in die Tabelle schreiben.

Alle folgenden vordefinierten IAM-Rollen enthält die Berechtigungen, die Sie für das Erstellen einer Tabelle benötigen:

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin (einschließlich der Berechtigung bigquery.jobs.create)
  • roles/bigquery.user (einschließlich der Berechtigung bigquery.jobs.create)
  • roles/bigquery.jobUser (einschließlich der Berechtigung bigquery.jobs.create)

Wenn Sie die Berechtigung bigquery.datasets.create haben, können Sie außerdem Tabellen in den von Ihnen erstellten Datasets anlegen und aktualisieren.

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Vordefinierte Rollen und Berechtigungen.

Eine leere Tabelle mit einer Schemadefinition erstellen

So können Sie eine leere Tabelle mit einer Schemadefinition erstellen:

  • Geben Sie das Schema mithilfe der Google Cloud Console ein.
  • Geben Sie das Schema inline mit dem bq-Befehlszeilentool an.
  • Reichen Sie eine JSON-Schemadatei unter Verwendung des bq-Befehlszeilentools ein.
  • Das Schema beim Aufrufen der API-Methode tables.insert in einer Tabellenressource angeben

Weitere Informationen zur Angabe eines Tabellenschemas finden Sie unter Schema angeben.

Nachdem die Tabelle erstellt wurde, können Sie Daten laden bzw. die Tabelle füllen. Dazu schreiben Sie Abfrageergebnisse in die Tabelle.

So erstellen Sie eine leere Tabelle mit einer Schemadefinition:

Console

  1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie dann ein Dataset aus.
  3. Klicken Sie im Abschnitt Dataset-Informationen auf Tabelle erstellen.
  4. Geben Sie im Bereich Tabelle erstellen die folgenden Details an:
    1. Wählen Sie im Abschnitt Quelle in der Liste Tabelle erstellen aus die Option Leere Tabelle aus.
    2. Geben Sie im Bereich Ziel die folgenden Details an:
      1. Wählen Sie bei Dataset das Dataset aus, in dem Sie die Tabelle erstellen möchten.
      2. Geben Sie im Feld Tabelle den Namen der Tabelle ein, die Sie erstellen möchten.
      3. Achten Sie darauf, dass das Feld Tabellentyp auf Native Tabelle eingestellt ist.
    3. Geben Sie im Abschnitt Schema die Schemadefinition ein. Sie können Schemainformationen manuell mit einer der folgenden Methoden eingeben:
      • Option 1: Klicken Sie auf Als Text bearbeiten und fügen Sie das Schema in Form eines JSON-Arrays ein. Generieren Sie das Schema mit demselben Verfahren wie beim Erstellen einer JSON-Schemadatei, wenn Sie ein JSON-Array verwenden. Sie können das Schema einer vorhandenen Tabelle im JSON-Format ansehen. Geben Sie dafür folgenden Befehl ein: 
            bq show --format=prettyjson dataset.table
      • Option 2: Klicken Sie auf Feld hinzufügen und geben Sie das Tabellenschema ein. Geben Sie für jedes Feld Name, Typ und Modus an.
    4. Optional: Geben Sie Partitions- und Clustereinstellungen an. Weitere Informationen finden Sie unter Partitionierte Tabellen erstellen und Geclusterte Tabellen erstellen und verwenden.
    5. Optional: Wählen Sie die Option Vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK) verwenden, wenn Sie im Abschnitt Erweiterte Optionen einen vom Kunden verwalteten Verschlüsselungsschlüssel verwenden möchten. Standardmäßig verschlüsselt BigQuery inaktive Kundendaten mit einem von Google verwalteten Schlüssel.
    6. Klicken Sie auf Tabelle erstellen.

SQL

Das folgende Beispiel erstellt eine Tabelle mit dem Namen newtable, die am 1. Januar 2023 abläuft.

  1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE mydataset.newtable (
  x INT64 OPTIONS (description = 'An optional INTEGER field'),
  y STRUCT <
    a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'),
    b BOOL
  >
) OPTIONS (
    expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC',
    description = 'a table that expires in 2023',
    labels = [('org_unit', 'development')]);

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

bq

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Führen Sie den Befehl bq mk mit dem Flag --table oder -t aus. Sie können Informationen zum Tabellenschema inline oder über eine JSON-Datei angeben. Optionale Parameter sind:

    • --expiration
    • --description
    • --time_partitioning_field
    • --time_partitioning_type
    • --range_partitioning
    • --clustering_fields
    • --destination_kms_key
    • --label

    --time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields und --destination_kms_key werden hier nicht behandelt. Weitere Informationen zu diesen optionalen Parametern finden Sie unter den folgenden Links:

    Wenn Sie eine Tabelle in einem anderen Projekt als dem Standardprojekt erstellen, fügen Sie dem Dataset die Projekt-ID im folgenden Format hinzu: project_id:dataset.

    Geben Sie Folgendes ein, um eine leere Tabelle mit einer Schemadefinition in einem vorhandenen Dataset zu erstellen:

    bq mk \
--table \
--expiration integer \
--description description \
--label key_1:value_1 \
--label key_2:value_2 \
project_id:dataset.table \
schema

    Dabei gilt:

    • integer die Standardlebensdauer (in Sekunden) der Tabelle ist. Der Mindestwert beträgt 3.600 Sekunden bzw. eine Stunde. Die Ablaufzeit entspricht der aktuellen UTC-Zeit plus dem ganzzahligen Wert. Wenn Sie beim Erstellen einer Tabelle die Ablaufzeit festlegen, wird die Standardeinstellung für die Ablaufzeit der Tabelle ignoriert.
    • description ist eine Beschreibung der Tabelle in Anführungszeichen.
    • key_1:value_1 und key_2:value_2 sind Schlüssel/Wert-Paare, die Labels angeben.
    • project_id ist die Projekt-ID.
    • dataset ist ein Dataset in Ihrem Projekt.
    • table ist der Name der Tabelle, die Sie erstellen.
    • schema ist eine Inline-Schemadefinition im Format field:data_type,field:data_type oder der Pfad zur JSON-Schemadatei auf Ihrem lokalen Computer.

    Wenn Sie das Schema in der Befehlszeile angeben, können Sie den Typ RECORD (STRUCT) und die Spaltenbeschreibung nicht einfügen. Außerdem ist es dann nicht möglich, den Modus der Spalte anzugeben. Als Modus ist immer standardmäßig NULLABLE eingestellt. Wenn Sie Beschreibungen, Modi und RECORD-Typen einbinden möchten, müssen Sie stattdessen eine JSON-Schemadatei bereitstellen.

    Beispiele:

    Mit dem folgenden Befehl erstellen Sie eine Tabelle mit einer Inline-Schemadefinition. Mithilfe dieses Befehls wird in Ihrem Standardprojekt eine Tabelle mit dem Namen mytable in mydataset erstellt. Die Ablaufzeit der Tabelle wird auf 3.600 Sekunden bzw. 1 Stunde, die Beschreibung auf This is my table und das Label auf organization:development festgelegt. Der Befehl verwendet das Kürzel -t anstelle von --table. So wird das Schema inline angegeben: qtr:STRING,sales:FLOAT,year:STRING.

    bq mk \
 -t \
 --expiration 3600 \
 --description "This is my table" \
 --label organization:development \
 mydataset.mytable \
 qtr:STRING,sales:FLOAT,year:STRING

    Mit dem folgenden Befehl erstellen Sie eine Tabelle mithilfe einer JSON-Schemadatei. Mithilfe dieses Befehls wird in Ihrem Standardprojekt eine Tabelle mit dem Namen mytable in mydataset erstellt. Die Ablaufzeit der Tabelle wird auf 3.600 Sekunden bzw. 1 Stunde, die Beschreibung auf This is my table und das Label auf organization:development festgelegt. Der Pfad zur Schemadatei lautet /tmp/myschema.json.

    bq mk \
 --table \
 --expiration 3600 \
 --description "This is my table" \
 --label organization:development \
 mydataset.mytable \
 /tmp/myschema.json

    Mit dem folgenden Befehl erstellen Sie eine Tabelle mit einer JSON-Schemadatei. Mithilfe dieses Befehls wird eine Tabelle mit dem Namen mytable in mydataset in myotherproject erstellt. Die Ablaufzeit der Tabelle wird auf 3.600 Sekunden bzw. 1 Stunde, die Beschreibung auf This is my table und das Label auf organization:development festgelegt. Der Pfad zur Schemadatei lautet /tmp/myschema.json.

    bq mk \
 --table \
 --expiration 3600 \
 --description "This is my table" \
 --label organization:development \
 myotherproject:mydataset.mytable \
 /tmp/myschema.json

    Nachdem die Tabelle erstellt wurde, können Sie die Ablaufzeit, die Beschreibung und die Labels der Tabelle aktualisieren. Ebenso können Sie die Schemadefinition ändern.

Terraform

Verwenden Sie die Ressource google_bigquery_table:

Tabelle erstellen

Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

Tabelle erstellen und Zugriff darauf gewähren

Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt und dann mit der Ressource google_bigquery_table_iam_policy Zugriff darauf gewährt. Führen Sie diesen Schritt nur aus, wenn Sie Hauptkonten, die keinen Zugriff auf das Dataset haben, in dem sich die Tabelle befindet, Zugriff auf die Tabelle gewähren möchten.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

Tabelle mit einem vom Kunden verwalteten Verschlüsselungsschlüssel erstellen

Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt. Außerdem werden die Ressourcen google_kms_crypto_key und google_kms_key_ring verwendet, um einen Cloud Key Management Service-Schlüssel für die Tabelle anzugeben. Sie müssen die Cloud Key Management Service API aktivieren, bevor Sie dieses Beispiel ausführen.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud-Projekt anzuwenden.

Cloud Shell vorbereiten

  1. Rufen Sie Cloud Shell auf.

  2. Legen Sie das Google Cloud-Standardprojekt fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

    Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

Verzeichnis vorbereiten

Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

  1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

    Kopieren Sie den Beispielcode in das neu erstellte main.tf.

    Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

  3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
  4. Speichern Sie die Änderungen.
  5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
    terraform init

    Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

    terraform init -upgrade

Änderungen anwenden

  1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
    terraform plan

    Korrigieren Sie die Konfiguration nach Bedarf.

  2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
    terraform apply

    Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

  3. Öffnen Sie Ihr Google Cloud-Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

API

Rufen Sie die Methode tables.insert mit einer definierten Tabellenressource auf.

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der C#-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


using Google.Cloud.BigQuery.V2;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Einfach loslegen (Go)

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Java

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    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();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Node.js

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// Import the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

Eine leere Tabelle ohne Schemadefinition erstellen

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Java-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a table without schema
public class CreateTableWithoutSchema {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createTableWithoutSchema(datasetName, tableName);
  }

  public static void createTableWithoutSchema(String datasetName, String tableName) {
    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();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Tabelle aus einem Abfrageergebnis erstellen

Schreiben Sie die Ergebnisse in eine Zieltabelle, um eine Tabelle aus einem Abfrageergebnis zu erstellen.

Console

  1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

    Zur Seite "BigQuery"

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

  3. Geben Sie eine gültige SQL-Abfrage ein.

  4. Klicken Sie auf Mehr und wählen Sie dann Abfrageoptionen aus.

    Abfrageeinstellungen

  5. Wählen Sie die Option Zieltabelle für Abfrageergebnisse festlegen aus.

    Ziel festlegen

  6. Wählen Sie unter Ziel das Dataset aus, in dem Sie die Tabelle erstellen möchten, und wählen Sie dann eine Tabellen-ID aus.

  7. Wählen Sie im Abschnitt Destination table write preference (Schreibeinstellung für Zieltabelle) eine der folgenden Optionen aus:

    • Write if empty (Schreiben, wenn leer): Die Abfrageergebnisse werden nur in die Tabelle geschrieben, wenn sie leer ist.
    • Append to table (An Tabelle anfügen): Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
    • Overwrite table (Tabelle überschreiben): Eine vorhandene Tabelle mit demselben Namen wird mit den Abfrageergebnissen überschrieben.

  8. Optional: Wählen Sie als Speicherort der Daten Ihren Standort aus.

  9. Klicken Sie auf Speichern, um die Abfrageeinstellungen zu aktualisieren.

  10. Klicken Sie auf Ausführen. Dadurch wird ein Abfragejob erstellt, mit dem die Abfrageergebnisse in die angegebene Tabelle geschrieben werden.

Wenn Sie vor dem Ausführen der Abfrage keine Zieltabelle angegeben haben, können Sie die im Cache gespeicherte Ergebnistabelle auch in eine permanente Tabelle kopieren. Klicken Sie hierfür über dem Editor auf die Schaltfläche Ergebnisse speichern.

SQL

Im folgenden Beispiel wird mit der Anweisung CREATE TABLE aus Daten in der öffentlichen Tabelle bikeshare_trips die Tabelle trips erstellt:

  1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE mydataset.trips AS (
  SELECT
    bike_id,
    start_time,
    duration_minutes
  FROM
    bigquery-public-data.austin_bikeshare.bikeshare_trips
);

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Weitere Informationen finden Sie unter Neue Tabelle aus einer vorhandenen Tabelle erstellen.

bq

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Um aus den Abfrageergebnissen eine permanente Tabelle zu erstellen, führen Sie den Befehl bq query mit dem Flag --destination_table aus. Mit dem Flag use_legacy_sql=false legen Sie die GoogleSQL-Syntax fest. Wenn Sie die Abfrageergebnisse in eine Tabelle schreiben möchten, die sich nicht in Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

    Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

    Geben Sie eines der folgenden optionalen Flags an, um die Schreibanordnung für eine vorhandene Zieltabelle zu steuern:

    • --append_table: Wenn die Zieltabelle vorhanden ist, werden die Abfrageergebnisse an diese angefügt.

    • --replace: Wenn die Zieltabelle vorhanden ist, wird sie mit den Abfrageergebnissen überschrieben.

      bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

      Dabei gilt:

    • location ist der Name des Standorts, an dem die Abfrage bearbeitet wurde. Das Flag --location ist optional. Wenn Sie BigQuery beispielsweise in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei .bigqueryrc können Sie für den Standort einen Standardwert festlegen.

    • project_id ist die Projekt-ID.

    • dataset ist der Name des Datasets mit der Tabelle, in die Sie die Abfrageergebnisse schreiben.

    • table ist der Name der Tabelle, in die Sie die Abfrageergebnisse schreiben.

    • query ist eine Abfrage in der GoogleSQL-Syntax.

      Wenn kein Schreibanordnungs-Flag angegeben ist, werden die Ergebnisse standardmäßig nur dann in die Tabelle geschrieben, wenn sie leer ist. Wenn die Tabelle vorhanden und nicht leer ist, wird der folgende Fehler zurückgegeben: "BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table".

      Beispiele:

      Mit dem folgenden Befehl schreiben Sie Abfrageergebnisse in eine Zieltabelle mit dem Namen mytable in mydataset. Das Dataset befindet sich in Ihrem Standardprojekt. Da im Befehl kein Schreibanordnungs-Flag angegeben ist, muss die Tabelle neu oder leer sein. Andernfalls wird der Fehler Already exists zurückgegeben. Mit dieser Abfrage werden Daten aus dem öffentlichen Dataset USA Name Data abgerufen.

      bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=false \
'SELECT
name,
number
FROM
`bigquery-public-data`.usa_names.usa_1910_current
WHERE
gender = "M"
ORDER BY
number DESC'

      Mit dem folgenden Befehl überschreiben Sie eine Zieltabelle mit dem Namen mytable in mydataset mit Abfrageergebnissen. Das Dataset befindet sich in Ihrem Standardprojekt. In dem Befehl wird das Flag --replace verwendet, um die Zieltabelle zu überschreiben.

      bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=false \
'SELECT
name,
number
FROM
`bigquery-public-data`.usa_names.usa_1910_current
WHERE
gender = "M"
ORDER BY
number DESC'

      Mit dem folgenden Befehl fügen Sie Abfrageergebnisse an eine Zieltabelle mit dem Namen mytable in mydataset an. Das Dataset befindet sich in my-other-project und nicht in Ihrem Standardprojekt. In dem Befehl wird das Flag --append_table verwendet, um die Abfrageergebnisse an die Zieltabelle anzufügen.

      bq query \
--append_table \
--use_legacy_sql=false \
--destination_table my-other-project:mydataset.mytable \
'SELECT
name,
number
FROM
`bigquery-public-data`.usa_names.usa_1910_current
WHERE
gender = "M"
ORDER BY
number DESC'

      Die Ausgabe für jedes dieser Beispiele sieht folgendermaßen aus. Aus Gründen der Lesbarkeit ist ein Teil der Ausgabe abgeschnitten.

      Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

Wenn Sie Abfrageergebnisse in einer permanenten Tabelle speichern möchten, rufen Sie die Methode jobs.insert auf. Anschließend konfigurieren Sie einen query-Job und geben einen Wert für das Attribut destinationTable an. Sie konfigurieren das Attribut writeDisposition, um die Schreibanordnung für eine vorhandene Zieltabelle zu steuern.

Geben Sie im Abschnitt jobReference der Jobressource das Attribut location an, um den Verarbeitungsstandort für den Abfragejob zu steuern.

Go

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	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 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// 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

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

Wenn Sie die Abfrageergebnisse in einer permanenten Tabelle speichern möchten, geben Sie für die Zieltabelle die gewünschte TableId in einer QueryJobConfiguration an.

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.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, 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();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \n" + e.toString());
    }
  }
}

Node.js

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

Wenn Sie die Abfrageergebnisse in einer permanenten Tabelle speichern möchten, erstellen Sie eine QueryJobConfig und legen als Ziel die gewünschte TableReference fest. Übergeben Sie die Jobkonfiguration an die Abfragemethode. 
from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Auf eine externe Datenquelle verweisende Tabelle erstellen

Eine externe Datenquelle ist eine Datenquelle, für die auch dann direkt aus BigQuery heraus eine Abfrage ausgeführt werden kann, wenn die Daten nicht im BigQuery-Speicher gespeichert sind. Angenommen, Sie haben Daten in einer anderen Google Cloud-Datenbank, in Dateien in Cloud Storage oder in einem anderen Cloud-Produkt, die Sie zwar in BigQuery analysieren möchten, die aber nicht für die Migration vorbereitet sind.

Weitere Informationen finden Sie unter Einführung in externe Datenquellen.

Tabelle beim Laden von Daten erstellen

Beim Laden von Daten in BigQuery können Sie Daten in eine neue Tabelle oder Partition laden bzw. an eine vorhandene Tabelle oder Partition anfügen. Genauso können Sie eine Tabelle oder Partition überschreiben. Sie müssen keine leere Tabelle erstellen, bevor Sie die Daten laden. Sie können die Daten gleich beim Erstellen der neuen Tabelle laden.

Beim Laden von Daten in BigQuery können Sie das Tabellen- oder Partitionsschema angeben oder die automatische Schemaerkennung verwenden, wenn es sich um unterstützte Datenformate handelt.

Weitere Informationen zum Laden von Daten finden Sie unter Einführung in das Laden von Daten in BigQuery.

Zugriff auf Tabellen steuern

Wenn Sie den Zugriff auf Tabellen und Ansichten konfigurieren möchten, können Sie einer Entität auf den folgenden Ebenen, geordnet vom größten zulässigen Ressourcenbereich zum kleinsten, eine IAM-Rolle zuweisen:

  • auf einer übergeordneten Ebene in der Google Cloud-Ressourcenhierarchie, z. B. der Projekt-, Ordner- oder Organisationsebene
  • auf der Dataset-Ebene
  • auf der Tabellen- oder Ansichtsebene

Sie können den Datenzugriff innerhalb von Tabellen auch mithilfe der folgenden Methoden einschränken:

Der Zugriff über eine durch IAM geschützte Ressource ist additiv. Wenn eine Entität beispielsweise keinen Zugriff auf übergeordneter Ebene (z. B. Projektebene) hat, können Sie der Entität Zugriff auf Dataset-Ebene gewähren. Die Entität hat dann Zugriff auf die Tabellen und Ansichten im Dataset. Wenn die Entität dagegen weder Zugriff auf übergeordneter Ebene noch auf Dataset-Ebene hat, können Sie der Entität Zugriff auf Tabellen- oder Ansichtsebene gewähren.

Wenn Sie in der Google Cloud-Ressourcenhierarchie IAM-Rollen auf einer höheren Ebene zuweisen, z. B. auf Projekt-, Ordner- oder Organisationsebene, erhält die Entität Zugriff auf eine Vielzahl von Ressourcen. Wenn Sie beispielsweise einer Entität auf Projektebene eine Rolle zuweisen, erhält diese Entität Berechtigungen, die für alle Datasets im gesamten Projekt gelten.

Durch das Zuweisen einer Rolle auf Dataset-Ebene werden die Vorgänge angegeben, die eine Entität für Tabellen und Ansichten in diesem bestimmten Dataset ausführen darf, auch wenn die Entität keinen Zugriff auf einer höheren Ebene hat. Informationen zum Konfigurieren von Zugriffssteuerungen auf Dataset-Ebene finden Sie unter Zugriff auf Datasets steuern.

Durch das Zuweisen einer Rolle auf Tabellen- oder Ansichtsebene werden die Vorgänge angegeben, die eine Entität für bestimmte Tabellen und Ansichten ausführen darf, auch wenn die Entität keinen Zugriff auf einer höheren Ebene hat. Informationen zum Konfigurieren von Zugriffssteuerungen auf Tabellenebene finden Sie unter Zugriff auf Tabellen und Ansichten steuern.

Sie können auch benutzerdefinierte IAM-Rollen erstellen. Wenn Sie eine benutzerdefinierte Rolle erstellen, hängen die erteilten Berechtigungen von den spezifischen Vorgängen ab, die die Entität ausführen soll.

Sie können für eine durch IAM geschützte Ressource keine "Ablehnen"-Berechtigung festlegen.

Weitere Informationen zu Rollen und Berechtigungen finden Sie in der IAM-Dokumentation unter Informationen zu Rollen und in BigQuery-IAM-Rollen und -Berechtigungen.

Informationen zu Tabellen abrufen

So erhalten Sie Informationen oder Metadaten zu Tabellen:

  • Google Cloud Console verwenden
  • Mit dem Befehl bq show des bq-Befehlszeilentools
  • Durch Aufruf der API-Methode tables.get
  • Mithilfe der Clientbibliotheken
  • Durch Abfragen der INFORMATION_SCHEMA-Ansichten (Beta)

Erforderliche Berechtigungen

Sie benötigen mindestens Berechtigungen vom Typ bigquery.tables.get, um Informationen zu Tabellen abzurufen. Die folgenden vordefinierten IAM-Rollen enthalten bigquery.tables.get-Berechtigungen:

  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit dem bigquery.dataOwner-Zugriff kann der Nutzer Metadaten von Tabellen abrufen.

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Zugriffssteuerung.

Tabelleninformationen abrufen

So rufen Sie Informationen zu Tabellen ab:

Console

  1. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.

  2. Klicken Sie auf den Namen des Datasets, um es einzublenden. Die Tabellen und Ansichten im Dataset werden angezeigt.

  3. Klicken Sie auf den Namen der Tabelle.

  4. Klicken Sie im Bereich Details auf Details, um die Beschreibung und die Informationen der Tabelle anzusehen.

  5. Wechseln Sie optional zum Tab Schema, um die Schemadefinition der Tabelle anzusehen.

bq

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Führen Sie den Befehl bq show aus, um alle Tabelleninformationen aufzurufen. Verwenden Sie das Flag --schema, wenn nur Informationen zum Tabellenschema angezeigt werden sollen. Mit dem Flag --format kann die Ausgabe gesteuert werden.

    Wenn Sie Informationen zu einer Tabelle in einem anderen Projekt als Ihrem Standardprojekt abrufen, fügen Sie dem Dataset die Projekt-ID im Format project_id:dataset hinzu.

    bq show \
--schema \
--format=prettyjson \
project_id:dataset.table

    Dabei gilt:

    • project_id ist die Projekt-ID.
    • dataset ist der Name des Datasets.
    • table ist der Name der Tabelle.

    Beispiele:

    Geben Sie den folgenden Befehl ein, um alle Informationen zu mytable in mydataset aufzurufen. mydataset befindet sich in Ihrem Standardprojekt.

    bq show --format=prettyjson mydataset.mytable

    Geben Sie den folgenden Befehl ein, um alle Informationen zu mytable in mydataset aufzurufen. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

    bq show --format=prettyjson myotherproject:mydataset.mytable

    Geben Sie den folgenden Befehl ein, um nur Schemainformationen zu mytable in mydataset aufzurufen. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

    bq show --schema --format=prettyjson myotherproject:mydataset.mytable

API

Mithilfe der Methode tables.get geben Sie alle relevanten Parameter an.

Go

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	return nil
}

Java

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

  public static void getTable(String projectId, String datasetName, String tableName) {
    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();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \n" + e.toString());
    }
  }
}

Node.js

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Mit INFORMATION_SCHEMA Informationen zu Tabellen abrufen

INFORMATION_SCHEMA umfasst mehrere Ansichten, über die auf Metadaten von Datasets, Routinen, Tabellen, Ansichten, Jobs, Reservierungen und Streamingdaten zugegriffen werden kann.

Sie können die folgenden Ansichten abfragen, um Tabelleninformationen abzurufen:

  • Mit den Ansichten INFORMATION_SCHEMA.TABLES und INFORMATION_SCHEMA.TABLE_OPTIONS können Sie Metadaten von Tabellen und Ansichten eines Projekts abrufen.
  • Mit den Ansichten INFORMATION_SCHEMA.COLUMNS und INFORMATION_SCHEMA.COLUMN_FIELD_PATHS können Sie Metadaten zu den Spalten (Feldern) einer Tabelle abrufen.
  • Mit den Ansichten INFORMATION_SCHEMA.TABLE_STORAGE können Sie Metadaten zur aktuellen und bisherigen Speichernutzung durch eine Tabelle abrufen.

Die Ansichten TABLES und TABLE_OPTIONS enthalten auch allgemeine Informationen zu Ansichten. Detaillierte Informationen erhalten Sie, wenn Sie stattdessen die Ansicht INFORMATION_SCHEMA.VIEWS abfragen.

Ansicht TABLES

Wenn Sie die Ansicht INFORMATION_SCHEMA.TABLES abfragen, wird in den Abfrageergebnissen jede Tabelle oder Ansicht eines Datasets in einer eigenen Zeile dargestellt. Detaillierte Informationen zu Ansichten erhalten Sie, wenn Sie stattdessen die Ansicht INFORMATION_SCHEMA.VIEWS abfragen.

Die Ansicht INFORMATION_SCHEMA.TABLES hat das folgende Schema:

Spaltenname Datentyp Wert
table_catalog STRING Die ID des Projekts, das das Dataset enthält.
table_schema STRING Der Name des Datasets, das die Tabelle oder Ansicht enthält. Wird auch als datasetId bezeichnet.
table_name STRING Der Name der Tabelle oder Ansicht. Wird auch als tableId bezeichnet.
table_type STRING Der Tabellentyp; einer der folgenden:
is_insertable_into STRING YES oder NO, je nachdem, ob die Tabelle DML INSERT-Anweisungen unterstützt
is_typed STRING Der Wert ist immer NO
creation_time TIMESTAMP Der Erstellungszeitpunkt der Tabelle
base_table_catalog STRING Für Tabellenklone und Tabellen-Snapshots ist dies das Projekt der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE oder SNAPSHOT gesetzt ist.
base_table_schema STRING Für Tabellenklone und Tabellen-Snapshots ist dies das Dataset der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE oder SNAPSHOT gesetzt ist.
base_table_name STRING Für Tabellenklone und Tabellen-Snapshots ist dies der Name der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE oder SNAPSHOT gesetzt ist.
snapshot_time_ms TIMESTAMP Für Tabellenklone und Tabellen-Snapshots ist dies der Zeitpunkt, zu dem der Klon- oder Snapshot-Vorgang zur Erstellung dieser Tabelle für die Basistabelle ausgeführt wurde. Wenn Zeitreise verwendet wurde, enthält dieses Feld den Zeitreise-Zeitstempel. Andernfalls ist das Feld snapshot_time_ms mit dem Feld creation_time identisch. Gilt nur für Tabellen, bei denen table_type auf CLONE oder SNAPSHOT gesetzt ist.
replica_source_catalog STRING Bei Replikaten der materialisierten Ansicht ist dies das Projekt der materialisierten Basisansicht.
replica_source_schema STRING Bei Replikaten der materialisierten Ansicht ist dies das Dataset der materialisierten Basisansicht.
replica_source_name STRING Für Replikate der materialisierten Ansicht ist dies der Name der materialisierten Basisansicht.
replication_status STRING Bei Replikaten der materialisierten Ansicht der Status der Replikation von der materialisierten Basisansicht zum Replikat der materialisierten Ansicht. Folgende Status sind möglich:
  • REPLICATION_STATUS_UNSPECIFIED
  • ACTIVE: Replikation ist ohne Fehler aktiv
  • SOURCE_DELETED: Die materialisierte Quellansicht wurde gelöscht
  • PERMISSION_DENIED: Die materialisierte Quellansicht wurde für das Dataset, das die Amazon S3-BigLake-Quelltabellen enthält, die in der Abfrage verwendet werden, die die materialisierte Ansicht erstellt haben, nicht autorisiert.
  • UNSUPPORTED_CONFIGURATION: Es gibt ein Problem mit den Voraussetzungen des Replikats außer der Autorisierung der materialisierten Quellansicht.
replication_error STRING Wenn replication_status auf ein Replikationsproblem für ein Replikat einer materialisierten Ansicht hinweist, enthält replication_error weitere Details zum Problem.
ddl STRING Die DDL-Anweisung, mit der die Tabelle neu erstellt werden kann, z. B. CREATE TABLE oder CREATE VIEW
default_collation_name STRING Der Name der standardmäßigen Sortierspezifikation, falls vorhanden. Andernfalls NULL.
upsert_stream_apply_watermark TIMESTAMP Bei Tabellen, die Change Data Capture (CDC) verwenden, ist dies der Zeitpunkt der letzten Anwendung von Zeilenänderungen. Weitere Informationen finden Sie unter Fortschritt des Tabellen-Upsert-Vorgangs überwachen.

Beispiele

Beispiel 1:

Im folgenden Beispiel werden Tabellenmetadaten für alle Tabellen im Dataset mydataset abgerufen. Die zurückgegebenen Metadaten gelten für alle Tabellentypen in mydataset in Ihrem Standardprojekt.

mydataset enthält folgende Tabellen:

  • mytable1: eine Standard-BigQuery-Tabelle
  • myview1: Eine BigQuery-Ansicht

Dem Dataset fügen Sie die Projekt-ID im folgenden Format hinzu, um die Abfrage für ein anderes Projekt als Ihr Standardprojekt auszuführen: `project_id`.dataset.INFORMATION_SCHEMA.view; beispielsweise `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

SELECT
  table_catalog, table_schema, table_name, table_type,
  is_insertable_into, creation_time, ddl
FROM
  mydataset.INFORMATION_SCHEMA.TABLES;

Das Ergebnis sieht etwa so aus. Zur besseren Lesbarkeit werden einige Spalten aus dem Ergebnis ausgeschlossen.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` |
|                |               |                |            |                    |                     | (                                           |
|                |               |                |            |                    |                     |   id INT64                                  |
|                |               |                |            |                    |                     | );                                          |
| myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1`   |
|                |               |                |            |                    |                     | AS SELECT 100 as id;                        |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Beispiel 2:

Im folgenden Beispiel werden Tabellenmetadaten für alle Tabellen des Typs CLONE oder SNAPSHOT aus der Ansicht INFORMATION_SCHEMA.TABLES abgerufen. Die zurückgegebenen Metadaten beziehen sich auf Tabellen in mydataset in Ihrem Standardprojekt.

Dem Dataset fügen Sie die Projekt-ID im folgenden Format hinzu, um die Abfrage für ein anderes Projekt als Ihr Standardprojekt auszuführen: `project_id`.dataset.INFORMATION_SCHEMA.view; beispielsweise `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

  SELECT
    table_name, table_type, base_table_catalog,
    base_table_schema, base_table_name, snapshot_time_ms
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'CLONE'
  OR
    table_type = 'SNAPSHOT';

Das Ergebnis sieht etwa so aus. Zur besseren Lesbarkeit werden einige Spalten aus dem Ergebnis ausgeschlossen.

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | table_name   | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms    |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | items_clone  | CLONE      | myproject          | mydataset         | items           | 2018-10-31 22:40:05 |
  | orders_bk    | SNAPSHOT   | myproject          | mydataset         | orders          | 2018-11-01 08:22:39 |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+

Beispiel 3:

Im folgenden Beispiel werden die Spalten table_name und ddl aus der Ansicht INFORMATION_SCHEMA.TABLES für die Tabelle population_by_zip_2010 im Dataset census_bureau_usa abgerufen. Dieses Dataset ist Teil des öffentlichen Dataset-Programms von BigQuery.

Da sich die abgefragte Tabelle in einem anderen Projekt befindet, fügen Sie dem Dataset die Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view. In diesem Beispiel ist der Wert `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

SELECT
  table_name, ddl
FROM
  `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
WHERE
  table_name = 'population_by_zip_2010';

Das Ergebnis sieht etwa so aus:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       table_name       |                                                                                                            ddl                                                                                                             |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010`                                                                                                                                               |
|                        | (                                                                                                                                                                                                                          |
|                        |   geo_id STRING OPTIONS(description="Geo code"),                                                                                                                                                                           |
|                        |   zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"),                                                                                                                          |
|                        |   population INT64 OPTIONS(description="The total count of the population for this segment."),                                                                                                                             |
|                        |   minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."),                                                          |
|                        |   maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), |
|                        |   gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.")                                                                                                                    |
|                        | )                                                                                                                                                                                                                          |
|                        | OPTIONS(                                                                                                                                                                                                                   |
|                        |   labels=[("freebqcovid", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Ansicht TABLE_OPTIONS

Wenn Sie die Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS abfragen, wird in den Abfrageergebnissen jede Tabelle oder Ansicht eines Datasets in einer eigenen Zeile für jede Option dargestellt. Detaillierte Informationen zu Ansichten erhalten Sie, wenn Sie stattdessen die Ansicht INFORMATION_SCHEMA.VIEWS abfragen.

Die Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle oder Ansicht enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
OPTION_NAME STRING Ein Namenswert der Optionstabelle
OPTION_TYPE STRING Ein Datentypwert der Optionstabelle
OPTION_VALUE STRING Eine Wertoption der Optionstabelle
Optionstabelle
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 Die Standardlebensdauer aller Partitionen in einer partitionierten Tabelle in Tagen
expiration_timestamp TIMESTAMP Die Zeit, zu der diese Tabelle abläuft
kms_key_name STRING Der Name des Cloud KMS-Schlüssels zum Verschlüsseln der Tabelle
friendly_name STRING Der beschreibende Name der Tabelle
description STRING Eine Beschreibung der Tabelle
labels ARRAY<STRUCT<STRING, STRING>> Ein STRUCT-Array, das die Labels der Tabelle darstellt
require_partition_filter BOOL Gibt an, ob Abfragen über die Tabelle einen Partitionsfilter erfordern
enable_refresh BOOL Gibt an, ob die automatische Aktualisierung für eine materialisierte Ansicht aktiviert ist
refresh_interval_minutes FLOAT64 Gibt an, wie häufig eine materialisierte Ansicht aktualisiert wird

Für externe Tabellen sind die folgenden Optionen möglich:

Optionen
allow_jagged_rows

BOOL

Bei true werden Zeilen ohne nachgestellte optionale Spalten zugelassen.

Gilt für CSV-Daten.
allow_quoted_newlines

BOOL

Bei true werden in Anführungszeichen eingeschlossene Datenabschnitte mit Zeilenumbruchzeichen in der Datei zugelassen.

Gilt für CSV-Daten.
bigtable_options

STRING

Nur erforderlich, wenn Sie eine externe Bigtable-Tabelle erstellen.

Gibt das Schema der externen Bigtable-Tabelle im JSON-Format an.

Eine Liste der Optionen für Bigtable-Tabellendefinitionen finden Sie in der REST API-Referenz unter BigtableOptions.
compression

STRING

Komprimierungstyp der Datenquelle. Diese Werte werden unterstützt: GZIP Wenn keine Angabe erfolgt, ist die Datenquelle unkomprimiert.

Gilt für CSV- und JSON-Daten.
decimal_target_types

ARRAY<STRING>

Bestimmt, wie ein Decimal-Typ konvertiert wird. Entspricht ExternalDataConfiguration.decimal_target_types

Beispiel: ["NUMERIC", "BIGNUMERIC"].
description

STRING

Eine Beschreibung dieser Tabelle.
enable_list_inference

BOOL

Verwenden Sie bei true die Schemainferenz speziell für den logischen Parquet-LIST-Typ.

Gilt für Parquet-Daten.
enable_logical_types

BOOL

Bei true werden logische Avro-Typen in die entsprechenden SQL-Typen konvertiert. Weitere Informationen finden Sie unter Logische Typen.

Gilt für Avro-Daten.
encoding

STRING

Die Zeichencodierung der Daten. Unterstützte Werte sind: UTF8 (oder UTF-8), ISO_8859_1 (oder ISO-8859-1).

Gilt für CSV-Daten.
enum_as_string

BOOL

Wenn true, wird der logische Parquet-ENUM-Typ standardmäßig als STRING und nicht als BYTES abgeleitet.

Gilt für Parquet-Daten.
expiration_timestamp

TIMESTAMP

Die Zeit, zu der diese Tabelle abläuft. Wenn keine Angabe erfolgt, läuft die Tabelle nicht ab.

Beispiel: "2025-01-01 00:00:00 UTC".
field_delimiter

STRING

Das Trennzeichen für Felder in einer CSV-Datei.

Gilt für CSV-Daten.
format

STRING

Das Format der externen Daten. Unterstützte Werte für CREATE EXTERNAL TABLE beinhalten: AVRO, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (Vorschau), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (oder JSON), ORC, PARQUET.

Unterstützte Werte für LOAD DATA umfassen: AVRO, CSV ,DELTA_LAKE (Vorschau )NEWLINE_DELIMITED_JSON (oderJSON), ORC, PARQUET.

Der Wert JSON entspricht NEWLINE_DELIMITED_JSON.
hive_partition_uri_prefix

STRING

Ein gemeinsames Präfix für alle Quell-URIs, bevor die Codierung des Partitionierungsschlüssels beginnt. Gilt nur für mit Hive partitionierte Tabellen.

Gilt für Avro-, CSV-, JSON-, Parquet- und ORC-Daten.

Beispiel: "gs://bucket/path".
file_set_spec_type

STRING

Gibt an, wie Quell-URIs für Ladejobs und externe Tabellen interpretiert werden. In der Vorschau.

Unterstützte Werte sind:

  • FILE_SYSTEM_MATCH. Maximiert die Quell-URIs, indem Dateien aus dem Objektspeicher aufgelistet werden. Dies ist das Standardverhalten, wenn FileSetSpecType nicht festgelegt ist.
  • NEW_LINE_DELIMITED_MANIFEST. Gibt an, dass die angegebenen URIs Manifestdateien mit Zeilenumbruch mit einem URI pro Zeile sind. Platzhalter-URIs werden in den Manifestdateien nicht unterstützt.

Wenn Sie beispielsweise den Quell-URI "gs://bucket/path/file" haben und file_set_spec_type den Wert FILE_SYSTEM_MATCH hat, wird die Datei direkt als Datendatei verwendet. Wenn file_set_spec_type den Wert NEW_LINE_DELIMITED_MANIFEST hat, wird jede Zeile in der Datei als URI interpretiert, der auf eine Datendatei verweist.
ignore_unknown_values

BOOL

Bei true werden zusätzliche Werte ignoriert, die nicht im Tabellenschema enthalten sind, ohne dass ein Fehler zurückgegeben wird.

Gilt für CSV- und JSON-Daten.
json_extension

STRING

Gibt für JSON-Daten ein bestimmtes JSON-Austauschformat an. Wenn nicht angegeben, liest BigQuery die Daten als generische JSON-Einträge.

Diese Werte werden unterstützt:
GEOJSON. Durch Zeilenumbruch getrennte GeoJSON-Daten. Weitere Informationen finden Sie unter Externe Tabelle aus einer durch Zeilenumbruch getrennten GeoJSON-Datei erstellen.

max_bad_records

INT64

Die maximale Anzahl fehlerhafter Datensätze, die beim Lesen der Daten ignoriert werden.

Gilt für CSV-, JSON- und Google Tabellen-Daten.
max_staleness

INTERVAL

Gilt für BigLake-Tabellen und Objekttabellen.

Gibt an, ob im Cache gespeicherte Metadaten von Vorgängen für die Tabelle verwendet werden und wie aktuell die im Cache gespeicherten Metadaten sein müssen, damit der Vorgang sie verwenden kann.

Geben Sie 0 an, um das Caching von Metadaten zu deaktivieren. Das ist die Standardeinstellung.

Geben Sie zum Aktivieren des Metadaten-Cachings für das Intervallliteral einen Wert zwischen 30 Minuten und 7 Tagen an. Beispiel: Geben Sie INTERVAL 4 HOUR für ein Veralterungsintervall von vier Stunden an. Mit diesem Wert verwenden Vorgänge im Zusammenhang mit der Tabelle im Cache gespeicherte Metadaten, wenn sie innerhalb der letzten vier Stunden aktualisiert wurden. Sind die im Cache gespeicherten Metadaten älter, werden für den Vorgang stattdessen Metadaten aus Cloud Storage abgerufen.
metadata_cache_mode

STRING

Gilt für BigLake-Tabellen und Objekttabellen.

Gibt an, ob der Metadaten-Cache für die Tabelle automatisch oder manuell aktualisiert wird.

Legen Sie AUTOMATIC fest, damit der Metadaten-Cache in einem systemdefinierten Intervall aktualisiert wird, normalerweise zwischen 30 und 60 Minuten.

Legen Sie MANUAL fest, wenn Sie den Metadaten-Cache nach einem von Ihnen bestimmten Zeitplan aktualisieren möchten. In diesem Fall können Sie den SystemvorgangBQ.REFRESH_EXTERNAL_METADATA_CACHE aufrufen, um den Cache zu aktualisieren.

Sie müssen metadata_cache_mode festlegen, wenn max_staleness auf einen Wert größer als 0 festgelegt ist.
null_marker

STRING

Der String, der NULL-Werte in einer CSV-Datei darstellt.

Gilt für CSV-Daten.
object_metadata

STRING

Nur erforderlich, wenn Sie eine Objekttabelle erstellen.

Legen Sie den Wert dieser Option beim Erstellen einer Objekttabelle auf SIMPLE fest.
preserve_ascii_control_characters

BOOL

Bei true werden die eingebetteten ASCII-Steuerzeichen, die die ersten 32 Zeichen in der ASCII-Tabelle sind, von „\x00” bis „\x1F” beibehalten.

Gilt für CSV-Daten.
projection_fields

STRING

Eine Liste der zu ladenden Entitätsattribute.

Gilt für Datastore-Daten.
quote

STRING

Der String, der zum Kennzeichnen von Datenabschnitten in einer CSV-Datei verwendet wird. Wenn Ihre Daten Zeilenumbruchzeichen in Anführungszeichen enthalten, setzen Sie auch das Attribut allow_quoted_newlines auf true.

Gilt für CSV-Daten.
reference_file_schema_uri

STRING

Vom Nutzer bereitgestellte Referenzdatei mit dem Tabellenschema.

Gilt für Parquet-/ORC-/AVRO-Daten.

Beispiel: "gs://bucket/path/reference_schema_file.parquet".
require_hive_partition_filter

BOOL

Bei true ist für alle Abfragen über diese Tabelle ein Partitionsfilter erforderlich, mit dem Partitionen beim Lesen von Daten entfernt werden können. Gilt nur für mit Hive partitionierte Tabellen.

Gilt für Avro-, CSV-, JSON-, Parquet- und ORC-Daten.
sheet_range

STRING

Bereich einer Google Tabellen-Tabelle, aus der abgefragt werden soll.

Gilt für Google Tabellen-Daten.

Beispiel: “sheet1!A1:B20”.
skip_leading_rows

INT64

Die Anzahl der Zeilen am Anfang einer Datei, die beim Lesen der Daten übersprungen werden sollen.

Gilt für CSV- und Google Tabellen-Daten.
uris

Für externe Tabellen, einschließlich Objekttabellen, die keine Bigtable-Tabellen sind:

ARRAY<STRING>

Ein Array von voll qualifizierten URIs für die externen Datenspeicherorte. Jeder URI kann ein Sternchen (*) als Platzhalterzeichen enthalten, das nach dem Bucket-Namen stehen muss. Wenn Sie uris-Werte angeben, die auf mehrere Dateien abzielen, müssen alle diese Dateien ein kompatibles Schema verwenden.

Die folgenden Beispiele zeigen gültige uris-Werte:

  • ['gs://bucket/path1/myfile.csv']
  • ['gs://bucket/path1/*.csv']
  • ['gs://bucket/path1/*', 'gs://bucket/path2/file00*']

Für Bigtable-Tabellen:

STRING

Der URI, der die Bigtable-Tabelle identifiziert, die als Datenquelle verwendet werden soll. Sie können nur einen Bigtable-URI angeben.

Beispiel: https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Weitere Informationen zum Erstellen eines Bigtable-URI finden Sie unter Bigtable-URI abrufen.

Beispiele

Beispiel 1:

Im folgenden Beispiel werden die Standardablaufzeiten für alle Tabellen in mydataset in Ihrem Standardprojekt myproject durch Abfrage der Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS abgerufen.

Dem Dataset fügen Sie die Projekt-ID im folgenden Format hinzu, um die Abfrage für ein anderes Projekt als Ihr Standardprojekt auszuführen: `project_id`.dataset.INFORMATION_SCHEMA.view; beispielsweise `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'expiration_timestamp';

Das Ergebnis sieht etwa so aus:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+

Beispiel 2:

Im folgenden Beispiel werden Metadaten von allen Tabellen in mydataset abgerufen, die Testdaten enthalten. Für die Abfrage werden zur Ermittlung von Tabellen, die den Begriff "test" in der Beschreibung enthalten, die Werte der Option description verwendet. mydataset befindet sich in Ihrem Standardprojekt myproject.

Wenn Sie die Abfrage für ein anderes Projekt als Ihr Standardprojekt ausführen möchten, fügen Sie dem Dataset die Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view; beispielsweise so: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'description'
    AND option_value LIKE '%test%';

Das Ergebnis sieht etwa so aus:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+

Ansicht COLUMNS

Wenn Sie die Ansicht INFORMATION_SCHEMA.COLUMNS abfragen, wird in den Abfrageergebnissen jede Spalte (jedes Feld) einer Tabelle in einer eigenen Zeile dargestellt.

Die Ansicht INFORMATION_SCHEMA.COLUMNS hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
COLUMN_NAME STRING Der Name der Spalte
ORDINAL_POSITION INT64 Der 1-indexierte Versatz der Spalte in der Tabelle; bei einer Pseudospalte wie _PARTITIONTIME oder _PARTITIONDATE ist der Wert NULL
IS_NULLABLE STRING YES oder NO, je nachdem, ob der Spaltenmodus NULL-Werte zulässt
DATA_TYPE STRING Der GoogleSQL-Datentyp der Spalte
IS_GENERATED STRING Der Wert ist immer NEVER
GENERATION_EXPRESSION STRING Der Wert ist immer NULL
IS_STORED STRING Der Wert ist immer NULL
IS_HIDDEN STRING YES oder NO, je nachdem, ob die Spalte eine Pseudospalte wie _PARTITIONTIME oder _PARTITIONDATE ist
IS_UPDATABLE STRING Der Wert ist immer NULL
IS_SYSTEM_DEFINED STRING YES oder NO, je nachdem, ob die Spalte eine Pseudospalte wie _PARTITIONTIME oder _PARTITIONDATE ist
IS_PARTITIONING_COLUMN STRING YES oder NO, je nachdem, ob die Spalte eine Partitionierungsspalte ist
CLUSTERING_ORDINAL_POSITION INT64 Der 1-indexierte Versatz der Spalte in den Clustering-Spalten der Tabelle; der Wert ist NULL, wenn die Tabelle keine geclusterte Tabelle ist
COLLATION_NAME STRING Der Name der Sortierspezifikation, falls vorhanden. Andernfalls NULL

. WennSTRING oder ARRAY<STRING> übergeben wird, wird die Sortierspezifikation zurückgegeben, sofern vorhanden. Andernfalls wird NULL zurückgegeben.
COLUMN_DEFAULT STRING Der Standardwert der Spalte, falls vorhanden. Andernfalls lautet der Wert NULL.
ROUNDING_MODE STRING Der Rundungsmodus, der für Werte verwendet wird, die in das Feld geschrieben werden, wenn der Typ ein parametrisierter NUMERIC oder BIGNUMERIC ist. Andernfalls ist der Wert NULL.

Beispiele

Im folgenden Beispiel werden aus der Ansicht INFORMATION_SCHEMA.COLUMNS Metadaten für die Tabelle population_by_zip_2010 im Dataset census_bureau_usa abgerufen. Dieses Dataset ist Teil des öffentlichen Dataset-Programms von BigQuery.

Da sich die abgefragte Tabelle in einem anderen Projekt (bigquery-public-data) befindet, fügen Sie dem Dataset die Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view; beispielsweise so: `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

Die folgenden Spalten sind nicht in den Abfrageergebnissen enthalten, da sie derzeit für eine zukünftige Verwendung reserviert sind:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE
  SELECT
    * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
  FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
  WHERE
    table_name = 'population_by_zip_2010';

Das Ergebnis sieht etwa so aus. Zur besseren Lesbarkeit werden einige Spalten aus dem Ergebnis ausgeschlossen.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+

Ansicht COLUMN_FIELD_PATHS

Wenn Sie die Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS abfragen, wird im Ergebnis jede Spalte, die in einer Spalte vom Typ RECORD (oder STRUCT) verschachtelt ist, in einer eigenen Zeile dargestellt.

Die Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
COLUMN_NAME STRING Der Name der Spalte
FIELD_PATH STRING Der Pfad zu einer Spalte, die in einer Spalte vom Typ RECORD (oder STRUCT) verschachtelt ist
DATA_TYPE STRING Der GoogleSQL-Datentyp der Spalte
DESCRIPTION STRING Die Beschreibung der Spalte
COLLATION_NAME STRING Der Name der Sortierspezifikation, falls vorhanden. Andernfalls NULL

. Wenn ein STRING-, ARRAY<STRING>- oder STRING-Feld in einer STRUCT übergeben wird, wird die Sortierspezifikation zurückgegeben, sofern vorhanden. Andernfalls wird NULL zurückgegeben.
ROUNDING_MODE STRING Der Rundungsmodus, der beim Anwenden der Genauigkeit und Skalierung auf parametrisierte NUMERIC- oder BIGNUMERIC-Werte genutzt wird. Andernfalls ist der Wert NULL.

Beispiele

Im folgenden Beispiel werden aus der Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS Metadaten für die Tabelle commits im Dataset github_repos abgerufen. Dieses Dataset ist Teil des öffentlichen Dataset-Programms von BigQuery.

Da sich die abgefragte Tabelle in einem anderen Projekt (bigquery-public-data) befindet, fügen Sie dem Dataset die Projekt-ID im Format `project_id`.dataset.INFORMATION_SCHEMA.view hinzu, beispielsweise so: `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

Die Tabelle commits enthält die folgenden verschachtelten sowie verschachtelten und wiederkehrenden Spalten:

  • author: verschachtelte Spalte des Typs RECORD
  • committer: verschachtelte Spalte des Typs RECORD
  • trailer: verschachtelte und wiederkehrende Spalte des Typs RECORD
  • difference: verschachtelte und wiederkehrende Spalte RECORD

Führen Sie die folgende Abfrage aus, um Metadaten zu den Spalten author und difference aufzurufen.

SELECT
  *
FROM
  `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE
  table_name = 'commits'
  AND (column_name = 'author' OR column_name = 'difference');

Das Ergebnis sieht etwa so aus. Zur besseren Lesbarkeit werden einige Spalten aus dem Ergebnis ausgeschlossen.

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+

Ansicht TABLE_STORAGE

Die Ansichten TABLE_STORAGE und TABLE_STORAGE_BY_ORGANIZATION haben das folgende Schema:

Spaltenname Datentyp Wert
PROJECT_ID STRING Die ID des Projekts, das das Dataset enthält
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
PROJECT_NUMBER INT64 Die Nummer des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle oder materialisierte Ansicht enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder materialisierten Ansicht (auch als tableId bezeichnet)
CREATION_TIME TIMESTAMP Der Erstellungszeitpunkt der Tabelle
DELETED BOOLEAN Gibt an, ob die Tabelle gelöscht wird
STORAGE_LAST_MODIFIED_TIME TIMESTAMP Der Zeitpunkt, zu dem Daten in die Tabelle geschrieben wurden.
TOTAL_ROWS INT64 Die Gesamtzahl der Zeilen in der Tabelle oder der materialisierten Ansicht
TOTAL_PARTITIONS INT64 Die Anzahl der vorhandenen Partitionen in der Tabelle oder der materialisierten Ansicht. Nicht partitionierte Tabellen geben 0 zurück.
TOTAL_LOGICAL_BYTES INT64 Gesamtzahl der logischen (unkomprimierten) Byte in der Tabelle oder materialisierten Ansicht
ACTIVE_LOGICAL_BYTES INT64 Anzahl der logischen (unkomprimierten) Byte, die weniger als 90 Tage alt sind
LONG_TERM_LOGICAL_BYTES INT64 Anzahl der logischen (unkomprimierten) Byte, die älter als 90 Tage sind
TOTAL_PHYSICAL_BYTES INT64 Gesamtzahl der physischen (komprimierten) Byte, die für die Speicherung verwendet werden, einschließlich aktiver, langfristiger und zeitübergreifender physischer Byte (gelöschte oder geänderte Daten) Byte
ACTIVE_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die weniger als 90 Tage alt sind, einschließlich zeitübergreifender physischer Byte (gelöschte oder geänderte Daten)
LONG_TERM_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die älter als 90 Tage sind
TIME_TRAVEL_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die vom zeitübergreifenden physischen Speicher verwendet wurden (gelöschte oder geänderte Daten)
FAIL_SAFE_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die vom ausfallsicheren Speicher verwendet werden (gelöschte oder geänderte Daten)
TABLE_TYPE STRING Der Typ der Tabelle. Beispiel: "EXTERNAL" oder "BASE TABLE"

Beispiele

Beispiel 1:

Das folgende Beispiel zeigt die Gesamtzahl der logischen Byte, die für das aktuelle Projekt in Rechnung gestellt werden.

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

Das Ergebnis sieht etwa so aus:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Beispiel 2:

Das folgende Beispiel zeigt, wie Sie die Preisdifferenz pro Dataset zwischen logischen und physischen Abrechnungsmodellen für die nächsten 30 Tage prognostizieren. In diesem Beispiel wird davon ausgegangen, dass die zukünftige Speichernutzung in den nächsten 30 Tagen ab dem Zeitpunkt der Abfrage konstant ist. Beachten Sie, dass die Prognose auf Basistabellen beschränkt ist und alle anderen Tabellentypen innerhalb eines Datasets ausschließt.

Die in den Preisvariablen für diese Abfrage verwendeten Preise gelten für die Region us-central1. Wenn Sie diese Abfrage für eine andere Region ausführen möchten, aktualisieren Sie die Preisvariablen entsprechend. Preisinformationen finden Sie unter Speicherpreise.

  1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

    Zur Seite „BigQuery“

  2. Geben Sie im Feld Abfrageeditor die folgende GoogleSQL-Abfrage ein. Für INFORMATION_SCHEMA muss die GoogleSQL-Syntax verwendet werden. GoogleSQL ist in der Google Cloud Console die Standardsyntax.

    DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;

WITH
 storage_sizes AS (
   SELECT
     table_schema AS dataset_name,
     -- Logical
     SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
     SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
     -- Physical
     SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
     SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
     SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
     -- Restorable previously deleted physical
     SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
     SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
   FROM
     `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
   WHERE total_physical_bytes > 0
     -- Base the forecast on base tables only for highest precision results
     AND table_type  = 'BASE TABLE'
     GROUP BY 1
 )
SELECT
  dataset_name,
  -- Logical
  ROUND(active_logical_gib, 2) AS active_logical_gib,
  ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
  -- Physical
  ROUND(active_physical_gib, 2) AS active_physical_gib,
  ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
  ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
  ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
  -- Compression ratio
  ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
  ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
  -- Forecast costs logical
  ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
  ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
  -- Forecast costs physical
  ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
  ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
  -- Forecast costs total
  ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
     (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
FROM
  storage_sizes
ORDER BY
  (forecast_active_logical_cost + forecast_active_physical_cost) DESC;

  3. Klicken Sie auf Ausführen.

Das Ergebnis sieht etwa so aus:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |

Tabellen in einem Dataset auflisten

So können Sie Tabellen in Datasets auflisten:

  • Google Cloud Console verwenden
  • Mit dem Befehl bq ls des bq-Befehlszeilentools
  • Durch Aufruf der API-Methode tables.list
  • Mithilfe der Clientbibliotheken

Erforderliche Berechtigungen

Zum Auflisten von Tabellen in einem Dataset benötigen Sie mindestens Berechtigungen vom Typ bigquery.tables.list. Die folgenden vordefinierten IAM-Rollen enthalten bigquery.tables.list-Berechtigungen:

  • bigquery.user
  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Zugriffssteuerung.

Tabellen auflisten

So listen Sie die Tabellen in einem Dataset auf:

Console

  1. Klicken Sie in der Google Cloud Console im Navigationsbereich auf das Dataset, um es zu maximieren.- Damit werden die Tabellen und Ansichten im Dataset angezeigt.

  2. Scrollen Sie durch die Liste, um die Tabellen im Dataset aufzurufen. Tabellen und Ansichten sind durch unterschiedliche Symbole gekennzeichnet.

bq

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Führen Sie den Befehl bq ls aus. Mit dem Flag --format kann die Ausgabe gesteuert werden. Wenn Sie Tabellen in einem anderen Projekt als Ihrem Standardprojekt auflisten, fügen Sie dem Dataset die Projekt-ID im folgenden Format hinzu: project_id:dataset.

    Zusätzliche Flags sind:

    • --max_results oder -n: Ganzzahl, die die maximale Anzahl von Ergebnissen angibt. Der Standardwert ist 50.
    bq ls \
--format=pretty \
--max_results integer \
project_id:dataset

    Dabei gilt:

    • integer ist eine Ganzzahl, die die Anzahl der aufzulistenden Tabellen darstellt.
    • project_id ist die Projekt-ID.
    • dataset ist der Name des Datasets.

    Wenn Sie den Befehl ausführen, wird im Feld Type entweder TABLE oder VIEW angezeigt. Beispiel:

    +-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

    Beispiele:

    Geben Sie den folgenden Befehl ein, um Tabellen im Dataset mydataset in Ihrem Standardprojekt aufzulisten: 

       bq ls --format=pretty mydataset

    Mit dem folgenden Befehl können Sie mehr als die Standardausgabe von 50 Tabellen aus mydataset zurückgeben. mydataset befindet sich in Ihrem Standardprojekt. 

       bq ls --format=pretty --max_results 60 mydataset

    Geben Sie den folgenden Befehl ein, um Tabellen im Dataset mydataset in myotherproject aufzulisten. 

       bq ls --format=pretty myotherproject:mydataset

API

Rufen Sie zum Auflisten von Tabellen mithilfe der API die Methode tables.list auf.

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der C#-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Einfach loslegen (Go)

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

Java

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

  public static void listTables(String projectId, String datasetName) {
    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();

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + e.toString());
    }
  }
}

Node.js

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function listTables() {
  // Lists tables in 'my_dataset'.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

PHP

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

Tabellensicherheit

Informationen zum Steuern des Zugriffs auf Tabellen in BigQuery finden Sie unter Einführung in die Tabellenzugriffssteuerung.

Nächste Schritte

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit von BigQuery in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

BigQuery kostenlos testen