Partitionierte Tabellen erstellen

Auf dieser Seite wird beschrieben, wie Sie in BigQuery partitionierte Tabellen erstellen. Eine Übersicht über partitionierte Tabellen finden Sie unter Einführung in partitionierte Tabellen.

Hinweis

Weisen Sie IAM-Rollen (Identity and Access Management) zu, die Nutzern die erforderlichen Berechtigungen zum Ausführen der einzelnen Aufgaben in diesem Dokument gewähren.

Erforderliche Berechtigungen

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen einer Tabelle benötigen:

  • BigQuery Job User (roles/bigquery.jobUser) für das Projekt, wenn Sie eine Tabelle erstellen, indem Sie Daten laden oder Abfrageergebnisse in einer Tabelle speichern.
  • BigQuery-Dateneditor (roles/bigquery.dataEditor) für das Dataset, in dem Sie die Tabelle erstellen.

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Erstellen einer Tabelle erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Zum Erstellen einer Tabelle sind die folgenden Berechtigungen erforderlich:

  • bigquery.tables.create für das Dataset, in dem Sie die Tabelle erstellen.
  • bigquery.tables.getData für alle Tabellen und Ansichten, auf die Ihre Abfrage verweist, wenn Sie Abfrageergebnisse als Tabelle speichern.
  • bigquery.jobs.create im Projekt, wenn Sie die Tabelle durch Laden von Daten oder durch Speichern von Abfrageergebnissen in einer Tabelle erstellen.
  • bigquery.tables.updateData für die Tabelle, wenn Sie Daten in einer Tabelle mit Abfrageergebnissen anfügen oder überschreiben.

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Leere partitionierte Tabellen erstellen

Die Schritte zum Erstellen einer partitionierten Tabelle in BigQuery sind ähnlich wie beim Erstellen einer Standardtabelle, nur dass Sie die Partitionierungsoptionen zusammen mit anderen Tabellenoptionen angeben.

Nach Datum partitionierte Tabelle mit Zeiteinheit erstellen

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

Console

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

    BigQuery aufrufen

  2. Klicken Sie im linken Bereich auf  Explorer.
  3. Maximieren Sie im Bereich Explorer Ihr Projekt, klicken Sie auf Datasets und wählen Sie dann ein Dataset aus.
  4. Klicken Sie im Abschnitt Dataset-Informationen auf Tabelle erstellen.
  5. 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. Das Schema muss die Spalte DATE, TIMESTAMP oder DATETIME für die Partitionierungsspalte enthalten. Weitere Informationen finden Sie unter Schema angeben. 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. Wählen Sie im Abschnitt Partitions- und Clustereinstellungen in der Liste Partitionierung die Option Nach Feld partitionieren und dann die Partitionierung-Spalte aus. Diese Option ist nur verfügbar, wenn das Schema eine Spalte des Typs DATE, TIMESTAMP oder DATETIME enthält.
    5. Optional: Wenn Sie einen Partitionsfilter für alle Abfragen für diese Tabelle benötigen, klicken Sie das Kästchen Partitionsfilter anfordern an. Ein Partitionsfilter kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.
    6. Wählen Sie den Partitionierungstyp aus. Nur Nach Tag wird unterstützt.
    7. Optional: Wählen Sie die Option Vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK) verwenden, wenn Sie im Abschnitt Erweiterte Optionen einen vom Kunden verwalteten Verschlüsselungsschlüssel verwenden möchten. Standardmäßig verschlüsselt BigQuery inaktive Kundendaten mit einem Google-owned and Google-managed encryption key.
    8. Klicken Sie auf Tabelle erstellen.

SQL

Verwenden Sie zum Erstellen einer nach Datum/Uhrzeit partitionierten Tabelle eine CREATE TABLE-DDL-Anweisung mit einer PARTITION BY-Klausel.

