Tabellen erstellen und verwenden

In diesem Dokument wird beschrieben, wie Sie in BigQuery Standardtabellen bzw. "native" Tabellen erstellen und verwenden. 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.

Tabellenbeschränkungen

BigQuery-Tabellen unterliegen den folgenden Beschränkungen:

  • Tabellennamen dürfen nur einmal pro Datensatz vorkommen.
  • Die GCP Console und die klassische BigQuery-Web-UI unterstützen pro Kopierjob nur eine Tabelle.
  • Beim Kopieren von Tabellen muss sich das Ziel-Dataset am gleichen Speicherort wie die zu kopierende Tabelle befinden. Beispielsweise ist es nicht möglich, eine Tabelle aus einem europäischen Dataset in ein US-amerikanisches Dataset zu kopieren.
  • Wenn Sie mehrere Quelltabellen mit der Befehlszeile, der API oder den Clientbibliotheken in eine Zieltabelle kopieren, müssen alle Quelltabellen identische Schemas haben.
  • Mit der GCP Console, der klassischen BigQuery-Web-UI, dem Befehlszeilentool, der API oder den Clientbibliotheken können Sie jeweils nur eine Tabelle gleichzeitig löschen.
  • Tabellendaten können nur in Cloud Storage exportiert werden.
  • Sobald ein Dataset rund 50.000 oder mehr Tabellen enthält, verlangsamt sich deren Aufzählung. Dies gilt speziell bei API-Aufrufen oder wenn Sie die klassische BigQuery-Web-UI verwenden. Derzeit können in der GCP Console in der BigQuery-Web-UI nur 50.000 Tabellen pro Dataset angezeigt werden.

    Sie können die Leistung der klassischen BigQuery-Web-UI verbessern. Hierfür begrenzen Sie einfach mithilfe des Parameters ?minimal die Anzahl der angezeigten Tabellen pro Projekt auf 30.000. Den Parameter fügen Sie der URL für die klassische BigQuery-Web-UI im folgenden Format hinzu: https://bigquery.cloud.google.com/queries/project_id?minimal

Tabelle erstellen

Sie können auf folgende Arten eine Tabelle in BigQuery erstellen:

  • Manuell mithilfe der GCP Console, der klassischen BigQuery-Web-UI oder des Befehls bq mk des Befehlszeilentools
  • Programmgesteuert 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
  • Mithilfe einer DDL-Anweisung des Typs CREATE TABLE

Tabellennamen

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

  • Bis zu 1.024 Zeichen enthalten
  • Buchstaben (groß-/kleingeschrieben), Ziffern und Unterstriche enthalten

Erforderliche Berechtigungen

Zum Erstellen einer Tabelle müssen Sie mindestens die folgenden Berechtigungen haben:

  • bigquery.tables.create, um die Tabelle zu erstellen
  • bigquery.tables.updateData, um Daten mit einem Ladejob, Abfragejob oder Kopierjob in die Tabelle zu schreiben
  • bigquery.jobs.create um einen Abfragejob, Ladejob oder Kopierjob auszuführen, der Daten in die Tabelle schreibt

Unter Umständen sind weitere Berechtigungen wie bigquery.tables.getData erforderlich, um auf die Daten zuzugreifen, die Sie in die Tabelle schreiben.

Die folgenden vordefinierten Cloud IAM-Rollen enthalten Berechtigungen der Typen bigquery.tables.create und bigquery.tables.updateData:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Die folgenden vordefinierten Cloud IAM-Rollen enthalten Berechtigungen des Typs bigquery.jobs.create:

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, wird ihm dafür außerdem bigquery.dataOwner-Zugriff erteilt. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, im Dataset Tabellen zu erstellen und zu aktualisieren.

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

Leere Tabelle mit einer Schemadefinition erstellen

Wenn Sie eine leere Tabelle mit einer Schemadefinition erstellen, können Sie Folgendes tun:

  • Das Schema über die GCP Console oder die klassische BigQuery-Web-UI eingeben
  • Das Schema inline mit dem Befehlszeilentool angeben
  • Eine JSON-Schemadatei unter Verwendung des Befehlszeilentools einreichen
  • Das Schema beim Aufrufen der API-Methode tables.insert in einer Tabellenressource angeben

Weitere Informationen zum Angeben eines Tabellenschemas finden Sie unter Schema angeben.

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

