Diese Seite wurde von der Cloud Translation API übersetzt.

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:

Richten Sie ein Projekt ein. Folgen Sie dafür einemStartleitfaden für BigQuery.
Erstellen Sie ein BigQuery-Dataset.
Optional: Unter Einführung in Tabellen finden Sie weitere Informationen zu Tabelleneinschränkungen, Kontingenten und Preisen.

Tabellennamen

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

Zeichen mit insgesamt bis zu 1.024 UTF-8-Byte enthalten.
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 enthalten 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.
Geben Sie das Schema beim Aufrufen der API-Methode tables.insert in einer Tabellenressource an.

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

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

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie dann ein Dataset aus.
Klicken Sie im Abschnitt Dataset-Informationen auf Tabelle erstellen.
Geben Sie im Bereich Tabelle erstellen die folgenden Details an:

Wählen Sie im Abschnitt Quelle in der Liste Tabelle erstellen aus die Option Leere Tabelle aus.
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.
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.
Optional: Geben Sie Partitions- und Clustereinstellungen an. Weitere Informationen finden Sie unter Partitionierte Tabellen erstellen und Geclusterte Tabellen erstellen und verwenden.
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 Google-eigenen und von Google verwalteten Schlüssel.
Klicken Sie auf Tabelle erstellen.

SQL

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

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

BigQuery aufrufen

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')]);

Klicken Sie auf Ausführen.

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

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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. Eine vollständige Liste der Parameter finden Sie in der bq mk --table-Referenz. Zu den optionalen Parametern gehören:
- --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:
- Weitere Informationen zu --time_partitioning_field, --time_partitioning_type und --range_partitioning finden Sie unter Partitionierte Tabellen.
- Weitere Informationen zu --clustering_fields finden Sie unter Geclusterte Tabellen.
- Weitere Informationen zu --destination_kms_key finden Sie unter Vom Kunden verwaltete Verschlüsselungsschlüssel.
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 \
--add_tags=key_3:value_3[,...] \
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.
- key_3:value_3 sind Schlüssel/Wert-Paare, die Tags angeben. Fügen Sie mehrere Tags unter demselben Flag hinzu und trennen Sie die Schlüssel/Wert-Paare durch Kommas.
- 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:

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

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

Rufen Sie Cloud Shell auf.
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).

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
```
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.
Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
Speichern Sie die Änderungen.
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

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.
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.
Ö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);
    }
}

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

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

Zur Seite "BigQuery"
Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.
Geben Sie eine gültige SQL-Abfrage ein.
Klicken Sie auf Mehr und wählen Sie dann Abfrageoptionen aus.
Wählen Sie die Option Zieltabelle für Abfrageergebnisse festlegen aus.
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.
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.
Optional: Wählen Sie als Speicherort der Daten Ihren Standort aus.
Klicken Sie auf Speichern, um die Abfrageeinstellungen zu aktualisieren.
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:

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

BigQuery aufrufen

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
);

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

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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'
```
  Ersetzen Sie dabei Folgendes:
