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

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

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

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

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

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

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

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

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 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. Achten Sie darauf, dass das Schema für die Partitionierungsspalte eine Spalte DATE, TIMESTAMP oder DATETIME enthält. 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 des Typs DATE, TIMESTAMP oder DATETIME enthält.

  9. Wählen Sie den Partitionierungstyp aus, um die tägliche, stündliche, monatliche oder jährliche Partitionierung auszuwählen.

  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

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

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

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.

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
)

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

bq

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

API

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

Go

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

import (
	"context"
	"fmt"
	"time"

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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

async function 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur  Python API.

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, 'my_dataset')

table_ref = dataset_ref.table("my_partitioned_table")
schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
    bigquery.SchemaField("date", "DATE"),
]
table = bigquery.Table(table_ref, schema=schema)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="date",  # name of column to use for partitioning
    expiration_ms=7776000000,
)  # 90 days

table = client.create_table(table)

print(
    "Created table {}, partitioned on column {}".format(
        table.table_id, 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 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.

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.

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
)

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

bq

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

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 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 Anweisung CREATE TABLE 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.

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.

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

bq

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

API

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

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

async function 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 ausprobieren, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur  Python API.

from google.cloud import bigquery

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

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

schema = [
    bigquery.SchemaField("full_name", "STRING"),
    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 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.

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

SQL

Verwenden Sie die Anweisung CREATE TABLE mit der Klausel SELECT AS für die Abfrage. 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.

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

bq

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'

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=PARTION_TYPE \
  --time_partitioning_expiration INTEGER \
  PROJECT_ID:SOURCE_DATASET.SOURCE_TABLE \
  PROJECT_ID:DESTINATION_DATASET.DESTINATION_TABLE

Dabei gilt:

  • 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 oder --description nicht. Sie können der partitionierten Tabelle nach dem Erstellen Labels, eine Ablaufzeit und eine Beschreibung hinzufügen.

Wenn Sie den Befehl partition ausführen, wird in BigQuery ein Kopierjob erstellt, 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.

Mehr zur Verwendung der Play Console erfahren