So erstellen Sie eine leere Tabelle mit einer Schemadefinition:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.
    Zur BigQuery-Web-UI

  2. Maximieren Sie im Navigationsbereich im Abschnitt Resources (Ressourcen) Ihr Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie auf der rechten Seite des Fensters im Detailbereich auf Create table (Tabelle erstellen).

    Tabelle erstellen

  4. Wählen Sie auf der Seite Create table (Tabelle erstellen) im Abschnitt Source (Quelle) die Option Empty table (Leere Tabelle) aus.

  5. Gehen Sie auf der Seite Create table (Tabelle erstellen) im Abschnitt Destination (Ziel) so vor:

    • Wählen Sie für Dataset name (Dataset-Name) das passende Dataset aus.

      Dataset auswählen

    • Geben Sie im Feld Table name (Tabellenname) den Namen der Tabelle ein, die Sie in BigQuery erstellen.

    • Achten Sie darauf, dass Table type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.

  6. Geben Sie im Abschnitt Schema die Schemadefinition ein.

    • So können Sie Schemainformationen manuell eingeben:

      • Klicken Sie auf Edit as text (Als Text bearbeiten) und geben Sie das Tabellenschema als JSON-Array ein.

      • Geben Sie das Schema mit Add field (Feld hinzufügen) manuell ein.

  7. Behalten Sie für Partition and cluster settings (Partitions- und Clustereinstellungen) den Standardwert No partitioning bei.

  8. Übernehmen Sie im Abschnitt Advanced options (Erweiterte Optionen) ebenfalls den Standardwert für Encryption (Verschlüsselung), und zwar Google-managed key. BigQuery verschlüsselt standardmäßig inaktive Kundendaten.

  9. Klicken Sie auf Create table (Tabelle erstellen).

DDL

DDL-Anweisungen (Data Definition Language) ermöglichen das Erstellen und Ändern von Tabellen und Ansichten mithilfe der Standard-SQL-Abfragesyntax.

Weitere Informationen finden Sie unter DDL-Anweisungen verwenden.

So erstellen Sie in der GCP Console mithilfe einer DDL-Anweisung eine Tabelle:

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.
    Zur GCP Console

  2. Klicken Sie auf Compose new query (Neue Abfrage erstellen).

  3. Geben Sie die DDL-Anweisung CREATE TABLE in den Textbereich des Abfrageeditors ein.

    Die folgende Abfrage erstellt eine Tabelle mit dem Namen newtable, die am 1. Januar 2020 abläuft. Die Tabellenbeschreibung lautet "a table that expires in 2020" (Eine Tabelle, die 2020 abläuft), und das Label der Tabelle ist org_unit:development.

     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 "2020-01-01 00:00:00 UTC",
       description="a table that expires in 2020",
       labels=[("org_unit", "development")]
     )

  4. (Optional) Klicken Sie auf More (Mehr) und wählen Sie Query settings (Abfrageeinstellungen) aus. Abfrageeinstellungen

  5. (Optional) Klicken Sie unter Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus. Wenn Sie keinen Verarbeitungsort angeben, d. h. "Unspecified" festlegen, wird der Verarbeitungsort automatisch erkannt. Verarbeitungsort der Abfrage

  6. Klicken Sie auf Run (Ausführen). Wenn die Abfrage abgeschlossen ist, wird die Tabelle im Bereich Resources (Ressourcen) angezeigt.

Klassische UI

  1. Klicken Sie im Navigationsbereich neben dem Dataset-Namen auf den Abwärtspfeil Abwärtspfeilsymbol und anschließend auf Create new table (Neue Tabelle erstellen).

  2. Klicken Sie auf der Seite Create Table (Tabelle erstellen) im Abschnitt Source Data (Quelldaten) auf Create empty table (Leere Tabelle erstellen).

  3. Gehen Sie auf der Seite Create Table (Tabelle erstellen) im Abschnitt Destination Table (Zieltabelle) so vor:

    • Wählen Sie unter Table name (Tabellenname) das entsprechende Dataset aus und geben Sie im Namensfeld den Namen der Tabelle ein, die Sie erstellen.
    • Achten Sie darauf, dass Table type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.
  4. Nehmen Sie im Abschnitt Schema eine manuelle Eingabe der Schemadefinition vor.

    • So können Sie Schemainformationen manuell eingeben:

      • Klicken Sie dazu auf Edit as text (Als Text bearbeiten) und geben Sie das Tabellenschema als JSON-Array ein:

        Schema als JSON-Array hinzufügen

      • Geben Sie das Schema mit Add Field (Feld hinzufügen) ein.

        Schema durch Hinzufügen von Feldern hinzufügen

  5. Übernehmen Sie im Abschnitt Options (Optionen) die Standardwerte.

    • Partitioning Type (Partitionierungstyp): None
    • Partitioning Field (Partitionierungsfeld): – (sollte nicht verfügbar sein)
    • Require partition filter (Partitionsfilter erforderlich): – (sollte nicht verfügbar sein)
    • Clustering Fields (Clustering-Felder): – (sollte nicht verfügbar sein)
    • Destination Encryption (Zielverschlüsselung): Default, standardmäßig verschlüsselt BigQuery inaktive Kundendaten mit einem von Google verwalteten Schlüssel.
  6. Klicken Sie auf Create Table (Tabelle erstellen).