Im folgenden Beispiel wird eine Tabelle mit täglichen Partitionen basierend auf der Spalte transaction_date erstellt:

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

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  transaction_date
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

    Verwenden Sie die OPTIONS-Klausel, um Tabellenoptionen wie Partitionsablauf und die Anforderungen an Partitionsfilter festzulegen.

  3. Klicken Sie auf Ausführen.

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

Der Standardpartitionierungstyp für DATE-Spalten ist die tägliche Partitionierung. Wenn Sie einen anderen Partitionierungstyp angeben möchten, nehmen Sie die Funktion DATE_TRUNC in die PARTITION BY-Klausel auf. Die folgende Abfrage erstellt beispielsweise eine Tabelle mit monatlichen Partitionen:

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  DATE_TRUNC(transaction_date, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

Sie können auch eine Spalte TIMESTAMP oder DATETIME als Partitionierungsspalte angeben. Fügen Sie in diesem Fall die Funktion TIMESTAMP_TRUNC oder DATETIME_TRUNC in die PARTITION BY-Klausel ein, um den Partitionstyp anzugeben. Mit der folgenden Anweisung wird beispielsweise eine Tabelle mit täglichen Partitionen anhand der Spalte TIMESTAMP erstellt:

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_ts TIMESTAMP)
PARTITION BY
  TIMESTAMP_TRUNC(transaction_ts, DAY)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

  2. Verwenden Sie den Befehl bq mk mit dem Flag --table (oder dem Kürzel -t):

    bq mk \
   --table \
   --schema SCHEMA \
   --time_partitioning_field COLUMN \
   --time_partitioning_type UNIT_TIME \
   --time_partitioning_expiration EXPIRATION_TIME \
   --require_partition_filter=BOOLEAN
   PROJECT_ID:DATASET.TABLE

    Dabei gilt:

    • SCHEMA: Eine Schemadefinition im Format column:data_type,column:data_type oder der Pfad zu einer JSON-Schemadatei auf Ihrem lokalen Computer. Weitere Informationen finden Sie unter Schema angeben.
    • COLUMN: Der Name der Partitionierungsspalte. Im Tabellenschema muss diese Spalte vom Typ TIMESTAMP, DATETIME oder DATE sein.
    • UNIT_TIME: Der Partitionierungstyp. Unterstützte Werte sind DAY, HOUR, MONTH oder YEAR.
    • EXPIRATION_TIME: Die Ablaufzeit für die Partitionen der Tabelle in Sekunden. Das Flag --time_partitioning_expiration ist optional. Weitere Informationen finden Sie unter Partitionsablauf festlegen.
    • BOOLEAN: Wenn true, müssen Abfragen in dieser Tabelle einen Partitionsfilter enthalten. Das Flag --require_partition_filter ist optional. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.
    • PROJECT_ID: die Projekt-ID Wenn nichts angegeben ist, wird das Standardprojekt verwendet.
    • DATASET: Der Name eines Datasets in Ihrem Projekt.
    • TABLE: Der Name der zu erstellenden Tabelle.

    Weitere Befehlszeilenoptionen finden Sie unter bq mk.

    Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt, die nach der stündlichen Partitionierung nach der Spalte ts partitioniert ist. Die Ablaufzeit der Partition beträgt 259.200 Sekunden (drei Tage).

    bq mk \
   -t \
   --schema 'ts:TIMESTAMP,qtr:STRING,sales:FLOAT' \
   --time_partitioning_field ts \
   --time_partitioning_type HOUR \
   --time_partitioning_expiration 259200  \
   mydataset.mytable

    3. Terraform

    Verwenden Sie die Ressource google_bigquery_table:

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

    Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt, die nach Tag partitioniert ist:

    resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  time_partitioning {
    type          = "DAY"
    field         = "Created"
    expiration_ms = 432000000 # 5 days
  }
  require_partition_filter = true

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Created",
    "type": "TIMESTAMP",
    "description": "Record creation timestamp"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

    Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud -Projekt anzuwenden.

    Cloud Shell vorbereiten

    1. Rufen Sie Cloud Shell auf.

    2. Legen Sie das Standardprojekt Google Cloud fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

      Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

    Verzeichnis vorbereiten

    Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

    1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

      Kopieren Sie den Beispielcode in das neu erstellte main.tf.

      Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

    3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
    4. Speichern Sie die Änderungen.
    5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
      terraform init

      Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

      terraform init -upgrade

    Änderungen anwenden

    1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
      terraform plan

      Korrigieren Sie die Konfiguration nach Bedarf.

    2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
      terraform apply

      Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

    3. Öffnen Sie Ihr Google Cloud Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

    API

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

    Go

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

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

    import (
	"context"
	"fmt"
	"time"

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

// createTablePartitioned demonstrates creating a table and specifying a time partitioning configuration.
func createTablePartitioned(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: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.IntegerFieldType},
		{Name: "date", Type: bigquery.DateFieldType},
	}
	metadata := &bigquery.TableMetadata{
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "date",
			Expiration: 90 * 24 * time.Hour,
		},
		Schema: sampleSchema,
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metadata); err != nil {
		return err
	}
	return nil
}

    Java

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

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

    import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;

