Nach Aufnahmezeit partitionierte Tabellen erstellen und verwenden

In diesem Dokument wird beschrieben, wie nach Aufnahmezeit partitionierte Tabellen in BigQuery erstellt und verwendet werden. Weitere Informationen zu nach Datum/Zeitstempel partitionierten Tabellen finden Sie unter Nach Datum/Zeitstempel partitionierte Tabellen erstellen und verwenden. Weitere Informationen zu nach Ganzzahlenbereich partitionierten Tabellen finden Sie unter Nach Ganzzahlenbereich partitionierte Tabellen erstellen und verwenden.

Nachdem Sie eine nach Aufnahmezeit partitionierte Tabelle erstellt haben, können Sie Folgendes tun:

  • Den Zugriff auf Ihre Tabellendaten steuern
  • Informationen zu den partitionierten Tabellen abfragen
  • Partitionierte Tabellen in einem Dataset auflisten
  • Metadaten von partitionierten Tabellen mithilfe von Metatabellen abrufen

Weitere Informationen zum Verwalten von partitionierten Tabellen, einschließlich Aktualisieren der Attribute von Tabellen, Kopieren von partitionierten Tabellen und Löschen von partitionierten Tabellen, finden Sie unter Partitionierte Tabellen verwalten.

Nach Aufnahmezeit partitionierte Tabellen erstellen

Sie haben folgende Möglichkeiten, um in BigQuery nach Aufnahmezeit partitionierte Tabellen zu erstellen:

  • Durch Ausführen der DDL-Anweisung CREATE TABLE mit einem partition_expression
  • Manuell mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq mk des Befehlszeilentools
  • Programmgesteuert durch Aufrufen der API-Methode tables.insert
  • Mit den Clientbibliotheken
  • Aus Abfrageergebnissen
  • Beim Laden von Daten
  • Durch Konvertieren von datumsfragmentierten Tabellen in partitionierte Tabellen

Tabellennamen

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

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

Erforderliche Berechtigungen

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

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

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

Diese vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen bigquery.tables.create und bigquery.tables.updateData:

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

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

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

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

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

Leere nach Aufnahmezeit partitionierte Tabelle mit Schemadefinition erstellen

Beim Erstellen einer leeren zeitpartitionierten Tabelle mit Schemadefinition können Sie Folgendes tun:

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

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

Nachdem die zeitpartitionierte Tabelle erstellt wurde, können Sie:

  • Daten in die Tabelle laden
  • Abfrageergebnisse in die Tabelle schreiben
  • Daten in die Tabelle kopieren

So erstellen Sie eine leere zeitpartitionierte Tabelle mit einer Schemadefinition:

Console

  1. Wählen Sie im Bereich Ressourcen des Navigationsbereichs ein Dataset aus. Klicken Sie rechts im Fenster auf Tabelle erstellen. Tabelle erstellen
  2. Wählen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle die Option Leere Tabelle erstellen aus.
  3. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel so vor:

    • Wählen Sie für Dataset-Name das entsprechende Dataset aus. Dataset auswählen

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

    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

  4. Geben Sie im Abschnitt Schema die Schemadefinition ein.

    • So können Sie Schemainformationen manuell eingeben:

      • Klicken Sie auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein.

      • Geben Sie das Schema mit Feld hinzufügen manuell ein.

  5. Im Abschnitt Partitions- und Clustereinstellungen:

    • Klicken Sie unter Partitionierung auf Keine Partitionierung und wählen Sie Nach Aufnahmezeit partitionieren aus.
  6. Optional: Klicken Sie unter Partitionierungsfilter auf das Kästchen Partitionsfilter anfordern, damit Nutzer eine WHERE-Klausel zur Angabe der abzufragenden Partitionen einfügen müssen. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Partitionierte Tabellen abfragen.

  7. Optional: Klicken Sie auf Erweiterte Optionen und dann unter Verschlüsselung auf Vom Kunden verwalteter Schlüssel, um einen Cloud Key Management Service-Schlüssel zu verwenden. Wenn Sie die Einstellung Von Google verwalteter Schlüssel beibehalten, verschlüsselt BigQuery inaktive Daten.

  8. Klicken Sie auf Tabelle erstellen.

Nachdem die partitionierte Tabelle erstellt wurde, können Sie die Ablaufzeit der Tabelle, die Beschreibung und die Labels aktualisieren. Nachdem eine Tabelle mit der BigQuery-Web-UI erstellt wurde, können Sie keine Ablaufzeit für die Partition mehr hinzufügen.

Klassische UI

  1. Klicken Sie im Navigationsbereich neben dem Dataset-Namen auf den Abwärtspfeil Abwärtspfeil und anschließend auf Neue Tabelle erstellen.

  2. Klicken Sie auf der Seite Tabelle erstellen im Abschnitt Quelldaten auf Leere Tabelle erstellen.

  3. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Zieltabelle so vor:

    • Wählen Sie für Tabellenname das entsprechende Dataset aus und geben Sie im Namensfeld für die Tabelle den Namen der Tabelle ein, die Sie in BigQuery erstellen.
    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.
  4. Führen Sie im Abschnitt Schema eine manuelle Eingabe der Schemadefinition aus.

    • So können Sie Schemainformationen manuell eingeben:

      • Klicken Sie dazu auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein:

        Schema als JSON-Array hinzufügen

      • Geben Sie das Schema mit Feld hinzufügen ein.

        Schema durch Hinzufügen von Feldern einfügen

  5. Im Bereich Optionen gehen Sie so vor:

  6. Klicken Sie auf Tabelle erstellen.