- 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:
  
  Hinweis: Diese Beispiele beziehen sich auf die Abfrage eines öffentlichen Datasets in den USA. Da das öffentliche Dataset am multiregionalen Standort "US" gespeichert ist, muss sich das Dataset, das Ihre Zieltabelle enthält, ebenfalls in den USA befinden. Sie können ein Dataset nicht an einem Standort abfragen und die Ergebnisse in eine Zieltabelle an einem anderen Standort schreiben.
  
  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

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

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

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

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 Ansicht INFORMATION_SCHEMA.VIEWS

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

Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.
Klicken Sie auf den Namen des Datasets, um es einzublenden. Die Tabellen und Ansichten im Dataset werden angezeigt.
Klicken Sie auf den Namen der Tabelle.
Klicken Sie im Bereich Details auf Details, um die Beschreibung und die Informationen der Tabelle anzusehen.
Wechseln Sie optional zum Tab Schema, um die Schemadefinition der Tabelle anzusehen.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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

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

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

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

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

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: `BASE TABLE`: Eine Standardtabelle `CLONE`: Ein Tabellenklon `SNAPSHOT`: Ein Tabellen-Snapshot `VIEW`: Eine Ansicht `MATERIALIZED VIEW`: Eine materialisierte Ansicht oder ein Replikat einer materialisierten Ansicht `EXTERNAL`: Eine Tabelle, die auf eine externe Datenquelle verweist
`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`
`is_change_history_enabled`	`STRING`	`YES` oder `NO`, je nachdem, ob der Änderungsverlauf aktiviert ist
`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 Quellmaterialisierte Ansicht 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` ein Replikationsproblem für ein Replikat der materialisierten Ansicht anzeigt, finden Sie unter `replication_error` weitere Informationen 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.

  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`
`description`	`STRING`	Eine Beschreibung der Tabelle
`enable_refresh`	`BOOL`	Gibt an, ob die automatische Aktualisierung für eine materialisierte Ansicht aktiviert ist
`expiration_timestamp`	`TIMESTAMP`	Die Zeit, zu der diese Tabelle abläuft
`friendly_name`	`STRING`	Der beschreibende Name der Tabelle
`kms_key_name`	`STRING`	Der Name des Cloud KMS-Schlüssels zum Verschlüsseln der Tabelle
`labels`	`ARRAY<STRUCT<STRING, STRING>>`	Ein `STRUCT`-Array, das die Labels der Tabelle darstellt
`partition_expiration_days`	`FLOAT64`	Die Standardlebensdauer aller Partitionen in einer partitionierten Tabelle in Tagen
`refresh_interval_minutes`	`FLOAT64`	Gibt an, wie häufig eine materialisierte Ansicht aktualisiert wird
`require_partition_filter`	`BOOL`	Gibt an, ob Abfragen über die Tabelle einen Partitionsfilter erfordern
`tags`	`ARRAY<STRUCT<STRING, STRING>>`	Tags, die einer Tabelle in einer nutzerdefinierten <Schlüssel, Wert>-Syntax angehängt sind. Weitere Informationen finden Sie unter Tags und bedingter Zugriff.

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`.
`column_name_character_map`	`STRING` Bestimmt, welche Zeichen für den Spaltennamen unterstützt werden und wie mit nicht unterstützten Zeichen umgegangen wird. Die Standardeinstellung ist `STRICT`. Das bedeutet, dass BigQuery bei nicht unterstützten Zeichen Fehler anzeigt. `V1` und `V2` ersetzen alle nicht unterstützten Zeichen durch Unterstriche. Unterstützte Werte sind: `STRICT`: Hiermit werden flexible Spaltennamen aktiviert. Dies ist der Standardwert. Ladejobs mit nicht unterstützten Zeichen in Spaltennamen schlagen mit einer Fehlermeldung fehl. Wenn Sie nicht unterstützte Zeichen durch Unterstriche ersetzen möchten, damit der Ladevorgang erfolgreich ist, geben Sie die Konfigurationseinstellung `default_column_name_character_map` an. `V1`. Spaltennamen dürfen nur Standardzeichen für Spaltennamen enthalten. Nicht unterstützte Zeichen werden durch Unterstriche ersetzt. Das ist das Standardverhalten für Tabellen, die vor der Einführung von `column_name_character_map` erstellt wurden. `V2`. Neben Standardzeichen für Spaltennamen werden auch flexible Spaltennamen unterstützt. Nicht unterstützte Zeichen werden durch Unterstriche ersetzt. Gilt für CSV- und Parquet-Daten.
`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` umfassen: `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` (oder`JSON`), `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. 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. Alle referenzierten Datendateien müssen sich im selben Bucket wie die Manifestdatei befinden. 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 Sheets-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.
`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 Sheets-Tabelle, aus der abgefragt werden soll. Gilt für Google Sheets-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 Sheets-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 zur Identifizierung der Bigtable-Tabelle, 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.

  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` . Wenn`STRING` 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 in das Feld geschriebene Werte verwendet wird, wenn sein 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.
`PROJECT_NUMBER`	`INT64`	Die Nummer des Projekts, das das Dataset enthält.
`TABLE_CATALOG`	`STRING`	Die ID 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.
`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 jünger als 90 Tage sind.
`LONG_TERM_LOGICAL_BYTES`	`INT64`	Anzahl der logischen (unkomprimierten) Byte, die älter als 90 Tage sind.
`CURRENT_PHYSICAL_BYTES`	`INT64`	Die Gesamtzahl der physischen Byte für den aktuellen Speicherplatz der Tabelle in allen Partitionen.
`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) Bytes. Ausfallsichere (gelöschte oder geänderte Daten, die nach dem Zeitreisefenster aufbewahrt wurden) Byte sind nicht enthalten.
`ACTIVE_PHYSICAL_BYTES`	`INT64`	Anzahl der physischen (komprimierten) Byte unter 90 Tagen, 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).
`STORAGE_LAST_MODIFIED_TIME`	`TIMESTAMP`	Der Zeitpunkt, zu dem Daten in die Tabelle geschrieben wurden.
`DELETED`	`BOOLEAN`	Gibt an, ob die Tabelle gelöscht wird.
`TABLE_TYPE`	`STRING`	Der Typ der Tabelle. Beispiel: `EXTERNAL` oder `BASE TABLE`.
`FAIL_SAFE_PHYSICAL_BYTES`	`INT64`	Anzahl der physischen (komprimierten) Byte, die vom ausfallsicheren Speicher verwendet werden (gelöschte oder geänderte Daten).
`LAST_METADATA_INDEX_REFRESH_TIME`	`TIMESTAMP`	Die Uhrzeit der letzten Aktualisierung des Metadatenindexes der Tabelle.

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.

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

Zur Seite „BigQuery“

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 + fail_safe_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;

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

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.
Scrollen Sie durch die Liste, um die Tabellen im Dataset aufzurufen. Tabellen und Ansichten sind durch unterschiedliche Symbole gekennzeichnet.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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#

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.");
        }
    }
}

Go

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

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

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

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

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

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

Weitere Informationen zu Datasets finden Sie unter Einführung in Datasets.
Tabellendaten verwalten
Weitere Informationen zur Angabe von Tabellenschemas finden Sie unter Schemas angeben.
Weitere Informationen zum Ändern von Tabellenschemas finden Sie unter Tabellenschemas ändern.
Tabellen verwalten
Übersicht über INFORMATION_SCHEMA unter Einführung in BigQuery INFORMATION_SCHEMA lesen.

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

Tabellen erstellen und verwenden

Hinweis

Tabellennamen

Tabellen erstellen

Erforderliche Berechtigungen

Eine leere Tabelle mit einer Schemadefinition erstellen

Console

SQL

bq

Terraform

Cloud Shell vorbereiten

Verzeichnis vorbereiten

Änderungen anwenden

API

C#

Go

Java

Node.js

PHP

Python

Ruby

Eine leere Tabelle ohne Schemadefinition erstellen

Java

Tabelle aus einem Abfrageergebnis erstellen

Console

SQL

bq

API

Go

Java

Node.js

Python

Auf eine externe Datenquelle verweisende Tabelle erstellen

Tabelle beim Laden von Daten erstellen

Zugriff auf Tabellen steuern

Informationen zu Tabellen abrufen

Erforderliche Berechtigungen

Tabelleninformationen abrufen

Console

bq

API

Go

Java

Node.js

PHP

Python

Mit INFORMATION_SCHEMA Informationen zu Tabellen abrufen

Ansicht TABLES

Beispiele

Beispiel 1:

Beispiel 2:

Beispiel 3:

Ansicht TABLE_OPTIONS

Optionstabelle

Beispiele

Beispiel 1:

Beispiel 2:

Ansicht COLUMNS

Beispiele

Ansicht COLUMN_FIELD_PATHS

Beispiele

Ansicht TABLE_STORAGE

Beispiele

Beispiel 1:

Beispiel 2:

Tabellen in einem Dataset auflisten

Erforderliche Berechtigungen

Tabellen auflisten

Console

bq

API

C#

Go

Java

Node.js

PHP

Python

Ruby

Tabellensicherheit

Nächste Schritte

Mit `INFORMATION_SCHEMA` Informationen zu Tabellen abrufen

Ansicht `TABLES`

Ansicht `TABLE_OPTIONS`

Ansicht `COLUMNS`

Ansicht `COLUMN_FIELD_PATHS`

Ansicht `TABLE_STORAGE`