// Sample to create a partition table
public class CreatePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING),
            Field.of("date", StandardSQLTypeName.DATE));
    createPartitionedTable(datasetName, tableName, schema);
  }

  public static void createPartitionedTable(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);

      TimePartitioning partitioning =
          TimePartitioning.newBuilder(TimePartitioning.Type.DAY)
              .setField("date") //  name of column to use for partitioning
              .setExpirationMs(7776000000L) // 90 days
              .build();

      StandardTableDefinition tableDefinition =
          StandardTableDefinition.newBuilder()
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .build();
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Partitioned table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Partitioned table was not created. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

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

async function createTablePartitioned() {
  // Creates a new partitioned 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, Post_Abbr:string, Date:date';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
    timePartitioning: {
      type: 'DAY',
      expirationMS: '7776000000',
      field: 'date',
    },
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);
  console.log(`Table ${table.id} created with partitioning: `);
  console.log(table.metadata.timePartitioning);
}

    Python

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

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

    from google.cloud import bigquery

client = bigquery.Client()

# Use format "your-project.your_dataset.your_table_name" for table_id
table_id = your_fully_qualified_table_id
schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
    bigquery.SchemaField("date", "DATE"),
]
table = bigquery.Table(table_id, schema=schema)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="date",  # name of column to use for partitioning
    expiration_ms=1000 * 60 * 60 * 24 * 90,
)  # 90 days

table = client.create_table(table)

print(
    f"Created table {table.project}.{table.dataset_id}.{table.table_id}, "
    f"partitioned on column {table.time_partitioning.field}."
)

Nach Aufnahmezeit partitionierte Tabelle erstellen

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

Console

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

    Zur Seite "BigQuery"

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

  3. Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.

  4. Klicken Sie im Detailfeld auf Tabelle erstellen.

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

  6. Gehen Sie im Abschnitt Destination (Ziel) so vor:

    • Wählen Sie für Dataset name (Dataset-Name) das passende Dataset aus.
    • Geben Sie im Feld Tabellenname den Namen der Tabelle ein.
    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

  7. Geben Sie im Abschnitt Schema die Schemadefinition ein.

  8. Klicken Sie im Abschnitt Partitions- und Clustereinstellungen für Partitionierung auf Nach Aufnahmezeit partitionieren.

  9. Optional: Wenn Sie einen Partitionsfilter für alle Abfragen für diese Tabelle benötigen, klicken Sie das Kästchen Partitionsfilter anfordern an. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.

  10. Klicken Sie auf Tabelle erstellen.

SQL

Verwenden Sie zum Erstellen einer nach Aufnahmezeit partitionierten Tabelle die Anweisung CREATE TABLE mit der Klausel PARTITION BY, die nach _PARTITIONDATE partitioniert.