Befehlszeile

Verwenden Sie den Befehl mk mit dem Flag --table oder -t. Sie können Informationen zum Tabellenschema inline oder über eine JSON-Datei angeben. Optionale Parameter umfassen:

  • --expiration
  • --description
  • --time_partitioning_type
  • --destination_kms_key
  • --label

Die Parameter --time_partitioning_type und --destination_kms_key werden hier nicht behandelt. Weitere Informationen zu --time_partitioning_type finden Sie unter Nach Aufnahmezeit partitionierte Tabellen erstellen und verwenden oder Partitionierte Tabellen erstellen und verwenden. Weitere Informationen zu --destination_kms_key finden Sie unter Daten mit Cloud KMS-Schlüsseln schützen.

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:value, key:value \
project_id:dataset.table \
schema

Dabei gilt:

  • integer ist die Standardlebensdauer der Tabelle in Sekunden. 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:value ist das Schlüssel/Wert-Paar für ein Label. Mit einer durch Kommas getrennten Liste können Sie mehrere Labels eingeben.
  • project_id ist Ihre 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 zu einer JSON-Schemadatei auf Ihrem lokalen Computer.

Wenn Sie das Schema in der Befehlszeile angeben, können Sie den Typ RECORD (STRUCT) nicht einfügen. Außerdem ist es dann nicht möglich, die Spaltenbeschreibung einzufügen oder den Modus der Spalte anzugeben. Alle Modi sind standardmäßig auf 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. Mit diesem Befehl 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. Mit diesem Befehl wird in myotherproject 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 \
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.

API

Die Methode tables.insert rufen Sie mit einer definierten Tabellenressource auf.

C#

Lesen Sie die Anleitung zur Einrichtung von C# in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.


using Google.Cloud.BigQuery.V2;
using System;

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

Folgen Sie der Anleitung zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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
}

Java

Folgen Sie der Anleitung zur Einrichtung von Java in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field field = Field.of(fieldName, LegacySQLTypeName.STRING);
// Table schema definition
Schema schema = Schema.of(field);
TableDefinition tableDefinition = StandardTableDefinition.of(schema);
TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();
Table table = bigquery.create(tableInfo);

Node.js

Lesen Sie die Anleitung zur Einrichtung von Node.js in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// 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 verwenden, sollten Sie die Anleitung zur Einrichtung von PHP in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken lesen. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery PHP API.

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

Folgen Sie der Anleitung zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

from google.cloud import bigquery

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

# TODO(developer): 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"

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

Ruby

Lesen Sie die Anleitung zum Einrichten von Ruby in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

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

Tabelle aus einem Abfrageergebnis erstellen