Nachdem die partitionierte Tabelle erstellt wurde, können Sie die Ablaufzeit der Tabelle, die Beschreibung und die Labels aktualisieren. Nachdem eine Tabelle mit der BigQuery-Web-UI erstellt wurde, können Sie keine Ablaufzeit für die Partition mehr hinzufügen.

bq

Verwenden Sie den Befehl mk mit dem Flag --table (oder dem Kürzel -t) und dem Flag -- time_partitioning_type, das Sie je nach Partitionierungstyp entweder auf DAY oder HOUR festlegen. Sie können die Schemadefinition der Tabelle inline oder über eine JSON-Schemadatei bereitstellen. Zu den optionalen Parametern gehören --expiration, -- description, --time_partitioning_expiration, --destination_kms_key und --label. 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.

--destination_kms_key wird hier nicht erläutert. Weitere Informationen zur Verwendung dieses Flags finden Sie unter Daten mit Cloud KMS-Schlüsseln schützen.

So erstellen Sie eine leere nach Aufnahmezeit partitionierte Tabelle mit einer Schemadefinition:

bq mk --table \
--expiration integer1 \
--time_partitioning_type=unit_time \
--time_partitioning_expiration integer2 \
--description "description" \
-label key:value,key:value \
project_id:dataset.table \
schema

Dabei gilt:

  • integer1 ist die Standardlebensdauer der Tabelle in Sekunden. Der Mindestwert beträgt 3.600 Sekunden (eine Stunde). Die Ablaufzeit entspricht der aktuellen UTC-Zeit plus dem ganzzahligen Wert. Wenn Sie die Ablaufzeit beim Erstellen der partitionierten Tabelle festlegen, wird die Standardeinstellung des Datasets für die Ablaufzeit der Tabelle ignoriert. Bei Angabe dieses Werts werden die Tabelle und alle Partitionen zur festgelegten Zeit gelöscht.
  • unit_time ist je nach Partitionierungstyp entweder DAY oder HOUR. Der Standardwert ist DAY, wenn time_partitioning_type nicht angegeben wurde.
  • integer2 ist die Standardlebensdauer der Partitionen in der Tabelle in Sekunden. Es gibt keinen Mindestwert. Die Ablaufzeit entspricht dem Datum der Partition plus dem ganzzahligen Wert. Die Ablaufzeit der Partition ist unabhängig von der Ablaufzeit der Tabelle, hat jedoch keinen Vorrang. Wenn Sie einen Partitionsablauf festlegen, der länger als der Ablauf der Tabelle ist, hat der Ablauf der Tabelle Vorrang.
  • description ist eine Beschreibung der Tabelle in Anführungszeichen.
  • key:value ist das Schlüssel/Wert-Paar für ein Label. Mit einer durch Kommas getrennten Liste können Sie mehrere Labels eingeben.
  • project_id ist die Projekt-ID.
  • dataset ist ein Dataset in Ihrem Projekt.
  • table ist der Name der zeitpartitionierten Tabelle, die Sie erstellen.
  • schema ist eine Inline-Schemadefinition im Format column:data_type,column: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 standardmäßig NULLABLE eingestellt. Wenn Sie Beschreibungen, Modi und RECORD-Typen einbinden möchten, müssen Sie stattdessen eine JSON-Schemadatei bereitstellen.

Beispiele:

Geben Sie den folgenden Befehl ein, um in Ihrem Standardprojekt in mydataset eine nach Aufnahmezeit partitionierte Tabelle namens mytable zu erstellen. Der Partitionierungstyp ist auf DAY gesetzt, der Ablauf der Partitionierung auf 259.200 Sekunden (3 Tage), der Ablauf der Tabelle auf 2.592.000 (1 Monat mit 30 Tagen), die Beschreibung auf This is my time partitioned table und das Label auf organization:development. 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 2592000 \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
--description "This is my time partitioned table" \
--label organization:development \
mydataset.mytable \
qtr:STRING,sales:FLOAT,year:STRING

Geben Sie den folgenden Befehl ein, um eine zeitpartitionierte Tabelle namens mytable in myotherproject und nicht in Ihrem Standardprojekt zu erstellen. Der Partitionierungstyp ist auf DAY festgelegt, der Ablauf der Partitionierung auf 259.200 Sekunden (3 Tage), die Beschreibung auf This is my time partitioned table und das Label auf organization:development. Der Befehl verwendet das Kürzel -t anstelle von --table. Dieser Befehl gibt keine Tabellenablaufzeit an. Wenn im Dataset ein Standardablaufwert für Tabellen festgelegt ist, wird dieser angewendet. Wenn im Dataset kein Standardablaufwert für Tabellen festgelegt ist, läuft die Tabelle niemals ab, aber die Partitionen laufen nach drei Tagen ab. Der Pfad zur Schemadatei lautet /tmp/myschema.json.