Im folgenden Beispiel wird eine Tabelle mit täglichen Partitionen erstellt:

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

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE
  mydataset.newtable (transaction_id INT64)
PARTITION BY
  _PARTITIONDATE
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

    Verwenden Sie die OPTIONS-Klausel, um Tabellenoptionen wie Partitionsablauf und die Anforderungen an Partitionsfilter festzulegen.

  3. Klicken Sie auf Ausführen.

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

Der Standardpartitionierungstyp für die Partitionierung nach Aufnahmezeit ist die tägliche Partitionierung. Wenn Sie einen anderen Partitionierungstyp angeben möchten, nehmen Sie die Funktion DATE_TRUNC in die PARTITION BY-Klausel auf. Die folgende Abfrage erstellt beispielsweise eine Tabelle mit monatlichen Partitionen:

CREATE TABLE
  mydataset.newtable (transaction_id INT64)
PARTITION BY
  DATE_TRUNC(_PARTITIONTIME, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

  2. Verwenden Sie den Befehl bq mk mit dem Flag --table (oder dem Kürzel -t):

    bq mk \
   --table \
   --schema SCHEMA \
   --time_partitioning_type UNIT_TIME \
   --time_partitioning_expiration EXPIRATION_TIME \
   --require_partition_filter=BOOLEAN  \
   PROJECT_ID:DATASET.TABLE

    Dabei gilt:

    • SCHEMA: Eine Definition im Format column:data_type,column:data_type oder der Pfad zu einer JSON-Schemadatei auf Ihrem lokalen Computer. Weitere Informationen finden Sie unter Schema angeben.
    • UNIT_TIME: Der Partitionierungstyp. Unterstützte Werte sind DAY, HOUR, MONTH oder YEAR.
    • EXPIRATION_TIME: Die Ablaufzeit für die Partitionen der Tabelle in Sekunden. Das Flag --time_partitioning_expiration ist optional. Weitere Informationen finden Sie unter Partitionsablauf festlegen.
    • BOOLEAN: Wenn true, müssen Abfragen in dieser Tabelle einen Partitionsfilter enthalten. Das Flag --require_partition_filter ist optional. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.
    • PROJECT_ID: die Projekt-ID Wenn nichts angegeben ist, wird das Standardprojekt verwendet.
    • DATASET: Der Name eines Datasets in Ihrem Projekt.
    • TABLE: Der Name der zu erstellenden Tabelle.

    Weitere Befehlszeilenoptionen finden Sie unter bq mk.

    Im folgenden Beispiel wird eine nach Aufnahmezeit partitionierte Tabelle namens mytable erstellt. Die Tabelle hat eine tägliche Partitionierung mit einem Partitionsablauf von 259.200 Sekunden (drei Tage).

    bq mk \
   -t \
   --schema qtr:STRING,sales:FLOAT,year:STRING \
   --time_partitioning_type DAY \
   --time_partitioning_expiration 259200 \
   mydataset.mytable

    3. Terraform

    Verwenden Sie die Ressource google_bigquery_table:

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

    Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt, die nach Aufnahmezeit partitioniert ist:

    resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  time_partitioning {
    type          = "MONTH"
    expiration_ms = 604800000 # 7 days
  }
  require_partition_filter = true

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

    Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud -Projekt anzuwenden.

    Cloud Shell vorbereiten

    1. Rufen Sie Cloud Shell auf.

    2. Legen Sie das Standardprojekt Google Cloud fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

      Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

    Verzeichnis vorbereiten

    Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

    1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

      Kopieren Sie den Beispielcode in das neu erstellte main.tf.

      Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

    3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
    4. Speichern Sie die Änderungen.
    5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
      terraform init

      Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

      terraform init -upgrade

    Änderungen anwenden

    1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
      terraform plan

      Korrigieren Sie die Konfiguration nach Bedarf.

    2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
      terraform apply

      Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

    3. Öffnen Sie Ihr Google Cloud Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

    API

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

Nach Ganzzahlbereich partitionierte Tabelle erstellen

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

Console

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

    Zur Seite "BigQuery"

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

  3. Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.

  4. Klicken Sie im Detailfeld auf Tabelle erstellen.

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

  6. Gehen Sie im Abschnitt Destination (Ziel) so vor:

    • Wählen Sie für Dataset name (Dataset-Name) das passende Dataset aus.
    • Geben Sie im Feld Tabellenname den Namen der Tabelle ein.
    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

  7. Geben Sie im Abschnitt Schema die Schemadefinition ein. Das Schema muss eine Spalte INTEGER für die Partitionierungsspalte enthalten. Weitere Informationen finden Sie unter Schema angeben.

  8. Wählen Sie im Abschnitt Partitions- und Clustereinstellungen in der Drop-down-Liste Partitionierung die Option Nach Feld partitionieren und dann Partitionierungsspalte. Diese Option ist nur verfügbar, wenn das Schema eine Spalte INTEGER enthält.

  9. Geben Sie Werte für Start, Ende und Intervall ein:

    • Start ist der Anfang des ersten Partitionsbereichs (einschließlich).
    • Ende ist das Ende des letzten Partitionsbereichs (exklusiv).
    • Intervall ist die Breite jedes Partitionsbereichs.

    Werte außerhalb dieser Bereiche werden in eine spezielle __UNPARTITIONED__-Partition geschrieben.

  10. Optional: Wenn Sie einen Partitionsfilter für alle Abfragen für diese Tabelle benötigen, klicken Sie das Kästchen Partitionsfilter anfordern an. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.

  11. Klicken Sie auf Tabelle erstellen.

SQL

Zum Erstellen einer nach Ganzzahlbereich partitionierten Tabelle verwenden Sie die CREATE TABLE-DDL-Anweisung mit einer PARTITION BY-Klausel.

Im folgenden Beispiel wird eine Tabelle erstellt, die nach der Spalte customer_id mit dem Anfangswert 0, dem Endwert 100 und einem Intervall von 10 partitioniert ist:

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

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE mydataset.newtable (customer_id INT64, date1 DATE)
PARTITION BY
  RANGE_BUCKET(customer_id, GENERATE_ARRAY(0, 100, 10))
  OPTIONS (
    require_partition_filter = TRUE);

    Mit der OPTIONS-Klausel können Sie Tabellenoptionen wie die Anforderungen an Partitionsfilter festlegen.

  3. Klicken Sie auf Ausführen.

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

  2. Verwenden Sie den Befehl bq mk mit dem Flag --table (oder dem Kürzel -t):

    bq mk \
   --schema schema \
   --range_partitioning=COLUMN_NAME,START,END,INTERVAL \
   --require_partition_filter=BOOLEAN  \
   PROJECT_ID:DATASET.TABLE

    Dabei gilt:

    • SCHEMA: Eine Inline-Schemadefinition im Format column:data_type,column:data_type oder der Pfad zu einer JSON-Schemadatei auf Ihrem lokalen Computer. Weitere Informationen finden Sie unter Schema angeben.
    • COLUMN_NAME: Der Name der Partitionierungsspalte. Im Tabellenschema muss diese Spalte vom Typ INTEGER sein.
    • START: Der Beginn des ersten Partitionsbereichs (einschließlich).
    • END: Das Ende des letzten Partitionsbereichs (exklusiv).
    • INTERVAL: Die Breite jedes Partitionsbereichs
    • BOOLEAN: Wenn true, müssen Abfragen in dieser Tabelle einen Partitionsfilter enthalten. Das Flag --require_partition_filter ist optional. Weitere Informationen finden Sie unter Anforderungen an Partitionsfilter festlegen.
    • PROJECT_ID: die Projekt-ID Wenn nichts angegeben ist, wird das Standardprojekt verwendet.
    • DATASET: Der Name eines Datasets in Ihrem Projekt.
    • TABLE: Der Name der zu erstellenden Tabelle.

    Werte außerhalb des Partitionsbereichs werden in eine spezielle __UNPARTITIONED__-Partition geschrieben.

    Weitere Befehlszeilenoptionen finden Sie unter bq mk.

    Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt, die über die Spalte customer_id partitioniert ist.

    bq mk \
   -t \
   --schema 'customer_id:INTEGER,qtr:STRING,sales:FLOAT' \
   --range_partitioning=customer_id,0,100,10 \
   mydataset.mytable

    3. Terraform

    Verwenden Sie die Ressource google_bigquery_table:

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

    Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt, die nach Ganzzahlbereich partitioniert ist:

    resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  range_partitioning {
    field = "ID"
    range {
      start    = 0
      end      = 1000
      interval = 10
    }
  }
  require_partition_filter = true

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

    Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud -Projekt anzuwenden.

    Cloud Shell vorbereiten

    1. Rufen Sie Cloud Shell auf.

    2. Legen Sie das Standardprojekt Google Cloud fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

      Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

    Verzeichnis vorbereiten

    Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

    1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

      Kopieren Sie den Beispielcode in das neu erstellte main.tf.

      Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

    3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
    4. Speichern Sie die Änderungen.
    5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
      terraform init

      Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

      terraform init -upgrade

    Änderungen anwenden

    1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
      terraform plan

      Korrigieren Sie die Konfiguration nach Bedarf.

    2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
      terraform apply

      Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

    3. Öffnen Sie Ihr Google Cloud Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

    API

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

    Java

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

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

    import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.RangePartitioning;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a range partitioned table
public class CreateRangePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("integerField", StandardSQLTypeName.INT64),
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL),
            Field.of("dateField", StandardSQLTypeName.DATE));
    createRangePartitionedTable(datasetName, tableName, schema);
  }

  public static void createRangePartitionedTable(
      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);

      // Note: The field must be a top- level, NULLABLE/REQUIRED field.
      // The only supported type is INTEGER/INT64
      RangePartitioning partitioning =
          RangePartitioning.newBuilder()
              .setField("integerField")
              .setRange(
                  RangePartitioning.Range.newBuilder()
                      .setStart(1L)
                      .setInterval(2L)
                      .setEnd(10L)
                      .build())
              .build();

      StandardTableDefinition tableDefinition =
          StandardTableDefinition.newBuilder()
              .setSchema(schema)
              .setRangePartitioning(partitioning)
              .build();
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Range partitioned table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Range partitioned table was not created. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

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