Sie können eine Tabelle aus einem Abfrageergebnis erstellen, indem Sie die Ergebnisse in eine Zieltabelle schreiben.

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Maximieren Sie im Navigationsbereich im Abschnitt Resources (Ressourcen) Ihr Projekt und wählen Sie ein Dataset aus.

  3. Wenn der Abfrageeditor ausgeblendet ist, klicken Sie oben rechts im Fenster auf Show editor (Editor einblenden).

  4. Geben Sie im Textbereich des Query editor (Abfrageeditor) eine gültige SQL-Abfrage ein.

  5. Klicken Sie unter dem Editor auf More (Mehr) und wählen Sie dann Query settings (Abfrageeinstellungen) aus.

    Abfrageeinstellungen

  6. Klicken Sie auf das Kästchen Set a destination table for query results (Zieltabelle für Abfrageergebnisse festlegen).

    Ziel festlegen

  7. Wählen Sie im Abschnitt Destination (Ziel) den entsprechenden Projektnamen unter Project name (Projektname) bzw. den Namen des Datasets, in dem die Tabelle erstellt werden soll, unter Dataset name (Dataset-Name) aus. Wählen Sie dann einen Tabellennamen unter Table name (Tabellenname) aus.

  8. 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.
  9. Optional: Klicken Sie unter Processing location (Verarbeitungsstandort) auf Auto-select (Automatische Auswahl) und wählen Sie den Standort Ihrer Daten aus.

  10. Klicken Sie auf Run query (Abfrage 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 unterhalb des Editors auf die Schaltfläche Save Results (Ergebnisse speichern).

DDL

DDL-Anweisungen (Data Definition Language) ermöglichen Ihnen, Tabellen mit der Standard-SQL-Abfragesyntax zu erstellen und zu ändern.

Weitere Informationen finden Sie auf der Seite zur CREATE TABLE-Anweisung und im Beispiel zu CREATE TABLE: Neue Tabelle aus einer vorhandenen Tabelle erstellen.

Klassische UI

  1. Rufen Sie die klassische BigQuery-Web-UI auf.
    Zur klassischen BigQuery-Web-UI

  2. Klicken Sie auf Compose query (Abfrage erstellen).

  3. Geben Sie in den Textbereich New Query (Neue Abfrage) eine gültige SQL-Abfrage ein.

  4. Klicken Sie auf Show Options (Optionen anzeigen).

  5. Klicken Sie im Abschnitt Destination Table (Zieltabelle) auf Select Table (Tabelle auswählen).

  6. Gehen Sie im Dialogfeld Select Destination Table (Zieltabelle auswählen) so vor:

    1. Unter Project (Projekt) wählen Sie das Projekt aus, in dem das Dataset und die Tabelle gespeichert werden sollen.

    2. Wählen Sie unter Dataset das Dataset aus, in dem die Tabelle gespeichert werden soll.

    3. Geben Sie im Feld Table ID (Tabellen-ID) einen Tabellennamen ein. Der Name darf im Ziel-Dataset nur einmal vorkommen. Der Tabellenname kann bis zu 1.024 Zeichen umfassen und darf nur a-z, A-Z, 0-9 oder _ (Unterstrich) enthalten.

    4. Klicken Sie auf OK.

  7. Wählen Sie im Abschnitt Destination Table (Zieltabelle) unter Write Preference (Schreibeinstellung) eine der folgenden Optionen aus:

    • Write if empty (Schreiben, wenn leer): Die Abfrageergebnisse werden nur in die Tabelle geschrieben, wenn sie leer ist.
    • Append to table (An Tabelle anfügen): Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
    • Overwrite table (Tabelle überschreiben): Eine vorhandene Tabelle mit demselben Namen wird mit den Abfrageergebnissen überschrieben.
  8. Optional: Klicken Sie bei Processing Location (Verarbeitungsstandort) auf Unspecified (Nicht angegeben) und wählen Sie den Standort Ihrer Daten aus.

  9. Klicken Sie auf Run query (Abfrage 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 temporäre Tabelle auch in eine permanente Tabelle kopieren. Klicken Sie hierfür im Ergebnisfenster auf die Schaltfläche Save as Table (Als Tabelle speichern).

Befehlszeile

Geben Sie den Befehl bq query und das Flag --destination_table ein, um anhand der Abfrageergebnisse eine permanente Tabelle zu erstellen. Mit dem Flag use_legacy_sql=false legen Sie die Standard-SQL-Abfragesyntax 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: Sie können das Flag --location angeben und als Wert Ihren Standort festlegen.

Mit einem der folgenden optionalen Flags steuern Sie die Schreibanordnung für eine vorhandene Zieltabelle:

  • --append_table: Wenn die Zieltabelle vorhanden ist, werden die Abfrageergebnisse an diese angefügt.
  • --replace: Wenn die Zieltabelle vorhanden ist, wird sie mit den Abfrageergebnissen überschrieben.
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

Dabei gilt:

  • location ist der Name des Standorts, an dem die Abfrage verarbeitet wurde. Das Flag --location ist optional. Wenn Sie BigQuery beispielsweise in der Region Tokio verwenden, legen Sie für das Flag den Wert asia-northeast1 fest. Mit der Datei ".bigqueryrc" können Sie für den Standort einen Standardwert festlegen.
  • project_id ist Ihre Projekt-ID.
  • dataset ist der Name des Datasets, das die Tabelle enthält, in die Sie die Abfrageergebnisse schreiben.
  • table ist der Name der Tabelle, in die Sie die Abfrageergebnisse schreiben.
  • query ist eine Abfrage in der Standard-SQL-Syntax.

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

Beispiele:

Mit dem folgenden Befehl schreiben Sie Abfrageergebnisse in eine Tabelle 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 Tabelle 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 Tabelle mit dem Namen mytable in mydataset an. Das Dataset befindet sich in my-other-project, nicht in Ihrem Standardprojekt. In dem Befehl wird das Flag --append verwendet, um die Abfrageergebnisse an die Zieltabelle anzufügen.

bq query \
--append \
--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 die 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.

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

Go

Folgen Sie der Anleitung zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")

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)
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.Println(row)
}