bq mk -t \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
--description "This is my time partitioned table" \
--label organization:development \
myotherproject:mydataset.mytable \
/tmp/myschema.json

Nachdem die nach Aufnahmezeit partitionierte Tabelle erstellt wurde, können Sie die Ablaufzeit der Tabelle, die Ablaufzeit der Partition, die Beschreibung und die Labels aktualisieren.

API

Rufen Sie die Methode tables.insert mit einer definierten Tabellenressource auf, die die Attribute timePartitioning und schema festlegt.

Nach Aufnahmezeit partitionierte Tabelle aus einem Abfrageergebnis erstellen

Schreiben Sie die Ergebnisse in eine neue Zieltabelle, um eine partitionierte Tabelle aus einem Abfrageergebnis zu erstellen. Sie können eine neue partitionierte Tabelle erstellen, indem Sie entweder eine partitionierte Tabelle oder eine nicht partitionierte Tabelle abfragen. Allerdings können Sie eine vorhandene Tabelle nicht mithilfe von Abfrageergebnissen in eine partitionierte Tabelle ändern.

Weitere Informationen zum Abfragen von zeitpartitionierten Tabellen finden Sie unter Partitionierte Tabellen abfragen.

Console

Sie können keine Partitionierungsoptionen für eine Zieltabelle angeben, wenn Sie Daten über die BigQuery-Web-UI der Console abfragen.

Klassische UI

Sie können keine Partitionierungsoptionen für eine Zieltabelle angeben, wenn Sie Daten über die klassische BigQuery-Web-UI abfragen.

bq

Geben Sie den Befehl bq query ein und geben Sie das Flag --destination_table an, um anhand der Abfrageergebnisse eine permanente Tabelle zu erstellen. Fügen Sie auch das Flag --time_partitioning_type hinzu, um eine nach Aufnahmezeit partitionierte Zieltabelle zu erstellen. DAY und HOUR sind die unterstützten Werte für --time_partitioning_type, je nachdem, welchen Detaillierungsgrad die Partition aufweist.

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 Format project_id:dataset hinzu.

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

Geben Sie den folgenden Befehl ein, um eine neue nach Aufnahmezeit partitionierte Zieltabelle anhand eines Abfrageergebnisses zu erstellen:

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

Dabei gilt:

  • location ist der Name Ihres Standorts. 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 einen Standardwert für den Standort festlegen.
  • project_id ist die Projekt-ID.
  • dataset ist der Name des Datasets, das die neue zeitpartitionierte Tabelle enthält.
  • table ist der Name der zeitpartitionierten Tabelle, die Sie anhand der Abfrageergebnisse erstellen.
    • unit_time ist je nach Partitionierungstyp entweder DAY oder HOUR. Der Standardwert ist DAY, wenn time_partitioning_type nicht angegeben wurde.
  • query ist eine Abfrage in der Standard-SQL-Syntax.

Beispiele:

Geben Sie den folgenden Befehl ein, um Abfrageergebnisse in eine nach Aufnahmezeit täglich partitionierte Zieltabelle namens mytable in mydataset zu schreiben. Das Dataset befindet sich in Ihrem Standardprojekt. Mit der Abfrage werden Daten aus einer nicht partitionierten Tabelle abgerufen, dem öffentlichen Dataset USA Name Data.

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

Geben Sie den folgenden Befehl ein, um Abfrageergebnisse in eine nach Aufnahmezeit partitionierte Zieltabelle namens mytable in mydataset zu schreiben, die nach dem Datum der Datenaufnahme partitioniert ist. Das Dataset befindet sich in myotherproject und nicht in Ihrem Standardprojekt. Mit der Abfrage werden Daten aus einer nicht partitionierten Tabelle abgerufen, dem öffentlichen Dataset USA Name Data.

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

API

Wenn Sie Abfrageergebnisse in einer permanenten, nach Aufnahmezeit partitionierten Tabelle speichern möchten, rufen Sie die Methode jobs.insert auf, konfigurieren einen query-Job und fügen einen Wert für die Attribute destinationTable und timePartitioning ein.

Nach Aufnahmezeit partitionierte Tabellen beim Laden von Daten erstellen

Sie können eine nach Aufnahmezeit partitionierte Tabelle erstellen, indem Sie Partitionierungsoptionen beim Laden von Daten in eine neue Tabelle angeben. Sie müssen keine leere partitionierte Tabelle erstellen, um die Daten zu laden. Sie können die partitionierte Tabelle erstellen und gleichzeitig Daten in diese Tabelle laden.

Beim Laden von Daten in BigQuery können Sie das Tabellenschema bereitstellen oder die automatische Erkennung verwenden, wenn es sich um unterstützte Datenformate handelt.

Mit Partitions-Decorators können Daten in eine bestimmte Partition geladen werden. Verwenden Sie einen Partitions-Decorator zum Laden von Daten in eine Partition basierend auf der gewünschten Zeitzone, um unterschiedliche Zeitzonen zu berücksichtigen. Wenn Sie beispielsweise Pacific Standard Time (PST) verwenden, schreiben Sie mit dem entsprechenden Partitions-Decorator alle am 1. Mai 2016 (PST) generierten Daten in die Partition für dieses Datum:

table_name$20160501

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

Datumsfragmentierte Tabellen in nach Aufnahmezeit partitionierte Tabellen konvertieren

Wenn Sie bereits datumsfragmentierte Tabellen erstellt haben, können Sie den gesamten Satz zugehöriger Tabellen in eine einzige nach Aufnahmezeit partitionierte Tabelle konvertieren. Verwenden Sie dazu den Befehl partition im bq-Befehlszeilentool. Die datumsfragmentierten Tabellen müssen der folgenden Namenskonvention entsprechen: table_YYYYMMDD. Beispiel: mytable_20160101, ..., mytable_20160331.

Zu den optionalen Parametern gehören --time_partitioning_expiration, --location und --time_partitioning_type. Wenn er nicht angegeben wird, wird --time_partitioning_type standardmäßig auf DAY gesetzt. Wenn sich die Quelltabellen oder die Zieltabelle in einem anderen Projekt als Ihrem Standardprojekt befinden, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

Geben Sie den folgenden Befehl ein, um eine Reihe von nach Datum fragmentierten Tabellen in eine nach Aufnahmezeit partitionierte Tabelle zu konvertieren, die nach Datum partitioniert ist:

bq --location=location partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration integer \
project_id:dataset.source_table_ \
project_id:dataset.destination_table

Dabei gilt:

  • location ist der Name Ihres Standorts. Das Flag --location ist optional. Wenn Sie beispielsweise BigQuery in der Region Tokio verwenden, geben Sie für das Flag den Wert asia-northeast1 an. Mit der Datei ".bigqueryrc" können Sie einen Standardwert für den Standort festlegen.
  • integer ist die Standardlebensdauer der Partitionen in der Tabelle in Sekunden. Es gibt keinen Mindestwert. Die Ablaufzeit ergibt sich aus dem UTC-Datum der Partition plus dem ganzzahligen Wert. Der Ablauf der Partition ist unabhängig vom Ablauf der Tabelle, hat jedoch keinen Vorrang. Wenn Sie einen Partitionsablauf festlegen, der länger als der Ablauf der Tabelle ist, hat der Ablauf der Tabelle Vorrang.
  • project_id ist die Projekt-ID.
  • dataset ist ein Dataset in Ihrem Projekt.
  • sourcetable ist das Präfix der datumsfragmentierten Tabelle.
  • destination_table ist der Name der partitionierten Tabelle, die Sie erstellen.

Beispiele:

Geben Sie den folgenden Befehl ein, um in Ihrem Standardprojekt in mydataset eine nach Aufnahmezeit partitionierte Tabelle namens mytable_partitioned zu erstellen. Die Tabelle wird nach Datum partitioniert, wobei der Partitionierungsablauf auf 259.200 Sekunden (3 Tage) festgelegt wird. Die datumsfragmentierten Quelltabellen haben das Präfix sourcetable_. Die Quelltabellen befinden sich ebenfalls in Ihrem Standardprojekt.

bq partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
mydataset.sourcetable_ \
mydataset.mytable_partitioned

Wenn Sie den Befehl ausführen, wird ein Kopierjob erstellt, der Partitionen aus den fragmentierten Tabellen generiert. Beispiel: Für die datumsfragmentierten Tabellen sourcetable_20180126 und sourcetable_20180127 würden mit dem Kopierjob die folgenden Partitionen erstellt werden: mydataset.mytable_partitioned$20180126 und mydataset.mytable_partitioned$20180127.

Geben Sie den folgenden Befehl ein, um in mydataset eine nach Aufnahmezeit partitionierte Tabelle mit dem Namen mytable_partitioned zu erstellen. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt. Die Tabelle wird nach Datum partitioniert, wobei der Ablauf der Partitionierung auf 86.400 Sekunden (1 Tag) festgelegt wird. Die datumsfragmentierten Quelltabellen haben das Präfix sourcetable_. Die Quelltabellen befinden sich in Ihrem Standardprojekt.

bq partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 86400 \
mydataset.sourcetable_ \
myotherproject:mydataset.mytable_partitioned

Geben Sie den folgenden Befehl ein, um in Ihrem Standardprojekt in mydataset eine nach Aufnahmezeit partitionierte Tabelle namens mytable_partitioned zu erstellen. mydataset wurde in der Region asia-northeast1 erstellt. Die Tabelle wird nach Datum partitioniert, wobei der Ablauf der Partitionierung auf 259.200 Sekunden (3 Tage) festgelegt wird. Die datumsfragmentierten Quelltabellen haben das Präfix sourcetable_. Die Quelltabellen befinden sich ebenfalls in Ihrem Standardprojekt.

bq --location=asia-northeast1 partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
mydataset.sourcetable_ \
mydataset.mytable_partitioned

Zugriff auf zeitpartitionierte Tabellen steuern

Sie können Zugriffssteuerungen nicht direkt Tabellen oder Ansichten zuweisen. Sie können den Zugriff auf Tabellen aber steuern, indem Sie die Zugriffssteuerung auf der Dataset- oder einer höheren Ebene konfigurieren.

Anstatt Zugriff auf einzelne Datasets zu gewähren, können Sie vordefinierte Cloud IAM-Rollen zuweisen, mit denen Berechtigungen auf Projektebene oder höher erteilt werden.

