Tabellen erstellen und verwenden

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

Nach dem Erstellen einer Tabelle können Sie:

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

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

Hinweis

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

Tabellennamen

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

  • bis zu 1.024 Zeichen 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 sind table-01, ग्राहक, 00_お客様, étudiant.

Tabelle erstellen

So können Sie eine Tabelle in BigQuery erstellen:

  • Manuell mit der 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
  • Mithilfe einer DDL-Anweisung des Typs CREATE TABLE

Erforderliche Berechtigungen

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

  • bigquery.tables.create-Berechtigungen, 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

Möglicherweise sind zusätzliche Berechtigungen wie bigquery.tables.getData erforderlich, um auf die Daten zuzugreifen, die Sie in die Tabelle schreiben.

Die folgenden vordefinierten IAM-Rollen enthalten die Berechtigungen bigquery.tables.create und bigquery.tables.updateData:

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

Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ bigquery.jobs.create:

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

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

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

Leere Tabelle mit einer Schemadefinition erstellen

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

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

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

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

So erstellen Sie eine leere Tabelle mit einer Schemadefinition:

Console

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

    Zur Seite "BigQuery"

  2. Maximieren Sie im Navigationsbereich im Abschnitt 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 das entsprechende 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 der Tabellentyp auf 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 Partitions- und Clustereinstellungen den Standardwert No partitioning bei.

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

  9. Klicken Sie auf Tabelle erstellen.

SQL

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 Cloud Console mithilfe einer DDL-Anweisung eine Tabelle:

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

    Zur Seite "BigQuery"

  2. Klicken Sie auf 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 2023 abläuft. Die Tabellenbeschreibung lautet "a table that expires in 2023" ("eine Tabelle, die 2023 abläuft") und das Label der Tabelle lautet 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 "2023-01-01 00:00:00 UTC",
       description="a table that expires in 2023",
       labels=[("org_unit", "development")]
     )

  4. Optional: Klicken Sie auf Mehr und wählen Sie 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. Verarbeitungsstandort der Abfrage

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

bq

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

  • --expiration
  • --description
  • --time_partitioning_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 oder Partitionierte 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:value, key:value \
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: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 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.

API

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

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von C# in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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

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

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: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

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: Clientbibliotheken verwenden. Weitere Informationen 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 anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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

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

from google.cloud import bigquery

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

# 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: Clientbibliotheken verwenden. Weitere Informationen 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

Eine leere Tabelle ohne Schemadefinition erstellen

Java

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

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

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

Console

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

    Zur Seite "BigQuery"

  2. Maximieren Sie im Navigationsbereich im Abschnitt 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 Abfrageeditors eine gültige SQL-Abfrage ein.

  5. Klicken Sie unter dem Editor auf Mehr und wählen Sie dann Abfrageeinstellungen aus.

    Abfrageeinstellungen

  6. Klicken Sie auf das Kästchen 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).

SQL

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.

bq

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 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: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

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 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 eine Abfrage in der Standard-SQL-Syntax ist.

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

Beispiele:

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

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

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

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

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

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

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

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

API

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

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

Go

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

import (
	"context"
	"fmt"
	"io"

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

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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.

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

public class SaveQueryToTable {

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

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

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

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

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

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

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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 queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

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

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

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

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

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

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. 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

# 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, 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 dazu eine Tabelle, die auf die externe Datenquelle verweist.

BigQuery ermöglicht die direkte Abfrage von Daten aus den folgenden Datenquellen:

Unterstützte Formate sind:

  • Avro
  • CSV
  • JSON (nur durch Zeilenumbruch getrennt)
  • ORC
  • Parquet

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. 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. Wenn es sich um unterstützte Datenformate handelt, können Sie auch die automatische Schemaerkennung verwenden.

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

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 unter:

Tabellen verwenden

Informationen zu Tabellen abrufen

So erhalten Sie Informationen oder Metadaten zu Tabellen:

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

Erforderliche Berechtigungen

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

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

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

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

Tabelleninformationen abrufen

So rufen Sie Informationen zu Tabellen ab:

Console

  1. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus. 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.

bq

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

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

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

Dabei gilt:

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

Beispiele:

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

bq show --format=prettyjson mydataset.mytable

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

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

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

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

API

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

Go

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

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

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

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

public class GetTable {

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

  public static void getTable(String projectId, String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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 getTable() {
  // Retrieves table named "my_table" in "my_dataset".

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

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

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

PHP

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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

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


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 (Beta) Informationen zu Tabellen abrufen

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

Durch Abfrage der Ansichten INFORMATION_SCHEMA.TABLES und INFORMATION_SCHEMA.TABLE_OPTIONS können Sie 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.

Die Ansicht INFORMATION_SCHEMA.TABLES hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Der Name des Projekts, zu dem das Dataset gehört
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)
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

Beispiele

Beispiel 1:

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

mydataset enthält folgende Tabellen:

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

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

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

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

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

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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.

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

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

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

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

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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.

Die Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS hat das folgende Schema:

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

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.

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.

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

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

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

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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 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.

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

  2. Geben Sie im Feld Abfrageeditor die folgende Standard-SQL-Abfrage ein. Für INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der Cloud 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 Ausführen.

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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.

Die Ansicht INFORMATION_SCHEMA.COLUMNS hat das folgende Schema:

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

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 für eine zukünftige Verwendung reserviert sind:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

  2. Geben Sie im Feld Abfrageeditor die folgende Standard-SQL-Abfrage ein. Für INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der Cloud 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 Ausführen.

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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 werden table_catalog und table_schema aus den Ergebnissen 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 des Typs 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 Der Name des Projekts, zu dem das Dataset gehört
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 des Typs RECORD oder STRUCT verschachtelt ist
DATA_TYPE STRING Der Standard-SQL-Datentyp der Spalte
DESCRIPTION STRING Die Beschreibung der Spalte

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 des Typs RECORD

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

So führen Sie die Abfrage aus:

Console

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

    Zur Seite "BigQuery"

  2. Geben Sie im Feld Abfrageeditor die folgende Standard-SQL-Abfrage ein. Für INFORMATION_SCHEMA muss die Standard-SQL-Syntax verwendet werden. In der Cloud 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 Ausführen.

bq

Verwenden Sie den Befehl query und geben Sie dabei die Standard-SQL-Syntax mit dem Flag --nouse_legacy_sql oder --use_legacy_sql=false an. 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 sind table_catalog und table_schema nicht in den Ergebnissen enthalten.

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

So können Sie Tabellen in Datasets auflisten:

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

Erforderliche Berechtigungen

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

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

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

Tabellen auflisten

So listen Sie die Tabellen in einem Dataset auf:

Console

  1. Klicken Sie in der Cloud 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.

bq

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

Zusätzliche Flags sind:

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

Dabei gilt:

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

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

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

Beispiele:

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

bq ls --format=pretty mydataset

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

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

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

bq ls --format=pretty myotherproject:mydataset

API

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

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von C# in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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

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

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"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

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

Java

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

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

public class ListTables {

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

  public static void listTables(String projectId, String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

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

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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 anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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

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


from google.cloud import bigquery

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

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

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

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

Ruby

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Ruby in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen 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