async function createTableRangePartitioned() {
  // Creates a new integer range partitioned 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: 'fullName', type: 'STRING'},
    {name: 'city', type: 'STRING'},
    {name: 'zipcode', type: 'INTEGER'},
  ];

  // To use integer range partitioning, select a top-level REQUIRED or
  // NULLABLE column with INTEGER / INT64 data type. Values that are
  // outside of the range of the table will go into the UNPARTITIONED
  // partition. Null values will be in the NULL partition.
  const rangePartition = {
    field: 'zipcode',
    range: {
      start: 0,
      end: 100000,
      interval: 10,
    },
  };

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    rangePartitioning: rangePartition,
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created with integer range partitioning: `);
  console.log(table.metadata.rangePartitioning);
}

    Python

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

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

    from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING"),
    bigquery.SchemaField("city", "STRING"),
    bigquery.SchemaField("zipcode", "INTEGER"),
]

table = bigquery.Table(table_id, schema=schema)
table.range_partitioning = bigquery.RangePartitioning(
    # To use integer range partitioning, select a top-level REQUIRED /
    # NULLABLE column with INTEGER / INT64 data type.
    field="zipcode",
    range_=bigquery.PartitionRange(start=0, end=100000, interval=10),
)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Partitionierte Tabelle aus einem Abfrageergebnis erstellen

Sie haben folgende Möglichkeiten, um eine partitionierte Tabelle aus einem Abfrageergebnis zu erstellen:

  • Verwenden Sie in SQL eine CREATE TABLE ... AS SELECT-Anweisung. Sie können mit diesem Ansatz eine Tabelle erstellen, die nach Zeitspalten oder Ganzzahlbereichen partitioniert ist, jedoch nicht nach Aufnahmezeit.
  • Verwenden Sie das bq-Befehlszeilentool oder die BigQuery API, um eine Zieltabelle für eine Abfrage festzulegen. Wenn die Abfrage ausgeführt wird, schreibt BigQuery die Ergebnisse in die Zieltabelle. Sie können diesen Ansatz für jeden Partitionierungstyp verwenden.

  • Rufen Sie die API-Methode jobs.insert auf und geben Sie die Partitionierung in einem der Attribute timePartitioning oder rangePartitioning an.

SQL

Verwenden Sie die Anweisung CREATE TABLE. Fügen Sie die Klausel PARTITION BY zur Konfiguration der Partitionierung ein.

Im folgenden Beispiel wird eine Tabelle erstellt, die nach der Spalte transaction_date partitioniert ist:

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

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  transaction_date
AS (
  SELECT
    transaction_id, transaction_date
  FROM
    mydataset.mytable
);

    Mit der OPTIONS-Klausel können Sie Tabellenoptionen wie die Anforderungen an Partitionsfilter festlegen.

  3. Klicken Sie auf Ausführen.

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

  2. Zum Erstellen einer partitionierten Tabelle aus einer Abfrage verwenden Sie den Befehl bq query mit dem Flag --destination_table und dem Flag --time_partitioning_type.

    Spaltenpartitionierung nach Zeiteinheit

    bq query \
   --use_legacy_sql=false \
   --destination_table TABLE_NAME \
   --time_partitioning_field COLUMN \
   --time_partitioning_type UNIT_TIME \
   'QUERY_STATEMENT'

    Partitionierung nach Aufnahmezeit:

    bq query \
   --use_legacy_sql=false \
   --destination_table TABLE_NAME \
   --time_partitioning_type UNIT_TIME \
   'QUERY_STATEMENT'

    Partitionierung nach Ganzzahlbereich:

    bq query \
   --use_legacy_sql=false \
   --destination_table PROJECT_ID:DATASET.TABLE \
   --range_partitioning COLUMN,START,END,INTERVAL \
   'QUERY_STATEMENT'

    Dabei gilt:

    • PROJECT_ID: die Projekt-ID Wenn nichts angegeben ist, wird das Standardprojekt verwendet.
    • DATASET: Der Name eines Datasets in Ihrem Projekt.
    • TABLE: Der Name der zu erstellenden Tabelle.
    • COLUMN: Der Name der Partitionierungsspalte.
    • UNIT_TIME: Der Partitionierungstyp. Zu den unterstützten Werte zählen: DAY, HOUR, MONTH und YEAR.
    • START: Beginn der Bereichspartitionierung (einschließlich).
    • END: Ende der Bereichspartitionierung (ausschließlich)
    • INTERVAL: Breite des jeweiligen Bereichs in der Partition.
    • QUERY_STATEMENT: Die Abfrage, die zum Füllen der Tabelle verwendet wird.

    Im folgenden Beispiel wird eine Tabelle erstellt, die mit der monatlichen Partitionierung in der Spalte transaction_date partitioniert ist.

    bq query \
   --use_legacy_sql=false \
   --destination_table mydataset.newtable \
   --time_partitioning_field transaction_date \
   --time_partitioning_type MONTH \
   'SELECT transaction_id, transaction_date FROM mydataset.mytable'

    Im folgenden Beispiel wird eine Tabelle erstellt, die in der Spalte customer_id nach Ganzahlbereich partitioniert ist.

    bq query \
   --use_legacy_sql=false \
   --destination_table mydataset.newtable \
   --range_partitioning customer_id,0,100,10 \
   'SELECT * FROM mydataset.ponies'

    Bei nach Aufnahmezeit partitionierten Tabellen können Sie Daten auch mit einem Partitions-Decorator in eine bestimmte Partition laden. Im folgenden Beispiel wird eine neue nach Aufnahmezeit partitionierte Tabelle erstellt und Daten in die Partition 20180201 (1. Februar 2018) geladen:

    bq query \
   --use_legacy_sql=false  \
   --time_partitioning_type=DAY \
   --destination_table='newtable$20180201' \
   'SELECT * FROM mydataset.mytable'

    3. API

    Rufen Sie die Methode jobs.insert auf, um Abfrageergebnisse in einer partitionierten Tabelle zu speichern. Konfigurieren Sie einen query-Job. Geben Sie die Zieltabelle in destinationTable an. Geben Sie die Partitionierung entweder im Attribut timePartitioning oder im Attribut rangePartitioning an.

Datumsfragmentierte Tabellen in nach Aufnahmezeit partitionierte Tabellen konvertieren

Wenn Sie bereits datumsfragmentierte Tabellen erstellt haben, können Sie den gesamten Satz zugehöriger Tabellen mit dem bq-Befehlszeilentool und dem Befehl partition in eine einzige nach Aufnahmezeit partitionierte Tabelle konvertieren.

bq --location=LOCATION partition \
    --time_partitioning_type=PARTITION_TYPE \
    --time_partitioning_expiration INTEGER \
    PROJECT_ID:SOURCE_DATASET.SOURCE_TABLE \
    PROJECT_ID:DESTINATION_DATASET.DESTINATION_TABLE

Ersetzen Sie Folgendes:

  • LOCATION: Name Ihres Standorts. Das Flag --location ist optional.
  • PARTITION_TYPE: Der Partitionstyp. Mögliche Werte sind DAY, HOUR, MONTH oder YEAR.
  • INTEGER: Die Ablaufzeit der Partition in Sekunden. Es gibt keinen Mindestwert. Die Ablaufzeit entspricht dem UTC-Datum der Partition plus dem ganzzahligen Wert. Das Flag time_partitioning_expiration ist optional.
  • PROJECT_ID: Ihre Projekt-ID.
  • SOURCE_DATASET: Das Dataset mit den datumsfragmentierten Tabellen.
  • SOURCE_TABLE: Das Präfix der datumsfragmentierten Tabellen.
  • DESTINATION_DATASET: Das Dataset für die neue partitionierte Tabelle.
  • DESTINATION_TABLE: Der Name der zu erstellenden Tabelle.

Der Befehl partition unterstützt die Flags --label, --expiration, --add_tags und --description nicht. Sie können der partitionierten Tabelle nach dem Erstellen Labels, eine Ablaufzeit, Tags und eine Beschreibung hinzufügen.

Wenn Sie den Befehl partition ausführen, erstellt BigQuery einen Kopierjob, der Partitionen aus den fragmentierten Tabellen generiert.

Im folgenden Beispiel wird eine nach Aufnahmezeit partitionierte Tabelle mit dem Namen mytable_partitioned aus einer Reihe von datumsfragmentierten Tabellen mit dem Präfix sourcetable_ erstellt. Die neue Tabelle wird täglich partitioniert. Die Partitionsablaufzeit beträgt dabei 259.200 Sekunden (drei Tage).

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

Wenn die datumsfragmentierten Tabellen sourcetable_20180126 und sourcetable_20180127 wären, würde dieser Befehl die folgenden Partitionen erstellen: mydataset.mytable_partitioned$20180126 und mydataset.mytable_partitioned$20180127.

Sicherheit partitionierter Tabellen

Die Zugriffssteuerung für partitionierte Tabellen entspricht der Zugriffssteuerung für Standardtabellen. Weitere Informationen finden Sie unter Einführung in die Tabellenzugriffssteuerung.

Nächste Schritte