Sie können auch benutzerdefinierte Rollen erstellen. Wenn Sie benutzerdefinierte Rollen erstellen, hängen die Berechtigungen von den Tabellenvorgängen ab, die der Nutzer, die Gruppe oder das Dienstkonto ausführen soll.

Weitere Informationen zu Rollen und Berechtigungen finden Sie unter:

Nach Aufnahmezeit partitionierte Tabellen erstellen

Informationen zu nach Aufnahmezeit partitionierten Tabellen abrufen

Sie können Informationen zu Tabellen mit den folgenden Methoden abrufen:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq show über die Befehlszeile
  • Durch Aufrufen der API-Methode tables.get
  • Mit den Clientbibliotheken

Erforderliche Berechtigungen

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

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

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit dem bigquery.dataOwner-Zugriff hat der Nutzer die Möglichkeit, Informationen über Tabellen in einem Dataset abzurufen.

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

Informationen zu nach Aufnahmezeit partitionierten Tabellen abrufen

So zeigen Sie Informationen zu einer nach Aufnahmezeit partitionierten Tabelle an:

Console

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

  2. Maximieren Sie im Navigationsbereich im Bereich Ressourcen Ihr Projekt und wählen Sie ein Dataset aus, um die darin enthaltenen Tabellen und Ansichten aufzulisten.

  3. Klicken Sie auf den Tabellennamen.

  4. Klicken Sie auf Details. Auf diesem Tab sind die Tabellenbeschreibung und Tabelleninformationen zu sehen.

    Tabellendetails

  5. Klicken Sie auf den Tab Schema, um die Schemadefinition der Tabelle anzuzeigen. Die zusätzliche Pseudospalte _PARTITIONTIME enthält den datumsbasierten Zeitstempel für Daten, die in die Tabelle geladen wurden.

Klassische UI

  1. Klicken Sie im Navigationsbereich links neben dem Dataset auf den Abwärtspfeil Abwärtspfeil, um die Ansicht zu maximieren, oder doppelklicken Sie auf den Dataset-Namen. Hierdurch werden die Tabellen und Ansichten im Dataset aufgerufen.

  2. Klicken Sie auf den Tabellennamen.

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

    Details zu partitionierten Tabellen

  4. Klicken Sie auf den Tab Schema, um die Schemadefinition der Tabelle anzuzeigen. Die zusätzliche Pseudospalte _PARTITIONTIME enthält den datumsbasierten Zeitstempel für Daten, die in die Tabelle geladen wurden.

    Partitioniertes Tabellenschema

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 <var>project_id:dataset.table</var>

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.

Beim Aufrufen von Schemainformationen für eine zeitpartitionierte Tabelle wird die Pseudospalte _PARTITIONTIME nicht angezeigt.

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

API

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

Nach Aufnahmezeit partitionierte Tabellen in einem Dataset auflisten

Sie können Tabellen in Datasets (einschließlich partitionierter Tabellen) auflisten. Verwenden Sie dazu die Cloud Console, die klassische BigQuery-Web-UI, den Befehl bq ls in der Befehlszeile oder die API-Methode tables.list.

Erforderliche Berechtigungen

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

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

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

Partitionierte Tabellen auflisten

So listen Sie Tabellen (einschließlich partitionierter Tabellen) in einem Dataset auf:

Console

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

  2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und klicken Sie auf Ihr Dataset.

  3. Scrollen Sie durch die Liste, um die Tabellen im Dataset aufzurufen. Tabellen, partitionierte Tabellen, Modelle und Ansichten sind durch verschiedene Symbole gekennzeichnet.

Klassische UI

  1. Klicken Sie im Navigationsbereich der Web-UI links neben dem Dataset auf den Abwärtspfeil Abwärtspfeil, um die Ansicht zu maximieren, oder doppelklicken Sie auf den Dataset-Namen. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

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

    Tabellen anzeigen

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, müssen Sie dem Dataset die Projekt-ID im folgenden Format hinzufügen: project_id:dataset

bq ls --format=pretty project_id:dataset

Dabei gilt:

  • 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. Bei nach Aufnahmezeit partitionierten Tabellen wird im Feld Time Partitioning der Wert DAY angezeigt. Sofern für die Partition eine Ablaufzeit angegeben wurde, wird diese in Millisekunden angegeben.

Beispiel:

+-------------------------+-------+----------------------+--------------------------------+
|         tableId         | Type  |        Labels        | Time Partitioning              |
+-------------------------+-------+----------------------+--------------------------------+
| mytable                 | TABLE | department:shipping  |  DAY (expirationMs: 259200000) |
| myview                  | VIEW  |                      |                                |
+-------------------------+-------+----------------------+--------------------------------+

Beispiele:

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

bq ls --format=pretty 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.

Partitionen in nach Aufnahmezeit partitionierten Tabellen auflisten

Sie können die Partitionen in einer nach Aufnahmezeit partitionierten Tabelle auflisten. Dazu fragen Sie die Pseudospalte _PARTITIONTIME (in Standard-SQL) oder die Metatabelle __PARTITIONS_SUMMARY__ (in Legacy-SQL) ab.

