Tabellen erstellen und verwenden

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

Nach dem Erstellen einer Tabelle können Sie:

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

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

Hinweis

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

Tabellennamen

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

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

Vorsichtsmaßnahmen:

  • Einige Tabellennamen und Präfixe für Tabellennamen sind reserviert. Wenn Ihnen eine Fehlermeldung angezeigt wird, dass der Tabellenname oder das Präfix reserviert ist, wählen Sie einen anderen Namen aus und versuchen Sie es noch einmal.
  • Wenn Sie mehrere Punktoperatoren (.) in eine Sequenz aufnehmen, werden die doppelten Operatoren implizit entfernt.

    Beispiel: project_name....datasest_name..table_name

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

Tabellen erstellen

So können Sie eine Tabelle in BigQuery erstellen:

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

Erforderliche Berechtigungen

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

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

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

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

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

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

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

Eine leere Tabelle mit einer Schemadefinition erstellen

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

  • Geben Sie das Schema mithilfe der 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. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

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

SQL

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

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

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

  3. Klicken Sie auf Ausführen.

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

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_field
  • --time_partitioning_type
  • --range_partitioning
  • --clustering_fields
  • --destination_kms_key
  • --label

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

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

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

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

Dabei gilt:

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

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

Beispiele:

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

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

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

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

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

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

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

API

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

C#

Bevor Sie dieses Beispiel ausprobieren, 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 zur Verwendung von Clientbibliotheken. Weitere Angaben 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 ausprobieren, 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// Import the Google Cloud client library 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 ausprobieren, 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 ausprobieren, 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 ausprobieren, 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 ausprobieren, 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

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

Console

  1. Öffnen Sie in der Console die Seite „BigQuery“.

    Zur Seite „BigQuery“

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

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

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

    Abfrageeinstellungen

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

    Ziel festlegen

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

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

    • Write if empty (Schreiben, wenn leer): Die Abfrageergebnisse werden nur in die Tabelle geschrieben, wenn sie leer ist.
    • Append to table (An Tabelle anfügen): Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
    • Overwrite table (Tabelle überschreiben): Eine vorhandene Tabelle mit demselben Namen wird mit den Abfrageergebnissen überschrieben.
  8. Optional: Wählen Sie als Speicherort der Daten Ihren Standort aus.

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

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

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

SQL

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

  1. Rufen Sie in der Console die BigQuery-Seite auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

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

  3. Klicken Sie auf Ausführen.

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

Weitere Informationen finden Sie unter 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-Syntax fest. Wenn Sie die Abfrageergebnisse in eine Tabelle schreiben möchten, die sich nicht in Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

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

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