Java

Folgen Sie der Anleitung zur Einrichtung von Java in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

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.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
// String destinationDataset = 'my_destination_dataset';
// String destinationTable = 'my_destination_table';
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    // Note that setUseLegacySql is set to false by default
    QueryJobConfiguration.newBuilder(query)
        // Save the results of the query to a permanent table.
        .setDestinationTable(TableId.of(destinationDataset, destinationTable))
        .build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Python

Folgen Sie der Anleitung zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

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
# client = bigquery.Client()
# dataset_id = 'your_dataset_id'

job_config = bigquery.QueryJobConfig()
# Set the destination table
table_ref = client.dataset(dataset_id).table('your_table_id')
job_config.destination = table_ref
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,
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config)  # API request - starts the query

query_job.result()  # Waits for the query to finish
print('Query results loaded to table {}'.format(table_ref.path))

Auf eine externe Datenquelle verweisende Tabelle erstellen

Eine externe Datenquelle, auch Verbunddatenquelle genannt, ist eine Datenquelle, für die auch dann direkt eine Abfrage ausgeführt werden kann, wenn die Daten nicht in BigQuery gespeichert sind. Statt die Daten zu laden oder zu streamen, erstellen Sie eine Tabelle, die auf die externe Datenquelle verweist.

BigQuery ermöglicht es, Abfragen direkt für Daten aus den folgenden Quellen auszuführen:

Sie können Daten in einer unterstützten externen Datenquelle abfragen, indem Sie eine temporäre oder permanente Tabelle erstellen, die auf in der externen Datenquelle gespeicherte Daten verweist. Weitere Informationen zum Arbeiten mit externen Datenquellen finden Sie unter:

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. Ebenfalls können Sie eine Tabelle oder Partition überschreiben. Die leere Tabelle muss nicht zuerst erstellt werden, bevor Sie Daten laden können. 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

Zugriffssteuerungen können nicht direkt Tabellen oder Ansichten zugewiesen werden. Die niedrigste Ebene der BigQuery-Ressourcen, auf die Sie Zugriff gewähren können, ist die Dataset-Ebene. Zum Konfigurieren von Zugriff auf Tabellen und Ansichten weisen Sie einer Entität auf Dataset-Ebene oder höher eine Cloud IAM-Rolle zu.

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

Sie können Cloud IAM-Rollen auch auf einer höheren Ebene in der Ressourcenhierarchie der Google Cloud Platform zuweisen, z. B. auf Projekt-, Ordner- oder Organisationsebene. Durch die Zuweisung von Rollen auf einer höheren Ebene erhält die Entität Zugriff auf eine größere Gruppe 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. Weitere Informationen zum Gewähren von Zugriff auf Ressourcen finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen in der Cloud IAM-Dokumentation.

Sie können auch benutzerdefinierte Cloud 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 kann.

Weitere Informationen zu Rollen und Berechtigungen finden Sie unter:

Tabellen verwenden

Informationen zu Tabellen abrufen

So erhalten Sie Informationen oder Metadaten zu Tabellen:

  • Mit der GCP Console oder der klassischen Web-UI von BigQuery
  • Mit dem Befehl bq show über die Befehlszeile
  • Durch Aufrufen der API-Methode tables.get
  • Mit den Clientbibliotheken
  • Durch Abfragen der INFORMATION_SCHEMA-Ansichten (Beta)

Erforderliche Berechtigungen

Zum Abrufen von Informationen zu Tabellen benötigen Sie mindestens Berechtigungen vom Typ bigquery.tables.get. Die folgenden vordefinierten Cloud IAM-Rollen enthalten Berechtigungen vom Typ bigquery.tables.get:

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

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

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

Tabelleninformationen abrufen

So rufen Sie Informationen zu Tabellen ab:

Console

  1. Maximieren Sie im Navigationsbereich im Abschnitt Resources (Ressourcen) Ihr Projekt und wählen Sie ein Dataset aus. Klicken Sie auf den Namen des Datasets, um es einzublenden. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

  2. Klicken Sie auf den Tabellennamen.

  3. Klicken Sie unter dem Editor auf Details. Auf dieser Seite sind die Tabellenbeschreibung und die Informationen zur Tabelle enthalten.

  4. Klicken Sie auf den Tab Schema, um die Schemadefinition der Tabelle anzuzeigen.