Sie können die Abfrage mit der Cloud Console, mit der klassischen BigQuery-Web-UI, mit dem Befehl bq query oder durch Aufrufen der Methode jobs.insert und durch Konfiguration eines query-Jobs ausführen.

Erforderliche Berechtigungen

Zum Ausführen eines Abfragejobs, der die Metatabelle __PARTITIONS_SUMMARY__ oder die Pseudospalte _PARTITIONTIME verwendet, benötigen Sie Berechtigungen des Typs bigquery.jobs.create. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen des Typs bigquery.jobs.create:

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

Sie benötigen außerdem Berechtigungen des Typs bigquery.tables.getData. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen des Typs bigquery.tables.getData:

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

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

Partitionen in nach Aufnahmezeit partitionierten Tabellen auflisten

Sie können die Partitionen in einer nach Aufnahmezeit partitionierten Tabelle mit Standard-SQL (bevorzugt) oder Legacy-SQL abrufen. So listen Sie Partitionen auf:

Standard-SQL:

Console

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

  2. Klicken Sie auf die Schaltfläche Neue Abfrage erstellen.

  3. Geben Sie im Feld Abfrageeditor den folgenden Text ein, um die Pseudospalte _PARTITIONTIME abzufragen:

    SELECT
      _PARTITIONTIME as pt
    FROM
      `dataset.table`
    GROUP BY 1
    

    Dabei gilt:

    • dataset ist das Dataset, das die Tabelle enthält.
    • table ist der Name der Tabelle.
  4. Optional: Klicken Sie auf Mehr und wählen Sie Abfrageeinstellungen aus.

    Abfrageeinstellungen

  5. Klicken Sie auf Ausführen.

Klassische UI

  1. Öffnen Sie die BigQuery-Web-UI.

    Zur BigQuery-Web-UI

  2. Klicken Sie auf Abfrage erstellen.

  3. Geben Sie in das Feld Neue Abfrage folgenden Text ein, um die Pseudospalte _PARTITIONTIME einer Tabelle abzufragen:

    #standardSQL
    SELECT
      _PARTITIONTIME as pt
    FROM
      `dataset.table`
    GROUP BY 1
    

    Dabei gilt:

    • dataset ist das Dataset, das die Tabelle enthält.
    • table ist der Name der Tabelle.
  4. Klicken Sie auf Optionen anzeigen.

  5. Optional: Klicken Sie bei Verarbeitungsstandort auf Nicht angegeben und wählen Sie den Standort Ihrer Daten aus.

  6. Klicken Sie auf Abfrage ausführen.

bq

Geben Sie die folgende Abfrage mit dem Befehl bq query ein:

bq --location=location query --use_legacy_sql=false '
SELECT
  _PARTITIONTIME as pt
FROM
  `dataset.table`
GROUP BY 1'

Dabei gilt:

  • location ist der Name Ihres Standorts. 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 einen Standardwert für den Standort festlegen.
  • dataset ist das Dataset, das die Tabelle enthält.
  • table ist der Name der Tabelle.

API

Rufen Sie die Methode jobs.insert auf und konfigurieren Sie einen query-Job, mit dem die Pseudospalte _PARTITIONTIME der Tabelle abgefragt wird.

Geben Sie im Abschnitt jobReference der Jobressource Ihren Standort im Attribut location an.

Legacy-SQL:

Console

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

  2. Klicken Sie auf die Schaltfläche Neue Abfrage erstellen.

  3. Geben Sie im Feld Abfrageeditor den folgenden Text ein, um die Metatabelle __PARTITIONS_SUMMARY__ abzufragen:

    #legacySQL
    SELECT
      partition_id
    FROM
      [dataset.table$__PARTITIONS_SUMMARY__]
    

    Dabei gilt:

    • dataset ist das Dataset, das die Tabelle enthält.
    • table ist der Name der Tabelle.
  4. Klicken Sie auf Mehr und wählen Sie Abfrageeinstellungen.

    Abfrageeinstellungen

  5. Klicken Sie unter Verarbeitungsstandort auf Automatische Auswahl und wählen Sie den Standort Ihrer Daten aus. Wenn sich Ihre Daten an einem multiregionalen Standort wie US oder EU befinden, können Sie für den Verarbeitungsstandort die automatische Auswahl beibehalten. Wenn sich Ihre Daten am Verarbeitungsstandort US oder EU befinden, wird der Verarbeitungsstandort automatisch erkannt.

    Verarbeitungsstandort der Abfrage

  6. Klicken Sie auf Ausführen.

Klassische UI

  1. Öffnen Sie die BigQuery-Web-UI.

    Zur BigQuery-Web-UI

  2. Klicken Sie auf Abfrage erstellen.

  3. Geben Sie in das Feld Neue Abfrage den folgenden Text ein, um die Metatabelle __PARTITIONS_SUMMARY__ einer Tabelle abzufragen:

    #legacySQL
    SELECT
       partition_id
     FROM
       [dataset.table$__PARTITIONS_SUMMARY__]
    

    Dabei gilt:

    • dataset ist das Dataset, das die Tabelle enthält.
    • table ist der Name der Tabelle.
  4. Klicken Sie auf Show Options.

  5. Optional: Klicken Sie bei Verarbeitungsstandort auf Nicht angegeben und wählen Sie den Standort Ihrer Daten aus.

  6. Klicken Sie auf Abfrage ausführen.