import (
	"context"
	"fmt"
	"io"

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

// 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 ausprobieren, 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur  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 ist eine Datenquelle, für die auch dann direkt aus BigQuery heraus eine Abfrage ausgeführt werden kann, wenn die Daten nicht im BigQuery-Speicher gespeichert sind.

BigQuery unterstützt die folgenden externen Datenquellen:

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

Tabelle beim Laden von Daten erstellen

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

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

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

Zugriff auf Tabellen steuern

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

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

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

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

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

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

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

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

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

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

Informationen zu Tabellen abrufen

So erhalten Sie Informationen oder Metadaten zu Tabellen:

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

Erforderliche Berechtigungen

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

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

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

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

Tabelleninformationen abrufen

So rufen Sie Informationen zu Tabellen ab:

Console

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

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

  3. Klicken Sie auf den Namen der Tabelle.

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

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

bq

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 zur Verwendung von Clientbibliotheken. Weitere Angaben 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 ausprobieren, 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
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 ausprobieren, 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 ausprobieren, 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 model to fetch.
# table_id = 'your-project.your_dataset.your_table'

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

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

Mit INFORMATION_SCHEMA Informationen zu Tabellen abrufen

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

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

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

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

Ansicht TABLES

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

Die Ansicht INFORMATION_SCHEMA.TABLES hat das folgende Schema:

Spaltenname Datentyp Wert
table_catalog STRING Die ID des Projekts, das das Dataset enthält.
table_schema STRING Der Name des Datasets, das die Tabelle oder Ansicht enthält. Wird auch als datasetId bezeichnet.
table_name STRING Der Name der Tabelle oder Ansicht. Wird auch als tableId bezeichnet.
table_type STRING Der Tabellentyp; einer der folgenden:
is_insertable_into STRING YES oder NO, je nachdem, ob die Tabelle DML INSERT-Anweisungen unterstützt
is_typed STRING Der Wert ist immer NO
creation_time TIMESTAMP Der Erstellungszeitpunkt der Tabelle
ddl STRING Die DDL-Anweisung, mit der die Tabelle neu erstellt werden kann, z. B. CREATE TABLE oder CREATE VIEW
clone_time TIMESTAMP Für Tabellenklone (Vorschau) der Zeitpunkt, zu dem die Basistabelle geklont wurde, um diese Tabelle zu erstellen. Wenn Zeitreise verwendet wurde, enthält dieses Feld den Zeitreise-Zeitstempel. Andernfalls ist das Feld clone_time mit dem Feld creation_time identisch. Gilt nur für Tabellen, bei denen table_type auf CLONE gesetzt ist.
base_table_catalog STRING Für Tabellenklone (Vorschau) ist dies das Projekt der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE gesetzt ist.
base_table_schema STRING Für Tabellenklone (Vorschau) ist dies das Dataset der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE gesetzt ist.
base_table_name STRING Für Tabellenklone (Vorschau) ist dies der Name der Basistabelle. Gilt nur für Tabellen, bei denen table_type auf CLONE gesetzt ist.
default_collation_name STRING Der Name der standardmäßigen Sortierspezifikation, falls vorhanden. Andernfalls NULL.

Beispiele

Beispiel 1:

Im folgenden Beispiel werden Tabellenmetadaten für alle Tabellen im Dataset mydataset abgerufen. Mit der Abfrage werden alle Spalten aus der Ansicht INFORMATION_SCHEMA.TABLES mit Ausnahme von is_typed ausgewählt. Diese Spalte ist für eine zukünftige Verwendung reserviert. Die zurückgegebenen Metadaten gelten für alle Tabellentypen in mydataset in Ihrem Standardprojekt.

mydataset enthält folgende Tabellen:

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

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

  SELECT
    * EXCEPT(is_typed)
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES;

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

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

Im folgenden Beispiel werden 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.

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

  SELECT
    * EXCEPT(is_typed)
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'BASE TABLE';

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

  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-31 22:40:05 | CREATE TABLE myproject.mydataset.mytable1 |
  |                |               |                |            |                    |                     | (                                           |
  |                |               |                |            |                    |                     |   id INT64                                  |
  |                |               |                |            |                    |                     | );                                          |
  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  

Beispiel 3:

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

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

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

Das Ergebnis sieht etwa so aus:

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

Ansicht TABLE_OPTIONS

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

Die Ansicht INFORMATION_SCHEMA.TABLE_OPTIONS hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle oder Ansicht enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
OPTION_NAME STRING Ein Namenswert der Optionstabelle
OPTION_TYPE STRING Ein Datentypwert der Optionstabelle
OPTION_VALUE STRING Eine Wertoption der Optionstabelle
Optionstabelle
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 Die Standardlebensdauer aller Partitionen in einer partitionierten Tabelle in Tagen
expiration_timestamp 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
enable_refresh BOOL Gibt an, ob die automatische Aktualisierung für eine materialisierte Ansicht aktiviert ist
refresh_interval_minutes FLOAT64 Gibt an, wie häufig eine materialisierte Ansicht aktualisiert wird

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

Optionen
allow_jagged_rows

BOOL

Bei true werden Zeilen ohne nachgestellte optionale Spalten zugelassen.

Gilt für CSV-Daten.

allow_quoted_newlines

BOOL

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

Gilt für CSV-Daten.

compression

STRING

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

Gilt für CSV- und JSON-Daten.

description

STRING

Eine Beschreibung dieser Tabelle.

enable_logical_types

BOOL

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

Gilt für Avro-Daten.

enum_as_string

BOOL

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

Gilt für Parquet-Daten.

enable_list_inference

BOOL

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

Gilt für Parquet-Daten.

encoding

STRING

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

Gilt für CSV-Daten.

expiration_timestamp

TIMESTAMP

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

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

field_delimiter

STRING

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

Gilt für CSV-Daten.

format

STRING

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

Unterstützte Werte für LOAD DATA beinhalten: AVRO, CSV, NEWLINE_DELIMITED_JSON (oder JSON), ORC, PARQUET.

Der Wert JSON entspricht NEWLINE_DELIMITED_JSON.

decimal_target_types

ARRAY<STRING>

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

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

json_extension

STRING

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

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

hive_partition_uri_prefix

STRING

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

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

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

ignore_unknown_values

BOOL

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

Gilt für CSV- und JSON-Daten.

max_bad_records

INT64

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

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

null_marker

STRING

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

Gilt für CSV-Daten.

preserve_ascii_control_characters

BOOL

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

Gilt für CSV-Daten.

projection_fields

STRING

Eine Liste der zu ladenden Entitätsattribute.

Gilt für Datastore-Daten.

quote

STRING

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

Gilt für CSV-Daten.

require_hive_partition_filter

BOOL

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

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

sheet_range

STRING

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

Gilt für Google Tabellen-Daten.

Beispiel: “sheet1!A1:B20”.

skip_leading_rows

INT64

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

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

uris

ARRAY<STRING>

Ein Array von voll qualifizierten URIs für die externen Datenspeicherorte.

Beispiel: ["gs://bucket/path/*"].

Beispiele

Beispiel 1:

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

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

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

Das Ergebnis sieht etwa so aus:

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

Beispiel 2:

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

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

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

Das Ergebnis sieht etwa so aus:

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

Ansicht COLUMNS

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

Die Ansicht INFORMATION_SCHEMA.COLUMNS hat das folgende Schema:

Spaltenname Datentyp Wert
TABLE_CATALOG STRING Die ID des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder Ansicht (auch als tableId bezeichnet)
COLUMN_NAME STRING Der Name der Spalte
ORDINAL_POSITION INT64 Der 1-indexierte Versatz der Spalte in der Tabelle; bei einer Pseudospalte wie _PARTITIONTIME oder _PARTITIONDATE ist der Wert NULL
IS_NULLABLE STRING YES oder NO, je nachdem, ob der Spaltenmodus NULL-Werte zulässt
DATA_TYPE STRING Der 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
COLLATION_NAME STRING Der Name der Sortierspezifikation, falls vorhanden. Andernfalls NULL

. WennSTRING oder ARRAY<STRING> übergeben wird, wird die Sortierspezifikation zurückgegeben, sofern vorhanden. Andernfalls wird NULL zurückgegeben.

Beispiele

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

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

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

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

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

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

Ansicht COLUMN_FIELD_PATHS

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

Die Ansicht INFORMATION_SCHEMA.COLUMN_FIELD_PATHS hat das folgende Schema:

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

. Wenn ein STRING-, ARRAY<STRING>- oder STRING-Feld in einer STRUCT übergeben wird, wird die Sortierspezifikation zurückgegeben, sofern vorhanden. Andernfalls wird NULL zurückgegeben.

Beispiele

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

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

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

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

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

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

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

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

Ansicht TABLE_STORAGE

Die Ansicht INFORMATION_SCHEMA.TABLE_STORAGE hat das folgende Schema:

Spaltenname Datentyp Wert
PROJECT_ID STRING Die ID des Projekts, das das Dataset enthält
PROJECT_NUMBER INT64 Die Nummer des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle oder materialisierte Ansicht enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder materialisierten Ansicht (auch als tableId bezeichnet)
CREATION_TIME TIMESTAMP Der Erstellungszeitpunkt der Tabelle
TOTAL_ROWS INT64 Die Gesamtzahl der Zeilen in der Tabelle oder der materialisierten Ansicht
TOTAL_PARTITIONS INT64 Die Anzahl der vorhandenen Partitionen in der Tabelle oder der materialisierten Ansicht. Nicht partitionierte Tabellen geben 0 zurück.
TOTAL_LOGICAL_BYTES INT64 Gesamtzahl der logischen (unkomprimierten) Byte in der Tabelle oder materialisierten Ansicht
ACTIVE_LOGICAL_BYTES INT64 Anzahl der logischen (unkomprimierten) Byte, die weniger als 90 Tage alt sind
LONG_TERM_LOGICAL_BYTES INT64 Anzahl der logischen (unkomprimierten) Byte, die älter als 90 Tage sind
TOTAL_PHYSICAL_BYTES INT64 Gesamtzahl der zum Speichern verwendeten physischen (komprimierten) Byte, einschließlich aktiver und langfristiger Byte sowie Byte für Zeitreisen (für gelöschte Tabellen)
ACTIVE_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die weniger als 90 Tage alt sind
LONG_TERM_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die älter als 90 Tage sind
TIME_TRAVEL_PHYSICAL_BYTES INT64 Anzahl der physischen (komprimierten) Byte, die vom Zeitreisenspeicher verwendet wurden (gelöschte oder geänderte Daten)

Beispiele

Das folgende Beispiel zeigt Ihnen, welche Projekte in Ihrer Organisation derzeit den meisten Speicher verwenden.

SELECT
  project_id,
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE
GROUP BY
  project_id
ORDER BY
  total_logical_bytes DESC;

Das Ergebnis sieht etwa so aus:

+---------------------+---------------------+
|     project_id      | total_logical_bytes |
+---------------------+---------------------+
| projecta            |     971329178274633 |
+---------------------+---------------------+
| projectb            |     834638211024843 |
+---------------------+---------------------+
| projectc            |     562910385625126 |
+---------------------+---------------------+

TABLE_STORAGE_TIMELINE_BY_*-Ansichten

In den Zeitachsenansichten des Tabellenspeichers wird eine Zeile für jedes Ereignis zurückgegeben, das eine Speicheränderung für die Tabelle auslöst, z. B. das Schreiben, Aktualisieren oder Löschen einer Zeile. Das bedeutet, dass eine Tabelle für einen Tag mehrere Zeilen haben kann. Wenn Sie eine Ansicht für einen bestimmten Zeitraum abfragen, verwenden Sie den neuesten Zeitstempel für den gewünschten Tag.

Diese Ansicht hat folgendes Schema:

Spaltenname Datentyp Wert
TIMESTAMP TIMESTAMP Zeitstempel der letzten Neuberechnung des Speichers. Die Neuberechnung wird durch Änderungen an den Daten in der Tabelle ausgelöst.
DELETED BOOLEAN Gibt an, ob die Tabelle gelöscht wird
PROJECT_ID STRING Die ID des Projekts, das das Dataset enthält
PROJECT_NUMBER INT64 Die Nummer des Projekts, das das Dataset enthält
TABLE_SCHEMA STRING Der Name des Datasets, das die Tabelle oder materialisierte Ansicht enthält (auch als datasetId bezeichnet)
TABLE_NAME STRING Der Name der Tabelle oder materialisierten Ansicht (auch als tableId bezeichnet)
CREATION_TIME TIMESTAMP Der Erstellungszeitpunkt der Tabelle
TOTAL_ROWS INT64 Die Gesamtzahl der Zeilen in der Tabelle oder der materialisierten Ansicht
TOTAL_PARTITIONS INT64 Die Anzahl der Partitionen für die Tabelle oder die materialisierte Ansicht. Nicht partitionierte Tabellen geben 0 zurück.
TOTAL_LOGICAL_BYTES INT64 Gesamtzahl der logischen Byte in der Tabelle oder materialisierten Ansicht
ACTIVE_LOGICAL_BYTES INT64 Anzahl der logischen Byte, die weniger als 90 Tage alt sind
LONG_TERM_LOGICAL_BYTES INT64 Anzahl der logischen Byte, die älter als 90 Tage sind
TOTAL_PHYSICAL_BYTES INT64 Gesamtzahl der zum Speichern verwendeten physischen Byte, einschließlich aktiver und langfristiger Byte sowie Byte für Zeitreisen (für gelöschte Tabellen)
ACTIVE_PHYSICAL_BYTES INT64 Anzahl der physischen Byte, die weniger als 90 Tage alt sind
LONG_TERM_PHYSICAL_BYTES INT64 Anzahl der physischen Byte, die älter als 90 Tage sind
TIME_TRAVEL_PHYSICAL_BYTES INT64 Anzahl der physischen Byte, die vom Zeitreisenspeicher verwendet wurden (gelöschte oder geänderte Daten)

Beispiele

Wenn Sie die Abfrage für ein anderes Projekt als Ihr Standardprojekt ausführen möchten, fügen Sie die Projekt-ID im folgenden Format hinzu:

PROJECT_ID.DATASET_ID.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
Dabei gilt:

  • PROJECT_ID: die ID des Projekts.
  • DATASET_ID: Die ID des Datasets.

z. B. myproject.mydataset.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION.

Das folgende Beispiel zeigt die Summe des physischen Speichers, der von jedem Projekt in Ihrer Organisation zu einem bestimmten Zeitpunkt verwendet wird:

WITH most_recent_records as (
  SELECT
    project_id,
    table_schema,
    table_name,
    MAX(timestamp) as max_timestamp
  FROM
    `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
  WHERE
    timestamp <= 'TIMESTAMP'
  GROUP BY
    project_id, table_schema, table_name
  )
  SELECT
    i_s.project_id,
    SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes
  FROM
    `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s
  JOIN
    most_recent_records
  ON
    i_s.project_id = most_recent_records.project_id
    AND i_s.table_schema = most_recent_records.table_schema
    AND i_s.table_name = most_recent_records.table_name
    AND i_s.timestamp = most_recent_records.max_timestamp
  GROUP BY
    project_id;

Das Ergebnis sieht etwa so aus:

-----------------+------------------------+
|  project_id    |  TotalPhysicalBytes    |
+----------------+------------------------+
| projecta       | 3844                   |
| projectb       | 16022778               |
| projectc       | 8934009                |
+----------------+------------------------+

Tabellen in einem Dataset auflisten

So können Sie Tabellen in Datasets auflisten:

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

Erforderliche Berechtigungen

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

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

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

Tabellen auflisten

So listen Sie die Tabellen in einem Dataset auf:

Console

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

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

bq

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

Zusätzliche Flags sind:

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

Dabei gilt:

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

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

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

Beispiele:

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

    bq ls --format=pretty mydataset

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

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

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

    bq ls --format=pretty myotherproject:mydataset

API

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

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie 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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

Bevor Sie dieses Beispiel ausprobieren, 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
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 ausprobieren, 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 ausprobieren, 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 ausprobieren, 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

Tabellensicherheit

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

Mehr zur Verwendung der Play Console erfahren

Jetzt testen

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

BigQuery kostenlos testen