Klassische UI

  1. Klicken Sie im Navigationsbereich auf den Abwärtspfeil Abwärtspfeilsymbol links neben dem Dataset, um es einzublenden, oder doppelklicken Sie auf den Dataset-Namen. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

  2. Klicken Sie auf den Tabellennamen.

  3. Klicken Sie auf Details. Auf der Seite Tabellendetails werden die Beschreibung und die Informationen der Tabelle angezeigt.

    Tabellendetails anzeigen

  4. Klicken Sie auf den Tab Schema, um die Schemadefinition der Tabelle anzuzeigen.

Befehlszeile

Führen Sie den Befehl bq show aus, um alle Tabelleninformationen anzuzeigen. 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 folgenden Format hinzu: project_id:dataset.

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

Dabei gilt:

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

Beispiele:

Geben Sie den folgenden Befehl ein, sodass alle Informationen über mytable in mydataset angezeigt werden. mydataset befindet sich in Ihrem Standardprojekt.

bq show --format=prettyjson mydataset.mytable

Geben Sie den folgenden Befehl ein, sodass alle Informationen über mytable in mydataset angezeigt werden. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

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

Geben Sie den folgenden Befehl ein, sodass nur Schemainformationen über mytable in mydataset angezeigt werden. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

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

API

Rufen Sie die Methode tables.get auf und geben Sie alle relevanten Parameter an.

Go

Folgen Sie der Anleitung zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

Java

Folgen Sie der Anleitung zur Einrichtung von Java in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

TableId tableId = TableId.of(projectId, datasetName, tableName);
Table table = bigquery.getTable(tableId);

PHP

Bevor Sie dieses Beispiel verwenden, sollten Sie die Anleitung zur Einrichtung von PHP in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken lesen. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery PHP API.

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

Folgen Sie der Anleitung zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

from google.cloud import bigquery

# TODO(developer): 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)

print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)

# View table properties
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Mit INFORMATION_SCHEMA (Beta) Informationen zu Tabellen abrufen

INFORMATION_SCHEMA steht für eine Reihe von Ansichten, die einen Zugriff auf Metadaten von Datasets, Tabellen und Ansichten ermöglichen.

Sie können durch Abfrage der Ansichten INFORMATION_SCHEMA.TABLES und INFORMATION_SCHEMA.TABLE_OPTIONS Metadaten von Tabellen und Ansichten eines Projekts abrufen. Außerdem haben Sie die Möglichkeit, die Ansichten INFORMATION_SCHEMA.COLUMNS und INFORMATION_SCHEMA.COLUMN_FIELD_PATHS für den Abruf von Metadaten zu den Spalten (Feldern) einer Tabelle abzufragen.

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.

Für Abfragen der Ansicht INFORMATION_SCHEMA.TABLES muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, benötigt Zugriff auf das Dataset, zu dem Tabellen oder Ansichten gehören.