bq

Geben Sie die folgende Abfrage mit dem Befehl bq query ein:

bq --location=location query --use_legacy_sql=true '
SELECT
   partition_id
 FROM
   [dataset.table$__PARTITIONS_SUMMARY__]'

Dabei gilt:

  • location ist der Name Ihres Standorts. 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 einen Standardwert für den Standort festlegen.
  • dataset ist das Dataset, das die Tabelle enthält.
  • table ist der Name der Tabelle.

API

Rufen Sie die Methode jobs.insert auf und konfigurieren Sie einen query-Job, mit dem die Metatabelle __PARTITIONS_SUMMARY__ abgefragt wird.

Geben Sie Ihren Standort im Abschnitt jobReference der Jobressource im Attribut location an.

Tabellenmetadaten mithilfe von Metatabellen abrufen

Sie können Informationen zu partitionierten Tabellen abrufen. Dazu verwenden Sie spezielle Tabellen, die als Metatabellen bezeichnet werden. Metatabellen enthalten Metadaten wie die Liste der Tabellen und Ansichten innerhalb eines Datasets. Die Metatabellen sind schreibgeschützt.

Metadaten einer Partition mithilfe von Metatabellen abrufen

Die Metatabelle __PARTITIONS_SUMMARY__ ist eine spezielle Tabelle mit Metadaten der Partitionen in einer zeitpartitionierten Tabelle. Die Metatabelle __PARTITIONS_SUMMARY__ ist schreibgeschützt.

Verwenden Sie die Metatabelle __PARTITIONS_SUMMARY__ in der SELECT-Anweisung einer Abfrage, um auf Metadaten der Partitionen in einer zeitpartitionierten Tabelle zuzugreifen. Sie können die Abfrage folgendermaßen ausführen:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq query des Befehlszeilentools
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines query-Jobs
  • Mit den Clientbibliotheken

Derzeit wird von Standard-SQL das Trennzeichen ($) des Partitions-Decorators nicht unterstützt. Sie können __PARTITIONS_SUMMARY__ also nicht in Standard-SQL abfragen. Eine Abfrage in Legacy-SQL mit der Metatabelle __PARTITIONS_SUMMARY__ sieht in etwa so aus:

SELECT
  column
FROM
  [dataset.table$__PARTITIONS_SUMMARY__]

Dabei gilt:

  • dataset ist der Name des Datasets.
  • table ist der Name der zeitpartitionierten Tabelle.
  • column ist eines der folgenden:
Wert Beschreibung
project_id Name des Projekts
dataset_id Name des Datasets
table_id Name der zeitpartitionierten Tabelle
partition_id Name (Datum) der Partition
creation_time Zeitpunkt, zu dem die Partition erstellt wurde, in Millisekunden seit dem 1. Januar 1970 (UTC)
last_modified_time Zeitpunkt, zu dem die Partition zuletzt geändert wurde, in Millisekunden seit dem 1. Januar 1970 (UTC)

Berechtigungen für die Metatabelle einer Partition

Zum Ausführen eines Abfragejobs, der die Metatabelle __PARTITIONS_SUMMARY__ verwendet, benötigen Sie mindestens Berechtigungen vom Typ bigquery.jobs.create. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen des Typs bigquery.jobs.create:

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

Sie benötigen außerdem Berechtigungen vom Typ bigquery.tables.getData. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen des Typs bigquery.tables.getData:

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

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

Beispiele für Metatabelle einer Partition

Durch die folgende Abfrage werden alle Partitionsmetadaten für eine zeitpartitionierte Tabelle namens mydataset.mytable abgerufen.

Console

#legacySQL
SELECT
  *
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]

Klassische UI

#legacySQL
SELECT
  *
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]

Befehlszeile

bq query --use_legacy_sql=true '
SELECT
  *
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]'

Die Ausgabe sieht in etwa so aus:

+----------------+------------+----------------+--------------+---------------+--------------------+
|   project_id   | dataset_id |    table_id    | partition_id | creation_time | last_modified_time |
+----------------+------------+----------------+--------------+---------------+--------------------+
| myproject      | mydataset  | mytable        | 20160314     | 1517190224120 | 1517190224997      |
| myproject      | mydataset  | mytable        | 20160315     | 1517190224120 | 1517190224997      |
+----------------+------------+----------------+--------------+---------------+--------------------+

Durch die folgende Abfrage werden die Zeiten aufgelistet, zu denen die Partitionen in mydataset.mytable zuletzt geändert wurden.

Console

#legacySQL
SELECT
  partition_id,
  last_modified_time
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]

Klassische UI

#legacySQL
SELECT
  partition_id,
  last_modified_time
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]

Befehlszeile

bq query --use_legacy_sql=true '
SELECT
  partition_id,
  last_modified_time
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]'

Die Ausgabe sieht in etwa so aus:

+--------------+--------------------+
| partition_id | last_modified_time |
+--------------+--------------------+
| 20160102     |      1471632556179 |
| 20160101     |      1471632538142 |
| 20160103     |      1471632570463 |
+--------------+--------------------+