Die Ansicht INFORMATION_SCHEMA.TABLES weist das folgende Schema auf:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Der Name des Projekts, zu dem das Dataset gehört
TABLE_SCHEMA STRING Der Name des Datasets, zu dem die Tabelle oder Ansicht gehört (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
TABLE_TYPE STRING Der Tabellentyp:
IS_INSERTABLE_INTO STRING YES oder NO, je nachdem, ob die Tabelle DML INSERT-Anweisungen unterstützt
IS_TYPED STRING Der Wert ist immer NO
CREATION_TIME TIMESTAMP Der Erstellungszeitpunkt der Tabelle

Weitere Informationen zu Dataset-Attributen finden Sie auf der Seite Dataset-Ressourcen in der REST API-Dokumentation. Weitere Informationen zu Attributen von Tabellen und Ansichten finden Sie auf der Seite Tabellenressourcen in der REST API-Dokumentation.

Beispiele

Beispiel 1:

Im folgenden Beispiel werden alle Spalten der Ansicht INFORMATION_SCHEMA.TABLES abgerufen, mit Ausnahme von is_typed. Diese Spalte ist für eine zukünftige Verwendung reserviert. Die zurückgegebenen Metadaten beziehen sich auf alle Tabellen in mydataset in Ihrem Standardprojekt myproject.

mydataset enthält folgende Tabellen:

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

Für Abfragen der Ansicht INFORMATION_SCHEMA.TABLES muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset mit den Tabellen haben.

Zum Ausführen der Abfrage für ein anderes Projekt als das Standardprojekt fügen Sie dem Dataset die jeweilige Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view. Beispiel: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES'

Die Ergebnisse sollten so aussehen:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 |
  | myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

Beispiel 2:

Im folgenden Beispiel werden alle Tabellen des Typs BASE TABLE aus der Ansicht INFORMATION_SCHEMA.TABLES abgerufen. Die Spalte is_typed ist ausgeschlossen. Die zurückgegebenen Metadaten beziehen sich auf Tabellen in mydataset in Ihrem Standardprojekt myproject.

Für Abfragen der Ansicht INFORMATION_SCHEMA.TABLES muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset mit den Tabellen haben.

Zum Ausführen der Abfrage für ein anderes Projekt als das Standardprojekt fügen Sie dem Dataset die jeweilige Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view. Beispiel: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    SELECT
     * EXCEPT(is_typed)
    FROM
     mydataset.INFORMATION_SCHEMA.TABLES
    WHERE
     table_type="BASE TABLE"
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'SELECT
   * EXCEPT(is_typed)
 FROM
   mydataset.INFORMATION_SCHEMA.TABLES
 WHERE
   table_type="BASE TABLE"'

Die Ergebnisse sollten so aussehen:

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | NO                 | 2018-10-31 22:40:05 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

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 dargestellt.

Für Abfragen der Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, benötigt Zugriff auf das Dataset, zu dem Tabellen oder Ansichten gehören.

Die Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS weist das folgende Schema auf:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Der Name des Projekts, zu dem das Dataset gehört
TABLE_SCHEMA STRING Der Name des Datasets, zu dem die Tabelle oder Ansicht gehört (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
OPTION_NAME STRING Ein Namenswert der Optionstabelle
OPTION_TYPE STRING Ein Datentypwert der Optionstabelle
OPTION_VALUE STRING Eine Wertoption der Optionstabelle
Optionstabelle
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 Die Standardlebensdauer aller Partitionen in einer partitionierten Tabelle in Tagen
expiration_timestamp FLOAT64 Die Standardlebensdauer der Tabelle in Tagen
kms_key_name STRING Der Name des Cloud KMS-Schlüssels zum Verschlüsseln der Tabelle
friendly_name STRING Der beschreibende Name der Tabelle
description STRING Eine Beschreibung der Tabelle
labels ARRAY<STRUCT<STRING, STRING>> Ein STRUCT-Array, das die Labels der Tabelle darstellt

Weitere Informationen zu Dataset-Attributen finden Sie auf der Seite Dataset-Ressourcen in der REST API-Dokumentation. Weitere Informationen zu Attributen von Tabellen und Ansichten finden Sie auf der Seite Tabellenressourcen in der REST API-Dokumentation.

Beispiele

Beispiel 1:

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

Für Abfragen der Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset mit den Tabellen haben.

Zum Ausführen der Abfrage für ein anderes Projekt als das Standardprojekt fügen Sie dem Dataset die jeweilige Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view. Beispiel: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="expiration_timestamp"
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="expiration_timestamp"'

Die Ergebnisse sollten so aussehen:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | 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 im Standardprojekt myproject.

Zum Ausführen der Abfrage für ein anderes Projekt als das Standardprojekt fügen Sie dem Dataset die jeweilige Projekt-ID im folgenden Format hinzu: `project_id`.dataset.INFORMATION_SCHEMA.view. Beispiel: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    SELECT
     *
    FROM
     mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
    WHERE
     option_name="description" AND option_value LIKE "%test%"
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'SELECT
   *
 FROM
   mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
 WHERE
   option_name="description" AND option_value LIKE "%test%"'

Die Ergebnisse sollten so aussehen:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | 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.

Für Abfragen der Ansicht INFORMATION_SCHEMA.COLUMNS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset mit den Tabellen haben.

Die Ansicht INFORMATION_SCHEMA.COLUMNS weist das folgende Schema auf:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Der Name des Projekts, zu dem das Dataset gehört
TABLE_SCHEMA STRING Der Name des Datasets, zu dem die Tabelle gehört (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 Standard-SQL-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 STRING Der 1-indexierte Versatz der Spalte in den Clustering-Spalten der Tabelle; der Wert ist NULL, wenn die Tabelle keine geclusterte Tabelle ist

Weitere Informationen zu Dataset-Attributen finden Sie auf der Seite Dataset-Ressourcen in der REST API-Dokumentation. Weitere Informationen zu Attributen von Tabellen und Ansichten finden Sie auf der Seite Tabellenressourcen in der REST API-Dokumentation.

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. Beispiel: `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

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

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

Für Abfragen der Ansicht INFORMATION_SCHEMA.COLUMNS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset mit den Tabellen haben.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    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"
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'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 sollte wie unten dargestellt aussehen. Zur besseren Lesbarkeit wurden die Spalten table_catalog und table_schema weggelassen.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       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.

Für Abfragen der Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset haben, das die Tabellen enthält.

Die Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS weist das folgende Schema auf:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Der Name des Projekts, zu dem das Dataset gehört
TABLE_SCHEMA STRING Der Name des Datasets, zu dem die Tabelle gehört (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 Standard-SQL-Datentyp der Spalte
DESCRIPTION STRING Die Beschreibung der Spalte

Weitere Informationen zu Dataset-Attributen finden Sie auf der Seite Dataset-Ressourcen in der REST API-Dokumentation. Weitere Informationen zu Attributen von Tabellen und Ansichten finden Sie auf der Seite Tabellenressourcen in der REST API-Dokumentation.

Beispiele

Im folgenden Beispiel werden aus der Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS Metadaten für die Tabelle commits im github_repos-Dataset 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. Beispiel: `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

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

  • author: Verschachtelte Spalte RECORD
  • committer: Verschachtelte Spalte RECORD
  • trailer: Verschachtelte und wiederholte Spalte RECORD
  • difference: Verschachtelte und wiederholte Spalte RECORD

Mit der Abfrage werden Metadaten zu den Spalten author und difference abgerufen.

Für Abfragen der Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS muss ein Dataset-Qualifizierer verwendet werden. Der Nutzer, der die Abfrage sendet, muss Zugriff auf das Dataset haben, das die Tabellen enthält.

So führen Sie die Abfrage aus:

Console

  1. Rufen Sie in der GCP Console die BigQuery-Web-UI auf.

    Zur GCP Console

  2. Geben Sie im Feld Query editor (Abfrageeditor) die folgende Standard-SQL-Abfrage ein. Für die Ansicht INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der GCP Console ist Standard-SQL die Standardsyntax.

    SELECT
     *
    FROM
     `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
    WHERE
     table_name="commits"
     AND column_name="author"
     OR column_name="difference"
    
  3. Klicken Sie auf Run (Ausführen).

Befehlszeile

Verwenden Sie den Befehl query und die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false. Für Abfragen von INFORMATION_SCHEMA ist die Standard-SQL-Syntax erforderlich.

So führen Sie die Abfrage aus:

bq query --nouse_legacy_sql \
'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 sollte wie unten dargestellt aussehen. Zur besseren Lesbarkeit wurden die Spalten table_catalog und table_schema weggelassen.

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

Tabellen in einem Dataset auflisten

Tabellen in Datasets können Sie auf folgende Weise auflisten:

  • Mit der GCP Console oder der klassischen Web-UI von BigQuery
  • Mit dem Befehl bq ls über die Befehlszeile
  • Durch Aufrufen der API-Methode tables.list
  • Mit den Clientbibliotheken

Erforderliche Berechtigungen

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

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

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

Tabellen auflisten

So listen Sie die Tabellen in einem Dataset auf:

Console

  1. Klicken Sie in der GCP Console im Navigationsbereich auf das Dataset, um es zu maximieren. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

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

Klassische UI

  1. Klicken Sie in der Web-UI im Navigationsbereich auf den Abwärtspfeil Abwärtspfeilsymbol links neben dem Dataset, um es einzublenden, oder klicken Sie doppelt auf den Dataset-Namen. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

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

    Tabellen anzeigen

Befehlszeile

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: Eine 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 Ihre 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 die 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#

Lesen Sie die Anleitung zur Einrichtung von C# in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.


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

Folgen Sie der Anleitung zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

Java

Folgen Sie der Anleitung zur Einrichtung von Java in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

DatasetId datasetId = DatasetId.of(projectId, datasetName);
Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
for (Table table : tables.iterateAll()) {
  // do something with the table
}

Node.js

Lesen Sie die Anleitung zur Einrichtung von Node.js in der BigQuery-Schnellstart-Anleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

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

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

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

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

PHP

Bevor Sie dieses Beispiel verwenden, sollten Sie die Anleitung zur Einrichtung von PHP in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken lesen. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery PHP API.

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

Folgen Sie der Anleitung zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

from google.cloud import bigquery

# TODO(developer): 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)

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

Ruby

Lesen Sie die Anleitung zum Einrichten von Ruby in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

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

Weitere Informationen

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...