Verwenden Sie die Funktion FORMAT_UTC_USEC, um das Feld last_modified_time in einem für Menschen lesbaren Format anzeigen zu lassen: Beispiel:

Console

#legacySQL
SELECT
  partition_id,
  FORMAT_UTC_USEC(last_modified_time*1000) AS last_modified
FROM
  [mydataset.table1$__PARTITIONS_SUMMARY__]

Klassische UI

#legacySQL
SELECT
  partition_id,
  FORMAT_UTC_USEC(last_modified_time*1000) AS last_modified
FROM
  [mydataset.table1$__PARTITIONS_SUMMARY__]

Befehlszeile

bq query --use_legacy_sql=true '
SELECT
  partition_id,
  FORMAT_UTC_USEC(last_modified_time*1000) AS last_modified
FROM
  [mydataset.mytable$__PARTITIONS_SUMMARY__]'

Die Ausgabe sieht etwa so aus:

+--------------+----------------------------+
| partition_id |       last_modified        |
+--------------+----------------------------+
| 20160103     | 2016-08-19 18:49:30.463000 |
| 20160102     | 2016-08-19 18:49:16.179000 |
| 20160101     | 2016-08-19 18:48:58.142000 |
+--------------+----------------------------+

Beispiel: Nach Aufnahmezeit partitionierte Tabelle aus Abfrageergebnissen erstellen

In diesem Beispiel erstellen Sie mithilfe des Befehlszeilentools eine nach Aufnahmezeit partitionierte Tabelle und fügen mithilfe von Abfrageergebnissen Daten zu drei Partitionen hinzu. Die Tabelle enthält nach Datum partitionierte Wetterdaten für die ersten drei Tage im Jahr 2016.

In diesem Beispiel wird das NOAA GSOD-Wetter-Dataset nach Temperaturen in den ersten drei Tagen des Jahres 2016 abgefragt. Die Ergebnisse werden in eine partitionierte Tabelle geschrieben.

Schritt 1: Erstellen Sie eine leere nach Aufnahmezeit partitionierte Tabelle, die nach Datum partitioniert ist, mit der Bezeichnung temps in einem Dataset mit dem Namen mydataset. Sie müssen kein Schema für die Tabelle angeben. Das Schema aus den Abfrageergebnissen wird als Schemadefinition für die Tabelle verwendet.

bq mk --time_partitioning_type=DAY mydataset.temps

Verwenden Sie den Befehl bq show, um sich die Konfigurationseinstellungen anzeigen zu lassen:

bq show --format=prettyjson mydataset.temps

Suchen Sie in der Ausgabe des Befehls bq show nach dem Eintrag timePartitioning:

{
  ...
  "timePartitioning": {
    "type": "DAY"
  },
  "type": "TABLE"
}

Schritt 2: Fragen Sie das NOAA GSOD-Wetter-Dataset nach Temperaturen in den ersten drei Tagen des Jahres 2016 ab und schreiben Sie die Ergebnisse in die entsprechenden Partitionen in der Tabelle temps. Die folgenden Abfragen verwenden die Option --destination_table und die Standard-SQL-Syntax, um 100 Zeilen mit Abfrageergebnissen in eine Partition zu schreiben.

  1. Führen Sie die folgende Abfrage aus, um Temperaturen vom 1. Januar 2016 in die Partition mydataset.temps$20160101 zu schreiben:

    bq query --use_legacy_sql=false \
    --destination_table 'mydataset.temps$20160101' \
    'SELECT
       stn,
       temp
     FROM
       `bigquery-public-data`.noaa_gsod.gsod2016
     WHERE
       mo="01"
       AND da="01"
     LIMIT
       100'
    
  2. Führen Sie die folgende Abfrage aus, um Temperaturen vom 2. Januar 2016 in die Partition mydataset.temps$20160102 zu schreiben:

    bq --location=US query --use_legacy_sql=false \
    --destination_table 'mydataset.temps$20160102' \
    'SELECT
       stn,
       temp
     FROM
       `bigquery-public-data`.noaa_gsod.gsod2016
     WHERE
       mo="01"
       AND da="02"
     LIMIT
       100'
    
  3. Führen Sie die folgende Abfrage aus, um Temperaturen vom 3. Januar 2016 in die Partition mydataset.temps$20160103 zu schreiben:

    bq --location=US query --use_legacy_sql=false \
    --destination_table 'mydataset.temps$20160103' \
    'SELECT
       stn,
       temp
     FROM
       `bigquery-public-data`.noaa_gsod.gsod2016
     WHERE
       mo="01"
       AND da="03"
     LIMIT
       100'
    

Schritt 3: Prüfen Sie mit dem Befehl bq show, ob in der Tabelle 300 Zeilen vorhanden sind.

bq show mydataset.temps

In den Ergebnissen werden das Schema und die Gesamtzahl der Zeilen angezeigt.

  Last modified        Schema       Total Rows   Total Bytes     Expiration      Time Partitioning   Labels   kmsKeyName
 ----------------- ---------------- ------------ ------------- ----------------- ------------------- -------- ------------
  28 Jan 15:03:45   |- stn: string   300          4800          29 Jan 15:00:32   DAY
                    |- temp: float

Tipp